@dotinc/ogre 0.4.0 → 0.5.0

package/src/commit.test.ts

@@ -1,4 +1,4 @@
-import test from "ava";
+import { test } from "tap";
 
 import {
   addOneStep,
@@ -12,25 +12,22 @@ test("baseline with 1 commit and zero changelog entries", async (t) => {
   const [repo] = await getBaseline();
 
   const history = repo.getHistory();
-  t.is(sumChanges(history.commits), 0, "has changelog entries");
-  t.is(history.commits.length, 0, "incorrect # of commits");
+  t.equal(sumChanges(history.commits), 0, "has changelog entries");
+  t.equal(history.commits.length, 0, "incorrect # of commits");
 });
 
 test("head points to main", async (t) => {
   const [repo] = await getBaseline();
 
-  t.is(repo.head(), "refs/heads/main", "head not pointing where it should");
+  t.equal(repo.head(), "refs/heads/main", "head not pointing where it should");
 });
 
 test("no commit without changes", async (t) => {
   const [repo] = await getBaseline();
 
-  await t.throwsAsync(
-    async () => {
-      return await repo.commit("baseline", testAuthor);
-    },
-    { message: "no changes to commit" }
-  );
+  await t.rejects(repo.commit("baseline", testAuthor), {
+    message: "no changes to commit",
+  });
 });
 
 test("no commit without changes after recent commit", async (t) => {
@@ -38,12 +35,9 @@ test("no commit without changes after recent commit", async (t) => {
   repo.data.name = "new name";
   await repo.commit("baseline", testAuthor);
 
-  await t.throwsAsync(
-    async () => {
-      return await repo.commit("baseline", testAuthor);
-    },
-    { message: "no changes to commit" }
-  );
+  await t.rejects(repo.commit("baseline", testAuthor), {
+    message: "no changes to commit",
+  });
 });
 
 test("treeHash of commit is matching content", async (t) => {
@@ -51,7 +45,7 @@ test("treeHash of commit is matching content", async (t) => {
   repo.data.name = "new name";
   await repo.commit("baseline", testAuthor);
   const { commits } = repo.getHistory();
-  t.is(commits.length, 1);
+  t.equal(commits.length, 1);
   t.not(commits[0].tree, "", "tree hash mismatch");
 });
 
@@ -59,12 +53,9 @@ test("no commit --amend without commit", async (t) => {
   const [repo] = await getBaseline();
   repo.data.name = "new name";
 
-  await t.throwsAsync(
-    async () => {
-      return await repo.commit("baseline", testAuthor, true);
-    },
-    { message: "no commit to amend" }
-  );
+  await t.rejects(repo.commit("baseline", testAuthor, true), {
+    message: "no commit to amend",
+  });
 });
 
 test("main moves to recent commit", async (t) => {
@@ -72,10 +63,10 @@ test("main moves to recent commit", async (t) => {
   repo.data.name = "new name";
   const hash = await repo.commit("baseline", testAuthor);
 
-  t.is(
+  t.equal(
     repo.ref("refs/heads/main"),
     hash,
-    "head does not point to recent commit"
+    "head does not point to recent commit",
   );
 });
 
@@ -85,8 +76,8 @@ test("two commits with 3 changes", async (t) => {
   await repo.commit("header data", testAuthor);
 
   const history = repo.getHistory();
-  t.is(sumChanges(history.commits), 3, "incorrect # of changelog entries");
-  t.is(history.commits.length, 1, "incorrect # of commits");
+  t.equal(sumChanges(history.commits), 3, "incorrect # of changelog entries");
+  t.equal(history.commits.length, 1, "incorrect # of commits");
 });
 
 test("array push double-change, 6 changes, 3 commits", async (t) => {
@@ -99,17 +90,17 @@ test("array push double-change, 6 changes, 3 commits", async (t) => {
   await repo.commit("first step", testAuthor);
 
   const history = repo.getHistory();
-  t.is(sumChanges(history.commits), 4, "incorrect # of changelog entries");
-  t.is(history.commits.length, 2, "incorrect # of commits");
-  t.is(
+  t.equal(sumChanges(history.commits), 4, "incorrect # of changelog entries");
+  t.equal(history.commits.length, 2, "incorrect # of commits");
+  t.equal(
     history.commits[0].changes.length,
     3,
-    "#incorrect # of changes in commit#1"
+    "#incorrect # of changes in commit#1",
   );
-  t.is(
+  t.equal(
     history.commits[1].changes.length,
     1,
-    "#incorrect # of changes in commit#2"
+    "#incorrect # of changes in commit#2",
   );
 });
 
@@ -119,21 +110,21 @@ test("all refs OK, when committing on new branch while main is empty main", asyn
   repo.data.name = "new name";
   const commit = await repo.commit("simple change", testAuthor);
 
-  t.is(
+  t.equal(
     repo.ref("refs/heads/main"),
     undefined,
-    "main should not point to a commit"
+    "main should not point to a commit",
   );
-  t.is(
+  t.equal(
     repo.ref("refs/heads/new_feature"),
     commit,
-    "new_feature should point to last commit"
+    "new_feature should point to last commit",
   );
-  t.is(repo.branch(), "new_feature", "branch should now be visible");
-  t.is(
+  t.equal(repo.branch(), "new_feature", "branch should now be visible");
+  t.equal(
     repo.head(),
     "refs/heads/new_feature",
-    "HEAD is pointing to wrong branch"
+    "HEAD is pointing to wrong branch",
   );
 });
 
@@ -145,25 +136,25 @@ test("commit --amend changes hash on content change", async (t) => {
   const changedHash = await repo.commit(
     "name and description change",
     testAuthor,
-    true
+    true,
   );
   t.not(changedHash, commitToAmend, "hash should have changed");
   const history = repo.getHistory();
-  t.is(history.commits.length, 1, "wrong # of commits");
+  t.equal(history.commits.length, 1, "wrong # of commits");
   // @ts-ignore
-  t.is(
+  t.equal(
     sumChanges(history.commits),
     2,
     `wrong # of changes: ${JSON.stringify(
-      history.commits.flatMap((c) => c.changes)
-    )}`
+      history.commits.flatMap((c) => c.changes),
+    )}`,
   );
-  t.is(repo.head(), "refs/heads/main", "HEAD is not pointing to main");
-  t.is(repo.branch(), "main", "we are on the wrong branch");
-  t.is(
+  t.equal(repo.head(), "refs/heads/main", "HEAD is not pointing to main");
+  t.equal(repo.branch(), "main", "we are on the wrong branch");
+  t.equal(
     repo.ref("refs/heads/main"),
     changedHash,
-    "main should point to changed commit hash"
+    "main should point to changed commit hash",
   );
 });
 
@@ -177,14 +168,14 @@ test("commit --amend changes hash on message change", async (t) => {
 
   t.not(changedHash, commitToAmend, "hash should have changed");
   const history = repo.getHistory();
-  t.is(history.commits.length, 1, "wrong # of commits");
-  t.is(sumChanges(history.commits), 1, "wrong # of changes");
-  t.is(repo.head(), "refs/heads/main", "HEAD is not pointing to main");
-  t.is(repo.branch(), "main", "we are on the wrong branch");
-  t.is(
+  t.equal(history.commits.length, 1, "wrong # of commits");
+  t.equal(sumChanges(history.commits), 1, "wrong # of changes");
+  t.equal(repo.head(), "refs/heads/main", "HEAD is not pointing to main");
+  t.equal(repo.branch(), "main", "we are on the wrong branch");
+  t.equal(
     repo.ref("refs/heads/main"),
     changedHash,
-    "main should point to changed commit hash"
+    "main should point to changed commit hash",
   );
 });
 
@@ -198,17 +189,17 @@ test("commit at detached HEAD does not affect main, but moves head", async (t) =
   const last = await repo.commit("desc change", testAuthor);
 
   repo.checkout(commit);
-  t.is(repo.head(), commit, "HEAD did not move to commit");
-  t.is(repo.branch(), "HEAD", "repo is not in detached state");
-  t.deepEqual(v1, repo.data, "object state does not match");
+  t.equal(repo.head(), commit, "HEAD did not move to commit");
+  t.equal(repo.branch(), "HEAD", "repo is not in detached state");
+  t.matchOnly(v1, repo.data, "object state does not match");
 
   repo.data.description = "a different description";
   const commitOnDetached = await repo.commit("msg", testAuthor);
-  t.is(repo.head(), commitOnDetached, "HEAD did not move to commit");
-  t.is(
+  t.equal(repo.head(), commitOnDetached, "HEAD did not move to commit");
+  t.equal(
     repo.ref("refs/heads/main"),
     last,
-    "main branch did not stay at last commit"
+    "main branch did not stay at last commit",
   );
 });
 
@@ -224,10 +215,10 @@ test("commit at detached HEAD saved to a branch", async (t) => {
   const commitOnDetached = await repo.commit("msg", testAuthor);
 
   const savepointRef = repo.createBranch("savepoint");
-  t.is(
+  t.equal(
     repo.ref(savepointRef),
     commitOnDetached,
-    "savepoint branch should point to last detached commit"
+    "savepoint branch should point to last detached commit",
   );
 });
 
@@ -241,13 +232,13 @@ test("commit --amend changes hash on message change even in detached HEAD", asyn
   const changedHash = await repo.commit("initial setup", testAuthor, true);
   t.not(changedHash, commitToAmend, "hash should have changed");
   const history = repo.getHistory();
-  t.is(history.commits.length, 1, "wrong # of commits");
-  t.is(sumChanges(history.commits), 1, "wrong # of changes");
-  t.is(repo.branch(), "HEAD", "not in detached state");
-  t.is(repo.head(), changedHash, "HEAD is not pointing to detached commit");
-  t.is(
+  t.equal(history.commits.length, 1, "wrong # of commits");
+  t.equal(sumChanges(history.commits), 1, "wrong # of changes");
+  t.equal(repo.branch(), "HEAD", "not in detached state");
+  t.equal(repo.head(), changedHash, "HEAD is not pointing to detached commit");
+  t.equal(
     repo.ref("refs/heads/main"),
     descCommit,
-    "main should point to changed commit hash"
+    "main should point to changed commit hash",
   );
 });

package/src/merge.test.ts

@@ -1,4 +1,4 @@
-import test from "ava";
+import { test } from "tap";
 import { getBaseline, testAuthor } from "./test.utils";
 
 test("merge with no commit fails", async (t) => {
@@ -12,7 +12,7 @@ test("merge with no commit fails", async (t) => {
     () => {
       repo.merge("new_feature");
     },
-    { message: "already up to date" }
+    { message: "already up to date" },
   );
 });
 
@@ -25,11 +25,15 @@ test("merge fast-forward", async (t) => {
   repo.checkout("new_branch", true);
   repo.data.name = "another name";
   const minorHash = await repo.commit("minor change", testAuthor);
-  t.is(repo.head(), "refs/heads/new_branch", "HEAD not pointing to new_branch");
-  t.is(
+  t.equal(
+    repo.head(),
+    "refs/heads/new_branch",
+    "HEAD not pointing to new_branch",
+  );
+  t.equal(
     repo.ref("refs/heads/new_branch"),
     minorHash,
-    "branch did not move to new commit"
+    "branch did not move to new commit",
   );
 
   // go to destination branch
@@ -38,11 +42,11 @@ test("merge fast-forward", async (t) => {
   const headRef = repo.head();
   const refHash = repo.ref(headRef);
 
-  t.is(mergeHash, minorHash, "did not fast-forward to expected commit");
-  t.is(refHash, mergeHash, `master is not at expected commit`);
-  t.is(
+  t.equal(mergeHash, minorHash, "did not fast-forward to expected commit");
+  t.equal(refHash, mergeHash, `master is not at expected commit`);
+  t.equal(
     repo.getHistory().commits.length,
     masterCommitCount + 1,
-    "fast-forward failed, superfluous commit detected"
+    "fast-forward failed, superfluous commit detected",
   );
 });

package/src/repository.test.ts

@@ -1,4 +1,4 @@
-import test from "ava";
+import { test } from "tap";
 
 import { Repository } from "./repository";
 import {
@@ -9,84 +9,7 @@ import {
   testAuthor,
   updateHeaderData,
 } from "./test.utils";
-
-test("reconstruction", async (t) => {
-  const [repo, wrapped] = await getBaseline();
-
-  let changeEntries = updateHeaderData(wrapped);
-  await repo.commit("header data", testAuthor);
-
-  changeEntries += addOneNested(wrapped);
-  const firstStep = await repo.commit("first step", testAuthor);
-
-  const history = repo.getHistory();
-  t.is(repo.head(), "refs/heads/main", "HEAD is wrong");
-  t.is(
-    repo.ref("refs/heads/main"),
-    firstStep,
-    "main is pointing at wrong commit"
-  );
-  t.is(history.commits.length, 2, "incorrect # of commits");
-
-  // start reconstruction
-  const p = new ComplexObject();
-  const repo2 = new Repository(p, { history });
-
-  const history2 = repo2.getHistory();
-  t.is(history2.commits.length, 2, "incorrect # of commits");
-  t.is(
-    sumChanges(history2.commits),
-    changeEntries,
-    "incorrect # of changelog entries"
-  );
-});
-
-test("reconstruct with 2 commits", async (t) => {
-  const [repo, wrapped] = await getBaseline();
-
-  let changeEntries = updateHeaderData(wrapped);
-  await repo.commit("header data", testAuthor);
-
-  addOneNested(wrapped);
-  changeEntries++;
-  const first = await repo.commit("first nested", testAuthor);
-
-  t.is(repo.ref("refs/heads/main"), first, "main is pointing at wrong commit");
-
-  addOneNested(wrapped);
-  changeEntries++;
-
-  const second = await repo.commit("second nested", testAuthor);
-
-  const history = repo.getHistory();
-
-  t.is(repo.ref("refs/heads/main"), second, "main is pointing at wrong commit");
-  t.is(history.commits.length, 3, "incorrect # of commits");
-
-  // start reconstruction
-  const p = new ComplexObject();
-  const repo2 = new Repository(p, { history });
-
-  const history2 = repo2.getHistory();
-  t.is(history2.commits.length, 3, "incorrect # of commits");
-  t.is(
-    sumChanges(history2.commits),
-    changeEntries,
-    "incorrect # of changelog entries"
-  );
-});
-
-test("history contains HEAD ref", async (t) => {
-  const [repo] = await getBaseline();
-
-  t.is(repo.head(), "refs/heads/main");
-
-  const history = repo.getHistory();
-  let headRef = history.refs.get("HEAD");
-  t.not(headRef, undefined);
-  t.is(headRef!.name, "HEAD");
-  t.is(headRef!.value, "ref: refs/heads/main");
-});
+import { History, Reference } from "./interfaces";
 
 test("diff is ok", async (t) => {
   const [repo, obj] = await getBaseline();
@@ -97,16 +20,171 @@ test("diff is ok", async (t) => {
   let changeEntries = addOneNested(obj);
   const first = await repo.commit("first nested", testAuthor);
 
-  t.is(repo.ref("refs/heads/main"), first, "main is pointing at wrong commit");
+  t.equal(
+    repo.ref("refs/heads/main"),
+    first,
+    "main is pointing at wrong commit",
+  );
 
   changeEntries += addOneNested(obj);
 
   const second = await repo.commit("second nested", testAuthor);
 
   const diff = repo.diff(zeroth);
-  t.is(
+  t.equal(
     diff.length,
     changeEntries,
-    `invalid # of change entries: ${JSON.stringify(diff)}`
+    `invalid # of change entries: ${JSON.stringify(diff)}`,
   );
 });
+
+test("restore", async (t) => {
+  t.test("history check", async (t) => {
+    const [repo, wrapped] = await getBaseline();
+
+    let changeEntries = updateHeaderData(wrapped);
+    await repo.commit("header data", testAuthor);
+
+    changeEntries += addOneNested(wrapped);
+    const firstStep = await repo.commit("first step", testAuthor);
+
+    const history = repo.getHistory();
+    t.equal(repo.head(), "refs/heads/main", "HEAD is wrong");
+    t.equal(
+      repo.ref("refs/heads/main"),
+      firstStep,
+      "main is pointing at wrong commit",
+    );
+    t.equal(history.commits.length, 2, "incorrect # of commits");
+
+    // start reconstruction
+    const p = {};
+    const repo2 = new Repository(p, { history });
+
+    const history2 = repo2.getHistory();
+    t.equal(
+      history2.commits.length,
+      history.commits.length,
+      "incorrect # of commits",
+    );
+    t.equal(
+      sumChanges(history2.commits),
+      sumChanges(history.commits),
+      "incorrect # of changelog entries",
+    );
+  });
+
+  t.test("reconstruct with 2 commits", async (t) => {
+    const [repo, wrapped] = await getBaseline();
+
+    let changeEntries = updateHeaderData(wrapped);
+    await repo.commit("header data", testAuthor);
+
+    addOneNested(wrapped);
+    changeEntries++;
+    const first = await repo.commit("first nested", testAuthor);
+
+    t.equal(
+      repo.ref("refs/heads/main"),
+      first,
+      "main is pointing at wrong commit",
+    );
+
+    addOneNested(wrapped);
+    changeEntries++;
+
+    const second = await repo.commit("second nested", testAuthor);
+
+    const history = repo.getHistory();
+
+    t.equal(
+      repo.ref("refs/heads/main"),
+      second,
+      "main is pointing at wrong commit",
+    );
+    t.equal(history.commits.length, 3, "incorrect # of commits");
+
+    // start reconstruction
+    const p = {};
+    const repo2 = new Repository(p, { history });
+
+    const history2 = repo2.getHistory();
+    t.equal(
+      history2.commits.length,
+      history.commits.length,
+      "incorrect # of commits",
+    );
+    t.equal(
+      sumChanges(history2.commits),
+      sumChanges(history.commits),
+      "incorrect # of changelog entries",
+    );
+  });
+
+  test("restoring from history", 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 obj2 = {};
+    // @ts-ignore
+    const repo2 = new Repository(obj2, { history });
+
+    t.matchOnly(obj, obj2, "restored object does not equal last version.");
+  });
+});
+
+test("history", async (t) => {
+  t.test("history contains HEAD ref", async (t) => {
+    const [repo] = await getBaseline();
+
+    t.equal(repo.head(), "refs/heads/main");
+
+    const history = repo.getHistory();
+    let headRef = history.refs.get("HEAD");
+    t.not(headRef, undefined);
+    t.equal(headRef!.name, "HEAD");
+    t.equal(headRef!.value, "ref: refs/heads/main");
+  });
+
+  t.test("empty history unreachable HEAD", async (t) => {
+    const co: ComplexObject = { nested: [] };
+    t.throws(
+      () =>
+        new Repository(co, {
+          history: {
+            original: co,
+            refs: new Map<string, Reference>(),
+            commits: [],
+          } as History<ComplexObject>,
+        }),
+      {
+        message: "unreachable: 'HEAD' is not present",
+      },
+    );
+  });
+});
+
+test("reset", async (t) => {
+  t.test("reset hard", async (t) => {
+    const [repo, co] = await getBaseline();
+    co.uuid = "asdf";
+    const hash = await repo.commit("baseline", testAuthor);
+    const h1 = repo.getHistory();
+    t.equal(h1.commits.length, 1);
+    // do changes
+    const changes = updateHeaderData(co);
+    const diff = repo.diff(hash);
+    t.equal(diff.length, changes, "wrong # of changes in diff");
+
+    // reset
+    repo.reset("hard");
+    const diff2 = repo.diff(hash);
+    t.equal(diff2.length, 0, "failed to reset");
+  });
+});