feat(it-tests): test schematics with yarn 1

.github/workflows/it-tests.yml

@@ -54,7 +54,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [ubuntu-latest, windows-latest]
-        packageManager: [yarn, npm]
+        packageManager: [yarn, npm, yarn1]
         testEnvironment: [o3r-project-with-app]
     runs-on: ${{ matrix.os }}
     env:

packages/@ama-sdk/create/src/index.it.spec.ts

@@ -9,7 +9,7 @@ const o3rEnvironment = globalThis.o3rEnvironment;
 import {
   getDefaultExecSyncOptions,
   getPackageManager,
-  getYarnVersionFromRoot,
+  isYarn1Enforced,
   packageManagerCreate,
   packageManagerExec,
   packageManagerInstall,
@@ -24,11 +24,13 @@ let sdkFolderPath: string;
 let sdkPackagePath: string;
 const execAppOptions = getDefaultExecSyncOptions();
 const packageManager = getPackageManager();
+const describeSkipYarn1 = isYarn1Enforced ? describe.skip : describe;
 
-describe('Create new sdk command', () => {
+describeSkipYarn1('Create new sdk command', () => {
   beforeEach(() => {
     const isYarnTest = o3rEnvironment.testEnvironment.isYarnTest;
-    const yarnVersion = isYarnTest ? getYarnVersionFromRoot(process.cwd()) || 'latest' : undefined;
+    sdkFolderPath = o3rEnvironment.testEnvironment.workspacePath;
+    const yarnVersion = o3rEnvironment.testEnvironment.packageManagerConfig.yarnVersion;
     sdkFolderPath = o3rEnvironment.testEnvironment.workspacePath;
     sdkPackagePath = path.join(sdkFolderPath, sdkPackageName.replace(/^@/, ''));
     execAppOptions.cwd = sdkFolderPath;
@@ -38,9 +40,10 @@ describe('Create new sdk command', () => {
       packageManagerInstall(execAppOptions);
 
       // copy yarnrc config to generated SDK
-      mkdirSync(sdkPackagePath, {recursive: true});
-      cpSync(path.join(sdkFolderPath, '.yarnrc.yml'), path.join(sdkPackagePath, '.yarnrc.yml'));
-      cpSync(path.join(sdkFolderPath, '.yarn'), path.join(sdkPackagePath, '.yarn'), {recursive: true});
+      mkdirSync(sdkPackagePath, { recursive: true });
+      const yarnConfigFile = '.yarnrc.yml';
+      cpSync(path.join(sdkFolderPath, yarnConfigFile), path.join(sdkPackagePath, yarnConfigFile));
+      cpSync(path.join(sdkFolderPath, '.yarn'), path.join(sdkPackagePath, '.yarn'), { recursive: true });
       fs.writeFileSync(path.join(sdkPackagePath, 'yarn.lock'), '');
     } else {
       // copy npmrc config to generated SDK
@@ -59,7 +62,7 @@ describe('Create new sdk command', () => {
       packageManagerCreate({
         script: '@ama-sdk',
         args: ['typescript', sdkPackageName, '--package-manager', packageManager, '--spec-path', path.join(sdkFolderPath, 'swagger-spec.yml')]
-      }, execAppOptions)
+      }, execAppOptions, 'npm')
     ).not.toThrow();
     expect(() => packageManagerRun({script: 'build'}, { ...execAppOptions, cwd: sdkPackagePath })).not.toThrow();
     expect(existsSync(path.join(sdkPackagePath, 'src', 'models', 'base', 'pet', 'pet.reviver.ts'))).toBeFalsy();
@@ -111,24 +114,27 @@ describe('Create new sdk command', () => {
   });
 
   test('should generate an empty SDK ready to be used', () => {
-    expect(() => packageManagerCreate({script: '@ama-sdk', args: ['typescript', sdkPackageName]}, execAppOptions)).not.toThrow();
-    expect(() => packageManagerRun({script: 'build'}, { ...execAppOptions, cwd: sdkPackagePath })).not.toThrow();
+    expect(() => packageManagerCreate({
+      script: '@ama-sdk',
+      args: ['typescript', sdkPackageName, '--package-manager', packageManager]
+    }, execAppOptions, 'npm')).not.toThrow();
+    expect(() => packageManagerRun({ script: 'build' }, { ...execAppOptions, cwd: sdkPackagePath })).not.toThrow();
     expect(() =>
       packageManagerExec({
         script: 'schematics',
         args: ['@ama-sdk/schematics:typescript-core', '--spec-path', path.join(path.relative(sdkPackagePath, sdkFolderPath), 'swagger-spec.yml')]
       }, { ...execAppOptions, cwd: sdkPackagePath })
     ).not.toThrow();
-    expect(() => packageManagerRun({script: 'build'}, { ...execAppOptions, cwd: sdkPackagePath })).not.toThrow();
-    expect(() => packageManagerRun({script: 'doc:generate'}, { ...execAppOptions, cwd: sdkPackagePath })).not.toThrow();
+    expect(() => packageManagerRun({ script: 'build' }, { ...execAppOptions, cwd: sdkPackagePath })).not.toThrow();
+    expect(() => packageManagerRun({ script: 'doc:generate' }, { ...execAppOptions, cwd: sdkPackagePath })).not.toThrow();
   });
 
   test('should fail when there is an error', () => {
     expect(() =>
       packageManagerCreate({
         script: '@ama-sdk',
-        args: ['typescript', sdkPackageName, '--package-manager', packageManager, '--spec-path','./missing-file.yml']
-      }, execAppOptions)
+        args: ['typescript', sdkPackageName, '--package-manager', packageManager, '--spec-path', './missing-file.yml']
+      }, execAppOptions, 'npm')
     ).toThrow();
   });
 
@@ -137,7 +143,7 @@ describe('Create new sdk command', () => {
       packageManagerCreate({
         script: `@ama-sdk@${o3rEnvironment.testEnvironment.o3rExactVersion}`,
         args: ['typescript', sdkPackageName, '--exact-o3r-version', '--package-manager', packageManager, '--spec-path', path.join(sdkFolderPath, 'swagger-spec.yml')]
-      }, execAppOptions)
+      }, execAppOptions, 'npm')
     ).not.toThrow();
     expect(() => packageManagerRun({script: 'build'}, { ...execAppOptions, cwd: sdkPackagePath })).not.toThrow();
     const packageJson = JSON.parse(fs.readFileSync(path.join(sdkPackagePath, 'package.json'), 'utf-8'));

packages/@o3r/create/src/index.it.spec.ts

@@ -9,6 +9,7 @@ const o3rEnvironment = globalThis.o3rEnvironment;
 import {
   getDefaultExecSyncOptions,
   getPackageManager,
+  isYarn1Enforced,
   packageManagerCreate,
   packageManagerExec,
   packageManagerInstall,
@@ -20,8 +21,8 @@ import * as path from 'node:path';
 
 const defaultExecOptions = getDefaultExecSyncOptions();
 const workspaceProjectName = 'my-project';
-
-describe('Create new otter project command', () => {
+const describeSkipYarn1 = isYarn1Enforced ? describe.skip : describe;
+describeSkipYarn1('Create new otter project command', () => {
   test('should generate a project with an application', async () => {
     const { workspacePath, packageManagerConfig, o3rVersion } = o3rEnvironment.testEnvironment;
     const inProjectPath = path.join(workspacePath, workspaceProjectName);

packages/@o3r/create/src/index.ts

@@ -255,7 +255,6 @@ const prepareWorkspace = (relativeDirectory = '.', projectPackageManager = 'npm'
 
   exitProcessIfErrorInSpawnSync(INSTALL_PROCESS_ERROR_CODE, spawnSync(runner, ['install'], spawnSyncOpts));
 };
-
 const addOtterFramework = (relativeDirectory = '.', projectPackageManager = 'npm') => {
   const cwd = resolve(process.cwd(), relativeDirectory);
   const runner = process.platform === 'win32' ? `${projectPackageManager}.cmd` : projectPackageManager;

packages/@o3r/telemetry/src/environment/index.ts

@@ -4,22 +4,22 @@ import { execSync } from 'node:child_process';
 import * as path from 'node:path';
 
 /** Support NPM package managers */
-type SupportedPackageManagers = 'npm' | 'yarn';
+type SupportedPackageManagers = 'npm' | 'yarn' | 'yarn1';
 
 /**
  * Determine if the given packager manager is supported
  * @param name Name of the package manager
  */
 function isSupportedPackageManager(name?: any): name is SupportedPackageManagers {
-  return name === 'yarn' || name === 'npm';
+  return ['yarn', 'yarn1', 'npm'].includes(name);
 }
 
 /**
  * Get package manager used
  */
 function getPackageManager() {
   if (isSupportedPackageManager(process.env?.ENFORCED_PACKAGE_MANAGER)) {
-    return process.env.ENFORCED_PACKAGE_MANAGER;
+    return (process.env.ENFORCED_PACKAGE_MANAGE === 'npm') ? 'npm' : 'yarn';
   }
   return (process.env?.npm_execpath?.includes('yarn') && 'yarn') || 'npm';
 }

packages/@o3r/test-helpers/src/prepare-test-env.ts

@@ -1,9 +1,9 @@
-import { execFileSync, ExecSyncOptions } from 'node:child_process';
+import { execFileSync, execSync, ExecSyncOptions } from 'node:child_process';
 import { cpSync, existsSync, mkdirSync, readFileSync, rmSync } from 'node:fs';
 import * as path from 'node:path';
 import type { PackageJson } from 'type-fest';
 import { createTestEnvironmentBlank } from './test-environments/create-test-environment-blank';
-import { createWithLock, getPackageManager, type Logger, packageManagerInstall, setPackagerManagerConfig, setupGit } from './utilities/index';
+import { createWithLock, getPackageManager, isYarn1Enforced, type Logger, packageManagerInstall, setPackagerManagerConfig, setupGit } from './utilities/index';
 import { createTestEnvironmentOtterProjectWithAppAndLib } from './test-environments/create-test-environment-otter-project';
 import { O3rCliError } from '@o3r/schematics';
 
@@ -15,8 +15,7 @@ export type PrepareTestEnvType = 'blank' | 'o3r-project-with-app';
 
 /**
  * Retrieve the version used by yarn and setup at root level
- * @param rootFolderPath: path to the folder where to take the configuration from
- * @param rootFolderPath
+ * @param rootFolderPath path to the folder where to take the configuration from
  */
 export function getYarnVersionFromRoot(rootFolderPath: string) {
   const o3rPackageJson: PackageJson & { generatorDependencies?: Record<string, string> } =
@@ -31,6 +30,11 @@ export interface PrepareTestEnvOptions {
   yarnVersion?: string;
   /** Logger to use for logging */
   logger?: Logger;
+  /**
+   * Scope of package used to run the create command
+   * Used on yarn1 tests, because it is not able to differetiate from which package scope to run the create
+   */
+  packageScope?: string;
 }
 
 /**
@@ -43,14 +47,15 @@ export async function prepareTestEnv(folderName: string, options?: PrepareTestEn
   const logger = options?.logger || console;
   const yarnVersionParam = options?.yarnVersion;
   const rootFolderPath = process.cwd();
-  const itTestsFolderPath = path.resolve(rootFolderPath, '..', 'it-tests');
+  const itTestsFolderPath = path.resolve(rootFolderPath, '..', 'it-tests', options?.packageScope || '');
   const workspacePath = path.resolve(itTestsFolderPath, folderName);
   const globalFolderPath = path.resolve(rootFolderPath, '.cache', 'test-app');
   const o3rVersion = '~999';
   const registry = 'http://127.0.0.1:4873';
 
   JSON.parse(readFileSync(path.join(rootFolderPath, 'packages', '@o3r', 'core', 'package.json')).toString());
-  const yarnVersion: string = yarnVersionParam || getYarnVersionFromRoot(rootFolderPath);
+  const yarn1Version = execSync('npm view yarn version', { encoding: 'utf8' }).trim();
+  const yarnVersion: string = yarnVersionParam || (isYarn1Enforced() && yarn1Version) || getYarnVersionFromRoot(rootFolderPath);
   const execAppOptions: ExecSyncOptions = {
     cwd: workspacePath,
     stdio: 'inherit',
@@ -61,17 +66,18 @@ export async function prepareTestEnv(folderName: string, options?: PrepareTestEn
   const packageManagerConfig = {
     yarnVersion,
     globalFolderPath,
-    registry
+    registry,
+    ...(isYarn1Enforced() ? {packageScope: options?.packageScope} : {})
   };
 
   // Create it-tests folder
   if (!existsSync(itTestsFolderPath)) {
     logger.debug?.(`Creating it-tests folder`);
     await createWithLock(() => {
-      mkdirSync(itTestsFolderPath);
+      mkdirSync(itTestsFolderPath, { recursive: true });
       setPackagerManagerConfig(packageManagerConfig, {...execAppOptions, cwd: itTestsFolderPath});
       return Promise.resolve();
-    }, {lockFilePath: `${itTestsFolderPath}.lock`, cwd: path.join(rootFolderPath, '..'), appDirectory: 'it-tests'});
+    }, {lockFilePath: `${itTestsFolderPath}.lock`, cwd: path.join(rootFolderPath, '..'), appDirectory: path.join('it-tests', options?.packageScope || '')});
   }
   const o3rExactVersion = execFileSync('npm', ['info', '@o3r/create', 'version'], {
     ...execAppOptions,