fetcher tests

Author: danieldelcore

packages/cli/src/main.spec.ts

@@ -1,11 +1,14 @@
+jest.mock('globby');
 jest.mock('live-plugin-manager');
 jest.mock('jscodeshift/src/Runner', () => ({
   run: jest.fn().mockImplementation(() => Promise.resolve()),
 }));
 
+import path from 'path';
 // @ts-ignore
 import * as jscodeshift from 'jscodeshift/src/Runner';
 import { PluginManager } from 'live-plugin-manager';
+import globby from 'globby';
 
 import main from './main';
 
@@ -532,28 +535,45 @@ describe('main', () => {
   });
 
   describe('when running transforms from NPM with the -p flag', () => {
+    const mockMatchedPath = path.join(
+      __dirname,
+      'path',
+      'to',
+      'codeshift.config.js',
+    );
+
     beforeEach(() => {
+      ((globby as unknown) as jest.Mock).mockImplementation(() =>
+        Promise.resolve([mockMatchedPath]),
+      );
+
       (PluginManager as jest.Mock).mockImplementation(() => ({
         install: jest.fn().mockResolvedValue(undefined),
-        require: jest.fn().mockImplementation((codemodName: string) => {
-          if (codemodName.startsWith('@codeshift')) {
-            return {};
-          }
+        require: jest.fn(),
+        getInfo: jest
+          .fn()
+          .mockReturnValue({ location: path.join(__dirname, 'path', 'to') }),
+        uninstallAll: jest.fn().mockResolvedValue(undefined),
+      }));
+    });
 
-          return {
+    it('should run package transform for single version', async () => {
+      jest.mock(
+        mockMatchedPath,
+        () => ({
+          __esModule: true,
+          default: {
             transforms: {
-              '18.0.0': `${codemodName}/path/to/18.js`,
+              '18.0.0': 'mylib/path/to/18.js',
             },
             presets: {
-              'update-formatting': `${codemodName}/path/to/update-formatting.js`,
+              'update-formatting': 'mylib/path/to/update-formatting.js',
             },
-          };
+          },
         }),
-        uninstallAll: jest.fn().mockResolvedValue(undefined),
-      }));
-    });
+        { virtual: true },
+      );
 
-    it('should run package transform for single version', async () => {
       await main([mockPath], {
         packages: 'mylib@18.0.0',
         parser: 'babel',

packages/fetcher/src/index.spec.ts

@@ -1 +1,173 @@
-// TODO
+jest.mock('globby');
+
+import globby from 'globby';
+import path from 'path';
+import { PluginManager } from 'live-plugin-manager';
+
+import { fetchConfig, fetchPackage, fetchRemotePackage } from '.';
+
+const mockBasePath = path.join(__dirname, 'path', 'to');
+
+const mockConfig = {
+  transforms: {
+    '10.0.0': 'path/to/transform.js',
+  },
+};
+
+describe('fetcher', () => {
+  let mockMatchedPaths: string[] = [];
+
+  beforeEach(() => {
+    mockMatchedPaths = [
+      path.join(mockBasePath, 'codeshift.config.js'),
+      path.join(mockBasePath, 'src', 'codeshift.config.ts'),
+      path.join(mockBasePath, 'codemods', 'codeshift.config.tsx'),
+    ];
+
+    ((globby as unknown) as jest.Mock).mockImplementation(() =>
+      Promise.resolve(mockMatchedPaths),
+    );
+  });
+
+  afterEach(() => {
+    jest.resetAllMocks();
+  });
+
+  describe('fetchConfig', () => {
+    it('fetches config with default export', async () => {
+      jest.mock(
+        `${__dirname}/path/to/codeshift.config.js`,
+        () => ({
+          __esModule: true,
+          default: mockConfig,
+        }),
+        { virtual: true },
+      );
+
+      const config = await fetchConfig(mockBasePath);
+
+      expect(config).toEqual(mockConfig);
+    });
+
+    it('fetches config with named export', async () => {
+      jest.mock(`${__dirname}/path/to/codeshift.config.js`, () => mockConfig, {
+        virtual: true,
+      });
+
+      const config = await fetchConfig(mockBasePath);
+
+      expect(config).toEqual(mockConfig);
+    });
+
+    it('fetches first matched config when multiple are found', async () => {
+      jest.mock(
+        `${__dirname}/path/to/src/codeshift.config.ts`,
+        () => ({
+          __esModule: true,
+          default: mockConfig,
+        }),
+        { virtual: true },
+      );
+
+      mockMatchedPaths = [
+        path.join(mockBasePath, 'src', 'codeshift.config.ts'),
+        path.join(mockBasePath, 'codemods', 'codeshift.config.tsx'),
+      ];
+
+      const config = await fetchConfig(mockBasePath);
+
+      expect(config).toEqual(mockConfig);
+    });
+
+    it('returns undefined if no config was found', async () => {
+      mockMatchedPaths = [];
+
+      const config = await fetchConfig(mockBasePath);
+
+      expect(config).toBe(undefined);
+    });
+  });
+
+  describe('fetchPackage', () => {
+    it('correctly fetches package and returns a config', async () => {
+      const mockPackageManager = {
+        install: jest.fn(),
+        require: jest.fn().mockReturnValue(mockConfig),
+      };
+
+      const config = await fetchPackage(
+        'fake-package',
+        (mockPackageManager as unknown) as PluginManager,
+      );
+
+      expect(config).toEqual(mockConfig);
+    });
+
+    it('should throw if fetching fails', async () => {
+      const mockPackageManager = {
+        install: jest.fn().mockRejectedValue('Import error'),
+        require: jest.fn().mockReturnValue(mockConfig),
+      };
+
+      expect.assertions(1);
+
+      await expect(
+        fetchPackage(
+          'fake-package',
+          (mockPackageManager as unknown) as PluginManager,
+        ),
+      ).rejects.toEqual('Import error');
+    });
+  });
+
+  describe('fetchRemotePackage', () => {
+    it('correctly fetches package and returns a config', async () => {
+      const mockPackageManager = {
+        install: jest.fn(),
+        getInfo: jest.fn().mockReturnValue({
+          location: mockBasePath,
+        }),
+      };
+
+      const config = await fetchRemotePackage(
+        'fake-package',
+        (mockPackageManager as unknown) as PluginManager,
+      );
+
+      expect(config).toEqual(mockConfig);
+    });
+
+    it('should throw if fetching fails', async () => {
+      const mockPackageManager = {
+        install: jest.fn().mockRejectedValue('Import error'),
+      };
+
+      expect.assertions(1);
+
+      await expect(
+        fetchRemotePackage(
+          'fake-package',
+          (mockPackageManager as unknown) as PluginManager,
+        ),
+      ).rejects.toEqual('Import error');
+    });
+
+    it('should throw if package source cannot be retrieved', async () => {
+      const mockPackageManager = {
+        install: jest.fn(),
+        getInfo: () => undefined,
+      };
+
+      expect.assertions(1);
+
+      await expect(
+        fetchRemotePackage(
+          'fake-package',
+          (mockPackageManager as unknown) as PluginManager,
+        ),
+      ).rejects.toEqual(
+        new Error(`Unable to locate package files for package: 'fake-package'`),
+      );
+    });
+  });
+});

packages/fetcher/src/index.ts

@@ -4,27 +4,28 @@ import { PluginManager } from 'live-plugin-manager';
 
 import { CodeshiftConfig } from '@codeshift/types';
 
+function resolveConfigExport(pkg: any): CodeshiftConfig {
+  return pkg.default ? pkg.default : pkg;
+}
+
 export async function fetchConfig(
   filePath: string,
 ): Promise<CodeshiftConfig | undefined> {
-  let config: CodeshiftConfig | undefined;
-
   const matchedPaths = await globby([
     path.join(filePath, 'codeshift.config.(js|ts|tsx)'),
     path.join(filePath, 'src', 'codeshift.config.(js|ts|tsx)'),
     path.join(filePath, 'codemods', 'codeshift.config.(js|ts|tsx)'),
   ]);
 
-  matchedPaths.forEach(matchedPath => {
+  for (const matchedPath of matchedPaths) {
     try {
       // eslint-disable-next-line @typescript-eslint/no-var-requires
       const pkg = require(matchedPath);
-      const searchConfig = pkg.default ? pkg.default : pkg;
-      config = searchConfig;
+      return resolveConfigExport(pkg);
     } catch (e) {}
-  });
+  }
 
-  return config;
+  return undefined;
 }
 
 export async function fetchPackage(
@@ -33,19 +34,21 @@ export async function fetchPackage(
 ): Promise<CodeshiftConfig | undefined> {
   await packageManager.install(packageName);
   const pkg = packageManager.require(packageName);
-  const config: CodeshiftConfig = pkg.default ? pkg.default : pkg;
-  return config;
+  return resolveConfigExport(pkg);
 }
 
 export async function fetchRemotePackage(
   packageName: string,
   packageManager: PluginManager,
 ): Promise<CodeshiftConfig | undefined> {
-  const config = await fetchPackage(packageName, packageManager);
-  if (config) return config;
-
+  await packageManager.install(packageName);
   const info = packageManager.getInfo(packageName);
-  if (!info) return undefined;
+
+  if (!info) {
+    throw new Error(
+      `Unable to locate package files for package: '${packageName}'`,
+    );
+  }
 
   return await fetchConfig(info.location);
 }