refactor(internal): refactor local presets (#6183)

renovatebot · May 9, 2020 · bf35278 · bf35278
1 parent 39f03b2
commit bf35278
Show file tree

Hide file tree

Showing 12 changed files with 137 additions and 87 deletions.
diff --git a/lib/config/presets/common.ts b/lib/config/presets/common.ts
@@ -3,10 +3,12 @@ import { RenovateConfig } from '../common';
 // TODO: Proper typing
 export type Preset = RenovateConfig & Record<string, unknown>;
 
+export type PresetConfig = {
+  packageName: string;
+  presetName?: string;
+  baseConfig?: RenovateConfig;
+};
+
 export interface PresetApi {
-  getPreset(
-    pkgName: string,
-    presetName?: string,
-    baseConfig?: RenovateConfig
-  ): Promise<Preset> | Preset;
+  getPreset(config: PresetConfig): Promise<Preset> | Preset;
 }
diff --git a/lib/config/presets/github/index.spec.ts b/lib/config/presets/github/index.spec.ts
@@ -7,7 +7,6 @@ import * as _hostRules from '../../../util/host-rules';
 import * as github from '.';
 import { PartialDeep } from 'type-fest';
 
-jest.mock('../../../platform/github/gh-got-wrapper');
 jest.mock('../../../util/got');
 jest.mock('../../../util/host-rules');
 
@@ -38,34 +37,41 @@ describe('config/presets/github', () => {
       expect(res).toMatchSnapshot();
     });
   });
+
   describe('getPreset()', () => {
     it('passes up platform-failure', async () => {
       got.mockImplementationOnce(() => {
         throw new Error(PLATFORM_FAILURE);
       });
-      await expect(github.getPreset('some/repo')).rejects.toThrow(
-        PLATFORM_FAILURE
-      );
+      await expect(
+        github.getPreset({ packageName: 'some/repo' })
+      ).rejects.toThrow(PLATFORM_FAILURE);
     });
     it('tries default then renovate', async () => {
       got.mockImplementationOnce(() => {
         throw new Error();
       });
-      await expect(github.getPreset('some/repo')).rejects.toThrow();
+      await expect(
+        github.getPreset({ packageName: 'some/repo' })
+      ).rejects.toThrow();
     });
     it('throws if no content', async () => {
       got.mockImplementationOnce(() => ({
         body: {},
       }));
-      await expect(github.getPreset('some/repo')).rejects.toThrow();
+      await expect(
+        github.getPreset({ packageName: 'some/repo' })
+      ).rejects.toThrow();
     });
     it('throws if fails to parse', async () => {
       got.mockImplementationOnce(() => ({
         body: {
           content: Buffer.from('not json').toString('base64'),
         },
       }));
-      await expect(github.getPreset('some/repo')).rejects.toThrow();
+      await expect(
+        github.getPreset({ packageName: 'some/repo' })
+      ).rejects.toThrow();
     });
     it('should return default.json', async () => {
       hostRules.find.mockReturnValueOnce({ token: 'abc' });
@@ -74,7 +80,7 @@ describe('config/presets/github', () => {
           content: Buffer.from('{"foo":"bar"}').toString('base64'),
         },
       }));
-      const content = await github.getPreset('some/repo');
+      const content = await github.getPreset({ packageName: 'some/repo' });
       expect(content).toEqual({ foo: 'bar' });
     });
     it('should query preset within the file', async () => {
@@ -84,7 +90,10 @@ describe('config/presets/github', () => {
           content: Buffer.from('{"somename":{"foo":"bar"}}').toString('base64'),
         },
       }));
-      const content = await github.getPreset('some/repo', 'somefile/somename');
+      const content = await github.getPreset({
+        packageName: 'some/repo',
+        presetName: 'somefile/somename',
+      });
       expect(content).toEqual({ foo: 'bar' });
     });
     it('should query subpreset', async () => {
@@ -96,15 +105,15 @@ describe('config/presets/github', () => {
           ).toString('base64'),
         },
       }));
-      let content = await github.getPreset(
-        'some/repo',
-        'somefile/somename/somesubname'
-      );
+      let content = await github.getPreset({
+        packageName: 'some/repo',
+        presetName: 'somefile/somename/somesubname',
+      });
       expect(content).toEqual({ foo: 'bar' });
-      content = await github.getPreset(
-        'some/repo',
-        'somefile/wrongname/somesubname'
-      );
+      content = await github.getPreset({
+        packageName: 'some/repo',
+        presetName: 'somefile/wrongname/somesubname',
+      });
       expect(content).toBeUndefined();
     });
     it('should return custom.json', async () => {
@@ -116,13 +125,17 @@ describe('config/presets/github', () => {
       }));
       try {
         global.appMode = true;
-        const content = await github.getPreset('some/repo', 'custom');
+        const content = await github.getPreset({
+          packageName: 'some/repo',
+          presetName: 'custom',
+        });
         expect(content).toEqual({ foo: 'bar' });
       } finally {
         delete global.appMode;
       }
     });
   });
+
   describe('getPresetFromEndpoint()', () => {
     it('uses custom endpoint', async () => {
       await github

diff --git a/lib/config/presets/github/index.ts b/lib/config/presets/github/index.ts
@@ -3,7 +3,7 @@ import { PLATFORM_TYPE_GITHUB } from '../../../constants/platforms';
 import { logger } from '../../../logger';
 import { Http, HttpOptions } from '../../../util/http';
 import { ensureTrailingSlash } from '../../../util/url';
-import { Preset } from '../common';
+import { Preset, PresetConfig } from '../common';
 
 const http = new Http(PLATFORM_TYPE_GITHUB);
 
@@ -50,7 +50,7 @@ export async function getPresetFromEndpoint(
   // eslint-disable-next-line no-param-reassign
   endpoint = ensureTrailingSlash(endpoint);
   const [fileName, presetName, subPresetName] = filePreset.split('/');
-  let jsonContent;
+  let jsonContent: any;
   if (fileName === 'default') {
     try {
       jsonContent = await fetchJSONFile(pkgName, 'default.json', endpoint);
@@ -75,9 +75,9 @@ export async function getPresetFromEndpoint(
   return jsonContent;
 }
 
-export async function getPreset(
-  pkgName: string,
-  presetName = 'default'
-): Promise<Preset> {
+export function getPreset({
+  packageName: pkgName,
+  presetName = 'default',
+}: PresetConfig): Promise<Preset> {
   return getPresetFromEndpoint(pkgName, presetName);
 }
diff --git a/lib/config/presets/gitlab/index.spec.ts b/lib/config/presets/gitlab/index.spec.ts
@@ -16,22 +16,29 @@ describe('config/presets/gitlab', () => {
   describe('getPreset()', () => {
     it('throws if non-default', async () => {
       await expect(
-        gitlab.getPreset('some/repo', 'non-default')
+        gitlab.getPreset({
+          packageName: 'some/repo',
+          presetName: 'non-default',
+        })
       ).rejects.toThrow();
     });
     it('throws if no content', async () => {
       glGot.mockResolvedValueOnce({
         body: {},
       });
-      await expect(gitlab.getPreset('some/repo')).rejects.toThrow();
+      await expect(
+        gitlab.getPreset({ packageName: 'some/repo' })
+      ).rejects.toThrow();
     });
     it('throws if fails to parse', async () => {
       glGot.mockResolvedValueOnce({
         body: {
           content: Buffer.from('not json').toString('base64'),
         },
       });
-      await expect(gitlab.getPreset('some/repo')).rejects.toThrow();
+      await expect(
+        gitlab.getPreset({ packageName: 'some/repo' })
+      ).rejects.toThrow();
     });
     it('should return the preset', async () => {
       glGot.mockResolvedValueOnce({
@@ -50,7 +57,7 @@ describe('config/presets/gitlab', () => {
           content: Buffer.from('{"foo":"bar"}').toString('base64'),
         },
       });
-      const content = await gitlab.getPreset('some/repo');
+      const content = await gitlab.getPreset({ packageName: 'some/repo' });
       expect(content).toEqual({ foo: 'bar' });
     });
   });

diff --git a/lib/config/presets/gitlab/index.ts b/lib/config/presets/gitlab/index.ts
@@ -1,7 +1,7 @@
 import { logger } from '../../../logger';
 import { api } from '../../../platform/gitlab/gl-got-wrapper';
 import { ensureTrailingSlash } from '../../../util/url';
-import { Preset } from '../common';
+import { Preset, PresetConfig } from '../common';
 
 const { get: glGot } = api;
 
@@ -67,9 +67,9 @@ export async function getPresetFromEndpoint(
   }
 }
 
-export async function getPreset(
-  pkgName: string,
-  presetName = 'default'
-): Promise<Preset> {
+export function getPreset({
+  packageName: pkgName,
+  presetName = 'default',
+}: PresetConfig): Promise<Preset> {
   return getPresetFromEndpoint(pkgName, presetName);
 }
diff --git a/lib/config/presets/index.spec.ts b/lib/config/presets/index.spec.ts
@@ -1,29 +1,30 @@
 import { RenovateConfig } from '..';
+import { mocked } from '../../../test/util';
 import presetIkatyang from './__fixtures__/renovate-config-ikatyang.json';
 import * as _npm from './npm';
 import * as presets from '.';
 
 jest.mock('./npm');
 jest.mock('./github');
 
-const npm: any = _npm;
+const npm = mocked(_npm);
 
-npm.getPreset = jest.fn((dep, presetName) => {
-  if (dep === 'renovate-config-ikatyang') {
+npm.getPreset = jest.fn(({ packageName, presetName }) => {
+  if (packageName === 'renovate-config-ikatyang') {
     return presetIkatyang.versions[presetIkatyang['dist-tags'].latest][
       'renovate-config'
     ][presetName];
   }
-  if (dep === 'renovate-config-notfound') {
+  if (packageName === 'renovate-config-notfound') {
     throw new Error('dep not found');
   }
-  if (dep === 'renovate-config-noconfig') {
+  if (packageName === 'renovate-config-noconfig') {
     throw new Error('preset renovate-config not found');
   }
-  if (dep === 'renovate-config-throw') {
+  if (packageName === 'renovate-config-throw') {
     throw new Error('whoops');
   }
-  if (dep === 'renovate-config-wrongpreset') {
+  if (packageName === 'renovate-config-wrongpreset') {
     throw new Error('preset not found');
   }
   return null;

diff --git a/lib/config/presets/index.ts b/lib/config/presets/index.ts
@@ -138,11 +138,11 @@ export async function getPreset(
 ): Promise<RenovateConfig> {
   logger.trace(`getPreset(${preset})`);
   const { presetSource, packageName, presetName, params } = parsePreset(preset);
-  let presetConfig = await presetSources[presetSource].getPreset(
+  let presetConfig = await presetSources[presetSource].getPreset({
     packageName,
     presetName,
-    baseConfig
-  );
+    baseConfig,
+  });
   logger.trace({ presetConfig }, `Found preset ${preset}`);
   if (params) {
     const argMapping = {};

diff --git a/lib/config/presets/internal/index.ts b/lib/config/presets/internal/index.ts
@@ -1,4 +1,4 @@
-import { Preset } from '../common';
+import { Preset, PresetConfig } from '../common';
 import * as configPreset from './config';
 import * as defaultPreset from './default';
 import * as dockerPreset from './docker';
@@ -21,9 +21,11 @@ export const groups: Record<string, Record<string, Preset>> = {
   schedule: schedulePreset.presets,
 };
 
-export function getPreset(
-  pkgName: string,
-  presetName: string
-): Preset | undefined {
-  return groups[pkgName] ? groups[pkgName][presetName] : undefined;
+export function getPreset({
+  packageName: pkgName,
+  presetName,
+}: PresetConfig): Preset | undefined {
+  return groups[pkgName]
+    ? groups[pkgName][presetName]
+    : /* istanbul ignore next */ undefined;
 }
diff --git a/lib/config/presets/local/index.spec.ts b/lib/config/presets/local/index.spec.ts
@@ -23,45 +23,68 @@ describe('config/presets/local', () => {
   describe('getPreset()', () => {
     it('throws for unsupported platform', async () => {
       await expect(
-        local.getPreset('some/repo', 'default', {
-          platform: 'unsupported-platform',
+        local.getPreset({
+          packageName: 'some/repo',
+          presetName: 'default',
+          baseConfig: {
+            platform: 'unsupported-platform',
+          },
         })
       ).rejects.toThrow();
     });
     it('throws for missing platform', async () => {
       await expect(
-        local.getPreset('some/repo', 'default', {
-          platform: undefined,
+        local.getPreset({
+          packageName: 'some/repo',
+          presetName: 'default',
+          baseConfig: {
+            platform: undefined,
+          },
         })
       ).rejects.toThrow();
     });
     it('forwards to gitlab', async () => {
-      const content = await local.getPreset('some/repo', '', {
-        platform: 'GitLab',
+      const content = await local.getPreset({
+        packageName: 'some/repo',
+        presetName: '',
+        baseConfig: {
+          platform: 'GitLab',
+        },
       });
       expect(gitlabGetPreset.mock.calls).toMatchSnapshot();
       expect(content).toMatchSnapshot();
     });
     it('forwards to custom gitlab', async () => {
-      const content = await local.getPreset('some/repo', '', {
-        platform: 'gitlab',
-        endpoint: 'https://gitlab.example.com/api/v4',
+      const content = await local.getPreset({
+        packageName: 'some/repo',
+        presetName: '',
+        baseConfig: {
+          platform: 'gitlab',
+          endpoint: 'https://gitlab.example.com/api/v4',
+        },
       });
       expect(gitlabGetPreset.mock.calls).toMatchSnapshot();
       expect(content).toMatchSnapshot();
     });
 
     it('forwards to github', async () => {
-      const content = await local.getPreset('some/repo', undefined, {
-        platform: 'github',
+      const content = await local.getPreset({
+        packageName: 'some/repo',
+        baseConfig: {
+          platform: 'github',
+        },
       });
       expect(githubGetPreset.mock.calls).toMatchSnapshot();
       expect(content).toMatchSnapshot();
     });
     it('forwards to custom github', async () => {
-      const content = await local.getPreset('some/repo', '', {
-        platform: 'GitHub',
-        endpoint: 'https://api.github.example.com',
+      const content = await local.getPreset({
+        packageName: 'some/repo',
+        presetName: '',
+        baseConfig: {
+          platform: 'github',
+          endpoint: 'https://api.github.example.com',
+        },
       });
       expect(githubGetPreset.mock.calls).toMatchSnapshot();
       expect(content).toMatchSnapshot();