def testSimpleFork(self):
        with phlgitu_fixture.lone_worker_context() as worker:

            # pylint has faulty detection here
            # pylint: disable=not-callable
            worker.repo("branch", "fork")
            worker.commit_new_file("add ONLY_MASTER", "ONLY_MASTER")
            worker.repo("checkout", "fork")
            # pylint: enable=not-callable

            worker.commit_new_file("add ONLY_FORK", "ONLY_FORK")
            worker.commit_new_file("add ONLY_FORK2", "ONLY_FORK2")
            rawDiff = phlgit_diff.raw_diff_range_to_here(worker.repo, "master")
            rawDiff2 = phlgit_diff.raw_diff_range(worker.repo, "master",
                                                  "fork")
            rawDiff3 = phlgit_diff.raw_diff_range(worker.repo, "master",
                                                  "fork", 1000)
            self.assertEqual(
                set(["ONLY_FORK", "ONLY_FORK2"]),
                phlgit_diff.parse_filenames_from_raw_diff(rawDiff))
            self.assertEqual(
                set(["ONLY_FORK", "ONLY_FORK2"]),
                phlgit_diff.parse_filenames_from_raw_diff(rawDiff2))
            self.assertEqual(
                set(["ONLY_FORK", "ONLY_FORK2"]),
                phlgit_diff.parse_filenames_from_raw_diff(rawDiff3))
    def test_C_ReduceAddMassiveFile(self):
        with phlgitu_fixture.lone_worker_context() as worker:

            # make a large file to base our changes on
            large_content = "lorem ipsum\n" * 1000
            worker.commit_new_file_on_new_branch(
                "diff_branch", "add large_file", "large_file", large_content)

            def make_diff(max_bytes):
                return abdt_differ.make_raw_diff(
                    worker.repo, "master", "diff_branch", max_bytes)

            # establish a baseline size for the diff
            diff_result = make_diff(100000)
            self.assertIn("lorem ipsum", diff_result.diff)
            original_diff_size = len(diff_result.diff)

            # [ C] a diff still outside the limits can be reduced
            #      to the diffstat
            diff_result = make_diff(500)
            self.assertNotIn("lorem ipsum", diff_result.diff)
            diffstat_diff_size = len(diff_result.diff)
            self.assertTrue(
                any(
                    isinstance(r, abdt_differ.DiffStatReduction)
                    for r in diff_result.reduction_list))
            self.assertLess(
                diffstat_diff_size,
                original_diff_size)
Esempio n. 3
0
    def testSimpleFork(self):
        with phlgitu_fixture.lone_worker_context() as worker:

            # pylint has faulty detection here
            # pylint: disable=not-callable
            worker.repo("branch", "fork")
            worker.commit_new_file("add ONLY_MASTER", "ONLY_MASTER")
            worker.repo("checkout", "fork")
            # pylint: enable=not-callable

            worker.commit_new_file("add ONLY_FORK", "ONLY_FORK")
            worker.commit_new_file("add ONLY_FORK2", "ONLY_FORK2")
            rawDiff = phlgit_diff.raw_diff_range_to_here(
                worker.repo, "master")
            rawDiff2 = phlgit_diff.raw_diff_range(
                worker.repo, "master", "fork")
            rawDiff3 = phlgit_diff.raw_diff_range(
                worker.repo, "master", "fork", 1000)
            self.assertEqual(
                set(["ONLY_FORK", "ONLY_FORK2"]),
                phlgit_diff.parse_filenames_from_raw_diff(rawDiff))
            self.assertEqual(
                set(["ONLY_FORK", "ONLY_FORK2"]),
                phlgit_diff.parse_filenames_from_raw_diff(rawDiff2))
            self.assertEqual(
                set(["ONLY_FORK", "ONLY_FORK2"]),
                phlgit_diff.parse_filenames_from_raw_diff(rawDiff3))
    def test_C_ReduceAddMassiveFile(self):
        with phlgitu_fixture.lone_worker_context() as worker:

            # make a large file to base our changes on
            large_content = "lorem ipsum\n" * 1000
            worker.commit_new_file_on_new_branch("diff_branch",
                                                 "add large_file",
                                                 "large_file", large_content)

            def make_diff(max_bytes):
                return abdt_differ.make_raw_diff(worker.repo, "master",
                                                 "diff_branch", max_bytes)

            # establish a baseline size for the diff
            diff_result = make_diff(100000)
            self.assertIn("lorem ipsum", diff_result.diff)
            original_diff_size = len(diff_result.diff)

            # [ C] a diff still outside the limits can be reduced
            #      to the diffstat
            diff_result = make_diff(500)
            self.assertNotIn("lorem ipsum", diff_result.diff)
            diffstat_diff_size = len(diff_result.diff)
            self.assertTrue(
                any(
                    isinstance(r, abdt_differ.DiffStatReduction)
                    for r in diff_result.reduction_list))
            self.assertLess(diffstat_diff_size, original_diff_size)
    def test_A_Breathing(self):
        with phlgitu_fixture.lone_worker_context() as worker:

            branch_name = "diff_branch"

            breakable_repo = _BreakableRepo(worker.repo)
            refcache_repo = phlgitx_refcache.Repo(breakable_repo)
            differ = abdt_differresultcache.Cache(refcache_repo)

            worker.repo("checkout", "-b", branch_name)

            def make_diff(max_bytes):
                return differ.checkout_make_raw_diff(
                    "refs/heads/master", "refs/heads/{}".format(branch_name), max_bytes
                )

            # make sure that the repo raises if used when disabled
            with self.assertRaises(_BreakableRepoUsedError):
                with breakable_repo.disabled_context():
                    with self.assertRaises(abdt_differ.NoDiffError):
                        make_diff(1)

            # An empty diff raises abdt_differ.NoDiffError
            with self.assertRaises(abdt_differ.NoDiffError):
                make_diff(1)

            # An empty diff raises abdt_differ.NoDiffError again, this time the
            # refcache_repo won't be used to do diffing so it won't need to
            # reset the cache
            with self.assertRaises(abdt_differ.NoDiffError):
                make_diff(1)

            # An empty diff raises abdt_differ.NoDiffError again
            # make sure that the repo isn't used at all, by disabling it
            with breakable_repo.disabled_context():
                with self.assertRaises(abdt_differ.NoDiffError):
                    make_diff(1)

            # the differ will detach HEAD so attach to branch again before
            # making any more commits on the branch
            worker.repo("checkout", branch_name)

            worker.commit_new_file("make a test diff", "newfile", "test content")

            # a diff within the limits passes straight through
            diff_result = make_diff(1000)
            self.assertIn("test content", diff_result.diff)

            # a diff within the limits passes straight through again
            diff_result = make_diff(1000)
            self.assertIn("test content", diff_result.diff)

            # raise if a diff cannot be reduced to the limits
            with self.assertRaises(abdt_exception.LargeDiffException):
                make_diff(1)

            # raise if a diff cannot be reduced to the limits again
            with self.assertRaises(abdt_exception.LargeDiffException):
                make_diff(1)
    def test_A_Breathing(self):
        with phlgitu_fixture.lone_worker_context() as worker:

            self.assertFalse(
                phlgitx_ignoreident.is_repo_definitely_ignoring(
                    worker.repo.working_dir))

            phlgitx_ignoreident.ensure_repo_ignoring(
                worker.repo.working_dir)

            self.assertTrue(
                phlgitx_ignoreident.is_repo_definitely_ignoring(
                    worker.repo.working_dir))

            phlgitx_ignoreident.ensure_repo_ignoring(
                worker.repo.working_dir)
    def test_A_Breathing(self):
        with phlgitu_fixture.lone_worker_context() as worker:

            worker.commit_new_file_on_new_branch(
                "diff_branch", "make a test diff", "newfile", "test content")

            def make_diff(max_bytes):
                return abdt_differ.make_raw_diff(
                    worker.repo, "master", "diff_branch", max_bytes)

            # [ A] a diff within the limits passes straight through
            diff_result = make_diff(1000)
            self.assertIn("test content", diff_result.diff)

            # [ A] raise if a diff cannot be reduced to the limits
            with self.assertRaises(abdt_exception.LargeDiffException):
                make_diff(1)
    def test_B_ReduceSmallChangeOnLargeFile(self):
        with phlgitu_fixture.lone_worker_context() as worker:

            # make a large file to base our changes on
            large_content = "lorem ipsum\n" * 1000
            worker.commit_new_file(
                "add large_file", "large_file", large_content)

            worker.append_to_file_on_new_branch(
                "diff_branch", "make small diff", "large_file", "test content")

            def make_diff(max_bytes):
                return abdt_differ.make_raw_diff(
                    worker.repo, "master", "diff_branch", max_bytes)

            # establish a baseline size for the diff
            diff_result = make_diff(100000)
            self.assertIn("test content", diff_result.diff)
            original_diff_size = len(diff_result.diff)

            # [ B] a diff outside the limits can be reduced ok with less
            #      context
            diff_result = make_diff(2000)
            self.assertIn("test content", diff_result.diff)
            reduced_context_diff_size = len(diff_result.diff)
            self.assertTrue(
                any(
                    isinstance(r, abdt_differ.LessContextReduction)
                    for r in diff_result.reduction_list))
            self.assertLess(
                reduced_context_diff_size,
                original_diff_size)

            # [ B] a diff still outside the limits can be reduced ok with no
            #      context
            diff_result = make_diff(500)
            self.assertIn("test content", diff_result.diff)
            no_context_diff_size = len(diff_result.diff)
            self.assertTrue(
                any(
                    isinstance(r, abdt_differ.RemoveContextReduction)
                    for r in diff_result.reduction_list))
            self.assertLess(
                no_context_diff_size,
                reduced_context_diff_size)
    def test_A_Breathing(self):
        with phlgitu_fixture.lone_worker_context() as worker:

            worker.commit_new_file_on_new_branch("diff_branch",
                                                 "make a test diff", "newfile",
                                                 "test content")

            def make_diff(max_bytes):
                return abdt_differ.make_raw_diff(worker.repo, "master",
                                                 "diff_branch", max_bytes)

            # [ A] a diff within the limits passes straight through
            diff_result = make_diff(1000)
            self.assertIn("test content", diff_result.diff)

            # [ A] raise if a diff cannot be reduced to the limits
            with self.assertRaises(abdt_exception.LargeDiffException):
                make_diff(1)
Esempio n. 10
0
    def test_B_ReduceSmallChangeOnLargeFile(self):
        with phlgitu_fixture.lone_worker_context() as worker:

            # make a large file to base our changes on
            large_content = "lorem ipsum\n" * 1000
            worker.commit_new_file("add large_file", "large_file",
                                   large_content)

            worker.append_to_file_on_new_branch("diff_branch",
                                                "make small diff",
                                                "large_file", "test content")

            def make_diff(max_bytes):
                return abdt_differ.make_raw_diff(worker.repo, "master",
                                                 "diff_branch", max_bytes)

            # establish a baseline size for the diff
            diff_result = make_diff(100000)
            self.assertIn("test content", diff_result.diff)
            original_diff_size = len(diff_result.diff)

            # [ B] a diff outside the limits can be reduced ok with less
            #      context
            diff_result = make_diff(2000)
            self.assertIn("test content", diff_result.diff)
            reduced_context_diff_size = len(diff_result.diff)
            self.assertTrue(
                any(
                    isinstance(r, abdt_differ.LessContextReduction)
                    for r in diff_result.reduction_list))
            self.assertLess(reduced_context_diff_size, original_diff_size)

            # [ B] a diff still outside the limits can be reduced ok with no
            #      context
            diff_result = make_diff(500)
            self.assertIn("test content", diff_result.diff)
            no_context_diff_size = len(diff_result.diff)
            self.assertTrue(
                any(
                    isinstance(r, abdt_differ.RemoveContextReduction)
                    for r in diff_result.reduction_list))
            self.assertLess(no_context_diff_size, reduced_context_diff_size)
    def test_D_UpdateInfoAttributes(self):

        all_attributes = list(phlgitx_ignoreattributes._REPO_ATTRIBUTES_TUPLE)
        all_attributes.append("")

        all_lines = itertools.combinations(
            all_attributes,
            len(all_attributes) - 1)

        for lines in all_lines:

            content = "\n".join(lines)
            print(content)
            print("---")
            with phlgitu_fixture.lone_worker_context() as worker:

                working_dir = worker.repo.working_dir
                attributes_path = os.path.join(
                    working_dir, '.git/info/attributes')
                phlsys_fs.write_text_file(attributes_path, content)

                # should not throw
                phlgitx_ignoreattributes.ensure_repo_ignoring(
                    worker.repo.working_dir)
Esempio n. 12
0
    def test_A_Breathing(self):
        with phlgitu_fixture.lone_worker_context() as worker:

            branch_name = 'diff_branch'

            breakable_repo = _BreakableRepo(worker.repo)
            refcache_repo = phlgitx_refcache.Repo(breakable_repo)
            differ = abdt_differresultcache.Cache(refcache_repo)

            # pylint has faulty detection here
            # pylint: disable=not-callable
            worker.repo('checkout', '-b', branch_name)

            # pylint: enable=not-callable

            def make_diff(max_bytes):
                return differ.checkout_make_raw_diff(
                    "refs/heads/master", "refs/heads/{}".format(branch_name),
                    max_bytes)

            # make sure that the repo raises if used when disabled
            with self.assertRaises(_BreakableRepoUsedError):
                with breakable_repo.disabled_context():
                    with self.assertRaises(abdt_differ.NoDiffError):
                        make_diff(1)

            # An empty diff raises abdt_differ.NoDiffError
            with self.assertRaises(abdt_differ.NoDiffError):
                make_diff(1)

            # An empty diff raises abdt_differ.NoDiffError again, this time the
            # refcache_repo won't be used to do diffing so it won't need to
            # reset the cache
            with self.assertRaises(abdt_differ.NoDiffError):
                make_diff(1)

            # An empty diff raises abdt_differ.NoDiffError again
            # make sure that the repo isn't used at all, by disabling it
            with breakable_repo.disabled_context():
                with self.assertRaises(abdt_differ.NoDiffError):
                    make_diff(1)

            # the differ will detach HEAD so attach to branch again before
            # making any more commits on the branch
            # pylint has faulty detection here
            # pylint: disable=not-callable
            worker.repo('checkout', branch_name)
            # pylint: enable=not-callable

            worker.commit_new_file("make a test diff", "newfile",
                                   "test content")

            # a diff within the limits passes straight through
            diff_result = make_diff(1000)
            self.assertIn("test content", diff_result.diff)

            # a diff within the limits passes straight through again
            diff_result = make_diff(1000)
            self.assertIn("test content", diff_result.diff)

            # raise if a diff cannot be reduced to the limits
            with self.assertRaises(abdt_exception.LargeDiffException):
                make_diff(1)

            # raise if a diff cannot be reduced to the limits again
            with self.assertRaises(abdt_exception.LargeDiffException):
                make_diff(1)