codecharta-visualization 1.119.1 → 1.120.0

package/app/codeCharta/state/effects/updateFileSettings/utils/edges.merger.ts

@@ -1,36 +0,0 @@
-import { getUpdatedPath } from "../../../../util/nodePathHelper"
-import { CCFile, Edge } from "../../../../codeCharta.model"
-import { clone } from "../../../../util/clone"
-
-export function getMergedEdges(inputFiles: CCFile[], withUpdatedPath: boolean) {
-	const edges: Map<string, Edge> = new Map()
-
-	if (inputFiles.length === 1) {
-		return inputFiles[0].settings.fileSettings.edges
-	}
-
-	for (const inputFile of inputFiles) {
-		if (inputFile.settings.fileSettings.edges) {
-			for (const oldEdge of inputFile.settings.fileSettings.edges) {
-				const edge: Edge = {
-					fromNodeName: withUpdatedPath
-						? getUpdatedPath(inputFile.fileMeta.fileName, oldEdge.fromNodeName)
-						: oldEdge.fromNodeName,
-					toNodeName: withUpdatedPath ? getUpdatedPath(inputFile.fileMeta.fileName, oldEdge.toNodeName) : oldEdge.toNodeName,
-					attributes: clone(oldEdge.attributes),
-					visible: oldEdge.visible
-				}
-				const equalEdgeItem = edges.get(`${edge.fromNodeName}|${edge.toNodeName}`)
-
-				if (equalEdgeItem !== undefined) {
-					for (const key of Object.keys(edge.attributes)) {
-						equalEdgeItem.attributes[key] = edge.attributes[key]
-					}
-				} else {
-					edges.set(`${edge.fromNodeName}|${edge.toNodeName}`, edge)
-				}
-			}
-		}
-	}
-	return [...edges.values()]
-}

package/app/codeCharta/state/effects/updateFileSettings/utils/markedPackages.merger.spec.ts

@@ -1,74 +0,0 @@
-import { TEST_FILE_DATA } from "../../../../util/dataMocks"
-import { getMergedMarkedPackages } from "./markedPackages.merger"
-import { CCFile, MarkedPackage } from "../../../../codeCharta.model"
-import { clone } from "../../../../util/clone"
-
-describe("MarkedPackagesMerger", () => {
-	describe("getMergedMarkedPackages", () => {
-		let mp1: MarkedPackage
-		let mp2: MarkedPackage
-		let mp3: MarkedPackage
-		let mp4: MarkedPackage
-
-		let file1: CCFile
-		let file2: CCFile
-
-		beforeEach(() => {
-			file1 = clone(TEST_FILE_DATA)
-			file1.fileMeta.fileName = "file1"
-
-			file2 = clone(TEST_FILE_DATA)
-			file2.fileMeta.fileName = "file2"
-
-			mp1 = {
-				path: "/root/nodeA",
-				color: "#ABABAB"
-			}
-
-			mp2 = {
-				path: "/root/nodeB",
-				color: "#FFFFFF"
-			}
-
-			mp3 = {
-				path: "/root/nodeA",
-				color: "#ABABAB"
-			}
-
-			mp4 = {
-				path: "/root/nodeA",
-				color: "#ABABAB"
-			}
-		})
-
-		it("should merge empty markedPackage-arrays", () => {
-			file1.settings.fileSettings.markedPackages = []
-			file2.settings.fileSettings.markedPackages = []
-			expect(getMergedMarkedPackages([file1, file2], false)).toEqual([])
-		})
-
-		it("should merge different markedPackages", () => {
-			file1.settings.fileSettings.markedPackages = [mp1]
-			file2.settings.fileSettings.markedPackages = [mp2]
-			expect(getMergedMarkedPackages([file1, file2], false)).toMatchSnapshot()
-		})
-
-		it("should merge all markedPackages if one file does not contain markedPackages", () => {
-			file1.settings.fileSettings.markedPackages = [mp1, mp2]
-			file2.settings.fileSettings.markedPackages = null
-			expect(getMergedMarkedPackages([file1, file2], false)).toMatchSnapshot()
-		})
-
-		it("should merge markedPackage-attributes for the same markedPackage paths", () => {
-			file1.settings.fileSettings.markedPackages = [mp1]
-			file2.settings.fileSettings.markedPackages = [mp3]
-			expect(getMergedMarkedPackages([file1, file2], false)).toMatchSnapshot()
-		})
-
-		it("should overwrite duplicated markedPackage-attributes for the same markedPackage", () => {
-			file1.settings.fileSettings.markedPackages = [mp1]
-			file2.settings.fileSettings.markedPackages = [mp4]
-			expect(getMergedMarkedPackages([file1, file2], false)).toMatchSnapshot()
-		})
-	})
-})

package/app/codeCharta/state/effects/updateFileSettings/utils/markedPackages.merger.ts

@@ -1,25 +0,0 @@
-import { getUpdatedBlacklistItemPath } from "../../../../util/nodePathHelper"
-import { CCFile, MarkedPackage } from "../../../../codeCharta.model"
-
-export function getMergedMarkedPackages(inputFiles: CCFile[], withUpdatedPath: boolean) {
-	if (inputFiles.length === 1) {
-		return inputFiles[0].settings.fileSettings.markedPackages
-	}
-
-	const markedPackages: Map<string, MarkedPackage> = new Map()
-
-	for (const inputFile of inputFiles) {
-		if (inputFile.settings.fileSettings.markedPackages) {
-			for (const oldMarkedPackages of inputFile.settings.fileSettings.markedPackages) {
-				const markedPackage: MarkedPackage = {
-					path: withUpdatedPath
-						? getUpdatedBlacklistItemPath(inputFile.fileMeta.fileName, oldMarkedPackages.path)
-						: oldMarkedPackages.path,
-					color: oldMarkedPackages.color
-				}
-				markedPackages.set(`${markedPackage.path}|${markedPackage.color}`, markedPackage)
-			}
-		}
-	}
-	return [...markedPackages.values()]
-}

package/app/codeCharta/state/effects/updateVisibleTopLabels/getNumberOfTopLabels.spec.ts

@@ -1,18 +0,0 @@
-import { getNumberOfTopLabels } from "./getNumberOfTopLabels"
-
-describe("getNumberOfTopLabels", () => {
-	it("should return 1 when number of nodes are equal or less than 100", () => {
-		const nodes = Array.from({ length: 10 }).fill({})
-		expect(getNumberOfTopLabels(nodes)).toBe(1)
-	})
-
-	it("should return 2 when number of nodes are greater than or equal to 200 and less than 300", () => {
-		const nodes = Array.from({ length: 200 }).fill({})
-		expect(getNumberOfTopLabels(nodes)).toBe(2)
-	})
-
-	it("should return 10 (max limit for displayed top labels) when number of nodes are greater than 1000", () => {
-		const nodes = Array.from({ length: 1001 }).fill({})
-		expect(getNumberOfTopLabels(nodes)).toBe(10)
-	})
-})

package/app/codeCharta/state/effects/updateVisibleTopLabels/getNumberOfTopLabels.ts

@@ -1,12 +0,0 @@
-import { defaultAmountOfTopLabels } from "../../store/appSettings/amountOfTopLabels/amountOfTopLabels.reducer"
-
-const BUILDINGS_PER_LABEL = 100
-const MAX_NUMBER_OF_LABELS = 10
-
-export const getNumberOfTopLabels = (codeMapNodes: { length: number }) => {
-	const numberOfLabels = Math.floor(codeMapNodes.length / BUILDINGS_PER_LABEL)
-	if (numberOfLabels <= defaultAmountOfTopLabels) {
-		return defaultAmountOfTopLabels
-	}
-	return Math.min(numberOfLabels, MAX_NUMBER_OF_LABELS)
-}

package/app/codeCharta/state/effects/updateVisibleTopLabels/updateVisibleTopLabels.effect.ts

@@ -1,24 +0,0 @@
-import { Injectable } from "@angular/core"
-import { createEffect } from "@ngrx/effects"
-
-import { map, withLatestFrom } from "rxjs"
-import { visibleFileStatesSelector } from "../../selectors/visibleFileStates.selector"
-import { codeMapNodesSelector } from "../../selectors/accumulatedData/codeMapNodes.selector"
-import { setAmountOfTopLabels } from "../../store/appSettings/amountOfTopLabels/amountOfTopLabels.actions"
-import { getNumberOfTopLabels } from "./getNumberOfTopLabels"
-import { Store } from "@ngrx/store"
-import { CcState } from "../../../codeCharta.model"
-
-@Injectable()
-export class UpdateVisibleTopLabelsEffect {
-	constructor(private store: Store<CcState>) {}
-
-	updateVisibleTopLabels$ = createEffect(() =>
-		this.store.select(visibleFileStatesSelector).pipe(
-			withLatestFrom(this.store.select(codeMapNodesSelector)),
-			map(([, codeMapNodes]) => {
-				return setAmountOfTopLabels({ value: getNumberOfTopLabels(codeMapNodes) })
-			})
-		)
-	)
-}

package/app/codeCharta/state/selectors/accumulatedData/accumulatedData.selector.spec.ts

@@ -1,76 +0,0 @@
-import { NodeType } from "../../../codeCharta.model"
-import { FileSelectionState, FileState } from "../../../model/files/files"
-import packageJson from "../../../../../package.json"
-import { _getUndecoratedAccumulatedData } from "./accumulatedData.selector"
-
-describe("accumulatedDataSelector", () => {
-	describe("_getUndecoratedAccumulatedData", () => {
-		const fileState1 = {
-			file: {
-				fileMeta: {
-					fileName: "file1",
-					fileChecksum: "md5-file1",
-					projectName: "Sample Project",
-					apiVersion: packageJson.codecharta.apiVersion,
-					exportedFileSize: 300_000
-				},
-				map: {
-					name: "root1",
-					type: NodeType.FOLDER,
-					path: "/root1",
-					attributes: { rloc: 170, functions: 1010, mcc: 11 },
-					children: []
-				}
-			}
-		} as unknown as FileState
-		const fileState2 = {
-			file: {
-				fileMeta: {
-					fileName: "file2",
-					fileChecksum: "md5-file2",
-					projectName: "Sample Project2",
-					apiVersion: packageJson.codecharta.apiVersion,
-					exportedFileSize: 300_000
-				},
-				map: {
-					name: "root2",
-					type: NodeType.FOLDER,
-					path: "/root2",
-					attributes: { rloc: 170, functions: 1010, mcc: 11 },
-					children: []
-				}
-			}
-		} as unknown as FileState
-
-		beforeEach(() => {
-			fileState1.selectedAs = FileSelectionState.None
-			fileState2.selectedAs = FileSelectionState.None
-		})
-
-		it("should wrap multiple selected files in a root path", () => {
-			fileState1.selectedAs = FileSelectionState.Partial
-			fileState2.selectedAs = FileSelectionState.Partial
-			const accumulatedData = _getUndecoratedAccumulatedData([fileState1, fileState2])
-			expect(accumulatedData.map.path).toBe("/root")
-		})
-
-		it("should not wrap a single selected file in a root path", () => {
-			fileState1.selectedAs = FileSelectionState.Partial
-			const accumulatedData = _getUndecoratedAccumulatedData([fileState1])
-			expect(accumulatedData.map.path).toBe("/root1")
-		})
-
-		it("should wrap a root path for delta mode", () => {
-			fileState1.selectedAs = FileSelectionState.Reference
-			fileState2.selectedAs = FileSelectionState.Comparison
-			const accumulatedData = _getUndecoratedAccumulatedData([fileState1, fileState2])
-			expect(accumulatedData.map.path).toBe("/root")
-		})
-
-		it("should not wrap a root path, when there is no comparison file in delta mode", () => {
-			fileState1.selectedAs = FileSelectionState.Reference
-			const accumulatedData = _getUndecoratedAccumulatedData([fileState1])
-			expect(accumulatedData.map.path).toBe("/root1")
-		})
-	})
-})

package/app/codeCharta/state/selectors/accumulatedData/accumulatedData.selector.ts

@@ -1,61 +0,0 @@
-import { CodeMapNode, FileMeta } from "../../../codeCharta.model"
-import { FileState } from "../../../model/files/files"
-import { fileStatesAvailable, isDeltaState, isPartialState } from "../../../model/files/files.helper"
-import { AggregationGenerator } from "../../../util/aggregationGenerator"
-import { NodeDecorator } from "../../../util/nodeDecorator"
-import { metricNamesSelector } from "./metricData/metricNames.selector"
-import { getDeltaFile } from "./utils/getDeltaFile"
-import { addEdgeMetricsForLeaves } from "./utils/addEdgeMetricsForLeaves"
-import { blacklistSelector } from "../../store/fileSettings/blacklist/blacklist.selector"
-import { attributeTypesSelector } from "../../store/fileSettings/attributeTypes/attributeTypes.selector"
-import { visibleFileStatesSelector } from "../visibleFileStates.selector"
-import { metricDataSelector } from "./metricData/metricData.selector"
-import { createSelector } from "@ngrx/store"
-import { clone } from "../../../util/clone"
-
-const accumulatedDataFallback: AccumulatedData = Object.freeze({
-	unifiedMapNode: undefined,
-	unifiedFileMeta: undefined
-})
-
-export type AccumulatedData = { unifiedMapNode: CodeMapNode | undefined; unifiedFileMeta: FileMeta | undefined }
-
-export const accumulatedDataSelector = createSelector(
-	metricDataSelector,
-	visibleFileStatesSelector,
-	attributeTypesSelector,
-	blacklistSelector,
-	metricNamesSelector,
-	(metricData, fileStates, attributeTypes, blacklist, metricNames) => {
-		if (!fileStatesAvailable(fileStates) || !metricData.nodeMetricData) {
-			return accumulatedDataFallback
-		}
-
-		const data = _getUndecoratedAccumulatedData(clone(fileStates))
-		if (!data?.map) {
-			return accumulatedDataFallback
-		}
-
-		NodeDecorator.decorateMap(data.map, metricData, blacklist)
-		addEdgeMetricsForLeaves(metricData.nodeEdgeMetricsMap, data.map, metricNames)
-		NodeDecorator.decorateParentNodesWithAggregatedAttributes(data.map, isDeltaState(fileStates), attributeTypes)
-
-		return {
-			unifiedMapNode: data.map,
-			unifiedFileMeta: data.fileMeta
-		}
-	}
-)
-
-export const _getUndecoratedAccumulatedData = (fileStates: FileState[]) => {
-	if (isPartialState(fileStates)) {
-		return AggregationGenerator.calculateAggregationFile(fileStates)
-	}
-	if (isDeltaState(fileStates)) {
-		const [reference, comparison] = fileStates
-		if (comparison && reference.file.map.name !== comparison.file.map.name) {
-			return AggregationGenerator.calculateAggregationFile(fileStates)
-		}
-		return getDeltaFile(fileStates)
-	}
-}

package/app/codeCharta/state/selectors/accumulatedData/codeMapNodes.selector.ts

@@ -1,11 +0,0 @@
-import { AccumulatedData, accumulatedDataSelector } from "./accumulatedData.selector"
-import { getAllNodes } from "../../../util/codeMapHelper"
-import { CodeMapNode } from "../../../codeCharta.model"
-import { createSelector } from "@ngrx/store"
-
-export const codeMapNodesSelector = createSelector(
-	accumulatedDataSelector,
-	(accumulatedData: Pick<AccumulatedData, "unifiedMapNode">): CodeMapNode[] => {
-		return getAllNodes(accumulatedData.unifiedMapNode)
-	}
-)

package/app/codeCharta/state/selectors/accumulatedData/idToNode.selector.spec.ts

@@ -1,15 +0,0 @@
-import { VALID_NODES_WITH_ID } from "../../../util/dataMocks"
-import { _calculateIdToNode } from "./idToNode.selector"
-
-describe("idToNodeSelector", () => {
-	it("should return an empty Map if there is no unifiedMapNode", () => {
-		expect(_calculateIdToNode({ unifiedMapNode: undefined }).size).toBe(0)
-	})
-
-	it("should include root node and its children", () => {
-		const idToNode = _calculateIdToNode({ unifiedMapNode: VALID_NODES_WITH_ID })
-		expect(idToNode.size).toBe(2)
-		expect(idToNode.get(0)).toEqual(VALID_NODES_WITH_ID)
-		expect(idToNode.get(1)).toEqual(VALID_NODES_WITH_ID.children[0])
-	})
-})

package/app/codeCharta/state/selectors/accumulatedData/idToNode.selector.ts

@@ -1,18 +0,0 @@
-import { createSelector } from "@ngrx/store"
-import { hierarchy } from "d3-hierarchy"
-import { CodeMapNode } from "../../../codeCharta.model"
-import { AccumulatedData, accumulatedDataSelector } from "./accumulatedData.selector"
-
-export const _calculateIdToNode = (accumulatedData: Pick<AccumulatedData, "unifiedMapNode">): Map<number, CodeMapNode> => {
-	if (!accumulatedData.unifiedMapNode) {
-		return new Map()
-	}
-
-	const idToNode: Map<number, CodeMapNode> = new Map([[accumulatedData.unifiedMapNode.id, accumulatedData.unifiedMapNode]])
-	for (const { data } of hierarchy(accumulatedData.unifiedMapNode)) {
-		idToNode.set(data.id, data)
-	}
-	return idToNode
-}
-
-export const idToNodeSelector = createSelector(accumulatedDataSelector, _calculateIdToNode)

package/app/codeCharta/state/selectors/accumulatedData/metricData/edgeMetricData.calculator.spec.ts

@@ -1,46 +0,0 @@
-import { calculateEdgeMetricData } from "./edgeMetricData.calculator"
-import { FILE_STATES, VALID_NODE_WITH_PATH } from "../../../../util/dataMocks"
-import { FileState } from "../../../../model/files/files"
-import { clone } from "../../../../util/clone"
-
-describe("edgeMetricDataCalculator", () => {
-	let fileStates: FileState[]
-
-	beforeEach(() => {
-		fileStates = clone(FILE_STATES)
-		fileStates[0].file.map = clone(VALID_NODE_WITH_PATH)
-	})
-
-	it("should create correct edge Metrics", () => {
-		const { edgeMetricData } = calculateEdgeMetricData(fileStates, [])
-
-		expect(edgeMetricData.map(x => x.name)).toContain("pairingRate")
-		expect(edgeMetricData.map(x => x.name)).toContain("otherMetric")
-	})
-
-	it("should calculate correct maximum value for edge Metrics", () => {
-		const { edgeMetricData } = calculateEdgeMetricData(fileStates, [])
-
-		expect(edgeMetricData.find(x => x.name === "pairingRate").maxValue).toEqual(2)
-		expect(edgeMetricData.find(x => x.name === "otherMetric").maxValue).toEqual(1)
-	})
-
-	it("should sort the metrics after calculating them", () => {
-		const { edgeMetricData } = calculateEdgeMetricData(fileStates, [])
-
-		expect(edgeMetricData).toHaveLength(3)
-		expect(edgeMetricData[0].name).toBe("avgCommits")
-		expect(edgeMetricData[1].name).toBe("otherMetric")
-		expect(edgeMetricData[2].name).toBe("pairingRate")
-	})
-
-	it("should provide nodeEdgeMetricsMap", () => {
-		const { nodeEdgeMetricsMap } = calculateEdgeMetricData(fileStates, [])
-
-		const pairingRateMapKeys = [...nodeEdgeMetricsMap.get("pairingRate").keys()]
-
-		expect(pairingRateMapKeys[0]).toEqual("/root/big leaf")
-		expect(pairingRateMapKeys[1]).toEqual("/root/Parent Leaf/small leaf")
-		expect(pairingRateMapKeys[2]).toEqual("/root/Parent Leaf/other small leaf")
-	})
-})

package/app/codeCharta/state/selectors/accumulatedData/metricData/edgeMetricData.calculator.ts

@@ -1,95 +0,0 @@
-import { hierarchy } from "d3-hierarchy"
-import { BlacklistItem, Edge, EdgeMetricCount, EdgeMetricData } from "../../../../codeCharta.model"
-import { FileState } from "../../../../model/files/files"
-import { isPathBlacklisted } from "../../../../util/codeMapHelper"
-import { sortByMetricName } from "./sortByMetricName"
-
-export type EdgeMetricCountMap = Map<string, EdgeMetricCount>
-export type NodeEdgeMetricsMap = Map<string, EdgeMetricCountMap>
-
-export function calculateEdgeMetricData(visibleFileStates: FileState[], blacklist: BlacklistItem[]) {
-	const nodeEdgeMetricsMap: NodeEdgeMetricsMap = new Map()
-
-	const allFilePaths: Set<string> = new Set()
-
-	for (const { file } of visibleFileStates) {
-		for (const { data } of hierarchy(file.map)) {
-			allFilePaths.add(data.path)
-		}
-	}
-
-	for (const fileState of visibleFileStates) {
-		for (const edge of fileState.file.settings.fileSettings.edges) {
-			if (bothNodesAssociatedAreVisible(edge, allFilePaths, blacklist)) {
-				// TODO: We likely only need the attributes once per file.
-				for (const edgeMetric of Object.keys(edge.attributes)) {
-					const edgeMetricEntry = updateEntryForMetric(nodeEdgeMetricsMap, edgeMetric)
-					addEdgeToNodes(edgeMetricEntry, edge.fromNodeName, edge.toNodeName)
-				}
-			}
-		}
-	}
-	const newEdgeMetricData = getMetricDataFromMap(nodeEdgeMetricsMap)
-	sortByMetricName(newEdgeMetricData)
-	return {
-		edgeMetricData: newEdgeMetricData,
-		nodeEdgeMetricsMap
-	}
-}
-
-function bothNodesAssociatedAreVisible(edge: Edge, filePaths: Set<string>, blacklist: BlacklistItem[]) {
-	if (filePaths.has(edge.fromNodeName) && filePaths.has(edge.toNodeName)) {
-		return !isPathBlacklisted(edge.fromNodeName, blacklist, "exclude") && !isPathBlacklisted(edge.toNodeName, blacklist, "exclude")
-	}
-	return false
-}
-
-function updateEntryForMetric(nodeEdgeMetricsMap: NodeEdgeMetricsMap, edgeMetricName: string) {
-	let nodeEdgeMetric = nodeEdgeMetricsMap.get(edgeMetricName)
-	if (!nodeEdgeMetric) {
-		nodeEdgeMetric = new Map()
-		nodeEdgeMetricsMap.set(edgeMetricName, nodeEdgeMetric)
-	}
-	return nodeEdgeMetric
-}
-
-function addEdgeToNodes(edgeMetricEntry: EdgeMetricCountMap, fromNode: string, toNode: string) {
-	const fromNodeEdgeMetric = edgeMetricEntry.get(fromNode)
-	if (fromNodeEdgeMetric === undefined) {
-		edgeMetricEntry.set(fromNode, { incoming: 0, outgoing: 1 })
-	} else {
-		fromNodeEdgeMetric.outgoing += 1
-	}
-
-	const toNodeEdgeMetric = edgeMetricEntry.get(toNode)
-	if (toNodeEdgeMetric === undefined) {
-		edgeMetricEntry.set(toNode, { incoming: 1, outgoing: 0 })
-	} else {
-		toNodeEdgeMetric.incoming += 1
-	}
-}
-
-function getMetricDataFromMap(nodeEdgeMetricsMap: NodeEdgeMetricsMap) {
-	const metricData: EdgeMetricData[] = []
-
-	for (const [edgeMetric, occurrences] of nodeEdgeMetricsMap) {
-		let maximumMetricValue = 0
-		let minimumMetricValue = Number.MIN_SAFE_INTEGER
-		for (const value of occurrences.values()) {
-			const combinedValue = value.incoming + value.outgoing
-			if (combinedValue > maximumMetricValue) {
-				maximumMetricValue = combinedValue
-			}
-			if (combinedValue <= minimumMetricValue) {
-				minimumMetricValue = combinedValue
-			}
-		}
-		metricData.push({
-			name: edgeMetric,
-			maxValue: maximumMetricValue,
-			minValue: minimumMetricValue
-		})
-	}
-
-	return metricData
-}

package/app/codeCharta/state/selectors/accumulatedData/metricData/metricData.selector.ts

@@ -1,12 +0,0 @@
-import { createSelector } from "@ngrx/store"
-import { blacklistSelector } from "../../../store/fileSettings/blacklist/blacklist.selector"
-import { visibleFileStatesSelector } from "../../visibleFileStates.selector"
-import { calculateEdgeMetricData } from "./edgeMetricData.calculator"
-import { calculateNodeMetricData } from "./nodeMetricData.calculator"
-
-export const metricDataSelector = createSelector(visibleFileStatesSelector, blacklistSelector, (visibleFileStates, blacklist) => {
-	return {
-		nodeMetricData: calculateNodeMetricData(visibleFileStates, blacklist),
-		...calculateEdgeMetricData(visibleFileStates, blacklist)
-	}
-})

package/app/codeCharta/state/selectors/accumulatedData/metricData/metricNames.selector.spec.ts

@@ -1,16 +0,0 @@
-import { CcState } from "../../../../codeCharta.model"
-import { metricDataSelector } from "./metricData.selector"
-import { metricNamesSelector } from "./metricNames.selector"
-
-const mockedMetricDataSelector = metricDataSelector as unknown as jest.Mock
-jest.mock("./metricData.selector", () => ({
-	metricDataSelector: jest.fn()
-}))
-
-describe("metricNamesSelector", () => {
-	it("should get the names of the metrics", () => {
-		mockedMetricDataSelector.mockImplementationOnce(() => ({ edgeMetricData: [{ name: "metricOfTruth" }, { name: "otherMetric" }] }))
-
-		expect(metricNamesSelector({} as unknown as CcState)).toEqual(["metricOfTruth", "otherMetric"])
-	})
-})

package/app/codeCharta/state/selectors/accumulatedData/metricData/metricNames.selector.ts

@@ -1,4 +0,0 @@
-import { createSelector } from "@ngrx/store"
-import { metricDataSelector } from "./metricData.selector"
-
-export const metricNamesSelector = createSelector(metricDataSelector, metricData => metricData.edgeMetricData.map(x => x.name))

package/app/codeCharta/state/selectors/accumulatedData/metricData/nodeMetricData.calculator.spec.ts

@@ -1,63 +0,0 @@
-import { TEST_DELTA_MAP_A, VALID_NODE_WITH_ROOT_UNARY } from "../../../../util/dataMocks"
-import { FileSelectionState, FileState } from "../../../../model/files/files"
-import { NodeDecorator } from "../../../../util/nodeDecorator"
-import { clone } from "../../../../util/clone"
-import { calculateNodeMetricData, UNARY_METRIC } from "./nodeMetricData.calculator"
-
-describe("nodeMetricDataCalculator", () => {
-	let fileState: FileState
-
-	beforeEach(() => {
-		const file = clone(TEST_DELTA_MAP_A)
-		NodeDecorator.decorateMapWithPathAttribute(file)
-		fileState = {
-			file,
-			selectedAs: FileSelectionState.Partial
-		}
-	})
-
-	it("should return a sorted array of metricData sorted by name calculated from visibleFileStates", () => {
-		const expected = [
-			{ maxValue: 1000, minValue: 10, name: "functions" },
-			{ maxValue: 100, minValue: 1, name: "mcc" },
-			{ maxValue: 100, minValue: 30, name: "rloc" },
-			{ maxValue: 1, minValue: 1, name: UNARY_METRIC }
-		]
-
-		const result = calculateNodeMetricData([fileState], [])
-
-		expect(result).toEqual(expected)
-	})
-
-	it("should ignore blacklisted nodes", () => {
-		const expected = [
-			{ maxValue: 1000, minValue: 100, name: "functions" },
-			{ maxValue: 100, minValue: 10, name: "mcc" },
-			{ maxValue: 70, minValue: 30, name: "rloc" },
-			{ maxValue: 1, minValue: 1, name: UNARY_METRIC }
-		]
-
-		const result = calculateNodeMetricData([fileState], [{ path: "root/big leaf", type: "exclude" }])
-
-		expect(result).toEqual(expected)
-	})
-
-	it("should always add unary metric if it's not included yet", () => {
-		const result = calculateNodeMetricData([fileState], [])
-
-		expect(result.filter(x => x.name === UNARY_METRIC)).toHaveLength(1)
-	})
-
-	it("should not add unary metric a second time if the cc.json already contains unary", () => {
-		fileState.file.map = VALID_NODE_WITH_ROOT_UNARY
-
-		const result = calculateNodeMetricData([fileState], [])
-
-		expect(result.filter(x => x.name === UNARY_METRIC).length).toBe(1)
-	})
-
-	it("should return empty metricData when there are no files selected. If it would contain default metrics someone might falsely assume all parsing was already done", () => {
-		const result = calculateNodeMetricData([], [])
-		expect(result.length).toBe(0)
-	})
-})