check- filaure fix

__tests__/cache-utils.test.ts

@@ -26,26 +26,32 @@ describe('cache-utils', () => {
   let fsRealPathSyncSpy: jest.SpyInstance;
 
   beforeEach(() => {
+    console.log('::stop-commands::stoptoken');
     process.env['GITHUB_WORKSPACE'] = path.join(__dirname, 'data');
     debugSpy = jest.spyOn(core, 'debug');
-    debugSpy.mockImplementation(() => {});
+    debugSpy.mockImplementation(msg => {});
 
     info = jest.spyOn(core, 'info');
     warningSpy = jest.spyOn(core, 'warning');
 
     isFeatureAvailable = jest.spyOn(cache, 'isFeatureAvailable');
+
     getCommandOutputSpy = jest.spyOn(utils, 'getCommandOutput');
 
     fsRealPathSyncSpy = jest.spyOn(fs, 'realpathSync');
-    fsRealPathSyncSpy.mockImplementation(dirName => dirName);
+    fsRealPathSyncSpy.mockImplementation(dirName => {
+      return dirName;
+    });
   });
 
   afterEach(() => {
     jest.resetAllMocks();
-    process.env['GITHUB_SERVER_URL'] = ''; // Ensure environment variables are cleaned up
+    jest.clearAllMocks();
+    //jest.restoreAllMocks();
   });
 
   afterAll(async () => {
+    console.log('::stoptoken::');
     jest.restoreAllMocks();
   }, 100000);
 
@@ -59,7 +65,9 @@ describe('cache-utils', () => {
       ['npm7', null]
     ])('getPackageManagerInfo for %s is %o', async (packageManager, result) => {
       getCommandOutputSpy.mockImplementationOnce(() => versionYarn1);
-      await expect(utils.getPackageManagerInfo(packageManager)).resolves.toBe(result);
+      await expect(utils.getPackageManagerInfo(packageManager)).resolves.toBe(
+        result
+      );
     });
   });
 
@@ -73,7 +81,7 @@ describe('cache-utils', () => {
     );
   });
 
-  it('isCacheFeatureAvailable for GHES has an internal error', () => {
+  it('isCacheFeatureAvailable for GHES has an interhal error', () => {
     isFeatureAvailable.mockImplementation(() => false);
     process.env['GITHUB_SERVER_URL'] = '';
     isCacheFeatureAvailable();
@@ -88,6 +96,12 @@ describe('cache-utils', () => {
     expect(isCacheFeatureAvailable()).toStrictEqual(true);
   });
 
+  afterEach(() => {
+    process.env['GITHUB_SERVER_URL'] = '';
+    jest.resetAllMocks();
+    jest.clearAllMocks();
+  });
+
   describe('getCacheDirectoriesPaths', () => {
     let existsSpy: jest.SpyInstance;
     let lstatSpy: jest.SpyInstance;
@@ -103,8 +117,10 @@ describe('cache-utils', () => {
       }));
 
       globCreateSpy = jest.spyOn(glob, 'create');
+
       globCreateSpy.mockImplementation(
-        (pattern: string): Promise<Globber> => MockGlobber.create(['/foo', '/bar'])
+        (pattern: string): Promise<Globber> =>
+          MockGlobber.create(['/foo', '/bar'])
       );
 
       resetProjectDirectoriesMemoized();
@@ -123,18 +139,29 @@ describe('cache-utils', () => {
       [supportedPackageManagers.pnpm, ''],
       [supportedPackageManagers.pnpm, '/dir/file.lock'],
       [supportedPackageManagers.pnpm, '/**/file.lock']
-    ])('getCacheDirectoriesPaths should return one dir for non yarn', async (packageManagerInfo, cacheDependency) => {
+    ])(
+      'getCacheDirectoriesPaths should return one dir for non yarn',
+      async (packageManagerInfo, cacheDependency) => {
         getCommandOutputSpy.mockImplementation(() => 'foo');
 
-      const dirs = await cacheUtils.getCacheDirectories(packageManagerInfo, cacheDependency);
+        const dirs = await cacheUtils.getCacheDirectories(
+          packageManagerInfo,
+          cacheDependency
+        );
         expect(dirs).toEqual(['foo']);
+        // to do not call for a version
+        // call once for get cache folder
         expect(getCommandOutputSpy).toHaveBeenCalledTimes(1);
-    });
+      }
+    );
 
     it('getCacheDirectoriesPaths should return one dir for yarn without cacheDependency', async () => {
       getCommandOutputSpy.mockImplementation(() => 'foo');
 
-      const dirs = await cacheUtils.getCacheDirectories(supportedPackageManagers.yarn, '');
+      const dirs = await cacheUtils.getCacheDirectories(
+        supportedPackageManagers.yarn,
+        ''
+      );
       expect(dirs).toEqual(['foo']);
     });
 
@@ -148,107 +175,168 @@ describe('cache-utils', () => {
       [supportedPackageManagers.yarn, ''],
       [supportedPackageManagers.yarn, '/dir/file.lock'],
       [supportedPackageManagers.yarn, '/**/file.lock']
-    ])('getCacheDirectoriesPaths should throw for getCommandOutput returning empty', async (packageManagerInfo, cacheDependency) => {
+    ])(
+      'getCacheDirectoriesPaths should throw for getCommandOutput returning empty',
+      async (packageManagerInfo, cacheDependency) => {
         getCommandOutputSpy.mockImplementation((command: string) =>
+          // return empty string to indicate getCacheFolderPath failed
+          //        --version still works
           command.includes('version') ? '1.' : ''
         );
 
-      await expect(cacheUtils.getCacheDirectories(packageManagerInfo, cacheDependency)).rejects.toThrow();
+        await expect(
-    });
+          cacheUtils.getCacheDirectories(packageManagerInfo, cacheDependency)
+        ).rejects.toThrow(); //'Could not get cache folder path for /dir');
+      }
+    );
 
     it.each([
       [supportedPackageManagers.yarn, '/dir/file.lock'],
       [supportedPackageManagers.yarn, '/**/file.lock']
-    ])('getCacheDirectoriesPaths should not throw in case of having no directories', async (packageManagerInfo, cacheDependency) => {
+    ])(
+      'getCacheDirectoriesPaths should nothrow in case of having not directories',
+      async (packageManagerInfo, cacheDependency) => {
         lstatSpy.mockImplementation(arg => ({
           isDirectory: () => false
         }));
 
-      await cacheUtils.getCacheDirectories(packageManagerInfo, cacheDependency);
+        await cacheUtils.getCacheDirectories(
+          packageManagerInfo,
+          cacheDependency
+        );
         expect(warningSpy).toHaveBeenCalledTimes(1);
         expect(warningSpy).toHaveBeenCalledWith(
           `No existing directories found containing cache-dependency-path="${cacheDependency}"`
         );
-    });
+      }
+    );
 
-    it.each(['1.1.1', '2.2.2'])('getCacheDirectoriesPaths yarn v%s should return one dir without cacheDependency', async version => {
+    it.each(['1.1.1', '2.2.2'])(
+      'getCacheDirectoriesPaths yarn v%s should return one dir without cacheDependency',
+      async version => {
         getCommandOutputSpy.mockImplementationOnce(() => version);
         getCommandOutputSpy.mockImplementationOnce(() => `foo${version}`);
 
-      const dirs = await cacheUtils.getCacheDirectories(supportedPackageManagers.yarn, '');
+        const dirs = await cacheUtils.getCacheDirectories(
+          supportedPackageManagers.yarn,
+          ''
+        );
         expect(dirs).toEqual([`foo${version}`]);
-    });
+      }
+    );
 
-    it.each(['1.1.1', '2.2.2'])('getCacheDirectoriesPaths yarn v%s should return 2 dirs with globbed cacheDependency', async version => {
+    it.each(['1.1.1', '2.2.2'])(
+      'getCacheDirectoriesPaths yarn v%s should return 2 dirs with globbed cacheDependency',
+      async version => {
         let dirNo = 1;
         getCommandOutputSpy.mockImplementation((command: string) =>
           command.includes('version') ? version : `file_${version}_${dirNo++}`
         );
         globCreateSpy.mockImplementation(
-        (pattern: string): Promise<Globber> => MockGlobber.create(['/tmp/dir1/file', '/tmp/dir2/file'])
+          (pattern: string): Promise<Globber> =>
+            MockGlobber.create(['/tmp/dir1/file', '/tmp/dir2/file'])
         );
 
-      const dirs = await cacheUtils.getCacheDirectories(supportedPackageManagers.yarn, '/tmp/**/file');
+        const dirs = await cacheUtils.getCacheDirectories(
+          supportedPackageManagers.yarn,
+          '/tmp/**/file'
+        );
         expect(dirs).toEqual([`file_${version}_1`, `file_${version}_2`]);
-    });
+      }
+    );
 
-    it.each(['1.1.1', '2.2.2'])('getCacheDirectoriesPaths yarn v%s should return 2 dirs with globbed cacheDependency expanding to duplicates', async version => {
+    it.each(['1.1.1', '2.2.2'])(
+      'getCacheDirectoriesPaths yarn v%s should return 2 dirs  with globbed cacheDependency expanding to duplicates',
+      async version => {
         let dirNo = 1;
         getCommandOutputSpy.mockImplementation((command: string) =>
           command.includes('version') ? version : `file_${version}_${dirNo++}`
         );
         globCreateSpy.mockImplementation(
-        (pattern: string): Promise<Globber> => MockGlobber.create([
+          (pattern: string): Promise<Globber> =>
+            MockGlobber.create([
               '/tmp/dir1/file',
               '/tmp/dir2/file',
               '/tmp/dir1/file'
             ])
         );
 
-      const dirs = await cacheUtils.getCacheDirectories(supportedPackageManagers.yarn, '/tmp/**/file');
+        const dirs = await cacheUtils.getCacheDirectories(
+          supportedPackageManagers.yarn,
+          '/tmp/**/file'
+        );
         expect(dirs).toEqual([`file_${version}_1`, `file_${version}_2`]);
-    });
+      }
+    );
 
-    it.each(['1.1.1', '2.2.2'])('getCacheDirectoriesPaths yarn v%s should return 2 unique dirs despite duplicate cache directories', async version => {
+    it.each(['1.1.1', '2.2.2'])(
+      'getCacheDirectoriesPaths yarn v%s should return 2 uniq dirs despite duplicate cache directories',
+      async version => {
         let dirNo = 1;
         getCommandOutputSpy.mockImplementation((command: string) =>
-        command.includes('version') ? version : `file_${version}_${dirNo++ % 2}`
+          command.includes('version')
+            ? version
+            : `file_${version}_${dirNo++ % 2}`
         );
         globCreateSpy.mockImplementation(
-        (pattern: string): Promise<Globber> => MockGlobber.create([
+          (pattern: string): Promise<Globber> =>
+            MockGlobber.create([
               '/tmp/dir1/file',
               '/tmp/dir2/file',
               '/tmp/dir3/file'
             ])
         );
 
-      const dirs = await cacheUtils.getCacheDirectories(supportedPackageManagers.yarn, '/tmp/**/file');
+        const dirs = await cacheUtils.getCacheDirectories(
+          supportedPackageManagers.yarn,
+          '/tmp/**/file'
+        );
         expect(dirs).toEqual([`file_${version}_1`, `file_${version}_0`]);
         expect(getCommandOutputSpy).toHaveBeenCalledTimes(6);
-      expect(getCommandOutputSpy).toHaveBeenCalledWith('yarn --version', '/tmp/dir1');
-      expect(getCommandOutputSpy).toHaveBeenCalledWith('yarn --version', '/tmp/dir2');
-      expect(getCommandOutputSpy).toHaveBeenCalledWith('yarn --version', '/tmp/dir3');
         expect(getCommandOutputSpy).toHaveBeenCalledWith(
-        version.startsWith('1.') ? 'yarn cache dir' : 'yarn config get cacheFolder',
+          'yarn --version',
           '/tmp/dir1'
         );
         expect(getCommandOutputSpy).toHaveBeenCalledWith(
-        version.startsWith('1.') ? 'yarn cache dir' : 'yarn config get cacheFolder',
+          'yarn --version',
           '/tmp/dir2'
         );
         expect(getCommandOutputSpy).toHaveBeenCalledWith(
-        version.startsWith('1.') ? 'yarn cache dir' : 'yarn config get cacheFolder',
+          'yarn --version',
           '/tmp/dir3'
         );
-    });
+        expect(getCommandOutputSpy).toHaveBeenCalledWith(
+          version.startsWith('1.')
+            ? 'yarn cache dir'
+            : 'yarn config get cacheFolder',
+          '/tmp/dir1'
+        );
+        expect(getCommandOutputSpy).toHaveBeenCalledWith(
+          version.startsWith('1.')
+            ? 'yarn cache dir'
+            : 'yarn config get cacheFolder',
+          '/tmp/dir2'
+        );
+        expect(getCommandOutputSpy).toHaveBeenCalledWith(
+          version.startsWith('1.')
+            ? 'yarn cache dir'
+            : 'yarn config get cacheFolder',
+          '/tmp/dir3'
+        );
+      }
+    );
 
-    it.each(['1.1.1', '2.2.2'])('getCacheDirectoriesPaths yarn v%s should return 4 dirs with multiple globs', async version => {
+    it.each(['1.1.1', '2.2.2'])(
+      'getCacheDirectoriesPaths yarn v%s should return 4 dirs with multiple globs',
+      async version => {
+        // simulate wrong indents
         const cacheDependencyPath = `/tmp/dir1/file
           /tmp/dir2/file
 /tmp/**/file
           `;
         globCreateSpy.mockImplementation(
-        (pattern: string): Promise<Globber> => MockGlobber.create([
+          (pattern: string): Promise<Globber> =>
+            MockGlobber.create([
               '/tmp/dir1/file',
               '/tmp/dir2/file',
               '/tmp/dir3/file',
@@ -259,13 +347,17 @@ describe('cache-utils', () => {
         getCommandOutputSpy.mockImplementation((command: string) =>
           command.includes('version') ? version : `file_${version}_${dirNo++}`
         );
-      const dirs = await cacheUtils.getCacheDirectories(supportedPackageManagers.yarn, cacheDependencyPath);
+        const dirs = await cacheUtils.getCacheDirectories(
+          supportedPackageManagers.yarn,
+          cacheDependencyPath
+        );
         expect(dirs).toEqual([
           `file_${version}_1`,
           `file_${version}_2`,
           `file_${version}_3`,
           `file_${version}_4`
         ]);
-    });
+      }
+    );
   });
 });