hgitaly 18.7.0a1__tar.gz → 18.7.2__tar.gz

{hgitaly-18.7.0a1/hgitaly.egg-info → hgitaly-18.7.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hgitaly
-Version: 18.7.0a1
+Version: 18.7.2
 Summary: Server-side implementation of Gitaly protocol for Mercurial
 Home-page: https://foss.heptapod.net/heptapod/hgitaly
 Author: Georges Racinet
@@ -10,7 +10,7 @@ Keywords: hg mercurial heptapod gitlab
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: heptapod>=5.4.0
+Requires-Dist: heptapod~=5.5.0
 Requires-Dist: protobuf~=6.31.1
 Requires-Dist: grpcio~=1.76.0
 Requires-Dist: grpcio-status~=1.76.0

{hgitaly-18.7.0a1 → hgitaly-18.7.2}/functional_tests/test_blob_tree.py

@@ -412,7 +412,7 @@ def test_compare_get_tree_entries_pagination(gitaly_rhgitaly_comparison):
     # case of unknown revision and limit=0
     assert_compare_errors(path=b'.', revision=b'unknown',
                           pagination_params=PaginationParameter(limit=0),
-                          skip_structured_errors_issue=156)
+                          )
 
     # case of no pagination params
     assert_compare_aggregated(path=b'sub',

{hgitaly-18.7.0a1 → hgitaly-18.7.2}/functional_tests/test_commit.py

@@ -17,6 +17,7 @@ from hgitaly.stub.shared_pb2 import (
 from hgitaly.stub.commit_pb2 import (
     CommitLanguagesRequest,
     CommitIsAncestorRequest,
+    CountCommitsRequest,
     FindCommitRequest,
     FindCommitsRequest,
     LastCommitForPathRequest,
@@ -40,6 +41,8 @@ if skip_comparison_tests():  # pragma no cover
 
 parametrize = pytest.mark.parametrize
 
+PSEUDO_RANGE_SEPARATORS = (b'..', b'...')
+
 
 def test_compare_last_commit_for(gitaly_rhgitaly_comparison):
     fixture = gitaly_rhgitaly_comparison
@@ -583,14 +586,20 @@ def test_compare_count_find_commits(gitaly_rhgitaly_comparison, hg_server):
     wrapper.update(2)
     ctx4 = wrapper.merge_commit(ctx3, message=b'merge with stable',
                                 utc_timestamp=ts+20)
+    unknown = b'unknown'
+    unknown_sha = b'cade12fe' * 5
+    range_with_unknown = b'..'.join((unknown_sha, ctx2.hex()))
+    assert_compare_errors(revision=unknown)
+    assert_compare_errors(revision=unknown_sha)
+    assert_compare_errors(revision=range_with_unknown)
 
     # when `revision` is provided as <revspec>
     with sorted_comparison():
         all_revs = [ctx0.hex(), ctx1.hex(), ctx2.hex(), ctx3.hex(), ctx4.hex()]
-        for range_str in (b'..', b'...'):
+        for range_sep in PSEUDO_RANGE_SEPARATORS:
             for r1 in all_revs:
                 for r2 in all_revs:
-                    assert_compare(revision=r1 + range_str + r2)
+                    assert_compare(revision=r1 + range_sep + r2)
 
     # with message_regex
     rx = 'FOO.*zoO'  # tests case insensitivity
@@ -688,7 +697,7 @@ def test_compare_count_find_commits(gitaly_rhgitaly_comparison, hg_server):
         hg_server=hg_server,
         stub_cls=CommitServiceStub,
         method_name='CountCommits',
-        request_cls=FindCommitsRequest,
+        request_cls=CountCommitsRequest,
         request_sha_attrs=['revision'],
     )
 
@@ -697,7 +706,10 @@ def test_compare_count_find_commits(gitaly_rhgitaly_comparison, hg_server):
 
     # when `revision` is provided as <revspec>
     all_revs = [ctx0.hex(), ctx1.hex(), ctx2.hex(), ctx3.hex(), ctx4.hex()]
-    for range_str in (b'..', ):  # TODO symdiff not implemented
+    range_ops = [b'..']
+    if hg_server == 'rhgitaly':
+        range_ops.append(b'...')
+    for range_str in range_ops:
         for r1 in all_revs:
             for r2 in all_revs:
                 assert_compare(revision=r1 + range_str + r2)
@@ -708,11 +720,27 @@ def test_compare_count_find_commits(gitaly_rhgitaly_comparison, hg_server):
     for ref in refs:
         rpc_helper.assert_compare(revision=ref)
 
+    for mc in (0, 1, 2, 3):
+        assert_compare(revision=ctx2.hex(), max_count=mc)
+
+    assert_compare(all=True)
+
+    if hg_server == 'rhgitaly':
+        for date in [date1, date2]:
+            assert_compare(revision=ctx4.hex(), after=date)
+            assert_compare(revision=ctx4.hex(), before=date)
+            assert_compare(revision=ctx4.hex(), before=date, after=date)
+        assert_compare(revision=ctx4.hex(), before=date1, after=date2)
+
     assert_compare_errors()
+    assert_compare(revision=unknown)
+    assert_compare(revision=unknown_sha)
+    assert_compare(revision=range_with_unknown)
 
 
-def test_compare_list_commits(gitaly_comparison):
-    fixture = gitaly_comparison
+@parametrize('hg_server', ('hgitaly', 'rhgitaly'))
+def test_compare_list_commits(gitaly_rhgitaly_comparison, hg_server):
+    fixture = gitaly_rhgitaly_comparison
 
     wrapper = fixture.hg_repo_wrapper
     # set_default_gitlab_branch(wrapper.repo, b'branch/default')
@@ -720,7 +748,7 @@ def test_compare_list_commits(gitaly_comparison):
     #
     #   @    4 (branch/default) merge with stable
     #   |\
-    #   | o  3 creates 'animal' (branch/stable)
+    #   | o  3 creates 'animals' (branch/stable)
     #   | |
     #   o |  2 rename 'foo' to 'zoo' (user: testuser)
     #   |/
@@ -741,9 +769,12 @@ def test_compare_list_commits(gitaly_comparison):
     ctx2 = wrapper.commit([b'foo', b'zoo'],
                           message=b"rename foo to zoo",
                           utc_timestamp=ts - 10)
+    # TODO the converted email by hg-git is more liberal, and would
+    # parse the email correctly from 'testuser <testuser@heptapod.test'.
+    # Same with HGitaly, compared to RHGitaly.
     ctx3 = wrapper.write_commit('animals', branch='stable', parent=ctx0,
                                 utc_timestamp=ts + 10,
-                                user='testuser <testuser@heptapod.test')
+                                user='testuser <testuser@heptapod.test>')
     wrapper.update(2)
     ctx4 = wrapper.merge_commit(ctx3, message=b'merge with stable',
                                 utc_timestamp=ts+20)
@@ -754,6 +785,7 @@ def test_compare_list_commits(gitaly_comparison):
                 normalize_commit_message(commit)
 
     rpc_helper = fixture.rpc_helper(
+        hg_server=hg_server,
         stub_cls=CommitServiceStub,
         method_name='ListCommits',
         request_cls=ListCommitsRequest,
@@ -805,12 +837,31 @@ def test_compare_list_commits(gitaly_comparison):
 
     assert_compare(revisions=[ctx4.hex(), caret(ctx1)])
     assert_compare(revisions=[ctx4.hex(), caret(ctx1)], reverse=True)
+    # symmetric difference (HGitaly does not accept pseudo range revisions)
+    # this is the only actual testing of `reverse` for RHGitaly many_commits
+    symdiff_revspec = b'...'.join((ctx2.hex(), ctx4.hex()))
+    if hg_server == 'rhgitaly':
+        assert_compare(revisions=[symdiff_revspec])
+        assert_compare(revisions=[symdiff_revspec], reverse=True)
+
     # interpretation of several exclusions
     assert_compare(revisions=[ctx4.hex(), caret(ctx1), caret(ctx2)])
 
     # no result
     assert_compare(revisions=[ctx4.hex(), caret(ctx4)])
 
+    # with paths
+    assert_compare(revisions=[ctx4.hex()], paths=[b'animals'])
+    assert_compare(revisions=[ctx4.hex()], paths=[b'foo'])
+    assert_compare(revisions=[ctx4.hex()], paths=[b'zoo'])
+    assert_compare(revisions=[ctx3.hex(), ctx2.hex()],
+                   paths=[b'animals', b'zoo'])
+    assert_compare(revisions=[ctx4.hex()], paths=[b'anim*'])
+    # with two paths, Git starts returning the merge
+    # but Mercurial does not. This seems more consistent on the Mercurial
+    # side, so we won't compare. It would be:
+    #    assert_compare(revisions=[ctx4.hex()], paths=[b'anim*', b'foo'])
+
     # orderings
     #
     # Comparison is limited because Mercurial orderings don't exactly

{hgitaly-18.7.0a1 → hgitaly-18.7.2}/functional_tests/test_ref.py

@@ -585,6 +585,9 @@ def test_list_refs(gitaly_rhgitaly_comparison, hg_server):
                         ref_msg.name[len(prefix):])
             if all_pseudo_ref_idx is not None:
                 del resp.references[all_pseudo_ref_idx]
+            if resp.HasField('pagination_cursor'):
+                pc = resp.pagination_cursor
+                pc.next_cursor = b64decode(pc.next_cursor).decode()
 
     rpc_helper = fixture.rpc_helper(
         hg_server=hg_server,
@@ -631,6 +634,8 @@ def test_list_refs(gitaly_rhgitaly_comparison, hg_server):
     fixture.write_special_ref(b'pipeline/13', hg_sha)
     rpc_helper.assert_compare()
     for head in False, True:
+        rpc_helper.assert_compare(patterns=[b'refs/'], head=head)
+        rpc_helper.assert_compare(patterns=[b'refs/pipeline/'], head=head)
         rpc_helper.assert_compare(patterns=[b'refs/heads/'], head=head)
         rpc_helper.assert_compare(patterns=[b'refs/tags/'], head=head)
 
@@ -692,6 +697,15 @@ def test_list_refs(gitaly_rhgitaly_comparison, hg_server):
             head=False,
         )
 
+    # with pagination parameters (RHGitaly only, HGitaly no longer used)
+    paginated = dict(head=False,
+                     patterns=[b'refs/heads/'],  # avoid ALL
+                     pagination_params=PaginationParameter(limit=2))
+    if hg_server == 'rhgitaly':
+        rpc_helper.assert_compare(**paginated)
+        rpc_helper.assert_compare(sort_by=SortBy(key=SortBy.AUTHORDATE),
+                                  **paginated)
+
     # FindRefsByOID is almost a subset of ListRefs, the only stated
     # thing that ListRefs would not do is accepting oids by prefix.
     # So we'll use the same setup

hgitaly-18.7.2/hgitaly/VERSION

@@ -0,0 +1 @@
+18.7.2

{hgitaly-18.7.0a1 → hgitaly-18.7.2}/hgitaly/revset.py

@@ -60,6 +60,9 @@ def revset_from_git_revspec(repo, revspec, for_follow=False):
             return None
         return ctx.hex() if for_follow else b"reverse(::%s)" % ctx
 
+    if revset is None:
+        return None
+
     return b"sort(%s, -rev)" % revset
 
 
@@ -90,6 +93,9 @@ def revset_git_range(repo, r1, r2, for_follow=False):
         raise FollowNotImplemented()
 
     ctx_start, ctx_end = resolve_git_range(repo, r1, r2)
+    if ctx_start is None or ctx_end is None:
+        return None
+
     return b"::%s - ::%s" % (ctx_end, ctx_start)
 
 
@@ -114,6 +120,9 @@ def revset_symmetric_difference(repo, r1, r2, for_follow=False):
         raise FollowNotImplemented()
 
     ctx_start, ctx_end = resolve_git_range(repo, r1, r2)
+    if ctx_start is None or ctx_end is None:
+        return None
+
     left = ctx_start.rev()
     right = ctx_end.rev()
     branchpoint = repo.revs(b"ancestor(%d, %d)" % (left, right)).first()

hgitaly-18.7.2/hgitaly/scripts/__init__.py

@@ -0,0 +1,3 @@
+# flake8: noqa F401 (reexports)
+from .stats import stats
+from .load_tests import load_test

hgitaly-18.7.2/hgitaly/scripts/load_tests.py

@@ -0,0 +1,373 @@
+"""Load tests for HGitaly.
+
+This simple script assumes that the HGitaly server has a given set of
+repositories:
+
+They must absolutely be dedicated to the task, because the load tests
+may involve mutation calls. Hence the script expects the HGitaly server
+to operate on its own separate repositories root and will clone everything
+if needed.
+
+Future facilities:
+
+- configuring and launching RHGitaly
+"""
+import argparse
+import json
+import logging
+import random
+import statistics
+import threading
+import multiprocessing as mp
+import time
+from urllib.parse import urlparse
+
+import grpc
+
+from hgitaly import feature
+from hgitaly.servicer import (
+    SKIP_HOOKS_MD_KEY,
+    NATIVE_PROJECT_MD_KEY,
+)
+
+from hgitaly.stub.commit_pb2_grpc import CommitServiceStub
+from hgitaly.stub.commit_pb2 import (
+    CountCommitsRequest,
+    FindCommitsRequest,
+)
+from hgitaly.stub.mercurial_operations_pb2 import (
+    InvalidateMergeAnalysisRequest,
+    MergeAnalysisRequest,
+)
+from hgitaly.stub.mercurial_operations_pb2_grpc import (
+    MercurialOperationsServiceStub,
+)
+from hgitaly.stub.mercurial_repository_pb2_grpc import (
+    MercurialRepositoryServiceStub,
+)
+from hgitaly.stub.mercurial_repository_pb2 import (
+    HgCallRequest,
+)
+from hgitaly.stub.repository_pb2_grpc import RepositoryServiceStub
+from hgitaly.stub.repository_pb2 import (
+    CreateRepositoryRequest,
+    RepositoryExistsRequest,
+)
+from hgitaly.stub.shared_pb2 import (
+    Repository,
+)
+
+FOSS_HEPTAPOD = 'https://foss.heptapod.net'
+
+logger = logging.getLogger(__name__)
+
+
+def gl_repo(relpath):
+    return Repository(storage_name='default', relative_path=relpath)
+
+
+class LoadWorker:
+
+    weighted_methods = (
+        ('find_commits_mercurial_devel', 9),
+        ('sleep_a_bit', 1),
+        ('merge_analysis_mercurial_devel', 1),
+    )
+    repositories = {
+        'mercurial-devel': FOSS_HEPTAPOD + '/mercurial/mercurial-devel',
+    }
+    feature_flags = ()
+
+    @classmethod
+    def compute_random_thresholds(cls):
+        total_weight = sum(wm[1] for wm in cls.weighted_methods)
+
+        thresholds = []
+        current = 0
+        for meth, weight in cls.weighted_methods:
+            thresholds.append((current, meth))
+            current += weight / total_weight
+        cls.random_thresholds = thresholds
+        logger.warning("Random thresholds: %r", thresholds)
+
+    @classmethod
+    def random_method(cls):
+        rand = random.random()
+        candidate = cls.random_thresholds[0][0]
+        for thr, name in cls.random_thresholds:
+            if thr > rand:
+                break
+            candidate = name
+        return candidate
+
+    def __init__(self, url, queue, wid=None):
+        self.url = url = urlparse(url)
+        self.queue = queue
+
+        if url.scheme != 'tcp':
+            raise RuntimeError("Unsupported URL scheme: %r" % url.scheme)
+        if wid is not None:
+            logger.info("Worker %d starting", wid)
+        self.channel = grpc.insecure_channel(url.netloc)
+        self.hg_operations_service = MercurialOperationsServiceStub(
+            self.channel)
+        self.hg_repository_service = MercurialRepositoryServiceStub(
+            self.channel)
+        self.repository_service = RepositoryServiceStub(self.channel)
+        self.commit_service = CommitServiceStub(self.channel)
+
+    def close(self):
+        self.channel.close()
+
+    def grpc_metadata(self):
+        mds = feature.as_grpc_metadata(self.feature_flags)
+        mds.append((SKIP_HOOKS_MD_KEY, 'true'))
+        mds.append((NATIVE_PROJECT_MD_KEY, 'true'))
+        return mds
+
+    def repo_exists(self, relpath):
+        return self.repository_service.RepositoryExists(
+            RepositoryExistsRequest(repository=gl_repo(relpath))
+        ).exists
+
+    def ensure_repos(self):
+        for relpath in self.repositories:
+            if self.repo_exists(relpath):
+                logger.info("Repository %r is present", relpath)
+            else:
+                self.import_repo(relpath)
+
+    def import_repo(self, relpath):
+        logger.warning("Importing repository %r", relpath)
+        self.repository_service.CreateRepository(
+            CreateRepositoryRequest(repository=gl_repo(relpath))
+        )
+
+        src_url = self.repositories[relpath]
+        self.hg_call(relpath,
+                     (b"pull", b"-q",
+                      b"--config", b"heptapod.initial-import=yes",
+                      src_url.encode('ascii')),
+                     timeout=3600)
+
+    def hg_call(self, relpath, args, timeout=30):
+        exit_code = -1
+        for resp in self.hg_repository_service.HgCall(
+            HgCallRequest(repository=gl_repo(relpath),
+                          args=args),
+            metadata=self.grpc_metadata(),
+            timeout=timeout,
+        ):
+            exit_code = resp.exit_code
+        if exit_code != 0:
+            raise RuntimeError(f"HgCall exit code {exit_code}")
+
+    def run_one(self, name):
+        start = time.time()
+        try:
+            getattr(self, name)()
+            code = 'OK'
+        except grpc.RpcError as exc:
+            code = exc.code().name
+            if self.queue is None:
+                logger.error(
+                    "Failed request when checking before actual load test"
+                )
+                raise
+
+        elapsed = time.time() - start
+
+        if self.queue is None:
+            logger.info("Ran %r in %d ms", name, elapsed * 1000)
+        else:
+            self.queue.put((name, code, elapsed), block=False, timeout=1)
+
+    def run_test(self, iterations):
+        for i in range(iterations):
+            meth = self.random_method()
+            logger.info("Iteration %d, running %r", i + 1, meth)
+            self.run_one(meth)
+
+    def sleep_a_bit(self):
+        # this can make RHGitaly find there are too many idle workers
+        # and recycle them, leading to interesting problems because of
+        # long HGitaly startup time.
+        time.sleep(2)
+
+    def find_commits_mercurial_devel(self):
+        count = 0
+        future = self.commit_service.FindCommits(FindCommitsRequest(
+            repository=gl_repo('mercurial-devel'),
+            revision=b'branch/default',
+            limit=100000,
+            paths=[b'rust/hg-core/Cargo.toml'],
+        ))
+
+        # see also `streaming_future_with_cancellation()`
+        for resp in future:
+            count += len(resp.commits)
+
+        logger.debug("Got FindCommits response with %d commits", count)
+
+    def count_commits_mercurial_devel(self):
+        resp = self.commit_service.CountCommits(CountCommitsRequest(
+            repository=gl_repo('mercurial-devel'),
+            revision=b'branch/default',
+        ))
+        logger.debug("Got FindCommits response with %d commits", resp.count)
+
+    def merge_analysis_mercurial_devel(self):
+        repo = gl_repo('mercurial-devel')
+        self.hg_operations_service.InvalidateMergeAnalysis(
+            InvalidateMergeAnalysisRequest(repository=repo)
+        )
+        # an actual merge, without conflicts
+        future = self.hg_operations_service.MergeAnalysis.future(
+            MergeAnalysisRequest(
+                repository=repo,
+                source_revision=b'412fd1f5d8bc',
+                target_revision=b'ff85442d08d7',
+            ),
+            timeout=120)
+        future.result()  # see also unary_future_with_cancellation()
+
+    def assert_requests(self):
+        """Run all requiests exactly once.
+
+        If one of them fails (typically due to a programming mistake),
+        better to know it before running thousands of them
+        """
+        for (name, _w) in self.weighted_methods:
+            if name != 'sleep_a_bit':
+                self.run_one(name)  # TODO check exit code
+
+
+def cancel_in(future, ms):
+    time.sleep(ms / 1000)
+    logger.info("Client-side cancellation")
+    future.cancel()
+
+
+def spawn_cancel_thread(*args):
+    t = threading.Thread(target=cancel_in, args=args)
+    t.start()
+    return t
+
+
+def unary_future_with_cancellation(future, cancel_in_ms):
+    """Actually send the request, but cancel it first."""
+    t = spawn_cancel_thread(future, cancel_in_ms)
+    try:
+        return future.result()
+    finally:
+        t.join()
+
+
+def streaming_future_with_cancellation(future, cancel_in_ms):
+    """Actually send the request, but cancel it first."""
+    t = spawn_cancel_thread(future, cancel_in_ms)
+    try:
+        for resp in future:
+            yield resp
+    finally:
+        t.join()
+
+
+LoadWorker.compute_random_thresholds()
+x = LoadWorker.random_method()
+x = LoadWorker.random_method()
+x = LoadWorker.random_method()
+
+
+def worker(wid, url, queue, iterations):
+    worker = LoadWorker(url, queue, wid=wid)
+    worker.run_test(iterations)
+    queue.put(('DONE', wid))
+
+
+def load_test():
+    parser = argparse.ArgumentParser(
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+        description=__doc__)
+
+    parser.add_argument('--url', '--rhgitaly-url',
+                        help="URL of the RHGitaly server",
+                        default='tcp://127.0.0.1:9237')
+    parser.add_argument('-c', '--concurrency', type=int, default=6)
+    parser.add_argument('--iterations', type=int, default=1000,
+                        help="Number of iteration per client worker")
+    parser.add_argument('-l', '--logging-level', default='info')
+    cl_args = parser.parse_args()
+
+    logging.basicConfig(level=getattr(logging,
+                                      cl_args.logging_level.upper()))
+
+    concurrency = cl_args.concurrency
+
+    prepare_worker = LoadWorker(cl_args.url, queue=None)
+    prepare_worker.ensure_repos()
+    prepare_worker.assert_requests()
+    prepare_worker.close()
+
+    logger.warning("Preflight check of all requests passed. Proceeding to "
+                   "actual load test")
+
+    queue = mp.Queue()
+
+    ctx = mp.get_context('fork')
+    processes = [ctx.Process(target=worker,
+                             args=(i, cl_args.url, queue, cl_args.iterations))
+                 for i in range(concurrency)]
+
+    for p in processes:
+        p.start()
+
+    done_process_ids = []
+    results = {}
+    while len(done_process_ids) < len(processes):
+        res = queue.get()
+        if res[0] == 'DONE':
+            wid = res[1]
+            processes[wid].join()
+            done_process_ids.append(wid)
+            logger.warning("Worker %d is done", wid)
+        else:
+            (results.setdefault(res[1], {})
+             .setdefault(res[0], [])
+             .append(res[2])
+             )
+
+    error_stats = {}
+    for code, details in results.items():
+        if code != 'OK':
+            for name, times in details.items():
+                error_stats.setdefault(name, {})[code] = dict(
+                    count=len(times),
+                    mean_time=statistics.mean(times)
+                )
+
+    successes = results.get('OK', {})
+    stats = {}
+    for name, times in successes.items():
+        mstats = stats[name] = dict(
+            count=len(times),
+            median=statistics.mean(times),
+            mean=statistics.median(times),
+            standard_deviation=statistics.pstdev(times),
+        )
+        if len(times) > 1:
+
+            deciles = statistics.quantiles(times, method='inclusive', n=10)
+            centiles = statistics.quantiles(times, method='inclusive',
+                                            n=100)
+            mstats["best_centile"] = centiles[0]
+            mstats["best_decile"] = deciles[0],
+            mstats["worst_centile"] = centiles[-1],
+            mstats["worst_decile"] = deciles[-1],
+
+            print(f"\n\nRESULTS for concurrency={concurrency}: ")
+    print(json.dumps(stats, indent=2))
+
+    if error_stats:
+        print(f"\n\nERRORS for concurrency={concurrency}: ")
+        print(json.dumps(error_stats, indent=2))

{hgitaly-18.7.0a1 → hgitaly-18.7.2}/hgitaly/service/commit.py

@@ -559,6 +559,14 @@ class CommitServicer(CommitServiceServicer, HGitalyServicer):
         if request.max_parents == 1:
             revset += b" and not merge()"
 
+        if request.paths:
+            revset += b" and ("
+            revset += b" or ".join(
+                b'file("%s/%s")' % (repo.root, p)
+                for p in request.paths
+            )
+            revset += b")"
+
         Order = ListCommitsRequest.Order
         reverse = request.reverse
 

{hgitaly-18.7.0a1 → hgitaly-18.7.2}/hgitaly/service/tests/test_commit.py

@@ -223,6 +223,11 @@ def test_find_commits(commit_fixture_empty_repo):
     # when revision does not exists (including special Node IDs)
     for rev in (b'does_not_exists',
                 b'1234deadbeaf',
+                b'1234dead' * 5,
+                b'unknown..%s' % ctx1.hex(),
+                b'%s..unknown' % ctx1.hex(),
+                b'unknown...%s' % ctx1.hex(),
+                b'%s...unknown' % ctx1.hex(),
                 b'ffffffff' * 5,
                 b'ffffffff'):
         with pytest.raises(grpc.RpcError) as exc_info:
@@ -805,6 +810,13 @@ def test_list_commits(commit_fixture_empty_repo):
     # author regexp
     assert list_commits(sha4, author=b't.stuser') == [sha3]
 
+    # paths
+    assert list_commits(sha4, paths=[b'animals']) == [sha3]
+    assert list_commits(sha4, paths=[b'anim*']) == [sha3]
+    # Mercurial does not count the merge (see also comment in Comp test)
+    assert list_commits(sha4,
+                        paths=[b'foo', b'animals']) == [sha3, sha2, sha0]
+
     # unknown revision, including special cases:
     for unknown in ('branch/unknown',
                     'f' * 39,  # wdir node id, prefix

{hgitaly-18.7.0a1 → hgitaly-18.7.2/hgitaly.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hgitaly
-Version: 18.7.0a1
+Version: 18.7.2
 Summary: Server-side implementation of Gitaly protocol for Mercurial
 Home-page: https://foss.heptapod.net/heptapod/hgitaly
 Author: Georges Racinet
@@ -10,7 +10,7 @@ Keywords: hg mercurial heptapod gitlab
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: heptapod>=5.4.0
+Requires-Dist: heptapod~=5.5.0
 Requires-Dist: protobuf~=6.31.1
 Requires-Dist: grpcio~=1.76.0
 Requires-Dist: grpcio-status~=1.76.0