@spcsn/taro-cli 0.1.0

package/src/__tests__/inspect.spec.ts

@@ -0,0 +1,160 @@
+import * as path from 'node:path';
+
+import { chalk, fs } from '@spcsn/taro-helper';
+
+import { run } from './utils';
+
+jest.mock('cli-highlight', () => {
+  return {
+    __esModule: true,
+    default(str) {
+      return str;
+    },
+  };
+});
+
+jest.mock('@spcsn/taro-helper', () => {
+  const helper = jest.requireActual('@spcsn/taro-helper');
+  const fs = helper.fs;
+  return {
+    __esModule: true,
+    ...helper,
+    fs: {
+      ...fs,
+      writeFileSync: jest.fn(),
+    },
+  };
+});
+
+const runInspect = run('inspect', [
+  'commands/build',
+  'commands/inspect',
+  require.resolve('@spcsn/taro-plugin-platform-weapp'),
+]);
+
+describe('inspect', () => {
+  beforeEach(() => {
+    jest.resetModules();
+  });
+
+  it("should exit because there isn't a Taro project", async () => {
+    const exitSpy = jest.spyOn(process, 'exit') as jest.SpyInstance<void, any>;
+    const logSpy = jest.spyOn(console, 'log');
+
+    exitSpy.mockImplementation(() => {
+      throw new Error();
+    });
+    logSpy.mockImplementation(() => {});
+
+    try {
+      await runInspect('');
+    } catch (error) {} // eslint-disable-line no-empty
+
+    expect(exitSpy).toBeCalledWith(1);
+    expect(logSpy).toBeCalledWith(chalk.red('找不到项目配置文件config/index，请确定当前目录是 Taro 项目根目录!'));
+
+    exitSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+
+  it("should exit when user haven't pass correct type", async () => {
+    const exitSpy = jest.spyOn(process, 'exit') as jest.SpyInstance<void, any>;
+    const logSpy = jest.spyOn(console, 'log');
+
+    exitSpy.mockImplementation(() => {
+      throw new Error();
+    });
+    logSpy.mockImplementation(() => {});
+
+    try {
+      await runInspect(path.resolve(__dirname, 'fixtures/default'));
+    } catch (error) {} // eslint-disable-line no-empty
+
+    expect(exitSpy).toBeCalledWith(0);
+    expect(logSpy).toBeCalledWith(chalk.red('请传入正确的编译类型！'));
+
+    exitSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+
+  it('should log config', async () => {
+    const exitSpy = jest.spyOn(process, 'exit') as jest.SpyInstance<void, any>;
+    const logSpy = jest.spyOn(console, 'info');
+
+    exitSpy.mockImplementation(() => {
+      throw new Error();
+    });
+    logSpy.mockImplementation(() => {});
+
+    try {
+      const appPath = path.resolve(__dirname, 'fixtures/default');
+      await runInspect(appPath, {
+        options: {
+          type: 'weapp',
+        },
+      });
+    } catch (error) {} // eslint-disable-line no-empty
+
+    expect(exitSpy).toBeCalledWith(0);
+    expect(logSpy).toBeCalledTimes(1);
+
+    exitSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+
+  it('should log specific config', async () => {
+    const exitSpy = jest.spyOn(process, 'exit') as jest.SpyInstance<void, any>;
+    const logSpy = jest.spyOn(console, 'info');
+    const errorSpy = jest.spyOn(console, 'error');
+
+    exitSpy.mockImplementation(() => {
+      throw new Error();
+    });
+    logSpy.mockImplementation(() => {});
+    errorSpy.mockImplementation(() => {});
+
+    try {
+      const appPath = path.resolve(__dirname, 'fixtures/default');
+      await runInspect(appPath, {
+        options: {
+          type: 'weapp',
+        },
+        args: ['resolve.mainFields.0'],
+      });
+    } catch (error) {} // eslint-disable-line no-empty
+
+    expect(exitSpy).toBeCalledWith(0);
+    expect(logSpy).toBeCalledTimes(1);
+    expect(logSpy).toBeCalledWith("'browser'");
+
+    exitSpy.mockRestore();
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+  });
+
+  it('should output config', async () => {
+    const exitSpy = jest.spyOn(process, 'exit') as jest.SpyInstance<void, any>;
+    const writeFileSync = fs.writeFileSync as jest.Mock<any>;
+    const outputPath = 'project-config.js';
+
+    exitSpy.mockImplementation(() => {
+      throw new Error();
+    });
+
+    try {
+      const appPath = path.resolve(__dirname, 'fixtures/default');
+      await runInspect(appPath, {
+        options: {
+          type: 'weapp',
+          output: outputPath,
+        },
+        args: ['resolve.mainFields.0'],
+      });
+    } catch (error) {} // eslint-disable-line no-empty
+
+    expect(exitSpy).toBeCalledWith(0);
+    expect(writeFileSync).toBeCalledWith(outputPath, "'browser'");
+
+    exitSpy.mockRestore();
+  });
+});

package/src/__tests__/update.spec.ts

@@ -0,0 +1,310 @@
+import * as path from 'node:path';
+
+import { chalk, fs, PROJECT_CONFIG, shouldUseCnpm, shouldUseYarn } from '@spcsn/taro-helper';
+import { exec } from 'child_process';
+
+import { getPkgVersion } from '../util';
+import { run } from './utils';
+
+const runUpdate = run('update', ['commands/update']);
+const lastestVersion = getPkgVersion();
+
+jest.mock('child_process', () => {
+  const exec = jest.fn();
+  exec.mockReturnValue({
+    stdout: {
+      on() {},
+    },
+    stderr: {
+      on() {},
+    },
+  });
+  return {
+    __esModule: true,
+    exec,
+  };
+});
+
+jest.mock('ora', () => {
+  const ora = jest.fn();
+  ora.mockReturnValue({
+    start() {
+      return {
+        stop() {},
+        warn() {},
+        succeed() {},
+      };
+    },
+  });
+  return ora;
+});
+
+jest.mock('@spcsn/taro-helper', () => {
+  const helper = jest.requireActual('@spcsn/taro-helper');
+  const fs = helper.fs;
+  return {
+    __esModule: true,
+    ...helper,
+    shouldUseCnpm: jest.fn(),
+    shouldUseYarn: jest.fn(),
+    chalk: {
+      red: jest.fn(),
+      green() {},
+    },
+    fs: {
+      ...fs,
+      writeJson: jest.fn(),
+    },
+  };
+});
+
+jest.mock('latest-version', () => () => lastestVersion);
+
+function updatePkg(pkgPath: string, version: string) {
+  let packageMap = require(pkgPath);
+  packageMap = {
+    ...packageMap,
+    dependencies: {
+      ...packageMap.dependencies,
+      '@spcsn/taro-shared': version,
+      '@spcsn/taro': version,
+      '@spcsn/taro-cli': version,
+      '@spcsn/taro-components': version,
+      '@spcsn/taro-api': version,
+      '@spcsn/taro-helper': version,
+      '@spcsn/taro-react': version,
+      '@spcsn/taro-runner-utils': version,
+      '@spcsn/taro-runtime': version,
+      '@spcsn/taro-service': version,
+      '@spcsn/taro-plugin-platform-weapp': version,
+      '@spcsn/taro-plugin-framework-react': version,
+      '@spcsn/taro-plugin-generator': version,
+      '@spcsn/taro-vite-runner': version,
+      '@spcsn/taro-binding': version,
+    },
+    devDependencies: {
+      ...packageMap.devDependencies,
+      'babel-preset-taro': version,
+      'babel-plugin-transform-taroapi': version,
+      'postcss-plugin-constparse': version,
+      'postcss-pxtransform': version,
+    },
+  };
+  return packageMap;
+}
+
+describe('update', () => {
+  const execMocked = exec as unknown as jest.Mock<any>;
+  const shouldUseCnpmMocked = shouldUseCnpm as jest.Mock<any>;
+  const shouldUseYarnMocked = shouldUseYarn as jest.Mock<any>;
+  const writeJson = fs.writeJson as jest.Mock<any>;
+
+  beforeEach(() => {
+    shouldUseCnpmMocked.mockReturnValue(false);
+    shouldUseYarnMocked.mockReturnValue(false);
+  });
+
+  afterEach(() => {
+    execMocked.mockClear();
+    shouldUseCnpmMocked.mockReset();
+    shouldUseYarnMocked.mockReset();
+    writeJson.mockClear();
+  });
+
+  it('should log errors', async () => {
+    const spy = jest.spyOn(console, 'log');
+    spy.mockImplementation(() => {});
+    await runUpdate('', {
+      options: {
+        npm: 'npm',
+        disableGlobalConfig: true,
+      },
+    });
+    expect(spy).toBeCalledTimes(3);
+    spy.mockRestore();
+  });
+
+  it('should update self', async () => {
+    await runUpdate('', {
+      args: ['self'],
+      options: {
+        npm: 'npm',
+        disableGlobalConfig: true,
+      },
+    });
+    expect(execMocked).toBeCalledWith(`npm i -g @spcsn/taro-cli@${lastestVersion}`);
+  });
+
+  it('should update self using yarn', async () => {
+    shouldUseCnpmMocked.mockReturnValue(true);
+    await runUpdate('', {
+      args: ['self'],
+      options: {
+        npm: 'yarn',
+        disableGlobalConfig: true,
+      },
+    });
+    expect(execMocked).toBeCalledWith(`yarn global add @spcsn/taro-cli@${lastestVersion}`);
+  });
+
+  it('should update self using pnpm', async () => {
+    shouldUseCnpmMocked.mockReturnValue(true);
+    await runUpdate('', {
+      args: ['self'],
+      options: {
+        npm: 'pnpm',
+        disableGlobalConfig: true,
+      },
+    });
+    expect(execMocked).toBeCalledWith(`pnpm add -g @spcsn/taro-cli@${lastestVersion}`);
+  });
+
+  it('should update self using cnpm', async () => {
+    shouldUseCnpmMocked.mockReturnValue(true);
+    await runUpdate('', {
+      args: ['self'],
+      options: {
+        npm: 'cnpm',
+        disableGlobalConfig: true,
+      },
+    });
+    expect(execMocked).toBeCalledWith(`cnpm i -g @spcsn/taro-cli@${lastestVersion}`);
+  });
+
+  it('should update self to specific version', async () => {
+    const version = '3.0.0-beta.0';
+    await runUpdate('', {
+      args: ['self', version],
+      options: {
+        npm: 'npm',
+        disableGlobalConfig: true,
+      },
+    });
+    expect(execMocked).toBeCalledWith(`npm i -g @spcsn/taro-cli@${version}`);
+  });
+
+  it("should throw when there isn't a Taro project", async () => {
+    const chalkMocked = chalk.red as unknown as jest.Mock<any>;
+    const exitSpy = jest.spyOn(process, 'exit');
+    const logSpy = jest.spyOn(console, 'log');
+    exitSpy.mockImplementation(() => {
+      throw new Error();
+    });
+    logSpy.mockImplementation(() => {});
+    try {
+      await runUpdate('', {
+        args: ['project'],
+        options: {
+          npm: 'npm',
+          disableGlobalConfig: true,
+        },
+      });
+    } catch (error) {} // eslint-disable-line no-empty
+    expect(exitSpy).toBeCalledWith(1);
+    expect(chalkMocked).toBeCalledWith(`找不到项目配置文件 ${PROJECT_CONFIG}，请确定当前目录是 Taro 项目根目录!`);
+    exitSpy.mockRestore();
+    logSpy.mockRestore();
+  });
+
+  it('should update project', async () => {
+    const appPath = path.resolve(__dirname, 'fixtures/default');
+    const pkgPath = path.join(appPath, 'package.json');
+    const packageMap = updatePkg(pkgPath, lastestVersion);
+
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+
+    await runUpdate(appPath, {
+      args: ['project'],
+      options: {
+        npm: 'npm',
+        disableGlobalConfig: true,
+      },
+    });
+    expect(writeJson.mock.calls[0][0]).toEqual(pkgPath);
+    expect(writeJson.mock.calls[0][1]).toEqual(packageMap);
+    expect(execMocked).toBeCalledWith('npm install');
+
+    logSpy.mockRestore();
+  });
+
+  it('should update project to specific version', async () => {
+    const version = '3.0.0-beta.4';
+    const appPath = path.resolve(__dirname, 'fixtures/default');
+    const pkgPath = path.join(appPath, 'package.json');
+    const packageMap = updatePkg(pkgPath, version);
+
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+
+    await runUpdate(appPath, {
+      args: ['project', version],
+      options: {
+        npm: 'npm',
+        disableGlobalConfig: true,
+      },
+    });
+    expect(writeJson.mock.calls[0][0]).toEqual(pkgPath);
+    expect(writeJson.mock.calls[0][1]).toEqual(packageMap);
+    expect(execMocked).toBeCalledWith('npm install');
+
+    logSpy.mockRestore();
+  });
+
+  it('should update project with yarn', async () => {
+    const appPath = path.resolve(__dirname, 'fixtures/default');
+
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+    shouldUseYarnMocked.mockReturnValue(true);
+
+    await runUpdate(appPath, {
+      args: ['project'],
+      options: {
+        npm: 'yarn',
+        disableGlobalConfig: true,
+      },
+    });
+    expect(execMocked).toBeCalledWith('yarn install');
+
+    logSpy.mockRestore();
+  });
+
+  it('should update project with pnpm', async () => {
+    const appPath = path.resolve(__dirname, 'fixtures/default');
+
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+    shouldUseCnpmMocked.mockReturnValue(true);
+
+    await runUpdate(appPath, {
+      args: ['project'],
+      options: {
+        npm: 'pnpm',
+        disableGlobalConfig: true,
+      },
+    });
+    expect(execMocked).toBeCalledWith('pnpm install');
+
+    logSpy.mockRestore();
+  });
+
+  it('should update project with cnpm', async () => {
+    const appPath = path.resolve(__dirname, 'fixtures/default');
+
+    const logSpy = jest.spyOn(console, 'log');
+    logSpy.mockImplementation(() => {});
+    shouldUseCnpmMocked.mockReturnValue(true);
+
+    await runUpdate(appPath, {
+      args: ['project'],
+      options: {
+        npm: 'cnpm',
+        disableGlobalConfig: true,
+      },
+    });
+    expect(execMocked).toBeCalledWith('cnpm install');
+
+    logSpy.mockRestore();
+  });
+});

package/src/__tests__/utils/index.ts

@@ -0,0 +1,54 @@
+import * as path from 'node:path';
+
+import { Config, Kernel } from '@spcsn/taro-service';
+
+interface IRunOptions {
+  options?: Record<string, string | boolean>;
+  args?: string[];
+}
+
+interface IRun {
+  (appPath: string, options?: IRunOptions): Promise<Kernel>;
+}
+
+export function run(name: string, presets: string[] = []): IRun {
+  return async function (appPath, opts = {}) {
+    const { options = {}, args = [] } = opts;
+
+    const config = new Config({
+      appPath: appPath,
+      disableGlobalConfig: !!options.disableGlobalConfig,
+    });
+    await config.init({
+      mode: (options.mode || process.env.NODE_ENV) as string,
+      command: name,
+    });
+
+    const kernel = new Kernel({
+      appPath: appPath,
+      presets: [
+        path.resolve(__dirname, '../__mocks__', 'presets.ts'),
+        ...presets.map((e) => (path.isAbsolute(e) ? e : path.resolve(__dirname, '../../presets', `${e}.ts`))),
+      ],
+      plugins: [],
+      config,
+    });
+    kernel.optsPlugins ||= [];
+
+    const type = options.type;
+    if (typeof type === 'string' && !presets.some((e) => e.includes(type))) {
+      kernel.optsPlugins.push(require.resolve(`@spcsn/taro-plugin-platform-${options.type}`));
+    }
+
+    await kernel.run({
+      name,
+      opts: {
+        _: [name, ...args],
+        options,
+        isHelp: false,
+      },
+    });
+
+    return kernel;
+  };
+}