Copy definitions-parser tests back in

packages/definitions-parser/.gitignore

@@ -0,0 +1,5 @@
+cache/
+data/
+logs/
+output/
+validateOutput/

packages/definitions-parser/src/index.ts

@@ -1,4 +1,5 @@
-export * from "./dataFile";
-export * from "./getDefinitelyTyped";
-export * from "./parseDefinitions";
+export * from "./data-file";
+export * from "./get-definitely-typed";
+export * from "./parse-definitions";
+export * from "./mocks";
 export * from "./packages";

packages/definitions-parser/src/lib/definition-parser-worker.ts

@@ -1,7 +1,7 @@
 import assert = require("assert");
 import process = require("process");
 import { logUncaughtErrors } from "@definitelytyped/utils";
-import { getLocallyInstalledDefinitelyTyped } from "../getDefinitelyTyped";
+import { getLocallyInstalledDefinitelyTyped } from "../get-definitely-typed";
 import { getTypingInfo } from "./definition-parser";
 
 // This file is "called" by runWithChildProcesses from parse-definition.ts

packages/definitions-parser/src/packages.ts

@@ -1,7 +1,7 @@
 import assert = require("assert");
 import { AllTypeScriptVersion, Author, TypeScriptVersion } from "@definitelytyped/header-parser";
 import { FS, mapValues, assertSorted, unmangleScopedPackage, joinPaths, Semver } from "@definitelytyped/utils";
-import { readDataFile } from "./dataFile";
+import { readDataFile } from "./data-file";
 import { outputDirPath, scopeName } from "./lib/settings";
 
 export class AllPackages {

packages/definitions-parser/src/parse-definitions.ts

@@ -1,5 +1,5 @@
 import { FS, LoggerWithErrors, filterNAtATimeOrdered, runWithChildProcesses } from "@definitelytyped/utils";
-import { writeDataFile } from "./dataFile";
+import { writeDataFile } from "./data-file";
 import { getTypingInfo } from "./lib/definition-parser";
 import { definitionParserWorkerFilename } from "./lib/definition-parser-worker";
 import { AllPackages, readNotNeededPackages, typesDataFilename, TypingsVersionsRaw } from "./packages";

packages/definitions-parser/test/definition-parser.test.ts

@@ -0,0 +1,95 @@
+import { createMockDT } from "../src/mocks";
+import { getTypingInfo } from "../src/lib/definition-parser";
+
+describe(getTypingInfo, () => {
+    it("keys data by major.minor version", () => {
+        const dt = createMockDT();
+        dt.addOldVersionOfPackage("jquery", "1.42");
+        dt.addOldVersionOfPackage("jquery", "2");
+        const info = getTypingInfo("jquery", dt.pkgFS("jquery"));
+
+        expect(Object.keys(info).sort()).toEqual(["1.42", "2.0", "3.3"]);
+    });
+
+    describe("concerning multiple versions", () => {
+        it("records what the version directory looks like on disk", () => {
+            const dt = createMockDT();
+            dt.addOldVersionOfPackage("jquery", "2");
+            dt.addOldVersionOfPackage("jquery", "1.5");
+            const info = getTypingInfo("jquery", dt.pkgFS("jquery"));
+
+            expect(info).toEqual({
+                "1.5": expect.objectContaining({
+                    libraryVersionDirectoryName: "1.5",
+                }),
+                "2.0": expect.objectContaining({
+                    libraryVersionDirectoryName: "2",
+                }),
+                "3.3": expect.objectContaining({
+                    // The latest version does not have its own version directory
+                    libraryVersionDirectoryName: undefined,
+                }),
+            });
+        });
+
+        it("records a path mapping to the version directory", () => {
+            const dt = createMockDT();
+            dt.addOldVersionOfPackage("jquery", "2");
+            dt.addOldVersionOfPackage("jquery", "1.5");
+            const info = getTypingInfo("jquery", dt.pkgFS("jquery"));
+
+            expect(info).toEqual({
+                "1.5": expect.objectContaining({
+                    pathMappings: [{
+                        packageName: "jquery",
+                        version: { major: 1, minor: 5 },
+                    }],
+                }),
+                "2.0": expect.objectContaining({
+                    pathMappings: [{
+                        packageName: "jquery",
+                        version: { major: 2, minor: undefined },
+                    }],
+                }),
+                "3.3": expect.objectContaining({
+                    // The latest version does not have path mappings of its own
+                    pathMappings: [],
+                }),
+            });
+        });
+
+        describe("validation thereof", () => {
+            it("throws if a directory exists for the latest major version", () => {
+                const dt = createMockDT();
+                dt.addOldVersionOfPackage("jquery", "3");
+
+                expect(() => {
+                    getTypingInfo("jquery", dt.pkgFS("jquery"));
+                }).toThrow(
+                    "The latest version is 3.3, so the subdirectory 'v3' is not allowed; " +
+                        "since it applies to any 3.* version, up to and including 3.3.",
+                );
+            });
+
+            it("throws if a directory exists for the latest minor version", () => {
+                const dt = createMockDT();
+                dt.addOldVersionOfPackage("jquery", "3.3");
+
+                expect(() => {
+                    getTypingInfo("jquery", dt.pkgFS("jquery"));
+                }).toThrow(
+                    "The latest version is 3.3, so the subdirectory 'v3.3' is not allowed.",
+                );
+            });
+
+            it("does not throw when a minor version is older than the latest", () => {
+                const dt = createMockDT();
+                dt.addOldVersionOfPackage("jquery", "3.0");
+
+                expect(() => {
+                    getTypingInfo("jquery", dt.pkgFS("jquery"));
+                }).not.toThrow();
+            });
+        });
+    });
+});

packages/definitions-parser/test/get-definitely-typed.test.ts

@@ -0,0 +1,31 @@
+import { getDefinitelyTyped } from "../src/get-definitely-typed";
+import { loggerWithErrors, Dir, FS, InMemoryFS } from "@definitelytyped/utils";
+import { testo } from "./utils";
+
+testo({
+    async downloadDefinitelyTyped() {
+        const dt = await getDefinitelyTyped({
+            definitelyTypedPath: undefined,
+            parseInParallel: false,
+            progress: false,
+        }, loggerWithErrors()[0]);
+        expect(dt.exists("types")).toBe(true);
+        expect(dt.exists("buncho")).toBe(false);
+    },
+    createDirs() {
+        const root = new Dir(undefined);
+        root.set("file1.txt", "ok");
+        expect(root.has("file1.txt")).toBe(true);
+        expect(root.get("file1.txt")).toBe("ok");
+    },
+    simpleMemoryFS() {
+        const root = new Dir(undefined);
+        root.set("file1.txt", "ok");
+        const dir = root.subdir("sub1");
+        dir.set("file2.txt", "x");
+        const fs: FS = new InMemoryFS(root, "test/");
+        expect(fs.exists("file1.txt")).toBe(true);
+        expect(fs.readFile("file1.txt")).toBe("ok");
+        expect(fs.readFile("sub1/file2.txt")).toBe("x");
+    },
+});

packages/definitions-parser/test/module-info.test.ts

@@ -0,0 +1,78 @@
+import * as ts from "typescript";
+import { Dir, InMemoryFS } from "@definitelytyped/utils";
+import { createMockDT } from "../src/mocks";
+import { testo } from "./utils";
+import { allReferencedFiles, getModuleInfo, getTestDependencies } from "../src/lib/module-info";
+
+const fs = createMockDT().fs;
+function getBoringReferences() {
+    return allReferencedFiles(["index.d.ts", "boring-tests.ts"], fs.subDir("types").subDir("boring"), "boring", "types/boring");
+}
+testo({
+    allReferencedFilesFromTsconfigFiles() {
+        const { types, tests } = getBoringReferences();
+        expect(Array.from(types.keys())).toEqual(["index.d.ts", "secondary.d.ts", "quaternary.d.ts", "tertiary.d.ts", "commonjs.d.ts", "v1.d.ts"]);
+        expect(Array.from(tests.keys())).toEqual(["boring-tests.ts"]);
+    },
+    allReferencedFilesFromTestIncludesSecondaryInternalFiles() {
+        const { types, tests } = allReferencedFiles(["boring-tests.ts"], fs.subDir("types").subDir("boring"), "boring", "types/boring");
+        expect(Array.from(types.keys())).toEqual(["secondary.d.ts", "quaternary.d.ts", "tertiary.d.ts", "commonjs.d.ts", "v1.d.ts"]);
+        expect(Array.from(tests.keys())).toEqual(["boring-tests.ts"]);
+    },
+    allReferencedFilesFromTsconfigGlobal() {
+        const { types, tests } = allReferencedFiles(["jquery-tests.ts", "index.d.ts"], fs.subDir("types").subDir("jquery"), "jquery", "types/jquery");
+        expect(Array.from(types.keys())).toEqual(["index.d.ts", "JQuery.d.ts"]);
+        expect(Array.from(tests.keys())).toEqual(["jquery-tests.ts"]);
+    },
+    allReferencedFilesFromTestIncludesSecondaryTripleSlashTypes() {
+        const { types, tests } = allReferencedFiles(
+            ["globby-tests.ts", "test/other-tests.ts"],
+            fs.subDir("types").subDir("globby"),
+            "globby",
+            "types/globby",
+        );
+        expect(Array.from(types.keys())).toEqual(["merges.d.ts"]);
+        expect(Array.from(tests.keys())).toEqual(["globby-tests.ts", "test/other-tests.ts"]);
+    },
+    getModuleInfoWorksWithOtherFiles() {
+        const { types } = getBoringReferences();
+        // written as if it were from OTHER_FILES.txt
+        types.set(
+            "untested.d.ts",
+            ts.createSourceFile("untested.d.ts", fs.subDir("types").subDir("boring").readFile("untested.d.ts"), ts.ScriptTarget.Latest, false),
+        );
+        const i = getModuleInfo("boring", types);
+        expect(i.dependencies).toEqual(new Set(["manual", "react", "react-default", "things", "vorticon"]));
+    },
+    getModuleInfoForNestedTypeReferences() {
+        const { types } = allReferencedFiles(
+            ["index.d.ts", "globby-tests.ts", "test/other-tests.ts"],
+            fs.subDir("types").subDir("globby"),
+            "globby",
+            "types/globby",
+        );
+        expect(Array.from(types.keys())).toEqual(["index.d.ts", "sneaky.d.ts", "merges.d.ts"]);
+        const i = getModuleInfo("globby", types);
+        expect(i.dependencies).toEqual(new Set(["andere"]));
+    },
+    versionTypeRefThrows() {
+        const fail = new Dir(undefined);
+        const memFS = new InMemoryFS(fail, "typeref-fails");
+        fail.set("index.d.ts", `// Type definitionssrc/ for fail 1.0
+// Project: https://youtube.com/s-fails
+// Definitions by: Type Ref Fails <https://github.com/typeref-fails>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+/// <reference types="elser/v3" />
+`);
+        const { types } = allReferencedFiles(["index.d.ts"], memFS, "typeref-fails", "types/typeref-fails");
+        expect(Array.from(types.keys())).toEqual(["index.d.ts"]);
+        expect(() => getModuleInfo("typeref-fails", types)).toThrow("do not directly import specific versions of another types package");
+    },
+    getTestDependenciesWorks() {
+        const { types, tests } = getBoringReferences();
+        const i = getModuleInfo("boring", types);
+        const d = getTestDependencies("boring", types, tests.keys(), i.dependencies, fs.subDir("types").subDir("boring"));
+        expect(d).toEqual(new Set(["super-big-fun-hus"]));
+    },
+});

packages/definitions-parser/test/packages.test.ts

@@ -0,0 +1,47 @@
+import { createMockDT } from "../src/mocks";
+import { getTypingInfo } from "../src/lib/definition-parser";
+import { TypingsVersions } from "../src/packages";
+
+describe(TypingsVersions, () => {
+    let versions: TypingsVersions;
+
+    beforeAll(() => {
+        const dt = createMockDT();
+        dt.addOldVersionOfPackage("jquery", "1");
+        dt.addOldVersionOfPackage("jquery", "2");
+        dt.addOldVersionOfPackage("jquery", "2.5");
+        versions = new TypingsVersions(getTypingInfo("jquery", dt.pkgFS("jquery")));
+    });
+
+    it("sorts the data from latest to oldest version", () => {
+        expect(Array.from(versions.getAll()).map(v => v.major)).toEqual([3, 2, 2, 1]);
+    });
+
+    it("returns the latest version", () => {
+        expect(versions.getLatest().major).toEqual(3);
+    });
+
+    it("finds the latest version when any version is wanted", () => {
+        expect(versions.get("*").major).toEqual(3);
+    });
+
+    it("finds the latest minor version for the given major version", () => {
+        expect(versions.get({ major: 2 }).major).toEqual(2);
+        expect(versions.get({ major: 2 }).minor).toEqual(5);
+    });
+
+    it("finds a specific version", () => {
+        expect(versions.get({ major: 2, minor: 0 }).major).toEqual(2);
+        expect(versions.get({ major: 2, minor: 0 }).minor).toEqual(0);
+    });
+
+    it("formats a version directory names", () => {
+        expect(versions.get({ major: 2, minor: 0 }).versionDirectoryName).toEqual("v2");
+        expect(versions.get({ major: 2, minor: 0 }).subDirectoryPath).toEqual("jquery/v2");
+    });
+
+    it("formats missing version error nicely", () => {
+        expect(() => versions.get({ major: 111, minor: 1001 })).toThrow("Could not find version 111.1001");
+        expect(() => versions.get({ major: 111 })).toThrow("Could not find version 111.*");
+    });
+});

packages/definitions-parser/test/parse-definitions.test.ts

@@ -0,0 +1,30 @@
+import { createMockDT } from "../src/mocks";
+import { parseDefinitions } from "../src/parse-definitions";
+import { loggerWithErrors } from "@definitelytyped/utils";
+import { testo } from "./utils";
+
+testo({
+    // async parseDefinitions() {
+    //     const log = loggerWithErrors()[0]
+    //     const dt = await getDefinitelyTyped(Options.defaults, log);
+    //     const defs = await parseDefinitions(dt, undefined, log)
+    //     expect(defs.allNotNeeded().length).toBeGreaterThan(0)
+    //     expect(defs.allTypings().length).toBeGreaterThan(5000)
+    //     const j = defs.tryGetLatestVersion("jquery")
+    //     expect(j).toBeDefined()
+    //     expect(j!.fullNpmName).toContain("types")
+    //     expect(j!.fullNpmName).toContain("jquery")
+    //     expect(defs.allPackages().length).toEqual(defs.allTypings().length + defs.allNotNeeded().length)
+    // },
+    async mockParse() {
+        const log = loggerWithErrors()[0];
+        const defs = await parseDefinitions(createMockDT().fs, undefined, log);
+        expect(defs.allNotNeeded().length).toBe(1);
+        expect(defs.allTypings().length).toBe(3);
+        const j = defs.tryGetLatestVersion("jquery");
+        expect(j).toBeDefined();
+        expect(j!.fullNpmName).toContain("types");
+        expect(j!.fullNpmName).toContain("jquery");
+        expect(defs.allPackages().length).toEqual(defs.allTypings().length + defs.allNotNeeded().length);
+    },
+});

packages/definitions-parser/test/tsconfig.json

@@ -7,6 +7,6 @@
   },
   "references": [
     { "path": ".." },
-    { "path": "../../definitions-parser" }
+    { "path": "../../utils" }
   ]
 }

packages/definitions-parser/test/utils.ts

@@ -0,0 +1,5 @@
+export function testo(o: { [s: string]: () => void }) {
+  for (const k of Object.keys(o)) {
+      test(k, o[k], 100_000);
+  }
+}

packages/publisher/test/generate-packages.test.ts

@@ -1,7 +1,7 @@
 import { createNotNeededPackageJSON, createPackageJSON, createReadme, getLicenseFileText } from "../src/generate-packages";
 import { Registry } from "../src/lib/common";
 import { AllPackages, License, NotNeededPackage, readNotNeededPackages, TypesDataFile, TypingsData, TypingsDataRaw } from "@definitelytyped/definitions-parser";
-import { createMockDT } from "../src/mocks";
+import { createMockDT } from "@definitelytyped/definitions-parser";
 import { testo } from "./utils";
 
 function createRawPackage(license: License): TypingsDataRaw {