chore: consider replacing any usage of any with unknown #59

test/common/testers/bindingTester.ts

@@ -10,6 +10,7 @@ import Abstract = interfaces.Abstract;
 import { mock, mockClear, mockDeep } from 'jest-mock-extended';
 import BindingToSyntax = interfaces.BindingToSyntax;
 import { mockFn } from '../safeMockFn';
+import { when } from 'jest-when';
 
 export type BinderFn = (bind: Bind) => void;
 
@@ -55,8 +56,8 @@ export const testNameOrMultiConstraint = (symbol: symbol, target: Abstract<any>,
   const matchesTagNameMock = mockFn<ReturnType<Request['target']['matchesTag']>>();
   const matchesTagMultiMock = mockFn<ReturnType<Request['target']['matchesTag']>>();
   const requestMock = mockDeep<Request>();
-  requestMock.target.matchesTag.calledWith(METADATA_KEY.NAMED_TAG).mockReturnValue(matchesTagNameMock);
-  requestMock.target.matchesTag.calledWith(METADATA_KEY.MULTI_INJECT_TAG).mockReturnValue(matchesTagMultiMock);
+  when(requestMock.target.matchesTag).calledWith(METADATA_KEY.NAMED_TAG).mockReturnValue(matchesTagNameMock);
+  when(requestMock.target.matchesTag).calledWith(METADATA_KEY.MULTI_INJECT_TAG).mockReturnValue(matchesTagMultiMock);
 
   beforeEach(() => {
     matchesTagNameMock.mockReset();

test/src/dependencyChecker/impl/packageInfoCache.spec.ts

@@ -0,0 +1,133 @@
+import { IPackageInfo } from '../../../../src/utils/packageInfo';
+import { mock, mockReset } from 'jest-mock-extended';
+import { DependencyVersion, IDependencyVersionRepositoryProvider } from '../../../../src/db';
+import { Repository } from 'typeorm';
+import { PackageInfoCache } from '../../../../src/dependencyChecker/impl/packageInfoCache';
+import { loggerFactory } from '../../../common/logger';
+import { isEqual } from '../../../common/isEqual';
+import { when } from 'jest-when';
+
+describe(`package info cache`, () => {
+  const packageInfoMock = mock<IPackageInfo>();
+  const repositoryMock = mock<Repository<DependencyVersion>>();
+  const dependencyVersionRepositoryProviderMock = mock<IDependencyVersionRepositoryProvider>();
+  dependencyVersionRepositoryProviderMock.getRepository.mockResolvedValue(repositoryMock);
+  let packageInfoCache: PackageInfoCache;
+
+  beforeEach(() => {
+    mockReset(packageInfoMock);
+    mockReset(repositoryMock);
+    packageInfoCache = new PackageInfoCache(packageInfoMock, dependencyVersionRepositoryProviderMock, loggerFactory);
+  });
+
+  it(`should memoize results`, async () => {
+    const dependencyVersion = new DependencyVersion({
+      version: `4.0.1`,
+      semver: `~4.0.0`,
+      name: `test dependency`,
+      repoUrl: null,
+      commitSha: null,
+      releaseDate: null,
+      engines: null,
+    });
+    const getOptions = { name: `test dependency`, semver: `~4.0.0` };
+    when(repositoryMock.findOne).calledWith(getOptions).mockResolvedValue(dependencyVersion);
+    const result = await packageInfoCache.getPackageInfo(getOptions);
+    expect(result).toEqual(dependencyVersion);
+    const result2 = await packageInfoCache.getPackageInfo(getOptions);
+    expect(result).toEqual(dependencyVersion);
+    expect(result).toBe(result2);
+    expect(repositoryMock.findOne).toBeCalledTimes(1);
+  });
+
+  it(`should return from cache`, async () => {
+    const dependencyVersion = new DependencyVersion({
+      version: `4.0.1`,
+      semver: `~4.0.0`,
+      name: `test dependency`,
+      repoUrl: null,
+      commitSha: null,
+      releaseDate: null,
+      engines: null,
+    });
+    const getOptions = { name: `test dependency`, semver: `~4.0.0` };
+    when(repositoryMock.findOne).calledWith(getOptions).mockResolvedValue(dependencyVersion);
+    const result = await packageInfoCache.getPackageInfo(getOptions);
+    expect(result).toEqual(dependencyVersion);
+  });
+
+  it(`should get info if not in cache`, async () => {
+    const packageInfo = {
+      version: `4.0.1`,
+      semver: `~4.0.0`,
+      name: `test dependency`,
+    };
+    const dependencyVersion = new DependencyVersion({
+      ...packageInfo,
+      repoUrl: null,
+      commitSha: null,
+      releaseDate: null,
+      engines: null,
+    });
+    const getOptions = { name: `test dependency`, semver: `~4.0.0` };
+    when(packageInfoMock.getPackageInfo)
+      .calledWith({ name: `test dependency`, semver: `~4.0.0` })
+      .mockResolvedValue(packageInfo);
+    const result = await packageInfoCache.getPackageInfo(getOptions);
+    expect(result).toEqual(dependencyVersion);
+    expect(repositoryMock.save).toBeCalledTimes(1);
+    expect(repositoryMock.save).toBeCalledWith(dependencyVersion);
+  });
+
+  it(`should get info if not cache throws`, async () => {
+    const packageInfo = {
+      version: `4.0.1`,
+      semver: `~4.0.0`,
+      name: `test dependency`,
+    };
+    const dependencyVersion = new DependencyVersion({
+      ...packageInfo,
+      repoUrl: null,
+      commitSha: null,
+      releaseDate: null,
+      engines: null,
+    });
+    const getOptions = { name: `test dependency`, semver: `~4.0.0` };
+    when(repositoryMock.findOne).calledWith(getOptions).mockRejectedValue(new Error(`dummy`));
+    packageInfoMock.getPackageInfo
+      .calledWith(isEqual({ name: `test dependency`, semver: `~4.0.0` }))
+      .mockResolvedValue(packageInfo);
+    const result = await packageInfoCache.getPackageInfo(getOptions);
+    expect(result).toEqual(dependencyVersion);
+    expect(repositoryMock.save).toBeCalledTimes(1);
+    expect(repositoryMock.save).toBeCalledWith(dependencyVersion);
+  });
+
+  it(`Should update commit`, async () => {
+    const dependencyVersion = new DependencyVersion({
+      version: `4.0.1`,
+      semver: `~4.0.0`,
+      name: `test dependency`,
+      repoUrl: null,
+      commitSha: null,
+      releaseDate: null,
+      engines: null,
+    });
+    const commitSha = `commitSha`;
+    await packageInfoCache.updateCommitSha({
+      dependencyVersion,
+      commitSha,
+    });
+    expect(dependencyVersion.commitSha).toBe(commitSha);
+    expect(repositoryMock.update).toBeCalledTimes(1);
+    expect(repositoryMock.update).toBeCalledWith(
+      {
+        semver: `~4.0.0`,
+        name: `test dependency`,
+      },
+      {
+        commitSha,
+      }
+    );
+  });
+});

test/src/resolvers/enginesResolver/impl/enginesResolver.spec.ts

@@ -2,7 +2,7 @@ import { EnginesResolver } from '../../../../../src/resolvers/enginesResolver/im
 import { mock, mockClear } from 'jest-mock-extended';
 import { INodeVersions } from '../../../../../src/utils/nodeVersions';
 import moment = require('moment');
-import { isEqual } from '../../../../common/isEqual';
+import { when } from 'jest-when';
 
 describe(`engines resolver`, () => {
   const nodeVersionsMock = mock<INodeVersions>();
@@ -65,7 +65,7 @@ describe(`engines resolver`, () => {
   });
 
   it(`should not match if range is not complete and releaseData exists but does not match`, async () => {
-    nodeVersionsMock.resolveStableVersion
+    when(nodeVersionsMock.resolveStableVersion)
       .calledWith({
         date: releaseDate,
       })
@@ -79,12 +79,10 @@ describe(`engines resolver`, () => {
   });
 
   it(`should match if range is not complete and releaseData exists and matches`, async () => {
-    nodeVersionsMock.resolveStableVersion
-      .calledWith(
-        isEqual({
-          date: releaseDate,
-        })
-      )
+    when(nodeVersionsMock.resolveStableVersion)
+      .calledWith({
+        date: releaseDate,
+      })
       .mockResolvedValue(`10`);
     const result = await enginesResolver.resolve({
       engines: `>=1 <=4 || >=6`,
@@ -95,12 +93,10 @@ describe(`engines resolver`, () => {
   });
 
   it(`should match if range is not complete and releaseData exists and matches exact`, async () => {
-    nodeVersionsMock.resolveStableVersion
-      .calledWith(
-        isEqual({
-          date: releaseDate,
-        })
-      )
+    when(nodeVersionsMock.resolveStableVersion)
+      .calledWith({
+        date: releaseDate,
+      })
       .mockResolvedValue(`8`);
     const result = await enginesResolver.resolve({
       engines: `>=1 <=4 || >=6`,