Merge branch 'bugfix/conftest_fix' into devel

Author: guyzmo

.travis.yml

@@ -1,12 +1,40 @@
 language: python
-python:
-    - "3.4"
-    - "3.5"
-    - "3.5-dev" # 3.5 development branch
+matrix:
+  include:
+    - os: linux
+      python: "3.4"
+    - os: linux
+      python: "3.5"
+    - os: linux
+      python: "3.5-dev"
+    - os: linux
+      python: "3.6-dev"
+    - os: linux
+      python: "nightly"
+    - os: linux
+      python: "pypy3"
+
+    - os: osx
+      sudo: required
+      language: generic
+
+  allow_failures:
+      - python: "3.6-dev"
+      - python: "nightly"
+      - python: "pypy3"
+      - os: "osx"
 addons:
   apt:
     packages:
         - pandoc
+before_install: |
+  if [[ $TRAVIS_OS_NAME == 'osx' ]]; then
+      brew update;
+      brew install python3 pandoc;
+      python3 -m venv venv;
+      source venv/bin/activate;
+      pip install . test
+  fi
 # command to install dependencies
 install:
     - "pip install --upgrade pip" # upgrade to latest pip (needed on py3.4)

tests/conftest.py

@@ -7,49 +7,54 @@
 
 record_mode = 'once'
 
+from git_repo.services.service import RepositoryService
+services = list(RepositoryService.service_map.keys())
+
 if os.environ.get('TRAVIS_GH3'):
     # create default bogus values for tokens and namespaces if missing for pytest
     # to run without environment values
     # also if an environment variable is not set, then we don't want to record cassettes
     record_mode = 'never'
-    for service_name in ('github', 'gitlab', 'bitbucket'):
-        token_name = 'PRIVATE_KEY_{}'.format(service_name.upper())
-        namespace_name = '{}_NAMESPACE'.format(service_name.upper())
+    for service in services:
+        token_name = 'PRIVATE_KEY_{}'.format(service.upper())
+        namespace_name = '{}_NAMESPACE'.format(service.upper())
         if token_name not in os.environ:
-            os.environ[token_name] = 'not_configured:test' # using a : for bitbucket's case
+            os.environ[token_name] = '_namespace_{}_:_private_'.format(service) # using a : for bitbucket's case
         if namespace_name not in os.environ:
-            os.environ[namespace_name] = 'not_configured'
+            os.environ[namespace_name] = '_namespace_{}_'.format(service)
 else:
+    # if running tests "locally" and not in travis, let's try to extract the keys from
+    # the local configuration if there is some local configuration. And exposes them as
+    # environment variables.
     import git, getpass
     config = git.config.GitConfigParser(os.path.join(os.environ['HOME'], '.gitconfig'))
-    conf_section = list(filter(lambda n: 'gitrepo' in n, config.sections()))
-    key_dict = {section.split('"')[1] :config.get_value(section, 'privatekey') for section in conf_section}
-    for service, key in key_dict.items():
+
+    # handle the different forms of token configuration item (yup, technical debt bites here)
+    get_section = lambda s: 'gitrepo "{}"'.format(s)
+    get_token = lambda s: config.get_value(get_section(s), 'token',
+                            config.get_value(get_section(s), 'private_token',
+                                config.get_value(get_section(s), 'privatekey',
+                                        '_namespace_{}_:_private_'.format(s) # using a : for bitbucket's case
+                                    )))
+    # XXX temporary fix that should not be necessary when refactoring with pybitbucket
+    get_default_namespace = lambda s: os.environ[token_name].split(':')[0] if s == 'bitbucket' else '_namespace_{}_'.format(s)
+
+    for service in services:
         token_name = 'PRIVATE_KEY_{}'.format(service.upper())
         namespace_name = '{}_NAMESPACE'.format(service.upper())
-        os.environ[token_name] = key
-        os.environ[namespace_name] = os.environ.get('GITREPO_NAMESPACE', getpass.getuser())
-
-api_token_github = os.environ['PRIVATE_KEY_GITHUB']
-api_token_gitlab = os.environ['PRIVATE_KEY_GITLAB']
-api_token_bitbucket = os.environ['PRIVATE_KEY_BITBUCKET']
-
-github_namespace = os.environ['GITHUB_NAMESPACE']
-gitlab_namespace = os.environ['GITLAB_NAMESPACE']
-bitbucket_namespace = os.environ['BITBUCKET_NAMESPACE']
+        if token_name not in os.environ:
+            os.environ[token_name] = get_token(service)
+        if namespace_name not in os.environ:
+            os.environ[namespace_name] = os.environ.get('GITREPO_NAMESPACE', get_default_namespace(service))
 
 betamax.Betamax.register_serializer(pretty_json.PrettyJSONSerializer)
 
 with betamax.Betamax.configure() as config:
     config.default_cassette_options['record_mode'] = record_mode
     config.cassette_library_dir = 'tests/integration/cassettes'
     config.default_cassette_options['serialize_with'] = 'prettyjson'
-    config.define_cassette_placeholder('<PRIVATE_KEY_GITHUB>', api_token_github)
-    config.define_cassette_placeholder('<PRIVATE_KEY_GITLAB>', api_token_gitlab)
-    config.define_cassette_placeholder('<PRIVATE_KEY_BITBUCKET>', api_token_bitbucket)
-    config.define_cassette_placeholder('<GITHUB_NAMESPACE>', github_namespace)
-    config.define_cassette_placeholder('<GITLAB_NAMESPACE>', gitlab_namespace)
-    config.define_cassette_placeholder('<BITBUCKET_NAMESPACE>', bitbucket_namespace)
-
-
+    # generating placeholders in betamax configuration for each service's key and default namespace
+    for service in services:
+        config.define_cassette_placeholder('<PRIVATE_KEY_{}>'.format(service.upper()), os.environ.get('PRIVATE_KEY_{}'.format(service.upper())))
+        config.define_cassette_placeholder('<{}_NAMESPACE>'.format(service.upper()), os.environ.get('{}_NAMESPACE'.format(service.upper())))
 

tests/helpers.py

@@ -9,6 +9,7 @@
 from contextlib import contextmanager
 
 import os
+import sys
 import logging
 import betamax
 
@@ -378,6 +379,17 @@ def teardown_method(self, method):
         self.log.info('GitRepoTestCase.teardown_method({})'.format(method))
         self.tempdir.cleanup()
 
+    '''cassette name helper'''
+
+    def _make_cassette_name(self):
+        # returns the name of the function calling the function calling this one
+        # in other words, when used in an helper function, returns the name of
+        # the test function calling the helper function, to make a cassette name.
+        test_function_name = sys._getframe(2).f_code.co_name
+        if test_function_name.startswith('test'):
+            return '_'.join(['test', self.service.name, test_function_name])
+        raise Exception("Helpers functions shall be used only within test functions!")
+
     '''popen helper'''
 
     def set_mock_popen_commands(self, cmd_list):
@@ -435,7 +447,7 @@ def assert_tracking_remote(self, remote_name=None, branch_name='master'):
 
     '''test cases templates'''
 
-    def action_fork(self, cassette_name, local_namespace, remote_namespace, repository):
+    def action_fork(self, local_namespace, remote_namespace, repository):
         # hijack subprocess call
         with self.mockup_git(local_namespace, repository):
             # prepare output for git commands
@@ -458,15 +470,15 @@ def action_fork(self, cassette_name, local_namespace, remote_namespace, reposito
                     ' * [new branch]      master     -> {}/master'.format(self.service.name)]).encode('utf-8'),
                 0)
             ])
-            with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+            with self.recorder.use_cassette(self._make_cassette_name()):
                 self.service.connect()
                 self.service.fork(remote_namespace, repository)
                 # emulate the outcome of the git actions
                 self.service.repository.create_remote('upstream', url=remote_slug)
                 self.service.repository.create_remote('all', url=local_slug)
                 self.service.repository.create_remote(self.service.name, url=local_slug)
 
-    def action_fork__no_clone(self, cassette_name, local_namespace, remote_namespace, repository):
+    def action_fork__no_clone(self, local_namespace, remote_namespace, repository):
         # hijack subprocess call
         with self.mockup_git(local_namespace, repository):
             # prepare output for git commands
@@ -489,15 +501,15 @@ def action_fork__no_clone(self, cassette_name, local_namespace, remote_namespace
                     ' * [new branch]      master     -> {}/master'.format(self.service.name)]).encode('utf-8'),
                 0)
             ])
-            with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+            with self.recorder.use_cassette(self._make_cassette_name()):
                 self.service.connect()
                 self.service.fork(remote_namespace, repository)
                 # emulate the outcome of the git actions
                 self.service.repository.create_remote('upstream', url=remote_slug)
                 self.service.repository.create_remote('all', url=local_slug)
                 self.service.repository.create_remote(self.service.name, url=local_slug)
 
-    def action_clone(self, cassette_name, namespace, repository):
+    def action_clone(self, namespace, repository):
         # hijack subprocess call
         with self.mockup_git(namespace, repository):
             local_slug = self.service.format_path(namespace=namespace, repository=repository, rw=True)
@@ -517,30 +529,30 @@ def action_clone(self, cassette_name, namespace, repository):
                     ' * [new branch]      master     -> {}/master'.format(self.service.name)]).encode('utf-8'),
                 0)
             ])
-            with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+            with self.recorder.use_cassette(self._make_cassette_name()):
                 self.service.connect()
                 self.service.clone(namespace, repository)
                 self.service.repository.create_remote('all', url=local_slug)
                 self.service.repository.create_remote(self.service.name, url=local_slug)
 
-    def action_create(self, cassette_name, namespace, repository):
-        with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+    def action_create(self, namespace, repository):
+        with self.recorder.use_cassette(self._make_cassette_name()):
             self.service.connect()
             self.service.create(namespace, repository, add=True)
             #
             self.assert_repository_exists(namespace, repository)
             self.assert_added_remote_defaults()
 
-    def action_create__no_add(self, cassette_name, namespace, repository):
-        with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+    def action_create__no_add(self, namespace, repository):
+        with self.recorder.use_cassette(self._make_cassette_name()):
             self.service.connect()
             self.service.create(namespace, repository, add=False)
             #
             self.assert_repository_exists(namespace, repository)
             self.assert_added_remote_defaults()
 
-    def action_delete(self, cassette_name, repository, namespace=None):
-        with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+    def action_delete(self, repository, namespace=None):
+        with self.recorder.use_cassette(self._make_cassette_name()):
             self.service.connect()
             if namespace:
                 self.service.delete(user=namespace, repo=repository)
@@ -551,8 +563,8 @@ def action_delete(self, cassette_name, repository, namespace=None):
                 namespace = self.service.user
             self.assert_repository_not_exists(namespace, repository)
 
-    def action_add(self, cassette_name, namespace, repository, alone=False, name=None, tracking='master'):
-        with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+    def action_add(self, namespace, repository, alone=False, name=None, tracking='master'):
+        with self.recorder.use_cassette(self._make_cassette_name()):
             # init git in the repository's destination
             self.repository.init()
             self.service.connect()
@@ -583,16 +595,16 @@ def action_add(self, cassette_name, namespace, repository, alone=False, name=Non
                     self.assert_added_remote(name)
                     self.assert_tracking_remote(name, tracking)
 
-    def action_request_list(self, cassette_name, namespace, repository, rq_list_data=[]):
-        with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+    def action_request_list(self, namespace, repository, rq_list_data=[]):
+        with self.recorder.use_cassette(self._make_cassette_name()):
             self.service.connect()
             requests = list(self.service.request_list(user=namespace, repo=repository))
             for i, rq in enumerate(rq_list_data):
                 assert requests[i] == rq
 
-    def action_request_fetch(self, cassette_name, namespace, repository, request, pull=False, fail=False):
+    def action_request_fetch(self, namespace, repository, request, pull=False, fail=False):
         local_slug = self.service.format_path(namespace=namespace, repository=repository, rw=False)
-        with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+        with self.recorder.use_cassette(self._make_cassette_name()):
             with self.mockup_git(namespace, repository):
                 self.set_mock_popen_commands([
                     ('git remote add all {}'.format(local_slug), b'', b'', 0),
@@ -642,7 +654,7 @@ def action_request_fetch(self, cassette_name, namespace, repository, request, pu
                 ])
                 self.service.request_fetch(repository, namespace, request)
 
-    def action_request_create(self, cassette_name,
+    def action_request_create(self,
             namespace, repository, branch,
             title, description,
             create_repository='test_create_requests',
@@ -670,7 +682,7 @@ def action_request_create(self, cassette_name,
 
         So all the contextual work is only done
         '''
-        cassette_name = '_'.join(['test', self.service.name, cassette_name])
+        cassette_name = self._make_cassette_name()
         will_record = 'never' != self.recorder.config.default_cassette_options['record_mode'] \
                 and not os.path.exists(os.path.join(self.recorder.config.cassette_library_dir, cassette_name+'.json'))
 
@@ -713,8 +725,8 @@ def prepare_project_for_test():
                 )
                 return request
 
-    def action_gist_list(self, cassette_name, gist=None, gist_list_data=[]):
-        with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+    def action_gist_list(self, gist=None, gist_list_data=[]):
+        with self.recorder.use_cassette(self._make_cassette_name()):
             self.service.connect()
             if gist is None:
                 gists = list(self.service.gist_list())
@@ -725,7 +737,7 @@ def action_gist_list(self, cassette_name, gist=None, gist_list_data=[]):
                 for i, gf in enumerate(gist_list_data):
                     assert gist_files[i] == gf
 
-    def action_gist_clone(self, cassette_name, gist):
+    def action_gist_clone(self, gist):
         with self.mockup_git(None, None):
             self.set_mock_popen_commands([
                 ('git version', b'git version 2.8.0', b'', 0),
@@ -741,28 +753,28 @@ def action_gist_clone(self, cassette_name, gist):
                     b' * branch            master     -> FETCH_HEAD']),
                 0),
             ])
-            with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+            with self.recorder.use_cassette(self._make_cassette_name()):
                 self.service.connect()
                 self.service.gist_clone(gist)
 
 
-    def action_gist_fetch(self, cassette_name, gist, gist_file=None):
-        with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+    def action_gist_fetch(self, gist, gist_file=None):
+        with self.recorder.use_cassette(self._make_cassette_name()):
             self.service.connect()
             content = self.service.gist_fetch(gist, gist_file)
             return content
 
-    def action_gist_create(self, cassette_name, description, gist_files, secret):
-        with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+    def action_gist_create(self, description, gist_files, secret):
+        with self.recorder.use_cassette(self._make_cassette_name()):
             self.service.connect()
             content = self.service.gist_create(gist_files, description, secret)
 
-    def action_gist_delete(self, cassette_name, gist):
-        with self.recorder.use_cassette('_'.join(['test', self.service.name, cassette_name])):
+    def action_gist_delete(self, gist):
+        with self.recorder.use_cassette(self._make_cassette_name()):
             self.service.connect()
             content = self.service.gist_delete(gist)
 
-    def action_open(self, cassette_name, namespace, repository):
+    def action_open(self, namespace, repository):
         self.set_mock_popen_commands([
             ('xdg-open {}'.format(self.service.format_path(namespace=namespace, repository=repository)), b'', b'', 0),
             ('open {}'.format(self.service.format_path(namespace=namespace, repository=repository)), b'', b'', 0),