Make .allDependencyTypings() respect path mappings

packages/definitions-parser/src/get-affected-packages.ts

@@ -94,8 +94,8 @@ function getReverseDependencies(
       }
     }
     for (const dependencyName of typing.testDependencies) {
-      const latest: PackageId = { name: dependencyName, version: "*" };
-      const dependencies = map.get(packageIdToKey(allPackages.tryResolve(latest)));
+      const version = typing.pathMappings.find(({ packageName }) => packageName === dependencyName)?.version || "*";
+      const dependencies = map.get(packageIdToKey(allPackages.tryResolve({ name: dependencyName, version })));
       if (dependencies) {
         dependencies[1].add(typing.id);
       }

packages/definitions-parser/src/mocks.ts

@@ -214,6 +214,32 @@ export * from "moment"`
   hasDependency.set("tsconfig.json", tsconfig(["has-dependency-tests.ts"]));
   hasDependency.set("package.json", `{ "private": true, "dependencies": { "moment": "*" } }`);
 
+  const hasOlderTestDependency = dt.pkgDir("has-older-test-dependency");
+  hasOlderTestDependency.set(
+    "index.d.ts",
+    `// Type definitions for has-older-test-dependency
+// Project: https://github.com/baz/foo
+// Definitions by: My Self <https://github.com/me>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+`
+  );
+  hasOlderTestDependency.set(
+    "has-older-test-dependency-tests.ts",
+    `import "jquery";
+`
+  );
+  hasOlderTestDependency.set(
+    "tsconfig.json",
+    JSON.stringify({
+      compilerOptions: {
+        paths: {
+          jquery: ["jquery/v1"]
+        }
+      },
+      files: ["index.d.ts", "has-older-test-dependency-tests.ts"]
+    })
+  );
+
   const jquery = dt.pkgDir("jquery");
   jquery.set(
     "JQuery.d.ts",

packages/definitions-parser/src/packages.ts

@@ -129,7 +129,8 @@ export class AllPackages {
     for (const name of pkg.testDependencies) {
       const versions = this.data.get(getMangledNameForScopedPackage(name));
       if (versions) {
-        yield versions.getLatest();
+        const version = pkg.pathMappings.find(({ packageName }) => packageName === name)?.version;
+        yield version ? versions.get(version) : versions.getLatest();
       }
     }
   }

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

@@ -3,13 +3,20 @@ import { NotNeededPackage, TypesDataFile, AllPackages } from "../src/packages";
 import { testo, createTypingsVersionRaw } from "./utils";
 
 const typesData: TypesDataFile = {
-  jquery: createTypingsVersionRaw("jquery", {}, []),
-  known: createTypingsVersionRaw("known", { jquery: { major: 1 } }, []),
-  "known-test": createTypingsVersionRaw("known-test", {}, ["jquery"]),
-  "most-recent": createTypingsVersionRaw("most-recent", { jquery: "*" }, []),
-  unknown: createTypingsVersionRaw("unknown", { "COMPLETELY-UNKNOWN": { major: 1 } }, []),
-  "unknown-test": createTypingsVersionRaw("unknown-test", {}, ["WAT"])
+  "has-older-test-dependency": createTypingsVersionRaw(
+    "has-older-test-dependency",
+    {},
+    ["jquery"],
+    [{ packageName: "jquery", version: { major: 1 } }]
+  ),
+  jquery: createTypingsVersionRaw("jquery", {}, [], []),
+  known: createTypingsVersionRaw("known", { jquery: { major: 1 } }, [], []),
+  "known-test": createTypingsVersionRaw("known-test", {}, ["jquery"], []),
+  "most-recent": createTypingsVersionRaw("most-recent", { jquery: "*" }, [], []),
+  unknown: createTypingsVersionRaw("unknown", { "COMPLETELY-UNKNOWN": { major: 1 } }, [], []),
+  "unknown-test": createTypingsVersionRaw("unknown-test", {}, ["WAT"], [])
 };
+typesData.jquery["2.0"] = { ...typesData.jquery["1.0"], libraryMajorVersion: 2 };
 
 const notNeeded = [
   new NotNeededPackage({
@@ -23,14 +30,29 @@ const allPackages = AllPackages.from(typesData, notNeeded);
 
 testo({
   updatedPackage() {
-    const affected = getAffectedPackages(allPackages, [{ name: "jquery", version: { major: 1 } }]);
-    expect(affected.changedPackages.length).toEqual(1);
-    expect((affected.changedPackages[0] as any).data).toEqual(typesData.jquery["1.0.0"]);
-    expect(affected.dependentPackages.length).toEqual(3);
+    const { changedPackages, dependentPackages } = getAffectedPackages(allPackages, [
+      { name: "jquery", version: { major: 2 } }
+    ]);
+    expect(changedPackages.map(({ id }) => id)).toEqual([{ name: "jquery", version: { major: 2, minor: 0 } }]);
+    expect((changedPackages[0] as any).data).toEqual(typesData.jquery["2.0"]);
+    expect(dependentPackages.map(({ id }) => id)).toEqual([
+      { name: "known-test", version: { major: 1, minor: 0 } },
+      { name: "most-recent", version: { major: 1, minor: 0 } }
+    ]);
   },
   deletedPackage() {
-    const affected = getAffectedPackages(allPackages, [{ name: "WAT", version: "*" }]);
-    expect(affected.changedPackages.length).toEqual(0);
-    expect(affected.dependentPackages.length).toEqual(1);
+    const { changedPackages, dependentPackages } = getAffectedPackages(allPackages, [{ name: "WAT", version: "*" }]);
+    expect(changedPackages.map(({ id }) => id)).toEqual([]);
+    expect(dependentPackages.map(({ id }) => id)).toEqual([{ name: "unknown-test", version: { major: 1, minor: 0 } }]);
+  },
+  olderVersion() {
+    const { changedPackages, dependentPackages } = getAffectedPackages(allPackages, [
+      { name: "jquery", version: { major: 1 } }
+    ]);
+    expect(changedPackages.map(({ id }) => id)).toEqual([{ name: "jquery", version: { major: 1, minor: 0 } }]);
+    expect(dependentPackages.map(({ id }) => id)).toEqual([
+      { name: "has-older-test-dependency", version: { major: 1, minor: 0 } },
+      { name: "known", version: { major: 1, minor: 0 } }
+    ]);
   }
 });

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

@@ -1,6 +1,26 @@
 import { createMockDT } from "../src/mocks";
 import { getTypingInfo } from "../src/lib/definition-parser";
-import { TypingsVersions } from "../src/packages";
+import { AllPackages, TypingsVersions } from "../src/packages";
+import { parseDefinitions } from "../src/parse-definitions";
+import { quietLoggerWithErrors } from "@definitelytyped/utils";
+
+describe(AllPackages, () => {
+  let allPackages: AllPackages;
+
+  beforeAll(async () => {
+    const dt = createMockDT();
+    dt.addOldVersionOfPackage("jquery", "1");
+    const [log] = quietLoggerWithErrors();
+    allPackages = await parseDefinitions(dt.fs, undefined, log);
+  });
+
+  it("applies path mappings to test dependencies", () => {
+    const pkg = allPackages.tryGetLatestVersion("has-older-test-dependency")!;
+    expect(Array.from(allPackages.allDependencyTypings(pkg), ({ id }) => id)).toEqual([
+      { name: "jquery", version: { major: 1, minor: 0 } }
+    ]);
+  });
+});
 
 describe(TypingsVersions, () => {
   let versions: TypingsVersions;

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

@@ -20,7 +20,7 @@ testo({
     const log = quietLoggerWithErrors()[0];
     const defs = await parseDefinitions(createMockDT().fs, undefined, log);
     expect(defs.allNotNeeded().length).toBe(1);
-    expect(defs.allTypings().length).toBe(4);
+    expect(defs.allTypings().length).toBe(5);
     const j = defs.tryGetLatestVersion("jquery");
     expect(j).toBeDefined();
     expect(j!.fullNpmName).toContain("types");

packages/definitions-parser/test/utils.ts

@@ -1,4 +1,4 @@
-import { TypingsVersionsRaw, License, DependencyVersion } from "../src/packages";
+import { TypingsVersionsRaw, License, DependencyVersion, PathMapping } from "../src/packages";
 
 export function testo(o: { [s: string]: () => void }) {
   for (const k of Object.keys(o)) {
@@ -9,18 +9,19 @@ export function testo(o: { [s: string]: () => void }) {
 export function createTypingsVersionRaw(
   name: string,
   dependencies: { readonly [name: string]: DependencyVersion },
-  testDependencies: string[]
+  testDependencies: string[],
+  pathMappings: PathMapping[]
 ): TypingsVersionsRaw {
   return {
-    "1.0.0": {
+    "1.0": {
       libraryName: name,
       typingsPackageName: name,
       dependencies,
       testDependencies,
       files: ["index.d.ts"],
       libraryMajorVersion: 1,
       libraryMinorVersion: 0,
-      pathMappings: [],
+      pathMappings,
       contributors: [{ name: "Bender", url: "futurama.com", githubUsername: "bender" }],
       minTsVersion: "2.3",
       typesVersions: [],