fixed async/await test case fallout from eslint changes

Signed-off-by: Jeromy Cannon <[email protected]>

Author: jeromy-cannon

Diff for: test/unit/core/platform_installer.test.mjs

@@ -36,61 +36,61 @@ describe('PackageInstaller', () => {
   const installer = new PlatformInstaller(testLogger, k8, configManager, accountManager)
 
   describe('validatePlatformReleaseDir', () => {
-    it('should fail for missing path', async () => {
+    it('should fail for missing path', () => {
       expect.assertions(1)
-      await expect(installer.validatePlatformReleaseDir('')).rejects.toThrow(MissingArgumentError)
+      expect(() => { installer.validatePlatformReleaseDir('') }).toThrow(MissingArgumentError)
     })
 
-    it('should fail for invalid path', async () => {
+    it('should fail for invalid path', () => {
       expect.assertions(1)
-      await expect(installer.validatePlatformReleaseDir('/INVALID')).rejects.toThrow(IllegalArgumentError)
+      expect(() => { installer.validatePlatformReleaseDir('/INVALID') }).toThrow(IllegalArgumentError)
     })
 
-    it('should fail if directory does not have data/apps directory', async () => {
+    it('should fail if directory does not have data/apps directory', () => {
       expect.assertions(1)
 
       const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'installer-'))
       fs.mkdirSync(`${tmpDir}/${core.constants.HEDERA_DATA_LIB_DIR}`, { recursive: true })
-      await expect(installer.validatePlatformReleaseDir(tmpDir)).rejects.toThrow(IllegalArgumentError)
+      expect(() => { installer.validatePlatformReleaseDir(tmpDir) }).toThrow(IllegalArgumentError)
       fs.rmSync(tmpDir, { recursive: true })
     })
 
-    it('should fail if directory does not have data/libs directory', async () => {
+    it('should fail if directory does not have data/libs directory', () => {
       expect.assertions(1)
 
       const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'installer-'))
       fs.mkdirSync(`${tmpDir}/${core.constants.HEDERA_DATA_APPS_DIR}`, { recursive: true })
-      await expect(installer.validatePlatformReleaseDir(tmpDir)).rejects.toThrow(IllegalArgumentError)
+      expect(() => { installer.validatePlatformReleaseDir(tmpDir) }).toThrow(IllegalArgumentError)
       fs.rmSync(tmpDir, { recursive: true })
     })
 
-    it('should fail if directory does not have data/app directory is empty', async () => {
+    it('should fail if directory does not have data/app directory is empty', () => {
       expect.assertions(1)
 
       const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'installer-'))
       fs.mkdirSync(`${tmpDir}/${core.constants.HEDERA_DATA_APPS_DIR}`, { recursive: true })
       fs.mkdirSync(`${tmpDir}/${core.constants.HEDERA_DATA_LIB_DIR}`, { recursive: true })
       fs.writeFileSync(`${tmpDir}/${core.constants.HEDERA_DATA_LIB_DIR}/test.jar`, '')
-      await expect(installer.validatePlatformReleaseDir()).rejects.toThrow(MissingArgumentError)
+      expect(() => { installer.validatePlatformReleaseDir() }).toThrow(MissingArgumentError)
       fs.rmSync(tmpDir, { recursive: true })
     })
 
-    it('should fail if directory does not have data/apps directory is empty', async () => {
+    it('should fail if directory does not have data/apps directory is empty', () => {
       const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'installer-app-'))
       fs.mkdirSync(`${tmpDir}/${core.constants.HEDERA_DATA_APPS_DIR}`, { recursive: true })
       fs.writeFileSync(`${tmpDir}/${core.constants.HEDERA_DATA_APPS_DIR}/app.jar`, '')
       fs.mkdirSync(`${tmpDir}/${core.constants.HEDERA_DATA_LIB_DIR}`, { recursive: true })
-      await expect(installer.validatePlatformReleaseDir()).rejects.toThrow(MissingArgumentError)
+      expect(() => { installer.validatePlatformReleaseDir() }).toThrow(MissingArgumentError)
       fs.rmSync(tmpDir, { recursive: true })
     })
 
-    it('should succeed with non-empty data/apps and data/libs directory', async () => {
+    it('should succeed with non-empty data/apps and data/libs directory', () => {
       const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'installer-lib-'))
       fs.mkdirSync(`${tmpDir}/${core.constants.HEDERA_DATA_APPS_DIR}`, { recursive: true })
       fs.writeFileSync(`${tmpDir}/${core.constants.HEDERA_DATA_APPS_DIR}/app.jar`, '')
       fs.mkdirSync(`${tmpDir}/${core.constants.HEDERA_DATA_LIB_DIR}`, { recursive: true })
       fs.writeFileSync(`${tmpDir}/${core.constants.HEDERA_DATA_LIB_DIR}/lib-1.jar`, '')
-      await expect(installer.validatePlatformReleaseDir()).rejects.toThrow(MissingArgumentError)
+      expect(() => { installer.validatePlatformReleaseDir() }).toThrow(MissingArgumentError)
       fs.rmSync(tmpDir, { recursive: true })
     })
   })

Diff for: test/unit/core/zippy.test.mjs

@@ -14,7 +14,6 @@
  * limitations under the License.
  *
  */
-import { describe, expect, it } from '@jest/globals'
 import * as core from '../../../src/core/index.mjs'
 import { SoloError, IllegalArgumentError, MissingArgumentError } from '../../../src/core/errors.mjs'
 import os from 'os'
@@ -26,72 +25,72 @@ describe('Zippy', () => {
   const zippy = new Zippy(testLogger)
 
   describe('unzip', () => {
-    it('should fail if source file is missing', async () => {
+    it('should fail if source file is missing', () => {
       expect.assertions(1)
-      await expect(zippy.unzip('', '')).rejects.toThrow(MissingArgumentError)
+      expect(() => { zippy.unzip('', '') }).toThrow(MissingArgumentError)
     })
 
-    it('should fail if destination file is missing', async () => {
+    it('should fail if destination file is missing', () => {
       expect.assertions(1)
-      await expect(zippy.unzip('', '')).rejects.toThrow(MissingArgumentError)
+      expect(() => { zippy.unzip('', '') }).toThrow(MissingArgumentError)
     })
 
-    it('should fail if source file is invalid', async () => {
+    it('should fail if source file is invalid', () => {
       expect.assertions(1)
-      await expect(zippy.unzip('/INVALID', os.tmpdir())).rejects.toThrow(IllegalArgumentError)
+      expect(() => { zippy.unzip('/INVALID', os.tmpdir()) }).toThrow(IllegalArgumentError)
     })
 
-    it('should fail for a directory', async () => {
+    it('should fail for a directory', () => {
       expect.assertions(1)
-      await expect(zippy.unzip('test/data', os.tmpdir())).rejects.toThrow(SoloError)
+      expect(() => { zippy.unzip('test/data', os.tmpdir()) }).toThrow(SoloError)
     })
 
-    it('should fail for a non-zip file', async () => {
+    it('should fail for a non-zip file', () => {
       expect.assertions(1)
-      await expect(zippy.unzip('test/data/test.txt', os.tmpdir())).rejects.toThrow(SoloError)
+      expect(() => { zippy.unzip('test/data/test.txt', os.tmpdir()) }).toThrow(SoloError)
     })
 
     it('should succeed for valid inputs', async () => {
       const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'installer-'))
       const zipFile = `${tmpDir}/test.zip`
       const unzippedFile = `${tmpDir}/unzipped`
       await expect(zippy.zip('test/data/.empty', zipFile)).resolves.toBe(zipFile)
-      await expect(zippy.unzip(zipFile, unzippedFile, true)).resolves.toBe(unzippedFile)
+      expect(zippy.unzip(zipFile, unzippedFile, true)).toBe(unzippedFile)
       fs.rmSync(tmpDir, { recursive: true, force: true }) // not very safe!
     })
   })
 
   describe('untar', () => {
-    it('should fail if source file is missing', async () => {
+    it('should fail if source file is missing', () => {
       expect.assertions(1)
-      await expect(zippy.untar('', '')).rejects.toThrow(MissingArgumentError)
+      expect(() => { zippy.untar('', '') }).toThrow(MissingArgumentError)
     })
 
-    it('should fail if destination file is missing', async () => {
+    it('should fail if destination file is missing', () => {
       expect.assertions(1)
-      await expect(zippy.untar('', '')).rejects.toThrow(MissingArgumentError)
+      expect(() => { zippy.untar('', '') }).toThrow(MissingArgumentError)
     })
 
-    it('should fail if source file is invalid', async () => {
+    it('should fail if source file is invalid', () => {
       expect.assertions(1)
-      await expect(zippy.untar('/INVALID', os.tmpdir())).rejects.toThrow(IllegalArgumentError)
+      expect(() => { zippy.untar('/INVALID', os.tmpdir()) }).toThrow(IllegalArgumentError)
     })
 
-    it('should fail for a directory', async () => {
+    it('should fail for a directory', () => {
       expect.assertions(1)
-      await expect(zippy.untar('test/data', os.tmpdir())).rejects.toThrow(SoloError)
+      expect(() => { zippy.untar('test/data', os.tmpdir()) }).toThrow(SoloError)
     })
 
-    it('should fail for a non-tar file', async () => {
+    it('should fail for a non-tar file', () => {
       expect.assertions(1)
-      await expect(zippy.untar('test/data/test.txt', os.tmpdir())).rejects.toThrow(SoloError)
+      expect(() => { zippy.untar('test/data/test.txt', os.tmpdir()) }).toThrow(SoloError)
     })
 
-    it('should succeed for valid inputs', async () => {
+    it('should succeed for valid inputs', () => {
       const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'installer-'))
       const tarFile = `${tmpDir}/test.tar.gz`
-      await expect(zippy.tar('test/data/.empty', tarFile)).resolves.toBe(tarFile)
-      await expect(zippy.untar(tarFile, tmpDir, true)).resolves.toBe(tmpDir)
+      expect(zippy.tar('test/data/.empty', tarFile), 'tar file should match').toBe(tarFile)
+      expect(zippy.untar(tarFile, tmpDir), 'tmp dir should match').toBe(tmpDir)
       fs.rmSync(tmpDir, { recursive: true, force: true }) // not very safe!
     })
   })