codecharta-visualization 1.119.1 → 1.120.1

package/app/codeCharta/ui/codeMap/arrow/__snapshots__/codeMap.arrow.service.spec.ts.snap

@@ -1,201 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`CodeMapArrowService Arrow Behaviour when selecting and hovering a building should only highlight small leaf when big leaf is selected 1`] = `
-[
-  CodeMapBuilding {
-    "_boundingBox": Box3 {
-      "max": Vector3 {
-        "x": 6,
-        "y": 8,
-        "z": 10,
-      },
-      "min": Vector3 {
-        "x": 5,
-        "y": 6,
-        "z": 7,
-      },
-    },
-    "_color": "#820E0E",
-    "_defaultColor": "#820E0E",
-    "_defaultDeltaColor": "#000000",
-    "_deltaColor": "#000000",
-    "_id": 1,
-    "_node": {
-      "attributes": {
-        "a": 20,
-        "b": 15,
-        "mcc": 100,
-      },
-      "color": "#820E0E",
-      "deltas": {
-        "a": 1,
-        "b": 2,
-      },
-      "depth": 4,
-      "edgeAttributes": {
-        "a": {
-          "incoming": 2,
-          "outgoing": 666,
-        },
-      },
-      "flat": false,
-      "height": 2,
-      "heightDelta": 20,
-      "id": 2,
-      "incomingEdgePoint": Vector3 {
-        "x": 1,
-        "y": 2,
-        "z": 3,
-      },
-      "isLeaf": true,
-      "length": 3,
-      "link": "NO_LINK",
-      "mapNodeDepth": 2,
-      "markingColor": "0xFFFFFF",
-      "name": "root/small leaf",
-      "outgoingEdgePoint": Vector3 {
-        "x": 1,
-        "y": 2,
-        "z": 3,
-      },
-      "path": "/root/Parent Leaf/small leaf",
-      "visible": true,
-      "width": 1,
-      "x0": 5,
-      "y0": 7,
-      "z0": 6,
-    },
-  },
-  CodeMapBuilding {
-    "_boundingBox": Box3 {
-      "max": Vector3 {
-        "x": 6,
-        "y": 8,
-        "z": 10,
-      },
-      "min": Vector3 {
-        "x": 5,
-        "y": 6,
-        "z": 7,
-      },
-    },
-    "_color": "#820E0E",
-    "_defaultColor": "#820E0E",
-    "_defaultDeltaColor": "#000000",
-    "_deltaColor": "#000000",
-    "_id": 1,
-    "_node": {
-      "attributes": {
-        "a": 20,
-        "b": 15,
-        "mcc": 100,
-      },
-      "color": "#820E0E",
-      "deltas": {
-        "a": 1,
-        "b": 2,
-      },
-      "depth": 4,
-      "edgeAttributes": {
-        "a": {
-          "incoming": 2,
-          "outgoing": 666,
-        },
-      },
-      "flat": false,
-      "height": 2,
-      "heightDelta": 20,
-      "id": 2,
-      "incomingEdgePoint": Vector3 {
-        "x": 1,
-        "y": 2,
-        "z": 3,
-      },
-      "isLeaf": true,
-      "length": 3,
-      "link": "NO_LINK",
-      "mapNodeDepth": 2,
-      "markingColor": "0xFFFFFF",
-      "name": "root/small leaf",
-      "outgoingEdgePoint": Vector3 {
-        "x": 1,
-        "y": 2,
-        "z": 3,
-      },
-      "path": "/root/Parent Leaf/small leaf",
-      "visible": true,
-      "width": 1,
-      "x0": 5,
-      "y0": 7,
-      "z0": 6,
-    },
-  },
-]
-`;
-
-exports[`CodeMapArrowService Arrow Behaviour when selecting and hovering a building should only highlight small leaf when big leaf is selected 2`] = `
-CodeMapBuilding {
-  "_boundingBox": Box3 {
-    "max": Vector3 {
-      "x": -Infinity,
-      "y": -Infinity,
-      "z": -Infinity,
-    },
-    "min": Vector3 {
-      "x": Infinity,
-      "y": Infinity,
-      "z": Infinity,
-    },
-  },
-  "_color": "#EB8319",
-  "_defaultColor": "#ddcc00",
-  "_defaultDeltaColor": "#EB8319",
-  "_deltaColor": "#EB8319",
-  "_id": 1,
-  "_node": {
-    "attributes": {
-      "a": 20,
-      "b": 15,
-      "mcc": 14,
-    },
-    "color": "#AABBCC",
-    "deltas": {
-      "a": 1,
-      "b": 2,
-    },
-    "depth": 4,
-    "edgeAttributes": {
-      "a": {
-        "incoming": 2,
-        "outgoing": 666,
-      },
-    },
-    "flat": false,
-    "height": 2,
-    "heightDelta": 20,
-    "id": 1,
-    "incomingEdgePoint": Vector3 {
-      "x": 1,
-      "y": 2,
-      "z": 3,
-    },
-    "isLeaf": true,
-    "length": 3,
-    "link": "NO_LINK",
-    "mapNodeDepth": 2,
-    "markingColor": "0xFFFFFF",
-    "name": "root/big leaf",
-    "outgoingEdgePoint": Vector3 {
-      "x": 1,
-      "y": 2,
-      "z": 3,
-    },
-    "path": "/root/big leaf",
-    "visible": true,
-    "width": 1,
-    "x0": 5,
-    "y0": 7,
-    "z0": 6,
-  },
-}
-`;

package/app/codeCharta/ui/codeMap/arrow/codeMap.arrow.service.spec.ts

@@ -1,300 +0,0 @@
-import { TestBed } from "@angular/core/testing"
-import { StoreModule, Store, State } from "@ngrx/store"
-import { CodeMapArrowService } from "./codeMap.arrow.service"
-import { ThreeSceneService } from "../threeViewer/threeSceneService"
-import { Object3D, Vector3 } from "three"
-import {
-	CODE_MAP_BUILDING,
-	OUTGOING_NODE,
-	DIFFERENT_NODE,
-	INCOMING_NODE,
-	VALID_EDGES_DECORATED,
-	CODE_MAP_BUILDING_WITH_INCOMING_EDGE_NODE,
-	CODE_MAP_BUILDING_WITH_OUTGOING_EDGE_NODE
-} from "../../../util/dataMocks"
-import { CcState, Node } from "../../../codeCharta.model"
-import { ColorConverter } from "../../../util/color/colorConverter"
-import { setScaling } from "../../../state/store/appSettings/scaling/scaling.actions"
-import { setEdges } from "../../../state/store/fileSettings/edges/edges.actions"
-import { setHeightMetric } from "../../../state/store/dynamicSettings/heightMetric/heightMetric.actions"
-import { CodeMapMesh } from "../rendering/codeMapMesh"
-import { toggleEdgeMetricVisible } from "../../../state/store/appSettings/isEdgeMetricVisible/isEdgeMetricVisible.actions"
-import { wait } from "../../../util/testUtils/wait"
-import { IdToBuildingService } from "../../../services/idToBuilding/idToBuilding.service"
-import { appReducers, setStateMiddleware } from "../../../state/store/state.manager"
-import { clone } from "../../../util/clone"
-
-describe("CodeMapArrowService", () => {
-	let codeMapArrowService: CodeMapArrowService
-	let threeSceneService: ThreeSceneService
-	let store: Store<CcState>
-	let state: State<CcState>
-	let idToBuildingService: IdToBuildingService
-
-	beforeEach(() => {
-		TestBed.configureTestingModule({
-			imports: [StoreModule.forRoot(appReducers, { metaReducers: [setStateMiddleware] })]
-		})
-		threeSceneService = TestBed.inject(ThreeSceneService)
-		store = TestBed.inject(Store)
-		state = TestBed.inject(State)
-		idToBuildingService = TestBed.inject(IdToBuildingService)
-		codeMapArrowService = new CodeMapArrowService(store, state, threeSceneService, idToBuildingService)
-	})
-
-	function withMockedThreeSceneService() {
-		threeSceneService = codeMapArrowService["threeSceneService"] = jest.fn().mockReturnValue({
-			edgeArrows: {
-				children: [],
-				add: jest.fn()
-			},
-			highlightedBuildings: [],
-			getMapMesh: jest.fn().mockReturnValue({
-				getMeshDescription: jest.fn().mockReturnValue({ getBuildingByPath: jest.fn() }),
-				clearHighlight: jest.fn(),
-				highlightBuilding: jest.fn(),
-				clearSelection: jest.fn(),
-				selectBuilding: jest.fn()
-			}),
-			highlightBuildings: jest.fn(),
-			addBuildingToHighlightingList: jest.fn(),
-			getSelectedBuilding: jest.fn().mockReturnValue({
-				value: "value"
-			})
-		})()
-	}
-
-	function setupEdgeArrowsWithChildren() {
-		const dummyObject3D = new Object3D()
-		threeSceneService.edgeArrows.children = [dummyObject3D, dummyObject3D]
-	}
-
-	function setupArrows() {
-		const dummyObject3D = new Object3D()
-		codeMapArrowService["arrows"] = [dummyObject3D, dummyObject3D]
-	}
-
-	describe("constructor", () => {
-		it("should assign arrows an empty array", () => {
-			expect(codeMapArrowService["arrows"].length).toBe(0)
-		})
-	})
-
-	describe("Arrow Behaviour when selecting and hovering a building", () => {
-		it("should only highlight small leaf when big leaf is selected", async () => {
-			store.dispatch(setEdges({ value: VALID_EDGES_DECORATED }))
-			const nodes: Node[] = [
-				CODE_MAP_BUILDING_WITH_OUTGOING_EDGE_NODE.node,
-				CODE_MAP_BUILDING_WITH_INCOMING_EDGE_NODE.node,
-				DIFFERENT_NODE
-			]
-			threeSceneService["mapMesh"] = new CodeMapMesh(nodes, state.getValue(), false)
-			codeMapArrowService.addEdgePreview(nodes)
-			store.dispatch(setHeightMetric({ value: "mcc" }))
-
-			threeSceneService.selectBuilding(CODE_MAP_BUILDING_WITH_OUTGOING_EDGE_NODE)
-			codeMapArrowService.onBuildingHovered(CODE_MAP_BUILDING_WITH_OUTGOING_EDGE_NODE)
-
-			await wait(codeMapArrowService["HIGHLIGHT_BUILDING_DELAY"])
-
-			expect(threeSceneService["highlighted"]).toMatchSnapshot()
-			expect(threeSceneService["selected"]).toMatchSnapshot()
-		})
-		it("should debounce the edge reset of buildings to improve performance", async () => {
-			const resetEdgesOfBuildingMock = jest.fn()
-			codeMapArrowService["resetEdgesOfBuildings"] = resetEdgesOfBuildingMock
-			codeMapArrowService.onBuildingHovered(CODE_MAP_BUILDING_WITH_OUTGOING_EDGE_NODE)
-
-			expect(resetEdgesOfBuildingMock).not.toHaveBeenCalled()
-
-			await wait(codeMapArrowService["HIGHLIGHT_BUILDING_DELAY"])
-
-			expect(resetEdgesOfBuildingMock).toHaveBeenCalled()
-		})
-	})
-
-	describe("SelectionMethods", () => {
-		beforeEach(() => {
-			codeMapArrowService.clearArrows = jest.fn()
-			codeMapArrowService.addArrow = jest.fn()
-			codeMapArrowService["showEdgesOfBuildings"] = jest.fn()
-			codeMapArrowService.addEdgePreview = jest.fn()
-			threeSceneService.clearHighlight = jest.fn()
-			codeMapArrowService["buildPairingEdges"] = jest.fn()
-			codeMapArrowService.scale = jest.fn()
-		})
-
-		it("should call clearArrows and showEdgesOfBuildings through BuildingSelected", () => {
-			codeMapArrowService.onBuildingSelected({ building: CODE_MAP_BUILDING })
-
-			expect(codeMapArrowService.clearArrows).toHaveBeenCalled()
-			expect(codeMapArrowService["showEdgesOfBuildings"]).toHaveBeenCalled()
-			expect(codeMapArrowService.addEdgePreview).toHaveBeenCalledTimes(0)
-		})
-
-		it("should not call sub-methods through BuildingSelected if building is undefined", () => {
-			codeMapArrowService.onBuildingSelected({ building: undefined })
-
-			expect(codeMapArrowService.clearArrows).not.toHaveBeenCalled()
-			expect(codeMapArrowService["showEdgesOfBuildings"]).not.toHaveBeenCalled()
-			expect(codeMapArrowService.addEdgePreview).not.toHaveBeenCalled()
-			expect(codeMapArrowService.scale).toHaveBeenCalled()
-		})
-
-		it("should call clearArrows and showEdgesOfBuildings through BuildingHovered", async () => {
-			codeMapArrowService.onBuildingHovered(CODE_MAP_BUILDING)
-
-			await wait(codeMapArrowService["HIGHLIGHT_BUILDING_DELAY"])
-
-			expect(codeMapArrowService.clearArrows).toHaveBeenCalled()
-			expect(codeMapArrowService["showEdgesOfBuildings"]).toHaveBeenCalled()
-			expect(codeMapArrowService.addEdgePreview).toHaveBeenCalledTimes(0)
-		})
-
-		it("should call clearArrows and showEdgesOfBuildings through BuildingUnHovered when edge metric is enabled", () => {
-			codeMapArrowService.onBuildingUnhovered()
-
-			expect(codeMapArrowService.clearArrows).toHaveBeenCalled()
-			expect(codeMapArrowService["showEdgesOfBuildings"]).toHaveBeenCalled()
-			expect(codeMapArrowService.addEdgePreview).toHaveBeenCalledTimes(0)
-		})
-
-		it("should call clearArrows and showEdgesOfBuildings through BuildingUnHovered when edge metric is disabled", () => {
-			store.dispatch(toggleEdgeMetricVisible())
-			codeMapArrowService.onBuildingUnhovered()
-
-			expect(codeMapArrowService.clearArrows).toHaveBeenCalledTimes(0)
-			expect(codeMapArrowService["showEdgesOfBuildings"]).toHaveBeenCalledTimes(0)
-			expect(codeMapArrowService.addEdgePreview).toHaveBeenCalledTimes(0)
-		})
-
-		it("should call clearArrows and showEdgesOfBuildings through BuildingDeselected", () => {
-			codeMapArrowService.onBuildingDeselected()
-
-			expect(codeMapArrowService.clearArrows).toHaveBeenCalled()
-			expect(codeMapArrowService.addEdgePreview).toHaveBeenCalled()
-			expect(codeMapArrowService.addArrow).toHaveBeenCalledTimes(0)
-			expect(threeSceneService.clearHighlight).toHaveBeenCalledTimes(0)
-			expect(codeMapArrowService["showEdgesOfBuildings"]).toHaveBeenCalledTimes(0)
-		})
-	})
-
-	describe("clearArrows", () => {
-		beforeEach(() => {
-			withMockedThreeSceneService()
-		})
-
-		it("should remove all array entries of field arrows", () => {
-			setupEdgeArrowsWithChildren()
-
-			codeMapArrowService.clearArrows()
-
-			expect(codeMapArrowService["arrows"].length).toBe(0)
-		})
-
-		it("should remove all array entries of threeSceneService.edgeArrows.children", () => {
-			setupEdgeArrowsWithChildren()
-
-			codeMapArrowService.clearArrows()
-
-			expect(threeSceneService.edgeArrows.children.length).toBe(0)
-		})
-	})
-
-	describe("addEdgePreview", () => {
-		beforeEach(() => {
-			codeMapArrowService["map"] = new Map<string, Node>()
-			codeMapArrowService["map"].get = jest.fn(() => {
-				return INCOMING_NODE
-			})
-			codeMapArrowService["previewMode"] = jest.fn()
-		})
-		it("should create an edge Preview of one", () => {
-			const nodes: Node[] = [OUTGOING_NODE]
-
-			codeMapArrowService.addEdgePreview(nodes)
-
-			expect(codeMapArrowService["map"].size).toEqual(1)
-		})
-		it("should create no edge Preview at all", () => {
-			codeMapArrowService.addEdgePreview()
-
-			expect(codeMapArrowService["map"].size).toEqual(0)
-		})
-		it("when targetNode is invalid then it should not call preview mode", () => {
-			const invalidEdge = clone(VALID_EDGES_DECORATED)
-			invalidEdge[0].toNodeName = "invalid"
-			store.dispatch(setEdges({ value: invalidEdge }))
-			const nodes: Node[] = [CODE_MAP_BUILDING_WITH_OUTGOING_EDGE_NODE.node]
-
-			codeMapArrowService.addEdgePreview(nodes)
-
-			expect(codeMapArrowService["previewMode"]).not.toHaveBeenCalled()
-		})
-		it("when originNodeName is invalid then it should not call preview mode", () => {
-			const invalidEdge = clone(VALID_EDGES_DECORATED)
-			invalidEdge[0].fromNodeName = "invalid"
-			store.dispatch(setEdges({ value: invalidEdge }))
-			const nodes: Node[] = [CODE_MAP_BUILDING_WITH_INCOMING_EDGE_NODE.node]
-
-			codeMapArrowService.addEdgePreview(nodes)
-
-			expect(codeMapArrowService["previewMode"]).not.toHaveBeenCalled()
-		})
-	})
-
-	describe("createCurve", () => {
-		it("should create a curve out of the 2 Nodes", () => {
-			const originNode: Node = OUTGOING_NODE
-			const targetNode: Node = INCOMING_NODE
-			const curveScale = 100 * state.getValue().appSettings.edgeHeight
-
-			const curve = codeMapArrowService["createCurve"](originNode, targetNode, curveScale)
-
-			expect(curve).toBeDefined()
-		})
-	})
-
-	describe("highlightBuilding", () => {
-		it("should highlight certain buildings", () => {
-			withMockedThreeSceneService()
-
-			codeMapArrowService["highlightBuilding"](OUTGOING_NODE)
-
-			expect(threeSceneService.getMapMesh().getMeshDescription().getBuildingByPath).toHaveBeenCalled()
-			expect(threeSceneService.addBuildingToHighlightingList).toHaveBeenCalled()
-		})
-	})
-
-	describe("setCurveColor", () => {
-		beforeEach(() => {
-			threeSceneService.edgeArrows["add"] = jest.fn()
-			codeMapArrowService["arrows"].push = jest.fn()
-		})
-		it("should run through the function with mocked subfunctions", () => {
-			const originNode: Node = OUTGOING_NODE
-			const targetNode: Node = INCOMING_NODE
-			const curveScale = 100 * state.getValue().appSettings.edgeHeight
-			const curve = codeMapArrowService["createCurve"](originNode, targetNode, curveScale)
-			const color = ColorConverter.convertHexToNumber(state.getValue().appSettings.mapColors.outgoingEdge)
-
-			codeMapArrowService["setCurveColor"](curve, color)
-
-			expect(threeSceneService.edgeArrows["add"]).toHaveBeenCalled()
-			expect(codeMapArrowService["arrows"].push).toHaveBeenCalled()
-		})
-	})
-
-	describe("scale", () => {
-		it("should set the scale of all arrows to x, y and z", () => {
-			setupArrows()
-			store.dispatch(setScaling({ value: new Vector3(1, 2, 3) }))
-
-			codeMapArrowService.scale()
-
-			expect(codeMapArrowService["arrows"][0].scale.x).toBe(1)
-			expect(codeMapArrowService["arrows"][0].scale.y).toBe(2)
-			expect(codeMapArrowService["arrows"][0].scale.z).toBe(3)
-		})
-	})
-})