@truedat/lm 4.42.2 → 4.42.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [4.42.4] 2022-04-19
+
+### Changed
+
+- [TD-4513] Limit related concepts graph depth
+
 ## [4.42.0] 2022-04-05
 
 ### Added

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@truedat/lm",
-  "version": "4.42.2",
+  "version": "4.42.5",
   "description": "Truedat Link Manager",
   "sideEffects": false,
   "jsnext:main": "src/index.js",
@@ -33,13 +33,12 @@
     "@testing-library/jest-dom": "^5.14.1",
     "@testing-library/react": "^12.0.0",
     "@testing-library/user-event": "^13.2.1",
-    "@truedat/test": "4.42.0",
+    "@truedat/test": "4.42.5",
     "babel-jest": "^27.0.6",
     "babel-plugin-dynamic-import-node": "^2.3.3",
     "babel-plugin-lodash": "^3.3.4",
     "babel-plugin-react-intl": "^5.1.18",
     "babel-plugin-transform-semantic-ui-react-imports": "^1.4.1",
-    "canvas": "^2.9.1",
     "enzyme": "^3.11.0",
     "enzyme-adapter-react-16": "^1.15.6",
     "enzyme-to-json": "^3.6.2",
@@ -84,12 +83,13 @@
     ]
   },
   "dependencies": {
-    "@truedat/core": "4.42.2",
+    "@truedat/core": "4.42.5",
     "path-to-regexp": "^1.7.0",
     "prop-types": "^15.7.2",
     "react-graph-vis": "1.0.5",
     "react-hook-form": "^6.15.8",
     "react-intl": "^5.20.10",
+    "react-rangeslider": "^2.2.0",
     "react-redux": "^7.2.4",
     "react-router-dom": "^5.2.0",
     "redux": "^4.1.1",
@@ -101,5 +101,5 @@
     "react-dom": ">= 16.8.6 < 17",
     "semantic-ui-react": ">= 0.88.2 < 2.1"
   },
-  "gitHead": "1ca6b75d5b0c80c8e2e931340d5efe4eeefb27de"
+  "gitHead": "77641b0e3a7555a6f6c4c0649ff7b6164292b4b0"
 }

package/src/components/RelationGraph.js

@@ -1,27 +1,14 @@
 import _ from "lodash/fp";
-import React, { useEffect, useState } from "react";
-import { connect } from "react-redux";
+import React, { useState } from "react";
 import { useIntl } from "react-intl";
 import PropTypes from "prop-types";
 import Graph from "react-graph-vis";
-import "../styles/relationGraph.less";
-import { dfsMaxDepth, dfs, getEdges } from "../services/relationGraphTraversal";
-import RelationGraphDepth from "./RelationGraphDepth";
 
-export const RelationGraph = ({
-  navigate,
-  currentId,
-  relationsGraph,
-  initialDepth,
-}) => {
+export const RelationGraph = ({ navigate, currentId, relationsGraph }) => {
   const { formatMessage } = useIntl();
   const [network, setNetwork] = useState({});
-  const [depth, setDepth] = useState(initialDepth || Infinity);
-  const [maxDepth, setMaxDepth] = useState();
-  const [limitedRelationsGraph, setLimitedRelationsGraph] = useState();
-  const [start, setStart] = useState();
 
-  const getVisNodes = _.flow(
+  const nodes = _.flow(
     _.get("nodes"),
     _.map(({ id, name: label }) => ({
       id,
@@ -44,9 +31,9 @@ export const RelationGraph = ({
             }
           : null,
     }))
-  );
+  )(relationsGraph);
 
-  const getVisEdges = _.flow(
+  const edges = _.flow(
     _.get("edges"),
     _.map(({ source_id: from, target_id: to, tags }) => ({
       from,
@@ -61,36 +48,7 @@ export const RelationGraph = ({
         _.join("\n")
       )(tags),
     }))
-  );
-
-  useEffect(() => {
-    if (!_.isEmpty(relationsGraph)) {
-      const start = _.flow(
-        _.getOr([], "nodes"),
-        _.find({ id: currentId })
-      )(relationsGraph);
-
-      const useEffectMaxDepth = dfsMaxDepth(relationsGraph, start, {}, 0);
-
-      setStart(start);
-      setMaxDepth(useEffectMaxDepth);
-      if (depth === Infinity) {
-        setDepth(useEffectMaxDepth);
-      }
-    }
-  }, [relationsGraph]);
-
-  useEffect(() => {
-    if (!_.isEmpty(relationsGraph) && !_.isEmpty(start) && depth !== Infinity) {
-      const nodes = dfs(relationsGraph, start, {}, depth);
-      depth < maxDepth
-        ? setLimitedRelationsGraph({
-            nodes,
-            edges: getEdges(relationsGraph, nodes),
-          })
-        : setLimitedRelationsGraph(relationsGraph);
-    }
-  }, [depth, start]);
+  )(relationsGraph);
 
   const options = {
     autoResize: true,
@@ -167,26 +125,14 @@ export const RelationGraph = ({
   };
   return (
     <>
-      {!_.isEmpty(limitedRelationsGraph?.nodes) && (
-        <>
-          <RelationGraphDepth
-            onClick={(_e) => setDepth(maxDepth)}
-            onChange={(event) => setDepth(parseInt(event.target.value))}
-            depth={depth}
-            maxDepth={maxDepth}
-          />
-
-          <Graph
-            graph={{
-              nodes: getVisNodes(limitedRelationsGraph),
-              edges: getVisEdges(limitedRelationsGraph),
-            }}
-            options={options}
-            events={events}
-            style={{ height: "640px" }}
-            getNetwork={setNetwork}
-          />
-        </>
+      {!_.isEmpty(relationsGraph) && (
+        <Graph
+          graph={{ nodes, edges }}
+          options={options}
+          events={events}
+          style={{ height: "640px" }}
+          getNetwork={setNetwork}
+        />
       )}
     </>
   );
@@ -196,15 +142,6 @@ RelationGraph.propTypes = {
   navigate: PropTypes.func,
   currentId: PropTypes.string,
   relationsGraph: PropTypes.object,
-  initialDepth: PropTypes.number,
 };
 
-export const mapStateToProps = ({
-  relationsGraph,
-  conceptGraphInitialDepth,
-}) => ({
-  initialDepth: conceptGraphInitialDepth,
-  relationsGraph,
-});
-
-export default connect(mapStateToProps)(RelationGraph);
+export default RelationGraph;

package/src/components/RelationGraphDepth.js

@@ -1,32 +1,30 @@
+import _ from "lodash/fp";
 import React from "react";
 import PropTypes from "prop-types";
-import { Button } from "semantic-ui-react";
+import { Segment } from "semantic-ui-react";
+import Slider from "react-rangeslider";
+import "react-rangeslider/lib/index.css";
 import { FormattedMessage } from "react-intl";
 
-export const RelationGraphDepth = ({ onClick, onChange, depth, maxDepth }) => {
-  return (
-    <div className="graph">
-      <label htmlFor="depth">
-        <FormattedMessage id="relationGraph.depth" /> [1-{maxDepth}]
-      </label>
-      <input
-        id="depth"
-        aria-label="depth"
-        type="number"
-        min="1"
-        max={maxDepth}
-        value={depth === Infinity ? 0 : depth}
+export const RelationGraphDepth = ({ onChange, depth, maxDepth }) => {
+  return _.isUndefined(maxDepth) ? null : (
+    <Segment className="graph-depth">
+      <FormattedMessage id="relationGraph.depth" />
+      <div>{depth}</div>
+      <Slider
+        value={depth}
+        orientation="vertical"
+        reverse={true}
         onChange={onChange}
-      ></input>
-      <Button disabled={depth === maxDepth} onClick={onClick}>
-        <FormattedMessage id="relationGraph.all" />
-      </Button>
-    </div>
+        min={1}
+        max={maxDepth}
+        tooltip={false}
+      />
+    </Segment>
   );
 };
 
 RelationGraphDepth.propTypes = {
-  onClick: PropTypes.func,
   onChange: PropTypes.func,
   depth: PropTypes.number,
   maxDepth: PropTypes.number,

package/src/components/index.js

@@ -12,6 +12,7 @@ import StructureLinks from "./StructureLinks";
 import StructureRelationForm from "./StructureRelationForm";
 import TagTypeSelector from "./TagTypeSelector";
 import RelationGraph from "./RelationGraph";
+import RelationGraphDepth from "./RelationGraphDepth";
 import RelationRoutes from "./RelationRoutes";
 import RelationTags from "./RelationTags";
 import RelationTagCards from "./RelationTagCards";
@@ -32,6 +33,7 @@ export {
   StructureRelationForm,
   TagTypeSelector,
   RelationGraph,
+  RelationGraphDepth,
   RelationRoutes,
   RelationTags,
   RelationTagCards,

package/src/selectors/__tests__/relationGraphTraversal.spec.js

@@ -0,0 +1,188 @@
+import _ from "lodash/fp";
+import { selectLimitedGraph } from "..";
+import { selectMaxDepth } from "../relationGraphTraversal";
+
+const nodes = [
+  {
+    id: "business_concept:92",
+    name: "My Awesome Concept",
+  },
+  {
+    id: "business_concept:5",
+    name: "New Concept 4",
+  },
+  {
+    id: "business_concept:18",
+    name: "Float Concept",
+  },
+];
+
+const edges = [
+  {
+    id: 1,
+    source_id: "business_concept:92",
+    target_id: "business_concept:5",
+    tags: [
+      {
+        id: 3,
+        value: {
+          target_type: "business_concept",
+          type: "bc_padre",
+        },
+      },
+    ],
+  },
+  {
+    id: 2,
+    source_id: "business_concept:5",
+    target_id: "business_concept:18",
+    tags: [
+      {
+        id: 3,
+        value: {
+          target_type: "business_concept",
+          type: "bc_padre",
+        },
+      },
+    ],
+  },
+  {
+    id: 3,
+    source_id: "business_concept:18",
+    target_id: "business_concept:5",
+    tags: [
+      {
+        id: 3,
+        value: {
+          target_type: "business_concept",
+          type: "bc_padre",
+        },
+      },
+    ],
+  },
+];
+
+const relationsGraph = {
+  nodes,
+  edges,
+};
+
+describe("selectors: relationGraphTraversal", () => {
+  const currentId = "business_concept:92";
+
+  it("gets Graph on non-empty relationsGraph", () => {
+    const limitedGraph = selectLimitedGraph({ relationsGraph }, currentId, 3);
+
+    expect(
+      _.isUndefined(
+        _.find({ id: nodes[0].id, name: nodes[0].name }, limitedGraph.nodes)
+      ) &&
+        _.isUndefined(
+          _.find({ id: nodes[1].id, name: nodes[1].name }, limitedGraph.nodes)
+        ) &&
+        _.isUndefined(
+          _.find({ id: nodes[2].id, name: nodes[2].name }, limitedGraph.nodes)
+        )
+    ).toBeFalsy();
+
+    expect(
+      _.isUndefined(
+        _.find(
+          {
+            source_id: edges[0].source_id,
+            target_id: edges[0].target_id,
+          },
+          limitedGraph.edges
+        )
+      ) &&
+        _.isUndefined(
+          _.find(
+            {
+              source_id: edges[1].source_id,
+              target_id: edges[1].target_id,
+            },
+            limitedGraph.edges
+          )
+        ) &&
+        _.isUndefined(
+          _.find(
+            {
+              source_id: edges[2].source_id,
+              target_id: edges[2].target_id,
+            },
+            limitedGraph.edges
+          )
+        )
+    ).toBeFalsy();
+  });
+
+  it("gets Graph on empty relationsGraph", () => {
+    const limitedGraph = selectLimitedGraph(
+      { relationsGraph: {} },
+      currentId,
+      3
+    );
+    expect(limitedGraph).toStrictEqual({});
+  });
+
+  it("gets depth limited graph", () => {
+    const limitedGraph = selectLimitedGraph({ relationsGraph }, currentId, 2);
+
+    expect(
+      _.isUndefined(
+        _.find({ id: nodes[0].id, name: nodes[0].name }, limitedGraph.nodes)
+      ) &&
+        _.isUndefined(
+          _.find({ id: nodes[1].id, name: nodes[1].name }, limitedGraph.nodes)
+        )
+    ).toBeFalsy();
+
+    expect(
+      _.isUndefined(
+        _.find({ id: nodes[2].id, name: nodes[2].name }, limitedGraph.nodes)
+      )
+    ).toBeTruthy();
+
+    expect(
+      _.isUndefined(
+        _.find(
+          {
+            source_id: edges[0].source_id,
+            target_id: edges[0].target_id,
+          },
+          limitedGraph.edges
+        )
+      )
+    ).toBeFalsy();
+
+    expect(
+      _.isUndefined(
+        _.find(
+          {
+            source_id: edges[1].source_id,
+            target_id: edges[1].target_id,
+          },
+          limitedGraph.edges
+        )
+      ) &&
+        _.isUndefined(
+          _.find(
+            {
+              source_id: edges[2].source_id,
+              target_id: edges[2].target_id,
+            },
+            limitedGraph.edges
+          )
+        )
+    ).toBeTruthy();
+  });
+
+  it("get graph max depth", () => {
+    const start = {
+      id: "business_concept:92",
+      name: "My Awesome Concept",
+    };
+
+    expect(selectMaxDepth({ relationsGraph }, currentId, start)).toBe(3);
+  });
+});

package/src/selectors/index.js

@@ -1,2 +1,3 @@
 export * from "./getStructureLinks";
 export * from "./getImplementationToConceptLinks";
+export * from "./relationGraphTraversal";

package/src/selectors/relationGraphTraversal.js

@@ -0,0 +1,113 @@
+/* eslint-disable fp/no-mutation */
+/* eslint-disable fp/no-let */
+import _ from "lodash/fp";
+import { createSelector } from "reselect";
+
+const selectStart = createSelector(
+  (state) => state.relationsGraph,
+  (state, currentId) => currentId,
+  (relationsGraph, currentId) => {
+    return (
+      _.flow(_.getOr([], "nodes"), _.find({ id: currentId }))(relationsGraph) ||
+      {}
+    );
+  }
+);
+
+export const selectMaxDepth = createSelector(
+  (state) => state.relationsGraph,
+  (state, currentId) => selectStart(state, currentId),
+  (relationsGraph, start) => bfsMaxDepth(relationsGraph, start)
+);
+
+export const selectLimitedGraph = createSelector(
+  (state) => state.relationsGraph,
+  (state, currentId) => selectStart(state, currentId),
+  (state, currentId) => selectMaxDepth(state, currentId),
+  (state, currentId, depth) => depth,
+  (relationsGraph, start, maxDepth, depth) =>
+    getLimitedGraph(relationsGraph, start, maxDepth, depth)
+);
+
+const getLimitedGraph = (relationsGraph, start, maxDepth, depth) => {
+  if (!_.isEmpty(relationsGraph) && !_.isEmpty(start) && depth !== Infinity) {
+    const nodes = dfs(relationsGraph, start, {}, depth);
+    return depth < maxDepth
+      ? {
+          nodes,
+          edges: getEdges(relationsGraph, nodes),
+        }
+      : relationsGraph;
+  } else {
+    return relationsGraph;
+  }
+};
+
+const getNeighbours = (relationsGraph, start) => {
+  const neighbours = _.concat(
+    // Up
+    _.flow(
+      _.filter((edge) => edge.target_id === start.id),
+      _.flatMap((edge) => _.find({ id: edge.source_id }, relationsGraph.nodes))
+    )(relationsGraph.edges),
+    // Down
+    _.flow(
+      _.filter((edge) => edge.source_id === start.id),
+      _.flatMap((edge) => _.find({ id: edge.target_id }, relationsGraph.nodes))
+    )(relationsGraph.edges)
+  );
+  return neighbours;
+};
+
+export const getEdges = (relationsGraph, nodes) => {
+  const nodeIds = Object.keys(nodes);
+  return _.filter(
+    (edge) =>
+      nodeIds.includes(edge.source_id) && nodeIds.includes(edge.target_id),
+    relationsGraph.edges
+  );
+};
+
+export const dfs = (relationsGraph, start, visited, maxDepth) => {
+  if (Object.keys(visited).includes(start.id) || maxDepth === 0) return {};
+
+  return _.reduce(
+    (acc, neighbour) => ({
+      ...acc,
+      ...dfs(
+        relationsGraph,
+        neighbour,
+        { ...visited, [start.id]: start },
+        maxDepth - 1
+      ),
+    }),
+    { [start.id]: start }
+  )(getNeighbours(relationsGraph, start));
+};
+
+/*
+ * Shortest Path (Unweighted Graph)
+ * If the graph is unweighed, then finding the shortest path is easy: we can
+ * use the breadth-first search algorithm. For a weighted graph, we can use Dijkstra's algorithm.
+ * https://aquarchitect.github.io/swift-algorithm-club/Shortest%20Path%20%28Unweighted%29/
+ */
+const bfsMaxDepth = (relationsGraph, start) => {
+  let queue = [];
+  let nodesDistance = {};
+
+  queue.push(start);
+  nodesDistance[start.id] = 1;
+
+  let current = start;
+  while (!_.isEmpty(current)) {
+    current = queue.shift() || {};
+    for (let neighbour of getNeighbours(relationsGraph, current)) {
+      if (!nodesDistance[neighbour.id]) {
+        queue.push(neighbour);
+        nodesDistance[neighbour.id] = nodesDistance[current.id] + 1;
+      }
+    }
+  }
+
+  return Math.max(...Object.values(nodesDistance));
+};

package/src/styles/relationGraph.less

@@ -1,34 +1,21 @@
+.graph-depth {
+  position: absolute !important;
+  z-index: 1;
+  margin-right: 0px;
 
-.graph{
-
-  div&{
-    position: absolute;
-    right: 0;
-    z-index: 1;
-    padding-right: 1rem;
-
-    input[type=number] {
-      vertical-align: top;
-      line-height: 34px;
-      width: 105px;
-      font-size: 20px;
-      text-align: center;
-    }
-
-    label {
-      position: absolute;
-      top: -20px;
-    }
-    .ui.button {
-      vertical-align: top;
-      width: 80px;
-      border-radius: 0 4px 4px 0;
-      border: 1px solid grey;
-      border-left: 0;
-      font-size: 14px;
-    }
+  div {
+    text-align: center;
+    font-weight: bold;
+  }
+}
 
+.graph-depth .rangeslider-vertical {
+  .rangeslider__fill {
+    background-color: #ed5c17;
+    border: 1px solid gray;
   }
 
-  
+  .rangeslider__handle {
+    border-radius: 4px;
+  }
 }

package/src/components/__tests__/RelationGraph.spec.js

@@ -1,264 +0,0 @@
-import _ from "lodash/fp";
-import React from "react";
-import { mount } from "enzyme";
-import { intl } from "@truedat/test/intl-stub";
-import userEvent from "@testing-library/user-event";
-import { render } from "@truedat/test/render";
-import { waitFor } from "@testing-library/react";
-import { RelationGraph } from "../RelationGraph";
-
-jest.spyOn(React, "useContext").mockImplementation(() => intl);
-
-const renderOpts = {
-  messages: {
-    en: {
-      "relationGraph.all": "All",
-      "relationGraph.depth": "Depth",
-    },
-  },
-};
-
-describe("<RelationGraph />", () => {
-  beforeEach(() => {
-    // Avoid `attachTo: document.body` Warning
-    const div = document.createElement("div");
-    div.setAttribute("id", "container");
-    document.body.appendChild(div);
-  });
-
-  afterEach(() => {
-    const div = document.getElementById("container");
-    if (div) {
-      document.body.removeChild(div);
-    }
-  });
-
-  const nodes = [
-    {
-      id: "business_concept:92",
-      name: "My Awesome Concept",
-    },
-    {
-      id: "business_concept:5",
-      name: "New Concept 4",
-    },
-    {
-      id: "business_concept:18",
-      name: "Float Concept",
-    },
-  ];
-
-  const edges = [
-    {
-      id: 1,
-      source_id: "business_concept:92",
-      target_id: "business_concept:5",
-      tags: [
-        {
-          id: 3,
-          value: {
-            target_type: "business_concept",
-            type: "bc_padre",
-          },
-        },
-      ],
-    },
-    {
-      id: 2,
-      source_id: "business_concept:5",
-      target_id: "business_concept:18",
-      tags: [
-        {
-          id: 3,
-          value: {
-            target_type: "business_concept",
-            type: "bc_padre",
-          },
-        },
-      ],
-    },
-    {
-      id: 3,
-      source_id: "business_concept:18",
-      target_id: "business_concept:5",
-      tags: [
-        {
-          id: 3,
-          value: {
-            target_type: "business_concept",
-            type: "bc_padre",
-          },
-        },
-      ],
-    },
-  ];
-
-  const relationsGraph = {
-    nodes,
-    edges,
-  };
-
-  const defaultProps = {
-    currentId: "business_concept:92",
-    navigate: jest.fn(),
-    relationsGraph: {},
-  };
-
-  it("renders Graph on non-empty relationsGraph", () => {
-    const props = { ...defaultProps, relationsGraph };
-
-    const wrapper = mount(<RelationGraph {...props} />, {
-      attachTo: document.getElementById("container"),
-    });
-
-    const graphComponent = wrapper.find("Graph");
-    expect(graphComponent.length).toBe(1);
-    const limitedGraph = graphComponent.prop("graph");
-
-    expect(
-      _.isUndefined(
-        _.find({ id: nodes[0].id, label: nodes[0].name }, limitedGraph.nodes)
-      ) &&
-        _.isUndefined(
-          _.find({ id: nodes[1].id, label: nodes[1].name }, limitedGraph.nodes)
-        ) &&
-        _.isUndefined(
-          _.find({ id: nodes[2].id, label: nodes[2].name }, limitedGraph.nodes)
-        )
-    ).toBeFalsy();
-
-    expect(
-      _.isUndefined(
-        _.find(
-          {
-            from: edges[0].source_id,
-            to: edges[0].target_id,
-            label: `source.${edges[0].tags[0].value.type}`,
-          },
-          limitedGraph.edges
-        )
-      ) &&
-        _.isUndefined(
-          _.find(
-            {
-              from: edges[1].source_id,
-              to: edges[1].target_id,
-              label: `source.${edges[1].tags[1].value.type}`,
-            },
-            limitedGraph.edges
-          )
-        ) &&
-        _.isUndefined(
-          _.find(
-            {
-              from: edges[2].source_id,
-              to: edges[2].target_id,
-              label: `source.${edges[2].tags[2].value.type}`,
-            },
-            limitedGraph.edges
-          )
-        )
-    ).toBeFalsy();
-  });
-
-  it("does not render Graph on empty relationsGraph", () => {
-    const wrapper = mount(<RelationGraph {...defaultProps} />, {
-      attachTo: document.getElementById("container"),
-    });
-    expect(wrapper.find("Graph").length).toBe(0);
-  });
-
-  it("sets initial depth", () => {
-    const initialDepth = 1;
-    const props = { ...defaultProps, relationsGraph, initialDepth };
-    const wrapper = mount(<RelationGraph {...props} />, {
-      attachTo: document.getElementById("container"),
-    });
-    const input = wrapper.find("input");
-    expect(input.prop("value")).toBe(initialDepth);
-  });
-
-  it("no initial depth defaults to max graph depth", () => {
-    const props = { ...defaultProps, relationsGraph };
-    const wrapper = mount(<RelationGraph {...props} />, {
-      attachTo: document.getElementById("container"),
-    });
-    const input = wrapper.find("input");
-    expect(input.prop("value")).toBe(3);
-  });
-
-  it("button sets max depth", async () => {
-    const initialDepth = 1;
-    const props = { ...defaultProps, relationsGraph, initialDepth };
-    const { getByRole, getByLabelText } = render(
-      <RelationGraph {...props} />,
-      renderOpts
-    );
-
-    userEvent.click(await getByRole("button"));
-    await waitFor(() => {
-      expect(parseInt(getByLabelText("depth").value)).toBe(3);
-    });
-  });
-
-  it("limits graph", async () => {
-    const props = { ...defaultProps, relationsGraph };
-    const wrapper = await mount(<RelationGraph {...props} />, {
-      attachTo: document.getElementById("container"),
-    });
-    const input = wrapper.find("input");
-    input.simulate("change", { target: { value: 2 } });
-    const limitedGraph = wrapper.find("Graph").prop("graph");
-
-    expect(
-      _.isUndefined(
-        _.find({ id: nodes[0].id, label: nodes[0].name }, limitedGraph.nodes)
-      ) &&
-        _.isUndefined(
-          _.find({ id: nodes[1].id, label: nodes[1].name }, limitedGraph.nodes)
-        )
-    ).toBeFalsy();
-
-    expect(
-      _.isUndefined(
-        _.find({ id: nodes[2].id, label: nodes[2].name }, limitedGraph.nodes)
-      )
-    ).toBeTruthy();
-
-    expect(
-      _.isUndefined(
-        _.find(
-          {
-            from: edges[0].source_id,
-            to: edges[0].target_id,
-            label: `source.${edges[0].tags[0].value.type}`,
-          },
-          limitedGraph.edges
-        )
-      )
-    ).toBeFalsy();
-
-    expect(
-      _.isUndefined(
-        _.find(
-          {
-            from: edges[1].source_id,
-            to: edges[1].target_id,
-            label: `source.${edges[1].tags[0].value.type}`,
-          },
-          limitedGraph.edges
-        )
-      ) &&
-        _.isUndefined(
-          _.find(
-            {
-              from: edges[2].source_id,
-              to: edges[2].target_id,
-              label: `source.${edges[2].tags[0].value.type}`,
-            },
-            limitedGraph.edges
-          )
-        )
-    ).toBeTruthy();
-  });
-});