@dotinc/ogre 0.8.1 → 0.9.0

package/src/repository.test.ts

@@ -10,9 +10,8 @@ import {
   testAuthor,
   updateHeaderData,
 } from "./test.utils";
-import { History, Reference } from "./interfaces";
-import { compare, Operation } from "fast-json-patch";
-import { printChange, printChangeLog } from "./utils";
+import { Reference } from "./interfaces";
+import { compare } from "fast-json-patch";
 
 test("diff is ok", async (t) => {
   const [repo, obj] = await getBaseline();
@@ -137,10 +136,14 @@ test("history", async (t) => {
     const history = repo.getHistory();
 
     const obj2 = {};
-    // @ts-ignore
     const repo2 = new Repository(obj2, { history });
 
-    t.matchOnly(obj, obj2, "restored object does not equal last version.");
+    t.matchOnlyStrict(
+      obj,
+      obj2,
+      "restored object does not equal last version.",
+    );
+    t.not(obj, obj2, "should not be the js ref");
   });
 
   t.test("remoteRefs doesn't change on commit", async (t) => {
@@ -373,3 +376,354 @@ test("apply", async (t) => {
     t.match(repo.data, targetState, "The final state does not match up");
   });
 });
+
+test("pending changes - push helpers", async (t) => {
+  t.test("1 commit & 1 ref update", async (t) => {
+    const [repo, obj] = await getBaseline();
+    updateHeaderData(obj);
+    await repo.commit("header data", testAuthor);
+    addOneNested(obj);
+    await repo.commit("first nested", testAuthor);
+    repo.tag("v0.1.0");
+    const history = repo.getHistory();
+
+    const repo2 = new Repository<ComplexObject>({}, { history });
+
+    repo2.data.description = "changed description";
+    const hash = await repo2.commit("changed desc", testAuthor);
+    const { commits } = repo2.getHistory();
+    const pendingCommit = commits.find((c) => c.hash === hash);
+
+    const pending = repo2.cherry();
+
+    t.equal(pending.commits.length, 1, "incorrect number of pending commits");
+    t.equal(pending.refs.size, 1, "incorrect number of pending ref updates");
+    t.matchOnly(pending.commits[0], pendingCommit, "wrong pending commit");
+    t.matchOnlyStrict(
+      Array.from(pending.refs.keys()),
+      ["refs/heads/main"],
+      "wrong pending ref update",
+    );
+  });
+
+  t.test("2 commit & 1 ref update", async (t) => {
+    const [repo, obj] = await getBaseline();
+    updateHeaderData(obj);
+    await repo.commit("header data", testAuthor);
+    addOneNested(obj);
+    await repo.commit("first nested", testAuthor);
+    repo.tag("v0.1.0");
+    const history = repo.getHistory();
+
+    const repo2 = new Repository<ComplexObject>({}, { history });
+
+    repo2.data.description = "changed description";
+    const hash1 = await repo2.commit("changed desc", testAuthor);
+    repo2.data.uuid = "uuid1";
+    const hash2 = await repo2.commit("changed uuid", testAuthor);
+
+    const { commits } = repo2.getHistory();
+    const pendingCommit1 = commits.find((c) => c.hash === hash1);
+    const pendingCommit2 = commits.find((c) => c.hash === hash2);
+
+    const pending = repo2.cherry();
+
+    t.equal(pending.commits.length, 2, "incorrect number of pending commits");
+    t.equal(pending.refs.size, 1, "incorrect number of pending ref updates");
+    t.matchOnlyStrict(
+      new Set(pending.commits),
+      new Set([pendingCommit2, pendingCommit1]),
+      "wrong pending commits",
+    );
+    t.matchOnlyStrict(
+      Array.from(pending.refs.keys()),
+      ["refs/heads/main"],
+      "wrong pending ref update",
+    );
+  });
+
+  t.test("1 commit & 2 ref updates", async (t) => {
+    const [repo, obj] = await getBaseline();
+    updateHeaderData(obj);
+    await repo.commit("header data", testAuthor);
+    addOneNested(obj);
+    await repo.commit("first nested", testAuthor);
+    repo.tag("v0.1.0");
+    const history = repo.getHistory();
+
+    const repo2 = new Repository<ComplexObject>({}, { history });
+
+    repo2.data.description = "changed description";
+    const hash1 = await repo2.commit("changed desc", testAuthor);
+    repo2.createBranch("branch2");
+
+    const { commits } = repo2.getHistory();
+    const pendingCommit1 = commits.find((c) => c.hash === hash1);
+
+    const pending = repo2.cherry();
+
+    t.equal(pending.commits.length, 1, "incorrect number of pending commits");
+    t.equal(pending.refs.size, 2, "incorrect number of pending ref updates");
+    t.matchOnlyStrict(
+      pending.commits,
+      [pendingCommit1],
+      "wrong pending commits",
+    );
+    t.matchOnlyStrict(
+      new Set(pending.refs.keys()),
+      new Set(["refs/heads/main", "refs/heads/branch2"]),
+      "wrong pending ref update",
+    );
+  });
+
+  t.test("2 commit & 2 ref updates", async (t) => {
+    const [repo, obj] = await getBaseline();
+    updateHeaderData(obj);
+    await repo.commit("header data", testAuthor);
+    addOneNested(obj);
+    await repo.commit("first nested", testAuthor);
+    repo.tag("v0.1.0");
+    const history = repo.getHistory();
+
+    const repo2 = new Repository<ComplexObject>({}, { history });
+
+    repo2.data.description = "changed description";
+    const hash1 = await repo2.commit("changed desc", testAuthor);
+    repo2.data.uuid = "uuid1";
+    const hash2 = await repo2.commit("changed uuid", testAuthor);
+    repo2.checkout("branch2", true);
+
+    const { commits } = repo2.getHistory();
+    const pendingCommit1 = commits.find((c) => c.hash === hash1);
+    const pendingCommit2 = commits.find((c) => c.hash === hash2);
+
+    const pending = repo2.cherry();
+
+    t.equal(pending.commits.length, 2, "incorrect number of pending commits");
+    t.equal(pending.refs.size, 2, "incorrect number of pending ref updates");
+    t.matchOnlyStrict(
+      new Set(pending.commits),
+      new Set([pendingCommit2, pendingCommit1]),
+      "wrong pending commits",
+    );
+    t.matchOnlyStrict(
+      new Set(pending.refs.keys()),
+      new Set(["refs/heads/main", "refs/heads/branch2"]),
+      "wrong pending ref update",
+    );
+  });
+
+  t.test("3 commit & 2 ref updates", async (t) => {
+    const [repo, obj] = await getBaseline();
+    updateHeaderData(obj);
+    await repo.commit("header data", testAuthor);
+    addOneNested(obj);
+    await repo.commit("first nested", testAuthor);
+    repo.tag("v0.1.0");
+    const history = repo.getHistory();
+
+    const repo2 = new Repository<ComplexObject>({}, { history });
+
+    repo2.data.description = "changed description";
+    const hash1 = await repo2.commit("changed desc", testAuthor);
+    repo2.data.uuid = "uuid1";
+    const hash2 = await repo2.commit("changed uuid", testAuthor);
+    repo2.checkout("branch2", true);
+
+    repo2.data.nested = [{ name: "a", uuid: "thing" }];
+    const hash3 = await repo2.commit("added a thing", testAuthor);
+
+    const { commits } = repo2.getHistory();
+    const pendingCommit1 = commits.find((c) => c.hash === hash1);
+    const pendingCommit2 = commits.find((c) => c.hash === hash2);
+    const pendingCommit3 = commits.find((c) => c.hash === hash3);
+
+    const pending = repo2.cherry();
+
+    t.equal(pending.commits.length, 3, "incorrect number of pending commits");
+    t.equal(pending.refs.size, 2, "incorrect number of pending ref updates");
+    t.matchOnlyStrict(
+      new Set(pending.commits),
+      new Set([pendingCommit3, pendingCommit2, pendingCommit1]),
+      "wrong pending commits",
+    );
+    t.matchOnlyStrict(
+      new Set(pending.refs.keys()),
+      new Set(["refs/heads/main", "refs/heads/branch2"]),
+      "wrong pending ref update",
+    );
+  });
+
+  t.test("3 commit & 3 ref updates", async (t) => {
+    const [repo, obj] = await getBaseline();
+    updateHeaderData(obj);
+    await repo.commit("header data", testAuthor);
+    addOneNested(obj);
+    await repo.commit("first nested", testAuthor);
+    repo.tag("v0.1.0");
+    const history = repo.getHistory();
+
+    const repo2 = new Repository<ComplexObject>({}, { history });
+
+    repo2.data.description = "changed description";
+    const hash1 = await repo2.commit("changed desc", testAuthor);
+    repo2.data.uuid = "uuid1";
+    const hash2 = await repo2.commit("changed uuid", testAuthor);
+    repo2.checkout("branch2", true);
+
+    repo2.data.nested = [{ name: "a", uuid: "thing" }];
+    const hash3 = await repo2.commit("added a thing", testAuthor);
+    repo2.tag("v0.2.0");
+
+    const { commits } = repo2.getHistory();
+    const pendingCommit1 = commits.find((c) => c.hash === hash1);
+    const pendingCommit2 = commits.find((c) => c.hash === hash2);
+    const pendingCommit3 = commits.find((c) => c.hash === hash3);
+
+    const pending = repo2.cherry();
+
+    t.equal(pending.commits.length, 3, "incorrect number of pending commits");
+    t.equal(pending.refs.size, 3, "incorrect number of pending ref updates");
+    t.matchOnlyStrict(
+      new Set(pending.commits),
+      new Set([pendingCommit3, pendingCommit2, pendingCommit1]),
+      "wrong pending commits",
+    );
+    t.matchOnlyStrict(
+      new Set(pending.refs.keys()),
+      new Set(["refs/heads/main", "refs/heads/branch2", "refs/tags/v0.2.0"]),
+      "wrong pending ref update",
+    );
+  });
+
+  t.test("after merge 1 commit & 3 ref updates", async (t) => {
+    const [repo, obj] = await getBaseline();
+    updateHeaderData(obj);
+    await repo.commit("header data", testAuthor);
+    addOneNested(obj);
+    await repo.commit("first nested", testAuthor);
+    repo.tag("v0.1.0");
+    const history = repo.getHistory();
+
+    const repo2 = new Repository<ComplexObject>({}, { history });
+    repo2.checkout("branch2", true);
+
+    repo2.data.nested = [{ name: "a", uuid: "thing" }];
+    const hash3 = await repo2.commit("added a thing", testAuthor);
+    repo2.tag("v0.2.0");
+
+    repo2.checkout("main");
+    repo2.merge("branch2");
+
+    const { commits } = repo2.getHistory();
+    const pendingCommit3 = commits.find((c) => c.hash === hash3);
+
+    const pending = repo2.cherry();
+
+    t.equal(pending.commits.length, 1, "incorrect number of pending commits");
+    t.equal(pending.refs.size, 3, "incorrect number of pending ref updates");
+    t.matchOnlyStrict(
+      pending.commits,
+      [pendingCommit3],
+      "wrong pending commits",
+    );
+    t.matchOnlyStrict(
+      new Set(pending.refs.keys()),
+      new Set(["refs/heads/main", "refs/heads/branch2", "refs/tags/v0.2.0"]),
+      "wrong pending ref update",
+    );
+  });
+
+  t.test("after merge 1 commit & 2 ref updates", async (t) => {
+    const [repo, obj] = await getBaseline();
+    updateHeaderData(obj);
+    await repo.commit("header data", testAuthor);
+    addOneNested(obj);
+    await repo.commit("first nested", testAuthor);
+    repo.tag("v0.1.0");
+    const history = repo.getHistory();
+
+    const repo2 = new Repository<ComplexObject>({}, { history });
+    repo2.checkout("branch2", true);
+
+    repo2.data.nested = [{ name: "a", uuid: "thing" }];
+    const hash3 = await repo2.commit("added a thing", testAuthor);
+
+    repo2.checkout("main");
+    repo2.merge("branch2");
+
+    const { commits } = repo2.getHistory();
+    const pendingCommit3 = commits.find((c) => c.hash === hash3);
+
+    const pending = repo2.cherry();
+
+    t.equal(pending.commits.length, 1, "incorrect number of pending commits");
+    t.equal(pending.refs.size, 2, "incorrect number of pending ref updates");
+    t.matchOnlyStrict(
+      pending.commits,
+      [pendingCommit3],
+      "wrong pending commits",
+    );
+    t.matchOnlyStrict(
+      new Set(pending.refs.keys()),
+      new Set(["refs/heads/main", "refs/heads/branch2"]),
+      "wrong pending ref update",
+    );
+  });
+  t.test("no merge 1 commit & 1 ref updates", async (t) => {
+    const [repo, obj] = await getBaseline();
+    updateHeaderData(obj);
+    await repo.commit("header data", testAuthor);
+    addOneNested(obj);
+    await repo.commit("first nested", testAuthor);
+    repo.tag("v0.1.0");
+    const history = repo.getHistory();
+
+    const repo2 = new Repository<ComplexObject>({}, { history });
+    repo2.checkout("branch2", true);
+
+    repo2.data.nested = [{ name: "a", uuid: "thing" }];
+    const hash3 = await repo2.commit("added a thing", testAuthor);
+
+    const { commits } = repo2.getHistory();
+    const pendingCommit3 = commits.find((c) => c.hash === hash3);
+
+    const pending = repo2.cherry();
+
+    t.equal(pending.commits.length, 1, "incorrect number of pending commits");
+    t.equal(pending.refs.size, 1, "incorrect number of pending ref updates");
+    t.matchOnlyStrict(
+      pending.commits,
+      [pendingCommit3],
+      "wrong pending commits",
+    );
+    t.matchOnlyStrict(
+      pending.refs.keys(),
+      ["refs/heads/branch2"],
+      "wrong pending ref update",
+    );
+  });
+  t.test("no merge no commit & 1 ref updates", async (t) => {
+    const [repo, obj] = await getBaseline();
+    updateHeaderData(obj);
+    await repo.commit("header data", testAuthor);
+    addOneNested(obj);
+    await repo.commit("first nested", testAuthor);
+    repo.tag("v0.1.0");
+    const history = repo.getHistory();
+
+    const repo2 = new Repository<ComplexObject>({}, { history });
+    repo2.checkout("branch2", true);
+
+    const pending = repo2.cherry();
+
+    t.equal(pending.commits.length, 0, "incorrect number of pending commits");
+    t.equal(pending.refs.size, 1, "incorrect number of pending ref updates");
+    t.matchOnlyStrict(pending.commits, [], "wrong pending commits");
+    t.matchOnlyStrict(
+      pending.refs.keys(),
+      ["refs/heads/branch2"],
+      "wrong pending ref update",
+    );
+  });
+});

package/src/repository.ts

@@ -21,6 +21,7 @@ import {
   createHeadRefValue,
   getLastRefPathElement,
   headValueRefPrefix,
+  immutableArrayCopy,
   immutableMapCopy,
   localHeadPathPrefix,
   mapPath,
@@ -50,18 +51,18 @@ export interface RepositoryObject<T extends { [k: string]: any }> {
    * @param shaishFrom expression (e.g. refs (branches, tags), commitSha)
    * @param shaishTo expression (e.g. refs (branches, tags), commitSha)
    */
-  diff(shaishFrom: string, shaishTo?: string): Operation[];
+  diff(shaishFrom: string, shaishTo?: string): Array<Operation>;
 
   /**
    * Returns pending changes.
    */
-  status(): Operation[];
+  status(): Array<Operation>;
 
   /**
    * Applies a patch to the repository's HEAD
    * @param patch
    */
-  apply(patch: Operation[]): void;
+  apply(patch: Array<Operation>): void;
 
   // It returns the reference where we are currently at
   head(): string;
@@ -73,7 +74,7 @@ export interface RepositoryObject<T extends { [k: string]: any }> {
 
   checkout(shaish: string, createBranch?: boolean): void;
 
-  logs(commits?: number): Commit[];
+  logs(commits?: number): Array<Commit>;
 
   createBranch(name: string): string;
 
@@ -98,6 +99,11 @@ export interface RepositoryObject<T extends { [k: string]: any }> {
    * The returned map is a readonly of remote.
    */
   remote(): ReadonlyMap<string, Readonly<Reference>> | undefined;
+
+  /**
+   * Cherry returns the commits that are missing from upstream and the refs that have been moved since remote
+   */
+  cherry(): { commits: Array<Commit>; refs: Map<string, Reference> };
 }
 
 /**
@@ -108,8 +114,11 @@ export class Repository<T extends { [k: PropertyKey]: any }>
 {
   constructor(obj: Partial<T>, options: RepositoryOptions<T>) {
     // FIXME: move this to refs/remote as git would do?
-
     this.remoteRefs = immutableMapCopy(options.history?.refs);
+    this.remoteCommits = immutableArrayCopy<Commit, string>(
+      options.history?.commits,
+      (c) => c.hash,
+    );
     this.original = deepClone(obj);
     // store js ref, so obj can still be modified without going through repo.data
     this.data = obj as T;
@@ -146,10 +155,106 @@ export class Repository<T extends { [k: PropertyKey]: any }>
     | ReadonlyMap<string, Readonly<Reference>>
     | undefined;
 
+  // stores the remote state upon initialization
+  private readonly remoteCommits: ReadonlyArray<Readonly<string>> | undefined;
+
   private observer: Observer<T>;
 
   private readonly refs: Map<string, Reference>;
-  private readonly commits: Commit[];
+  private readonly commits: Array<Commit>;
+
+  cherry(): { commits: Array<Commit>; refs: Map<string, Reference> } {
+    const commits: Array<Commit> = [];
+    const refs = new Map<string, Reference>();
+
+    const collectedHashes: Array<string> = [];
+    const shouldExclude = (hash: string) =>
+      this.remoteCommits?.includes(hash) || collectedHashes.includes(hash);
+    const collect = (c: Commit) => {
+      // we can't include remote state in the pending report
+      if (shouldExclude(c.hash)) {
+        return false;
+      }
+      commits.push(c);
+      collectedHashes.push(c.hash);
+      return true;
+    };
+    // collect ref updates and commits that are not present on the remote
+    for (const [key, ref] of this.refs) {
+      if (key === REFS_HEAD_KEY) {
+        continue;
+      }
+      const remote = this.remoteRefs?.get(key);
+      if (!remote) {
+        // if we have no remote pair, we need to sync the ref
+        refs.set(key, ref);
+        const localCommit = this.commits.find((c) => c.hash === ref.value);
+        // if ref is not pointing to a commit move on
+        if (!localCommit) {
+          continue;
+        }
+        // map all commits to root
+        const [isAncestor, path] = mapPath(
+          this.commits,
+          localCommit,
+          undefined,
+        );
+
+        if (isAncestor) {
+          for (let i = 0; i < path.length; i++) {
+            const commit = path[i];
+            collect({
+              hash: commit.hash,
+              author: commit.author,
+              changes: commit.changes,
+              message: commit.message,
+              parent: commit.parent,
+              timestamp: commit.timestamp,
+              tree: commit.tree,
+            });
+          }
+        }
+        continue;
+      }
+
+      if (remote.value === ref.value) {
+        // early exit if remote is the same
+        continue;
+      }
+
+      // local and remote refs differ
+      refs.set(key, ref);
+      const localCommit = this.commits.find((c) => c.hash === ref.value);
+      // if ref is not pointing to a commit move on
+      if (!localCommit) {
+        continue;
+      }
+      // FIXME: do we have to have the remote ref as a commit locally?
+      const remoteCommit = this.commits.find((c) => c.hash === remote.value)!;
+      const [isAncestor, path] = mapPath(
+        this.commits,
+        localCommit,
+        remoteCommit,
+      );
+
+      if (isAncestor) {
+        for (let i = 0; i < path.length; i++) {
+          const commit = path[i];
+          collect({
+            hash: commit.hash,
+            author: commit.author,
+            changes: commit.changes,
+            message: commit.message,
+            parent: commit.parent,
+            timestamp: commit.timestamp,
+            tree: commit.tree,
+          });
+        }
+      }
+    }
+
+    return { commits, refs };
+  }
 
   remote(): ReadonlyMap<string, Readonly<Reference>> | undefined {
     return this.remoteRefs;
@@ -166,8 +271,8 @@ export class Repository<T extends { [k: PropertyKey]: any }>
     this.observer = observe(this.data);
   }
 
-  apply(patch: Operation[]): JsonPatchError | undefined {
-    const p = deepClone(patch) as Operation[];
+  apply(patch: Array<Operation>): JsonPatchError | undefined {
+    const p = deepClone(patch) as Array<Operation>;
     const err = validate(p, this.data);
     if (err) {
       // credit goes to @NicBright
@@ -247,7 +352,7 @@ export class Repository<T extends { [k: PropertyKey]: any }>
     return this.diff(commit.hash);
   }
 
-  diff(shaishFrom: string, shaishTo?: string): Operation[] {
+  diff(shaishFrom: string, shaishTo?: string): Array<Operation> {
     const [cFrom] = shaishToCommit(shaishFrom, this.refs, this.commits);
     let target: T;
     if (shaishTo) {
@@ -393,7 +498,7 @@ export class Repository<T extends { [k: PropertyKey]: any }>
     }
     // traverse backwards and build commit tree
     let c: Commit | undefined = commit;
-    let commitsList: Commit[] = [];
+    let commitsList: Array<Commit> = [];
     while (c !== undefined) {
       commitsList = [c, ...commitsList];
       c = this.commits.find((parent) => parent.hash === c?.parent);
@@ -408,8 +513,8 @@ export class Repository<T extends { [k: PropertyKey]: any }>
     };
   }
 
-  logs(numberOfCommits?: number): Commit[] {
-    const logs: Commit[] = [];
+  logs(numberOfCommits?: number): Array<Commit> {
+    const logs: Array<Commit> = [];
     const limit = numberOfCommits ?? -1;
     let c = this.commitAtHead();
     let counter = 0;
@@ -458,7 +563,7 @@ export class Repository<T extends { [k: PropertyKey]: any }>
     // *---*
     //      \
     //       *---*---* (master, foo)
-    const [isAncestor] = mapPath(headCommit, srcCommit, this.commits);
+    const [isAncestor] = mapPath(this.commits, srcCommit, headCommit);
     if (isAncestor) {
       this.moveRef(this.head(), srcCommit);
       this.moveTo(srcCommit);

package/src/utils.test.ts

@@ -1,5 +1,7 @@
 import { test } from "tap";
-import { cleanAuthor } from "./utils";
+import { cleanAuthor, mapPath, shaishToCommit } from "./utils";
+import { Repository } from "./repository";
+import { ComplexObject, testAuthor } from "./test.utils";
 
 test("author <email@domain.info>", (t) => {
   const [name, email] = cleanAuthor("author <email@domain.info>");
@@ -52,3 +54,88 @@ test("empty author", (t) => {
   );
   t.end();
 });
+
+test("mapPath", async (t) => {
+  t.test("find root", async (t) => {
+    const repo = new Repository<ComplexObject>({}, {});
+    repo.data.name = "name";
+    const hash = await repo.commit("set name", testAuthor);
+
+    const { commits, refs } = repo.getHistory();
+    const [c] = shaishToCommit(hash, refs, commits);
+    const [isAncestor, path] = mapPath(commits, c);
+    t.equal(path.length, 1, "path does not contain 1 commit");
+    t.equal(isAncestor, true, "root is not ancestor of commit");
+    t.matchOnlyStrict(path[0], c, "path does not contain the right commit");
+  });
+
+  t.test("finds full path to root", async (t) => {
+    const repo = new Repository<ComplexObject>({}, {});
+    repo.data.name = "name";
+    const h1 = await repo.commit("set name", testAuthor);
+    repo.data.description = "description";
+    const h2 = await repo.commit("set desc", testAuthor);
+
+    const { commits, refs } = repo.getHistory();
+    const [c1] = shaishToCommit(h1, refs, commits);
+    const [c2] = shaishToCommit(h2, refs, commits);
+    const [isAncestor, path] = mapPath(commits, c2);
+
+    t.equal(path.length, 2, "path does not contain 1 commit");
+    t.equal(isAncestor, true, "root is not ancestor of commit");
+    t.matchOnlyStrict(
+      path[0],
+      c2,
+      "path does not contain the right commit at 0",
+    );
+    t.matchOnlyStrict(
+      path[1],
+      c1,
+      "path does not contain the right commit at 1",
+    );
+  });
+
+  t.test("parent-to-child no ancestor", async (t) => {
+    const repo = new Repository<ComplexObject>({}, {});
+    repo.data.name = "name";
+    const h1 = await repo.commit("set name", testAuthor);
+    repo.data.description = "description";
+    const h2 = await repo.commit("set desc", testAuthor);
+
+    const { commits, refs } = repo.getHistory();
+    const [c1] = shaishToCommit(h1, refs, commits);
+    const [c2] = shaishToCommit(h2, refs, commits);
+    const [isAncestor, path] = mapPath(commits, c1, c2);
+
+    t.equal(path.length, 0, "path contains a commit");
+    t.equal(isAncestor, false, "child must not be an ancestor of parent");
+  });
+
+  t.test("finds path across 2 branches", async (t) => {
+    const repo = new Repository<ComplexObject>({}, {});
+    repo.data.name = "name";
+    const h1 = await repo.commit("set name", testAuthor);
+    repo.checkout("branch", true);
+
+    repo.data.description = "description";
+    const h2 = await repo.commit("set desc", testAuthor);
+
+    const { commits, refs } = repo.getHistory();
+    const [c1] = shaishToCommit(h1, refs, commits);
+    const [c2] = shaishToCommit(h2, refs, commits);
+    const [isAncestor, path] = mapPath(commits, c2);
+
+    t.equal(path.length, 2, "path does not contain 1 commit");
+    t.equal(isAncestor, true, "root is not ancestor of commit");
+    t.matchOnlyStrict(
+      path[0],
+      c2,
+      "path does not contain the right commit at 0",
+    );
+    t.matchOnlyStrict(
+      path[1],
+      c1,
+      "path does not contain the right commit at 1",
+    );
+  });
+});