Python import_repo 예제들

예제 #1

파일: server_utils.py 프로젝트: ChipJust/dulwich

    def test_push_to_dulwich_no_op(self):
        self._old_repo = import_repo('server_old.export')
        self._new_repo = import_repo('server_old.export')
        self.assertReposEqual(self._old_repo, self._new_repo)
        port = self._start_server(self._old_repo)

        run_git_or_fail(['push', self.url(port)] + self.branch_args(),
                        cwd=self._new_repo.path)
        self.assertReposEqual(self._old_repo, self._new_repo)

예제 #2

파일: server_utils.py 프로젝트: MadAd360/GoGramming

    def test_push_to_dulwich_no_op(self):
        self._old_repo = import_repo('server_old.export')
        self._new_repo = import_repo('server_old.export')
        self.assertReposEqual(self._old_repo, self._new_repo)
        port = self._start_server(self._old_repo)

        run_git_or_fail(['push', self.url(port)] + self.branch_args(),
                        cwd=self._new_repo.path)
        self.assertReposEqual(self._old_repo, self._new_repo)

예제 #3

파일: server_utils.py 프로젝트: rfaulkner/dulwich

    def test_push_to_dulwich_no_op(self):
        self._old_repo = import_repo("server_old.export")
        self.addCleanup(tear_down_repo, self._old_repo)
        self._new_repo = import_repo("server_old.export")
        self.addCleanup(tear_down_repo, self._new_repo)
        self.assertReposEqual(self._old_repo, self._new_repo)
        port = self._start_server(self._old_repo)

        run_git_or_fail(["push", self.url(port)] + self.branch_args(), cwd=self._new_repo.path)
        self.assertReposEqual(self._old_repo, self._new_repo)

예제 #4

파일: server_utils.py 프로젝트: ChipJust/dulwich

    def test_push_to_dulwich_remove_branch(self):
        self._old_repo = import_repo('server_old.export')
        self._new_repo = import_repo('server_old.export')
        self.assertReposEqual(self._old_repo, self._new_repo)
        port = self._start_server(self._old_repo)

        run_git_or_fail(['push', self.url(port), ":master"],
                        cwd=self._new_repo.path)

        self.assertEquals(
            self._old_repo.get_refs().keys(), ["refs/heads/branch"])

예제 #5

    def test_fetch_from_dulwich_no_op(self):
        self._old_repo = import_repo('server_old.export')
        self._new_repo = import_repo('server_old.export')
        self.assertReposEqual(self._old_repo, self._new_repo)
        port = self._start_server(self._new_repo)

        run_git_or_fail(['fetch', self.url(port)] + self.branch_args(),
                        cwd=self._old_repo.path)
        # flush the pack cache so any new packs are picked up
        self._old_repo.object_store._pack_cache = None
        self.assertReposEqual(self._old_repo, self._new_repo)

예제 #6

파일: server_utils.py 프로젝트: MadAd360/GoGramming

    def test_push_to_dulwich_remove_branch(self):
        self._old_repo = import_repo('server_old.export')
        self._new_repo = import_repo('server_old.export')
        self.assertReposEqual(self._old_repo, self._new_repo)
        port = self._start_server(self._old_repo)

        run_git_or_fail(['push', self.url(port), ":master"],
                        cwd=self._new_repo.path)

        self.assertEquals(self._old_repo.get_refs().keys(),
                          ["refs/heads/branch"])

예제 #7

파일: server_utils.py 프로젝트: ChipJust/dulwich

    def test_fetch_from_dulwich_no_op(self):
        self._old_repo = import_repo('server_old.export')
        self._new_repo = import_repo('server_old.export')
        self.assertReposEqual(self._old_repo, self._new_repo)
        port = self._start_server(self._new_repo)

        run_git_or_fail(['fetch', self.url(port)] + self.branch_args(),
                        cwd=self._old_repo.path)
        # flush the pack cache so any new packs are picked up
        self._old_repo.object_store._pack_cache = None
        self.assertReposEqual(self._old_repo, self._new_repo)

예제 #8

파일: server_utils.py 프로젝트: rmoorman/dulwich

    def test_fetch_same_depth_into_shallow_clone_from_dulwich(self):
        require_git_version(self.min_single_branch_version)
        self._source_repo = import_repo('server_new.export')
        self.addCleanup(tear_down_repo, self._source_repo)
        self._stub_repo = _StubRepo('shallow')
        self.addCleanup(tear_down_repo, self._stub_repo)
        port = self._start_server(self._source_repo)

        # Fetch at depth 1
        run_git_or_fail([
            'clone', '--mirror', '--depth=1', '--no-single-branch',
            self.url(port), self._stub_repo.path
        ])
        clone = self._stub_repo = Repo(self._stub_repo.path)

        # Fetching at the same depth is a no-op.
        run_git_or_fail(
            ['fetch', '--depth=1', self.url(port)] + self.branch_args(),
            cwd=self._stub_repo.path)
        expected_shallow = [
            '94de09a530df27ac3bb613aaecdd539e0a0655e1',
            'da5cd81e1883c62a25bb37c4d1f8ad965b29bf8d'
        ]
        self.assertEqual(expected_shallow, _get_shallow(clone))
        self.assertReposNotEqual(clone, self._source_repo)

예제 #9

파일: server_utils.py 프로젝트: tylerbutler/dulwich

    def test_fetch_full_depth_into_shallow_clone_from_dulwich(self):
        self._source_repo = import_repo('server_new.export')
        self.addCleanup(tear_down_repo, self._source_repo)
        self._stub_repo = _StubRepo('shallow')
        self.addCleanup(tear_down_repo, self._stub_repo)
        port = self._start_server(self._source_repo)

        # Fetch at depth 1
        run_git_or_fail([
            'clone', '--mirror', '--depth=1', '--no-single-branch',
            self.url(port), self._stub_repo.path
        ])
        clone = self._stub_repo = Repo(self._stub_repo.path)

        # Fetching at the same depth is a no-op.
        run_git_or_fail(
            ['fetch', '--depth=1', self.url(port)] + self.branch_args(),
            cwd=self._stub_repo.path)

        # The whole repo only has depth 3, so it should equal server_new.
        run_git_or_fail(
            ['fetch', '--depth=3', self.url(port)] + self.branch_args(),
            cwd=self._stub_repo.path)
        self.assertEqual([], _get_shallow(clone))
        self.assertReposEqual(clone, self._source_repo)

예제 #10

파일: server_utils.py 프로젝트: rfaulkner/dulwich

    def test_new_shallow_clone_from_dulwich(self):
        self._source_repo = import_repo("server_new.export")
        self.addCleanup(tear_down_repo, self._source_repo)
        self._stub_repo = _StubRepo("shallow")
        self.addCleanup(tear_down_repo, self._stub_repo)
        port = self._start_server(self._source_repo)

        # Fetch at depth 1
        run_git_or_fail(["clone", "--mirror", "--depth=1", "--no-single-branch", self.url(port), self._stub_repo.path])
        clone = self._stub_repo = Repo(self._stub_repo.path)
        expected_shallow = ["94de09a530df27ac3bb613aaecdd539e0a0655e1", "da5cd81e1883c62a25bb37c4d1f8ad965b29bf8d"]
        self.assertEqual(expected_shallow, _get_shallow(clone))
        self.assertReposNotEqual(clone, self._source_repo)

예제 #11

파일: server_utils.py 프로젝트: redhat-cip/dulwich

    def test_new_shallow_clone_from_dulwich(self):
        self._source_repo = import_repo('server_new.export')
        self.addCleanup(tear_down_repo, self._source_repo)
        self._stub_repo = _StubRepo('shallow')
        self.addCleanup(tear_down_repo, self._stub_repo)
        port = self._start_server(self._source_repo)

        # Fetch at depth 1
        run_git_or_fail(['clone', '--mirror', '--depth=1', '--no-single-branch',
                        self.url(port), self._stub_repo.path])
        clone = self._stub_repo = Repo(self._stub_repo.path)
        expected_shallow = ['94de09a530df27ac3bb613aaecdd539e0a0655e1',
                            'da5cd81e1883c62a25bb37c4d1f8ad965b29bf8d']
        self.assertEqual(expected_shallow, _get_shallow(clone))
        self.assertReposNotEqual(clone, self._source_repo)

예제 #12

파일: server_utils.py 프로젝트: michael-k/dulwich

    def test_new_shallow_clone_from_dulwich(self):
        require_git_version(self.min_single_branch_version)
        self._source_repo = import_repo('server_new.export')
        self.addCleanup(tear_down_repo, self._source_repo)
        self._stub_repo = _StubRepo('shallow')
        self.addCleanup(tear_down_repo, self._stub_repo)
        port = self._start_server(self._source_repo)

        # Fetch at depth 1
        run_git_or_fail(['clone', '--mirror', '--depth=1', '--no-single-branch',
                        self.url(port), self._stub_repo.path])
        clone = self._stub_repo = Repo(self._stub_repo.path)
        expected_shallow = ['94de09a530df27ac3bb613aaecdd539e0a0655e1',
                            'da5cd81e1883c62a25bb37c4d1f8ad965b29bf8d']
        self.assertEqual(expected_shallow, _get_shallow(clone))
        self.assertReposNotEqual(clone, self._source_repo)

예제 #13

파일: server_utils.py 프로젝트: rfaulkner/dulwich

    def test_fetch_full_depth_into_shallow_clone_from_dulwich(self):
        self._source_repo = import_repo("server_new.export")
        self.addCleanup(tear_down_repo, self._source_repo)
        self._stub_repo = _StubRepo("shallow")
        self.addCleanup(tear_down_repo, self._stub_repo)
        port = self._start_server(self._source_repo)

        # Fetch at depth 1
        run_git_or_fail(["clone", "--mirror", "--depth=1", "--no-single-branch", self.url(port), self._stub_repo.path])
        clone = self._stub_repo = Repo(self._stub_repo.path)

        # Fetching at the same depth is a no-op.
        run_git_or_fail(["fetch", "--depth=1", self.url(port)] + self.branch_args(), cwd=self._stub_repo.path)

        # The whole repo only has depth 3, so it should equal server_new.
        run_git_or_fail(["fetch", "--depth=3", self.url(port)] + self.branch_args(), cwd=self._stub_repo.path)
        self.assertEqual([], _get_shallow(clone))
        self.assertReposEqual(clone, self._source_repo)

예제 #14

파일: server_utils.py 프로젝트: caiguanhao/dulwich

    def test_fetch_same_depth_into_shallow_clone_from_dulwich(self):
        self._source_repo = import_repo('server_new.export')
        self.addCleanup(tear_down_repo, self._source_repo)
        self._stub_repo = _StubRepo('shallow')
        self.addCleanup(tear_down_repo, self._stub_repo)
        port = self._start_server(self._source_repo)

        # Fetch at depth 1
        run_git_or_fail(['clone', '--mirror', '--depth=1', '--no-single-branch',
                        self.url(port), self._stub_repo.path])
        clone = self._stub_repo = Repo(self._stub_repo.path)

        # Fetching at the same depth is a no-op.
        run_git_or_fail(
          ['fetch', '--depth=1', self.url(port)] + self.branch_args(),
          cwd=self._stub_repo.path)
        expected_shallow = ['94de09a530df27ac3bb613aaecdd539e0a0655e1',
                            'da5cd81e1883c62a25bb37c4d1f8ad965b29bf8d']
        self.assertEqual(expected_shallow, _get_shallow(clone))
        self.assertReposNotEqual(clone, self._source_repo)

예제 #15

파일: server_utils.py 프로젝트: michael-k/dulwich

    def test_fetch_full_depth_into_shallow_clone_from_dulwich(self):
        require_git_version(self.min_single_branch_version)
        self._source_repo = import_repo('server_new.export')
        self.addCleanup(tear_down_repo, self._source_repo)
        self._stub_repo = _StubRepo('shallow')
        self.addCleanup(tear_down_repo, self._stub_repo)
        port = self._start_server(self._source_repo)

        # Fetch at depth 1
        run_git_or_fail(['clone', '--mirror', '--depth=1', '--no-single-branch',
                        self.url(port), self._stub_repo.path])
        clone = self._stub_repo = Repo(self._stub_repo.path)

        # Fetching at the same depth is a no-op.
        run_git_or_fail(
          ['fetch', '--depth=1', self.url(port)] + self.branch_args(),
          cwd=self._stub_repo.path)

        # The whole repo only has depth 3, so it should equal server_new.
        run_git_or_fail(
          ['fetch', '--depth=3', self.url(port)] + self.branch_args(),
          cwd=self._stub_repo.path)
        self.assertEqual([], _get_shallow(clone))
        self.assertReposEqual(clone, self._source_repo)

예제 #16

파일: server_utils.py 프로젝트: redhat-cip/dulwich

 def test_lsremote_from_dulwich(self):
     self._repo = import_repo('server_old.export')
     port = self._start_server(self._repo)
     o = run_git_or_fail(['ls-remote', self.url(port)])
     self.assertEqual(len(o.split('\n')), 4)

예제 #17

파일: server_utils.py 프로젝트: rfaulkner/dulwich

 def test_lsremote_from_dulwich(self):
     self._repo = import_repo("server_old.export")
     port = self._start_server(self._repo)
     o = run_git_or_fail(["ls-remote", self.url(port)])
     self.assertEqual(len(o.split("\n")), 4)

예제 #18

파일: server_utils.py 프로젝트: ChipJust/dulwich

 def import_repos(self):
     self._old_repo = import_repo('server_old.export')
     self.addCleanup(tear_down_repo, self._old_repo)
     self._new_repo = import_repo('server_new.export')
     self.addCleanup(tear_down_repo, self._new_repo)

예제 #19

파일: test_repository.py 프로젝트: Lutger/fuzzballflux

 def setUp(self):
     CompatTestCase.setUp(self)
     self._repo = import_repo('server_new.export')

예제 #20

파일: test_repository.py 프로젝트: agilescm/dulwich

 def setUp(self):
     super(ObjectStoreTestCase, self).setUp()
     self._repo = import_repo('server_new.export')
     self.addCleanup(tear_down_repo, self._repo)

예제 #21

파일: server_utils.py 프로젝트: dborowitz/dulwich

 def import_repos(self):
     self._old_repo = import_repo('server_old.export')
     self._new_repo = import_repo('server_new.export')

예제 #22

파일: server_utils.py 프로젝트: redhat-cip/dulwich

 def import_repos(self):
     self._old_repo = import_repo('server_old.export')
     self.addCleanup(tear_down_repo, self._old_repo)
     self._new_repo = import_repo('server_new.export')
     self.addCleanup(tear_down_repo, self._new_repo)

예제 #23

파일: test_repository.py 프로젝트: redhat-cip/dulwich

 def setUp(self):
     super(ObjectStoreTestCase, self).setUp()
     self._repo = import_repo('server_new.export')
     self.addCleanup(tear_down_repo, self._repo)

예제 #24

파일: server_utils.py 프로젝트: caiguanhao/dulwich

 def test_lsremote_from_dulwich(self):
     self._repo = import_repo('server_old.export')
     port = self._start_server(self._repo)
     o = run_git_or_fail(['ls-remote', self.url(port)])
     self.assertEqual(len(o.split('\n')), 4)