@dotinc/ogre 0.1.0

package/lib/test.utils.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sumChanges = exports.addOneStep = exports.updateHeaderData = exports.getBaseline = exports.testAuthor = exports.ComplexObject = exports.NestedObject = void 0;
+const uuid_1 = require("uuid");
+const repository_1 = require("./repository");
+class NestedObject {
+}
+exports.NestedObject = NestedObject;
+class ComplexObject {
+    constructor() {
+        this.nested = [];
+    }
+}
+exports.ComplexObject = ComplexObject;
+exports.testAuthor = 'User name <name@domain.com>';
+async function getBaseline() {
+    const co = new ComplexObject();
+    const repo = new repository_1.Repository(co, {});
+    return [repo, repo.data];
+}
+exports.getBaseline = getBaseline;
+function updateHeaderData(wrapped) {
+    wrapped.uuid = (0, uuid_1.v4)();
+    wrapped.name = 'my first process template';
+    wrapped.description = 'now we have a description';
+    return 3; // change entries
+}
+exports.updateHeaderData = updateHeaderData;
+function addOneStep(wrapped) {
+    const pe = new NestedObject();
+    pe.uuid = (0, uuid_1.v4)();
+    pe.name = 'first name';
+    wrapped.nested.push(pe);
+    wrapped.nested[0].name = 'new name';
+    return 3; // change entries
+}
+exports.addOneStep = addOneStep;
+function sumChanges(commits) {
+    return commits === null || commits === void 0 ? void 0 : commits.map(c => c.changes.length).reduce((p, c) => p + c, 0);
+}
+exports.sumChanges = sumChanges;

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@dotinc/ogre",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dotindustries/ogre.git"
+  },
+  "version": "0.1.0",
+  "description": "Git-like repository for in-memory object versioning",
+  "main": "lib/index.ts",
+  "types": "lib/index.d.ts",
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "test": "nyc --reporter=lcov ava",
+    "test.watch": "ava --watch",
+    "coverage:html": "nyc report --reporter=html"
+  },
+  "ava": {
+    "timeout": "60s",
+    "files": [
+      "./src/**/*.test.ts"
+    ],
+    "extensions": [
+      "ts"
+    ],
+    "require": [
+      "ts-node/register"
+    ]
+  },
+  "author": "János Veres @nadilas",
+  "license": "MIT",
+  "devDependencies": {
+    "@ava/typescript": "^3.0.1",
+    "@types/node": "^17.0.21",
+    "@types/uuid": "^8.3.4",
+    "ava": "^4.0.1",
+    "coveralls": "^3.1.1",
+    "nyc": "^15.1.0",
+    "ts-node": "^10.7.0",
+    "tslib": "^2.3.1",
+    "turbo": "^1.1.5",
+    "typescript": "^4.5.5",
+    "uuid": "^8.3.2"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "gitHead": "d1ea04300335cd7618f4cf66251123f489d17b1c"
+}

package/src/branch.test.ts

@@ -0,0 +1,58 @@
+import test from 'ava'
+import {getBaseline, sumChanges, testAuthor} from './test.utils'
+
+
+test('current branch on empty repo is HEAD', async t => {
+  const [repo] = await getBaseline()
+
+  t.is(repo.branch(), 'HEAD', 'invalid current branch')
+})
+
+test('first commit goes onto default \'main\' branch', async t => {
+  const [repo] = await getBaseline()
+  repo.data.name = 'new name'
+  await repo.commit('initial commit', testAuthor)
+
+  t.is(repo.branch(), 'main', 'invalid current branch')
+  t.is(repo.head(), 'refs/heads/main', 'invalid HEAD')
+})
+
+test('fails to create a branch with empty repo', async t => {
+  const [ repo ] = await getBaseline()
+  let history = repo.getHistory()
+  t.is(history.commits.length, 0, 'incorrect # of commits')
+  t.is(sumChanges(history?.commits), 0, 'new branch w/ incorrect # of changelog entries')
+
+  t.throws(() => {
+    // cannot point new branch to nothing on empty repo
+    repo.createBranch('new_feature')
+  }, {message: 'fatal: not a valid object name: \'main\''})
+})
+
+test('checkout new branch with empty repo', async t => {
+  const [ repo ] = await getBaseline()
+
+  repo.checkout('new_feature', true)
+  t.is(repo.head(), 'refs/heads/new_feature', 'HEAD did not move to new branch')
+  t.is(repo.ref('/refs/heads/main'), undefined, 'main should not be pointing to anything')
+  t.is(repo.ref('refs/heads/new_feature'), undefined, 'new_feature should not be pointing to anything')
+})
+
+test('creating a valid branch on a baseline', async t => {
+  const [ repo ] = await getBaseline()
+  repo.data.name = 'new name'
+  const commit = await repo.commit('simple change', testAuthor)
+  const ref = repo.createBranch('new_feature')
+  t.is(ref, 'refs/heads/new_feature', 'invalid branch ref created')
+  t.is(repo.ref(ref), commit, 'new branch is pointing to wrong commit')
+})
+
+test('cannot create new branch with invalid name', async t => {
+  const [ repo ] = await getBaseline()
+
+  for (const name of ['', '-foo', 'HEAD']) {
+    t.throws(() => {
+      repo.createBranch(name)
+    }, {message: 'invalid ref name'})
+  }
+})

package/src/checkout.test.ts

@@ -0,0 +1,101 @@
+import test from 'ava'
+import {addOneStep, ComplexObject, getBaseline, sumChanges, testAuthor, updateHeaderData} from './test.utils'
+import {Repository} from './repository'
+
+test('checkout prev commit', async t => {
+  const [ repo, wrapped ] = await getBaseline()
+
+  updateHeaderData(wrapped)
+  const headerDataHash = await repo.commit('header data', testAuthor)
+
+  addOneStep(wrapped)
+  await repo.commit('first step', testAuthor)
+
+  repo.checkout(headerDataHash)
+  const head = repo.head()
+  const history = repo.getHistory()
+  t.is(sumChanges(history.commits), 3, `incorrect # of changelog entries`)
+  t.is(history.commits.length, 1, 'incorrect # of commits')
+  t.is(head, headerDataHash, `points to wrong commit`)
+  t.is(repo.branch(), 'HEAD', 'repo is not in detached state')
+})
+
+test('checkout new branch with simple name', async t => {
+  const [ repo ] = await getBaseline()
+  repo.data.name = 'new name'
+  await repo.commit('simple change', testAuthor)
+
+  const ref = repo.createBranch('new_feature')
+  repo.checkout('new_feature')
+  t.is(repo.head(), ref, 'HEAD is not moved to target branch')
+})
+
+test('checkout new branch with full ref name', async t => {
+  const [ repo ] = await getBaseline()
+  repo.data.name = 'new name'
+  await repo.commit('simple change', testAuthor)
+
+  const ref = repo.createBranch('new_feature')
+  repo.checkout(ref)
+  t.is(repo.head(), ref, 'HEAD is not moved to target branch')
+})
+
+test('checkout commit which has two refs pointing leaves HEAD detached', async t => {
+  const [ repo ] = await getBaseline()
+  repo.data.name = 'new name'
+  const commit = await repo.commit('simple change', testAuthor)
+
+  repo.createBranch('new_feature')
+  repo.checkout(commit)
+  t.is(repo.ref('refs/heads/main'), commit, 'main does not point to commit')
+  t.is(repo.ref('refs/heads/new_feature'), commit, 'new_feature does not point to commit')
+  t.is(repo.branch(), 'HEAD', 'HEAD is not detached at commit')
+  t.is(repo.head(), commit, 'HEAD is not pointing to commit')
+})
+
+test('checkout new branch moves head to new branch', async t => {
+  const [ repo ] = await getBaseline()
+  repo.data.name = 'new name'
+  await repo.commit('simple change', testAuthor)
+
+  const ref = repo.createBranch('new_feature')
+  repo.checkout('new_feature')
+  t.is(repo.head(), ref, 'HEAD is not moved to target branch')
+})
+
+test('checkout and create new branch on empty main', async t => {
+  const [repo] = await getBaseline()
+
+  repo.checkout('new_feature', true)
+  t.is(repo.head(), 'refs/heads/new_feature', 'HEAD should point to empty branch')
+  t.is(repo.branch(), 'HEAD', 'branch still should be empty')
+})
+
+test('checkout and create new branch with at least 1 commit', async t => {
+  const [repo] = await getBaseline()
+  repo.data.name = 'new name'
+  const commit = await repo.commit('simple change', testAuthor)
+
+  repo.checkout('new_feature', true)
+  t.is(repo.head(), 'refs/heads/new_feature', 'HEAD should point to new branch')
+  t.is(repo.ref('refs/heads/new_feature'), commit, 'branch is not pointing to last HEAD commit')
+})
+
+
+test('replacing default branch on empty master removes main', async t => {
+  const repo = new Repository(new ComplexObject(), {})
+
+  // replacing default main branch by moving HEAD to new branch
+  // is OK even on empty repo
+  repo.checkout('new_feature', true)
+  const history = repo.getHistory()
+  t.is(sumChanges(history?.commits), 0, 'new branch w/ incorrect # of changelog entries')
+
+  repo.data.name = "name changed"
+  repo.data.description = "description changed"
+  await repo.commit('description changes', testAuthor)
+
+  t.throws(() => {
+    repo.checkout('main')
+  }, {message: `pathspec 'main' did not match any known refs`})
+})

package/src/commit.test.ts

@@ -0,0 +1,168 @@
+import test from 'ava'
+import { addOneStep, getBaseline, sumChanges, testAuthor, updateHeaderData } from './test.utils'
+
+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')
+})
+
+test('head points to main', async t => {
+  const [repo] = await getBaseline()
+
+  t.is(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' })
+})
+
+test('no commit without changes after recent commit', async t => {
+  const [repo] = await getBaseline()
+  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' })
+})
+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' })
+})
+
+test('main moves to recent commit', async t => {
+  const [repo] = await getBaseline()
+  repo.data.name = 'new name'
+  const hash = await repo.commit('baseline', testAuthor)
+
+  t.is(repo.ref('refs/heads/main'), hash, 'head does not point to recent commit')
+})
+
+test('two commits with 3 changes', async t => {
+  const [repo, wrapped] = await getBaseline()
+  updateHeaderData(wrapped)
+  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')
+})
+
+test('array push double-change, 6 changes, 3 commits', async t => {
+  const [repo, wrapped] = await getBaseline()
+
+  updateHeaderData(wrapped)
+  await repo.commit('header data', testAuthor)
+
+  addOneStep(wrapped)
+  await repo.commit('first step', testAuthor)
+
+  const history = repo.getHistory()
+  t.is(sumChanges(history.commits), 6, 'incorrect # of changelog entries')
+  t.is(history.commits.length, 2, 'incorrect # of commits')
+  t.is(history.commits[0].changes.length, 3, '#incorrect # of changes in commit#1')
+  t.is(history.commits[1].changes.length, 3, '#incorrect # of changes in commit#2')
+})
+
+test('all refs OK, when committing on new branch while main is empty main', async t => {
+  const [repo] = await getBaseline()
+  repo.checkout('new_feature', true)
+  repo.data.name = 'new name'
+  const commit = await repo.commit('simple change', testAuthor)
+
+  t.is(repo.ref('refs/heads/main'), undefined, 'main should not point to a commit')
+  t.is(repo.ref('refs/heads/new_feature'), commit, 'new_feature should point to last commit')
+  t.is(repo.branch(), 'new_feature', 'branch should now be visible')
+  t.is(repo.head(), 'refs/heads/new_feature', 'HEAD is pointing to wrong branch')
+})
+
+test('commit --amend changes hash on content change', async t => {
+  const [repo] = await getBaseline()
+  repo.data.name = 'new name'
+  const commitToAmend = await repo.commit('name change', testAuthor)
+  repo.data.description = 'new description'
+  const changedHash = await repo.commit('name and description change', 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), 2, '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(repo.ref('refs/heads/main'), changedHash, 'main should point to changed commit hash')
+})
+
+test('commit --amend changes hash on message change', async t => {
+  const [repo] = await getBaseline()
+  repo.data.name = 'new name'
+  const commitToAmend = await repo.commit('name change', testAuthor)
+  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.head(), 'refs/heads/main', 'HEAD is not pointing to main')
+  t.is(repo.branch(), 'main', 'we are on the wrong branch')
+  t.is(repo.ref('refs/heads/main'), changedHash, 'main should point to changed commit hash')
+})
+
+test('commit at detached HEAD does not affect main, but moves head', async t => {
+  const [repo] = await getBaseline()
+  repo.data.name = 'new name'
+  const v1 = repo.data
+  const commit = await repo.commit('name change', testAuthor)
+  repo.data.description = 'new fancy description'
+  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')
+
+  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(repo.ref('refs/heads/main'), last, 'main branch did not stay at last commit')
+})
+
+test('commit at detached HEAD saved to a branch', async t => {
+  const [repo] = await getBaseline()
+  repo.data.name = 'new name'
+  const commit = await repo.commit('name change', testAuthor)
+  repo.data.description = 'new fancy description'
+  await repo.commit('desc change', testAuthor)
+  repo.checkout(commit)
+
+  repo.data.description = 'a different description'
+  const commitOnDetached = await repo.commit('msg', testAuthor)
+
+  const savepointRef = repo.createBranch('savepoint')
+  t.is(repo.ref(savepointRef), commitOnDetached, 'savepoint branch should point to last detached commit')
+})
+
+
+test('commit --amend changes hash on message change even in detached HEAD', async t => {
+  const [repo] = await getBaseline()
+  repo.data.name = 'new name'
+  const commitToAmend = await repo.commit('name change', testAuthor)
+  repo.data.description = 'desc change'
+  const descCommit = await repo.commit('desc change', testAuthor)
+  repo.checkout(commitToAmend)
+  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(repo.ref('refs/heads/main'), descCommit, 'main should point to changed commit hash')
+})

package/src/commit.ts

@@ -0,0 +1,45 @@
+import { Change } from './interfaces'
+import { digest } from './hash'
+
+export interface Commit {
+  // The hash of the commit
+  // Is an sha256 of:
+  // - tree object reference (changes?)
+  // - parent object reference (parent hash)
+  // - author
+  // - author commit timestamp with timezone
+  // - commit message
+  hash: string
+
+  message: string | undefined
+  author: string
+
+  // The hash of the parent commit
+  parent: string | undefined
+
+  // The diff of this commit from the parent
+  changes: Change[]
+
+  // Commit timestamp with timezone
+  timestamp: Date
+
+  // The version number to the corresponding changelog entry (not zero-based index)
+  // Therefore it can be used as an index, when accessing the changelog to
+  // retrieve the relevant changes e.g.:
+  // ```
+  // const changes = changeLog.slice(commit.from, commit.to)
+  // ```
+  to: number;
+}
+
+export interface HashContent {
+  message: string
+  author: string
+  parentRef: string | undefined
+  changes: Change[]
+  timestamp: Date
+}
+
+export function calculateHash(content: HashContent) {
+  return digest(content)
+}

package/src/hash.ts

@@ -0,0 +1,82 @@
+/**
+ * Credit goes to https://github.com/juanelas/object-sha
+ *
+ * @remarks
+ * This module runs perfectly in node.js and browsers
+ *
+ * @packageDocumentation
+ */
+
+/**
+ * Returns a string with a hexadecimal representation of the digest of the input object using a given hash algorithm.
+ * It first creates an array of the object values ordered by the object keys (using hashable(obj));
+ * then, it JSON.stringify-es it; and finally it hashes it.
+ *
+ * @param obj - An Object
+ * @param algorithm - For compatibility with browsers it should be 'SHA-1', 'SHA-256', 'SHA-384' and 'SHA-512'.
+ *
+ * @param isBrowser
+ * @throws {RangeError}
+ * Thrown if an invalid hash algorithm is selected.
+ *
+ * @returns a promise that resolves to a string with hexadecimal content.
+ */
+export function digest (obj: any, algorithm = 'SHA-256', isBrowser = false): Promise<string> { // eslint-disable-line
+  const algorithms = ['SHA-1', 'SHA-256', 'SHA-384', 'SHA-512']
+  if (!algorithms.includes(algorithm)) {
+    throw RangeError(`Valid hash algorithm values are any of ${JSON.stringify(algorithms)}`)
+  }
+  return (async function (obj, algorithm) {
+    const encoder = new TextEncoder()
+    const hashInput = encoder.encode(hashable(obj)).buffer
+    let digest = ''
+
+    if (isBrowser) {
+      const buf = await crypto.subtle.digest(algorithm, hashInput)
+      const h = '0123456789abcdef';
+      (new Uint8Array(buf)).forEach((v) => {
+        digest += h[v >> 4] + h[v & 15]
+      })
+    } else {
+      const nodeAlg = algorithm.toLowerCase().replace('-', '')
+      digest = require('crypto').createHash(nodeAlg).update(Buffer.from(hashInput)).digest('hex') // eslint-disable-line
+    }
+    /* eslint-enable no-lone-blocks */
+    return digest
+  })(obj, algorithm)
+}
+
+function isObject (val: any): boolean {
+  return (val != null) && (typeof val === 'object') && !(Array.isArray(val))
+}
+
+function objectToArraySortedByKey (obj: any): any {
+  if (!isObject(obj) && !Array.isArray(obj)) {
+    return obj
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => {
+      if (Array.isArray(item) || isObject(item)) {
+        return objectToArraySortedByKey(item)
+      }
+      return item
+    })
+  }
+  // if it is an object convert to array and sort
+  return Object.keys(obj) // eslint-disable-line
+    .sort()
+    .map((key) => {
+      return [key, objectToArraySortedByKey(obj[key])]
+    })
+}
+
+/**
+ * If the input object is not an Array, this function converts the object to an array, all the key-values to 2-arrays [key, value] and then sort the array by the keys. All the process is done recursively so objects inside objects or arrays are also ordered. Once the array is created the method returns the JSON.stringify() of the sorted array.
+ *
+ * @param {object} obj the object
+ *
+ * @returns {string} a JSON stringify of the created sorted array
+ */
+const hashable = (obj: object) => {
+  return JSON.stringify(objectToArraySortedByKey(obj))
+}

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './interfaces'
+export * from './repository'
+export {Commit} from './commit'
+export * from './ref'
+export * from './size'

package/src/interfaces.ts

@@ -0,0 +1,19 @@
+import { Commit } from './commit'
+
+export interface Reference {
+  name: string
+  // A reference can point to a commit via its sha256
+  // or it can point to a reference
+  value: string
+}
+
+export interface Change {
+  path: any[]
+  newValue: any | undefined
+  oldValue: any | undefined
+}
+
+export interface History {
+  refs: Map<string, Reference>
+  commits: Commit[]
+}

package/src/merge.test.ts

@@ -0,0 +1,38 @@
+import test from 'ava'
+import {getBaseline, testAuthor} from './test.utils'
+
+test('merge with no commit fails', async t => {
+  const [repo] = await getBaseline()
+  repo.data.name = 'new name'
+  await repo.commit('simple change', testAuthor)
+
+  repo.createBranch('new_feature')
+
+  t.throws(() => {
+    repo.merge('new_feature')
+  }, { message: 'already up to date'})
+})
+
+test('merge fast-forward', async t => {
+  const [repo] = await getBaseline()
+  repo.data.name = 'new name'
+  await repo.commit('simple change', testAuthor)
+  const masterCommitCount = repo.getHistory().commits.length
+
+  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(repo.ref('refs/heads/new_branch'), minorHash, 'branch did not move to new commit')
+
+  // go to destination branch
+  repo.checkout('main')
+  const mergeHash = repo.merge('new_branch')
+  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(repo.getHistory().commits.length, masterCommitCount+1, 'fast-forward failed, superfluous commit detected')
+
+})

package/src/ref.ts

@@ -0,0 +1,10 @@
+const bad = /(^|[/.])([/.]|$)|^@$|@{|[\x00-\x20\x7f~^:?*[\\]|\.lock(\/|$)/
+const badBranch = /^(-|HEAD$)/
+
+export function validRef (name: string, onelevel: boolean) {
+  return !bad.test(name) && (onelevel || name.includes('/'))
+}
+
+export function validBranch (name: string) {
+  return validRef(name, true) && !badBranch.test(name)
+}

package/src/repository.test.ts

@@ -0,0 +1,26 @@
+import test from 'ava'
+import { Repository } from './repository'
+import {addOneStep, ComplexObject, getBaseline, sumChanges, 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 += addOneStep(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')
+})