From fc5c9ea5896ede3d8e3042b54fec426372f2e7f6 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dandelion=20Man=C3=A9?= Date: Thu, 30 Aug 2018 15:25:42 -0700 Subject: [PATCH] Create canonical demoAdapters for testing (#735) PluginAdapters and Node/Edge types are increasingly fundamental to the cred explorer. Prior to this commit, we had no canonical demo adapters/types, and we would create ad-hoc and messy adapters whenever we needed them. This creates unnecessary repetition and lowers test quality. This commit creates a canonical demo adapter (loosely themed based on the wonderful game [Factorio]) and refactors most existing test cases to use the demo adapters. In particular, the horrible mess of pagerankTable adapters has been removed. [Factorio]: https://www.factorio.com/ I left `aggregate.test.js` untouched because I would have needed to materially re-write the tests to port them over. I added a comment so that if we ever do re-write those tests, we'll use the new demo adapters. Test plan: `yarn test` passes. --- src/app/adapters/adapterSet.test.js | 109 +++----------- src/app/adapters/demoAdapters.js | 129 ++++++++++++++++ .../pagerankTable/Aggregation.test.js | 10 +- .../pagerankTable/Connection.test.js | 31 ++-- .../credExplorer/pagerankTable/Node.test.js | 15 +- .../credExplorer/pagerankTable/Table.test.js | 7 +- .../__snapshots__/Table.test.js.snap | 38 +---- .../pagerankTable/aggregate.test.js | 3 + .../pagerankTable/sharedTestUtils.js | 142 +----------------- 9 files changed, 196 insertions(+), 288 deletions(-) create mode 100644 src/app/adapters/demoAdapters.js diff --git a/src/app/adapters/adapterSet.test.js b/src/app/adapters/adapterSet.test.js index 92e9cdf..cf0a213 100644 --- a/src/app/adapters/adapterSet.test.js +++ b/src/app/adapters/adapterSet.test.js @@ -1,91 +1,22 @@ // @flow -import { - NodeAddress, - EdgeAddress, - type NodeAddressT, - Graph, -} from "../../core/graph"; -import type {DynamicPluginAdapter} from "./pluginAdapter"; +import {NodeAddress, EdgeAddress, Graph} from "../../core/graph"; +import {FactorioStaticAdapter} from "./demoAdapters"; import {StaticAdapterSet} from "./adapterSet"; import {FallbackStaticAdapter, FALLBACK_NAME} from "./fallbackAdapter"; import {Assets} from "../assets"; -import {makeRepo, type Repo} from "../../core/repo"; +import {makeRepo} from "../../core/repo"; describe("app/adapters/adapterSet", () => { - class TestStaticPluginAdapter { - loadingMock: Function; - constructor() { - this.loadingMock = jest.fn(); - } - name() { - return "other plugin"; - } - nodePrefix() { - return NodeAddress.fromParts(["other"]); - } - edgePrefix() { - return EdgeAddress.fromParts(["other"]); - } - nodeTypes() { - return [ - { - name: "other1", - pluralName: "others1", - defaultWeight: 0, - prefix: NodeAddress.fromParts(["other", "1"]), - }, - { - name: "other2", - pluralName: "others2", - defaultWeight: 0, - prefix: NodeAddress.fromParts(["other", "2"]), - }, - ]; - } - edgeTypes() { - return [ - { - forwardName: "others_1", - backwardName: "othered_by_1", - prefix: EdgeAddress.fromParts(["other", "1"]), - }, - { - forwardName: "others_2", - backwardName: "othered_by_2", - prefix: EdgeAddress.fromParts(["other", "2"]), - }, - ]; - } - - load(assets: Assets, repo: Repo) { - return this.loadingMock(assets, repo).then( - () => new TestDynamicPluginAdapter() - ); - } - } - - class TestDynamicPluginAdapter implements DynamicPluginAdapter { - graph() { - return new Graph().addNode(NodeAddress.fromParts(["other1", "example"])); - } - nodeDescription(x: NodeAddressT) { - return `Node from the test plugin: ${NodeAddress.toString(x)}`; - } - static() { - return new TestStaticPluginAdapter(); - } - } - describe("StaticAdapterSet", () => { function example() { - const x = new TestStaticPluginAdapter(); + const x = new FactorioStaticAdapter(); const fallback = new FallbackStaticAdapter(); const sas = new StaticAdapterSet([x]); return {x, fallback, sas}; } it("errors if two plugins have the same name", () => { - const x = new TestStaticPluginAdapter(); + const x = new FactorioStaticAdapter(); const shouldError = () => new StaticAdapterSet([x, x]); expect(shouldError).toThrowError("Multiple plugins with name"); }); @@ -100,24 +31,30 @@ describe("app/adapters/adapterSet", () => { it("aggregates NodeTypes across plugins", () => { const {sas} = example(); const nodeTypes = sas.nodeTypes(); - expect(nodeTypes).toHaveLength(3); + const expectedNumNodeTypes = + new FactorioStaticAdapter().nodeTypes().length + + new FallbackStaticAdapter().nodeTypes().length; + expect(nodeTypes).toHaveLength(expectedNumNodeTypes); }); it("aggregates EdgeTypes across plugins", () => { const {sas} = example(); const edgeTypes = sas.edgeTypes(); - expect(edgeTypes).toHaveLength(3); + const expectedNumEdgeTypes = + new FactorioStaticAdapter().edgeTypes().length + + new FallbackStaticAdapter().edgeTypes().length; + expect(edgeTypes).toHaveLength(expectedNumEdgeTypes); }); it("finds adapter matching a node", () => { const {x, sas} = example(); const matching = sas.adapterMatchingNode( - NodeAddress.fromParts(["other", "foo"]) + NodeAddress.fromParts(["factorio", "inserter"]) ); expect(matching.name()).toBe(x.name()); }); it("finds adapter matching an edge", () => { const {x, sas} = example(); const matching = sas.adapterMatchingEdge( - EdgeAddress.fromParts(["other", "foo"]) + EdgeAddress.fromParts(["factorio", "assembles"]) ); expect(matching.name()).toBe(x.name()); }); @@ -134,16 +71,16 @@ describe("app/adapters/adapterSet", () => { it("finds type matching a node", () => { const {sas} = example(); const type = sas.typeMatchingNode( - NodeAddress.fromParts(["other", "1", "foo"]) + NodeAddress.fromParts(["factorio", "inserter", "1", "foo"]) ); - expect(type.name).toBe("other1"); + expect(type.name).toBe("inserter"); }); it("finds type matching an edge", () => { const {sas} = example(); const type = sas.typeMatchingEdge( - EdgeAddress.fromParts(["other", "1", "foo"]) + EdgeAddress.fromParts(["factorio", "assembles", "other", "1", "foo"]) ); - expect(type.forwardName).toBe("others_1"); + expect(type.forwardName).toBe("assembles"); }); it("finds fallback type for unregistered node", () => { const {sas} = example(); @@ -161,6 +98,7 @@ describe("app/adapters/adapterSet", () => { }); it("loads a dynamicAdapterSet", async () => { const {x, sas} = example(); + x.loadingMock = jest.fn(); x.loadingMock.mockResolvedValue(); expect(x.loadingMock).toHaveBeenCalledTimes(0); const assets = new Assets("/my/gateway/"); @@ -176,9 +114,8 @@ describe("app/adapters/adapterSet", () => { describe("DynamicAdapterSet", () => { async function example() { - const x = new TestStaticPluginAdapter(); + const x = new FactorioStaticAdapter(); const sas = new StaticAdapterSet([x]); - x.loadingMock.mockResolvedValue(); const das = await sas.load( new Assets("/my/gateway/"), makeRepo("foo", "bar") @@ -203,14 +140,14 @@ describe("app/adapters/adapterSet", () => { it("finds adapter matching a node", async () => { const {x, das} = await example(); const matching = das.adapterMatchingNode( - NodeAddress.fromParts(["other", "foo"]) + NodeAddress.fromParts(["factorio", "inserter"]) ); expect(matching.static().name()).toBe(x.name()); }); it("finds adapter matching an edge", async () => { const {x, das} = await example(); const matching = das.adapterMatchingEdge( - EdgeAddress.fromParts(["other", "foo"]) + EdgeAddress.fromParts(["factorio", "assembles"]) ); expect(matching.static().name()).toBe(x.name()); }); diff --git a/src/app/adapters/demoAdapters.js b/src/app/adapters/demoAdapters.js new file mode 100644 index 0000000..c943847 --- /dev/null +++ b/src/app/adapters/demoAdapters.js @@ -0,0 +1,129 @@ +// @flow + +import {Assets} from "../assets"; +import { + Graph, + NodeAddress, + type NodeAddressT, + EdgeAddress, +} from "../../core/graph"; +import type { + StaticPluginAdapter, + DynamicPluginAdapter, + EdgeType, + NodeType, +} from "./pluginAdapter"; + +import {StaticAdapterSet} from "./adapterSet"; +import {makeRepo, type Repo} from "../../core/repo"; + +export const inserterNodeType: NodeType = Object.freeze({ + name: "inserter", + pluralName: "inserters", + prefix: NodeAddress.fromParts(["factorio", "inserter"]), + defaultWeight: 1, +}); + +export const machineNodeType: NodeType = Object.freeze({ + name: "machine", + pluralName: "machines", + prefix: NodeAddress.fromParts(["factorio", "machine"]), + defaultWeight: 2, +}); + +export const assemblesEdgeType: EdgeType = Object.freeze({ + forwardName: "assembles", + backwardName: "is assembled by", + prefix: EdgeAddress.fromParts(["factorio", "assembles"]), +}); + +export const transportsEdgeType: EdgeType = Object.freeze({ + forwardName: "transports", + backwardName: "is transported by", + prefix: EdgeAddress.fromParts(["factorio", "transports"]), +}); + +export class FactorioStaticAdapter implements StaticPluginAdapter { + loadingMock: Function; + name() { + return "Factorio demo adapter"; + } + nodePrefix() { + return NodeAddress.fromParts(["factorio"]); + } + nodeTypes() { + return [inserterNodeType, machineNodeType]; + } + edgePrefix() { + return EdgeAddress.fromParts(["factorio"]); + } + edgeTypes() { + return [assemblesEdgeType, transportsEdgeType]; + } + async load(assets: Assets, repo: Repo): Promise { + if (this.loadingMock) { + return this.loadingMock(assets, repo).then( + () => new FactorioDynamicAdapter() + ); + } + return Promise.resolve(new FactorioDynamicAdapter()); + } +} + +export const factorioNodes = Object.freeze({ + inserter1: NodeAddress.fromParts(["factorio", "inserter", "1"]), + machine1: NodeAddress.fromParts(["factorio", "machine", "1"]), + inserter2: NodeAddress.fromParts(["factorio", "inserter", "2"]), + machine2: NodeAddress.fromParts(["factorio", "machine", "2"]), +}); + +export const factorioEdges = Object.freeze({ + transports1: Object.freeze({ + src: factorioNodes.inserter1, + dst: factorioNodes.machine1, + address: EdgeAddress.fromParts(["factorio", "transports", "1"]), + }), + assembles1: Object.freeze({ + src: factorioNodes.machine1, + dst: factorioNodes.inserter2, + address: EdgeAddress.fromParts(["factorio", "assembles", "1"]), + }), + transports2: Object.freeze({ + src: factorioNodes.inserter2, + dst: factorioNodes.machine2, + address: EdgeAddress.fromParts(["factorio", "assembles", "2"]), + }), +}); +export function factorioGraph() { + return new Graph() + .addNode(factorioNodes.inserter1) + .addNode(factorioNodes.inserter2) + .addNode(factorioNodes.machine1) + .addNode(factorioNodes.machine2) + .addEdge(factorioEdges.transports1) + .addEdge(factorioEdges.transports2) + .addEdge(factorioEdges.assembles1); +} + +export class FactorioDynamicAdapter implements DynamicPluginAdapter { + graph() { + return factorioGraph(); + } + nodeDescription(x: NodeAddressT) { + return NodeAddress.toString(x); + } + static() { + return new FactorioStaticAdapter(); + } +} + +export function staticAdapterSet() { + return new StaticAdapterSet([new FactorioStaticAdapter()]); +} + +export async function dynamicAdapterSet() { + return await staticAdapterSet().load( + new Assets("/gateway/"), + makeRepo("foo", "bar") + ); +} diff --git a/src/app/credExplorer/pagerankTable/Aggregation.test.js b/src/app/credExplorer/pagerankTable/Aggregation.test.js index 329d289..ed4b93b 100644 --- a/src/app/credExplorer/pagerankTable/Aggregation.test.js +++ b/src/app/credExplorer/pagerankTable/Aggregation.test.js @@ -2,6 +2,7 @@ import React from "react"; import {shallow} from "enzyme"; + import * as NullUtil from "../../../util/null"; import {NodeAddress, EdgeAddress} from "../../../core/graph"; import type {NodeType, EdgeType} from "../../adapters/pluginAdapter"; @@ -15,6 +16,7 @@ import {Badge} from "./shared"; import {example} from "./sharedTestUtils"; import {aggregateFlat, type FlatAggregation} from "./aggregate"; import {TableRow} from "./TableRow"; +import {factorioNodes} from "../../adapters/demoAdapters"; require("../../testUtil").configureEnzyme(); @@ -31,8 +33,8 @@ describe("app/credExplorer/pagerankTable/Aggregation", () => { }); describe("AggregationRowList", () => { it("instantiates AggregationRows for each aggregation", async () => { - const {adapters, pnd, nodes} = await example(); - const node = nodes.bar1; + const {adapters, pnd} = await example(); + const node = factorioNodes.inserter1; const depth = 20; const maxEntriesPerList = 50; const sharedProps = {adapters, pnd, maxEntriesPerList}; @@ -66,9 +68,9 @@ describe("app/credExplorer/pagerankTable/Aggregation", () => { describe("AggregationRow", () => { async function setup() { - const {pnd, adapters, nodes} = await example(); + const {pnd, adapters} = await example(); const sharedProps = {adapters, pnd, maxEntriesPerList: 123}; - const target = nodes.bar1; + const target = factorioNodes.inserter1; const {scoredConnections} = NullUtil.get(pnd.get(target)); const aggregations = aggregateFlat( scoredConnections, diff --git a/src/app/credExplorer/pagerankTable/Connection.test.js b/src/app/credExplorer/pagerankTable/Connection.test.js index 5d50570..699eceb 100644 --- a/src/app/credExplorer/pagerankTable/Connection.test.js +++ b/src/app/credExplorer/pagerankTable/Connection.test.js @@ -9,6 +9,7 @@ import {ConnectionRowList, ConnectionRow, ConnectionView} from "./Connection"; import {example} from "./sharedTestUtils"; import {TableRow} from "./TableRow"; import {NodeRow} from "./Node"; +import {factorioNodes} from "../../adapters/demoAdapters"; require("../../testUtil").configureEnzyme(); @@ -26,9 +27,9 @@ describe("app/credExplorer/pagerankTable/Connection", () => { describe("ConnectionRowList", () => { async function setup(maxEntriesPerList: number = 100000) { - const {adapters, pnd, nodes} = await example(); + const {adapters, pnd} = await example(); const depth = 2; - const node = nodes.bar1; + const node = factorioNodes.inserter1; const sharedProps = {adapters, pnd, maxEntriesPerList}; const connections = NullUtil.get(sharedProps.pnd.get(node)) .scoredConnections; @@ -76,15 +77,11 @@ describe("app/credExplorer/pagerankTable/Connection", () => { describe("ConnectionRow", () => { async function setup() { - const {pnd, adapters, nodes} = await example(); + const {pnd, adapters} = await example(); const sharedProps = {adapters, pnd, maxEntriesPerList: 123}; - const target = nodes.bar1; + const target = factorioNodes.inserter1; const {scoredConnections} = NullUtil.get(pnd.get(target)); - const alphaConnections = scoredConnections.filter( - (sc) => sc.source === nodes.fooAlpha - ); - expect(alphaConnections).toHaveLength(1); - const scoredConnection = alphaConnections[0]; + const scoredConnection = scoredConnections[0]; const depth = 2; const component = ( { }); describe("ConnectionView", () => { async function setup() { - const {pnd, adapters, nodes} = await example(); - const {scoredConnections} = NullUtil.get(pnd.get(nodes.bar1)); + const {pnd, adapters} = await example(); + const {scoredConnections} = NullUtil.get(pnd.get(factorioNodes.machine1)); const connections = scoredConnections.map((sc) => sc.connection); function connectionByType(t) { return NullUtil.get( @@ -208,8 +205,10 @@ describe("app/credExplorer/pagerankTable/Connection", () => { const outerSpan = view.find("span").first(); const badge = outerSpan.find("Badge"); const description = outerSpan.children().find("span"); - expect(badge.children().text()).toEqual("is barred by"); - expect(description.text()).toEqual('bar: NodeAddress["bar","a","1"]'); + expect(badge.children().text()).toEqual("is transported by"); + expect(description.text()).toEqual( + 'NodeAddress["factorio","inserter","1"]' + ); }); it("for outward connections, renders a `Badge` and description", async () => { const {cvForConnection, outConnection} = await setup(); @@ -217,8 +216,10 @@ describe("app/credExplorer/pagerankTable/Connection", () => { const outerSpan = view.find("span").first(); const badge = outerSpan.find("Badge"); const description = outerSpan.children().find("span"); - expect(badge.children().text()).toEqual("bars"); - expect(description.text()).toEqual("xox node!"); + expect(badge.children().text()).toEqual("assembles"); + expect(description.text()).toEqual( + 'NodeAddress["factorio","inserter","2"]' + ); }); it("for synthetic connections, renders only a `Badge`", async () => { const {cvForConnection, syntheticConnection} = await setup(); diff --git a/src/app/credExplorer/pagerankTable/Node.test.js b/src/app/credExplorer/pagerankTable/Node.test.js index 1518af9..4b529e4 100644 --- a/src/app/credExplorer/pagerankTable/Node.test.js +++ b/src/app/credExplorer/pagerankTable/Node.test.js @@ -7,11 +7,12 @@ import * as NullUtil from "../../../util/null"; import {TableRow} from "./TableRow"; import {AggregationRowList} from "./Aggregation"; -import {type NodeAddressT, NodeAddress} from "../../../core/graph"; +import type {NodeAddressT} from "../../../core/graph"; import {nodeDescription} from "./shared"; import {example} from "./sharedTestUtils"; import {NodeRowList, NodeRow, type NodeRowProps} from "./Node"; +import {factorioNodes} from "../../adapters/demoAdapters"; require("../../testUtil").configureEnzyme(); @@ -32,14 +33,8 @@ describe("app/credExplorer/pagerankTable/Node", () => { } async function setup(maxEntriesPerList: number = 100000) { const {adapters, pnd} = await example(); - const nodes = sortedByScore(Array.from(pnd.keys()), pnd) - .reverse() // ascending order! - .filter((x) => - NodeAddress.hasPrefix(x, NodeAddress.fromParts(["foo"])) - ); + const nodes = Array.from(pnd.keys()); expect(nodes).not.toHaveLength(0); - expect(nodes).not.toHaveLength(1); - expect(nodes).not.toHaveLength(pnd.size); const sharedProps = {adapters, pnd, maxEntriesPerList}; const component = ; const element = shallow(component); @@ -86,9 +81,9 @@ describe("app/credExplorer/pagerankTable/Node", () => { describe("NodeRow", () => { async function setup(props: $Shape<{...NodeRowProps}>) { props = props || {}; - const {pnd, adapters, nodes} = await example(); + const {pnd, adapters} = await example(); const sharedProps = {adapters, pnd, maxEntriesPerList: 123}; - const node = nodes.bar1; + const node = factorioNodes.inserter1; const component = shallow( { }); it("with the ability to filter nodes passed to NodeRowList", async () => { const {element, options} = await setup(); - const option1 = options.at(1); - const value = option1.prop("value"); + const option = options.at(2); + + const value = option.prop("value"); expect(value).not.toEqual(NodeAddress.empty); const previousNodes = element.find("NodeRowList").prop("nodes"); expect( @@ -89,7 +90,7 @@ describe("app/credExplorer/pagerankTable/Table", () => { expect(element.state().topLevelFilter).toEqual(NodeAddress.empty); }); it("filter defaults to defaultNodeFilter if available", async () => { - const filter = NodeAddress.fromParts(["foo", "a"]); + const filter = NodeAddress.fromParts(["factorio", "inserter"]); const {element} = await setup(filter); expect(element.state().topLevelFilter).toEqual(filter); }); diff --git a/src/app/credExplorer/pagerankTable/__snapshots__/Table.test.js.snap b/src/app/credExplorer/pagerankTable/__snapshots__/Table.test.js.snap index f8df367..a9781a8 100644 --- a/src/app/credExplorer/pagerankTable/__snapshots__/Table.test.js.snap +++ b/src/app/credExplorer/pagerankTable/__snapshots__/Table.test.js.snap @@ -13,44 +13,18 @@ Array [ "style": Object { "fontWeight": "bold", }, - "text": "bar", - "valueString": "NodeAddress[\\"bar\\"]", + "text": "Factorio demo adapter", + "valueString": "NodeAddress[\\"factorio\\"]", }, Object { "style": undefined, - "text": " alpha", - "valueString": "NodeAddress[\\"bar\\",\\"a\\"]", - }, - Object { - "style": Object { - "fontWeight": "bold", - }, - "text": "foo", - "valueString": "NodeAddress[\\"foo\\"]", + "text": " inserter", + "valueString": "NodeAddress[\\"factorio\\",\\"inserter\\"]", }, Object { "style": undefined, - "text": " alpha", - "valueString": "NodeAddress[\\"foo\\",\\"a\\"]", - }, - Object { - "style": undefined, - "text": " beta", - "valueString": "NodeAddress[\\"foo\\",\\"b\\"]", - }, - Object { - "style": Object { - "fontWeight": "bold", - }, - "text": "unused", - "valueString": "NodeAddress[\\"unused\\"]", - }, - Object { - "style": Object { - "fontWeight": "bold", - }, - "text": "xox", - "valueString": "NodeAddress[\\"xox\\"]", + "text": " machine", + "valueString": "NodeAddress[\\"factorio\\",\\"machine\\"]", }, ] `; diff --git a/src/app/credExplorer/pagerankTable/aggregate.test.js b/src/app/credExplorer/pagerankTable/aggregate.test.js index 543c2a6..23be9ab 100644 --- a/src/app/credExplorer/pagerankTable/aggregate.test.js +++ b/src/app/credExplorer/pagerankTable/aggregate.test.js @@ -11,6 +11,9 @@ import { } from "./aggregate"; describe("app/credExplorer/aggregate", () => { + // TODO: If making major modifications to these tests, consider switching + // from the hand-maintained connections and types, and instead use the demo + // adadpters from app/adapters/demoAdapters function example() { const nodes = { root: NodeAddress.fromParts(["root"]), diff --git a/src/app/credExplorer/pagerankTable/sharedTestUtils.js b/src/app/credExplorer/pagerankTable/sharedTestUtils.js index f57d07a..ed5995f 100644 --- a/src/app/credExplorer/pagerankTable/sharedTestUtils.js +++ b/src/app/credExplorer/pagerankTable/sharedTestUtils.js @@ -1,151 +1,17 @@ // @flow -import {Graph, NodeAddress, EdgeAddress} from "../../../core/graph"; - -import {StaticAdapterSet, DynamicAdapterSet} from "../../adapters/adapterSet"; -import type {DynamicPluginAdapter} from "../../adapters/pluginAdapter"; +import {dynamicAdapterSet} from "../../adapters/demoAdapters"; import {pagerank} from "../../../core/attribution/pagerank"; export const COLUMNS = () => ["Description", "", "Cred"]; export async function example() { - const graph = new Graph(); - const nodes = { - fooAlpha: NodeAddress.fromParts(["foo", "a", "1"]), - fooBeta: NodeAddress.fromParts(["foo", "b", "2"]), - bar1: NodeAddress.fromParts(["bar", "a", "1"]), - bar2: NodeAddress.fromParts(["bar", "2"]), - xox: NodeAddress.fromParts(["xox"]), - empty: NodeAddress.empty, - }; - Object.values(nodes).forEach((n) => graph.addNode((n: any))); - - function addEdge(parts, src, dst) { - const edge = {address: EdgeAddress.fromParts(parts), src, dst}; - graph.addEdge(edge); - return edge; - } - - const edges = { - fooA: addEdge(["foo", "a"], nodes.fooAlpha, nodes.fooBeta), - fooB: addEdge(["foo", "b"], nodes.fooAlpha, nodes.bar1), - fooC: addEdge(["foo", "c"], nodes.fooAlpha, nodes.xox), - barD: addEdge(["bar", "d"], nodes.bar1, nodes.bar1), - barE: addEdge(["bar", "e"], nodes.bar1, nodes.xox), - barF: addEdge(["bar", "f"], nodes.bar1, nodes.xox), - }; - - const dynamicAdapters: DynamicPluginAdapter[] = [ - { - static: () => ({ - name: () => "foo", - nodePrefix: () => NodeAddress.fromParts(["foo"]), - edgePrefix: () => EdgeAddress.fromParts(["foo"]), - nodeTypes: () => [ - { - pluralName: "alphas", - name: "alpha", - prefix: NodeAddress.fromParts(["foo", "a"]), - defaultWeight: 1, - }, - { - pluralName: "betas", - name: "beta", - prefix: NodeAddress.fromParts(["foo", "b"]), - defaultWeight: 1, - }, - ], - edgeTypes: () => [ - { - prefix: EdgeAddress.fromParts(["foo"]), - forwardName: "foos", - backwardName: "is fooed by", - }, - ], - load: (_unused_repo) => { - throw new Error("unused"); - }, - }), - graph: () => { - throw new Error("unused"); - }, - nodeDescription: (x) => `foo: ${NodeAddress.toString(x)}`, - }, - { - static: () => ({ - name: () => "bar", - nodePrefix: () => NodeAddress.fromParts(["bar"]), - edgePrefix: () => EdgeAddress.fromParts(["bar"]), - nodeTypes: () => [ - { - name: "alpha", - pluralName: "alphas", - prefix: NodeAddress.fromParts(["bar", "a"]), - defaultWeight: 1, - }, - ], - edgeTypes: () => [ - { - prefix: EdgeAddress.fromParts(["bar"]), - forwardName: "bars", - backwardName: "is barred by", - }, - ], - load: (_unused_repo) => { - throw new Error("unused"); - }, - }), - graph: () => { - throw new Error("unused"); - }, - nodeDescription: (x) => `bar: ${NodeAddress.toString(x)}`, - }, - { - static: () => ({ - name: () => "xox", - nodePrefix: () => NodeAddress.fromParts(["xox"]), - edgePrefix: () => EdgeAddress.fromParts(["xox"]), - nodeTypes: () => [], - edgeTypes: () => [], - load: (_unused_repo) => { - throw new Error("unused"); - }, - }), - graph: () => { - throw new Error("unused"); - }, - nodeDescription: (_unused_arg) => `xox node!`, - }, - { - static: () => ({ - nodePrefix: () => NodeAddress.fromParts(["unused"]), - edgePrefix: () => EdgeAddress.fromParts(["unused"]), - nodeTypes: () => [], - edgeTypes: () => [], - name: () => "unused", - load: (_unused_repo) => { - throw new Error("unused"); - }, - }), - graph: () => { - throw new Error("unused"); - }, - nodeDescription: () => { - throw new Error("Unused"); - }, - }, - ]; - - const staticAdapters = dynamicAdapters.map((x) => x.static()); - const adapters = new DynamicAdapterSet( - new StaticAdapterSet(staticAdapters), - dynamicAdapters - ); - + const adapters = await dynamicAdapterSet(); + const graph = adapters.graph(); const pnd = await pagerank(graph, (_unused_Edge) => ({ toWeight: 1, froWeight: 1, })); - return {adapters, nodes, edges, graph, pnd}; + return {adapters, pnd}; }