tests: cleanup vcs aconfig setup - move setup to setup_package

kallithea/tests/vcs/__init__.py

@@ -1,50 +1,65 b''
 """
 Unit tests for vcs_ library.
 
 In order to run tests we need to prepare our environment first. Tests would be
 run for each engine listed at ``conf.SCM_TESTS`` - keys are aliases from
 ``vcs.backends.BACKENDS``.
 
 For each SCM we run tests for, we need some repository. We would use
 repositories location from system environment variables or test suite defaults
 - see ``conf`` module for more detail. We simply try to check if repository at
 certain location exists, if not we would try to fetch them. At ``test_vcs`` or
 ``test_common`` we run unit tests common for each repository type and for
 example specific mercurial tests are located at ``test_hg`` module.
 
 Oh, and tests are run with ``unittest.collector`` wrapped by ``collector``
 function at ``tests/__init__.py``.
 
 .. _vcs: http://bitbucket.org/marcinkuzminski/vcs
 .. _unittest: http://pypi.python.org/pypi/unittest
 
 """
+
+import os
+import shutil
+
 from kallithea.tests.base import TEST_HG_REPO, HG_REMOTE_REPO, TEST_GIT_REPO, GIT_REMOTE_REPO
 from kallithea.tests.vcs.utils import SCMFetcher
 
 from kallithea.tests.base import *
 
 
+# Base directory for the VCS tests.
+VCS_TEST_MODULE_BASE_DIR = os.path.abspath(os.path.dirname(__file__))
+
+# Path to user configuration file used during tests.
+TEST_USER_CONFIG_FILE = os.path.join(TESTS_TMP_PATH, 'aconfig')
+
+
 def setup_package():
     """
     Prepares whole package for tests which mainly means it would try to fetch
     test repositories or use already existing ones.
     """
     fetchers = {
         'hg': {
             'alias': 'hg',
             'test_repo_path': TEST_HG_REPO,
             'remote_repo': HG_REMOTE_REPO,
             'clone_cmd': 'hg clone --insecure',
         },
         'git': {
             'alias': 'git',
             'test_repo_path': TEST_GIT_REPO,
             'remote_repo': GIT_REMOTE_REPO,
             'clone_cmd': 'git clone --bare',
         },
     }
 
     for scm, fetcher_info in fetchers.items():
         fetcher = SCMFetcher(**fetcher_info)
         fetcher.setup()
+
+    # Copy the test user configuration file to location where
+    # temporary test data is stored at.
+    shutil.copy(os.path.join(VCS_TEST_MODULE_BASE_DIR, 'aconfig'), TEST_USER_CONFIG_FILE)

kallithea/tests/vcs/conf.py

@@ -1,66 +1,60 b''
 """
 Unit tests configuration module for vcs.
 """
 import os
-import shutil
 import uuid
 
 # Retrieve the necessary configuration options from the test base
 # module. Some of these configuration options are subsequently
 # consumed by the VCS test module.
 from kallithea.tests.base import (
     TESTS_TMP_PATH, SCM_TESTS,
     TEST_HG_REPO, HG_REMOTE_REPO,
     TEST_GIT_REPO, GIT_REMOTE_REPO,
 )
 
 __all__ = (
     'TEST_HG_REPO', 'TEST_GIT_REPO', 'HG_REMOTE_REPO', 'GIT_REMOTE_REPO',
     'SCM_TESTS',
 )
 
-THIS = os.path.abspath(os.path.dirname(__file__))
 
 def get_new_dir(title=None):
     """
     Calculates a path for a new, non-existant, unique sub-directory in TESTS_TMP_PATH.
 
     Resulting directory name will have format:
 
     vcs-test-[title-]hexuuid
 
     The "hexuuid" is a hexadecimal value of a randomly generated
     UUID. Title will be added if specified.
 
     Args:
         title: Custom title to include as part of the resulting sub-directory
             name. Can be useful for debugging to identify destination. Defaults
             to None.
 
     Returns:
         Path to the new directory as a string.
     """
 
     test_repo_prefix = 'vcs-test'
 
     if title:
         name = "%s-%s" % (test_repo_prefix, title)
     else:
         name = test_repo_prefix
 
     path = os.path.join(TESTS_TMP_PATH, name)
 
     # Generate new hexes until we get a unique name (just in case).
     hex_uuid = uuid.uuid4().hex
     while os.path.exists("%s-%s" % (path, hex_uuid)):
         hex_uuid = uuid.uuid4().hex
 
     return "%s-%s" % (path, hex_uuid)
 
 
-_dest = os.path.join(TESTS_TMP_PATH, 'aconfig')
-shutil.copy(os.path.join(THIS, 'aconfig'), _dest)
-TEST_USER_CONFIG_FILE = _dest
-
 # overide default configurations with kallithea ones
 from kallithea.tests.base import *

kallithea/tests/vcs/test_repository.py

@@ -1,225 +1,225 b''
 import datetime
 from kallithea.tests.vcs.base import _BackendTestMixin
 from kallithea.tests.vcs.conf import SCM_TESTS
-from kallithea.tests.vcs.conf import TEST_USER_CONFIG_FILE
+from kallithea.tests.vcs import TEST_USER_CONFIG_FILE
 from kallithea.lib.vcs.nodes import FileNode
 from kallithea.lib.vcs.utils.compat import unittest
 from kallithea.lib.vcs.exceptions import ChangesetDoesNotExistError
 
 
 class RepositoryBaseTest(_BackendTestMixin):
     recreate_repo_per_test = False
 
     @classmethod
     def _get_commits(cls):
         return super(RepositoryBaseTest, cls)._get_commits()[:1]
 
     def test_get_config_value(self):
         self.assertEqual(self.repo.get_config_value('universal', 'foo',
             TEST_USER_CONFIG_FILE), 'bar')
 
     def test_get_config_value_defaults_to_None(self):
         self.assertEqual(self.repo.get_config_value('universal', 'nonexist',
             TEST_USER_CONFIG_FILE), None)
 
     def test_get_user_name(self):
         self.assertEqual(self.repo.get_user_name(TEST_USER_CONFIG_FILE),
             'Foo Bar')
 
     def test_get_user_email(self):
         self.assertEqual(self.repo.get_user_email(TEST_USER_CONFIG_FILE),
             '[e-mail]')
 
     def test_repo_equality(self):
         self.assertTrue(self.repo == self.repo)
 
     def test_repo_equality_broken_object(self):
         import copy
         _repo = copy.copy(self.repo)
         delattr(_repo, 'path')
         self.assertTrue(self.repo != _repo)
 
     def test_repo_equality_other_object(self):
         class dummy(object):
             path = self.repo.path
         self.assertTrue(self.repo != dummy())
 
 
 class RepositoryGetDiffTest(_BackendTestMixin):
 
     @classmethod
     def _get_commits(cls):
         commits = [
             {
                 'message': 'Initial commit',
                 'author': 'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
                     FileNode('foobar', content='foobar'),
                     FileNode('foobar2', content='foobar2'),
                 ],
             },
             {
                 'message': 'Changed foobar, added foobar3',
                 'author': 'Jane Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 21),
                 'added': [
                     FileNode('foobar3', content='foobar3'),
                 ],
                 'changed': [
                     FileNode('foobar', 'FOOBAR'),
                 ],
             },
             {
                 'message': 'Removed foobar, changed foobar3',
                 'author': 'Jane Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 22),
                 'changed': [
                     FileNode('foobar3', content='FOOBAR\nFOOBAR\nFOOBAR\n'),
                 ],
                 'removed': [FileNode('foobar')],
             },
         ]
         return commits
 
     def test_raise_for_wrong(self):
         with self.assertRaises(ChangesetDoesNotExistError):
             self.repo.get_diff('a' * 40, 'b' * 40)
 
 
 class GitRepositoryGetDiffTest(RepositoryGetDiffTest, unittest.TestCase):
     backend_alias = 'git'
 
     def test_initial_commit_diff(self):
         initial_rev = self.repo.revisions[0]
         self.assertEqual(self.repo.get_diff(self.repo.EMPTY_CHANGESET, initial_rev), '''diff --git a/foobar b/foobar
 new file mode 100644
 index 0000000000000000000000000000000000000000..f6ea0495187600e7b2288c8ac19c5886383a4632
 --- /dev/null
 +++ b/foobar
 @@ -0,0 +1 @@
 +foobar
 \ No newline at end of file
 diff --git a/foobar2 b/foobar2
 new file mode 100644
 index 0000000000000000000000000000000000000000..e8c9d6b98e3dce993a464935e1a53f50b56a3783
 --- /dev/null
 +++ b/foobar2
 @@ -0,0 +1 @@
 +foobar2
 \ No newline at end of file
 ''')
 
     def test_second_changeset_diff(self):
         revs = self.repo.revisions
         self.assertEqual(self.repo.get_diff(revs[0], revs[1]), '''diff --git a/foobar b/foobar
 index f6ea0495187600e7b2288c8ac19c5886383a4632..389865bb681b358c9b102d79abd8d5f941e96551 100644
 --- a/foobar
 +++ b/foobar
 @@ -1 +1 @@
 -foobar
 \ No newline at end of file
 +FOOBAR
 \ No newline at end of file
 diff --git a/foobar3 b/foobar3
 new file mode 100644
 index 0000000000000000000000000000000000000000..c11c37d41d33fb47741cff93fa5f9d798c1535b0
 --- /dev/null
 +++ b/foobar3
 @@ -0,0 +1 @@
 +foobar3
 \ No newline at end of file
 ''')
 
     def test_third_changeset_diff(self):
         revs = self.repo.revisions
         self.assertEqual(self.repo.get_diff(revs[1], revs[2]), '''diff --git a/foobar b/foobar
 deleted file mode 100644
 index 389865bb681b358c9b102d79abd8d5f941e96551..0000000000000000000000000000000000000000
 --- a/foobar
 +++ /dev/null
 @@ -1 +0,0 @@
 -FOOBAR
 \ No newline at end of file
 diff --git a/foobar3 b/foobar3
 index c11c37d41d33fb47741cff93fa5f9d798c1535b0..f9324477362684ff692aaf5b9a81e01b9e9a671c 100644
 --- a/foobar3
 +++ b/foobar3
 @@ -1 +1,3 @@
 -foobar3
 \ No newline at end of file
 +FOOBAR
 +FOOBAR
 +FOOBAR
 ''')
 
 
 class HgRepositoryGetDiffTest(RepositoryGetDiffTest, unittest.TestCase):
     backend_alias = 'hg'
 
     def test_initial_commit_diff(self):
         initial_rev = self.repo.revisions[0]
         self.assertEqual(self.repo.get_diff(self.repo.EMPTY_CHANGESET, initial_rev), '''diff --git a/foobar b/foobar
 new file mode 100644
 --- /dev/null
 +++ b/foobar
 @@ -0,0 +1,1 @@
 +foobar
 \ No newline at end of file
 diff --git a/foobar2 b/foobar2
 new file mode 100644
 --- /dev/null
 +++ b/foobar2
 @@ -0,0 +1,1 @@
 +foobar2
 \ No newline at end of file
 ''')
 
     def test_second_changeset_diff(self):
         revs = self.repo.revisions
         self.assertEqual(self.repo.get_diff(revs[0], revs[1]), '''diff --git a/foobar b/foobar
 --- a/foobar
 +++ b/foobar
 @@ -1,1 +1,1 @@
 -foobar
 \ No newline at end of file
 +FOOBAR
 \ No newline at end of file
 diff --git a/foobar3 b/foobar3
 new file mode 100644
 --- /dev/null
 +++ b/foobar3
 @@ -0,0 +1,1 @@
 +foobar3
 \ No newline at end of file
 ''')
 
     def test_third_changeset_diff(self):
         revs = self.repo.revisions
         self.assertEqual(self.repo.get_diff(revs[1], revs[2]), '''diff --git a/foobar b/foobar
 deleted file mode 100644
 --- a/foobar
 +++ /dev/null
 @@ -1,1 +0,0 @@
 -FOOBAR
 \ No newline at end of file
 diff --git a/foobar3 b/foobar3
 --- a/foobar3
 +++ b/foobar3
 @@ -1,1 +1,3 @@
 -foobar3
 \ No newline at end of file
 +FOOBAR
 +FOOBAR
 +FOOBAR
 ''')
 
 
 # For each backend create test case class
 for alias in SCM_TESTS:
     attrs = {
         'backend_alias': alias,
     }
     cls_name = alias.capitalize() + RepositoryBaseTest.__name__
     bases = (RepositoryBaseTest, unittest.TestCase)
     globals()[cls_name] = type(cls_name, bases, attrs)