Make tests CI invariant for testing command

Author: leeyi45

lib/buildtools/src/commands/__tests__/testing.test.ts

@@ -1,4 +1,4 @@
-import { describe, expect, test, vi } from 'vitest';
+import { afterAll, beforeAll, describe, expect, test, vi } from 'vitest';
 import { testMocksDir } from '../../__tests__/fixtures.js';
 import * as runner from '../../testing/runner.js';
 import * as configs from '../../testing/utils.js';
@@ -13,75 +13,85 @@ describe('Test regular test command', () => {
   const mockedTestConfiguration = vi.spyOn(configs, 'getTestConfiguration');
   const runCommand = getCommandRunner(getTestCommand);
 
-  test('Providing both the project directory and pattern', async () => {
-    const mockConfig: configs.GetTestConfigurationResult = {
-      severity: 'success',
-      config: {
-        test: {
-          name: 'Test0'
+  describe('Tests that need to be CI process env invariant', () => {
+    beforeAll(() => {
+      vi.stubEnv('CI', 'yeet');
+    });
+
+    afterAll(() => {
+      vi.unstubAllEnvs();
+    });
+
+    test('Providing both the project directory and pattern', async () => {
+      const mockConfig: configs.GetTestConfigurationResult = {
+        severity: 'success',
+        config: {
+          test: {
+            name: 'Test0'
+          }
         }
-      }
-    };
+      };
 
-    mockedTestConfiguration.mockResolvedValueOnce(mockConfig);
-    const projectPath = `${testMocksDir}/dir`;
+      mockedTestConfiguration.mockResolvedValueOnce(mockConfig);
+      const projectPath = `${testMocksDir}/dir`;
 
-    await expect(runCommand('--project', projectPath, `${projectPath}/dir1`)).commandSuccess();
-    expect(configs.getTestConfiguration).toHaveBeenCalledExactlyOnceWith(projectPath, false);
-    expect(runner.runVitest).toHaveBeenCalledExactlyOnceWith('test', [`${projectPath}/dir1`], [mockConfig.config], { allowOnly: true });
-  });
+      await expect(runCommand('--project', projectPath, `${projectPath}/dir1`)).commandSuccess();
+      expect(configs.getTestConfiguration).toHaveBeenCalledExactlyOnceWith(projectPath, false);
+      expect(runner.runVitest).toHaveBeenCalledExactlyOnceWith('test', [`${projectPath}/dir1`], [mockConfig.config], { allowOnly: true });
+    });
 
-  test('Providing both the project directory but no patterns', async () => {
-    const projectPath = `${testMocksDir}/dir`;
-    const mockConfig: configs.GetTestConfigurationResult = {
-      severity: 'success',
-      config: {
-        test: {
-          name: 'Test0'
+    test('Providing both the project directory but no patterns', async () => {
+      const projectPath = `${testMocksDir}/dir`;
+      const mockConfig: configs.GetTestConfigurationResult = {
+        severity: 'success',
+        config: {
+          test: {
+            name: 'Test0'
+          }
         }
-      }
-    };
-
-    mockedTestConfiguration.mockResolvedValueOnce(mockConfig);
+      };
 
-    await expect(runCommand('--project', projectPath)).commandSuccess();
-    expect(configs.getTestConfiguration).toHaveBeenCalledExactlyOnceWith(projectPath, false);
-    expect(runner.runVitest).toHaveBeenCalledExactlyOnceWith('test', [], [mockConfig.config], { allowOnly: true });
-  });
+      mockedTestConfiguration.mockResolvedValueOnce(mockConfig);
 
-  test('Expect command to exit with no issues if no tests were found', async () => {
-    const projectPath = `${testMocksDir}/dir`;
-    mockedTestConfiguration.mockResolvedValueOnce({
-      severity: 'success',
-      config: null
+      await expect(runCommand('--project', projectPath)).commandSuccess();
+      expect(configs.getTestConfiguration).toHaveBeenCalledExactlyOnceWith(projectPath, false);
+      expect(runner.runVitest).toHaveBeenCalledExactlyOnceWith('test', [], [mockConfig.config], { allowOnly: true });
     });
 
-    await expect(runCommand('--project', projectPath)).commandSuccess();
-  });
+    test('Expect command to exit with no issues if no tests were found', async () => {
+      const projectPath = `${testMocksDir}/dir`;
+      mockedTestConfiguration.mockResolvedValueOnce({
+        severity: 'success',
+        config: null
+      });
 
-  test('Command should error if the command was called from beyond the git root', async () => {
-    const projectPath = `${testMocksDir}/..`;
-    await expect(runCommand('--project', projectPath)).commandExit();
-  });
+      await expect(runCommand('--project', projectPath)).commandSuccess();
+    });
+
+    test('Command should error if the command was called from beyond the git root', async () => {
+      const projectPath = `${testMocksDir}/..`;
+      await expect(runCommand('--project', projectPath)).commandExit();
+    });
 
-  test('--no-allow-only should not allow only :)', async () => {
-    const mockConfig: configs.GetTestConfigurationResult = {
-      severity: 'success',
-      config: {
-        test: {
-          name: 'Test0'
+    test('--no-allow-only should not allow only :)', async () => {
+      const mockConfig: configs.GetTestConfigurationResult = {
+        severity: 'success',
+        config: {
+          test: {
+            name: 'Test0'
+          }
         }
-      }
-    };
-    mockedTestConfiguration.mockResolvedValueOnce(mockConfig);
-
-    await expect(runCommand('--no-allow-only')).commandSuccess();
-    expect(runner.runVitest).toHaveBeenCalledExactlyOnceWith(
-      'test',
-      [],
-      [mockConfig.config],
-      { allowOnly: false }
-    );
+      };
+      mockedTestConfiguration.mockResolvedValueOnce(mockConfig);
+
+      await expect(runCommand('--no-allow-only')).commandSuccess();
+      expect(runner.runVitest).toHaveBeenCalledExactlyOnceWith(
+        'test',
+        [],
+        [mockConfig.config],
+        { allowOnly: false }
+      );
+    });
   });
 
   test('--no-allow-only should be true when CI', async () => {