codecharta-visualization 1.119.0 → 1.120.0

package/app/codeCharta/util/fileValidator.spec.ts

@@ -1,307 +0,0 @@
-import {
-	TEST_FILE_CONTENT,
-	TEST_FILE_CONTENT_INVALID_API,
-	TEST_FILE_CONTENT_INVALID_MAJOR_API,
-	TEST_FILE_CONTENT_INVALID_MINOR_API,
-	TEST_FILE_CONTENT_NO_API
-} from "./dataMocks"
-import { CodeMapNode, NameDataPair, NodeType } from "../codeCharta.model"
-import packageJson from "../../../package.json"
-import { checkErrors, checkWarnings, ERROR_MESSAGES } from "./fileValidator"
-import { fileWithFixedFolders, fileWithFixedOverlappingSubFolders } from "../resources/fixed-folders/fixed-folders-example"
-import { APIVersions, ExportCCFile } from "../codeCharta.api.model"
-import { clone } from "./clone"
-
-describe("FileValidator", () => {
-	let file: ExportCCFile
-
-	beforeEach(() => {
-		file = clone(TEST_FILE_CONTENT)
-	})
-
-	it("API version exists in package.json", () => {
-		expect(packageJson.codecharta.apiVersion).toEqual("1.3")
-	})
-
-	it("should throw on null", () => {
-		const expectedErrors = [ERROR_MESSAGES.fileIsInvalid]
-
-		expect(checkErrors(null)).toEqual(expectedErrors)
-	})
-
-	it("should throw when higher Major API", () => {
-		const nameDataPair: NameDataPair = {
-			fileName: "fileName",
-			fileSize: 30,
-			content: TEST_FILE_CONTENT_INVALID_MAJOR_API
-		}
-		const expectedErrors = [ERROR_MESSAGES.majorApiVersionIsOutdated]
-
-		expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-	})
-
-	it("should throw on warning with higher minor API version", () => {
-		const nameDataPair: NameDataPair = {
-			fileName: "fileName",
-			fileSize: 30,
-			content: TEST_FILE_CONTENT_INVALID_MINOR_API
-		}
-		const expectedWarnings = [`${ERROR_MESSAGES.minorApiVersionOutdated} Found: ${nameDataPair.content.apiVersion}`]
-
-		expect(checkWarnings(nameDataPair.content)).toEqual(expectedWarnings)
-	})
-
-	it("should throw on file missing API version", () => {
-		const nameDataPair: NameDataPair = {
-			fileName: "fileName",
-			fileSize: 30,
-			content: TEST_FILE_CONTENT_NO_API
-		}
-		const expectedErrors = [ERROR_MESSAGES.apiVersionIsInvalid]
-
-		expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-	})
-
-	it("should throw on file with wrong API version", () => {
-		const nameDataPair: NameDataPair = {
-			fileName: "fileName",
-			fileSize: 30,
-			content: TEST_FILE_CONTENT_INVALID_API
-		}
-		const expectedErrors = [ERROR_MESSAGES.apiVersionIsInvalid]
-
-		expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-	})
-
-	it("should not throw on a file with edges", () => {
-		file.edges = [
-			{
-				fromNodeName: "a",
-				toNodeName: "b",
-				attributes: {
-					avgCommits: 42,
-					pairingRate: 80
-				}
-			}
-		]
-
-		const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-
-		expect(checkErrors(nameDataPair.content)).toEqual([])
-		expect(checkWarnings(nameDataPair.content)).toEqual([])
-	})
-
-	it("should not throw on a file without edges", () => {
-		file.edges = undefined
-
-		const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-
-		expect(checkErrors(nameDataPair.content)).toEqual([])
-		expect(checkWarnings(nameDataPair.content)).toEqual([])
-	})
-
-	it("should not throw on a file when numbers are floating point values", () => {
-		file.nodes[0].children[0].attributes["rloc"] = 333.4
-
-		const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-
-		expect(checkErrors(nameDataPair.content)).toEqual([])
-		expect(checkWarnings(nameDataPair.content)).toEqual([])
-	})
-
-	it("should throw when children are not unique in name+type", () => {
-		file.nodes[0].children[0].name = "same"
-		file.nodes[0].children[0].type = NodeType.FILE
-		file.nodes[0].children[1].name = "same"
-		file.nodes[0].children[1].type = NodeType.FILE
-		const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-		const expectedErrors = [`${ERROR_MESSAGES.nodesNotUnique} Found duplicate of File with path: /root/same`]
-
-		expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-	})
-
-	it("should throw when nodes are empty", () => {
-		file.nodes = []
-		const nameDataPair: NameDataPair = { fileName: "", fileSize: 30, content: file }
-		const expectedErrors = [ERROR_MESSAGES.nodesEmpty]
-
-		expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-	})
-
-	it("should throw if nodes is not a node and therefore has no name or id", () => {
-		file.nodes[0] = {
-			// @ts-expect-error
-			something: "something"
-		}
-		const nameDataPair: NameDataPair = { fileName: "", fileSize: 30, content: file }
-		const expectedErrors = [
-			"Required error: nodes[0] should have required property 'name'",
-			"Required error: nodes[0] should have required property 'type'"
-		]
-
-		expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-	})
-
-	describe("fixed sub folders validation", () => {
-		it("should throw an error, if two sub folders horizontally overlap", () => {
-			file = clone(fileWithFixedOverlappingSubFolders)
-			const folder1: CodeMapNode = file.nodes[0].children[0].children[0]
-			const folder2: CodeMapNode = file.nodes[0].children[0].children[1]
-			const nameDataPair: NameDataPair = { fileName: "", fileSize: 30, content: file }
-			const expectedErrors = [
-				`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_1_1 ${JSON.stringify(
-					folder1.fixedPosition
-				)} and folder_1_2 ${JSON.stringify(folder2.fixedPosition)}`
-			]
-
-			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-		})
-	})
-
-	describe("fixed folders validation", () => {
-		let folder1: CodeMapNode
-		let folder2: CodeMapNode
-
-		beforeEach(() => {
-			file = clone(fileWithFixedFolders)
-			;[folder1, folder2] = file.nodes[0].children
-		})
-
-		it("should throw an error, if there are fixed folders, but not every folder on root is fixed", () => {
-			folder1.fixedPosition = undefined
-			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-			const expectedErrors = [`${ERROR_MESSAGES.notAllFoldersAreFixed} Found: folder_1`]
-
-			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-		})
-
-		it("should throw an error, if at least one fixed folder has a padding that is out of bounds", () => {
-			folder1.fixedPosition.left = -5
-			folder1.fixedPosition.width = 7
-			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-			const expectedErrors = [`${ERROR_MESSAGES.fixedFoldersOutOfBounds} Found: folder_1 ${JSON.stringify(folder1.fixedPosition)}`]
-
-			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-		})
-
-		it("should throw an error, if at least one fixed folder has a width or height that is out of bounds", () => {
-			folder1.fixedPosition.left = 10
-			folder1.fixedPosition.width = -50
-			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-			const expectedErrors = [`${ERROR_MESSAGES.fixedFoldersOutOfBounds} Found: folder_1 ${JSON.stringify(folder1.fixedPosition)}`]
-
-			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-		})
-
-		it("should throw an error, if at least one fixed folder exceeds the maximum coordinate of 100", () => {
-			folder1.fixedPosition.left = 99
-			folder1.fixedPosition.width = 2
-			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-			const expectedErrors = [`${ERROR_MESSAGES.fixedFoldersOutOfBounds} Found: folder_1 ${JSON.stringify(folder1.fixedPosition)}`]
-
-			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-		})
-
-		it("should throw an error, if two folders horizontally overlap", () => {
-			folder1.fixedPosition = {
-				left: 0,
-				top: 0,
-				width: 10,
-				height: 10
-			}
-			folder2.fixedPosition = {
-				left: 5,
-				top: 1,
-				width: 10,
-				height: 10
-			}
-			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-			const expectedErrors = [
-				`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_1 ${JSON.stringify(
-					folder1.fixedPosition
-				)} and folder_2 ${JSON.stringify(folder2.fixedPosition)}`
-			]
-
-			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-		})
-
-		it("should throw an error, if two folders vertically overlap", () => {
-			folder1.fixedPosition = {
-				left: 0,
-				top: 0,
-				width: 10,
-				height: 10
-			}
-			folder2.fixedPosition = {
-				left: 0,
-				top: 5,
-				width: 10,
-				height: 10
-			}
-			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-			const expectedErrors = [
-				`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_1 ${JSON.stringify(
-					folder1.fixedPosition
-				)} and folder_2 ${JSON.stringify(folder2.fixedPosition)}`
-			]
-			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-		})
-
-		it("should throw an error, if a folder is placed inside another", () => {
-			folder1.fixedPosition = {
-				left: 0,
-				top: 0,
-				width: 10,
-				height: 10
-			}
-			folder2.fixedPosition = {
-				left: 1,
-				top: 1,
-				width: 1,
-				height: 1
-			}
-			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-			const expectedErrors = [
-				`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_2 ${JSON.stringify(
-					folder2.fixedPosition
-				)} and folder_1 ${JSON.stringify(folder1.fixedPosition)}`
-			]
-
-			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-		})
-
-		it("should throw an error, if a folder has the same boundaries as another", () => {
-			folder1.fixedPosition = {
-				left: 0,
-				top: 0,
-				width: 10,
-				height: 10
-			}
-			folder2.fixedPosition = folder1.fixedPosition
-			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-			const expectedErrors = [
-				`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: folder_1 ${JSON.stringify(
-					folder1.fixedPosition
-				)} and folder_2 ${JSON.stringify(folder2.fixedPosition)}`
-			]
-
-			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-		})
-
-		it("should throw an error, if the major api version is smaller and fixed folders were defined", () => {
-			file.apiVersion = APIVersions.ZERO_POINT_ONE
-			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-			const expectedErrors = [`${ERROR_MESSAGES.fixedFoldersNotAllowed} Found: 0.1`]
-
-			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-		})
-
-		it("should throw an error, if the minor api version is smaller and fixed folders were defined", () => {
-			file.apiVersion = APIVersions.ONE_POINT_ONE
-			const nameDataPair: NameDataPair = { fileName: "fileName", fileSize: 30, content: file }
-			const expectedErrors = [`${ERROR_MESSAGES.fixedFoldersNotAllowed} Found: 1.1`]
-
-			expect(checkErrors(nameDataPair.content)).toEqual(expectedErrors)
-		})
-	})
-})

package/app/codeCharta/util/fileValidator.ts

@@ -1,222 +0,0 @@
-import { CodeMapNode, FixedPosition } from "../codeCharta.model"
-import Ajv from "ajv"
-import packageJson from "../../../package.json"
-import { ExportCCFile } from "../codeCharta.api.model"
-import jsonSchema from "./generatedSchema.json"
-import { isLeaf } from "./codeMapHelper"
-
-const latestApiVersion = packageJson.codecharta.apiVersion
-
-interface ApiVersion {
-	major: number
-	minor: number
-}
-
-export interface CCFileValidationResult {
-	fileName: string
-	errors: string[]
-	warnings: string[]
-}
-
-export const ERROR_MESSAGES = {
-	fileIsInvalid: "File is empty or invalid.",
-	apiVersionIsInvalid: "API Version is empty or invalid.",
-	majorApiVersionIsOutdated: "API Version Outdated: Update CodeCharta API Version to match cc.json.",
-	minorApiVersionOutdated: "Minor API Version Outdated.",
-	nodesNotUnique: "Node names in combination with node types are not unique.",
-	nodesEmpty: "The nodes array is empty. At least one node is required.",
-	notAllFoldersAreFixed: "If at least one direct sub-folder of root is marked as fixed, all direct sub-folders of root must be fixed.",
-	fixedFoldersOutOfBounds: "Coordinates of fixed folders must be within a range of 0 and 100.",
-	fixedFoldersOverlapped: "Folders may not overlap.",
-	fixedFoldersNotAllowed: "Fixated folders may not be defined in API-Version < 1.2.",
-	fileAlreadyExists: "File already exists.",
-	blacklistError: "Excluding all buildings is not possible."
-}
-
-export function checkWarnings(file: ExportCCFile) {
-	const warnings: string[] = []
-	if (!file) {
-		return warnings
-	}
-	if (fileHasHigherMinorVersion(file)) {
-		warnings.push(`${ERROR_MESSAGES.minorApiVersionOutdated} Found: ${file.apiVersion}`)
-	}
-	return warnings
-}
-
-export function checkErrors(file: ExportCCFile) {
-	const errors: string[] = []
-	switch (true) {
-		case !file:
-			errors.push(ERROR_MESSAGES.fileIsInvalid)
-			break
-		case !isValidApiVersion(file):
-			errors.push(ERROR_MESSAGES.apiVersionIsInvalid)
-			break
-		case fileHasHigherMajorVersion(file):
-			errors.push(ERROR_MESSAGES.majorApiVersionIsOutdated)
-			break
-	}
-	if (errors.length === 0) {
-		errors.push(...checkJsonSchema(file))
-	}
-	return errors
-}
-
-function checkJsonSchema(file: ExportCCFile) {
-	const errors: string[] = []
-	if (errors.length === 0) {
-		const ajv = new Ajv({ allErrors: true })
-		const validate = ajv.compile(jsonSchema)
-		const valid = validate(file)
-
-		if (!valid) {
-			errors.push(...validate.errors.map((error: Ajv.ErrorObject) => getValidationMessage(error)))
-		} else if (file.nodes.length === 0) {
-			errors.push(ERROR_MESSAGES.nodesEmpty)
-		} else {
-			errors.push(...validateAllNodesAreUnique(file.nodes[0]), ...validateFixedFolders(file))
-		}
-	}
-	return errors
-}
-
-function isValidApiVersion(file: ExportCCFile) {
-	const { apiVersion } = file
-	const hasApiVersion = apiVersion !== undefined
-	const versionRegExp = /\d+\.\d+/
-	const isValidVersion = versionRegExp.test(apiVersion)
-	return hasApiVersion && isValidVersion
-}
-
-function fileHasHigherMajorVersion(file: ExportCCFile) {
-	const apiVersion = getAsApiVersion(file.apiVersion)
-	return apiVersion.major > getAsApiVersion(latestApiVersion).major
-}
-
-function fileHasHigherMinorVersion(file: ExportCCFile) {
-	const apiVersion = getAsApiVersion(file.apiVersion)
-	return apiVersion.minor > getAsApiVersion(latestApiVersion).minor
-}
-
-export function getAsApiVersion(version: string): ApiVersion {
-	return {
-		major: Number(version.split(".")[0]),
-		minor: Number(version.split(".")[1])
-	}
-}
-
-function getValidationMessage(error: Ajv.ErrorObject) {
-	const errorType = error.keyword.charAt(0).toUpperCase() + error.keyword.slice(1)
-	const errorParameter = error.dataPath.slice(1)
-	return `${errorType} error: ${errorParameter} ${error.message}`
-}
-
-function validateAllNodesAreUnique(node: CodeMapNode) {
-	const errors: string[] = []
-	const names = new Set<string>()
-	names.add(`${node.name}|${node.type}`)
-	validateChildrenAreUniqueRecursive(node, errors, names, `/${node.name}`)
-	return errors
-}
-
-function validateChildrenAreUniqueRecursive(node: CodeMapNode, errors: string[], names: Set<string>, subPath: string) {
-	if (isLeaf(node)) {
-		return
-	}
-
-	for (const child of node.children) {
-		const path = `${subPath}/${child.name}`
-		if (names.has(`${path}|${child.type}`)) {
-			errors.push(`${ERROR_MESSAGES.nodesNotUnique} Found duplicate of ${child.type} with path: ${path}`)
-		} else {
-			names.add(`${path}|${child.type}`)
-			validateChildrenAreUniqueRecursive(child, errors, names, path)
-		}
-	}
-}
-
-function checkChildNodes(
-	childNodes: CodeMapNode[],
-	notFixed: string[],
-	file: ExportCCFile,
-	errors: string[],
-	outOfBounds: string[],
-	intersections: Set<string>
-) {
-	for (const node of childNodes) {
-		if (node.fixedPosition === undefined) {
-			notFixed.push(`${node.name}`)
-		} else {
-			const apiVersion = getAsApiVersion(file.apiVersion)
-			if (apiVersion.major < 1 || (apiVersion.major === 1 && apiVersion.minor < 2)) {
-				errors.push(`${ERROR_MESSAGES.fixedFoldersNotAllowed} Found: ${file.apiVersion}`)
-				return
-			}
-
-			if (isOutOfBounds(node)) {
-				outOfBounds.push(getFoundFolderMessage(node))
-			}
-
-			for (const node2 of childNodes) {
-				if (
-					node2.fixedPosition !== undefined &&
-					node !== node2 &&
-					rectanglesIntersect(node.fixedPosition, node2.fixedPosition) &&
-					!intersections.has(`${getFoundFolderMessage(node2)} and ${getFoundFolderMessage(node)}`)
-				) {
-					intersections.add(`${getFoundFolderMessage(node)} and ${getFoundFolderMessage(node2)}`)
-				}
-			}
-		}
-	}
-}
-
-function validateFixedFolders(file: ExportCCFile, childNodes: CodeMapNode[] = file.nodes[0].children) {
-	const errors: string[] = []
-	const notFixed: string[] = []
-	const outOfBounds: string[] = []
-	const intersections: Set<string> = new Set()
-
-	checkChildNodes(childNodes, notFixed, file, errors, outOfBounds, intersections)
-
-	if (notFixed.length > 0 && notFixed.length !== childNodes.length) {
-		errors.push(`${ERROR_MESSAGES.notAllFoldersAreFixed} Found: ${notFixed.join(", ")}`)
-	}
-
-	if (outOfBounds.length > 0) {
-		errors.push(`${ERROR_MESSAGES.fixedFoldersOutOfBounds} Found: ${outOfBounds.join(", ")}`)
-	}
-
-	if (intersections.size > 0) {
-		errors.push(`${ERROR_MESSAGES.fixedFoldersOverlapped} Found: ${[...intersections].join(", ")}`)
-	}
-
-	for (const node of childNodes) {
-		if (node.children) {
-			errors.push(...validateFixedFolders(file, node.children))
-		}
-	}
-	return errors
-}
-
-function getFoundFolderMessage(node: CodeMapNode) {
-	return `${node.name} ${JSON.stringify(node.fixedPosition)}`
-}
-
-function rectanglesIntersect(rect1: FixedPosition, rect2: FixedPosition) {
-	return (
-		isInRectangle(rect1.left, rect1.top, rect2) ||
-		isInRectangle(rect1.left, rect1.top + rect1.height, rect2) ||
-		isInRectangle(rect1.left + rect1.width, rect1.top, rect2) ||
-		isInRectangle(rect1.left + rect1.width, rect1.top + rect1.height, rect2)
-	)
-}
-
-function isInRectangle(x: number, y: number, rect: FixedPosition) {
-	return x >= rect.left && x <= rect.left + rect.width && y >= rect.top && y <= rect.top + rect.height
-}
-
-function isOutOfBounds({ fixedPosition: { left, top, width, height } }: CodeMapNode) {
-	return left < 0 || top < 0 || left + width > 100 || top + height > 100 || width < 0 || height < 0
-}

package/app/codeCharta/util/gameObjectsParser/__snapshots__/gameObjectsImporter.spec.ts.snap

@@ -1,121 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`GameObjectsImporter should parse gameObjects json to cc.json 1`] = `
-{
-  "checksum": "64ba632559688f092d2adf0dee446d7e",
-  "data": {
-    "apiVersion": "1.3",
-    "attributeTypes": {
-      "edges": {
-        "coupling": "relative",
-      },
-    },
-    "edges": [
-      {
-        "attributes": {
-          "coupling": 100,
-        },
-        "fromNodeName": "/base/root/CHANGELOG/CHANGELOG",
-        "toNodeName": "/base/root/visualization/packageLock/packageLock",
-      },
-    ],
-    "fileChecksum": "",
-    "nodes": [
-      {
-        "attributes": {},
-        "children": [
-          {
-            "attributes": {},
-            "children": [
-              {
-                "attributes": {},
-                "children": [
-                  {
-                    "attributes": {},
-                    "children": [
-                      {
-                        "attributes": {
-                          "height": 1,
-                        },
-                        "name": "ui",
-                        "type": "File",
-                      },
-                    ],
-                    "fixedPosition": {
-                      "height": 3.13,
-                      "left": 2.27,
-                      "top": 95.63,
-                      "width": 5.68,
-                    },
-                    "name": "ui",
-                    "type": "Folder",
-                  },
-                  {
-                    "attributes": {},
-                    "children": [
-                      {
-                        "attributes": {
-                          "height": 4,
-                        },
-                        "name": "packageLock",
-                        "type": "File",
-                      },
-                    ],
-                    "fixedPosition": {
-                      "height": 1.25,
-                      "left": 95.45,
-                      "top": 48.13,
-                      "width": 2.27,
-                    },
-                    "name": "packageLock",
-                    "type": "Folder",
-                  },
-                ],
-                "fixedPosition": {
-                  "height": 95.24,
-                  "left": 0.72,
-                  "top": 2.38,
-                  "width": 15.74,
-                },
-                "name": "visualization",
-                "type": "Folder",
-              },
-              {
-                "attributes": {},
-                "children": [
-                  {
-                    "attributes": {
-                      "height": 1,
-                    },
-                    "name": "CHANGELOG",
-                    "type": "File",
-                  },
-                ],
-                "fixedPosition": {
-                  "height": 2.98,
-                  "left": 98.39,
-                  "top": 48.51,
-                  "width": 0.89,
-                },
-                "name": "CHANGELOG",
-                "type": "Folder",
-              },
-            ],
-            "fixedPosition": {
-              "height": 30.05,
-              "left": 0,
-              "top": 34,
-              "width": 100,
-            },
-            "name": "root",
-            "type": "Folder",
-          },
-        ],
-        "name": "base",
-        "type": "Folder",
-      },
-    ],
-    "projectName": "GameObjects",
-  },
-}
-`;

package/app/codeCharta/util/gameObjectsParser/gameObjectsImporter.spec.ts

@@ -1,11 +0,0 @@
-import { TEST_GAMEOBJECTS_FILE } from "./gameObjectsMocks"
-import { clone } from "../clone"
-import { parseGameObjectsFile } from "./gameObjectsImporter"
-
-describe("GameObjectsImporter", () => {
-	it("should parse gameObjects json to cc.json", function () {
-		const gameObjectsFile = clone(TEST_GAMEOBJECTS_FILE)
-
-		expect(parseGameObjectsFile(JSON.stringify(gameObjectsFile))).toMatchSnapshot()
-	})
-})