Merge branch 'master' into octopus

NEWS

@@ -3,13 +3,29 @@
  * Add support for octopus merge strategy. (Jelmer Vernooij, #1816)
 
  * Add support for ``git show-branch`` command to display branches and their
+
+ * Add ``dulwich cherry`` command to find commits not merged upstream.
+   Compares commits by patch ID to identify equivalent patches regardless of
+   commit metadata. Supports automatic upstream detection from tracking branches
+   and verbose mode to display commit messages. (Jelmer Vernooij, #1782)
+
+ * Add support for ``git mailsplit`` command to split mbox files and Maildir
+   into individual message files. Supports mboxrd format, custom precision,
+   and all standard git mailsplit options. (Jelmer Vernooij, #1840)
+
+ * Add support for ``dulwich show-branch`` command to display branches and their
    commits. Supports filtering by local/remote branches, topological ordering,
    list mode, independent branch detection, and merge base calculation.
    (Jelmer Vernooij, #1829)
 
+ * Add ``dulwich config`` command to get and set repository or global
+   configuration options. Supports getting/setting values, listing all config,
+   getting all values for multivars, and unsetting values.
+   (Jelmer Vernooij, #1775)
+
 0.24.5	2025-10-15
 
- * Add support for ``git show-ref`` command to list references in a local
+ * Add support for ``dulwich show-ref`` command to list references in a local
    repository. Supports filtering by branches/tags, pattern matching,
    dereferencing tags, verification mode, and existence checking. Available
    as ``porcelain.show_ref()`` and ``dulwich show-ref`` CLI command.
@@ -35,11 +51,7 @@
 
  * Add ``dulwich merge-base`` command. (Jelmer Vernooij, #1831)
 
- * Add support for ``git mailsplit`` command to split mbox files and Maildir
-   into individual message files. Supports mboxrd format, custom precision,
-   and all standard git mailsplit options. (Jelmer Vernooij, #1840)
-
- * Add support for ``git var`` command to display Git's logical variables
+ * Add support for ``dulwich var`` command to display Git's logical variables
    (GIT_AUTHOR_IDENT, GIT_COMMITTER_IDENT, GIT_EDITOR, GIT_SEQUENCE_EDITOR,
    GIT_PAGER, GIT_DEFAULT_BRANCH). Available as ``porcelain.var()`` and
    ``dulwich var`` CLI command. (Jelmer Vernooij, #1841)
@@ -59,7 +71,7 @@
    other filters that send status messages in final headers.
    (Jelmer Vernooij, #1889)
 
- * Add ``git worktree repair`` command to repair worktree administrative files
+ * Add ``dulwich worktree repair`` command to repair worktree administrative files
    after worktrees or the main repository have been moved.
    (Jelmer Vernooij, #1799)
 
@@ -96,7 +108,7 @@
  * Fix Windows config loading to only use current Git config path,
    avoiding loading older config files.  (Jelmer Vernooij, #1732)
 
- * Add interactive rebase support with ``git rebase -i``, including support
+ * Add interactive rebase support with ``dulwich rebase -i``, including support
    for pick, reword, edit, squash, fixup, drop, exec, and break commands.
    (Jelmer Vernooij, #1696)
 
@@ -119,7 +131,7 @@
 
  * Optimize LFS filter performance by avoiding redundant disk writes when
    checking file status. The LFS store now checks if objects already exist
-   before writing them to disk, significantly improving ``git status``
+   before writing them to disk, significantly improving ``dulwich status``
    performance in repositories with many LFS-tracked files.
    (Jelmer Vernooij, #1789)
 

dulwich/cli.py

@@ -1340,6 +1340,222 @@ def _get_commit_message_with_template(
     return message
 
 
+class cmd_config(Command):
+    """Get and set repository or global options."""
+
+    def run(self, args: Sequence[str]) -> Optional[int]:
+        """Execute the config command.
+
+        Args:
+            args: Command line arguments
+        """
+        parser = argparse.ArgumentParser()
+        parser.add_argument(
+            "--global",
+            dest="global_config",
+            action="store_true",
+            help="Use global config file",
+        )
+        parser.add_argument(
+            "--local",
+            action="store_true",
+            help="Use repository config file (default)",
+        )
+        parser.add_argument(
+            "-l",
+            "--list",
+            action="store_true",
+            help="List all variables",
+        )
+        parser.add_argument(
+            "--unset",
+            action="store_true",
+            help="Remove a variable",
+        )
+        parser.add_argument(
+            "--unset-all",
+            action="store_true",
+            help="Remove all matches for a variable",
+        )
+        parser.add_argument(
+            "--get-all",
+            action="store_true",
+            help="Get all values for a multivar",
+        )
+        parser.add_argument(
+            "key",
+            nargs="?",
+            help="Config key (e.g., user.name)",
+        )
+        parser.add_argument(
+            "value",
+            nargs="?",
+            help="Config value to set",
+        )
+        parsed_args = parser.parse_args(args)
+
+        # Determine which config file to use
+        if parsed_args.global_config:
+            # Use global config file
+            config_path = os.path.expanduser("~/.gitconfig")
+            try:
+                from .config import ConfigFile
+
+                config = ConfigFile.from_path(config_path)
+            except FileNotFoundError:
+                from .config import ConfigFile
+
+                config = ConfigFile()
+                config.path = config_path
+        else:
+            # Use local repository config (default)
+            try:
+                repo = Repo(".")
+                config = repo.get_config()
+            except NotGitRepository:
+                logger.error("error: not a git repository")
+                return 1
+
+        # Handle --list
+        if parsed_args.list:
+            for section in config.sections():
+                for key, value in config.items(section):
+                    section_str = ".".join(
+                        s.decode("utf-8") if isinstance(s, bytes) else s
+                        for s in section
+                    )
+                    key_str = key.decode("utf-8") if isinstance(key, bytes) else key
+                    value_str = (
+                        value.decode("utf-8") if isinstance(value, bytes) else value
+                    )
+                    print(f"{section_str}.{key_str}={value_str}")
+            return 0
+
+        # Handle --unset or --unset-all
+        if parsed_args.unset or parsed_args.unset_all:
+            if not parsed_args.key:
+                logger.error("error: key is required for --unset")
+                return 1
+
+            # Parse the key (e.g., "user.name" or "remote.origin.url")
+            parts = parsed_args.key.split(".")
+            if len(parts) < 2:
+                logger.error("error: invalid key format")
+                return 1
+
+            if len(parts) == 2:
+                section = (parts[0],)
+                name = parts[1]
+            else:
+                # For keys like "remote.origin.url", section is ("remote", "origin")
+                section = tuple(parts[:-1])
+                name = parts[-1]
+
+            try:
+                # Check if the key exists first
+                try:
+                    config.get(section, name)
+                except KeyError:
+                    logger.error(f"error: key '{parsed_args.key}' not found")
+                    return 1
+
+                # Delete the configuration key using ConfigDict's delete method
+                section_bytes = tuple(
+                    s.encode("utf-8") if isinstance(s, str) else s for s in section
+                )
+                name_bytes = name.encode("utf-8") if isinstance(name, str) else name
+
+                section_dict = config._values.get(section_bytes)
+                if section_dict:
+                    del section_dict[name_bytes]
+                    config.write_to_path()
+                else:
+                    logger.error(f"error: key '{parsed_args.key}' not found")
+                    return 1
+            except Exception as e:
+                logger.error(f"error: {e}")
+                return 1
+
+            return 0
+
+        # Handle --get-all
+        if parsed_args.get_all:
+            if not parsed_args.key:
+                logger.error("error: key is required for --get-all")
+                return 1
+
+            parts = parsed_args.key.split(".")
+            if len(parts) < 2:
+                logger.error("error: invalid key format")
+                return 1
+
+            if len(parts) == 2:
+                section = (parts[0],)
+                name = parts[1]
+            else:
+                section = tuple(parts[:-1])
+                name = parts[-1]
+
+            try:
+                for value in config.get_multivar(section, name):
+                    value_str = (
+                        value.decode("utf-8") if isinstance(value, bytes) else value
+                    )
+                    print(value_str)
+                return 0
+            except KeyError:
+                return 1
+
+        # Handle get (no value provided)
+        if parsed_args.key and not parsed_args.value:
+            parts = parsed_args.key.split(".")
+            if len(parts) < 2:
+                logger.error("error: invalid key format")
+                return 1
+
+            if len(parts) == 2:
+                section = (parts[0],)
+                name = parts[1]
+            else:
+                # For keys like "remote.origin.url", section is ("remote", "origin")
+                section = tuple(parts[:-1])
+                name = parts[-1]
+
+            try:
+                value = config.get(section, name)
+                value_str = value.decode("utf-8") if isinstance(value, bytes) else value
+                print(value_str)
+                return 0
+            except KeyError:
+                return 1
+
+        # Handle set (key and value provided)
+        if parsed_args.key and parsed_args.value:
+            parts = parsed_args.key.split(".")
+            if len(parts) < 2:
+                logger.error("error: invalid key format")
+                return 1
+
+            if len(parts) == 2:
+                section = (parts[0],)
+                name = parts[1]
+            else:
+                # For keys like "remote.origin.url", section is ("remote", "origin")
+                section = tuple(parts[:-1])
+                name = parts[-1]
+
+            config.set(section, name, parsed_args.value)
+            if parsed_args.global_config:
+                config.write_to_path()
+            else:
+                config.write_to_path()
+            return 0
+
+        # No action specified
+        parser.print_help()
+        return 1
+
+
 class cmd_commit(Command):
     """Record changes to the repository."""
 
@@ -3371,6 +3587,71 @@ class cmd_notes(SuperCommand):
     default_command = cmd_notes_list
 
 
+class cmd_cherry(Command):
+    """Find commits not merged upstream."""
+
+    def run(self, args: Sequence[str]) -> Optional[int]:
+        """Execute the cherry command.
+
+        Args:
+            args: Command line arguments
+
+        Returns:
+            Exit code (0 for success, 1 for error)
+        """
+        parser = argparse.ArgumentParser(description="Find commits not merged upstream")
+        parser.add_argument(
+            "-v",
+            "--verbose",
+            action="store_true",
+            help="Show commit messages",
+        )
+        parser.add_argument(
+            "upstream",
+            nargs="?",
+            help="Upstream branch (default: tracking branch or HEAD^)",
+        )
+        parser.add_argument(
+            "head",
+            nargs="?",
+            help="Head branch (default: HEAD)",
+        )
+        parser.add_argument(
+            "limit",
+            nargs="?",
+            help="Limit commits to those after this ref",
+        )
+        parsed_args = parser.parse_args(args)
+
+        try:
+            results = porcelain.cherry(
+                ".",
+                upstream=parsed_args.upstream,
+                head=parsed_args.head,
+                limit=parsed_args.limit,
+                verbose=parsed_args.verbose,
+            )
+        except (NotGitRepository, OSError, FileFormatException, ValueError) as e:
+            logger.error(f"Error: {e}")
+            return 1
+
+        # Output results
+        for status, commit_sha, message in results:
+            # Convert commit_sha to hex string
+            if isinstance(commit_sha, bytes):
+                commit_hex = commit_sha.hex()
+            else:
+                commit_hex = commit_sha
+
+            if parsed_args.verbose and message:
+                message_str = message.decode("utf-8", errors="replace")
+                logger.info(f"{status} {commit_hex} {message_str}")
+            else:
+                logger.info(f"{status} {commit_hex}")
+
+        return 0
+
+
 class cmd_cherry_pick(Command):
     """Apply the changes introduced by some existing commits."""
 
@@ -4990,10 +5271,12 @@ commands = {
     "check-ignore": cmd_check_ignore,
     "check-mailmap": cmd_check_mailmap,
     "checkout": cmd_checkout,
+    "cherry": cmd_cherry,
     "cherry-pick": cmd_cherry_pick,
     "clone": cmd_clone,
     "commit": cmd_commit,
     "commit-tree": cmd_commit_tree,
+    "config": cmd_config,
     "count-objects": cmd_count_objects,
     "describe": cmd_describe,
     "daemon": cmd_daemon,

dulwich/patch.py

@@ -648,3 +648,115 @@ def parse_patch_message(
     except StopIteration:
         version = None
     return c, diff, version
+
+
+def patch_id(diff_data: bytes) -> bytes:
+    """Compute patch ID for a diff.
+
+    The patch ID is computed by normalizing the diff and computing a SHA1 hash.
+    This follows git's patch-id algorithm which:
+    1. Removes whitespace from lines starting with + or -
+    2. Replaces line numbers in @@ headers with a canonical form
+    3. Computes SHA1 of the result
+
+    Args:
+        diff_data: Raw diff data as bytes
+
+    Returns:
+        SHA1 hash of normalized diff (40-byte hex string)
+
+    TODO: This implementation uses a simple line-by-line approach. For better
+    compatibility with git's patch-id, consider using proper patch parsing that:
+    - Handles edge cases in diff format (binary diffs, mode changes, etc.)
+    - Properly parses unified diff format according to the spec
+    - Matches git's exact normalization algorithm byte-for-byte
+    See git's patch-id.c for reference implementation.
+    """
+    import hashlib
+    import re
+
+    # Normalize the diff for patch-id computation
+    normalized_lines = []
+
+    for line in diff_data.split(b"\n"):
+        # Skip diff headers (diff --git, index, ---, +++)
+        if line.startswith(
+            (
+                b"diff --git ",
+                b"index ",
+                b"--- ",
+                b"+++ ",
+                b"new file mode ",
+                b"old file mode ",
+                b"deleted file mode ",
+                b"new mode ",
+                b"old mode ",
+                b"similarity index ",
+                b"dissimilarity index ",
+                b"rename from ",
+                b"rename to ",
+                b"copy from ",
+                b"copy to ",
+            )
+        ):
+            continue
+
+        # Normalize @@ headers to a canonical form
+        if line.startswith(b"@@"):
+            # Replace line numbers with canonical form
+            match = re.match(rb"^@@\s+-\d+(?:,\d+)?\s+\+\d+(?:,\d+)?\s+@@", line)
+            if match:
+                # Use canonical hunk header without line numbers
+                normalized_lines.append(b"@@")
+                continue
+
+        # For +/- lines, strip all whitespace
+        if line.startswith((b"+", b"-")):
+            # Keep the +/- prefix but remove all whitespace from the rest
+            if len(line) > 1:
+                # Remove all whitespace from the content
+                content = line[1:].replace(b" ", b"").replace(b"\t", b"")
+                normalized_lines.append(line[:1] + content)
+            else:
+                # Just +/- alone
+                normalized_lines.append(line[:1])
+            continue
+
+        # Keep context lines and other content as-is
+        if line.startswith(b" ") or line == b"":
+            normalized_lines.append(line)
+
+    # Join normalized lines and compute SHA1
+    normalized = b"\n".join(normalized_lines)
+    return hashlib.sha1(normalized).hexdigest().encode("ascii")
+
+
+def commit_patch_id(store: "BaseObjectStore", commit_id: bytes) -> bytes:
+    """Compute patch ID for a commit.
+
+    Args:
+        store: Object store to read objects from
+        commit_id: Commit ID (40-byte hex string)
+
+    Returns:
+        Patch ID (40-byte hex string)
+    """
+    from io import BytesIO
+
+    commit = store[commit_id]
+    assert isinstance(commit, Commit)
+
+    # Get the parent tree (or empty tree for root commit)
+    if commit.parents:
+        parent = store[commit.parents[0]]
+        assert isinstance(parent, Commit)
+        parent_tree = parent.tree
+    else:
+        # Root commit - compare against empty tree
+        parent_tree = None
+
+    # Generate diff
+    diff_output = BytesIO()
+    write_tree_diff(diff_output, store, parent_tree, commit.tree)
+
+    return patch_id(diff_output.getvalue())

dulwich/porcelain.py

@@ -5708,6 +5708,144 @@ def merge_tree(
         return merged_tree.id, conflicts
 
 
+def cherry(
+    repo: Union[str, os.PathLike[str], Repo],
+    upstream: Optional[Union[str, bytes]] = None,
+    head: Optional[Union[str, bytes]] = None,
+    limit: Optional[Union[str, bytes]] = None,
+    verbose: bool = False,
+) -> list[tuple[str, bytes, Optional[bytes]]]:
+    """Find commits not merged upstream.
+
+    Args:
+        repo: Repository path or object
+        upstream: Upstream branch (default: tracking branch or @{upstream})
+        head: Head branch (default: HEAD)
+        limit: Limit commits to those after this ref
+        verbose: Include commit messages in output
+
+    Returns:
+        List of tuples (status, commit_sha, message) where status is '+' or '-'
+        '+' means commit is not in upstream, '-' means equivalent patch exists upstream
+        message is None unless verbose=True
+    """
+    from .patch import commit_patch_id
+
+    with open_repo_closing(repo) as r:
+        # Resolve upstream
+        if upstream is None:
+            # Try to find tracking branch
+            upstream_found = False
+            head_refs, _ = r.refs.follow(b"HEAD")
+            if head_refs:
+                head_ref = head_refs[0]
+                if head_ref.startswith(b"refs/heads/"):
+                    config = r.get_config()
+                    branch_name = head_ref[len(b"refs/heads/") :]
+
+                    try:
+                        upstream_ref = config.get((b"branch", branch_name), b"merge")
+                    except KeyError:
+                        upstream_ref = None
+
+                    if upstream_ref:
+                        try:
+                            remote_name = config.get(
+                                (b"branch", branch_name), b"remote"
+                            )
+                        except KeyError:
+                            remote_name = None
+
+                        if remote_name:
+                            # Build the tracking branch ref
+                            upstream_refname = (
+                                b"refs/remotes/"
+                                + remote_name
+                                + b"/"
+                                + upstream_ref.split(b"/")[-1]
+                            )
+                            if upstream_refname in r.refs:
+                                upstream = upstream_refname
+                                upstream_found = True
+
+            if not upstream_found:
+                # Default to HEAD^ if no tracking branch found
+                head_commit = r[b"HEAD"]
+                if isinstance(head_commit, Commit) and head_commit.parents:
+                    upstream = head_commit.parents[0]
+                else:
+                    raise ValueError("Could not determine upstream branch")
+
+        # Resolve head
+        if head is None:
+            head = b"HEAD"
+
+        # Convert strings to bytes
+        if isinstance(upstream, str):
+            upstream = upstream.encode("utf-8")
+        if isinstance(head, str):
+            head = head.encode("utf-8")
+        if limit is not None and isinstance(limit, str):
+            limit = limit.encode("utf-8")
+
+        # Resolve refs to commit IDs
+        assert upstream is not None
+        upstream_obj = r[upstream]
+        head_obj = r[head]
+        upstream_id = upstream_obj.id
+        head_id = head_obj.id
+
+        # Get limit commit ID if specified
+        limit_id = None
+        if limit is not None:
+            limit_id = r[limit].id
+
+        # Find all commits reachable from head but not from upstream
+        # This is equivalent to: git rev-list ^upstream head
+
+        # Get commits from head that are not in upstream
+        walker = r.get_walker([head_id], exclude=[upstream_id])
+        head_commits = []
+        for entry in walker:
+            commit = entry.commit
+            # Apply limit if specified
+            if limit_id is not None:
+                # Stop when we reach the limit commit
+                if commit.id == limit_id:
+                    break
+            head_commits.append(commit.id)
+
+        # Compute patch IDs for upstream commits
+        upstream_walker = r.get_walker([upstream_id])
+        upstream_patch_ids = {}  # Maps patch_id -> commit_id for debugging
+        for entry in upstream_walker:
+            commit = entry.commit
+            pid = commit_patch_id(r.object_store, commit.id)
+            upstream_patch_ids[pid] = commit.id
+
+        # For each head commit, check if equivalent patch exists in upstream
+        results: list[tuple[str, bytes, Optional[bytes]]] = []
+        for commit_id in reversed(head_commits):  # Show oldest first
+            obj = r.object_store[commit_id]
+            assert isinstance(obj, Commit)
+            commit = obj
+
+            pid = commit_patch_id(r.object_store, commit_id)
+
+            if pid in upstream_patch_ids:
+                status = "-"
+            else:
+                status = "+"
+
+            message = None
+            if verbose:
+                message = commit.message.split(b"\n")[0]  # First line only
+
+            results.append((status, commit_id, message))
+
+        return results
+
+
 def cherry_pick(  # noqa: D417
     repo: Union[str, os.PathLike[str], Repo],
     committish: Union[str, bytes, Commit, Tag, None],
@@ -7333,7 +7471,8 @@ def lfs_fetch(
                         if pointer and pointer.is_valid_oid():
                             # Check if we already have it
                             try:
-                                store.open_object(pointer.oid)
+                                with store.open_object(pointer.oid):
+                                    pass  # Object exists, no need to fetch
                             except KeyError:
                                 pointers_to_fetch.append((pointer.oid, pointer.size))
 
@@ -7520,7 +7659,8 @@ def lfs_status(repo: Union[str, os.PathLike[str], Repo] = ".") -> dict[str, list
 
                     # Check if object exists locally
                     try:
-                        store.open_object(pointer.oid)
+                        with store.open_object(pointer.oid):
+                            pass  # Object exists locally
                     except KeyError:
                         status["missing"].append(path_str)
 

tests/test_cli.py

@@ -3464,5 +3464,118 @@ class MergeBaseCommandTest(DulwichCliTestCase):
         self.assertEqual(result, 1)
 
 
+class ConfigCommandTest(DulwichCliTestCase):
+    """Tests for config command."""
+
+    def test_config_set_and_get(self):
+        """Test setting and getting a config value."""
+        # Set a config value
+        result, stdout, _stderr = self._run_cli("config", "user.name", "Test User")
+        self.assertEqual(result, 0)
+        self.assertEqual(stdout, "")
+
+        # Get the value back
+        result, stdout, _stderr = self._run_cli("config", "user.name")
+        self.assertEqual(result, 0)
+        self.assertEqual(stdout, "Test User\n")
+
+    def test_config_set_and_get_subsection(self):
+        """Test setting and getting a config value with subsection."""
+        # Set a config value with subsection (e.g., remote.origin.url)
+        result, stdout, _stderr = self._run_cli(
+            "config", "remote.origin.url", "https://example.com/repo.git"
+        )
+        self.assertEqual(result, 0)
+        self.assertEqual(stdout, "")
+
+        # Get the value back
+        result, stdout, _stderr = self._run_cli("config", "remote.origin.url")
+        self.assertEqual(result, 0)
+        self.assertEqual(stdout, "https://example.com/repo.git\n")
+
+    def test_config_list(self):
+        """Test listing all config values."""
+        # Set some config values
+        self._run_cli("config", "user.name", "Test User")
+        self._run_cli("config", "user.email", "test@example.com")
+
+        # Get the actual config values that may vary by platform
+        config = self.repo.get_config()
+        filemode = config.get((b"core",), b"filemode")
+        try:
+            symlinks = config.get((b"core",), b"symlinks")
+        except KeyError:
+            symlinks = None
+
+        # List all values
+        result, stdout, _stderr = self._run_cli("config", "--list")
+        self.assertEqual(result, 0)
+
+        # Build expected output with platform-specific values
+        expected = "core.repositoryformatversion=0\n"
+        expected += f"core.filemode={filemode.decode('utf-8')}\n"
+        if symlinks is not None:
+            expected += f"core.symlinks={symlinks.decode('utf-8')}\n"
+        expected += (
+            "core.bare=false\n"
+            "core.logallrefupdates=true\n"
+            "user.name=Test User\n"
+            "user.email=test@example.com\n"
+        )
+
+        self.assertEqual(stdout, expected)
+
+    def test_config_unset(self):
+        """Test unsetting a config value."""
+        # Set a config value
+        self._run_cli("config", "user.name", "Test User")
+
+        # Verify it's set
+        result, stdout, _stderr = self._run_cli("config", "user.name")
+        self.assertEqual(result, 0)
+        self.assertEqual(stdout, "Test User\n")
+
+        # Unset it
+        result, stdout, _stderr = self._run_cli("config", "--unset", "user.name")
+        self.assertEqual(result, 0)
+        self.assertEqual(stdout, "")
+
+        # Verify it's gone
+        result, stdout, _stderr = self._run_cli("config", "user.name")
+        self.assertEqual(result, 1)
+        self.assertEqual(stdout, "")
+
+    def test_config_get_nonexistent(self):
+        """Test getting a nonexistent config value."""
+        result, stdout, _stderr = self._run_cli("config", "nonexistent.key")
+        self.assertEqual(result, 1)
+        self.assertEqual(stdout, "")
+
+    def test_config_unset_nonexistent(self):
+        """Test unsetting a nonexistent config value."""
+        result, _stdout, _stderr = self._run_cli("config", "--unset", "nonexistent.key")
+        self.assertEqual(result, 1)
+
+    def test_config_invalid_key_format(self):
+        """Test config with invalid key format."""
+        result, stdout, _stderr = self._run_cli("config", "invalidkey")
+        self.assertEqual(result, 1)
+        self.assertEqual(stdout, "")
+
+    def test_config_get_all(self):
+        """Test getting all values for a multivar."""
+        # Set multiple values for the same key
+        config = self.repo.get_config()
+        config.set(("test",), "multivar", "value1")
+        config.add(("test",), "multivar", "value2")
+        config.add(("test",), "multivar", "value3")
+        config.write_to_path()
+
+        # Get all values
+        result, stdout, _stderr = self._run_cli("config", "--get-all", "test.multivar")
+        self.assertEqual(result, 0)
+        self.assertEqual(stdout, "value1\nvalue2\nvalue3\n")
+
+
 if __name__ == "__main__":
     unittest.main()

tests/test_patch.py

@@ -28,8 +28,10 @@ from dulwich.object_store import MemoryObjectStore
 from dulwich.objects import S_IFGITLINK, Blob, Commit, Tree
 from dulwich.patch import (
     DiffAlgorithmNotAvailable,
+    commit_patch_id,
     get_summary,
     git_am_patch_split,
+    patch_id,
     unified_diff_with_algorithm,
     write_blob_diff,
     write_commit_patch,
@@ -797,3 +799,97 @@ class PatienceDiffTests(TestCase):
         self.assertIn(b"diff --git", diff)
         self.assertIn(b"-line2", diff)
         self.assertIn(b"+line2 modified", diff)
+
+
+class PatchIdTests(TestCase):
+    """Tests for patch_id and commit_patch_id functions."""
+
+    def test_patch_id_simple(self) -> None:
+        """Test patch_id computation with a simple diff."""
+        diff = b"""diff --git a/file.txt b/file.txt
+index 3b0f961..a116b51 644
+--- a/file.txt
++++ b/file.txt
+@@ -1,2 +1,2 @@
+-old
++new
+ same
+"""
+        pid = patch_id(diff)
+        # Patch ID should be a 40-byte hex string
+        self.assertEqual(40, len(pid))
+        self.assertTrue(all(c in b"0123456789abcdef" for c in pid))
+
+    def test_patch_id_same_for_equivalent_diffs(self) -> None:
+        """Test that equivalent patches have the same ID."""
+        # Two diffs with different line numbers but same changes
+        diff1 = b"""diff --git a/file.txt b/file.txt
+--- a/file.txt
++++ b/file.txt
+@@ -1,3 +1,3 @@
+ context
+-old line
++new line
+ context
+"""
+        diff2 = b"""diff --git a/file.txt b/file.txt
+--- a/file.txt
++++ b/file.txt
+@@ -10,3 +10,3 @@
+ context
+-old line
++new line
+ context
+"""
+        pid1 = patch_id(diff1)
+        pid2 = patch_id(diff2)
+        # Same patch content should give same patch ID
+        self.assertEqual(pid1, pid2)
+
+    def test_commit_patch_id(self) -> None:
+        """Test commit_patch_id computation."""
+        store = MemoryObjectStore()
+
+        # Create two trees
+        blob1 = Blob.from_string(b"content1\n")
+        blob2 = Blob.from_string(b"content2\n")
+        store.add_objects([(blob1, None), (blob2, None)])
+
+        tree1 = Tree()
+        tree1.add(b"file.txt", 0o644, blob1.id)
+        store.add_object(tree1)
+
+        tree2 = Tree()
+        tree2.add(b"file.txt", 0o644, blob2.id)
+        store.add_object(tree2)
+
+        # Create a commit
+        commit = Commit()
+        commit.tree = tree2.id
+        commit.parents = [b"0" * 40]  # Fake parent
+        commit.author = commit.committer = b"Test <test@example.com>"
+        commit.author_time = commit.commit_time = 1234567890
+        commit.author_timezone = commit.commit_timezone = 0
+        commit.message = b"Test commit\n"
+        commit.encoding = b"UTF-8"
+        store.add_object(commit)
+
+        # Create parent commit
+        parent_commit = Commit()
+        parent_commit.tree = tree1.id
+        parent_commit.parents = []
+        parent_commit.author = parent_commit.committer = b"Test <test@example.com>"
+        parent_commit.author_time = parent_commit.commit_time = 1234567880
+        parent_commit.author_timezone = parent_commit.commit_timezone = 0
+        parent_commit.message = b"Parent commit\n"
+        parent_commit.encoding = b"UTF-8"
+        store.add_object(parent_commit)
+
+        # Update commit to have real parent
+        commit.parents = [parent_commit.id]
+        store.add_object(commit)
+
+        # Compute patch ID
+        pid = commit_patch_id(store, commit.id)
+        self.assertEqual(40, len(pid))
+        self.assertTrue(all(c in b"0123456789abcdef" for c in pid))

tests/test_porcelain.py

@@ -10041,3 +10041,119 @@ class MergeBaseTests(PorcelainTestCase):
         """Test independent_commits with empty list."""
         result = porcelain.independent_commits(self.repo.path, committishes=[])
         self.assertEqual([], result)
+
+
+class CherryTests(PorcelainTestCase):
+    """Tests for cherry command."""
+
+    def test_cherry_no_changes(self):
+        """Test cherry when head and upstream are the same."""
+        # Create a simple commit
+        commit_sha = self.repo.do_commit(
+            b"Initial commit", committer=b"Test <test@example.com>"
+        )
+
+        # Cherry should return empty when comparing a commit to itself
+        results = porcelain.cherry(
+            self.repo.path, upstream=commit_sha.decode(), head=commit_sha.decode()
+        )
+        self.assertEqual([], results)
+
+    def test_cherry_unique_commits(self):
+        """Test cherry with commits unique to head."""
+        # Create initial commit
+        with open(os.path.join(self.repo_path, "file1.txt"), "w") as f:
+            f.write("base content\n")
+        self.repo.stage(["file1.txt"])
+        base_commit = self.repo.do_commit(
+            b"Base commit", committer=b"Test <test@example.com>"
+        )
+
+        # Create a new commit on head
+        with open(os.path.join(self.repo_path, "file2.txt"), "w") as f:
+            f.write("new content\n")
+        self.repo.stage(["file2.txt"])
+        head_commit = self.repo.do_commit(
+            b"New commit", committer=b"Test <test@example.com>"
+        )
+
+        # Cherry should show the new commit as unique
+        results = porcelain.cherry(
+            self.repo.path, upstream=base_commit.decode(), head=head_commit.decode()
+        )
+        self.assertEqual(1, len(results))
+        status, commit_sha, message = results[0]
+        self.assertEqual("+", status)
+        self.assertEqual(head_commit, commit_sha)
+        self.assertIsNone(message)
+
+    def test_cherry_verbose(self):
+        """Test cherry with verbose flag."""
+        # Create initial commit
+        with open(os.path.join(self.repo_path, "file1.txt"), "w") as f:
+            f.write("base content\n")
+        self.repo.stage(["file1.txt"])
+        base_commit = self.repo.do_commit(
+            b"Base commit", committer=b"Test <test@example.com>"
+        )
+
+        # Create a new commit on head
+        with open(os.path.join(self.repo_path, "file2.txt"), "w") as f:
+            f.write("new content\n")
+        self.repo.stage(["file2.txt"])
+        head_commit = self.repo.do_commit(
+            b"New commit on head", committer=b"Test <test@example.com>"
+        )
+
+        # Cherry with verbose should include commit message
+        results = porcelain.cherry(
+            self.repo.path,
+            upstream=base_commit.decode(),
+            head=head_commit.decode(),
+            verbose=True,
+        )
+        self.assertEqual(1, len(results))
+        status, commit_sha, message = results[0]
+        self.assertEqual("+", status)
+        self.assertEqual(head_commit, commit_sha)
+        self.assertEqual(b"New commit on head", message)
+
+    def test_cherry_equivalent_patches(self):
+        """Test cherry with equivalent patches (cherry-picked commits)."""
+        # Create base commit
+        with open(os.path.join(self.repo_path, "file.txt"), "w") as f:
+            f.write("line1\n")
+        self.repo.stage(["file.txt"])
+        base_commit = self.repo.do_commit(
+            b"Base commit", committer=b"Test <test@example.com>"
+        )
+
+        # Create upstream branch with a change
+        with open(os.path.join(self.repo_path, "file.txt"), "w") as f:
+            f.write("line1\nline2\n")
+        self.repo.stage(["file.txt"])
+        upstream_commit = self.repo.do_commit(
+            b"Add line2", committer=b"Test <test@example.com>"
+        )
+
+        # Reset to base and create same change on head branch
+        self.repo.refs[b"HEAD"] = base_commit
+        self.repo.reset_index()
+        with open(os.path.join(self.repo_path, "file.txt"), "w") as f:
+            f.write("line1\nline2\n")
+        self.repo.stage(["file.txt"])
+        head_commit = self.repo.do_commit(
+            b"Add line2 (different metadata)",
+            committer=b"Different <different@example.com>",
+        )
+
+        # Cherry should mark this as equivalent (-)
+        results = porcelain.cherry(
+            self.repo.path,
+            upstream=upstream_commit.decode(),
+            head=head_commit.decode(),
+        )
+        self.assertEqual(1, len(results))
+        status, commit_sha, _message = results[0]
+        self.assertEqual("-", status)
+        self.assertEqual(head_commit, commit_sha)