Implement a Git graph view (#415)

Summary:
Similar in structure to the GitHub graph view.

Test Plan:
Unit tests added, with full coverage.

wchargin-branch: git-graph-view

src/v3/plugins/git/createGraph.test.js

@@ -8,6 +8,7 @@ import {
   findBecomesEdges,
   findBecomesEdgesForCommits,
 } from "./createGraph";
+import {GraphView} from "./graphView";
 import type {Hash, Tree} from "./types";
 
 const makeData = () => cloneDeep(require("./demoData/example-git"));
@@ -17,6 +18,11 @@ describe("plugins/git/createGraph", () => {
     it("processes a simple repository", () => {
       expect(createGraph(makeData())).toMatchSnapshot();
     });
+
+    it("satisfies the GraphView invariants", () => {
+      const graph = createGraph(makeData());
+      expect(() => new GraphView(graph)).not.toThrow();
+    });
   });
 
   describe("findBecomesEdgesForCommits", () => {

src/v3/plugins/git/graphView.js

@@ -0,0 +1,327 @@
+// @flow
+
+import {
+  type EdgeAddressT,
+  type NeighborsOptions,
+  type NodeAddressT,
+  Direction,
+  Graph,
+  NodeAddress,
+  edgeToString,
+} from "../../core/graph";
+
+import * as GN from "./nodes";
+import * as GE from "./edges";
+
+export class GraphView {
+  _graph: Graph;
+
+  constructor(graph: Graph): void {
+    this._graph = graph;
+    this._maybeCheckInvariants();
+  }
+
+  *_neighbors<T: GN.StructuredAddress>(
+    node: GN.StructuredAddress,
+    options: NeighborsOptions
+  ): Iterator<T> {
+    if (!NodeAddress.hasPrefix(options.nodePrefix, GN._Prefix.base)) {
+      throw new Error(`_neighbors must filter to Git nodes`);
+    }
+    const rawNode: GN.RawAddress = GN.toRaw(node);
+    for (const neighbor of this._graph.neighbors(rawNode, options)) {
+      this._maybeCheckInvariants();
+      yield ((GN.fromRaw(
+        (((neighbor.node: NodeAddressT): any): GN.RawAddress)
+      ): any): T);
+    }
+    this._maybeCheckInvariants();
+  }
+
+  graph(): Graph {
+    const result = this._graph;
+    this._maybeCheckInvariants();
+    return result;
+  }
+
+  commits(): Iterator<GN.CommitAddress> {
+    const result = this._commits();
+    this._maybeCheckInvariants();
+    return result;
+  }
+
+  *_commits(): Iterator<GN.CommitAddress> {
+    for (const node of this._graph.nodes({prefix: GN._Prefix.commit})) {
+      const rawAddress: GN.RawAddress = ((node: NodeAddressT): any);
+      const commit: GN.CommitAddress = (GN.fromRaw(rawAddress): any);
+      this._maybeCheckInvariants();
+      yield commit;
+    }
+    this._maybeCheckInvariants();
+  }
+
+  tree(commit: GN.CommitAddress): GN.TreeAddress {
+    const result: GN.TreeAddress = Array.from(
+      this._neighbors(commit, {
+        direction: Direction.OUT,
+        nodePrefix: GN._Prefix.tree,
+        edgePrefix: GE._Prefix.hasTree,
+      })
+    )[0];
+    this._maybeCheckInvariants();
+    return result;
+  }
+
+  parents(commit: GN.CommitAddress): Iterator<GN.CommitAddress> {
+    const result: Iterator<GN.CommitAddress> = this._neighbors(commit, {
+      direction: Direction.OUT,
+      nodePrefix: GN._Prefix.commit,
+      edgePrefix: GE._Prefix.hasParent,
+    });
+    this._maybeCheckInvariants();
+    return result;
+  }
+
+  entries(tree: GN.TreeAddress): Iterator<GN.TreeEntryAddress> {
+    const result: Iterator<GN.TreeEntryAddress> = this._neighbors(tree, {
+      direction: Direction.OUT,
+      nodePrefix: GN._Prefix.treeEntry,
+      edgePrefix: GE._Prefix.includes,
+    });
+    this._maybeCheckInvariants();
+    return result;
+  }
+
+  contents(entry: GN.TreeEntryAddress): Iterator<GN.TreeEntryContentsAddress> {
+    const result: Iterator<GN.TreeEntryContentsAddress> = this._neighbors(
+      entry,
+      {
+        direction: Direction.OUT,
+        nodePrefix: GN._Prefix.base, // multiple kinds
+        edgePrefix: GE._Prefix.hasContents,
+      }
+    );
+    this._maybeCheckInvariants();
+    return result;
+  }
+
+  evolvesTo(entry: GN.TreeEntryAddress): Iterator<GN.TreeEntryAddress> {
+    const result: Iterator<GN.TreeEntryAddress> = this._neighbors(entry, {
+      direction: Direction.OUT,
+      nodePrefix: GN._Prefix.treeEntry,
+      edgePrefix: GE._Prefix.becomes,
+    });
+    this._maybeCheckInvariants();
+    return result;
+  }
+
+  evolvesFrom(entry: GN.TreeEntryAddress): Iterator<GN.TreeEntryAddress> {
+    const result: Iterator<GN.TreeEntryAddress> = this._neighbors(entry, {
+      direction: Direction.IN,
+      nodePrefix: GN._Prefix.treeEntry,
+      edgePrefix: GE._Prefix.becomes,
+    });
+    this._maybeCheckInvariants();
+    return result;
+  }
+
+  _maybeCheckInvariants() {
+    if (process.env.NODE_ENV === "test") {
+      // TODO(perf): If this method becomes really slow, we can disable
+      // it on specific tests wherein we construct large graphs.
+      this.checkInvariants();
+    }
+  }
+
+  checkInvariants() {
+    // All Git nodes and edges must have valid Git addresses.
+    for (const node of this._graph.nodes({prefix: GN._Prefix.base})) {
+      GN.fromRaw((((node: NodeAddressT): any): GN.RawAddress));
+    }
+    // (Edges are checked down below.)
+
+    // All Git edges must have `src` and `dst` of specific types.
+    type EdgeInvariant = {|
+      +prefix: GE.RawAddress,
+      +homs: $ReadOnlyArray<{|
+        +srcPrefix: NodeAddressT,
+        +dstPrefix: NodeAddressT,
+      |}>,
+    |};
+    const edgeInvariants = {
+      [GE.HAS_TREE_TYPE]: {
+        prefix: GE._Prefix.hasTree,
+        homs: [{srcPrefix: GN._Prefix.commit, dstPrefix: GN._Prefix.tree}],
+      },
+      [GE.HAS_PARENT_TYPE]: {
+        prefix: GE._Prefix.hasParent,
+        homs: [{srcPrefix: GN._Prefix.commit, dstPrefix: GN._Prefix.commit}],
+      },
+      [GE.INCLUDES_TYPE]: {
+        prefix: GE._Prefix.includes,
+        homs: [{srcPrefix: GN._Prefix.tree, dstPrefix: GN._Prefix.treeEntry}],
+      },
+      [GE.BECOMES_TYPE]: {
+        prefix: GE._Prefix.becomes,
+        homs: [
+          {srcPrefix: GN._Prefix.treeEntry, dstPrefix: GN._Prefix.treeEntry},
+        ],
+      },
+      [GE.HAS_CONTENTS_TYPE]: {
+        prefix: GE._Prefix.hasContents,
+        homs: [
+          {srcPrefix: GN._Prefix.treeEntry, dstPrefix: GN._Prefix.blob},
+          {srcPrefix: GN._Prefix.treeEntry, dstPrefix: GN._Prefix.tree},
+          {
+            srcPrefix: GN._Prefix.treeEntry,
+            dstPrefix: GN._Prefix.submoduleCommit,
+          },
+        ],
+      },
+    };
+
+    for (const edge of this._graph.edges({
+      addressPrefix: GE._Prefix.base,
+      srcPrefix: NodeAddress.empty,
+      dstPrefix: NodeAddress.empty,
+    })) {
+      const address = GE.fromRaw(
+        (((edge.address: EdgeAddressT): any): GE.RawAddress)
+      );
+      const invariant: EdgeInvariant = edgeInvariants[address.type];
+      if (invariant == null) {
+        throw new Error(
+          `Missing invariant definition for: ${String(address.type)}`
+        );
+      }
+      if (
+        !invariant.homs.some(
+          ({srcPrefix, dstPrefix}) =>
+            NodeAddress.hasPrefix(edge.src, srcPrefix) &&
+            NodeAddress.hasPrefix(edge.dst, dstPrefix)
+        )
+      ) {
+        throw new Error(`invariant violation: bad hom: ${edgeToString(edge)}`);
+      }
+    }
+
+    // Each commits must have a unique and properly named HAS_TREE edge.
+    for (const rawNode of this._graph.nodes({prefix: GN._Prefix.commit})) {
+      const treeNeighbors = Array.from(
+        this._graph.neighbors(rawNode, {
+          direction: Direction.OUT,
+          nodePrefix: NodeAddress.empty,
+          edgePrefix: GE._Prefix.hasTree,
+        })
+      );
+      if (treeNeighbors.length !== 1) {
+        throw new Error(
+          "invariant violation: commit should have 1 tree, " +
+            `but has ${treeNeighbors.length}: ${NodeAddress.toString(rawNode)}`
+        );
+      }
+      const rawEdge = treeNeighbors[0].edge;
+      const edge: GE.HasTreeAddress = (GE.fromRaw(
+        (((rawEdge.address: EdgeAddressT): any): GE.RawAddress)
+      ): any);
+      const node: GN.CommitAddress = ((GN.fromRaw(
+        (((rawNode: NodeAddressT): any): GN.RawAddress)
+      ): GN.StructuredAddress): any);
+      if (node.hash !== edge.commit.hash) {
+        throw new Error(
+          `invariant violation: bad HAS_TREE edge: ${edgeToString(rawEdge)}`
+        );
+      }
+    }
+
+    // All HAS_PARENT edges must map between between the correct commits.
+    for (const edge of this._graph.edges({
+      addressPrefix: GE._Prefix.hasParent,
+      srcPrefix: NodeAddress.empty,
+      dstPrefix: NodeAddress.empty,
+    })) {
+      const src: GN.CommitAddress = ((GN.fromRaw(
+        (((edge.src: NodeAddressT): any): GN.RawAddress)
+      ): GN.StructuredAddress): any);
+      const dst: GN.CommitAddress = ((GN.fromRaw(
+        (((edge.dst: NodeAddressT): any): GN.RawAddress)
+      ): GN.StructuredAddress): any);
+      const expectedEdge = GE.createEdge.hasParent(src, dst);
+      if (edge.address !== expectedEdge.address) {
+        throw new Error(
+          `invariant violation: bad HAS_PARENT edge: ${edgeToString(edge)}`
+        );
+      }
+    }
+
+    // Each tree entry must have a unique and properly named INCLUDES edge.
+    for (const rawNode of this._graph.nodes({prefix: GN._Prefix.treeEntry})) {
+      const treeNeighbors = Array.from(
+        this._graph.neighbors(rawNode, {
+          direction: Direction.IN,
+          nodePrefix: NodeAddress.empty,
+          edgePrefix: GE._Prefix.includes,
+        })
+      );
+      if (treeNeighbors.length !== 1) {
+        throw new Error(
+          "invariant violation: tree entry should have 1 inclusion, " +
+            `but has ${treeNeighbors.length}: ${NodeAddress.toString(rawNode)}`
+        );
+      }
+      const edge = treeNeighbors[0].edge;
+      const tree: GN.TreeAddress = ((GN.fromRaw(
+        (((edge.src: NodeAddressT): any): GN.RawAddress)
+      ): GN.StructuredAddress): any);
+      const treeEntry: GN.TreeEntryAddress = ((GN.fromRaw(
+        (((edge.dst: NodeAddressT): any): GN.RawAddress)
+      ): GN.StructuredAddress): any);
+      const expectedEdge = GE.createEdge.includes(tree, treeEntry);
+      if (edge.address !== expectedEdge.address) {
+        throw new Error(
+          `invariant violation: bad INCLUDES edge: ${edgeToString(edge)}`
+        );
+      }
+    }
+
+    // All BECOMES edges must map between between the correct tree entries.
+    for (const edge of this._graph.edges({
+      addressPrefix: GE._Prefix.becomes,
+      srcPrefix: NodeAddress.empty,
+      dstPrefix: NodeAddress.empty,
+    })) {
+      const src: GN.TreeEntryAddress = ((GN.fromRaw(
+        (((edge.src: NodeAddressT): any): GN.RawAddress)
+      ): GN.StructuredAddress): any);
+      const dst: GN.TreeEntryAddress = ((GN.fromRaw(
+        (((edge.dst: NodeAddressT): any): GN.RawAddress)
+      ): GN.StructuredAddress): any);
+      const expectedEdge = GE.createEdge.becomes(src, dst);
+      if (edge.address !== expectedEdge.address) {
+        throw new Error(
+          `invariant violation: bad BECOMES edge: ${edgeToString(edge)}`
+        );
+      }
+    }
+
+    // All HAS_CONTENTS edges must be properly named.
+    for (const edge of this._graph.edges({
+      addressPrefix: GE._Prefix.hasContents,
+      srcPrefix: NodeAddress.empty,
+      dstPrefix: NodeAddress.empty,
+    })) {
+      const src: GN.TreeEntryAddress = ((GN.fromRaw(
+        (((edge.src: NodeAddressT): any): GN.RawAddress)
+      ): GN.StructuredAddress): any);
+      const dst: GN.TreeEntryContentsAddress = ((GN.fromRaw(
+        (((edge.dst: NodeAddressT): any): GN.RawAddress)
+      ): GN.StructuredAddress): any);
+      const expectedEdge = GE.createEdge.hasContents(src, dst);
+      if (edge.address !== expectedEdge.address) {
+        throw new Error(
+          `invariant violation: bad HAS_CONTENTS edge: ${edgeToString(edge)}`
+        );
+      }
+    }
+  }
+}

src/v3/plugins/git/graphView.test.js

@@ -0,0 +1,427 @@
+// @flow
+
+import cloneDeep from "lodash.clonedeep";
+
+import {EdgeAddress, Graph, NodeAddress, edgeToString} from "../../core/graph";
+import {createGraph} from "./createGraph";
+import {GraphView} from "./graphView";
+import type {Repository} from "./types";
+
+import * as GE from "./edges";
+import * as GN from "./nodes";
+
+const makeData = (): Repository => cloneDeep(require("./demoData/example-git"));
+const makeGraph = () => createGraph(makeData());
+const makeView = () => new GraphView(makeGraph());
+
+describe("plugins/git/graphView", () => {
+  const view = makeView();
+  function expectEqualMultisets(x: Iterable<mixed>, y: Iterable<mixed>) {
+    const ax = Array.from(x);
+    const ay = Array.from(y);
+    expect(ax).toEqual(expect.arrayContaining(ay));
+    expect(ay).toEqual(expect.arrayContaining(ax));
+  }
+
+  describe("GraphView", () => {
+    it("#graph returns the provided graph", () => {
+      const g1 = new Graph();
+      const g2 = makeGraph();
+      expect(new GraphView(g1).graph()).toBe(g1);
+      expect(new GraphView(g2).graph()).toBe(g2);
+    });
+
+    it("#commits yields all commits", () => {
+      const expectedHashes = Object.keys(makeData().commits);
+      const actualHashes = Array.from(view.commits()).map((a) => a.hash);
+      expectEqualMultisets(actualHashes, expectedHashes);
+    });
+
+    it("#tree yields the correct tree for each commit", () => {
+      const commits = makeData().commits;
+      for (const commitHash of Object.keys(commits)) {
+        const commit = commits[commitHash];
+        const node: GN.CommitAddress = {type: GN.COMMIT_TYPE, hash: commitHash};
+        expect(view.tree(node).hash).toEqual(commit.treeHash);
+      }
+    });
+
+    it("#parents yields the correct parents for each commit", () => {
+      const commits = makeData().commits;
+      expect(Object.keys(commits)).not.toEqual([]);
+      for (const commitHash of Object.keys(commits)) {
+        const commit = commits[commitHash];
+        const node: GN.CommitAddress = {type: GN.COMMIT_TYPE, hash: commitHash};
+        const expectedParents = commit.parentHashes.slice();
+        const actualParents = Array.from(view.parents(node)).map((a) => a.hash);
+        expectEqualMultisets(actualParents, expectedParents);
+      }
+    });
+
+    it("#entries yields the correct entries for each tree", () => {
+      const trees = makeData().trees;
+      expect(Object.keys(trees)).not.toEqual([]);
+      for (const treeHash of Object.keys(trees)) {
+        const tree = trees[treeHash];
+        const node: GN.TreeAddress = {type: GN.TREE_TYPE, hash: treeHash};
+        const actualEntries = Array.from(view.entries(node));
+        const expectedEntries = Object.keys(tree.entries).map((name) => ({
+          type: "TREE_ENTRY",
+          treeHash,
+          name,
+        }));
+        expectEqualMultisets(actualEntries, expectedEntries);
+      }
+    });
+
+    describe("#contents yields the correct contents", () => {
+      const entryByName = (name): GN.TreeEntryAddress => ({
+        type: GN.TREE_ENTRY_TYPE,
+        treeHash: "7be3ecfee5314ffa9b2d93fc4377792b2d6d70ed",
+        name,
+      });
+      it("for blobs", () => {
+        const actual = Array.from(view.contents(entryByName("science.txt")));
+        const expected: $ReadOnlyArray<GN.BlobAddress> = [
+          {
+            type: GN.BLOB_TYPE,
+            hash: "f1f2514ca6d7a6a1a0511957021b1995bf9ace1c",
+          },
+        ];
+        expect(actual).toEqual(expected);
+      });
+      it("for trees", () => {
+        const actual = Array.from(view.contents(entryByName("src")));
+        const expected: $ReadOnlyArray<GN.TreeAddress> = [
+          {
+            type: GN.TREE_TYPE,
+            hash: "78fc9c83023386854c6bfdc5761c0e58f68e226f",
+          },
+        ];
+        expect(actual).toEqual(expected);
+      });
+      it("for submodule commits", () => {
+        const actual = Array.from(
+          view.contents(entryByName("pygravitydefier"))
+        );
+        const expected: $ReadOnlyArray<GN.SubmoduleCommitAddress> = [
+          {
+            type: GN.SUBMODULE_COMMIT_TYPE,
+            submoduleUrl:
+              "https://github.com/sourcecred/example-git-submodule.git",
+            commitHash: "29ef158bc982733e2ba429fcf73e2f7562244188",
+          },
+        ];
+        expect(actual).toEqual(expected);
+      });
+    });
+
+    it("#evolvesTo yields the correct entries", () => {
+      const v0: GN.TreeEntryAddress = {
+        type: GN.TREE_ENTRY_TYPE,
+        treeHash: "569e1d383759903134df75230d63c0090196d4cb",
+        name: "pygravitydefier",
+      };
+      const v1: GN.TreeEntryAddress = {
+        type: GN.TREE_ENTRY_TYPE,
+        treeHash: "819fc546cea489476ce8dc90785e9ba7753d0a8f",
+        name: "pygravitydefier",
+      };
+      expect(Array.from(view.evolvesTo(v0))).toEqual([v1]);
+    });
+
+    it("#evolvesFrom yields the correct entries", () => {
+      const v0: GN.TreeEntryAddress = {
+        type: GN.TREE_ENTRY_TYPE,
+        treeHash: "569e1d383759903134df75230d63c0090196d4cb",
+        name: "pygravitydefier",
+      };
+      const v1: GN.TreeEntryAddress = {
+        type: GN.TREE_ENTRY_TYPE,
+        treeHash: "819fc546cea489476ce8dc90785e9ba7753d0a8f",
+        name: "pygravitydefier",
+      };
+      expect(Array.from(view.evolvesFrom(v1))).toEqual([v0]);
+    });
+
+    describe("invariants", () => {
+      it("check for malformed nodes", () => {
+        const node = GN._gitAddress("wat");
+        const g = new Graph().addNode(node);
+        const expected = "Bad address: " + NodeAddress.toString(node);
+        expect(() => new GraphView(g)).toThrow(expected);
+      });
+      it("check for malformed edges", () => {
+        const c1: GN.CommitAddress = {type: GN.COMMIT_TYPE, hash: "c1"};
+        const c2: GN.CommitAddress = {type: GN.COMMIT_TYPE, hash: "c2"};
+        const edge = {
+          address: EdgeAddress.append(GE._Prefix.base, "wat"),
+          src: GN.toRaw(c1),
+          dst: GN.toRaw(c2),
+        };
+        const g = new Graph()
+          .addNode(GN.toRaw(c1))
+          .addNode(GN.toRaw(c2))
+          .addEdge(edge);
+        const expected = "Bad address: " + EdgeAddress.toString(edge.address);
+        expect(() => new GraphView(g)).toThrow(expected);
+      });
+
+      describe("check HAS_TREE edges", () => {
+        const commit: GN.CommitAddress = {type: GN.COMMIT_TYPE, hash: "c1"};
+        const otherCommit: GN.CommitAddress = {
+          type: GN.COMMIT_TYPE,
+          hash: "c2",
+        };
+        const tree: GN.TreeAddress = {type: GN.TREE_TYPE, hash: "t1"};
+        const otherTree: GN.TreeAddress = {type: GN.TREE_TYPE, hash: "t2"};
+        const edge = GE.createEdge.hasTree(commit, tree);
+        const otherEdge = GE.createEdge.hasTree(otherCommit, otherTree);
+        const foreignNode = NodeAddress.fromParts(["who", "are", "you"]);
+        const baseGraph = () =>
+          new Graph()
+            .addNode(foreignNode)
+            .addNode(GN.toRaw(commit))
+            .addNode(GN.toRaw(tree))
+            .addNode(GN.toRaw(otherTree));
+        it("for proper src", () => {
+          const badEdge = {...edge, src: foreignNode};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad hom: " + edgeToString(badEdge)
+          );
+        });
+        it("for proper dst", () => {
+          const badEdge = {...edge, dst: foreignNode};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad hom: " + edgeToString(badEdge)
+          );
+        });
+        it("for existence", () => {
+          const g = baseGraph();
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: commit should have 1 tree, but has 0: " +
+              NodeAddress.toString(GN.toRaw(commit))
+          );
+        });
+        it("for correctness", () => {
+          const badEdge = {...otherEdge, src: edge.src};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad HAS_TREE edge: " + edgeToString(badEdge)
+          );
+        });
+      });
+
+      describe("check HAS_PARENT edges", () => {
+        const c1: GN.CommitAddress = {type: GN.COMMIT_TYPE, hash: "c1"};
+        const c2: GN.CommitAddress = {type: GN.COMMIT_TYPE, hash: "c2"};
+        const c3: GN.CommitAddress = {type: GN.COMMIT_TYPE, hash: "c3"};
+        const e2 = GE.createEdge.hasParent(c1, c2);
+        const e3 = GE.createEdge.hasParent(c1, c3);
+        const tree: GN.TreeAddress = {type: GN.TREE_TYPE, hash: "t1"};
+        const foreignNode = NodeAddress.fromParts(["who", "are", "you"]);
+        const baseGraph = () =>
+          new Graph()
+            .addNode(foreignNode)
+            .addNode(GN.toRaw(c1))
+            .addNode(GN.toRaw(c2))
+            .addNode(GN.toRaw(c3))
+            .addNode(GN.toRaw(tree))
+            .addEdge(GE.createEdge.hasTree(c1, tree))
+            .addEdge(GE.createEdge.hasTree(c2, tree))
+            .addEdge(GE.createEdge.hasTree(c3, tree));
+        it("for proper src", () => {
+          const badEdge = {...e2, src: foreignNode};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad hom: " + edgeToString(badEdge)
+          );
+        });
+        it("for proper dst", () => {
+          const badEdge = {...e2, dst: foreignNode};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad hom: " + edgeToString(badEdge)
+          );
+        });
+        it("for correctness", () => {
+          const badEdge = {...e2, src: GN.toRaw(c2), dst: GN.toRaw(c3)};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad HAS_PARENT edge: " + edgeToString(badEdge)
+          );
+        });
+        it("allowing multiple parents", () => {
+          const g = baseGraph()
+            .addEdge(e2)
+            .addEdge(e3);
+          expect(() => new GraphView(g)).not.toThrow();
+        });
+      });
+
+      describe("check INCLUDES edges", () => {
+        const tree: GN.TreeAddress = {type: GN.TREE_TYPE, hash: "t1"};
+        const entry: GN.TreeEntryAddress = {
+          type: GN.TREE_ENTRY_TYPE,
+          treeHash: tree.hash,
+          name: "tree_entry.txt",
+        };
+        const anotherEntry: GN.TreeEntryAddress = {
+          type: GN.TREE_ENTRY_TYPE,
+          treeHash: tree.hash,
+          name: "wat.txt",
+        };
+        const foreignNode = NodeAddress.fromParts(["who", "are", "you"]);
+        const edge = GE.createEdge.includes(tree, entry);
+        const baseGraph = () =>
+          new Graph()
+            .addNode(foreignNode)
+            .addNode(GN.toRaw(tree))
+            .addNode(GN.toRaw(entry));
+        it("for proper src", () => {
+          const badEdge = {...edge, src: foreignNode};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad hom: " + edgeToString(badEdge)
+          );
+        });
+        it("for proper dst", () => {
+          const badEdge = {...edge, dst: foreignNode};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad hom: " + edgeToString(badEdge)
+          );
+        });
+        it("for existence", () => {
+          const g = baseGraph();
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: " +
+              "tree entry should have 1 inclusion, but has 0: " +
+              NodeAddress.toString(GN.toRaw(entry))
+          );
+        });
+        it("for correctness", () => {
+          const badEdge = {
+            ...edge,
+            address: GE.createEdge.includes(tree, anotherEntry).address,
+          };
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad INCLUDES edge: " + edgeToString(badEdge)
+          );
+        });
+      });
+
+      describe("check BECOMES edges", () => {
+        const t1: GN.TreeAddress = {type: GN.TREE_TYPE, hash: "t1"};
+        const t2: GN.TreeAddress = {type: GN.TREE_TYPE, hash: "t1"};
+        const te1: GN.TreeEntryAddress = {
+          type: GN.TREE_ENTRY_TYPE,
+          treeHash: "t1",
+          name: "foo",
+        };
+        const te2: GN.TreeEntryAddress = {
+          type: GN.TREE_ENTRY_TYPE,
+          treeHash: "t2",
+          name: "foo",
+        };
+        const te3: GN.TreeEntryAddress = {
+          type: GN.TREE_ENTRY_TYPE,
+          treeHash: "t2",
+          name: "bar",
+        };
+        const e2 = GE.createEdge.becomes(te1, te2);
+        const e3 = GE.createEdge.becomes(te1, te3);
+        const foreignNode = NodeAddress.fromParts(["who", "are", "you"]);
+        const baseGraph = () =>
+          new Graph()
+            .addNode(foreignNode)
+            .addNode(GN.toRaw(t1))
+            .addNode(GN.toRaw(t2))
+            .addNode(GN.toRaw(te1))
+            .addNode(GN.toRaw(te2))
+            .addNode(GN.toRaw(te3))
+            .addEdge(GE.createEdge.includes(t1, te1))
+            .addEdge(GE.createEdge.includes(t2, te2))
+            .addEdge(GE.createEdge.includes(t2, te3));
+        it("for proper src", () => {
+          const badEdge = {...e2, src: foreignNode};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad hom: " + edgeToString(badEdge)
+          );
+        });
+        it("for proper dst", () => {
+          const badEdge = {...e2, dst: foreignNode};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad hom: " + edgeToString(badEdge)
+          );
+        });
+        it("for correctness", () => {
+          const badEdge = {...e2, src: GN.toRaw(te2), dst: GN.toRaw(te3)};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad BECOMES edge: " + edgeToString(badEdge)
+          );
+        });
+        it("allowing multiple edges from a single source", () => {
+          const g = baseGraph()
+            .addEdge(e2)
+            .addEdge(e3);
+          expect(() => new GraphView(g)).not.toThrow();
+        });
+      });
+
+      describe("checks HAS_CONTENTS edges", () => {
+        const tree: GN.TreeAddress = {type: GN.TREE_TYPE, hash: "ceda12"};
+        const te1: GN.TreeEntryAddress = {
+          type: GN.TREE_ENTRY_TYPE,
+          treeHash: "ceda12",
+          name: "foo",
+        };
+        const te2: GN.TreeEntryAddress = {
+          type: GN.TREE_ENTRY_TYPE,
+          treeHash: "ceda12",
+          name: "bar",
+        };
+        const blob: GN.BlobAddress = {type: GN.BLOB_TYPE, hash: "fish"};
+        const e1 = GE.createEdge.hasContents(te1, blob);
+        const foreignNode = NodeAddress.fromParts(["who", "are", "you"]);
+        const baseGraph = () =>
+          new Graph()
+            .addNode(foreignNode)
+            .addNode(GN.toRaw(tree))
+            .addNode(GN.toRaw(te1))
+            .addNode(GN.toRaw(te2))
+            .addNode(GN.toRaw(blob))
+            .addEdge(GE.createEdge.includes(tree, te1))
+            .addEdge(GE.createEdge.includes(tree, te2));
+        it("for proper src", () => {
+          const badEdge = {...e1, src: foreignNode};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad hom: " + edgeToString(badEdge)
+          );
+        });
+        it("for proper dst", () => {
+          const badEdge = {...e1, dst: foreignNode};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad hom: " + edgeToString(badEdge)
+          );
+        });
+        it("for correctness", () => {
+          const badEdge = {...e1, src: GN.toRaw(te2)};
+          const g = baseGraph().addEdge(badEdge);
+          expect(() => new GraphView(g)).toThrow(
+            "invariant violation: bad HAS_CONTENTS edge: " +
+              edgeToString(badEdge)
+          );
+        });
+      });
+    });
+  });
+});