hgitaly 2.5.3__tar.gz → 2.5.5__tar.gz

{hgitaly-2.5.3 → hgitaly-2.5.5}/.hgtags

@@ -118,3 +118,5 @@ a118debbf0a0deaa94b02ed0007ab2ef0f2b73c3 2.4.0
 c1b00e1bc1bf0a2d41907b345c48cf795f910a4f 2.5.0
 136dff98ddc1315e6db9479d9b6dd2c2204c2e5f 2.5.1
 7dbcba18d83708ff81d8cec9696a86d24ed5d20a 2.5.2
+3a83836b7408f1318a80f1ba97051086596edd12 2.5.3
+3c955f8f106db667acb67a1cc5fa06b4a7e218e6 2.5.4

{hgitaly-2.5.3 → hgitaly-2.5.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hgitaly
-Version: 2.5.3
+Version: 2.5.5
 Summary: Server-side implementation of Gitaly protocol for Mercurial
 Home-page: https://foss.heptapod.net/heptapod/hgitaly
 Author: Georges Racinet

hgitaly-2.5.5/hgitaly/VERSION

@@ -0,0 +1 @@
+2.5.5

{hgitaly-2.5.3 → hgitaly-2.5.5}/hgitaly/diff.py

@@ -46,17 +46,19 @@ Status_Type_Map = dict(
     added=ChangedPaths.Status.ADDED,
     modified=ChangedPaths.Status.MODIFIED,
     removed=ChangedPaths.Status.DELETED,
+    renamed=ChangedPaths.Status.RENAMED,
     # Note: Mercurial includes TYPE_CHANGE
     # (symlink, regular file, submodule...etc) in MODIFIED status
 )
 """Mapping status object attributes to ChangedPaths enum."""
 
 COPIED = ChangedPaths.Status.COPIED
+RENAMED = ChangedPaths.Status.RENAMED
 DIFF_HUNKS_START_RX = re.compile(rb'^(--- )|^(Binary file)')
 """To match the header line right before hunks start getting dumped."""
 
 
-def changed_paths(repo, from_ctx, to_ctx, base_path):
+def changed_paths(repo, from_ctx, to_ctx, base_path, find_renames=False):
     if base_path is None:
         matcher = None
         path_trim_at = 0
@@ -74,26 +76,33 @@ def changed_paths(repo, from_ctx, to_ctx, base_path):
             patterns=[b'path:' + base_path])
         path_trim_at = len(base_path) + 1
 
-    copied = list(copy_changed_paths(
-        from_ctx,
-        to_ctx,
-        copies.pathcopies(from_ctx, to_ctx, match=matcher),
-        trim_at=path_trim_at))
-    copied_paths = set(cp.path for cp in copied)
+    copy_info = copies.pathcopies(from_ctx, to_ctx, match=matcher)
+    # copies do not distinguish actual copies from renames. The difference
+    # will be that a rename goes with deletion of the original.
 
     status = from_ctx.status(to_ctx, match=matcher)
-    for path in status_changed_paths(from_ctx, to_ctx, status,
-                                     trim_at=path_trim_at):
-        if path.path not in copied_paths:
-            yield path
-
-    yield from iter(copied)
-
-
-def status_changed_paths(from_ctx, to_ctx, status, trim_at=0):
+    # this will remove renames from copy_info, keeping only actual copies
+    yield from status_changed_paths(from_ctx, to_ctx, status, copy_info,
+                                    find_renames=find_renames,
+                                    trim_at=path_trim_at)
+    yield from copy_changed_paths(from_ctx,
+                                  to_ctx,
+                                  copy_info,
+                                  trim_at=path_trim_at)
+
+
+def status_changed_paths(from_ctx, to_ctx, status, copy_info,
+                         find_renames=False, trim_at=0):
+    rcopy_info = {v: k for k, v in copy_info.items()}
     """Return ChangedPaths from Mercurial status object"""
     for stype in ['added', 'modified', 'removed']:
         for path in status.__getattribute__(stype):
+            copied_from = copy_info.get(path)
+            if copied_from is not None:
+                if copied_from not in status.removed or find_renames:
+                    continue
+
+            old_path = b''
             if stype == 'added':
                 old_mode = OBJECT_MODE_DOES_NOT_EXIST
                 old_blob_id = NULL_BLOB_OID
@@ -102,8 +111,21 @@ def status_changed_paths(from_ctx, to_ctx, status, trim_at=0):
                 old_blob_id = ctx_blob_oid(from_ctx, path)
 
             if stype == 'removed':
-                new_mode = OBJECT_MODE_DOES_NOT_EXIST
-                new_blob_id = NULL_BLOB_OID
+                new_path = rcopy_info.get(path)
+                if new_path is None:
+                    new_mode = OBJECT_MODE_DOES_NOT_EXIST
+                    new_blob_id = NULL_BLOB_OID
+                else:
+                    del copy_info[new_path]
+                    if find_renames:
+                        stype = 'renamed'
+                        old_path = path
+                        path = new_path
+                        new_mode = git_perms(to_ctx.filectx(new_path))
+                        new_blob_id = ctx_blob_oid(to_ctx, new_path)
+                    else:
+                        new_mode = OBJECT_MODE_DOES_NOT_EXIST
+                        new_blob_id = NULL_BLOB_OID
             else:
                 new_mode = git_perms(to_ctx.filectx(path))
                 new_blob_id = ctx_blob_oid(to_ctx, path)
@@ -114,11 +136,13 @@ def status_changed_paths(from_ctx, to_ctx, status, trim_at=0):
                 new_mode=new_mode,
                 old_blob_id=old_blob_id,
                 new_blob_id=new_blob_id,
+                old_path=old_path,
                 status=Status_Type_Map[stype]
             )
 
 
-def copy_changed_paths(from_ctx, to_ctx, path_copies, trim_at=0):
+def copy_changed_paths(from_ctx, to_ctx, path_copies,
+                       trim_at=0, find_renames=False):
     """Return ChangedPaths for the given paths, relative to base_path.
 
     Given that Gitaly currently (gitaly@c54d613d0) does not pass
@@ -129,8 +153,11 @@ def copy_changed_paths(from_ctx, to_ctx, path_copies, trim_at=0):
     for target, source in path_copies.items():
         yield ChangedPaths(path=target[trim_at:],
                            status=COPIED,
-                           old_mode=git_perms(to_ctx.filectx(source)),
+                           old_mode=git_perms(from_ctx.filectx(source)),
+                           old_blob_id=ctx_blob_oid(from_ctx, source),
                            new_mode=git_perms(to_ctx.filectx(target)),
+                           new_blob_id=ctx_blob_oid(to_ctx, target),
+                           old_path=source[trim_at:],
                            )
 
 

{hgitaly-2.5.3 → hgitaly-2.5.5}/hgitaly/message.py

@@ -87,6 +87,10 @@ def message_to_string(message):
     return result
 
 
+def as_dict(message):
+    return {descr.name: value for descr, value in message.ListFields()}
+
+
 class Logging:
     """Wrapper of requests and responses for sensible logging.
 

{hgitaly-2.5.3 → hgitaly-2.5.5}/hgitaly/service/diff.py

@@ -521,8 +521,11 @@ class DiffServicer(DiffServiceServicer, HGitalyServicer):
                                        for cp in cids_paths]
                 extracted.append((left_ctx, right_ctx, path))
 
+        find_renames = request.find_renames
         for paths in chunked(path for extr in extracted
-                             for path in changed_paths(repo, *extr)):
+                             for path in changed_paths(
+                                     repo, *extr,
+                                     find_renames=find_renames)):
             yield FindChangedPathsResponse(paths=paths)
 
     def GetPatchID(self, request: GetPatchIDRequest,

{hgitaly-2.5.3 → hgitaly-2.5.5}/hgitaly/service/ref.py

@@ -28,6 +28,8 @@ from hgext3rd.heptapod.special_ref import (
 )
 from hgext3rd.heptapod.keep_around import (
     parse_keep_around_ref,
+    iter_keep_arounds,
+    init_keep_arounds,
 )
 
 from ..errors import (
@@ -40,6 +42,8 @@ from ..pagination import (
 )
 from ..revision import (
     CHANGESET_HASH_BYTES_REGEXP,
+    ZERO_SHA,
+    ZERO_SHA_STR,
     gitlab_revision_hash,
 )
 from ..stream import (
@@ -51,6 +55,7 @@ from ..stub.shared_pb2 import (
 )
 from ..stub.errors_pb2 import (
     ReferenceNotFoundError,
+    ReferenceStateMismatchError,
 )
 from ..stub.ref_pb2 import (
     FindDefaultBranchNameRequest,
@@ -74,6 +79,9 @@ from ..stub.ref_pb2 import (
     FindBranchResponse,
     DeleteRefsRequest,
     DeleteRefsResponse,
+    UpdateReferencesError,
+    UpdateReferencesRequest,
+    UpdateReferencesResponse,
     ListBranchNamesContainingCommitRequest,
     ListBranchNamesContainingCommitResponse,
     ListTagNamesContainingCommitRequest,
@@ -87,9 +95,6 @@ from ..stub.ref_pb2 import (
 )
 from ..stub.ref_pb2_grpc import RefServiceServicer
 
-from ..revision import (
-    ZERO_SHA_STR,
-)
 from ..branch import (
     BranchSortBy,
     gitlab_branch_head,
@@ -273,6 +278,93 @@ class RefServicer(RefServiceServicer, HGitalyServicer):
         return FindBranchResponse(
             branch=Branch(name=name, target_commit=message.commit(head)))
 
+    def UpdateReferences(self,
+                         request: UpdateReferencesRequest,
+                         context) -> UpdateReferencesResponse:
+        self.STATUS_CODE_STORAGE_NOT_FOUND = StatusCode.INVALID_ARGUMENT
+        first = True
+        special_changes = []
+        ka_changes = []
+        for req in request:
+            if first:
+                # blobs are given by oid, hence as in direct changeset Node
+                # IDs, the unfiltered repo is the right one for the task
+                repo = self.load_repo(req.repository, context).unfiltered()
+                first = False
+
+            for upd in req.updates:
+                if len(upd.new_object_id) != 40:
+                    oid = upd.new_object_id.decode('ascii', 'replace')
+                    context.abort(StatusCode.INVALID_ARGUMENT,
+                                  "validating new object ID: "
+                                  f'invalid object ID: "{oid}", '
+                                  f"expected length 40, got {len(oid)}")
+
+                ref_path = upd.reference
+                change = (upd.old_object_id, upd.new_object_id)
+                if change[0] == change[1]:
+                    # let's not waste resources for this
+                    continue
+
+                # consider only special refs and keep-arounds, as other refs
+                # (branches and tags) are only reflecting changesets content,
+                # setting them independently makes no sense with Mercurial
+                special_ref = parse_special_ref(ref_path)
+                if special_ref is not None:
+                    special_changes.append((special_ref, change))
+                    continue
+
+                ka = parse_keep_around_ref(upd.reference)
+                if ka is not None:
+                    if (
+                            upd.new_object_id != ZERO_SHA
+                            and ka != upd.new_object_id
+                    ):
+                        context.abort(StatusCode.INVALID_ARGUMENT,
+                                      "Inconsistent keep-around.")
+                    ka_changes.append(change)
+
+        with repo.lock():
+            # keeping promise of atomicity of this method
+            special_existing = special_refs(repo)
+            if special_existing is GITLAB_TYPED_REFS_MISSING:
+                special_existing = {}
+            for name, (old_id, new_id) in special_changes:
+                existing = special_existing.get(name)
+                if old_id == ZERO_SHA and existing is not None:
+                    context.abort(StatusCode.INTERNAL,
+                                  "committing update: "
+                                  "reference already exists")
+                elif old_id and old_id != ZERO_SHA and existing != old_id:
+                    Mismatch = ReferenceStateMismatchError  # just too long!
+                    structured_abort(
+                        context, StatusCode.ABORTED,
+                        "reference does not point to expected object",
+                        UpdateReferencesError(
+                            reference_state_mismatch=Mismatch(
+                                reference_name=b'refs/' + name,
+                                expected_object_id=old_id,
+                                actual_object_id=existing)))
+                elif new_id == ZERO_SHA:
+                    del special_existing[name]
+                else:
+                    special_existing[name] = new_id
+
+            # TODO make a collect_keep_arounds() or keep_arounds_set()
+            ka_existing = set(iter_keep_arounds(repo))
+            ka_existing.discard(GITLAB_TYPED_REFS_MISSING)
+            for old_id, new_id in ka_changes:
+                # bogus requests have already been prohibited
+                if new_id == ZERO_SHA:
+                    ka_existing.discard(old_id)
+                else:
+                    ka_existing.add(new_id)
+
+            write_special_refs(repo, special_existing)
+            init_keep_arounds(repo, ka_existing)
+
+        return UpdateReferencesResponse()
+
     def DeleteRefs(self,
                    request: DeleteRefsRequest,
                    context) -> DeleteRefsResponse:

{hgitaly-2.5.3 → hgitaly-2.5.5}/hgitaly/service/tests/test_diff.py

@@ -127,7 +127,7 @@ class DiffFixture(ServiceFixture):
                     (changed.status, perm_change))
         return by_file
 
-    def find_changed_paths_commits(self, commits, compare_to=()):
+    def find_changed_paths_commits(self, commits, compare_to=(), **kw):
         """Wrap FindChangedPaths used with CommitRequest.
 
         :param compare_to: if given, will be used in all requests, hoping
@@ -141,6 +141,7 @@ class DiffFixture(ServiceFixture):
                         commit_revision=c,
                         parent_commit_revisions=compare_to))
                 for c in commits],
+            **kw
         )
 
     def find_changed_paths_tree(self, left_oid, right_oid):
@@ -686,6 +687,50 @@ def test_find_changed_paths_copy_in_tree(diff_fixture):
     }
 
 
+def test_find_changed_paths_rename(diff_fixture):
+    wrapper = diff_fixture.repo_wrapper
+
+    (wrapper.path / 'subdir').mkdir()  # avoid all lengths to be 3
+    (wrapper.path / 'subdir/bar').write_text('some bar')
+    ctx0 = wrapper.commit(rel_paths=['subdir'], add_remove=True)
+
+    wrapper.command(b'mv', wrapper.repo.root + b'/subdir/bar',
+                    wrapper.repo.root + b'/subdir/baz')
+    ctx1 = wrapper.commit(rel_paths=['subdir'])
+
+    repo = wrapper.repo
+
+    sub0_oid, sub1_oid = [tree_oid(repo, ctx.hex().decode('ascii'), b'subdir')
+                          for ctx in (ctx0, ctx1)]
+    ret = diff_fixture.find_changed_paths_commits(
+        [ctx1.hex()],
+        compare_to=[ctx0.hex()],
+        find_renames=False,
+    )
+    assert ret == {
+        b'subdir/baz': [(ChangedPaths.Status.ADDED,
+                         (OBJECT_MODE_DOES_NOT_EXIST,
+                          OBJECT_MODE_NON_EXECUTABLE),
+                         )],
+        b'subdir/bar': [(ChangedPaths.Status.DELETED,
+                         (OBJECT_MODE_NON_EXECUTABLE,
+                          OBJECT_MODE_DOES_NOT_EXIST)
+                         )],
+    }
+
+    ret = diff_fixture.find_changed_paths_commits(
+        [ctx1.hex()],
+        compare_to=[ctx0.hex()],
+        find_renames=True,
+    )
+    assert ret == {
+        b'subdir/baz': [(ChangedPaths.Status.RENAMED, None)],
+    }
+
+    # TODO test the case of rename with duplication:
+    # hg cp foo bar; hg mv foo bar2
+
+
 def test_get_patch_id(diff_fixture):
     wrapper = diff_fixture.repo_wrapper
     patch_id = diff_fixture.get_patch_id

{hgitaly-2.5.3 → hgitaly-2.5.5}/hgitaly/service/tests/test_ref.py

@@ -30,6 +30,7 @@ from hgext3rd.heptapod.keep_around import (
 from hgitaly import feature
 from hgitaly.errors import parse_assert_structured_error
 from hgitaly.revision import (
+    ZERO_SHA,
     ZERO_SHA_STR,
 )
 from hgitaly.tests.common import (
@@ -56,6 +57,7 @@ from hgitaly.stub.ref_pb2 import (
     FindRefsByOIDRequest,
     FindTagError,
     FindTagRequest,
+    UpdateReferencesRequest,
 )
 from hgitaly.stub.ref_pb2_grpc import RefServiceStub
 
@@ -85,6 +87,10 @@ class RefFixture(ServiceFixture):
             metadata=feature.as_grpc_metadata(self.feature_flags),
         )
 
+    def ref_exists(self, ref, **kw):
+        kw.setdefault('repository', self.grpc_repo)
+        return self.stub.RefExists(RefExistsRequest(ref=ref, **kw)).value
+
     def list_refs(self, patterns=(b"refs/", ), **kw):
         return [(ref.name, ref.target)
                 for resp in self.stub.ListRefs(
@@ -97,6 +103,22 @@ class RefFixture(ServiceFixture):
         kw.setdefault('repository', self.grpc_repo)
         return self.stub.FindRefsByOID(FindRefsByOIDRequest(**kw)).refs
 
+    def update_refs(self, updates, **kw):
+        Update = UpdateReferencesRequest.Update
+        kw.setdefault('repository', self.grpc_repo)
+
+        update_messages = []
+        for ref_path, old_id, new_id in updates:
+            upd_kw = dict(reference=ref_path, new_object_id=new_id)
+            if old_id is not None:
+                upd_kw['old_object_id'] = old_id
+            update_messages.append(Update(**upd_kw))
+
+        return self.stub.UpdateReferences(
+            iter([UpdateReferencesRequest(updates=[upd], **kw)
+                  for upd in update_messages])
+        )
+
 
 @pytest.fixture
 def ref_fixture(grpc_channel, server_repos_root):
@@ -633,3 +655,58 @@ def test_list_refs(ref_fixture):
     assert fixture.find_refs_by_oid(
         oid=sha1, sort_field='refname', limit=1
     ) == ['refs/heads/branch/default']
+
+
+def test_update_references(ref_fixture):
+    fixture = ref_fixture
+    wrapper = fixture.repo_wrapper
+
+    sha0 = wrapper.write_commit('afoo', message="Some foo").hex()
+    sha1 = wrapper.write_commit('afoo', message="Some foo").hex()
+
+    pipeline_1 = b'refs/pipelines/1'
+    ka_0 = b'refs/keep-around/' + sha0
+    fixture.update_refs([(pipeline_1, ZERO_SHA, sha1),
+                         (ka_0, ZERO_SHA, sha0),
+                         ])
+    assert fixture.ref_exists(ka_0)
+    assert fixture.ref_exists(pipeline_1)
+    assert fixture.list_refs(patterns=[b'refs/pipelines/']) == [
+        (pipeline_1, sha1.decode())
+    ]
+
+    fixture.update_refs([(pipeline_1, sha1, sha0),
+                         (ka_0, sha0, ZERO_SHA),
+                         ])
+    assert not fixture.ref_exists(ka_0)
+    assert fixture.list_refs(patterns=[b'refs/pipelines/']) == [
+        (pipeline_1, sha0.decode())
+    ]
+
+    # edge case equivalent to no-op
+    fixture.update_refs([(pipeline_1, sha0, sha0)])
+    assert fixture.list_refs(patterns=[b'refs/pipelines/']) == [
+        (pipeline_1, sha0.decode())
+    ]
+
+    # error cases
+    with pytest.raises(grpc.RpcError) as exc_info:
+        fixture.update_refs([(pipeline_1, None, b'branch/default')])
+    assert exc_info.value.code() == grpc.StatusCode.INVALID_ARGUMENT
+
+    with pytest.raises(grpc.RpcError) as exc_info:
+        fixture.update_refs([(ka_0, None, sha1)])
+    assert exc_info.value.code() == grpc.StatusCode.INVALID_ARGUMENT
+
+    with pytest.raises(grpc.RpcError) as exc_info:
+        fixture.update_refs([(pipeline_1, ZERO_SHA, sha1)])
+    assert exc_info.value.code() == grpc.StatusCode.INTERNAL
+    assert 'reference already exists' in exc_info.value.details()
+
+    with pytest.raises(grpc.RpcError) as exc_info:
+        fixture.update_refs([(pipeline_1, sha1, sha0)])
+    assert exc_info.value.code() == grpc.StatusCode.ABORTED
+
+    # deletions
+    fixture.update_refs([(pipeline_1, sha0, ZERO_SHA)])
+    assert not fixture.ref_exists(pipeline_1)

{hgitaly-2.5.3 → hgitaly-2.5.5}/hgitaly/tests/test_messages.py

@@ -54,6 +54,11 @@ def test_tag(tmpdir):
     assert tag.signature_type == SignatureType.PGP
 
 
+def test_as_dict():
+    d = dict(storage_name='thestore', relative_path='a/b/c')
+    assert message.as_dict(Repository(**d)) == d
+
+
 def test_commit_author():
 
     class FakeContext:

{hgitaly-2.5.3 → hgitaly-2.5.5}/hgitaly.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: hgitaly
-Version: 2.5.3
+Version: 2.5.5
 Summary: Server-side implementation of Gitaly protocol for Mercurial
 Home-page: https://foss.heptapod.net/heptapod/hgitaly
 Author: Georges Racinet

{hgitaly-2.5.3 → hgitaly-2.5.5}/tests_with_gitaly/comparison.py

@@ -35,6 +35,7 @@ from hgitaly.errors import (
     parse_structured_error,
 )
 from hgitaly import feature
+from hgitaly import message
 from hgitaly.errors import HGITALY_ISSUES_URL
 from hgitaly.gitlab_ref import (
     keep_around_ref_path,
@@ -264,6 +265,59 @@ class BaseRpcHelper:
             for k, v in defaults.items():
                 kwargs.setdefault(k, v)
 
+    def structured_errors_git_converter(self, fields, error_git_cls=None):
+        """Return a function that is suitable for `to_git` in handler.
+
+        This matches the common pattern of the structured error being
+        an enum with subobject variants
+        Only full hash string or bytes values are supported and lists of
+        these are supported at this point
+
+        :param fields: a list of :class:`dict`with keys:
+
+          - `hg_field`: name of the variant for HGitaly
+          - `git_field`: name of the variant for Gitaly,
+                        defaults to `hg_field`
+          - `git_cls`: variant class to use for Gitaly, defaults to the
+                       received HGitaly variant class
+          - `subfields`: list of names of fields in the varian to convert.
+                         Use the `[]` suffix to specify that a field is
+                         repeated.
+        """
+        def to_git(error):
+            if error_git_cls is None:
+                error_git_class = error.__class__  # pragma no cover
+            else:
+                error_git_class = error_git_cls
+            for descr in fields:
+                name = descr['hg_field']
+                new_name = descr.get('git_field', name)
+                if error.HasField(name):
+                    subobj = getattr(error, name)
+                    git_cls = descr.get('git_cls', subobj.__class__)
+                    # direct assignment to repeated values is not possible
+                    # so we copy in a dict and reinstantiate
+                    subitems = message.as_dict(subobj)
+                    for field in descr['subfields']:
+                        repeated = field.endswith('[]')
+                        if repeated:
+                            field = field[:-2]
+                        hg_val = subitems.get(field)
+                        if hg_val is None:
+                            continue  # pragma no cover
+
+                        if repeated:
+                            git_val = [self.hg2git(sha) for sha in hg_val]
+                        else:
+                            git_val = self.hg2git(hg_val)
+                        subitems[field] = git_val
+                    subobj = git_cls(**subitems)
+                    return error_git_class(**{new_name: subobj})
+
+            raise AssertionError("Unexpected error variant")  # pragma no cover
+
+        return to_git
+
     def assert_compare_grpc_exceptions(self, exc0, exc1,
                                        same_details=True,
                                        vcses=('hg', 'git'),
@@ -319,12 +373,13 @@ class BaseRpcHelper:
                 if extracted:
                     assert extracted[0]['code'] == extracted[1]['code']
                     if vcses[1] == 'git':
-                        git_norm = handler.get('git_normalizer')
-                        if git_norm is not None:
-                            git_norm(extracted[1]['error'])
                         extracted[0]['error'] = handler['to_git'](
                             extracted[0]['error'])
 
+                    norm = handler.get('normalizer')
+                    if norm is not None:
+                        norm(extracted[0]['error'])
+                        norm(extracted[1]['error'])
                     assert extracted[0]['error'] == extracted[1]['error']
 
                 # already done and a priori not directly comparable
@@ -413,15 +468,17 @@ class RpcHelper(BaseRpcHelper):
         return keep_around_ref_path(self.hg2git(hg_sha))
 
     def request_kwargs_to_git(self, hg_kwargs):
-        git_kwargs = hg_kwargs.copy()
-        for sha_attr in self.request_sha_attrs:
-            sha = hg_kwargs.get(sha_attr)
-            if sha is None:
-                continue
-            if isinstance(sha, list):
-                git_kwargs[sha_attr] = [self.revspec_to_git(s) for s in sha]
-            else:
-                git_kwargs[sha_attr] = self.revspec_to_git(sha)
+        # attr_path_to_git updates lists in place, because it needs
+        # to do so in the case of scalar lists for Messages. Hence in the
+        # case of dicts, we need to perform the deep copy.
+        git_kwargs = deepcopy(hg_kwargs)
+        sha_attr_paths = [path.split('.') for path in self.request_sha_attrs]
+        for attr_path in sha_attr_paths:
+            self.attr_path_to_git(git_kwargs, attr_path,
+                                  accessor=lambda d, k: d.get(k),
+                                  setter=lambda d, k, v: d.__setitem__(k, v),
+                                  has_field=lambda d, f: f in d,
+                                  )
         return git_kwargs
 
     def revspec_to_git(self, revspec):
@@ -445,16 +502,20 @@ class RpcHelper(BaseRpcHelper):
     def response_to_git(self, resp):
         sha_attr_paths = [path.split('.') for path in self.response_sha_attrs]
         if self.streaming:
-            for message in resp:
-                self.message_to_git(message, sha_attr_paths)
+            for msg in resp:
+                self.message_to_git(msg, sha_attr_paths)
         else:
             self.message_to_git(resp, sha_attr_paths)
 
-    def message_to_git(self, message, attr_paths):
+    def message_to_git(self, message, attr_paths, **kw):
         for attr_path in attr_paths:
-            self.attr_path_to_git(message, attr_path)
+            self.attr_path_to_git(message, attr_path, **kw)
 
-    def attr_path_to_git(self, message, attr_path):
+    def attr_path_to_git(self, message, attr_path,
+                         accessor=getattr,
+                         setter=setattr,
+                         has_field=lambda o, f: o.HasField(f),
+                         ):
         """Convert to Git part of message specified by an attr_path.
 
         :param attr_path: symbolic representation, as a succession of dotted
@@ -475,11 +536,14 @@ class RpcHelper(BaseRpcHelper):
             if recurse:
                 attr_name = attr_name[:-2]
             # HasField cannot be used on repeated attributes, hence the elif
-            elif not obj.HasField(attr_name):
+            elif not has_field(obj, attr_name):
                 return
-            obj = getattr(obj, attr_name)
+            obj = accessor(obj, attr_name)
+            if obj is None:  # can happen with an accessor for dicts
+                continue  # pragma no cover TODO make unit tests for RpcHelper
             if recurse:
                 for msg in obj:
+                    # after traversal, we are sure to be on a Message instance
                     self.message_to_git(msg, [trav])
                 return
 
@@ -487,13 +551,15 @@ class RpcHelper(BaseRpcHelper):
         scalar_list = obj_attr.endswith('[]')
         if scalar_list:
             obj_attr = obj_attr[:-2]
-        value = getattr(obj, obj_attr)
+        value = accessor(obj, obj_attr)
+        if value is None:
+            return
 
         if scalar_list:
             for i, sha in enumerate(value):
-                value[i] = self.hg2git(sha)
+                value[i] = self.revspec_to_git(sha)
         else:
-            setattr(obj, obj_attr, self.hg2git(value))
+            setter(obj, obj_attr, self.revspec_to_git(value))
 
     def call_backends(self, **hg_kwargs):
         """Call Gitaly and HGitaly with uniform request kwargs.