tests: fixed tests after removing hardcoded timezone in tests.

rhodecode/tests/plugin.py

@@ -1,1816 +1,1825 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import collections
 import datetime
 import hashlib
 import os
 import re
 import pprint
 import shutil
 import socket
 import subprocess32
 import time
 import uuid
+import dateutil.tz
 
 import mock
 import pyramid.testing
 import pytest
 import colander
 import requests
 
 import rhodecode
 from rhodecode.lib.utils2 import AttributeDict
 from rhodecode.model.changeset_status import ChangesetStatusModel
 from rhodecode.model.comment import CommentsModel
 from rhodecode.model.db import (
     PullRequest, Repository, RhodeCodeSetting, ChangesetStatus, RepoGroup,
     UserGroup, RepoRhodeCodeUi, RepoRhodeCodeSetting, RhodeCodeUi)
 from rhodecode.model.meta import Session
 from rhodecode.model.pull_request import PullRequestModel
 from rhodecode.model.repo import RepoModel
 from rhodecode.model.repo_group import RepoGroupModel
 from rhodecode.model.user import UserModel
 from rhodecode.model.settings import VcsSettingsModel
 from rhodecode.model.user_group import UserGroupModel
 from rhodecode.model.integration import IntegrationModel
 from rhodecode.integrations import integration_type_registry
 from rhodecode.integrations.types.base import IntegrationTypeBase
 from rhodecode.lib.utils import repo2db_mapper
 from rhodecode.lib.vcs import create_vcsserver_proxy
 from rhodecode.lib.vcs.backends import get_backend
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.tests import (
     login_user_session, get_new_dir, utils, TESTS_TMP_PATH,
     TEST_USER_ADMIN_LOGIN, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR2_LOGIN,
     TEST_USER_REGULAR_PASS)
 from rhodecode.tests.utils import CustomTestApp
 from rhodecode.tests.fixture import Fixture
 
 
 def _split_comma(value):
     return value.split(',')
 
 
 def pytest_addoption(parser):
     parser.addoption(
         '--keep-tmp-path', action='store_true',
         help="Keep the test temporary directories")
     parser.addoption(
         '--backends', action='store', type=_split_comma,
         default=['git', 'hg', 'svn'],
         help="Select which backends to test for backend specific tests.")
     parser.addoption(
         '--dbs', action='store', type=_split_comma,
         default=['sqlite'],
         help="Select which database to test for database specific tests. "
              "Possible options are sqlite,postgres,mysql")
     parser.addoption(
         '--appenlight', '--ae', action='store_true',
         help="Track statistics in appenlight.")
     parser.addoption(
         '--appenlight-api-key', '--ae-key',
         help="API key for Appenlight.")
     parser.addoption(
         '--appenlight-url', '--ae-url',
         default="https://ae.rhodecode.com",
         help="Appenlight service URL, defaults to https://ae.rhodecode.com")
     parser.addoption(
         '--sqlite-connection-string', action='store',
         default='', help="Connection string for the dbs tests with SQLite")
     parser.addoption(
         '--postgres-connection-string', action='store',
         default='', help="Connection string for the dbs tests with Postgres")
     parser.addoption(
         '--mysql-connection-string', action='store',
         default='', help="Connection string for the dbs tests with MySQL")
     parser.addoption(
         '--repeat', type=int, default=100,
         help="Number of repetitions in performance tests.")
 
 
 def pytest_configure(config):
     # Appy the kombu patch early on, needed for test discovery on Python 2.7.11
     from rhodecode.config import patches
     patches.kombu_1_5_1_python_2_7_11()
 
 
 def pytest_collection_modifyitems(session, config, items):
     # nottest marked, compare nose, used for transition from nose to pytest
     remaining = [
         i for i in items if getattr(i.obj, '__test__', True)]
     items[:] = remaining
 
 
 def pytest_generate_tests(metafunc):
     # Support test generation based on --backend parameter
     if 'backend_alias' in metafunc.fixturenames:
         backends = get_backends_from_metafunc(metafunc)
         scope = None
         if not backends:
             pytest.skip("Not enabled for any of selected backends")
         metafunc.parametrize('backend_alias', backends, scope=scope)
     elif hasattr(metafunc.function, 'backends'):
         backends = get_backends_from_metafunc(metafunc)
         if not backends:
             pytest.skip("Not enabled for any of selected backends")
 
 
 def get_backends_from_metafunc(metafunc):
     requested_backends = set(metafunc.config.getoption('--backends'))
     if hasattr(metafunc.function, 'backends'):
         # Supported backends by this test function, created from
         # pytest.mark.backends
         backends = metafunc.function.backends.args
     elif hasattr(metafunc.cls, 'backend_alias'):
         # Support class attribute "backend_alias", this is mainly
         # for legacy reasons for tests not yet using pytest.mark.backends
         backends = [metafunc.cls.backend_alias]
     else:
         backends = metafunc.config.getoption('--backends')
     return requested_backends.intersection(backends)
 
 
 @pytest.fixture(scope='session', autouse=True)
 def activate_example_rcextensions(request):
     """
     Patch in an example rcextensions module which verifies passed in kwargs.
     """
     from rhodecode.tests.other import example_rcextensions
 
     old_extensions = rhodecode.EXTENSIONS
     rhodecode.EXTENSIONS = example_rcextensions
 
     @request.addfinalizer
     def cleanup():
         rhodecode.EXTENSIONS = old_extensions
 
 
 @pytest.fixture
 def capture_rcextensions():
     """
     Returns the recorded calls to entry points in rcextensions.
     """
     calls = rhodecode.EXTENSIONS.calls
     calls.clear()
     # Note: At this moment, it is still the empty dict, but that will
     # be filled during the test run and since it is a reference this
     # is enough to make it work.
     return calls
 
 
 @pytest.fixture(scope='session')
 def http_environ_session():
     """
     Allow to use "http_environ" in session scope.
     """
     return http_environ(
         http_host_stub=http_host_stub())
 
 
 @pytest.fixture
 def http_host_stub():
     """
     Value of HTTP_HOST in the test run.
     """
     return 'test.example.com:80'
 
 
 @pytest.fixture
 def http_environ(http_host_stub):
     """
     HTTP extra environ keys.
 
     User by the test application and as well for setting up the pylons
     environment. In the case of the fixture "app" it should be possible
     to override this for a specific test case.
     """
     return {
         'SERVER_NAME': http_host_stub.split(':')[0],
         'SERVER_PORT': http_host_stub.split(':')[1],
         'HTTP_HOST': http_host_stub,
     }
 
 
 @pytest.fixture(scope='function')
 def app(request, pylonsapp, http_environ):
 
 
     app = CustomTestApp(
         pylonsapp,
         extra_environ=http_environ)
     if request.cls:
         request.cls.app = app
     return app
 
 
 @pytest.fixture(scope='session')
 def app_settings(pylonsapp, pylons_config):
     """
     Settings dictionary used to create the app.
 
     Parses the ini file and passes the result through the sanitize and apply
     defaults mechanism in `rhodecode.config.middleware`.
     """
     from paste.deploy.loadwsgi import loadcontext, APP
     from rhodecode.config.middleware import (
         sanitize_settings_and_apply_defaults)
     context = loadcontext(APP, 'config:' + pylons_config)
     settings = sanitize_settings_and_apply_defaults(context.config())
     return settings
 
 
 @pytest.fixture(scope='session')
 def db(app_settings):
     """
     Initializes the database connection.
 
     It uses the same settings which are used to create the ``pylonsapp`` or
     ``app`` fixtures.
     """
     from rhodecode.config.utils import initialize_database
     initialize_database(app_settings)
 
 
 LoginData = collections.namedtuple('LoginData', ('csrf_token', 'user'))
 
 
 def _autologin_user(app, *args):
     session = login_user_session(app, *args)
     csrf_token = rhodecode.lib.auth.get_csrf_token(session)
     return LoginData(csrf_token, session['rhodecode_user'])
 
 
 @pytest.fixture
 def autologin_user(app):
     """
     Utility fixture which makes sure that the admin user is logged in
     """
     return _autologin_user(app)
 
 
 @pytest.fixture
 def autologin_regular_user(app):
     """
     Utility fixture which makes sure that the regular user is logged in
     """
     return _autologin_user(
         app, TEST_USER_REGULAR_LOGIN, TEST_USER_REGULAR_PASS)
 
 
 @pytest.fixture(scope='function')
 def csrf_token(request, autologin_user):
     return autologin_user.csrf_token
 
 
 @pytest.fixture(scope='function')
 def xhr_header(request):
     return {'HTTP_X_REQUESTED_WITH': 'XMLHttpRequest'}
 
 
 @pytest.fixture
 def real_crypto_backend(monkeypatch):
     """
     Switch the production crypto backend on for this test.
 
     During the test run the crypto backend is replaced with a faster
     implementation based on the MD5 algorithm.
     """
     monkeypatch.setattr(rhodecode, 'is_test', False)
 
 
 @pytest.fixture(scope='class')
 def index_location(request, pylonsapp):
     index_location = pylonsapp.config['app_conf']['search.location']
     if request.cls:
         request.cls.index_location = index_location
     return index_location
 
 
 @pytest.fixture(scope='session', autouse=True)
 def tests_tmp_path(request):
     """
     Create temporary directory to be used during the test session.
     """
     if not os.path.exists(TESTS_TMP_PATH):
         os.makedirs(TESTS_TMP_PATH)
 
     if not request.config.getoption('--keep-tmp-path'):
         @request.addfinalizer
         def remove_tmp_path():
             shutil.rmtree(TESTS_TMP_PATH)
 
     return TESTS_TMP_PATH
 
 
 @pytest.fixture(scope='session', autouse=True)
 def patch_pyro_request_scope_proxy_factory(request):
     """
     Patch the pyro proxy factory to always use the same dummy request object
     when under test. This will return the same pyro proxy on every call.
     """
     dummy_request = pyramid.testing.DummyRequest()
 
     def mocked_call(self, request=None):
         return self.getProxy(request=dummy_request)
 
     patcher = mock.patch(
         'rhodecode.lib.vcs.client.RequestScopeProxyFactory.__call__',
         new=mocked_call)
     patcher.start()
 
     @request.addfinalizer
     def undo_patching():
         patcher.stop()
 
 
 @pytest.fixture
 def test_repo_group(request):
     """
     Create a temporary repository group, and destroy it after
     usage automatically
     """
     fixture = Fixture()
     repogroupid = 'test_repo_group_%s' % int(time.time())
     repo_group = fixture.create_repo_group(repogroupid)
 
     def _cleanup():
         fixture.destroy_repo_group(repogroupid)
 
     request.addfinalizer(_cleanup)
     return repo_group
 
 
 @pytest.fixture
 def test_user_group(request):
     """
     Create a temporary user group, and destroy it after
     usage automatically
     """
     fixture = Fixture()
     usergroupid = 'test_user_group_%s' % int(time.time())
     user_group = fixture.create_user_group(usergroupid)
 
     def _cleanup():
         fixture.destroy_user_group(user_group)
 
     request.addfinalizer(_cleanup)
     return user_group
 
 
 @pytest.fixture(scope='session')
 def test_repo(request):
     container = TestRepoContainer()
     request.addfinalizer(container._cleanup)
     return container
 
 
 class TestRepoContainer(object):
     """
     Container for test repositories which are used read only.
 
     Repositories will be created on demand and re-used during the lifetime
     of this object.
 
     Usage to get the svn test repository "minimal"::
 
        test_repo = TestContainer()
        repo = test_repo('minimal', 'svn')
 
     """
 
     dump_extractors = {
         'git': utils.extract_git_repo_from_dump,
         'hg': utils.extract_hg_repo_from_dump,
         'svn': utils.extract_svn_repo_from_dump,
     }
 
     def __init__(self):
         self._cleanup_repos = []
         self._fixture = Fixture()
         self._repos = {}
 
     def __call__(self, dump_name, backend_alias):
         key = (dump_name, backend_alias)
         if key not in self._repos:
             repo = self._create_repo(dump_name, backend_alias)
             self._repos[key] = repo.repo_id
         return Repository.get(self._repos[key])
 
     def _create_repo(self, dump_name, backend_alias):
         repo_name = '%s-%s' % (backend_alias, dump_name)
         backend_class = get_backend(backend_alias)
         dump_extractor = self.dump_extractors[backend_alias]
         repo_path = dump_extractor(dump_name, repo_name)
         vcs_repo = backend_class(repo_path)
         repo2db_mapper({repo_name: vcs_repo})
         repo = RepoModel().get_by_repo_name(repo_name)
         self._cleanup_repos.append(repo_name)
         return repo
 
     def _cleanup(self):
         for repo_name in reversed(self._cleanup_repos):
             self._fixture.destroy_repo(repo_name)
 
 
 @pytest.fixture
 def backend(request, backend_alias, pylonsapp, test_repo):
     """
     Parametrized fixture which represents a single backend implementation.
 
     It respects the option `--backends` to focus the test run on specific
     backend implementations.
 
     It also supports `pytest.mark.xfail_backends` to mark tests as failing
     for specific backends. This is intended as a utility for incremental
     development of a new backend implementation.
     """
     if backend_alias not in request.config.getoption('--backends'):
         pytest.skip("Backend %s not selected." % (backend_alias, ))
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
     repo_name = 'vcs_test_%s' % (backend_alias, )
     backend = Backend(
         alias=backend_alias,
         repo_name=repo_name,
         test_name=request.node.name,
         test_repo_container=test_repo)
     request.addfinalizer(backend.cleanup)
     return backend
 
 
 @pytest.fixture
 def backend_git(request, pylonsapp, test_repo):
     return backend(request, 'git', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_hg(request, pylonsapp, test_repo):
     return backend(request, 'hg', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_svn(request, pylonsapp, test_repo):
     return backend(request, 'svn', pylonsapp, test_repo)
 
 
 @pytest.fixture
 def backend_random(backend_git):
     """
     Use this to express that your tests need "a backend.
 
     A few of our tests need a backend, so that we can run the code. This
     fixture is intended to be used for such cases. It will pick one of the
     backends and run the tests.
 
     The fixture `backend` would run the test multiple times for each
     available backend which is a pure waste of time if the test is
     independent of the backend type.
     """
     # TODO: johbo: Change this to pick a random backend
     return backend_git
 
 
 @pytest.fixture
 def backend_stub(backend_git):
     """
     Use this to express that your tests need a backend stub
 
     TODO: mikhail: Implement a real stub logic instead of returning
     a git backend
     """
     return backend_git
 
 
 @pytest.fixture
 def repo_stub(backend_stub):
     """
     Use this to express that your tests need a repository stub
     """
     return backend_stub.create_repo()
 
 
 class Backend(object):
     """
     Represents the test configuration for one supported backend
 
     Provides easy access to different test repositories based on
     `__getitem__`. Such repositories will only be created once per test
     session.
     """
 
     invalid_repo_name = re.compile(r'[^0-9a-zA-Z]+')
     _master_repo = None
     _commit_ids = {}
 
     def __init__(self, alias, repo_name, test_name, test_repo_container):
         self.alias = alias
         self.repo_name = repo_name
         self._cleanup_repos = []
         self._test_name = test_name
         self._test_repo_container = test_repo_container
         # TODO: johbo: Used as a delegate interim. Not yet sure if Backend or
         # Fixture will survive in the end.
         self._fixture = Fixture()
 
     def __getitem__(self, key):
         return self._test_repo_container(key, self.alias)
 
     @property
     def repo(self):
         """
         Returns the "current" repository. This is the vcs_test repo or the
         last repo which has been created with `create_repo`.
         """
         from rhodecode.model.db import Repository
         return Repository.get_by_repo_name(self.repo_name)
 
     @property
     def default_branch_name(self):
         VcsRepository = get_backend(self.alias)
         return VcsRepository.DEFAULT_BRANCH_NAME
 
     @property
     def default_head_id(self):
         """
         Returns the default head id of the underlying backend.
 
         This will be the default branch name in case the backend does have a
         default branch. In the other cases it will point to a valid head
         which can serve as the base to create a new commit on top of it.
         """
         vcsrepo = self.repo.scm_instance()
         head_id = (
             vcsrepo.DEFAULT_BRANCH_NAME or
             vcsrepo.commit_ids[-1])
         return head_id
 
     @property
     def commit_ids(self):
         """
         Returns the list of commits for the last created repository
         """
         return self._commit_ids
 
     def create_master_repo(self, commits):
         """
         Create a repository and remember it as a template.
 
         This allows to easily create derived repositories to construct
         more complex scenarios for diff, compare and pull requests.
 
         Returns a commit map which maps from commit message to raw_id.
         """
         self._master_repo = self.create_repo(commits=commits)
         return self._commit_ids
 
     def create_repo(
             self, commits=None, number_of_commits=0, heads=None,
             name_suffix=u'', **kwargs):
         """
         Create a repository and record it for later cleanup.
 
         :param commits: Optional. A sequence of dict instances.
            Will add a commit per entry to the new repository.
         :param number_of_commits: Optional. If set to a number, this number of
            commits will be added to the new repository.
         :param heads: Optional. Can be set to a sequence of of commit
            names which shall be pulled in from the master repository.
 
         """
         self.repo_name = self._next_repo_name() + name_suffix
         repo = self._fixture.create_repo(
             self.repo_name, repo_type=self.alias, **kwargs)
         self._cleanup_repos.append(repo.repo_name)
 
         commits = commits or [
             {'message': 'Commit %s of %s' % (x, self.repo_name)}
             for x in xrange(number_of_commits)]
         self._add_commits_to_repo(repo.scm_instance(), commits)
         if heads:
             self.pull_heads(repo, heads)
 
         return repo
 
     def pull_heads(self, repo, heads):
         """
         Make sure that repo contains all commits mentioned in `heads`
         """
         vcsmaster = self._master_repo.scm_instance()
         vcsrepo = repo.scm_instance()
         vcsrepo.config.clear_section('hooks')
         commit_ids = [self._commit_ids[h] for h in heads]
         vcsrepo.pull(vcsmaster.path, commit_ids=commit_ids)
 
     def create_fork(self):
         repo_to_fork = self.repo_name
         self.repo_name = self._next_repo_name()
         repo = self._fixture.create_fork(repo_to_fork, self.repo_name)
         self._cleanup_repos.append(self.repo_name)
         return repo
 
     def new_repo_name(self, suffix=u''):
         self.repo_name = self._next_repo_name() + suffix
         self._cleanup_repos.append(self.repo_name)
         return self.repo_name
 
     def _next_repo_name(self):
         return u"%s_%s" % (
             self.invalid_repo_name.sub(u'_', self._test_name),
             len(self._cleanup_repos))
 
     def ensure_file(self, filename, content='Test content\n'):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         commits = [
             {'added': [
                 FileNode(filename, content=content),
             ]},
         ]
         self._add_commits_to_repo(self.repo.scm_instance(), commits)
 
     def enable_downloads(self):
         repo = self.repo
         repo.enable_downloads = True
         Session().add(repo)
         Session().commit()
 
     def cleanup(self):
         for repo_name in reversed(self._cleanup_repos):
             self._fixture.destroy_repo(repo_name)
 
     def _add_commits_to_repo(self, repo, commits):
         commit_ids = _add_commits_to_repo(repo, commits)
         if not commit_ids:
             return
         self._commit_ids = commit_ids
 
         # Creating refs for Git to allow fetching them from remote repository
         if self.alias == 'git':
             refs = {}
             for message in self._commit_ids:
                 # TODO: mikhail: do more special chars replacements
                 ref_name = 'refs/test-refs/{}'.format(
                     message.replace(' ', ''))
                 refs[ref_name] = self._commit_ids[message]
             self._create_refs(repo, refs)
 
     def _create_refs(self, repo, refs):
         for ref_name in refs:
             repo.set_refs(ref_name, refs[ref_name])
 
 
 @pytest.fixture
 def vcsbackend(request, backend_alias, tests_tmp_path, pylonsapp, test_repo):
     """
     Parametrized fixture which represents a single vcs backend implementation.
 
     See the fixture `backend` for more details. This one implements the same
     concept, but on vcs level. So it does not provide model instances etc.
 
     Parameters are generated dynamically, see :func:`pytest_generate_tests`
     for how this works.
     """
     if backend_alias not in request.config.getoption('--backends'):
         pytest.skip("Backend %s not selected." % (backend_alias, ))
 
     utils.check_xfail_backends(request.node, backend_alias)
     utils.check_skip_backends(request.node, backend_alias)
 
     repo_name = 'vcs_test_%s' % (backend_alias, )
     repo_path = os.path.join(tests_tmp_path, repo_name)
     backend = VcsBackend(
         alias=backend_alias,
         repo_path=repo_path,
         test_name=request.node.name,
         test_repo_container=test_repo)
     request.addfinalizer(backend.cleanup)
     return backend
 
 
 @pytest.fixture
 def vcsbackend_git(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'git', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_hg(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'hg', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_svn(request, tests_tmp_path, pylonsapp, test_repo):
     return vcsbackend(request, 'svn', tests_tmp_path, pylonsapp, test_repo)
 
 
 @pytest.fixture
 def vcsbackend_random(vcsbackend_git):
     """
     Use this to express that your tests need "a vcsbackend".
 
     The fixture `vcsbackend` would run the test multiple times for each
     available vcs backend which is a pure waste of time if the test is
     independent of the vcs backend type.
     """
     # TODO: johbo: Change this to pick a random backend
     return vcsbackend_git
 
 
 @pytest.fixture
 def vcsbackend_stub(vcsbackend_git):
     """
     Use this to express that your test just needs a stub of a vcsbackend.
 
     Plan is to eventually implement an in-memory stub to speed tests up.
     """
     return vcsbackend_git
 
 
 class VcsBackend(object):
     """
     Represents the test configuration for one supported vcs backend.
     """
 
     invalid_repo_name = re.compile(r'[^0-9a-zA-Z]+')
 
     def __init__(self, alias, repo_path, test_name, test_repo_container):
         self.alias = alias
         self._repo_path = repo_path
         self._cleanup_repos = []
         self._test_name = test_name
         self._test_repo_container = test_repo_container
 
     def __getitem__(self, key):
         return self._test_repo_container(key, self.alias).scm_instance()
 
     @property
     def repo(self):
         """
         Returns the "current" repository. This is the vcs_test repo of the last
         repo which has been created.
         """
         Repository = get_backend(self.alias)
         return Repository(self._repo_path)
 
     @property
     def backend(self):
         """
         Returns the backend implementation class.
         """
         return get_backend(self.alias)
 
     def create_repo(self, commits=None, number_of_commits=0, _clone_repo=None):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         repo_class = get_backend(self.alias)
         src_url = None
         if _clone_repo:
             src_url = _clone_repo.path
         repo = repo_class(self._repo_path, create=True, src_url=src_url)
         self._cleanup_repos.append(repo)
 
         commits = commits or [
             {'message': 'Commit %s of %s' % (x, repo_name)}
             for x in xrange(number_of_commits)]
         _add_commits_to_repo(repo, commits)
         return repo
 
     def clone_repo(self, repo):
         return self.create_repo(_clone_repo=repo)
 
     def cleanup(self):
         for repo in self._cleanup_repos:
             shutil.rmtree(repo.path)
 
     def new_repo_path(self):
         repo_name = self._next_repo_name()
         self._repo_path = get_new_dir(repo_name)
         return self._repo_path
 
     def _next_repo_name(self):
         return "%s_%s" % (
             self.invalid_repo_name.sub('_', self._test_name),
             len(self._cleanup_repos))
 
     def add_file(self, repo, filename, content='Test content\n'):
         imc = repo.in_memory_commit
         imc.add(FileNode(filename, content=content))
         imc.commit(
             message=u'Automatic commit from vcsbackend fixture',
             author=u'Automatic')
 
     def ensure_file(self, filename, content='Test content\n'):
         assert self._cleanup_repos, "Avoid writing into vcs_test repos"
         self.add_file(self.repo, filename, content)
 
 
 def _add_commits_to_repo(vcs_repo, commits):
     commit_ids = {}
     if not commits:
         return commit_ids
 
     imc = vcs_repo.in_memory_commit
     commit = None
 
     for idx, commit in enumerate(commits):
         message = unicode(commit.get('message', 'Commit %s' % idx))
 
         for node in commit.get('added', []):
             imc.add(FileNode(node.path, content=node.content))
         for node in commit.get('changed', []):
             imc.change(FileNode(node.path, content=node.content))
         for node in commit.get('removed', []):
             imc.remove(FileNode(node.path))
 
         parents = [
             vcs_repo.get_commit(commit_id=commit_ids[p])
             for p in commit.get('parents', [])]
 
         operations = ('added', 'changed', 'removed')
         if not any((commit.get(o) for o in operations)):
             imc.add(FileNode('file_%s' % idx, content=message))
 
         commit = imc.commit(
             message=message,
             author=unicode(commit.get('author', 'Automatic')),
             date=commit.get('date'),
             branch=commit.get('branch'),
             parents=parents)
 
         commit_ids[commit.message] = commit.raw_id
 
     return commit_ids
 
 
 @pytest.fixture
 def reposerver(request):
     """
     Allows to serve a backend repository
     """
 
     repo_server = RepoServer()
     request.addfinalizer(repo_server.cleanup)
     return repo_server
 
 
 class RepoServer(object):
     """
     Utility to serve a local repository for the duration of a test case.
 
     Supports only Subversion so far.
     """
 
     url = None
 
     def __init__(self):
         self._cleanup_servers = []
 
     def serve(self, vcsrepo):
         if vcsrepo.alias != 'svn':
             raise TypeError("Backend %s not supported" % vcsrepo.alias)
 
         proc = subprocess32.Popen(
             ['svnserve', '-d', '--foreground', '--listen-host', 'localhost',
              '--root', vcsrepo.path])
         self._cleanup_servers.append(proc)
         self.url = 'svn://localhost'
 
     def cleanup(self):
         for proc in self._cleanup_servers:
             proc.terminate()
 
 
 @pytest.fixture
 def pr_util(backend, request):
     """
     Utility for tests of models and for functional tests around pull requests.
 
     It gives an instance of :class:`PRTestUtility` which provides various
     utility methods around one pull request.
 
     This fixture uses `backend` and inherits its parameterization.
     """
 
     util = PRTestUtility(backend)
 
     @request.addfinalizer
     def cleanup():
         util.cleanup()
 
     return util
 
 
 class PRTestUtility(object):
 
     pull_request = None
     pull_request_id = None
     mergeable_patcher = None
     mergeable_mock = None
     notification_patcher = None
 
     def __init__(self, backend):
         self.backend = backend
 
     def create_pull_request(
             self, commits=None, target_head=None, source_head=None,
             revisions=None, approved=False, author=None, mergeable=False,
             enable_notifications=True, name_suffix=u'', reviewers=None,
             title=u"Test", description=u"Description"):
         self.set_mergeable(mergeable)
         if not enable_notifications:
             # mock notification side effect
             self.notification_patcher = mock.patch(
                 'rhodecode.model.notification.NotificationModel.create')
             self.notification_patcher.start()
 
         if not self.pull_request:
             if not commits:
                 commits = [
                     {'message': 'c1'},
                     {'message': 'c2'},
                     {'message': 'c3'},
                 ]
                 target_head = 'c1'
                 source_head = 'c2'
                 revisions = ['c2']
 
             self.commit_ids = self.backend.create_master_repo(commits)
             self.target_repository = self.backend.create_repo(
                 heads=[target_head], name_suffix=name_suffix)
             self.source_repository = self.backend.create_repo(
                 heads=[source_head], name_suffix=name_suffix)
             self.author = author or UserModel().get_by_username(
                 TEST_USER_ADMIN_LOGIN)
 
             model = PullRequestModel()
             self.create_parameters = {
                 'created_by': self.author,
                 'source_repo': self.source_repository.repo_name,
                 'source_ref': self._default_branch_reference(source_head),
                 'target_repo': self.target_repository.repo_name,
                 'target_ref': self._default_branch_reference(target_head),
                 'revisions': [self.commit_ids[r] for r in revisions],
                 'reviewers': reviewers or self._get_reviewers(),
                 'title': title,
                 'description': description,
             }
             self.pull_request = model.create(**self.create_parameters)
             assert model.get_versions(self.pull_request) == []
 
             self.pull_request_id = self.pull_request.pull_request_id
 
             if approved:
                 self.approve()
 
             Session().add(self.pull_request)
             Session().commit()
 
         return self.pull_request
 
     def approve(self):
         self.create_status_votes(
             ChangesetStatus.STATUS_APPROVED,
             *self.pull_request.reviewers)
 
     def close(self):
         PullRequestModel().close_pull_request(self.pull_request, self.author)
 
     def _default_branch_reference(self, commit_message):
         reference = '%s:%s:%s' % (
             'branch',
             self.backend.default_branch_name,
             self.commit_ids[commit_message])
         return reference
 
     def _get_reviewers(self):
         model = UserModel()
         return [
             model.get_by_username(TEST_USER_REGULAR_LOGIN),
             model.get_by_username(TEST_USER_REGULAR2_LOGIN),
         ]
 
     def update_source_repository(self, head=None):
         heads = [head or 'c3']
         self.backend.pull_heads(self.source_repository, heads=heads)
 
     def add_one_commit(self, head=None):
         self.update_source_repository(head=head)
         old_commit_ids = set(self.pull_request.revisions)
         PullRequestModel().update_commits(self.pull_request)
         commit_ids = set(self.pull_request.revisions)
         new_commit_ids = commit_ids - old_commit_ids
         assert len(new_commit_ids) == 1
         return new_commit_ids.pop()
 
     def remove_one_commit(self):
         assert len(self.pull_request.revisions) == 2
         source_vcs = self.source_repository.scm_instance()
         removed_commit_id = source_vcs.commit_ids[-1]
 
         # TODO: johbo: Git and Mercurial have an inconsistent vcs api here,
         # remove the if once that's sorted out.
         if self.backend.alias == "git":
             kwargs = {'branch_name': self.backend.default_branch_name}
         else:
             kwargs = {}
         source_vcs.strip(removed_commit_id, **kwargs)
 
         PullRequestModel().update_commits(self.pull_request)
         assert len(self.pull_request.revisions) == 1
         return removed_commit_id
 
     def create_comment(self, linked_to=None):
         comment = CommentsModel().create(
             text=u"Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             pull_request=self.pull_request)
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_inline_comment(
             self, linked_to=None, line_no=u'n1', file_path='file_1'):
         comment = CommentsModel().create(
             text=u"Test comment",
             repo=self.target_repository.repo_name,
             user=self.author,
             line_no=line_no,
             f_path=file_path,
             pull_request=self.pull_request)
         assert comment.pull_request_version_id is None
 
         if linked_to:
             PullRequestModel()._link_comments_to_version(linked_to)
 
         return comment
 
     def create_version_of_pull_request(self):
         pull_request = self.create_pull_request()
         version = PullRequestModel()._create_version_from_snapshot(
             pull_request)
         return version
 
     def create_status_votes(self, status, *reviewers):
         for reviewer in reviewers:
             ChangesetStatusModel().set_status(
                 repo=self.pull_request.target_repo,
                 status=status,
                 user=reviewer.user_id,
                 pull_request=self.pull_request)
 
     def set_mergeable(self, value):
         if not self.mergeable_patcher:
             self.mergeable_patcher = mock.patch.object(
                 VcsSettingsModel, 'get_general_settings')
             self.mergeable_mock = self.mergeable_patcher.start()
         self.mergeable_mock.return_value = {
             'rhodecode_pr_merge_enabled': value}
 
     def cleanup(self):
         # In case the source repository is already cleaned up, the pull
         # request will already be deleted.
         pull_request = PullRequest().get(self.pull_request_id)
         if pull_request:
             PullRequestModel().delete(pull_request)
             Session().commit()
 
         if self.notification_patcher:
             self.notification_patcher.stop()
 
         if self.mergeable_patcher:
             self.mergeable_patcher.stop()
 
 
 @pytest.fixture
 def user_admin(pylonsapp):
     """
     Provides the default admin test user as an instance of `db.User`.
     """
     user = UserModel().get_by_username(TEST_USER_ADMIN_LOGIN)
     return user
 
 
 @pytest.fixture
 def user_regular(pylonsapp):
     """
     Provides the default regular test user as an instance of `db.User`.
     """
     user = UserModel().get_by_username(TEST_USER_REGULAR_LOGIN)
     return user
 
 
 @pytest.fixture
 def user_util(request, pylonsapp):
     """
     Provides a wired instance of `UserUtility` with integrated cleanup.
     """
     utility = UserUtility(test_name=request.node.name)
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 # TODO: johbo: Split this up into utilities per domain or something similar
 class UserUtility(object):
 
     def __init__(self, test_name="test"):
         self._test_name = self._sanitize_name(test_name)
         self.fixture = Fixture()
         self.repo_group_ids = []
         self.repos_ids = []
         self.user_ids = []
         self.user_group_ids = []
         self.user_repo_permission_ids = []
         self.user_group_repo_permission_ids = []
         self.user_repo_group_permission_ids = []
         self.user_group_repo_group_permission_ids = []
         self.user_user_group_permission_ids = []
         self.user_group_user_group_permission_ids = []
         self.user_permissions = []
 
     def _sanitize_name(self, name):
         for char in ['[', ']']:
             name = name.replace(char, '_')
         return name
 
     def create_repo_group(
             self, owner=TEST_USER_ADMIN_LOGIN, auto_cleanup=True):
         group_name = "{prefix}_repogroup_{count}".format(
             prefix=self._test_name,
             count=len(self.repo_group_ids))
         repo_group = self.fixture.create_repo_group(
             group_name, cur_user=owner)
         if auto_cleanup:
             self.repo_group_ids.append(repo_group.group_id)
         return repo_group
 
     def create_repo(self, owner=TEST_USER_ADMIN_LOGIN, parent=None, auto_cleanup=True):
         repo_name = "{prefix}_repository_{count}".format(
             prefix=self._test_name,
             count=len(self.repos_ids))
 
         repository = self.fixture.create_repo(
             repo_name, cur_user=owner, repo_group=parent)
         if auto_cleanup:
             self.repos_ids.append(repository.repo_id)
         return repository
 
     def create_user(self, auto_cleanup=True, **kwargs):
         user_name = "{prefix}_user_{count}".format(
             prefix=self._test_name,
             count=len(self.user_ids))
         user = self.fixture.create_user(user_name, **kwargs)
         if auto_cleanup:
             self.user_ids.append(user.user_id)
         return user
 
     def create_user_with_group(self):
         user = self.create_user()
         user_group = self.create_user_group(members=[user])
         return user, user_group
 
     def create_user_group(self, members=None, auto_cleanup=True, **kwargs):
         group_name = "{prefix}_usergroup_{count}".format(
             prefix=self._test_name,
             count=len(self.user_group_ids))
         user_group = self.fixture.create_user_group(group_name, **kwargs)
         if auto_cleanup:
             self.user_group_ids.append(user_group.users_group_id)
         if members:
             for user in members:
                 UserGroupModel().add_user_to_group(user_group, user)
         return user_group
 
     def grant_user_permission(self, user_name, permission_name):
         self._inherit_default_user_permissions(user_name, False)
         self.user_permissions.append((user_name, permission_name))
 
     def grant_user_permission_to_repo_group(
             self, repo_group, user, permission_name):
         permission = RepoGroupModel().grant_user_permission(
             repo_group, user, permission_name)
         self.user_repo_group_permission_ids.append(
             (repo_group.group_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_repo_group(
             self, repo_group, user_group, permission_name):
         permission = RepoGroupModel().grant_user_group_permission(
             repo_group, user_group, permission_name)
         self.user_group_repo_group_permission_ids.append(
             (repo_group.group_id, user_group.users_group_id))
         return permission
 
     def grant_user_permission_to_repo(
             self, repo, user, permission_name):
         permission = RepoModel().grant_user_permission(
             repo, user, permission_name)
         self.user_repo_permission_ids.append(
             (repo.repo_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_repo(
             self, repo, user_group, permission_name):
         permission = RepoModel().grant_user_group_permission(
             repo, user_group, permission_name)
         self.user_group_repo_permission_ids.append(
             (repo.repo_id, user_group.users_group_id))
         return permission
 
     def grant_user_permission_to_user_group(
             self, target_user_group, user, permission_name):
         permission = UserGroupModel().grant_user_permission(
             target_user_group, user, permission_name)
         self.user_user_group_permission_ids.append(
             (target_user_group.users_group_id, user.user_id))
         return permission
 
     def grant_user_group_permission_to_user_group(
             self, target_user_group, user_group, permission_name):
         permission = UserGroupModel().grant_user_group_permission(
             target_user_group, user_group, permission_name)
         self.user_group_user_group_permission_ids.append(
             (target_user_group.users_group_id, user_group.users_group_id))
         return permission
 
     def revoke_user_permission(self, user_name, permission_name):
         self._inherit_default_user_permissions(user_name, True)
         UserModel().revoke_perm(user_name, permission_name)
 
     def _inherit_default_user_permissions(self, user_name, value):
         user = UserModel().get_by_username(user_name)
         user.inherit_default_permissions = value
         Session().add(user)
         Session().commit()
 
     def cleanup(self):
         self._cleanup_permissions()
         self._cleanup_repos()
         self._cleanup_repo_groups()
         self._cleanup_user_groups()
         self._cleanup_users()
 
     def _cleanup_permissions(self):
         if self.user_permissions:
             for user_name, permission_name in self.user_permissions:
                 self.revoke_user_permission(user_name, permission_name)
 
         for permission in self.user_repo_permission_ids:
             RepoModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_repo_permission_ids:
             RepoModel().revoke_user_group_permission(*permission)
 
         for permission in self.user_repo_group_permission_ids:
             RepoGroupModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_repo_group_permission_ids:
             RepoGroupModel().revoke_user_group_permission(*permission)
 
         for permission in self.user_user_group_permission_ids:
             UserGroupModel().revoke_user_permission(*permission)
 
         for permission in self.user_group_user_group_permission_ids:
             UserGroupModel().revoke_user_group_permission(*permission)
 
     def _cleanup_repo_groups(self):
         def _repo_group_compare(first_group_id, second_group_id):
             """
             Gives higher priority to the groups with the most complex paths
             """
             first_group = RepoGroup.get(first_group_id)
             second_group = RepoGroup.get(second_group_id)
             first_group_parts = (
                 len(first_group.group_name.split('/')) if first_group else 0)
             second_group_parts = (
                 len(second_group.group_name.split('/')) if second_group else 0)
             return cmp(second_group_parts, first_group_parts)
 
         sorted_repo_group_ids = sorted(
             self.repo_group_ids, cmp=_repo_group_compare)
         for repo_group_id in sorted_repo_group_ids:
             self.fixture.destroy_repo_group(repo_group_id)
 
     def _cleanup_repos(self):
         sorted_repos_ids = sorted(self.repos_ids)
         for repo_id in sorted_repos_ids:
             self.fixture.destroy_repo(repo_id)
 
     def _cleanup_user_groups(self):
         def _user_group_compare(first_group_id, second_group_id):
             """
             Gives higher priority to the groups with the most complex paths
             """
             first_group = UserGroup.get(first_group_id)
             second_group = UserGroup.get(second_group_id)
             first_group_parts = (
                 len(first_group.users_group_name.split('/'))
                 if first_group else 0)
             second_group_parts = (
                 len(second_group.users_group_name.split('/'))
                 if second_group else 0)
             return cmp(second_group_parts, first_group_parts)
 
         sorted_user_group_ids = sorted(
             self.user_group_ids, cmp=_user_group_compare)
         for user_group_id in sorted_user_group_ids:
             self.fixture.destroy_user_group(user_group_id)
 
     def _cleanup_users(self):
         for user_id in self.user_ids:
             self.fixture.destroy_user(user_id)
 
 
 # TODO: Think about moving this into a pytest-pyro package and make it a
 # pytest plugin
 @pytest.hookimpl(tryfirst=True, hookwrapper=True)
 def pytest_runtest_makereport(item, call):
     """
     Adding the remote traceback if the exception has this information.
 
     Pyro4 attaches this information as the attribute `_vcs_server_traceback`
     to the exception instance.
     """
     outcome = yield
     report = outcome.get_result()
     if call.excinfo:
         _add_vcsserver_remote_traceback(report, call.excinfo.value)
 
 
 def _add_vcsserver_remote_traceback(report, exc):
     vcsserver_traceback = getattr(exc, '_vcs_server_traceback', None)
 
     if vcsserver_traceback:
         section = 'VCSServer remote traceback ' + report.when
         report.sections.append((section, vcsserver_traceback))
 
 
 @pytest.fixture(scope='session')
 def testrun():
     return {
         'uuid': uuid.uuid4(),
         'start': datetime.datetime.utcnow().isoformat(),
         'timestamp': int(time.time()),
     }
 
 
 @pytest.fixture(autouse=True)
 def collect_appenlight_stats(request, testrun):
     """
     This fixture reports memory consumtion of single tests.
 
     It gathers data based on `psutil` and sends them to Appenlight. The option
     ``--ae`` has te be used to enable this fixture and the API key for your
     application has to be provided in ``--ae-key``.
     """
     try:
         # cygwin cannot have yet psutil support.
         import psutil
     except ImportError:
         return
 
     if not request.config.getoption('--appenlight'):
         return
     else:
         # Only request the pylonsapp fixture if appenlight tracking is
         # enabled. This will speed up a test run of unit tests by 2 to 3
         # seconds if appenlight is not enabled.
         pylonsapp = request.getfuncargvalue("pylonsapp")
     url = '{}/api/logs'.format(request.config.getoption('--appenlight-url'))
     client = AppenlightClient(
         url=url,
         api_key=request.config.getoption('--appenlight-api-key'),
         namespace=request.node.nodeid,
         request=str(testrun['uuid']),
         testrun=testrun)
 
     client.collect({
         'message': "Starting",
     })
 
     server_and_port = pylonsapp.config['vcs.server']
     server = create_vcsserver_proxy(server_and_port)
     with server:
         vcs_pid = server.get_pid()
         server.run_gc()
     vcs_process = psutil.Process(vcs_pid)
     mem = vcs_process.memory_info()
     client.tag_before('vcsserver.rss', mem.rss)
     client.tag_before('vcsserver.vms', mem.vms)
 
     test_process = psutil.Process()
     mem = test_process.memory_info()
     client.tag_before('test.rss', mem.rss)
     client.tag_before('test.vms', mem.vms)
 
     client.tag_before('time', time.time())
 
     @request.addfinalizer
     def send_stats():
         client.tag_after('time', time.time())
         with server:
             gc_stats = server.run_gc()
         for tag, value in gc_stats.items():
             client.tag_after(tag, value)
         mem = vcs_process.memory_info()
         client.tag_after('vcsserver.rss', mem.rss)
         client.tag_after('vcsserver.vms', mem.vms)
 
         mem = test_process.memory_info()
         client.tag_after('test.rss', mem.rss)
         client.tag_after('test.vms', mem.vms)
 
         client.collect({
             'message': "Finished",
         })
         client.send_stats()
 
     return client
 
 
 class AppenlightClient():
 
     url_template = '{url}?protocol_version=0.5'
 
     def __init__(
             self, url, api_key, add_server=True, add_timestamp=True,
             namespace=None, request=None, testrun=None):
         self.url = self.url_template.format(url=url)
         self.api_key = api_key
         self.add_server = add_server
         self.add_timestamp = add_timestamp
         self.namespace = namespace
         self.request = request
         self.server = socket.getfqdn(socket.gethostname())
         self.tags_before = {}
         self.tags_after = {}
         self.stats = []
         self.testrun = testrun or {}
 
     def tag_before(self, tag, value):
         self.tags_before[tag] = value
 
     def tag_after(self, tag, value):
         self.tags_after[tag] = value
 
     def collect(self, data):
         if self.add_server:
             data.setdefault('server', self.server)
         if self.add_timestamp:
             data.setdefault('date', datetime.datetime.utcnow().isoformat())
         if self.namespace:
             data.setdefault('namespace', self.namespace)
         if self.request:
             data.setdefault('request', self.request)
         self.stats.append(data)
 
     def send_stats(self):
         tags = [
             ('testrun', self.request),
             ('testrun.start', self.testrun['start']),
             ('testrun.timestamp', self.testrun['timestamp']),
             ('test', self.namespace),
         ]
         for key, value in self.tags_before.items():
             tags.append((key + '.before', value))
             try:
                 delta = self.tags_after[key] - value
                 tags.append((key + '.delta', delta))
             except Exception:
                 pass
         for key, value in self.tags_after.items():
             tags.append((key + '.after', value))
         self.collect({
             'message': "Collected tags",
             'tags': tags,
         })
 
         response = requests.post(
             self.url,
             headers={
                 'X-appenlight-api-key': self.api_key},
             json=self.stats,
         )
 
         if not response.status_code == 200:
             pprint.pprint(self.stats)
             print response.headers
             print response.text
             raise Exception('Sending to appenlight failed')
 
 
 @pytest.fixture
 def gist_util(request, pylonsapp):
     """
     Provides a wired instance of `GistUtility` with integrated cleanup.
     """
     utility = GistUtility()
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 class GistUtility(object):
     def __init__(self):
         self.fixture = Fixture()
         self.gist_ids = []
 
     def create_gist(self, **kwargs):
         gist = self.fixture.create_gist(**kwargs)
         self.gist_ids.append(gist.gist_id)
         return gist
 
     def cleanup(self):
         for id_ in self.gist_ids:
             self.fixture.destroy_gists(str(id_))
 
 
 @pytest.fixture
 def enabled_backends(request):
     backends = request.config.option.backends
     return backends[:]
 
 
 @pytest.fixture
 def settings_util(request):
     """
     Provides a wired instance of `SettingsUtility` with integrated cleanup.
     """
     utility = SettingsUtility()
     request.addfinalizer(utility.cleanup)
     return utility
 
 
 class SettingsUtility(object):
     def __init__(self):
         self.rhodecode_ui_ids = []
         self.rhodecode_setting_ids = []
         self.repo_rhodecode_ui_ids = []
         self.repo_rhodecode_setting_ids = []
 
     def create_repo_rhodecode_ui(
             self, repo, section, value, key=None, active=True, cleanup=True):
         key = key or hashlib.sha1(
             '{}{}{}'.format(section, value, repo.repo_id)).hexdigest()
 
         setting = RepoRhodeCodeUi()
         setting.repository_id = repo.repo_id
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_rhodecode_ui(
             self, section, value, key=None, active=True, cleanup=True):
         key = key or hashlib.sha1('{}{}'.format(section, value)).hexdigest()
 
         setting = RhodeCodeUi()
         setting.ui_section = section
         setting.ui_value = value
         setting.ui_key = key
         setting.ui_active = active
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_ui_ids.append(setting.ui_id)
         return setting
 
     def create_repo_rhodecode_setting(
             self, repo, name, value, type_, cleanup=True):
         setting = RepoRhodeCodeSetting(
             repo.repo_id, key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.repo_rhodecode_setting_ids.append(setting.app_settings_id)
         return setting
 
     def create_rhodecode_setting(self, name, value, type_, cleanup=True):
         setting = RhodeCodeSetting(key=name, val=value, type=type_)
         Session().add(setting)
         Session().commit()
 
         if cleanup:
             self.rhodecode_setting_ids.append(setting.app_settings_id)
 
         return setting
 
     def cleanup(self):
         for id_ in self.rhodecode_ui_ids:
             setting = RhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.rhodecode_setting_ids:
             setting = RhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_ui_ids:
             setting = RepoRhodeCodeUi.get(id_)
             Session().delete(setting)
 
         for id_ in self.repo_rhodecode_setting_ids:
             setting = RepoRhodeCodeSetting.get(id_)
             Session().delete(setting)
 
         Session().commit()
 
 
 @pytest.fixture
 def no_notifications(request):
     notification_patcher = mock.patch(
         'rhodecode.model.notification.NotificationModel.create')
     notification_patcher.start()
     request.addfinalizer(notification_patcher.stop)
 
 
 @pytest.fixture
 def silence_action_logger(request):
     notification_patcher = mock.patch(
         'rhodecode.lib.utils.action_logger')
     notification_patcher.start()
     request.addfinalizer(notification_patcher.stop)
 
 
 @pytest.fixture(scope='session')
 def repeat(request):
     """
     The number of repetitions is based on this fixture.
 
     Slower calls may divide it by 10 or 100. It is chosen in a way so that the
     tests are not too slow in our default test suite.
     """
     return request.config.getoption('--repeat')
 
 
 @pytest.fixture
 def rhodecode_fixtures():
     return Fixture()
 
 
 @pytest.fixture
 def request_stub():
     """
     Stub request object.
     """
     request = pyramid.testing.DummyRequest()
     request.scheme = 'https'
     return request
 
 
 @pytest.fixture
 def config_stub(request, request_stub):
     """
     Set up pyramid.testing and return the Configurator.
     """
     config = pyramid.testing.setUp(request=request_stub)
 
     @request.addfinalizer
     def cleanup():
         pyramid.testing.tearDown()
 
     return config
 
 
 @pytest.fixture
 def StubIntegrationType():
     class _StubIntegrationType(IntegrationTypeBase):
         """ Test integration type class """
 
         key = 'test'
         display_name = 'Test integration type'
         description = 'A test integration type for testing'
         icon = 'test_icon_html_image'
 
         def __init__(self, settings):
             super(_StubIntegrationType, self).__init__(settings)
             self.sent_events = [] # for testing
 
         def send_event(self, event):
             self.sent_events.append(event)
 
         def settings_schema(self):
             class SettingsSchema(colander.Schema):
                 test_string_field = colander.SchemaNode(
                     colander.String(),
                     missing=colander.required,
                     title='test string field',
                 )
                 test_int_field = colander.SchemaNode(
                     colander.Int(),
                     title='some integer setting',
                 )
             return SettingsSchema()
 
 
     integration_type_registry.register_integration_type(_StubIntegrationType)
     return _StubIntegrationType
 
 @pytest.fixture
 def stub_integration_settings():
     return {
         'test_string_field': 'some data',
         'test_int_field': 100,
     }
 
 
 @pytest.fixture
 def repo_integration_stub(request, repo_stub, StubIntegrationType,
         stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test repo integration',
         repo=repo_stub, repo_group=None, child_repos_only=None)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def repogroup_integration_stub(request, test_repo_group, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test repogroup integration',
         repo=None, repo_group=test_repo_group, child_repos_only=True)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def repogroup_recursive_integration_stub(request, test_repo_group,
     StubIntegrationType, stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test recursive repogroup integration',
         repo=None, repo_group=test_repo_group, child_repos_only=False)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def global_integration_stub(request, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test global integration',
         repo=None, repo_group=None, child_repos_only=None)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
 
 
 @pytest.fixture
 def root_repos_integration_stub(request, StubIntegrationType,
     stub_integration_settings):
     integration = IntegrationModel().create(
         StubIntegrationType, settings=stub_integration_settings, enabled=True,
         name='test global integration',
         repo=None, repo_group=None, child_repos_only=True)
 
     @request.addfinalizer
     def cleanup():
         IntegrationModel().delete(integration)
 
     return integration
+
+
[e-mail]
+def local_dt_to_utc():
+    def _factory(dt):
+        return dt.replace(tzinfo=dateutil.tz.tzlocal()).astimezone(
+            dateutil.tz.tzutc()).replace(tzinfo=None)
+    return _factory

rhodecode/tests/vcs/test_branches.py

@@ -1,173 +1,146 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import datetime
 
 import pytest
 
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.tests.vcs.base import BackendTestMixin
 
 
 class TestBranches(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='Foobar II'),
-                    FileNode('foo/bar/baz', content='baz here!'),
-                ],
-            },
-            {
-                'message': 'Changes...',
-                'author': 'Jane Doe <[e-mail]>',
-                'date': datetime.datetime(2010, 1, 1, 21),
-                'added': [
-                    FileNode('some/new.txt', content='news...'),
-                ],
-                'changed': [
-                    FileNode('foobar', 'Foobar I'),
-                ],
-                'removed': [],
-            },
-        ]
-        return commits
-
     def test_empty_repository_has_no_branches(self, vcsbackend):
         empty_repo = vcsbackend.create_repo()
         assert empty_repo.branches == {}
 
     def test_branches_all(self, vcsbackend):
         branch_count = {
             'git': 1,
             'hg': 1,
             'svn': 0,
         }
         assert len(self.repo.branches_all) == branch_count[vcsbackend.alias]
 
     def test_closed_branches(self):
         assert len(self.repo.branches_closed) == 0
 
-    def test_simple(self):
+    def test_simple(self, local_dt_to_utc):
         tip = self.repo.get_commit()
-        assert tip.date == datetime.datetime(2010, 1, 1, 21)
+        assert tip.message == 'Changes...'
+        assert tip.date == local_dt_to_utc(datetime.datetime(2010, 1, 1, 21))
 
     @pytest.mark.backends("git", "hg")
     def test_new_branch(self):
         # This check must not be removed to ensure the 'branches' LazyProperty
         # gets hit *before* the new 'foobar' branch got created:
         assert 'foobar' not in self.repo.branches
         self.imc.add(FileNode(
             'docs/index.txt',
             content='Documentation\n'))
         foobar_tip = self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
         )
         assert 'foobar' in self.repo.branches
         assert foobar_tip.branch == 'foobar'
 
     @pytest.mark.backends("git", "hg")
     def test_new_head(self):
         tip = self.repo.get_commit()
         self.imc.add(FileNode(
             'docs/index.txt',
             content='Documentation\n'))
         foobar_tip = self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
             parents=[tip],
         )
         self.imc.change(FileNode(
             'docs/index.txt',
             content='Documentation\nand more...\n'))
         newtip = self.imc.commit(
             message=u'At default branch',
             author=u'joe',
             branch=foobar_tip.branch,
             parents=[foobar_tip],
         )
 
         newest_tip = self.imc.commit(
             message=u'Merged with %s' % foobar_tip.raw_id,
             author=u'joe',
             branch=self.backend_class.DEFAULT_BRANCH_NAME,
             parents=[newtip, foobar_tip],
         )
 
         assert newest_tip.branch == \
             self.backend_class.DEFAULT_BRANCH_NAME
 
     @pytest.mark.backends("git", "hg")
     def test_branch_with_slash_in_name(self):
         self.imc.add(FileNode('extrafile', content='Some data\n'))
         self.imc.commit(
             u'Branch with a slash!', author=u'joe',
             branch='issue/123')
         assert 'issue/123' in self.repo.branches
 
     @pytest.mark.backends("git", "hg")
     def test_branch_with_slash_in_name_and_similar_without(self):
         self.imc.add(FileNode('extrafile', content='Some data\n'))
         self.imc.commit(
             u'Branch with a slash!', author=u'joe',
             branch='issue/123')
         self.imc.add(FileNode('extrafile II', content='Some data\n'))
         self.imc.commit(
             u'Branch without a slash...', author=u'joe',
             branch='123')
         assert 'issue/123' in self.repo.branches
         assert '123' in self.repo.branches
 
 
-class TestSvnBranches:
+class TestSvnBranches(object):
 
     def test_empty_repository_has_no_tags_and_branches(self, vcsbackend_svn):
         empty_repo = vcsbackend_svn.create_repo()
         assert empty_repo.branches == {}
         assert empty_repo.tags == {}
 
     def test_missing_structure_has_no_tags_and_branches(self, vcsbackend_svn):
         repo = vcsbackend_svn.create_repo(number_of_commits=1)
         assert repo.branches == {}
         assert repo.tags == {}
 
     def test_discovers_ordered_branches(self, vcsbackend_svn):
         repo = vcsbackend_svn['svn-simple-layout']
         expected_branches = [
             'branches/add-docs',
             'branches/argparse',
             'trunk',
         ]
         assert repo.branches.keys() == expected_branches
 
     def test_discovers_ordered_tags(self, vcsbackend_svn):
         repo = vcsbackend_svn['svn-simple-layout']
         expected_tags = [
             'tags/v0.1', 'tags/v0.2', 'tags/v0.3', 'tags/v0.5']
         assert repo.tags.keys() == expected_tags

rhodecode/tests/vcs/test_commits.py

@@ -1,577 +1,575 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import datetime
 import time
 
 import pytest
 
 from rhodecode.lib.vcs.backends.base import (
     CollectionGenerator, FILEMODE_DEFAULT, EmptyCommit)
 from rhodecode.lib.vcs.exceptions import (
     BranchDoesNotExistError, CommitDoesNotExistError,
     RepositoryError, EmptyRepositoryError)
 from rhodecode.lib.vcs.nodes import (
     FileNode, AddedFileNodesGenerator,
     ChangedFileNodesGenerator, RemovedFileNodesGenerator)
 from rhodecode.tests import get_new_dir
 from rhodecode.tests.vcs.base import BackendTestMixin
 
 
 class TestBaseChangeset:
 
     def test_is_deprecated(self):
         from rhodecode.lib.vcs.backends.base import BaseChangeset
         pytest.deprecated_call(BaseChangeset)
 
 
 class TestEmptyCommit:
 
     def test_branch_without_alias_returns_none(self):
         commit = EmptyCommit()
         assert commit.branch is None
 
 
 class TestCommitsInNonEmptyRepo(BackendTestMixin):
     recreate_repo_per_test = True
 
     @classmethod
     def _get_commits(cls):
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in xrange(5):
             yield {
                 'message': 'Commit %d' % x,
                 'author': 'Joe Doe <[e-mail]>',
                 'date': start_date + datetime.timedelta(hours=12 * x),
                 'added': [
                     FileNode('file_%d.txt' % x, content='Foobar %d' % x),
                 ],
             }
 
     def test_walk_returns_empty_list_in_case_of_file(self):
         result = list(self.tip.walk('file_0.txt'))
         assert result == []
 
     @pytest.mark.backends("git", "hg")
     def test_new_branch(self):
         self.imc.add(FileNode('docs/index.txt',
                      content='Documentation\n'))
         foobar_tip = self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
         )
         assert 'foobar' in self.repo.branches
         assert foobar_tip.branch == 'foobar'
         # 'foobar' should be the only branch that contains the new commit
         branch = self.repo.branches.values()
         assert branch[0] != branch[1]
 
     @pytest.mark.backends("git", "hg")
     def test_new_head_in_default_branch(self):
         tip = self.repo.get_commit()
         self.imc.add(FileNode('docs/index.txt',
                      content='Documentation\n'))
         foobar_tip = self.imc.commit(
             message=u'New branch: foobar',
             author=u'joe',
             branch='foobar',
             parents=[tip],
         )
         self.imc.change(FileNode('docs/index.txt',
                         content='Documentation\nand more...\n'))
         newtip = self.imc.commit(
             message=u'At default branch',
             author=u'joe',
             branch=foobar_tip.branch,
             parents=[foobar_tip],
         )
 
         newest_tip = self.imc.commit(
             message=u'Merged with %s' % foobar_tip.raw_id,
             author=u'joe',
             branch=self.backend_class.DEFAULT_BRANCH_NAME,
             parents=[newtip, foobar_tip],
         )
 
         assert newest_tip.branch == self.backend_class.DEFAULT_BRANCH_NAME
 
     @pytest.mark.backends("git", "hg")
     def test_get_commits_respects_branch_name(self):
         """
         * e1930d0 (HEAD, master) Back in default branch
         | * e1930d0 (docs) New Branch: docs2
         | * dcc14fa New branch: docs
         |/
         * e63c41a Initial commit
         ...
         * 624d3db Commit 0
 
         :return:
         """
         DEFAULT_BRANCH = self.repo.DEFAULT_BRANCH_NAME
         TEST_BRANCH = 'docs'
         org_tip = self.repo.get_commit()
 
         self.imc.add(FileNode('readme.txt', content='Document\n'))
         initial = self.imc.commit(
             message=u'Initial commit',
             author=u'joe',
             parents=[org_tip],
             branch=DEFAULT_BRANCH,)
 
         self.imc.add(FileNode('newdoc.txt', content='foobar\n'))
         docs_branch_commit1 = self.imc.commit(
             message=u'New branch: docs',
             author=u'joe',
             parents=[initial],
             branch=TEST_BRANCH,)
 
         self.imc.add(FileNode('newdoc2.txt', content='foobar2\n'))
         docs_branch_commit2 = self.imc.commit(
             message=u'New branch: docs2',
             author=u'joe',
             parents=[docs_branch_commit1],
             branch=TEST_BRANCH,)
 
         self.imc.add(FileNode('newfile', content='hello world\n'))
         self.imc.commit(
             message=u'Back in default branch',
             author=u'joe',
             parents=[initial],
             branch=DEFAULT_BRANCH,)
 
         default_branch_commits = self.repo.get_commits(
             branch_name=DEFAULT_BRANCH)
         assert docs_branch_commit1 not in list(default_branch_commits)
         assert docs_branch_commit2 not in list(default_branch_commits)
 
         docs_branch_commits = self.repo.get_commits(
             start_id=self.repo.commit_ids[0], end_id=self.repo.commit_ids[-1],
             branch_name=TEST_BRANCH)
         assert docs_branch_commit1 in list(docs_branch_commits)
         assert docs_branch_commit2 in list(docs_branch_commits)
 
     @pytest.mark.backends("svn")
     def test_get_commits_respects_branch_name_svn(self, vcsbackend_svn):
         repo = vcsbackend_svn['svn-simple-layout']
         commits = repo.get_commits(branch_name='trunk')
         commit_indexes = [c.idx for c in commits]
         assert commit_indexes == [1, 2, 3, 7, 12, 15]
 
     def test_get_commit_by_branch(self):
         for branch, commit_id in self.repo.branches.iteritems():
             assert commit_id == self.repo.get_commit(branch).raw_id
 
     def test_get_commit_by_tag(self):
         for tag, commit_id in self.repo.tags.iteritems():
             assert commit_id == self.repo.get_commit(tag).raw_id
 
     def test_get_commit_parents(self):
         repo = self.repo
         for test_idx in [1, 2, 3]:
             commit = repo.get_commit(commit_idx=test_idx - 1)
             assert [commit] == repo.get_commit(commit_idx=test_idx).parents
 
     def test_get_commit_children(self):
         repo = self.repo
         for test_idx in [1, 2, 3]:
             commit = repo.get_commit(commit_idx=test_idx + 1)
             assert [commit] == repo.get_commit(commit_idx=test_idx).children
 
 
 class TestCommits(BackendTestMixin):
     recreate_repo_per_test = False
 
     @classmethod
     def _get_commits(cls):
         start_date = datetime.datetime(2010, 1, 1, 20)
         for x in xrange(5):
             yield {
                 'message': u'Commit %d' % x,
                 'author': u'Joe Doe <[e-mail]>',
                 'date': start_date + datetime.timedelta(hours=12 * x),
                 'added': [
                     FileNode('file_%d.txt' % x, content='Foobar %d' % x),
                 ],
             }
 
     def test_simple(self):
         tip = self.repo.get_commit()
         assert tip.date, datetime.datetime(2010, 1, 3 == 20)
 
     def test_simple_serialized_commit(self):
         tip = self.repo.get_commit()
         # json.dumps(tip) uses .__json__() method
         data = tip.__json__()
         assert 'branch' in data
         assert data['revision']
 
     def test_retrieve_tip(self):
         tip = self.repo.get_commit('tip')
         assert tip == self.repo.get_commit()
 
     def test_invalid(self):
         with pytest.raises(CommitDoesNotExistError):
             self.repo.get_commit(commit_idx=123456789)
 
     def test_idx(self):
         commit = self.repo[0]
         assert commit.idx == 0
 
     def test_negative_idx(self):
         commit = self.repo.get_commit(commit_idx=-1)
         assert commit.idx >= 0
 
     def test_revision_is_deprecated(self):
         def get_revision(commit):
             return commit.revision
 
         commit = self.repo[0]
         pytest.deprecated_call(get_revision, commit)
 
     def test_size(self):
         tip = self.repo.get_commit()
         size = 5 * len('Foobar N')  # Size of 5 files
         assert tip.size == size
 
     def test_size_at_commit(self):
         tip = self.repo.get_commit()
         size = 5 * len('Foobar N')  # Size of 5 files
         assert self.repo.size_at_commit(tip.raw_id) == size
 
     def test_size_at_first_commit(self):
         commit = self.repo[0]
         size = len('Foobar N')  # Size of 1 file
         assert self.repo.size_at_commit(commit.raw_id) == size
 
     def test_author(self):
         tip = self.repo.get_commit()
         assert_text_equal(tip.author, u'Joe Doe <[e-mail]>')
 
     def test_author_name(self):
         tip = self.repo.get_commit()
         assert_text_equal(tip.author_name, u'Joe Doe')
 
     def test_author_email(self):
         tip = self.repo.get_commit()
         assert_text_equal(tip.author_email, u'[e-mail]')
 
     def test_message(self):
         tip = self.repo.get_commit()
         assert_text_equal(tip.message, u'Commit 4')
 
     def test_diff(self):
         tip = self.repo.get_commit()
         diff = tip.diff()
         assert "+Foobar 4" in diff.raw
 
     def test_prev(self):
         tip = self.repo.get_commit()
         prev_commit = tip.prev()
         assert prev_commit.message == 'Commit 3'
 
     def test_prev_raises_on_first_commit(self):
         commit = self.repo.get_commit(commit_idx=0)
         with pytest.raises(CommitDoesNotExistError):
             commit.prev()
 
     def test_prev_works_on_second_commit_issue_183(self):
         commit = self.repo.get_commit(commit_idx=1)
         prev_commit = commit.prev()
         assert prev_commit.idx == 0
 
     def test_next(self):
         commit = self.repo.get_commit(commit_idx=2)
         next_commit = commit.next()
         assert next_commit.message == 'Commit 3'
 
     def test_next_raises_on_tip(self):
         commit = self.repo.get_commit()
         with pytest.raises(CommitDoesNotExistError):
             commit.next()
 
     def test_get_file_commit(self):
         commit = self.repo.get_commit()
         commit.get_file_commit('file_4.txt')
         assert commit.message == 'Commit 4'
 
     def test_get_filenodes_generator(self):
         tip = self.repo.get_commit()
         filepaths = [node.path for node in tip.get_filenodes_generator()]
         assert filepaths == ['file_%d.txt' % x for x in xrange(5)]
 
     def test_get_file_annotate(self):
         file_added_commit = self.repo.get_commit(commit_idx=3)
         annotations = list(file_added_commit.get_file_annotate('file_3.txt'))
+
         line_no, commit_id, commit_loader, line = annotations[0]
+
         assert line_no == 1
         assert commit_id == file_added_commit.raw_id
         assert commit_loader() == file_added_commit
-
-        # git annotation is generated differently thus different results
-        if self.repo.alias == 'git':
-            assert line == '(Joe Doe 2010-01-03 08:00:00 +0000 1) Foobar 3'
-        else:
-            assert line == 'Foobar 3'
+        assert 'Foobar 3' in line
 
     def test_get_file_annotate_does_not_exist(self):
         file_added_commit = self.repo.get_commit(commit_idx=2)
         # TODO: Should use a specific exception class here?
         with pytest.raises(Exception):
             list(file_added_commit.get_file_annotate('file_3.txt'))
 
     def test_get_file_annotate_tip(self):
         tip = self.repo.get_commit()
         commit = self.repo.get_commit(commit_idx=3)
         expected_values = list(commit.get_file_annotate('file_3.txt'))
         annotations = list(tip.get_file_annotate('file_3.txt'))
 
         # Note: Skip index 2 because the loader function is not the same
         for idx in (0, 1, 3):
             assert annotations[0][idx] == expected_values[0][idx]
 
     def test_get_commits_is_ordered_by_date(self):
         commits = self.repo.get_commits()
         assert isinstance(commits, CollectionGenerator)
         assert len(commits) == 0 or len(commits) != 0
         commits = list(commits)
         ordered_by_date = sorted(commits, key=lambda commit: commit.date)
         assert commits == ordered_by_date
 
     def test_get_commits_respects_start(self):
         second_id = self.repo.commit_ids[1]
         commits = self.repo.get_commits(start_id=second_id)
         assert isinstance(commits, CollectionGenerator)
         commits = list(commits)
         assert len(commits) == 4
 
     def test_get_commits_includes_start_commit(self):
         second_id = self.repo.commit_ids[1]
         commits = self.repo.get_commits(start_id=second_id)
         assert isinstance(commits, CollectionGenerator)
         commits = list(commits)
         assert commits[0].raw_id == second_id
 
     def test_get_commits_respects_end(self):
         second_id = self.repo.commit_ids[1]
         commits = self.repo.get_commits(end_id=second_id)
         assert isinstance(commits, CollectionGenerator)
         commits = list(commits)
         assert commits[-1].raw_id == second_id
         assert len(commits) == 2
 
     def test_get_commits_respects_both_start_and_end(self):
         second_id = self.repo.commit_ids[1]
         third_id = self.repo.commit_ids[2]
         commits = self.repo.get_commits(start_id=second_id, end_id=third_id)
         assert isinstance(commits, CollectionGenerator)
         commits = list(commits)
         assert len(commits) == 2
 
     def test_get_commits_on_empty_repo_raises_EmptyRepository_error(self):
         repo_path = get_new_dir(str(time.time()))
         repo = self.Backend(repo_path, create=True)
 
         with pytest.raises(EmptyRepositoryError):
             list(repo.get_commits(start_id='foobar'))
 
     def test_get_commits_includes_end_commit(self):
         second_id = self.repo.commit_ids[1]
         commits = self.repo.get_commits(end_id=second_id)
         assert isinstance(commits, CollectionGenerator)
         assert len(commits) == 2
         commits = list(commits)
         assert commits[-1].raw_id == second_id
 
     def test_get_commits_respects_start_date(self):
         start_date = datetime.datetime(2010, 1, 2)
         commits = self.repo.get_commits(start_date=start_date)
         assert isinstance(commits, CollectionGenerator)
         # Should be 4 commits after 2010-01-02 00:00:00
         assert len(commits) == 4
         for c in commits:
             assert c.date >= start_date
 
     def test_get_commits_respects_start_date_and_end_date(self):
         start_date = datetime.datetime(2010, 1, 2)
         end_date = datetime.datetime(2010, 1, 3)
         commits = self.repo.get_commits(start_date=start_date,
                                         end_date=end_date)
         assert isinstance(commits, CollectionGenerator)
         assert len(commits) == 2
         for c in commits:
             assert c.date >= start_date
             assert c.date <= end_date
 
     def test_get_commits_respects_end_date(self):
         end_date = datetime.datetime(2010, 1, 2)
         commits = self.repo.get_commits(end_date=end_date)
         assert isinstance(commits, CollectionGenerator)
         assert len(commits) == 1
         for c in commits:
             assert c.date <= end_date
 
     def test_get_commits_respects_reverse(self):
         commits = self.repo.get_commits()  # no longer reverse support
         assert isinstance(commits, CollectionGenerator)
         assert len(commits) == 5
         commit_ids = reversed([c.raw_id for c in commits])
         assert list(commit_ids) == list(reversed(self.repo.commit_ids))
 
     def test_get_commits_slice_generator(self):
         commits = self.repo.get_commits(
             branch_name=self.repo.DEFAULT_BRANCH_NAME)
         assert isinstance(commits, CollectionGenerator)
         commit_slice = list(commits[1:3])
         assert len(commit_slice) == 2
 
     def test_get_commits_raise_commitdoesnotexist_for_wrong_start(self):
         with pytest.raises(CommitDoesNotExistError):
             list(self.repo.get_commits(start_id='foobar'))
 
     def test_get_commits_raise_commitdoesnotexist_for_wrong_end(self):
         with pytest.raises(CommitDoesNotExistError):
             list(self.repo.get_commits(end_id='foobar'))
 
     def test_get_commits_raise_branchdoesnotexist_for_wrong_branch_name(self):
         with pytest.raises(BranchDoesNotExistError):
             list(self.repo.get_commits(branch_name='foobar'))
 
     def test_get_commits_raise_repositoryerror_for_wrong_start_end(self):
         start_id = self.repo.commit_ids[-1]
         end_id = self.repo.commit_ids[0]
         with pytest.raises(RepositoryError):
             list(self.repo.get_commits(start_id=start_id, end_id=end_id))
 
     def test_get_commits_raises_for_numerical_ids(self):
         with pytest.raises(TypeError):
             self.repo.get_commits(start_id=1, end_id=2)
 
     def test_commit_equality(self):
         commit1 = self.repo.get_commit(self.repo.commit_ids[0])
         commit2 = self.repo.get_commit(self.repo.commit_ids[1])
 
         assert commit1 == commit1
         assert commit2 == commit2
         assert commit1 != commit2
         assert commit2 != commit1
         assert commit1 != None
         assert None != commit1
         assert 1 != commit1
         assert 'string' != commit1
 
 
 @pytest.mark.parametrize("filename, expected", [
     ("README.rst", False),
     ("README", True),
 ])
 def test_commit_is_link(vcsbackend, filename, expected):
     commit = vcsbackend.repo.get_commit()
     link_status = commit.is_link(filename)
     assert link_status is expected
 
 
 class TestCommitsChanges(BackendTestMixin):
     recreate_repo_per_test = False
 
     @classmethod
     def _get_commits(cls):
         return [
             {
                 'message': u'Initial',
                 'author': u'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'added': [
                     FileNode('foo/bar', content='foo'),
                     FileNode('foo/bał', content='foo'),
                     FileNode('foobar', content='foo'),
                     FileNode('qwe', content='foo'),
                 ],
             },
             {
                 'message': u'Massive changes',
                 'author': u'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 22),
                 'added': [FileNode('fallout', content='War never changes')],
                 'changed': [
                     FileNode('foo/bar', content='baz'),
                     FileNode('foobar', content='baz'),
                 ],
                 'removed': [FileNode('qwe')],
             },
         ]
 
-    def test_initial_commit(self):
+    def test_initial_commit(self, local_dt_to_utc):
         commit = self.repo.get_commit(commit_idx=0)
         assert set(commit.added) == set([
             commit.get_node('foo/bar'),
             commit.get_node('foo/bał'),
             commit.get_node('foobar'),
             commit.get_node('qwe'),
         ])
         assert set(commit.changed) == set()
         assert set(commit.removed) == set()
         assert set(commit.affected_files) == set(
             ['foo/bar', 'foo/bał', 'foobar', 'qwe'])
-        assert commit.date == datetime.datetime(2010, 1, 1, 20, 0)
+        assert commit.date == local_dt_to_utc(
+            datetime.datetime(2010, 1, 1, 20, 0))
 
     def test_head_added(self):
         commit = self.repo.get_commit()
         assert isinstance(commit.added, AddedFileNodesGenerator)
         assert set(commit.added) == set([commit.get_node('fallout')])
         assert isinstance(commit.changed, ChangedFileNodesGenerator)
         assert set(commit.changed) == set([
             commit.get_node('foo/bar'),
             commit.get_node('foobar'),
         ])
         assert isinstance(commit.removed, RemovedFileNodesGenerator)
         assert len(commit.removed) == 1
         assert list(commit.removed)[0].path == 'qwe'
 
     def test_get_filemode(self):
         commit = self.repo.get_commit()
         assert FILEMODE_DEFAULT == commit.get_file_mode('foo/bar')
 
     def test_get_filemode_non_ascii(self):
         commit = self.repo.get_commit()
         assert FILEMODE_DEFAULT == commit.get_file_mode('foo/bał')
         assert FILEMODE_DEFAULT == commit.get_file_mode(u'foo/bał')
 
     def test_get_file_history(self):
         commit = self.repo.get_commit()
         history = commit.get_file_history('foo/bar')
         assert len(history) == 2
 
     def test_get_file_history_with_limit(self):
         commit = self.repo.get_commit()
         history = commit.get_file_history('foo/bar', limit=1)
         assert len(history) == 1
 
     def test_get_file_history_first_commit(self):
         commit = self.repo[0]
         history = commit.get_file_history('foo/bar')
         assert len(history) == 1
 
 
 def assert_text_equal(expected, given):
     assert expected == given
     assert isinstance(expected, unicode)
     assert isinstance(given, unicode)

rhodecode/tests/vcs/test_inmemory.py

@@ -1,344 +1,344 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 """
 Tests so called "in memory commits" commit API of vcs.
 """
 import datetime
 
 import pytest
 
 from rhodecode.lib.utils2 import safe_unicode
 from rhodecode.lib.vcs.exceptions import (
     EmptyRepositoryError, NodeAlreadyAddedError, NodeAlreadyExistsError,
     NodeAlreadyRemovedError, NodeAlreadyChangedError, NodeDoesNotExistError,
     NodeNotChangedError)
 from rhodecode.lib.vcs.nodes import DirNode, FileNode
 from rhodecode.tests.vcs.base import BackendTestMixin
 
 
 @pytest.fixture
 def nodes():
     nodes = [
         FileNode('foobar', content='Foo & bar'),
         FileNode('foobar2', content='Foo & bar, doubled!'),
         FileNode('foo bar with spaces', content=''),
         FileNode('foo/bar/baz', content='Inside'),
         FileNode(
             'foo/bar/file.bin',
             content=(
                 '\xd0\xcf\x11\xe0\xa1\xb1\x1a\xe1\x00\x00\x00\x00\x00\x00'
                 '\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00;\x00\x03\x00\xfe'
                 '\xff\t\x00\x06\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
                 '\x01\x00\x00\x00\x1a\x00\x00\x00\x00\x00\x00\x00\x00\x10\x00'
                 '\x00\x18\x00\x00\x00\x01\x00\x00\x00\xfe\xff\xff\xff\x00\x00'
                 '\x00\x00\x00\x00\x00\x00\xff\xff\xff\xff\xff\xff\xff\xff\xff'
                 '\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff\xff'
             )
         ),
     ]
     return nodes
 
 
 class TestInMemoryCommit(BackendTestMixin):
     """
     This is a backend independent test case class which should be created
     with ``type`` method.
 
     It is required to set following attributes at subclass:
 
     - ``backend_alias``: alias of used backend (see ``vcs.BACKENDS``)
     """
 
     @classmethod
     def _get_commits(cls):
         return []
 
     def test_add(self, nodes):
         for node in nodes:
             self.imc.add(node)
 
         self.commit()
         self.assert_succesful_commit(nodes)
 
     @pytest.mark.skip_backends(
         'svn', reason="Svn does not support commits on branches.")
     def test_add_on_branch(self, nodes):
         for node in nodes:
             self.imc.add(node)
         self.commit(branch=u'stable')
         self.assert_succesful_commit(nodes)
 
     def test_add_in_bulk(self, nodes):
         self.imc.add(*nodes)
 
         self.commit()
         self.assert_succesful_commit(nodes)
 
     def test_add_non_ascii_files(self):
         nodes = [
             FileNode('żółwik/zwierzątko_utf8_str', content='ćććć'),
             FileNode(u'żółwik/zwierzątko_unicode', content=u'ćććć'),
         ]
 
         for node in nodes:
             self.imc.add(node)
 
         self.commit()
         self.assert_succesful_commit(nodes)
 
     def commit(self, branch=None):
         self.old_commit_count = len(self.repo.commit_ids)
         self.commit_message = u'Test commit with unicode: żółwik'
         self.commit_author = unicode(self.__class__)
         self.commit = self.imc.commit(
             message=self.commit_message, author=self.commit_author,
             branch=branch)
 
     def test_add_actually_adds_all_nodes_at_second_commit_too(self):
         to_add = [
             FileNode('foo/bar/image.png', content='\0'),
             FileNode('foo/README.txt', content='readme!'),
         ]
         self.imc.add(*to_add)
         commit = self.imc.commit(u'Initial', u'[e-mail]')
         assert isinstance(commit.get_node('foo'), DirNode)
         assert isinstance(commit.get_node('foo/bar'), DirNode)
         self.assert_nodes_in_commit(commit, to_add)
 
         # commit some more files again
         to_add = [
             FileNode('foo/bar/foobaz/bar', content='foo'),
             FileNode('foo/bar/another/bar', content='foo'),
             FileNode('foo/baz.txt', content='foo'),
             FileNode('foobar/foobaz/file', content='foo'),
             FileNode('foobar/barbaz', content='foo'),
         ]
         self.imc.add(*to_add)
         commit = self.imc.commit(u'Another', u'[e-mail]')
         self.assert_nodes_in_commit(commit, to_add)
 
     def test_add_raise_already_added(self):
         node = FileNode('foobar', content='baz')
         self.imc.add(node)
         with pytest.raises(NodeAlreadyAddedError):
             self.imc.add(node)
 
     def test_check_integrity_raise_already_exist(self):
         node = FileNode('foobar', content='baz')
         self.imc.add(node)
         self.imc.commit(message=u'Added foobar', author=unicode(self))
         self.imc.add(node)
         with pytest.raises(NodeAlreadyExistsError):
             self.imc.commit(message='new message', author=str(self))
 
     def test_change(self):
         self.imc.add(FileNode('foo/bar/baz', content='foo'))
         self.imc.add(FileNode('foo/fbar', content='foobar'))
         tip = self.imc.commit(u'Initial', u'[e-mail]')
 
         # Change node's content
         node = FileNode('foo/bar/baz', content='My **changed** content')
         self.imc.change(node)
         self.imc.commit(u'Changed %s' % node.path, u'[e-mail]')
 
         newtip = self.repo.get_commit()
         assert tip != newtip
         assert tip.id != newtip.id
         self.assert_nodes_in_commit(newtip, (node,))
 
     def test_change_non_ascii(self):
         to_add = [
             FileNode('żółwik/zwierzątko', content='ćććć'),
             FileNode(u'żółwik/zwierzątko_uni', content=u'ćććć'),
         ]
         for node in to_add:
             self.imc.add(node)
 
         tip = self.imc.commit(u'Initial', u'[e-mail]')
 
         # Change node's content
         node = FileNode('żółwik/zwierzątko', content='My **changed** content')
         self.imc.change(node)
         self.imc.commit(u'Changed %s' % safe_unicode(node.path),
                         u'[e-mail]')
 
         node_uni = FileNode(
             u'żółwik/zwierzątko_uni', content=u'My **changed** content')
         self.imc.change(node_uni)
         self.imc.commit(u'Changed %s' % safe_unicode(node_uni.path),
                         u'[e-mail]')
 
         newtip = self.repo.get_commit()
         assert tip != newtip
         assert tip.id != newtip.id
 
         self.assert_nodes_in_commit(newtip, (node, node_uni))
 
     def test_change_raise_empty_repository(self):
         node = FileNode('foobar')
         with pytest.raises(EmptyRepositoryError):
             self.imc.change(node)
 
     def test_check_integrity_change_raise_node_does_not_exist(self):
         node = FileNode('foobar', content='baz')
         self.imc.add(node)
         self.imc.commit(message=u'Added foobar', author=unicode(self))
         node = FileNode('not-foobar', content='')
         self.imc.change(node)
         with pytest.raises(NodeDoesNotExistError):
             self.imc.commit(
                 message='Changed not existing node',
                 author=str(self))
 
     def test_change_raise_node_already_changed(self):
         node = FileNode('foobar', content='baz')
         self.imc.add(node)
         self.imc.commit(message=u'Added foobar', author=unicode(self))
         node = FileNode('foobar', content='more baz')
         self.imc.change(node)
         with pytest.raises(NodeAlreadyChangedError):
             self.imc.change(node)
 
     def test_check_integrity_change_raise_node_not_changed(self, nodes):
         self.test_add(nodes)  # Performs first commit
 
         node = FileNode(nodes[0].path, content=nodes[0].content)
         self.imc.change(node)
         with pytest.raises(NodeNotChangedError):
             self.imc.commit(
                 message=u'Trying to mark node as changed without touching it',
                 author=unicode(self))
 
     def test_change_raise_node_already_removed(self):
         node = FileNode('foobar', content='baz')
         self.imc.add(node)
         self.imc.commit(message=u'Added foobar', author=unicode(self))
         self.imc.remove(FileNode('foobar'))
         with pytest.raises(NodeAlreadyRemovedError):
             self.imc.change(node)
 
     def test_remove(self, nodes):
         self.test_add(nodes)  # Performs first commit
 
         tip = self.repo.get_commit()
         node = nodes[0]
         assert node.content == tip.get_node(node.path).content
         self.imc.remove(node)
         self.imc.commit(
             message=u'Removed %s' % node.path, author=unicode(self))
 
         newtip = self.repo.get_commit()
         assert tip != newtip
         assert tip.id != newtip.id
         with pytest.raises(NodeDoesNotExistError):
             newtip.get_node(node.path)
 
     def test_remove_last_file_from_directory(self):
         node = FileNode('omg/qwe/foo/bar', content='foobar')
         self.imc.add(node)
         self.imc.commit(u'added', u'joe doe')
 
         self.imc.remove(node)
         tip = self.imc.commit(u'removed', u'joe doe')
         with pytest.raises(NodeDoesNotExistError):
             tip.get_node('omg/qwe/foo/bar')
 
     def test_remove_raise_node_does_not_exist(self, nodes):
         self.imc.remove(nodes[0])
         with pytest.raises(NodeDoesNotExistError):
             self.imc.commit(
                 message='Trying to remove node at empty repository',
                 author=str(self))
 
     def test_check_integrity_remove_raise_node_does_not_exist(self, nodes):
         self.test_add(nodes)  # Performs first commit
 
         node = FileNode('no-such-file')
         self.imc.remove(node)
         with pytest.raises(NodeDoesNotExistError):
             self.imc.commit(
                 message=u'Trying to remove not existing node',
                 author=unicode(self))
 
     def test_remove_raise_node_already_removed(self, nodes):
         self.test_add(nodes)  # Performs first commit
 
         node = FileNode(nodes[0].path)
         self.imc.remove(node)
         with pytest.raises(NodeAlreadyRemovedError):
             self.imc.remove(node)
 
     def test_remove_raise_node_already_changed(self, nodes):
         self.test_add(nodes)  # Performs first commit
 
         node = FileNode(nodes[0].path, content='Bending time')
         self.imc.change(node)
         with pytest.raises(NodeAlreadyChangedError):
             self.imc.remove(node)
 
     def test_reset(self):
         self.imc.add(FileNode('foo', content='bar'))
         # self.imc.change(FileNode('baz', content='new'))
         # self.imc.remove(FileNode('qwe'))
         self.imc.reset()
         assert not any((self.imc.added, self.imc.changed, self.imc.removed))
 
     def test_multiple_commits(self):
         N = 3  # number of commits to perform
         last = None
         for x in xrange(N):
             fname = 'file%s' % str(x).rjust(5, '0')
             content = 'foobar\n' * x
             node = FileNode(fname, content=content)
             self.imc.add(node)
             commit = self.imc.commit(u"Commit no. %s" % (x + 1), author=u'vcs')
             assert last != commit
             last = commit
 
         # Check commit number for same repo
         assert len(self.repo.commit_ids) == N
 
         # Check commit number for recreated repo
         repo = self.Backend(self.repo_path)
         assert len(repo.commit_ids) == N
 
-    def test_date_attr(self):
+    def test_date_attr(self, local_dt_to_utc):
         node = FileNode('foobar.txt', content='Foobared!')
         self.imc.add(node)
         date = datetime.datetime(1985, 1, 30, 1, 45)
         commit = self.imc.commit(
             u"Committed at time when I was born ;-)",
             author=u'lb', date=date)
 
-        assert commit.date == date
+        assert commit.date == local_dt_to_utc(date)
 
     def assert_succesful_commit(self, added_nodes):
         newtip = self.repo.get_commit()
         assert self.commit == newtip
         assert self.old_commit_count + 1 == len(self.repo.commit_ids)
         assert newtip.message == self.commit_message
         assert newtip.author == self.commit_author
         assert not any((self.imc.added, self.imc.changed, self.imc.removed))
         self.assert_nodes_in_commit(newtip, added_nodes)
 
     def assert_nodes_in_commit(self, commit, nodes):
         for node in nodes:
             assert commit.get_node(node.path).content == node.content

rhodecode/tests/vcs/test_repository.py

@@ -1,532 +1,534 b''
 # -*- coding: utf-8 -*-
 
 # Copyright (C) 2010-2017 RhodeCode GmbH
 #
 # This program is free software: you can redistribute it and/or modify
 # it under the terms of the GNU Affero General Public License, version 3
 # (only), as published by the Free Software Foundation.
 #
 # This program is distributed in the hope that it will be useful,
 # but WITHOUT ANY WARRANTY; without even the implied warranty of
 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 # GNU General Public License for more details.
 #
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 # This program is dual-licensed. If you wish to learn more about the
 # RhodeCode Enterprise Edition, including its added features, Support services,
 # and proprietary license terms, please see https://rhodecode.com/licenses/
 
 import datetime
 from urllib2 import URLError
 
 import mock
 import pytest
 
 from rhodecode.lib.vcs import backends
 from rhodecode.lib.vcs.backends.base import (
     Config, BaseInMemoryCommit, Reference, MergeResponse, MergeFailureReason)
 from rhodecode.lib.vcs.exceptions import VCSError, RepositoryError
 from rhodecode.lib.vcs.nodes import FileNode
 from rhodecode.tests.vcs.base import BackendTestMixin
 
 
 class TestRepositoryBase(BackendTestMixin):
     recreate_repo_per_test = False
 
     def test_init_accepts_unicode_path(self, tmpdir):
         path = unicode(tmpdir.join(u'unicode ä'))
         self.Backend(path, create=True)
 
     def test_init_accepts_str_path(self, tmpdir):
         path = str(tmpdir.join('str ä'))
         self.Backend(path, create=True)
 
     def test_init_fails_if_path_does_not_exist(self, tmpdir):
         path = unicode(tmpdir.join('i-do-not-exist'))
         with pytest.raises(VCSError):
             self.Backend(path)
 
     def test_init_fails_if_path_is_not_a_valid_repository(self, tmpdir):
         path = unicode(tmpdir.mkdir(u'unicode ä'))
         with pytest.raises(VCSError):
             self.Backend(path)
 
     def test_has_commits_attribute(self):
         self.repo.commit_ids
 
     def test_name(self):
         assert self.repo.name.startswith('vcs-test')
 
     @pytest.mark.backends("hg", "git")
     def test_has_default_branch_name(self):
         assert self.repo.DEFAULT_BRANCH_NAME is not None
 
     @pytest.mark.backends("svn")
     def test_has_no_default_branch_name(self):
         assert self.repo.DEFAULT_BRANCH_NAME is None
 
     def test_has_empty_commit(self):
         assert self.repo.EMPTY_COMMIT_ID is not None
         assert self.repo.EMPTY_COMMIT is not None
 
     def test_empty_changeset_is_deprecated(self):
         def get_empty_changeset(repo):
             return repo.EMPTY_CHANGESET
         pytest.deprecated_call(get_empty_changeset, self.repo)
 
     def test_bookmarks(self):
         assert len(self.repo.bookmarks) == 0
 
     # TODO: Cover two cases: Local repo path, remote URL
     def test_check_url(self):
         config = Config()
         assert self.Backend.check_url(self.repo.path, config)
 
     def test_check_url_invalid(self):
         config = Config()
         with pytest.raises(URLError):
             self.Backend.check_url(self.repo.path + "invalid", config)
 
     def test_get_contact(self):
-        self.repo.contact
+        assert self.repo.contact
 
     def test_get_description(self):
-        self.repo.description
+        assert self.repo.description
 
     def test_get_hook_location(self):
         assert len(self.repo.get_hook_location()) != 0
 
-    def test_last_change(self):
-        assert self.repo.last_change >= datetime.datetime(2010, 1, 1, 21, 0)
+    def test_last_change(self, local_dt_to_utc):
+        assert self.repo.last_change >= local_dt_to_utc(
+            datetime.datetime(2010, 1, 1, 21, 0))
 
-    def test_last_change_in_empty_repository(self, vcsbackend):
+    def test_last_change_in_empty_repository(self, vcsbackend, local_dt_to_utc):
         delta = datetime.timedelta(seconds=1)
-        start = datetime.datetime.now()
+
+        start = local_dt_to_utc(datetime.datetime.now())
         empty_repo = vcsbackend.create_repo()
-        now = datetime.datetime.now()
+        now = local_dt_to_utc(datetime.datetime.now())
         assert empty_repo.last_change >= start - delta
         assert empty_repo.last_change <= now + delta
 
     def test_repo_equality(self):
         assert self.repo == self.repo
 
     def test_repo_equality_broken_object(self):
         import copy
         _repo = copy.copy(self.repo)
         delattr(_repo, 'path')
         assert self.repo != _repo
 
     def test_repo_equality_other_object(self):
         class dummy(object):
             path = self.repo.path
         assert self.repo != dummy()
 
     def test_get_commit_is_implemented(self):
         self.repo.get_commit()
 
     def test_get_commits_is_implemented(self):
         commit_iter = iter(self.repo.get_commits())
         commit = next(commit_iter)
         assert commit.idx == 0
 
     def test_supports_iteration(self):
         repo_iter = iter(self.repo)
         commit = next(repo_iter)
         assert commit.idx == 0
 
     def test_in_memory_commit(self):
         imc = self.repo.in_memory_commit
         assert isinstance(imc, BaseInMemoryCommit)
 
     @pytest.mark.backends("hg")
     def test__get_url_unicode(self):
         url = u'/home/repos/malmö'
         assert self.repo._get_url(url)
 
 
 class TestDeprecatedRepositoryAPI(BackendTestMixin):
     recreate_repo_per_test = False
 
     def test_revisions_is_deprecated(self):
         def get_revisions(repo):
             return repo.revisions
         pytest.deprecated_call(get_revisions, self.repo)
 
     def test_get_changeset_is_deprecated(self):
         pytest.deprecated_call(self.repo.get_changeset)
 
     def test_get_changesets_is_deprecated(self):
         pytest.deprecated_call(self.repo.get_changesets)
 
     def test_in_memory_changeset_is_deprecated(self):
         def get_imc(repo):
             return repo.in_memory_changeset
         pytest.deprecated_call(get_imc, self.repo)
 
 
 # TODO: these tests are incomplete, must check the resulting compare result for
 # correcteness
 class TestRepositoryCompare:
 
     @pytest.mark.parametrize('merge', [True, False])
     def test_compare_commits_of_same_repository(self, vcsbackend, merge):
         target_repo = vcsbackend.create_repo(number_of_commits=5)
         target_repo.compare(
             target_repo[1].raw_id, target_repo[3].raw_id, target_repo,
             merge=merge)
 
     @pytest.mark.xfail_backends('svn')
     @pytest.mark.parametrize('merge', [True, False])
     def test_compare_cloned_repositories(self, vcsbackend, merge):
         target_repo = vcsbackend.create_repo(number_of_commits=5)
         source_repo = vcsbackend.clone_repo(target_repo)
         assert target_repo != source_repo
 
         vcsbackend.add_file(source_repo, 'newfile', 'somecontent')
         source_commit = source_repo.get_commit()
 
         target_repo.compare(
             target_repo[1].raw_id, source_repo[3].raw_id, source_repo,
             merge=merge)
 
     @pytest.mark.xfail_backends('svn')
     @pytest.mark.parametrize('merge', [True, False])
     def test_compare_unrelated_repositories(self, vcsbackend, merge):
         orig = vcsbackend.create_repo(number_of_commits=5)
         unrelated = vcsbackend.create_repo(number_of_commits=5)
         assert orig != unrelated
 
         orig.compare(
             orig[1].raw_id, unrelated[3].raw_id, unrelated, merge=merge)
 
 
 class TestRepositoryGetCommonAncestor:
 
     def test_get_common_ancestor_from_same_repo_existing(self, vcsbackend):
         target_repo = vcsbackend.create_repo(number_of_commits=5)
 
         expected_ancestor = target_repo[2].raw_id
 
         assert target_repo.get_common_ancestor(
             commit_id1=target_repo[2].raw_id,
             commit_id2=target_repo[4].raw_id,
             repo2=target_repo
         ) == expected_ancestor
 
         assert target_repo.get_common_ancestor(
             commit_id1=target_repo[4].raw_id,
             commit_id2=target_repo[2].raw_id,
             repo2=target_repo
         ) == expected_ancestor
 
     @pytest.mark.xfail_backends("svn")
     def test_get_common_ancestor_from_cloned_repo_existing(self, vcsbackend):
         target_repo = vcsbackend.create_repo(number_of_commits=5)
         source_repo = vcsbackend.clone_repo(target_repo)
         assert target_repo != source_repo
 
         vcsbackend.add_file(source_repo, 'newfile', 'somecontent')
         source_commit = source_repo.get_commit()
 
         expected_ancestor = target_repo[4].raw_id
 
         assert target_repo.get_common_ancestor(
             commit_id1=target_repo[4].raw_id,
             commit_id2=source_commit.raw_id,
             repo2=source_repo
         ) == expected_ancestor
 
         assert target_repo.get_common_ancestor(
             commit_id1=source_commit.raw_id,
             commit_id2=target_repo[4].raw_id,
             repo2=target_repo
         ) == expected_ancestor
 
     @pytest.mark.xfail_backends("svn")
     def test_get_common_ancestor_from_unrelated_repo_missing(self, vcsbackend):
         original = vcsbackend.create_repo(number_of_commits=5)
         unrelated = vcsbackend.create_repo(number_of_commits=5)
         assert original != unrelated
 
         assert original.get_common_ancestor(
             commit_id1=original[0].raw_id,
             commit_id2=unrelated[0].raw_id,
             repo2=unrelated
         ) == None
 
         assert original.get_common_ancestor(
             commit_id1=original[-1].raw_id,
             commit_id2=unrelated[-1].raw_id,
             repo2=unrelated
         ) == None
 
 
 @pytest.mark.backends("git", "hg")
 class TestRepositoryMerge:
     def prepare_for_success(self, vcsbackend):
         self.target_repo = vcsbackend.create_repo(number_of_commits=1)
         self.source_repo = vcsbackend.clone_repo(self.target_repo)
         vcsbackend.add_file(self.target_repo, 'README_MERGE1', 'Version 1')
         vcsbackend.add_file(self.source_repo, 'README_MERGE2', 'Version 2')
         imc = self.source_repo.in_memory_commit
         imc.add(FileNode('file_x', content=self.source_repo.name))
         imc.commit(
             message=u'Automatic commit from repo merge test',
             author=u'Automatic')
         self.target_commit = self.target_repo.get_commit()
         self.source_commit = self.source_repo.get_commit()
         # This only works for Git and Mercurial
         default_branch = self.target_repo.DEFAULT_BRANCH_NAME
         self.target_ref = Reference(
             'branch', default_branch, self.target_commit.raw_id)
         self.source_ref = Reference(
             'branch', default_branch, self.source_commit.raw_id)
         self.workspace = 'test-merge'
 
     def prepare_for_conflict(self, vcsbackend):
         self.target_repo = vcsbackend.create_repo(number_of_commits=1)
         self.source_repo = vcsbackend.clone_repo(self.target_repo)
         vcsbackend.add_file(self.target_repo, 'README_MERGE', 'Version 1')
         vcsbackend.add_file(self.source_repo, 'README_MERGE', 'Version 2')
         self.target_commit = self.target_repo.get_commit()
         self.source_commit = self.source_repo.get_commit()
         # This only works for Git and Mercurial
         default_branch = self.target_repo.DEFAULT_BRANCH_NAME
         self.target_ref = Reference(
             'branch', default_branch, self.target_commit.raw_id)
         self.source_ref = Reference(
             'branch', default_branch, self.source_commit.raw_id)
         self.workspace = 'test-merge'
 
     def test_merge_success(self, vcsbackend):
         self.prepare_for_success(vcsbackend)
 
         merge_response = self.target_repo.merge(
             self.target_ref, self.source_repo, self.source_ref, self.workspace,
             'test user', '[e-mail]', 'merge message 1',
             dry_run=False)
         expected_merge_response = MergeResponse(
             True, True, merge_response.merge_ref,
             MergeFailureReason.NONE)
         assert merge_response == expected_merge_response
 
         target_repo = backends.get_backend(vcsbackend.alias)(
             self.target_repo.path)
         target_commits = list(target_repo.get_commits())
         commit_ids = [c.raw_id for c in target_commits[:-1]]
         assert self.source_ref.commit_id in commit_ids
         assert self.target_ref.commit_id in commit_ids
 
         merge_commit = target_commits[-1]
         assert merge_commit.raw_id == merge_response.merge_ref.commit_id
         assert merge_commit.message.strip() == 'merge message 1'
         assert merge_commit.author == 'test user <[e-mail]>'
 
         # We call it twice so to make sure we can handle updates
         target_ref = Reference(
             self.target_ref.type, self.target_ref.name,
             merge_response.merge_ref.commit_id)
 
         merge_response = target_repo.merge(
             target_ref, self.source_repo, self.source_ref, self.workspace,
             'test user', '[e-mail]', 'merge message 2',
             dry_run=False)
         expected_merge_response = MergeResponse(
             True, True, merge_response.merge_ref,
             MergeFailureReason.NONE)
         assert merge_response == expected_merge_response
 
         target_repo = backends.get_backend(
             vcsbackend.alias)(self.target_repo.path)
         merge_commit = target_repo.get_commit(
             merge_response.merge_ref.commit_id)
         assert merge_commit.message.strip() == 'merge message 1'
         assert merge_commit.author == 'test user <[e-mail]>'
 
     def test_merge_success_dry_run(self, vcsbackend):
         self.prepare_for_success(vcsbackend)
 
         merge_response = self.target_repo.merge(
             self.target_ref, self.source_repo, self.source_ref, self.workspace,
             dry_run=True)
 
         # We call it twice so to make sure we can handle updates
         merge_response_update = self.target_repo.merge(
             self.target_ref, self.source_repo, self.source_ref, self.workspace,
             dry_run=True)
 
         # Multiple merges may differ in their commit id. Therefore we set the
         # commit id to `None` before comparing the merge responses.
         merge_response = merge_response._replace(
             merge_ref=merge_response.merge_ref._replace(commit_id=None))
         merge_response_update = merge_response_update._replace(
             merge_ref=merge_response_update.merge_ref._replace(commit_id=None))
 
         assert merge_response == merge_response_update
         assert merge_response.possible is True
         assert merge_response.executed is False
         assert merge_response.merge_ref
         assert merge_response.failure_reason is MergeFailureReason.NONE
 
     @pytest.mark.parametrize('dry_run', [True, False])
     def test_merge_conflict(self, vcsbackend, dry_run):
         self.prepare_for_conflict(vcsbackend)
         expected_merge_response = MergeResponse(
             False, False, None, MergeFailureReason.MERGE_FAILED)
 
         merge_response = self.target_repo.merge(
             self.target_ref, self.source_repo, self.source_ref, self.workspace,
             'test_user', '[e-mail]', 'test message', dry_run=dry_run)
         assert merge_response == expected_merge_response
 
         # We call it twice so to make sure we can handle updates
         merge_response = self.target_repo.merge(
             self.target_ref, self.source_repo, self.source_ref, self.workspace,
             'test_user', '[e-mail]', 'test message', dry_run=dry_run)
         assert merge_response == expected_merge_response
 
     def test_merge_target_is_not_head(self, vcsbackend):
         self.prepare_for_success(vcsbackend)
         expected_merge_response = MergeResponse(
             False, False, None, MergeFailureReason.TARGET_IS_NOT_HEAD)
 
         target_ref = Reference(
             self.target_ref.type, self.target_ref.name, '0' * 40)
 
         merge_response = self.target_repo.merge(
             target_ref, self.source_repo, self.source_ref, self.workspace,
             dry_run=True)
 
         assert merge_response == expected_merge_response
 
     def test_merge_missing_source_reference(self, vcsbackend):
         self.prepare_for_success(vcsbackend)
         expected_merge_response = MergeResponse(
             False, False, None, MergeFailureReason.MISSING_SOURCE_REF)
 
         source_ref = Reference(
             self.source_ref.type, 'not_existing', self.source_ref.commit_id)
 
         merge_response = self.target_repo.merge(
             self.target_ref, self.source_repo, source_ref, self.workspace,
             dry_run=True)
 
         assert merge_response == expected_merge_response
 
     def test_merge_raises_exception(self, vcsbackend):
         self.prepare_for_success(vcsbackend)
         expected_merge_response = MergeResponse(
             False, False, None, MergeFailureReason.UNKNOWN)
 
         with mock.patch.object(self.target_repo, '_merge_repo',
                                side_effect=RepositoryError()):
             merge_response = self.target_repo.merge(
                 self.target_ref, self.source_repo, self.source_ref,
                 self.workspace, dry_run=True)
 
         assert merge_response == expected_merge_response
 
     def test_merge_invalid_user_name(self, vcsbackend):
         repo = vcsbackend.create_repo(number_of_commits=1)
         ref = Reference('branch', 'master', 'not_used')
         with pytest.raises(ValueError):
             repo.merge(ref, self, ref, 'workspace_id')
 
     def test_merge_invalid_user_email(self, vcsbackend):
         repo = vcsbackend.create_repo(number_of_commits=1)
         ref = Reference('branch', 'master', 'not_used')
         with pytest.raises(ValueError):
             repo.merge(ref, self, ref, 'workspace_id', 'user name')
 
     def test_merge_invalid_message(self, vcsbackend):
         repo = vcsbackend.create_repo(number_of_commits=1)
         ref = Reference('branch', 'master', 'not_used')
         with pytest.raises(ValueError):
             repo.merge(
                 ref, self, ref, 'workspace_id', 'user name', '[e-mail]')
 
 
 class TestRepositoryStrip(BackendTestMixin):
     recreate_repo_per_test = True
 
     @classmethod
     def _get_commits(cls):
         commits = [
             {
                 'message': 'Initial commit',
                 'author': 'Joe Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 20),
                 'branch': 'master',
                 'added': [
                     FileNode('foobar', content='foobar'),
                     FileNode('foobar2', content='foobar2'),
                 ],
             },
         ]
         for x in xrange(10):
             commit_data = {
                 'message': 'Changed foobar - commit%s' % x,
                 'author': 'Jane Doe <[e-mail]>',
                 'date': datetime.datetime(2010, 1, 1, 21, x),
                 'branch': 'master',
                 'changed': [
                     FileNode('foobar', 'FOOBAR - %s' % x),
                 ],
             }
             commits.append(commit_data)
         return commits
 
     @pytest.mark.backends("git", "hg")
     def test_strip_commit(self):
         tip = self.repo.get_commit()
         assert tip.idx == 10
         self.repo.strip(tip.raw_id, self.repo.DEFAULT_BRANCH_NAME)
 
         tip = self.repo.get_commit()
         assert tip.idx == 9
 
     @pytest.mark.backends("git", "hg")
     def test_strip_multiple_commits(self):
         tip = self.repo.get_commit()
         assert tip.idx == 10
 
         old = self.repo.get_commit(commit_idx=5)
         self.repo.strip(old.raw_id, self.repo.DEFAULT_BRANCH_NAME)
 
         tip = self.repo.get_commit()
         assert tip.idx == 4
 
 
 @pytest.mark.backends('hg', 'git')
 class TestRepositoryPull:
 
     def test_pull(self, vcsbackend):
         source_repo = vcsbackend.repo
         target_repo = vcsbackend.create_repo()
         assert len(source_repo.commit_ids) > len(target_repo.commit_ids)
 
         target_repo.pull(source_repo.path)
         # Note: Get a fresh instance, avoids caching trouble
         target_repo = vcsbackend.backend(target_repo.path)
         assert len(source_repo.commit_ids) == len(target_repo.commit_ids)
 
     def test_pull_wrong_path(self, vcsbackend):
         target_repo = vcsbackend.create_repo()
         with pytest.raises(RepositoryError):
             target_repo.pull(target_repo.path + "wrong")
 
     def test_pull_specific_commits(self, vcsbackend):
         source_repo = vcsbackend.repo
         target_repo = vcsbackend.create_repo()
 
         second_commit = source_repo[1].raw_id
         if vcsbackend.alias == 'git':
             second_commit_ref = 'refs/test-refs/a'
             source_repo.set_refs(second_commit_ref, second_commit)
 
         target_repo.pull(source_repo.path, commit_ids=[second_commit])
         target_repo = vcsbackend.backend(target_repo.path)
         assert 2 == len(target_repo.commit_ids)
         assert second_commit == target_repo.get_commit().raw_id