codecharta-visualization 1.119.1 → 1.120.1

package/app/codeCharta/ui/ribbonBar/artificialIntelligence/selectors/artificialIntelligence.selector.spec.ts

@@ -1,65 +0,0 @@
-import { calculate } from "./artificialIntelligence.selector"
-import { VALID_NODE_JAVA } from "../../../../util/dataMocks"
-import { BlacklistItem, NodeType } from "../../../../codeCharta.model"
-
-describe("ArtificialIntelligenceSelector", () => {
-	it("should return undefined when no unifiedMapNode is available", () => {
-		const actual = calculate({ unifiedMapNode: undefined }, [])
-
-		expect(actual).toBeUndefined()
-	})
-
-	it("should calculate suspicious metrics and risk profile when experimental features are enabled ", () => {
-		const actual = calculate({ unifiedMapNode: VALID_NODE_JAVA }, [])
-
-		expect(actual).toEqual({
-			analyzedProgrammingLanguage: "java",
-			riskProfile: { highRisk: 37, lowRisk: 46, moderateRisk: 17, veryHighRisk: 0 },
-			suspiciousMetricSuggestionLinks: [
-				{ from: 365, isOutlier: true, metric: "loc", to: 554 },
-				{ from: 29, isOutlier: true, metric: "functions", to: 44 },
-				{ from: 48, metric: "mcc", to: 71 }
-			],
-			unsuspiciousMetrics: ["rloc (Real Lines of Code)"],
-			untrackedMetrics: []
-		})
-	})
-
-	it("should return untracked metrics", () => {
-		VALID_NODE_JAVA.children[0].children.map(object => {
-			object.attributes.unknownMetric = 2569
-		})
-		const actual = calculate({ unifiedMapNode: VALID_NODE_JAVA }, [])
-
-		expect(actual).toEqual({
-			analyzedProgrammingLanguage: "java",
-			riskProfile: { highRisk: 37, lowRisk: 46, moderateRisk: 17, veryHighRisk: 0 },
-			suspiciousMetricSuggestionLinks: [
-				{ from: 365, isOutlier: true, metric: "loc", to: 554 },
-				{ from: 29, isOutlier: true, metric: "functions", to: 44 },
-				{ from: 48, metric: "mcc", to: 71 }
-			],
-			unsuspiciousMetrics: ["rloc (Real Lines of Code)"],
-			untrackedMetrics: ["unknownMetric"]
-		})
-	})
-
-	it("should ignore excluded nodes", () => {
-		const blacklist: BlacklistItem[] = [{ path: "file1.java", type: "exclude" }]
-		const blacklistedNode = {
-			name: "file1.java",
-			path: "file1.java",
-			type: NodeType.FILE,
-			attributes: { rloc: 70, mcc: 1000 }
-		}
-
-		const actual = calculate({ unifiedMapNode: blacklistedNode }, blacklist)
-
-		expect(actual).toEqual({
-			riskProfile: undefined,
-			suspiciousMetricSuggestionLinks: [],
-			unsuspiciousMetrics: [],
-			untrackedMetrics: []
-		})
-	})
-})

package/app/codeCharta/ui/ribbonBar/artificialIntelligence/selectors/artificialIntelligence.selector.ts

@@ -1,98 +0,0 @@
-import {
-	AREA_METRIC,
-	aggregateRiskProfile,
-	EXCLUDED_FILE_EXTENSION,
-	HEIGHT_METRIC,
-	RiskProfile,
-	getPercentagesOfRiskProfile
-} from "./util/riskProfileHelper"
-import {
-	calculateSuspiciousMetrics,
-	findGoodAndBadMetrics,
-	setMetricValuesByLanguage,
-	MetricSuggestionParameters,
-	MetricValuesByLanguage
-} from "./util/suspiciousMetricsHelper"
-import { hierarchy } from "d3-hierarchy"
-import { BlacklistItem, CodeMapNode, NodeType } from "../../../../codeCharta.model"
-import { getMostFrequentLanguage } from "./util/mainProgrammingLanguageHelper"
-import { isPathBlacklisted } from "../../../../util/codeMapHelper"
-import { blacklistSelector } from "../../../../state/store/fileSettings/blacklist/blacklist.selector"
-import { AccumulatedData, accumulatedDataSelector } from "../../../../state/selectors/accumulatedData/accumulatedData.selector"
-import { createSelector } from "@ngrx/store"
-
-export type ArtificialIntelligenceData = {
-	analyzedProgrammingLanguage: string
-	suspiciousMetricSuggestionLinks: MetricSuggestionParameters[]
-	unsuspiciousMetrics: string[]
-	untrackedMetrics: string[]
-	riskProfile: RiskProfile
-}
-
-export const calculate = (
-	accumulatedData: Pick<AccumulatedData, "unifiedMapNode">,
-	blacklist: BlacklistItem[]
-): ArtificialIntelligenceData | undefined => {
-	if (!accumulatedData.unifiedMapNode) {
-		return
-	}
-
-	const artificialIntelligenceViewModel: ArtificialIntelligenceData = {
-		analyzedProgrammingLanguage: undefined,
-		suspiciousMetricSuggestionLinks: [],
-		unsuspiciousMetrics: [],
-		untrackedMetrics: [],
-		riskProfile: undefined
-	}
-
-	const numberOfFilesByLanguage = new Map<string, number>()
-	const rlocRisk = { lowRisk: 0, moderateRisk: 0, highRisk: 0, veryHighRisk: 0 }
-	let totalRloc = 0
-	let totalMcc = 0
-	const metricValuesByLanguage: MetricValuesByLanguage = {}
-
-	for (const { data } of hierarchy(accumulatedData.unifiedMapNode)) {
-		const fileExtension = getFileExtension(data.name)
-		if (data.type === NodeType.FILE && fileExtension !== undefined && !isPathBlacklisted(data.path, blacklist, "exclude")) {
-			const filesPerLanguage = numberOfFilesByLanguage.get(fileExtension) ?? 0
-			numberOfFilesByLanguage.set(fileExtension, filesPerLanguage + 1)
-			setMetricValuesByLanguage(data, metricValuesByLanguage, fileExtension)
-
-			if (isFileValid(data, fileExtension)) {
-				totalRloc += data.attributes[AREA_METRIC]
-				totalMcc += data.attributes[HEIGHT_METRIC]
-				aggregateRiskProfile(data, rlocRisk, fileExtension)
-			}
-		}
-	}
-
-	if (totalRloc > 0 && totalMcc > 0) {
-		artificialIntelligenceViewModel.riskProfile = getPercentagesOfRiskProfile(rlocRisk)
-	}
-
-	const mainProgrammingLanguage = getMostFrequentLanguage(numberOfFilesByLanguage)
-	artificialIntelligenceViewModel.analyzedProgrammingLanguage = mainProgrammingLanguage
-
-	if (mainProgrammingLanguage !== undefined) {
-		const metricAssessmentResults = findGoodAndBadMetrics(metricValuesByLanguage, mainProgrammingLanguage)
-		artificialIntelligenceViewModel.unsuspiciousMetrics = metricAssessmentResults.unsuspiciousMetrics
-		artificialIntelligenceViewModel.untrackedMetrics = metricAssessmentResults.untrackedMetrics
-		artificialIntelligenceViewModel.suspiciousMetricSuggestionLinks = calculateSuspiciousMetrics(metricAssessmentResults)
-	}
-
-	return artificialIntelligenceViewModel
-}
-
-function getFileExtension(fileName: string) {
-	return fileName.includes(".") ? fileName.slice(fileName.lastIndexOf(".") + 1) : undefined
-}
-
-function isFileValid(node: CodeMapNode, fileExtension: string) {
-	return (
-		node.attributes[HEIGHT_METRIC] !== undefined &&
-		node.attributes[AREA_METRIC] !== undefined &&
-		!EXCLUDED_FILE_EXTENSION.has(fileExtension)
-	)
-}
-
-export const artificialIntelligenceSelector = createSelector(accumulatedDataSelector, blacklistSelector, calculate)

package/app/codeCharta/ui/ribbonBar/artificialIntelligence/selectors/util/artificialIntelligence.metricThresholds.ts

@@ -1,136 +0,0 @@
-export interface Percentiles {
-	percentile70: number
-	percentile80: number
-	percentile90: number
-	percentile95: number
-}
-
-export interface MetricThresholds {
-	[key: string]: Percentiles
-}
-
-export interface MetricThresholdsByLanguage {
-	java: MetricThresholds
-	miscellaneous: MetricThresholds
-}
-
-export const metricThresholdsByLanguage: MetricThresholdsByLanguage = {
-	java: {
-		// Thresholds derived without any pre-clustering from benchmark data
-		//  that means that 241 heterogeneous open source projects were included in the benchmark:
-		//  e.g. young and old (2-10 years) old projects, projects with few lines of code or with quite a lot
-		//  on this basis thresholds were derived
-		mcc: {
-			percentile70: 48,
-			percentile80: 71,
-			percentile90: 117,
-			percentile95: 191
-		},
-		rloc: {
-			percentile70: 365,
-			percentile80: 554,
-			percentile90: 1001,
-			percentile95: 1665
-		},
-		loc: {
-			percentile70: 365,
-			percentile80: 554,
-			percentile90: 1001,
-			percentile95: 1665
-		},
-		cognitive_complexity: {
-			percentile70: 30,
-			percentile80: 56,
-			percentile90: 124,
-			percentile95: 226
-		},
-		code_smell: {
-			percentile70: 5,
-			percentile80: 9,
-			percentile90: 22,
-			percentile95: 50
-		},
-		comment_lines: {
-			percentile70: 35,
-			percentile80: 62,
-			percentile90: 135,
-			percentile95: 273
-		},
-		max_nesting_level: {
-			percentile70: 2,
-			percentile80: 3,
-			percentile90: 4,
-			percentile95: 5
-		},
-		functions: {
-			percentile70: 29,
-			percentile80: 44,
-			percentile90: 75,
-			percentile95: 126
-		},
-		statements: {
-			percentile70: 157,
-			percentile80: 245,
-			percentile90: 439,
-			percentile95: 727
-		}
-	},
-	miscellaneous: {
-		// No derived Thresholds for other programming languages than java
-		// Just use empirical thresholds
-		mcc: {
-			percentile70: 50,
-			percentile80: 70,
-			percentile90: 120,
-			percentile95: 190
-		},
-		rloc: {
-			percentile70: 370,
-			percentile80: 560,
-			percentile90: 1011,
-			percentile95: 1670
-		},
-		loc: {
-			percentile70: 370,
-			percentile80: 560,
-			percentile90: 1010,
-			percentile95: 1670
-		},
-		cognitive_complexity: {
-			percentile70: 35,
-			percentile80: 60,
-			percentile90: 130,
-			percentile95: 230
-		},
-		code_smell: {
-			percentile70: 6,
-			percentile80: 10,
-			percentile90: 25,
-			percentile95: 55
-		},
-		comment_lines: {
-			percentile70: 40,
-			percentile80: 65,
-			percentile90: 140,
-			percentile95: 275
-		},
-		max_nesting_level: {
-			percentile70: 3,
-			percentile80: 4,
-			percentile90: 5,
-			percentile95: 6
-		},
-		functions: {
-			percentile70: 30,
-			percentile80: 50,
-			percentile90: 80,
-			percentile95: 130
-		},
-		statements: {
-			percentile70: 160,
-			percentile80: 260,
-			percentile90: 440,
-			percentile95: 730
-		}
-	}
-}

package/app/codeCharta/ui/ribbonBar/artificialIntelligence/selectors/util/getMetricThresholds.ts

@@ -1,5 +0,0 @@
-import { metricThresholdsByLanguage } from "./artificialIntelligence.metricThresholds"
-
-export function getAssociatedMetricThresholds(programmingLanguage: string) {
-	return programmingLanguage === "java" ? metricThresholdsByLanguage.java : metricThresholdsByLanguage.miscellaneous
-}

package/app/codeCharta/ui/ribbonBar/artificialIntelligence/selectors/util/mainProgrammingLanguageHelper.spec.ts

@@ -1,17 +0,0 @@
-import { getMostFrequentLanguage } from "./mainProgrammingLanguageHelper"
-
-describe("mainProgrammingLanguageHelper", () => {
-	it("should get most frequently programming language", () => {
-		const numberOfFilesByLanguage = new Map<string, number>([
-			["java", 10],
-			["css", 9],
-			["html", 8]
-		])
-		expect(getMostFrequentLanguage(numberOfFilesByLanguage)).toBe("java")
-	})
-
-	it("should get undefined when a programming language is not detected", () => {
-		const numberOfFilesByLanguage = new Map<string, number>()
-		expect(getMostFrequentLanguage(numberOfFilesByLanguage)).toBeUndefined()
-	})
-})

package/app/codeCharta/ui/ribbonBar/artificialIntelligence/selectors/util/mainProgrammingLanguageHelper.ts

@@ -1,11 +0,0 @@
-export function getMostFrequentLanguage(numberOfFilesPerLanguage: Map<string, number>): string | undefined {
-	let language
-	let max = -1
-	for (const [key, filesPerLanguage] of numberOfFilesPerLanguage) {
-		if (max < filesPerLanguage) {
-			max = filesPerLanguage
-			language = key
-		}
-	}
-	return language
-}

package/app/codeCharta/ui/ribbonBar/artificialIntelligence/selectors/util/riskProfileHelper.spec.ts

@@ -1,67 +0,0 @@
-import { aggregateRiskProfile, getPercentagesOfRiskProfile, RiskProfile } from "./riskProfileHelper"
-import { CodeMapNode, NodeType } from "../../../../../codeCharta.model"
-import { metricThresholdsByLanguage } from "./artificialIntelligence.metricThresholds"
-
-describe("riskProfileHelper", () => {
-	it("should calculate risk profile for java files", () => {
-		const actualRlocRisk: RiskProfile = { lowRisk: 0, moderateRisk: 0, highRisk: 0, veryHighRisk: 0 }
-		const fileExtension = "java"
-		const nodes: CodeMapNode[] = [
-			{ name: "javaFile1", type: NodeType.FILE, attributes: { rloc: 1, mcc: 48 } },
-			{ name: "javaFile2", type: NodeType.FILE, attributes: { rloc: 10, mcc: 71 } },
-			{ name: "javaFile3", type: NodeType.FILE, attributes: { rloc: 100, mcc: 117 } },
-			{ name: "javaFile4", type: NodeType.FILE, attributes: { rloc: 1000, mcc: 191 } }
-		]
-
-		for (const node of nodes) {
-			aggregateRiskProfile(node, actualRlocRisk, fileExtension)
-		}
-
-		expect(actualRlocRisk).toEqual({ lowRisk: 1, moderateRisk: 10, highRisk: 100, veryHighRisk: 1000 })
-	})
-
-	it("should calculate risk profile for all occurring programming languages in files", () => {
-		const actualRiskProfile: RiskProfile = { lowRisk: 0, moderateRisk: 0, highRisk: 0, veryHighRisk: 0 }
-		const fileExtensions = ["java", "java", "java", "ts"]
-		const nodes: CodeMapNode[] = [
-			{
-				name: "javaFile1",
-				type: NodeType.FILE,
-				attributes: { rloc: 1, mcc: metricThresholdsByLanguage.java["mcc"].percentile70 }
-			},
-			{
-				name: "javaFile2",
-				type: NodeType.FILE,
-				attributes: { rloc: 10, mcc: metricThresholdsByLanguage.java["mcc"].percentile80 }
-			},
-			{
-				name: "javaFile3",
-				type: NodeType.FILE,
-				attributes: { rloc: 100, mcc: metricThresholdsByLanguage.java["mcc"].percentile90 }
-			},
-			{
-				name: "tsFile",
-				type: NodeType.FILE,
-				attributes: { rloc: 1000, mcc: metricThresholdsByLanguage.miscellaneous["mcc"].percentile90 }
-			}
-		]
-
-		for (const [index, node] of nodes.entries()) {
-			aggregateRiskProfile(node, actualRiskProfile, fileExtensions[index])
-		}
-
-		expect(actualRiskProfile).toEqual({ lowRisk: 1, moderateRisk: 10, highRisk: 1100, veryHighRisk: 0 })
-	})
-
-	it("should get percentages of risk profile", () => {
-		const rlocRisk: RiskProfile = { lowRisk: 1000, moderateRisk: 0, highRisk: 0, veryHighRisk: 1000 }
-		const totalRloc = Object.values(rlocRisk).reduce((a, b) => a + b)
-		const veryHighRiskRloc = totalRloc - rlocRisk.veryHighRisk
-		const veryHighRisk = Math.round((veryHighRiskRloc / totalRloc) * 100)
-		const expectedRiskProfile = { highRisk: 0, lowRisk: 100 - veryHighRisk, moderateRisk: 0, veryHighRisk }
-
-		const actualRiskProfile = getPercentagesOfRiskProfile(rlocRisk)
-
-		expect(actualRiskProfile).toEqual(expectedRiskProfile)
-	})
-})

package/app/codeCharta/ui/ribbonBar/artificialIntelligence/selectors/util/riskProfileHelper.ts

@@ -1,42 +0,0 @@
-import { CodeMapNode } from "../../../../../codeCharta.model"
-import percentRound from "percent-round"
-import { getAssociatedMetricThresholds } from "./getMetricThresholds"
-
-export interface RiskProfile {
-	lowRisk: number
-	moderateRisk: number
-	highRisk: number
-	veryHighRisk: number
-}
-
-export const HEIGHT_METRIC = "mcc"
-export const AREA_METRIC = "rloc"
-export const EXCLUDED_FILE_EXTENSION = new Set(["html", "sass", "css", "scss", "txt", "md", "json", undefined])
-
-export function aggregateRiskProfile(node: CodeMapNode, rlocRisk: RiskProfile, fileExtension: string) {
-	const languageSpecificThresholds = getAssociatedMetricThresholds(fileExtension)
-	const thresholds = languageSpecificThresholds[HEIGHT_METRIC]
-	const nodeMetricValue = node.attributes[HEIGHT_METRIC]
-	const nodeRlocValue = node.attributes[AREA_METRIC]
-
-	if (nodeMetricValue <= thresholds.percentile70) {
-		rlocRisk.lowRisk += nodeRlocValue
-	} else if (nodeMetricValue <= thresholds.percentile80) {
-		rlocRisk.moderateRisk += nodeRlocValue
-	} else if (nodeMetricValue <= thresholds.percentile90) {
-		rlocRisk.highRisk += nodeRlocValue
-	} else {
-		rlocRisk.veryHighRisk += nodeRlocValue
-	}
-}
-
-export function getPercentagesOfRiskProfile(rlocRisk: RiskProfile): RiskProfile {
-	const [lowRisk, moderateRisk, highRisk, veryHighRisk] = percentRound([
-		rlocRisk.lowRisk,
-		rlocRisk.moderateRisk,
-		rlocRisk.highRisk,
-		rlocRisk.veryHighRisk
-	])
-
-	return { lowRisk, moderateRisk, highRisk, veryHighRisk }
-}

package/app/codeCharta/ui/ribbonBar/artificialIntelligence/selectors/util/suspiciousMetricsHelper.spec.ts

@@ -1,197 +0,0 @@
-import {
-	calculateSuspiciousMetrics,
-	findGoodAndBadMetrics,
-	MetricAssessmentResults,
-	MetricValuesByLanguage,
-	setMetricValuesByLanguage
-} from "./suspiciousMetricsHelper"
-import { CodeMapNode, ColorRange, NodeType } from "../../../../../codeCharta.model"
-import { metricThresholdsByLanguage } from "./artificialIntelligence.metricThresholds"
-import { metricTitles } from "../../../../../util/metric/metricTitles"
-
-describe("suspiciousMetricsHelper", () => {
-	it("should set metrics by language when node has attributes", () => {
-		const actualMetricValuesByLanguage: MetricValuesByLanguage = {}
-		const nodes: CodeMapNode[] = [
-			{ name: "javaFile1", type: NodeType.FILE, attributes: { rloc: 1, mcc: 5 } },
-			{ name: "javaFile2", type: NodeType.FILE, attributes: { rloc: 10, mcc: 15 } },
-			{ name: "tsFile1", type: NodeType.FILE, attributes: { rloc: 20, mcc: 25 } },
-			{ name: "tsFile2", type: NodeType.FILE, attributes: { rloc: 30, mcc: 35 } }
-		]
-		const programmingLanguages: string[] = ["java", "java", "ts", "ts"]
-
-		for (const [index, node] of nodes.entries()) {
-			setMetricValuesByLanguage(node, actualMetricValuesByLanguage, programmingLanguages[index])
-		}
-
-		expect(actualMetricValuesByLanguage).toEqual({
-			java: {
-				rloc: [1, 10],
-				mcc: [5, 15]
-			},
-			ts: {
-				rloc: [20, 30],
-				mcc: [25, 35]
-			}
-		})
-	})
-
-	it("should not set metrics when node has no attributes", () => {
-		const actualMetricValuesByLanguage: MetricValuesByLanguage = {}
-		const nodes: CodeMapNode[] = [
-			{ name: "javaFile1", type: NodeType.FILE, attributes: {} },
-			{ name: "javaFile2", type: NodeType.FILE, attributes: {} },
-			{ name: "javaFile3", type: NodeType.FILE, attributes: {} },
-			{ name: "javaFile4", type: NodeType.FILE, attributes: {} }
-		]
-
-		for (const node of nodes) {
-			setMetricValuesByLanguage(node, actualMetricValuesByLanguage, "java")
-		}
-
-		expect(actualMetricValuesByLanguage).toEqual({})
-	})
-
-	it("should find unsuspicious metrics only of main programming language", () => {
-		const metricValuesByLanguage: MetricValuesByLanguage = {
-			java: { functions: [1, 10, 20, 29], rloc: [366, 554, 1001, 1002] },
-			ts: { functions: [1, 10, 20, 29], rloc: [366, 554, 1001, 1002] }
-		}
-
-		const expectedColorRange: ColorRange = {
-			from: metricThresholdsByLanguage.java.rloc.percentile70,
-			to: metricThresholdsByLanguage.java.rloc.percentile80
-		}
-		const expectedMetricAssessmentResults: MetricAssessmentResults = {
-			suspiciousMetrics: new Map<string, ColorRange>([["rloc", expectedColorRange]]),
-			unsuspiciousMetrics: ["functions (Number of Functions)"],
-			outliersThresholds: new Map<string, number>([["rloc", metricThresholdsByLanguage.java.rloc.percentile90]]),
-			untrackedMetrics: []
-		}
-
-		const actualAssessmentResults: MetricAssessmentResults = findGoodAndBadMetrics(metricValuesByLanguage, "java")
-
-		expect(actualAssessmentResults.unsuspiciousMetrics).toEqual(expectedMetricAssessmentResults.unsuspiciousMetrics)
-		expect(actualAssessmentResults.suspiciousMetrics).toEqual(expectedMetricAssessmentResults.suspiciousMetrics)
-		expect(actualAssessmentResults.outliersThresholds).toEqual(expectedMetricAssessmentResults.outliersThresholds)
-	})
-
-	it("should set unsuspicious metrics of main programming language", () => {
-		const metricValuesByLanguage: MetricValuesByLanguage = {
-			java: { mcc: [10, 20, 30, 48], rloc: [100, 200, 300, 365] },
-			ts: { functions: [10, 20, 30, 48], rloc: [100, 200, 300, 365] }
-		}
-
-		const actualAssessmentResults: MetricAssessmentResults = findGoodAndBadMetrics(metricValuesByLanguage, "java")
-
-		expect(actualAssessmentResults.unsuspiciousMetrics).toEqual([
-			`mcc (${metricTitles.get("mcc")})`,
-			`rloc (${metricTitles.get("rloc")})`
-		])
-	})
-
-	it("should set suspicious metrics of main programming language", () => {
-		const metricValuesByLanguage: MetricValuesByLanguage = {}
-		metricValuesByLanguage["java"] = { rloc: [366, 555, 1001, 1665] }
-		metricValuesByLanguage["ts"] = { functions: [1, 10, 20, 29], rloc: [366, 554, 1001, 1002] }
-		const expectedColorRange: ColorRange = {
-			from: metricThresholdsByLanguage.java.rloc.percentile70,
-			to: metricThresholdsByLanguage.java.rloc.percentile80
-		}
-		const expected = new Map<string, ColorRange>([["rloc", expectedColorRange]])
-		const actualAssessmentResults: MetricAssessmentResults = findGoodAndBadMetrics(metricValuesByLanguage, "java")
-
-		expect(actualAssessmentResults.suspiciousMetrics).toEqual(expected)
-	})
-
-	it("should mark metric as outlier when metric value is above percentile of 90 of main programming language", () => {
-		const metricValuesByLanguage: MetricValuesByLanguage = {}
-		metricValuesByLanguage["java"] = { rloc: [366, 555, 1001, 100_000] }
-		metricValuesByLanguage["ts"] = { functions: [1, 10, 20, 29], rloc: [366, 554, 1001, 1002] }
-
-		const expected = new Map<string, number>([["rloc", metricThresholdsByLanguage.java.rloc.percentile90]])
-		const actualAssessmentResults: MetricAssessmentResults = findGoodAndBadMetrics(metricValuesByLanguage, "java")
-
-		expect(actualAssessmentResults.outliersThresholds).toEqual(expected)
-	})
-
-	it("should get empty MetricAssessmentResults when no attributes are available", () => {
-		const metricValuesByLanguage: MetricValuesByLanguage = {}
-
-		const actualAssessmentResults: MetricAssessmentResults = findGoodAndBadMetrics(metricValuesByLanguage, "python")
-
-		expect(actualAssessmentResults).toEqual({
-			suspiciousMetrics: new Map<string, ColorRange>(),
-			unsuspiciousMetrics: [],
-			outliersThresholds: new Map<string, number>(),
-			untrackedMetrics: []
-		})
-	})
-
-	it("should get description of metric or else should write nothing", () => {
-		const metricValuesByLanguage: MetricValuesByLanguage = {}
-		metricValuesByLanguage["java"] = { rloc: [1, 1, 1, 1], cognitive_complexity: [3, 5, 1, 1] }
-
-		const actualAssessmentResults: MetricAssessmentResults = findGoodAndBadMetrics(metricValuesByLanguage, "java")
-
-		expect(actualAssessmentResults).toEqual({
-			suspiciousMetrics: new Map<string, ColorRange>(),
-			unsuspiciousMetrics: ["rloc (Real Lines of Code)", "cognitive_complexity"],
-			outliersThresholds: new Map<string, number>(),
-			untrackedMetrics: []
-		})
-	})
-
-	it("should calculate suspicious metrics", () => {
-		const colorRange: ColorRange = {
-			from: 1,
-			to: 10
-		}
-		const metricAssessmentResults: MetricAssessmentResults = {
-			suspiciousMetrics: new Map([["mcc", colorRange]]),
-			unsuspiciousMetrics: [],
-			outliersThresholds: new Map([["mcc", 1000]]),
-			untrackedMetrics: []
-		}
-
-		const actualMetricSuggestionParameter = calculateSuspiciousMetrics(metricAssessmentResults)
-
-		expect(actualMetricSuggestionParameter).toEqual([
-			{
-				from: 1,
-				isOutlier: true,
-				metric: "mcc",
-				to: 10
-			}
-		])
-	})
-
-	it("should calculate suspicious metrics sort by outlier", () => {
-		const colorRange: ColorRange = {
-			from: 1,
-			to: 10
-		}
-		const metricAssessmentResults: MetricAssessmentResults = {
-			suspiciousMetrics: new Map([
-				["mcc", colorRange],
-				["loc", colorRange],
-				["functions", colorRange]
-			]),
-			unsuspiciousMetrics: [],
-			outliersThresholds: new Map([
-				["mcc", 1000],
-				["loc", 2000]
-			]),
-			untrackedMetrics: []
-		}
-
-		const actualMetricSuggestionParameter = calculateSuspiciousMetrics(metricAssessmentResults)
-
-		expect(actualMetricSuggestionParameter[0].metric).toBe("mcc")
-		expect(actualMetricSuggestionParameter[0].isOutlier).toBe(true)
-		expect(actualMetricSuggestionParameter[1].metric).toBe("loc")
-		expect(actualMetricSuggestionParameter[1].isOutlier).toBe(true)
-		expect(actualMetricSuggestionParameter[2].metric).toBe("functions")
-		expect(actualMetricSuggestionParameter[2].isOutlier).toBeUndefined()
-	})
-})