示例#1
0
    def test_find_git_honors_git_files(self,
                                       is_git_dir,
                                       is_git_file,
                                       read_git_file):
        git_file = '/the/root/.git'
        worktree = '/the/root'
        git_dir = '/super/module/.git/modules/root'

        is_git_dir.side_effect = lambda x: x == git_file
        is_git_file.side_effect = lambda x: x == git_file
        read_git_file.return_value = git_dir

        paths = git.find_git_directory('/the/root/sub/dir')

        self.assertEqual(git_dir, paths.git_dir)
        self.assertEqual(git_file, paths.git_file)
        self.assertEqual(worktree, paths.worktree)

        kwargs = {}
        self.assertEqual(6, is_git_dir.call_count)
        is_git_dir.assert_has_calls([
            (('/the/root/sub/dir',), kwargs),
            (('/the/root/sub/dir/.git',), kwargs),
            (('/the/root/sub',), kwargs),
            (('/the/root/sub/.git',), kwargs),
            (('/the/root',), kwargs),
            (('/the/root/.git',), kwargs),
        ])
        read_git_file.assert_called_once_with('/the/root/.git')
示例#2
0
def test_find_git_honors_ceiling_dirs(is_git_dir, getenv):

    git_dir = '/ceiling/.git'
    ceiling = '/tmp:/ceiling:/other/ceiling'
    is_git_dir.side_effect = lambda x: x == git_dir

    def mock_getenv(k, v=None):
        if k == 'GIT_CEILING_DIRECTORIES':
            return ceiling
        return v

    getenv.side_effect = mock_getenv

    paths = git.find_git_directory('/ceiling/sub/dir')

    assert paths.git_dir is None
    assert paths.git_file is None
    assert paths.worktree is None
    assert is_git_dir.call_count == 4
    is_git_dir.assert_has_calls([
        (('/ceiling/sub/dir', ), {}),
        (('/ceiling/sub/dir/.git', ), {}),
        (('/ceiling/sub', ), {}),
        (('/ceiling/sub/.git', ), {}),
    ])
示例#3
0
def test_find_git_dir_empty_string(is_git_dir):
    paths = git.find_git_directory('')

    assert not is_git_dir.called
    assert paths.git_dir is None
    assert paths.git_file is None
    assert paths.worktree is None
示例#4
0
    def test_find_git_honors_ceiling_dirs(self, is_git_dir, getenv):

        git_dir = '/ceiling/.git'
        ceiling = '/tmp:/ceiling:/other/ceiling'
        is_git_dir.side_effect = lambda x: x == git_dir

        def mock_getenv(k, v=None):
            if k == 'GIT_CEILING_DIRECTORIES':
                return ceiling
            return v

        getenv.side_effect = mock_getenv

        paths = git.find_git_directory('/ceiling/sub/dir')

        self.assertEqual(None, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(None, paths.worktree)

        self.assertEqual(4, is_git_dir.call_count)
        kwargs = {}
        is_git_dir.assert_has_calls([
            (('/ceiling/sub/dir',), kwargs),
            (('/ceiling/sub/dir/.git',), kwargs),
            (('/ceiling/sub',), kwargs),
            (('/ceiling/sub/.git',), kwargs),
        ])
示例#5
0
def test_find_git_honors_git_files(is_git_dir, is_git_file, read_git_file):
    git_file = '/the/root/.git'
    worktree = '/the/root'
    git_dir = '/super/module/.git/modules/root'

    is_git_dir.side_effect = lambda x: x == git_file
    is_git_file.side_effect = lambda x: x == git_file
    read_git_file.return_value = git_dir

    paths = git.find_git_directory('/the/root/sub/dir')

    assert git_dir == paths.git_dir
    assert git_file == paths.git_file
    assert worktree == paths.worktree

    expect = 6
    actual = is_git_dir.call_count
    assert expect == actual
    is_git_dir.assert_has_calls([
        (('/the/root/sub/dir', ), {}),
        (('/the/root/sub/dir/.git', ), {}),
        (('/the/root/sub', ), {}),
        (('/the/root/sub/.git', ), {}),
        (('/the/root', ), {}),
        (('/the/root/.git', ), {}),
    ])
    read_git_file.assert_called_once_with('/the/root/.git')
示例#6
0
    def test_find_git_honors_ceiling_dirs(self, is_git_dir, getenv):

        git_dir = '/ceiling/.git'
        ceiling = '/tmp:/ceiling:/other/ceiling'
        is_git_dir.side_effect = lambda x: x == git_dir

        def mock_getenv(k, v=None):
            if k == 'GIT_CEILING_DIRECTORIES':
                return ceiling
            return v

        getenv.side_effect = mock_getenv

        paths = git.find_git_directory('/ceiling/sub/dir')

        self.assertEqual(None, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(None, paths.worktree)

        self.assertEqual(4, is_git_dir.call_count)
        kwargs = {}
        is_git_dir.assert_has_calls([
            (('/ceiling/sub/dir',), kwargs),
            (('/ceiling/sub/dir/.git',), kwargs),
            (('/ceiling/sub',), kwargs),
            (('/ceiling/sub/.git',), kwargs),
        ])
示例#7
0
def test_find_git_dir_None(is_git_dir):
    paths = git.find_git_directory(None)

    assert not is_git_dir.called
    assert paths.git_dir is None
    assert paths.git_file is None
    assert paths.worktree is None
示例#8
0
    def test_find_git_honors_git_files(self,
                                       is_git_dir,
                                       is_git_file,
                                       read_git_file):
        git_file = '/the/root/.git'
        worktree = '/the/root'
        git_dir = '/super/module/.git/modules/root'

        is_git_dir.side_effect = lambda x: x == git_file
        is_git_file.side_effect = lambda x: x == git_file
        read_git_file.return_value = git_dir

        paths = git.find_git_directory('/the/root/sub/dir')

        self.assertEqual(git_dir, paths.git_dir)
        self.assertEqual(git_file, paths.git_file)
        self.assertEqual(worktree, paths.worktree)

        kwargs = {}
        self.assertEqual(6, is_git_dir.call_count)
        is_git_dir.assert_has_calls([
            (('/the/root/sub/dir',), kwargs),
            (('/the/root/sub/dir/.git',), kwargs),
            (('/the/root/sub',), kwargs),
            (('/the/root/sub/.git',), kwargs),
            (('/the/root',), kwargs),
            (('/the/root/.git',), kwargs),
        ])
        read_git_file.assert_called_once_with('/the/root/.git')
示例#9
0
    def test_find_git_dir_empty_string(self, is_git_dir):

        paths = git.find_git_directory('')

        self.assertFalse(is_git_dir.called)
        self.assertEqual(None, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(None, paths.worktree)
示例#10
0
    def test_find_git_dir_empty_string(self, is_git_dir):

        paths = git.find_git_directory('')

        self.assertFalse(is_git_dir.called)
        self.assertEqual(None, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(None, paths.worktree)
示例#11
0
    def test_find_git_does_discovery(self, is_git_dir):
        git_dir = '/the/root/.git'
        worktree = '/the/root'
        is_git_dir.side_effect = lambda x: x == git_dir

        paths = git.find_git_directory('/the/root/sub/dir')

        self.assertEqual(git_dir, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(worktree, paths.worktree)
示例#12
0
def test_finds_no_worktree_from_bare_repo(is_git_dir):
    git_dir = '/repos/bare.git'
    worktree = None
    is_git_dir.return_value = True

    paths = git.find_git_directory(git_dir)
    assert is_git_dir.called
    assert git_dir == paths.git_dir
    assert paths.git_file is None
    assert worktree == paths.worktree
示例#13
0
    def test_find_git_does_discovery(self, is_git_dir):
        git_dir = '/the/root/.git'
        worktree = '/the/root'
        is_git_dir.side_effect = lambda x: x == git_dir

        paths = git.find_git_directory('/the/root/sub/dir')

        self.assertEqual(git_dir, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(worktree, paths.worktree)
示例#14
0
def test_find_git_does_discovery(is_git_dir):
    git_dir = '/the/root/.git'
    worktree = '/the/root'
    is_git_dir.side_effect = lambda x: x == git_dir

    paths = git.find_git_directory('/the/root/sub/dir')

    assert git_dir == paths.git_dir
    assert paths.git_file is None
    assert worktree == paths.worktree
示例#15
0
    def test_finds_no_worktree_from_bare_repo(self, is_git_dir):
        git_dir = '/repos/bare.git'
        worktree = None
        is_git_dir.return_value = True

        paths = git.find_git_directory(git_dir)
        self.assertTrue(is_git_dir.called)
        self.assertEqual(git_dir, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(worktree, paths.worktree)
示例#16
0
    def test_find_git_worktree_from_GIT_DIR(self, is_git_dir, getenv):
        git_dir = '/repo/.git'
        worktree = '/repo'
        is_git_dir.return_value = True
        getenv.side_effect = lambda x: x == 'GIT_DIR' and '/repo/.git' or None

        paths = git.find_git_directory(git_dir)
        self.assertTrue(is_git_dir.called)
        self.assertEqual(git_dir, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(worktree, paths.worktree)
示例#17
0
    def test_find_git_dir_found_right_away(self, is_git_dir):
        git_dir = '/seems/to/exist/.git'
        worktree = '/seems/to/exist'
        is_git_dir.return_value = True

        paths = git.find_git_directory(git_dir)

        self.assertTrue(is_git_dir.called)
        self.assertEqual(git_dir, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(worktree, paths.worktree)
示例#18
0
def test_find_git_dir_found_right_away(is_git_dir):
    git_dir = '/seems/to/exist/.git'
    worktree = '/seems/to/exist'
    is_git_dir.return_value = True

    paths = git.find_git_directory(git_dir)

    assert is_git_dir.called
    assert git_dir == paths.git_dir
    assert paths.git_file is None
    assert worktree == paths.worktree
示例#19
0
    def test_find_git_dir_found_right_away(self, is_git_dir):
        git_dir = '/seems/to/exist/.git'
        worktree = '/seems/to/exist'
        is_git_dir.return_value = True

        paths = git.find_git_directory(git_dir)

        self.assertTrue(is_git_dir.called)
        self.assertEqual(git_dir, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(worktree, paths.worktree)
示例#20
0
def test_find_git_worktree_from_GIT_DIR(is_git_dir, getenv):
    git_dir = '/repo/.git'
    worktree = '/repo'
    is_git_dir.return_value = True
    getenv.side_effect = lambda x: x == 'GIT_DIR' and '/repo/.git' or None

    paths = git.find_git_directory(git_dir)
    assert is_git_dir.called
    assert git_dir == paths.git_dir
    assert paths.git_file is None
    assert worktree == paths.worktree
示例#21
0
    def test_find_git_directory_uses_GIT_WORK_TREE(self, is_git_dir, getenv):
        git_dir = '/repo/worktree/.git'
        worktree = '/repo/worktree'

        def is_git_dir_fn(path):
            return path == git_dir

        is_git_dir.side_effect = is_git_dir_fn

        def getenv_fn(name):
            if name == 'GIT_WORK_TREE':
                return worktree
            return None

        getenv.side_effect = getenv_fn

        paths = git.find_git_directory(worktree)
        self.assertTrue(is_git_dir.called)
        self.assertEqual(git_dir, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(worktree, paths.worktree)
示例#22
0
def test_find_git_directory_uses_GIT_WORK_TREE(is_git_dir, getenv):
    git_dir = '/repo/worktree/.git'
    worktree = '/repo/worktree'

    def is_git_dir_fn(path):
        return path == git_dir

    is_git_dir.side_effect = is_git_dir_fn

    def getenv_fn(name):
        if name == 'GIT_WORK_TREE':
            return worktree
        return None

    getenv.side_effect = getenv_fn

    paths = git.find_git_directory(worktree)
    assert is_git_dir.called
    assert git_dir == paths.git_dir
    assert paths.git_file is None
    assert worktree == paths.worktree
示例#23
0
    def test_find_git_dir_never_found(self, is_git_dir):
        is_git_dir.return_value = False

        paths = git.find_git_directory('/does/not/exist')

        self.assertTrue(is_git_dir.called)
        self.assertEqual(None, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(None, paths.worktree)

        self.assertEqual(8, is_git_dir.call_count)
        kwargs = {}
        is_git_dir.assert_has_calls([
            (('/does/not/exist',), kwargs),
            (('/does/not/exist/.git',), kwargs),
            (('/does/not',), kwargs),
            (('/does/not/.git',), kwargs),
            (('/does',), kwargs),
            (('/does/.git',), kwargs),
            (('/',), kwargs),
            (('/.git',), kwargs),
        ])
示例#24
0
    def test_uses_cwd_for_worktree_with_GIT_DIR(self, is_git_dir, getenv):
        git_dir = '/repo/.yadm/repo.git'
        worktree = '/repo'

        def getenv_fn(name):
            if name == 'GIT_DIR':
                return git_dir
            return None

        getenv.side_effect = getenv_fn

        def is_git_dir_fn(path):
            return path == git_dir

        is_git_dir.side_effect = is_git_dir_fn

        paths = git.find_git_directory(worktree)
        self.assertTrue(is_git_dir.called)
        self.assertTrue(getenv.called)
        self.assertEqual(git_dir, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(worktree, paths.worktree)
示例#25
0
    def test_find_git_dir_never_found(self, is_git_dir):
        is_git_dir.return_value = False

        paths = git.find_git_directory('/does/not/exist')

        self.assertTrue(is_git_dir.called)
        self.assertEqual(None, paths.git_dir)
        self.assertEqual(None, paths.git_file)
        self.assertEqual(None, paths.worktree)

        self.assertEqual(8, is_git_dir.call_count)
        kwargs = {}
        is_git_dir.assert_has_calls([
            (('/does/not/exist',), kwargs),
            (('/does/not/exist/.git',), kwargs),
            (('/does/not',), kwargs),
            (('/does/not/.git',), kwargs),
            (('/does',), kwargs),
            (('/does/.git',), kwargs),
            (('/',), kwargs),
            (('/.git',), kwargs),
        ])
示例#26
0
def test_uses_cwd_for_worktree_with_GIT_DIR(is_git_dir, getenv):
    git_dir = '/repo/.yadm/repo.git'
    worktree = '/repo'

    def getenv_fn(name):
        if name == 'GIT_DIR':
            return git_dir
        return None

    getenv.side_effect = getenv_fn

    def is_git_dir_fn(path):
        return path == git_dir

    is_git_dir.side_effect = is_git_dir_fn

    paths = git.find_git_directory(worktree)
    assert is_git_dir.called
    assert getenv.called
    assert git_dir == paths.git_dir
    assert paths.git_file is None
    assert worktree == paths.worktree
示例#27
0
def test_find_git_dir_never_found(is_git_dir):
    is_git_dir.return_value = False

    paths = git.find_git_directory('/does/not/exist')

    assert is_git_dir.called
    assert paths.git_dir is None
    assert paths.git_file is None
    assert paths.worktree is None

    expect = 8
    actual = is_git_dir.call_count
    assert expect == actual
    is_git_dir.assert_has_calls([
        (('/does/not/exist', ), {}),
        (('/does/not/exist/.git', ), {}),
        (('/does/not', ), {}),
        (('/does/not/.git', ), {}),
        (('/does', ), {}),
        (('/does/.git', ), {}),
        (('/', ), {}),
        (('/.git', ), {}),
    ])