Ejemplo n.º 1
0
def test_overwrite_filelocking():
    path = 'tests/fixtures/empty_repo.conf'
    mocked_path = MagicMock()
    mocked_path.__str__ = lambda x: path

    mocked_fcntl = MagicMock()
    mocked_open = MagicMock()

    with patch('pyolite.repo.open', mocked_open, create=True):
        manager = mocked_open.return_value.__enter__.return_value

        # asserts file locking has been put in place before writing
        manager.write = lambda text: ([
            mocked_fcntl.flock.assert_called_once_with(manager, mocked_fcntl.
                                                       LOCK_EX),
            mocked_fcntl.reset_mock()
        ])

        with patch.multiple('pyolite.repo', fcntl=mocked_fcntl):
            repo = Repo(path)

            mocked_fcntl.reset_mock()
            repo.overwrite('some_text')

            # asserts lock has been removed after writing
            mocked_fcntl.flock.assert_called_once_with(manager,
                                                       mocked_fcntl.LOCK_UN)
Ejemplo n.º 2
0
  def test_if_we_commit_after_a_key_append(self):
    key_path = "tests/fixtures/simple_key.pub"

    mock_file = MagicMock()
    mock_file.__str__ = lambda x: key_path
    mock_path = MagicMock(return_value=mock_file)

    mock_hashlib = MagicMock()
    mock_hashlib.md5.hexdigest.return_value = "HASH"

    mock_user = MagicMock()
    mock_user.path = "path"
    mock_user.name = "test"

    with patch.multiple('models.lists.keys', Path=mock_path,
                        hashlib=mock_hashlib):
      keys = ListKeys(mock_user)

      keys.append(key_path)

    mock_path.has_calls([
        call("path", key_path),
        call("path", "keydir", "HASH"),
        call(mock_file, "test"),
    ])

    eq_(mock_file.isfile.call_count, 1)
    eq_(mock_file.mkdir.call_count, 1)
    mock_file.write_file.assert_called_once_with('nothing to see here\n')
Ejemplo n.º 3
0
def test_overwrite_filelocking():
    path = 'tests/fixtures/empty_repo.conf'
    mocked_path = MagicMock()
    mocked_path.__str__ = lambda x: path

    mocked_fcntl = MagicMock()
    mocked_open = MagicMock()

    with patch('pyolite.repo.open', mocked_open, create=True):
        manager = mocked_open.return_value.__enter__.return_value

        # asserts file locking has been put in place before writing
        manager.write = lambda text: ([
            mocked_fcntl.flock.assert_called_once_with(
                manager, mocked_fcntl.LOCK_EX
            ),
            mocked_fcntl.reset_mock()
        ])

        with patch.multiple('pyolite.repo', fcntl=mocked_fcntl):
            repo = Repo(path)

            mocked_fcntl.reset_mock()
            repo.overwrite('some_text')

            # asserts lock has been removed after writing
            mocked_fcntl.flock.assert_called_once_with(manager,
                                                       mocked_fcntl.LOCK_UN)
Ejemplo n.º 4
0
def test_users_filelocking():
    path = 'tests/fixtures/repo_users.conf'
    mocked_path = MagicMock()
    mocked_path.__str__ = lambda x: path

    mocked_path.exists.return_value = True

    mocked_re = MagicMock()
    mocked_fcntl = MagicMock()
    mocked_open = MagicMock()

    with patch('pyolite.repo.open', mocked_open, create=True):
        manager = mocked_open.return_value.__enter__.return_value

        # asserts file locking has been put in place before reading
        manager.read = lambda: ([
            mocked_fcntl.flock.assert_called_once_with(
                manager, mocked_fcntl.LOCK_EX
            ),
            mocked_fcntl.reset_mock()
        ])

        with patch.multiple('pyolite.repo', re=mocked_re,
                            fcntl=mocked_fcntl):
            repo = Repo(mocked_path)

            mocked_fcntl.reset_mock()
            repo.users

            # asserts lock has been removed after reading
            mocked_fcntl.flock.assert_called_once_with(manager,
                                                       mocked_fcntl.LOCK_UN)
Ejemplo n.º 5
0
  def test_it_should_add_a_new_user_to_repo_if_is_valid(self):
    mocked_repo = MagicMock()
    mocked_repository = MagicMock()
    mocked_user = MagicMock()

    mock_single_user = MagicMock()
    mock_single_user.name = 'another_user'
    mock_single_user.__str__ = lambda x: 'another_user'

    mocked_repository.name = 'test_repo'
    mocked_repository.path = 'path'

    mocked_user.get.return_value = mock_single_user
    mocked_repo.users = ['user']

    with patch.multiple('models.lists.users',
                        Repo=MagicMock(return_value=mocked_repo),
                        User=mocked_user):
      repo_users = ListUsers(mocked_repository)
      repo_users.add('test', 'RW+')

      content = '    RW+     =    another_user\n'
      mocked_repo.write.assert_called_once_with(content)

      message = 'User another_user added to repo test_repo ' \
                'with permissions: RW+'
      mocked_repository.git.commit.has_calls([call(['conf'], message)])
Ejemplo n.º 6
0
  def test_user_removing(self):
    mocked_repo = MagicMock()
    mocked_repository = MagicMock()
    mocked_user = MagicMock()

    mock_single_user = MagicMock()
    mock_single_user.name = 'another_user'
    mock_single_user.__str__ = lambda x: 'another_user'

    mocked_repository.name = 'test_repo'
    mocked_repository.path = 'path'

    mocked_user.get.return_value = mock_single_user
    mocked_repo.users = ['user']

    with patch.multiple('models.lists.users',
                        Repo=MagicMock(return_value=mocked_repo),
                        User=mocked_user):
      repo_users = ListUsers(mocked_repository)
      repo_users.remove('test')

      pattern = r'(\s*)([RW+DC]*)(\s*)=(\s*)%s' % 'another_user'
      mocked_repo.replace.assert_called_once_with(pattern, "")

      message = "Deleted user another_user from repository test_repo"
      mocked_repository.git.commit.has_calls([call(['conf'], message)])
Ejemplo n.º 7
0
def test_it_should_commit_if_a_new_repository_was_succesfully_created():
    mocked_repository = MagicMock()

    mocked_file = MagicMock()
    mocked_file.__str__ = lambda x: 'dont_exists'

    mocked_file.exists.return_value = False
    mocked_path.return_value = mocked_file

    mocked_repository.return_value = 'new repo'

    RepositoryManager.__bases__ = (MockManager, )

    with patch.multiple('pyolite.managers.repository',
                        Path=mocked_path,
                        Repository=mocked_repository):
        repos = RepositoryManager('/path/to/admin/repo/')
        repo = repos.create('dont_exists')

        mocked_path.has_calls(call(mocked_path, 'conf/repos/dont_exists.conf'))
        assert mocked_file.exists.call_count == 1
        mocked_file.write_file.assert_called_once_with('repo dont_exists\n')
        mocked_git.commit.has_calls(
            call(['dont_exists'], 'Created repo dont_exists'))
        mocked_repository.assert_called_once_with('dont_exists', mocked_path,
                                                  mocked_git)
        assert repo == 'new repo'
Ejemplo n.º 8
0
    def test_it_should_add_a_new_user_to_repo_if_is_valid(self):
        mocked_repo = MagicMock()
        mocked_repository = MagicMock()
        mocked_user = MagicMock()

        mock_single_user = MagicMock()
        mock_single_user.name = 'another_user'
        mock_single_user.__str__ = lambda x: 'another_user'

        mocked_repository.name = 'test_repo'
        mocked_repository.path = 'path'

        mocked_user.get.return_value = mock_single_user
        mocked_repo.users = ['user']

        with patch.multiple('pyolite.models.lists.users',
                            Repo=MagicMock(return_value=mocked_repo),
                            User=mocked_user):
            repo_users = ListUsers(mocked_repository)
            repo_users.add('test', 'RW+')

            content = '    RW+     =    another_user\n'
            mocked_repo.write.assert_called_once_with(content)

            message = 'User another_user added to repo test_repo ' \
                      'with permissions: RW+'
            mocked_repository.git.commit.has_calls([call(['conf'], message)])
Ejemplo n.º 9
0
    def test_user_removing(self):
        mocked_repo = MagicMock()
        mocked_repository = MagicMock()
        mocked_user = MagicMock()

        mock_single_user = MagicMock()
        mock_single_user.name = 'another_user'
        mock_single_user.__str__ = lambda x: 'another_user'

        mocked_repository.name = 'test_repo'
        mocked_repository.path = 'path'

        mocked_user.get.return_value = mock_single_user
        mocked_repo.users = ['user']

        with patch.multiple('pyolite.models.lists.users',
                            Repo=MagicMock(return_value=mocked_repo),
                            User=mocked_user):
            repo_users = ListUsers(mocked_repository)
            repo_users.remove('test')

            pattern = r'(\s*)([RW+DC]*)(\s*)=(\s*)%s' % 'another_user'
            mocked_repo.replace.assert_called_once_with(pattern, "")

            message = "Deleted user another_user from repository test_repo"
            mocked_repository.git.commit.has_calls([call(['conf'], message)])
Ejemplo n.º 10
0
  def test_get_all_users(self):
    mocked_key_dir = MagicMock()
    mocked_file = MagicMock()
    mocked_dir = MagicMock()
    mocked_re = MagicMock()

    mocked_user = MagicMock()
    mocked_user.get_by_name.return_value = 'test_user'

    mocked_path.return_value = mocked_key_dir
    mocked_dir.isdir.return_value = True
    mocked_file.isdir.return_value = False
    mocked_file.__str__ = lambda x: 'ok_file'

    mocked_re.compile().findall.return_value = ['file1.pub']

    mocked_key_dir.walk.return_value = [mocked_file, mocked_dir]

    UserManager.__bases__ = (MockManager, )
    with patch.multiple('pyolite.managers.user', User=mocked_user,
                        Path=mocked_path, re=mocked_re):
      users = UserManager('~/path/to/admin/gitolite/repo')

      eq_(users.all(), ['test_user'])
      mocked_path.has_calls([call(mocked_path, 'keydir')])
      eq_(mocked_key_dir.walk.call_count, 1)
      eq_(mocked_dir.isdir.call_count, 1)
      eq_(mocked_file.isdir.call_count, 1)

      mocked_re.compile.has_calls([call('(\w.pub)')])
      mocked_re.compile('\w.pub').findall.assert_called_once_with('ok_file')

      mocked_user.get_by_name.assert_called_once_with('file1', mocked_path,
                                                      mocked_git)
Ejemplo n.º 11
0
    def test_user_edit_invalid_permissions(self):
        mocked_repo = MagicMock()
        mocked_repository = MagicMock()
        mocked_user = MagicMock()

        mock_single_user = MagicMock()
        mock_single_user.name = 'another_user'
        mock_single_user.__str__ = lambda x: 'another_user'

        mocked_repository.name = 'test_repo'
        mocked_repository.path = 'path'

        mocked_user.get.return_value = mock_single_user
        mocked_repo.users = ['another_user']

        with patch.multiple('pyolite.models.lists.users',
                            Repo=MagicMock(return_value=mocked_repo),
                            User=mocked_user):
            repo_users = ListUsers(mocked_repository)
            repo_users.edit('test', 'X')

            pattern = r'(\s*)([RW+DC]*)(\s*)=(\s*)%s' % 'another_user'
            string = r"\n    %s    =    %s" % ('X', 'another_user')
            mocked_repo.replace.assert_called_once_with(pattern, string)

            message = "User another_user edit invalid permission for repository test_repo"
            mocked_repository.git.commit.has_calls([call(['conf'], message)])
Ejemplo n.º 12
0
  def test_it_should_commit_if_a_new_repository_was_succesfully_created(self):
    mocked_repository = MagicMock()

    mocked_file = MagicMock()
    mocked_file.__str__ = lambda x: 'dont_exists'

    mocked_file.exists.return_value = False
    mocked_path.return_value = mocked_file

    mocked_repository.return_value = 'new repo'

    RepositoryManager.__bases__ = (MockManager, )

    with patch.multiple('managers.repository',
                        Path=mocked_path,
                        Repository=mocked_repository):
      repos = RepositoryManager('/path/to/admin/repo/')
      repo = repos.create('dont_exists')

      mocked_path.has_calls(call(mocked_path,
                                 'conf/repos/dont_exists.conf'))
      eq_(mocked_file.exists.call_count, 1)
      mocked_file.write_file.assert_called_once_with('repo dont_exists\n')
      mocked_git.commit.has_calls(call(['dont_exists'],
                                       'Created repo dont_exists'))
      mocked_repository.assert_called_once_with('dont_exists', mocked_path,
                                                mocked_git)
      eq_(repo, 'new repo')
Ejemplo n.º 13
0
def test_users_filelocking():
    path = 'tests/fixtures/repo_users.conf'
    mocked_path = MagicMock()
    mocked_path.__str__ = lambda x: path
    mocked_path.exists.return_value = True

    mocked_re = MagicMock()
    mocked_re.return_value = 'another_text'
    mocked_re.finditer.return_value = []
    mocked_fcntl = MagicMock()
    mocked_open = MagicMock()

    with patch('pyolite.abstracts.config.open', mocked_open, create=True):
        manager = mocked_open.return_value.__enter__.return_value

        # asserts file locking has been put in place before reading
        manager.read = lambda: ([
            mocked_fcntl.assert_called_once_with(manager, fcntl.LOCK_EX),
            mocked_fcntl.reset_mock()
        ])

        repo = Repo(mocked_path)
        with patch.object(repo, 'regex',
                          mocked_re), patch('fcntl.flock', mocked_fcntl):
            mocked_fcntl.reset_mock()
            repo.objects
            # asserts lock has been removed after reading
            mocked_fcntl.assert_called_once_with(manager, fcntl.LOCK_UN)
Ejemplo n.º 14
0
def test_users_filelocking():
    path = 'tests/fixtures/repo_users.conf'
    mocked_path = MagicMock()
    mocked_path.__str__ = lambda x: path

    mocked_path.exists.return_value = True

    mocked_re = MagicMock()
    mocked_fcntl = MagicMock()
    mocked_open = MagicMock()

    with patch('pyolite.repo.open', mocked_open, create=True):
        manager = mocked_open.return_value.__enter__.return_value

        # asserts file locking has been put in place before reading
        manager.read = lambda: ([
            mocked_fcntl.flock.assert_called_once_with(manager, mocked_fcntl.
                                                       LOCK_EX),
            mocked_fcntl.reset_mock()
        ])

        with patch.multiple('pyolite.repo', re=mocked_re, fcntl=mocked_fcntl):
            repo = Repo(mocked_path)

            mocked_fcntl.reset_mock()
            repo.users

            # asserts lock has been removed after reading
            mocked_fcntl.flock.assert_called_once_with(manager,
                                                       mocked_fcntl.LOCK_UN)
Ejemplo n.º 15
0
def test_get_all_users():
    mocked_key_dir = MagicMock()
    mocked_file = MagicMock()
    mocked_dir = MagicMock()
    mocked_re = MagicMock()

    mocked_user = MagicMock()
    mocked_user.get_by_name.return_value = 'test_user'

    mocked_path.return_value = mocked_key_dir
    mocked_dir.isdir.return_value = True
    mocked_file.isdir.return_value = False
    mocked_file.__str__ = lambda x: 'ok_file'

    mocked_re.compile().findall.return_value = ['file1.pub']

    mocked_key_dir.walk.return_value = [mocked_file, mocked_dir]

    UserManager.__bases__ = (MockManager,)
    with patch.multiple('pyolite.managers.user', User=mocked_user,
                        Path=mocked_path, re=mocked_re):
        users = UserManager('~/path/to/admin/gitolite/repo')

        assert users.all() == ['test_user']
        mocked_path.has_calls([call(mocked_path, 'keydir')])
        assert mocked_key_dir.walk.call_count == 1
        assert mocked_dir.isdir.call_count == 1
        assert mocked_file.isdir.call_count == 1

        mocked_re.compile.has_calls([call(r'(\w.pub)')])
        mocked_re.compile('\w.pub').findall.assert_called_once_with(r'ok_file')

        mocked_user.get_by_name.assert_called_once_with('file1', mocked_path, mocked_git)
Ejemplo n.º 16
0
    def test_if_we_commit_after_a_key_append(self):
        key_path = "tests/fixtures/simple_key.pub"

        mock_file = MagicMock()
        mock_file.__str__ = lambda x: key_path
        mock_path = MagicMock(return_value=mock_file)

        mock_hashlib = MagicMock()
        mock_hashlib.md5.hexdigest.return_value = "HASH"

        mock_user = MagicMock()
        mock_user.path = "path"
        mock_user.name = "test"

        with patch.multiple('models.lists.keys',
                            Path=mock_path,
                            hashlib=mock_hashlib):
            keys = ListKeys(mock_user)

            keys.append(key_path)

        mock_path.has_calls([
            call("path", key_path),
            call("path", "keydir", "HASH"),
            call(mock_file, "test"),
        ])

        eq_(mock_file.isfile.call_count, 1)
        eq_(mock_file.mkdir.call_count, 1)
        mock_file.write_file.assert_called_once_with('nothing to see here\n')
Ejemplo n.º 17
0
    def test_list_remove(self):
        key = "my_awesome_key"

        mock_file = MagicMock()
        mock_file.__str__ = lambda x: key
        mock_file.exists.return_value = True
        mock_path = MagicMock(return_value=mock_file)

        mock_hashlib = MagicMock()
        mock_hashlib.md5.hexdigest.return_value = "HASH"

        mock_user = MagicMock()
        mock_user.path = "path"
        mock_user.name = "test"

        with patch.multiple('models.lists.keys',
                            Path=mock_path,
                            hashlib=mock_hashlib):
            keys = ListKeys(mock_user)

            keys.remove(key)

            mock_path.has_calls([
                call("path", 'keydir', 'HASH'),
                call(mock_file, "test.pub"),
            ])

            commit_message = "Removed key for user test"
            mock_user.git.commit.has_calls(
                [call(["my_awesome_key"], commit_message, action='remove')])
Ejemplo n.º 18
0
  def test_list_remove(self):
    key = "my_awesome_key"

    mock_file = MagicMock()
    mock_file.__str__ = lambda x: key
    mock_file.exists.return_value = True
    mock_path = MagicMock(return_value=mock_file)

    mock_hashlib = MagicMock()
    mock_hashlib.md5.hexdigest.return_value = "HASH"

    mock_user = MagicMock()
    mock_user.path = "path"
    mock_user.name = "test"

    with patch.multiple('models.lists.keys', Path=mock_path,
                        hashlib=mock_hashlib):
      keys = ListKeys(mock_user)

      keys.remove(key)

      mock_path.has_calls([
          call("path", 'keydir', 'HASH'),
          call(mock_file, "test.pub"),
      ])

      commit_message = "Removed key for user test"
      mock_user.git.commit.has_calls([call(["my_awesome_key"],
                                           commit_message,
                                           action='remove')])
Ejemplo n.º 19
0
  def test_user_edit_permissions(self):
    mocked_repo = MagicMock()
    mocked_repository = MagicMock()
    mocked_user = MagicMock()

    mock_single_user = MagicMock()
    mock_single_user.name = 'another_user'
    mock_single_user.__str__ = lambda x: 'another_user'

    mocked_repository.name = 'test_repo'
    mocked_repository.path = 'path'

    mocked_user.get.return_value = mock_single_user
    mocked_repo.users = ['user']

    with patch.multiple('models.lists.users',
                        Repo=MagicMock(return_value=mocked_repo),
                        User=mocked_user):
      repo_users = ListUsers(mocked_repository)
      repo_users.edit('test', 'R')

      pattern = r'(\s*)([RW+DC]*)(\s*)=(\s*)%s' % 'another_user'
      string = r"\n    %s    =    %s" % ('R', 'another_user')
      mocked_repo.replace.assert_called_once_with(pattern, string)

      message = "User another_user has R permission for repository test_repo"
      mocked_repository.git.commit.has_calls([call(['conf'], message)])
Ejemplo n.º 20
0
def test_it_should_not_be_valid_a_repo_starting_with_the_same_name():
    mocked_users = MagicMock()
    mocked_file = MagicMock()
    mocked_dir = MagicMock()
    mocked_path = MagicMock()

    mocked_dir.isdir.return_value = True
    mocked_file.isdir.return_value = False
    mocked_file.__str__ = lambda x: 'tests/fixtures/almost_get_repo_by_name.conf'

    mocked_path.walk.return_value = [mocked_file, mocked_dir]

    with patch.multiple('pyolite.models.repository',
                        Path=MagicMock(return_value=mocked_path),
                        ListUsers=MagicMock(return_value=mocked_users)):
        assert Repository.get_by_name('new_one', 'simple_path', 'git') is None
Ejemplo n.º 21
0
    def _create_logger_mock(self):
        logger_instance = self._runner.testCreate()
        logger_ext = logger_instance.extension

        underlying_logger_mock = MagicMock()
        logger_ext._underlying_logger = underlying_logger_mock
        logger_ext._underlying_logger.return_value = None

        format_mock = MagicMock(return_value='format_mock')
        # do not verify number of conversions to string
        format_mock.__str__ = MagicMock(return_value='format_mock')
        format_mock.__unicode__ = MagicMock(return_value='format_mock')

        logger_ext._format_without_exceptions = format_mock

        return logger_instance, format_mock, underlying_logger_mock
Ejemplo n.º 22
0
    def _create_logger_mock(self):
        logger_instance = self._runner.testCreate()
        logger_ext = logger_instance.extension

        underlying_logger_mock = MagicMock()
        logger_ext._underlying_logger = underlying_logger_mock
        logger_ext._underlying_logger.return_value = None

        format_mock = MagicMock(return_value='format_mock')
        # do not verify number of conversions to string
        format_mock.__str__ = MagicMock(return_value='format_mock')
        format_mock.__unicode__ = MagicMock(return_value='format_mock')

        logger_ext._format_without_exceptions = format_mock

        return logger_instance, format_mock, underlying_logger_mock
Ejemplo n.º 23
0
def test_it_should_retrieve_all_users_from_repo():
    path = 'tests/fixtures/repo_users.conf'
    mocked_path = MagicMock()
    mocked_path.__str__ = lambda x: path

    mocked_path.exists.return_value = True

    mocked_re = MagicMock()
    mocked_user1 = MagicMock()
    mocked_user2 = MagicMock()

    mocked_re.finditer.return_value = [mocked_user1, mocked_user2]
    mocked_user1.group.return_value = 'user1'
    mocked_user2.group.return_value = 'user2'

    repo = Repo(mocked_path)
    with patch.object(repo, 'regex', mocked_re):
        assert repo.objects == ['user1', 'user2']
Ejemplo n.º 24
0
def test_it_should_retrieve_all_users_from_repo():
    path = 'tests/fixtures/repo_users.conf'
    mocked_path = MagicMock()
    mocked_path.__str__ = lambda x: path

    mocked_path.exists.return_value = True

    mocked_re = MagicMock()
    mocked_user1 = MagicMock()
    mocked_user2 = MagicMock()

    mocked_re.compile('=( *)(\w+)').finditer.return_value = [mocked_user1,
                                                             mocked_user2]
    mocked_user1.group.return_value = 'user1'
    mocked_user2.group.return_value = 'user2'

    with patch.multiple('pyolite.repo', re=mocked_re):
        repo = Repo(mocked_path)
        assert repo.users == ['user1', 'user2']
Ejemplo n.º 25
0
  def test_it_should_retrieve_all_users_from_repo(self):
    path = 'tests/fixtures/repo_users.conf'
    mocked_path = MagicMock()
    mocked_path.__str__ = lambda x: path

    mocked_path.exists.return_value = True

    mocked_re = MagicMock()
    mocked_user1 = MagicMock()
    mocked_user2 = MagicMock()

    mocked_re.compile('=( *)(\w+)').finditer.return_value = [mocked_user1,
                                                             mocked_user2]
    mocked_user1.group.return_value = 'user1'
    mocked_user2.group.return_value = 'user2'

    with patch.multiple('repo', re=mocked_re):
      repo = Repo(mocked_path)
      eq_(repo.users, ['user1', 'user2'])
Ejemplo n.º 26
0
def test_it_should_be_possible_to_retrieve_by_name_a_repo():
    mocked_users = MagicMock()
    mocked_file = MagicMock()
    mocked_dir = MagicMock()
    mocked_path = MagicMock()

    mocked_dir.isdir.return_value = True
    mocked_file.isdir.return_value = False
    mocked_file.__str__ = lambda x: 'tests/fixtures/get_repo_by_name.conf'

    mocked_path.walk.return_value = [mocked_file, mocked_dir]

    with patch.multiple('pyolite.models.repository',
                        Path=MagicMock(return_value=mocked_path),
                        ListUsers=MagicMock(return_value=mocked_users)):
        repo = Repository.get_by_name('new_one', 'simple_path', 'git')

        assert repo.name == 'new_one'
        assert repo.path == 'simple_path'
        assert repo.git == 'git'
        assert repo.users == mocked_users
Ejemplo n.º 27
0
    def test_it_should_be_possible_to_retrieve_by_name_a_repo(self):
        mocked_users = MagicMock()
        mocked_file = MagicMock()
        mocked_dir = MagicMock()
        mocked_path = MagicMock()

        mocked_dir.isdir.return_value = True
        mocked_file.isdir.return_value = False
        mocked_file.__str__ = lambda x: 'tests/fixtures/get_repo_by_name.conf'

        mocked_path.walk.return_value = [mocked_file, mocked_dir]

        with patch.multiple('pyolite.models.repository',
                                                Path=MagicMock(return_value=mocked_path),
                                                ListUsers=MagicMock(return_value=mocked_users)):
            repo = Repository.get_by_name('new_one', 'simple_path', 'git')

            eq_(repo.name, 'new_one')
            eq_(repo.path, 'simple_path')
            eq_(repo.git, 'git')
            eq_(repo.users, mocked_users)
Ejemplo n.º 28
0
    def test_it_should_commit_if_a_new_repository_was_succesfully_created(self):
        mocked_repository = MagicMock()

        mocked_file = MagicMock()
        mocked_file.__str__ = lambda x: "dont_exists"

        mocked_file.exists.return_value = False
        mocked_path.return_value = mocked_file

        mocked_repository.return_value = "new repo"

        RepositoryManager.__bases__ = (MockManager,)

        with patch.multiple("pyolite.managers.repository", Path=mocked_path, Repository=mocked_repository):
            repos = RepositoryManager("/path/to/admin/repo/")
            repo = repos.create("dont_exists")

            mocked_path.has_calls(call(mocked_path, "conf/repos/dont_exists.conf"))
            eq_(mocked_file.exists.call_count, 1)
            mocked_file.write_file.assert_called_once_with("repo dont_exists\n")
            mocked_git.commit.has_calls(call(["dont_exists"], "Created repo dont_exists"))
            mocked_repository.assert_called_once_with("dont_exists", mocked_path, mocked_git)
            eq_(repo, "new repo")