Merge branch 'main' into electron-prompt

Author: rakillen

electron/app/test/childProcessExecutor-test.js

@@ -4,32 +4,36 @@
  * Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
  * @ignore
  */
-"use strict";
-const fs = require('fs');
+'use strict';
+
 const path = require('path');
 const proxyquire = require('proxyquire');
-const { assert, expect } = require('chai');
+const { expect } = require('chai');
+const { describe, it } = require('mocha');
 const osUtils = require('../js/osUtils');
 
 const wktLoggerMock = {
   getLogger: () => {
     return console;
   }
-}
+};
 
 const { executeFileCommand, executeScriptCommand } = proxyquire('../js/childProcessExecutor', { './wktLogging': wktLoggerMock });
 
-it('verify node version is returned', async () => {
+/* global __dirname, process */
+describe('Child Process Executor tests', () => {
+  it('verify node version is returned', async () => {
     const args = [ '-v' ];
 
     const output = await executeFileCommand('node', args);
     expect(output.trim()).is.equal(process.version);
-});
+  });
 
-it('verify spaces in file path work', async() => {
-  const scriptPath = path.join(__dirname, 'dir with spaces', 'testScript') + (osUtils.isWindows() ? '.cmd' : '.sh');
-  const argList = [ '-v', 'some args with lots of spaces' ];
+  it('verify spaces in file path work', async() => {
+    const scriptPath = path.join(__dirname, 'dir with spaces', 'testScript') + (osUtils.isWindows() ? '.cmd' : '.sh');
+    const argList = [ '-v', 'some args with lots of spaces' ];
 
-  const output = await executeScriptCommand(scriptPath, argList);
-  expect(output.trim()).is.equal('Hello World from dir with spaces with 2 arguments');
+    const output = await executeScriptCommand(scriptPath, argList);
+    expect(output.trim()).is.equal('Hello World from dir with spaces with 2 arguments');
+  });
 });

electron/app/test/credentialEncryptor-test.js

@@ -4,30 +4,33 @@
  * Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
  * @ignore
  */
-"use strict";
-const proxyquire = require('proxyquire');
-const { assert, expect } = require('chai');
+'use strict';
+
+const { expect } = require('chai');
+const { describe, it } = require('mocha');
 const CredentialEncryptor = require('../js/credentialEncryptor');
 
-const passphrase = 'isdfgwgfigr94re9fhc8oifh298ei';
-let encryptor = new CredentialEncryptor(passphrase);
-const textToHide = 'My Super Secret Text';
-const storedEncryptedText = 'eJwVy8lygjAAANAP6jgUZLEHDg0RWzKNbEblBmHfIRIIX+/03R/qiheGw0evTelSD+RHXJL42zQPy9AWt0gn9d6' +
-  'NNnx4YMlzxb/5nKvmIbWRv/ZWI+mrhZJAOsqvU/u/NrqV4LK6qKeGnEVUsqeMlZVPCJb0qn1SZ2pUy3OrcODub8yFoz2P3tblyXyHhed06hSipc72' +
-  'l+XgqPurTkY+rmRGArHz/DCIajBRGlqqoSuGioia+DPmQKaWq8CpzIJNyTGGoCBhwvoKbNl5L+/CYcK/LqDhI/uaqaLyOGDmGyy9VlY=';
-let encryptedText;
+describe('Credential Encryptor tests', () => {
+  const passphrase = 'isdfgwgfigr94re9fhc8oifh298ei';
+  let encryptor = new CredentialEncryptor(passphrase);
+  const textToHide = 'My Super Secret Text';
+  const storedEncryptedText = 'eJwVy8lygjAAANAP6jgUZLEHDg0RWzKNbEblBmHfIRIIX+/03R/qiheGw0evTelSD+RHXJL42zQPy9AWt0gn9d6' +
+    'NNnx4YMlzxb/5nKvmIbWRv/ZWI+mrhZJAOsqvU/u/NrqV4LK6qKeGnEVUsqeMlZVPCJb0qn1SZ2pUy3OrcODub8yFoz2P3tblyXyHhed06hSipc72' +
+    'l+XgqPurTkY+rmRGArHz/DCIajBRGlqqoSuGioia+DPmQKaWq8CpzIJNyTGGoCBhwvoKbNl5L+/CYcK/LqDhI/uaqaLyOGDmGyy9VlY=';
+  let encryptedText;
 
-it('encryption works', () => {
-  encryptedText = encryptor.getEncryptedText(textToHide);
-  expect(encryptedText).to.not.be.null;
-});
+  it('encryption works', () => {
+    encryptedText = encryptor.getEncryptedText(textToHide);
+    expect(encryptedText).to.not.be.null;
+  });
 
-it('decryption works', () => {
-  const clearText = encryptor.getDecryptedText(encryptedText);
-  expect(clearText).to.equal(textToHide);
-});
+  it('decryption works', () => {
+    const clearText = encryptor.getDecryptedText(encryptedText);
+    expect(clearText).to.equal(textToHide);
+  });
 
-it('decryption with new encryptor works', () => {
-  const clearText = encryptor.getDecryptedText(storedEncryptedText);
-  expect(clearText).to.equal(textToHide);
+  it('decryption with new encryptor works', () => {
+    const clearText = encryptor.getDecryptedText(storedEncryptedText);
+    expect(clearText).to.equal(textToHide);
+  });
 });

electron/app/test/credentialStore-test.js

@@ -4,120 +4,125 @@
  * Licensed under the Universal Permissive License v 1.0 as shown at https://oss.oracle.com/licenses/upl.
  * @ignore
  */
-"use strict";
+'use strict';
+
 const proxyquire = require('proxyquire');
 const { assert, expect } = require('chai');
+const { before, describe, it } = require('mocha');
 const osUtils = require('../js/osUtils');
 
-const wktLoggerMock = {
-  getLogger: () => {
-    return console;
-  }
-}
+/* global process */
+describe('Credential Store tests', () => {
+  const wktLoggerMock = {
+    getLogger: () => {
+      return console;
+    }
+  };
 
-const CredentialStore = proxyquire('../js/credentialStore', { './wktLogging': wktLoggerMock });
-let credStore;
+  const CredentialStore = proxyquire('../js/credentialStore', { './wktLogging': wktLoggerMock });
+  let credStore;
 
-let skipTestsInJenkins = false;
-if (osUtils.isMac() && 'JENKINS_NODE_COOKIE' in process.env) {
-  skipTestsInJenkins = true;
-}
+  let skipTestsInJenkins = false;
+  if (osUtils.isMac() && 'JENKINS_NODE_COOKIE' in process.env) {
+    skipTestsInJenkins = true;
+  }
 
-before(async () => {
-  credStore = new CredentialStore('wktui-test');
-  await cleanStaleCredentials();
-});
+  before(async () => {
+    credStore = new CredentialStore('wktui-test');
+    await cleanStaleCredentials();
+  });
 
-async function cleanStaleCredentials() {
-  const staleCreds = credStore.findCredentials();
-  if (staleCreds && Array.isArray(staleCreds)) {
-    for (const staleCred of staleCreds) {
-      await credStore.deleteCredential(staleCred.account);
+  async function cleanStaleCredentials() {
+    const staleCreds = credStore.findCredentials();
+    if (staleCreds && Array.isArray(staleCreds)) {
+      for (const staleCred of staleCreds) {
+        await credStore.deleteCredential(staleCred.account);
+      }
     }
   }
-}
 
-if (!skipTestsInJenkins) {
-  it('store new credential works', async () => {
-    try {
-      await credStore.storeCredential('test1', 'f00b@r!');
-    } catch (err) {
-      assert.fail(`Failed to store credential test1: ${err}`);
-    }
-  });
+  if (!skipTestsInJenkins) {
+    it('store new credential works', async () => {
+      try {
+        await credStore.storeCredential('test1', 'f00b@r!');
+      } catch (err) {
+        assert.fail(`Failed to store credential test1: ${err}`);
+      }
+    });
 
-  // On the Jenkins MacOS slaves, this test fails at least half the time with the error:
-  // The specified item already exists in the keychain.  This causes some of the subsequent
-  // tests to fail.
-  //
-  // This has never once reproduced on a developer's MacOS machine so we will just not run
-  // the tests in the Jenkins MacOS environment.
-  //
-  it('replace existing credential works', async () => {
-    try {
-      await credStore.storeCredential('test1', '8e7rty9wrfhofhd98@92382093ue09udjo8dfsyu');
-      const newCredentialValue = await credStore.getCredential('test1');
-      expect(newCredentialValue).to.equal('8e7rty9wrfhofhd98@92382093ue09udjo8dfsyu');
-    } catch (err) {
-      assert.fail(`Failed to replace existing credential test1: ${err}`);
-    }
-  });
+    // On the Jenkins MacOS slaves, this test fails at least half the time with the error:
+    // The specified item already exists in the keychain.  This causes some of the subsequent
+    // tests to fail.
+    //
+    // This has never once reproduced on a developer's MacOS machine so we will just not run
+    // the tests in the Jenkins MacOS environment.
+    //
+    it('replace existing credential works', async () => {
+      try {
+        await credStore.storeCredential('test1', '8e7rty9wrfhofhd98@92382093ue09udjo8dfsyu');
+        const newCredentialValue = await credStore.getCredential('test1');
+        expect(newCredentialValue).to.equal('8e7rty9wrfhofhd98@92382093ue09udjo8dfsyu');
+      } catch (err) {
+        assert.fail(`Failed to replace existing credential test1: ${err}`);
+      }
+    });
 
-  it('get existing credential works', async () => {
-    try {
-      const credentialValue = await credStore.getCredential('test1');
-      expect(credentialValue).to.equal('8e7rty9wrfhofhd98@92382093ue09udjo8dfsyu');
-    } catch (err) {
-      assert.fail(`Failed to get existing credential test1: ${err}`);
-    }
-  });
+    it('get existing credential works', async () => {
+      try {
+        const credentialValue = await credStore.getCredential('test1');
+        expect(credentialValue).to.equal('8e7rty9wrfhofhd98@92382093ue09udjo8dfsyu');
+      } catch (err) {
+        assert.fail(`Failed to get existing credential test1: ${err}`);
+      }
+    });
 
-  it('get non-existent credential works as expected', async () => {
-    try {
-      const credentialValue = await credStore.getCredential('test2');
-      expect(credentialValue).to.be.null;
-    } catch (err) {
-      assert.fail(`Failed to get non-existent credential test2: ${err}`);
-    }
-  });
+    it('get non-existent credential works as expected', async () => {
+      try {
+        const credentialValue = await credStore.getCredential('test2');
+        expect(credentialValue).to.be.null;
+      } catch (err) {
+        assert.fail(`Failed to get non-existent credential test2: ${err}`);
+      }
+    });
 
-  it('find credentials to work', async () => {
-    try {
-      const credentials = await credStore.findCredentials();
-      expect(credentials).to.not.be.null;
-      expect(credentials).to.have.length(1);
-      expect(credentials[0].name).to.equal('test1');
-      expect(credentials[0].value).to.equal('8e7rty9wrfhofhd98@92382093ue09udjo8dfsyu');
-    } catch (err) {
-      assert.fail(`Failed to get credentials: ${err}`);
-    }
-  });
+    it('find credentials to work', async () => {
+      try {
+        const credentials = await credStore.findCredentials();
+        expect(credentials).to.not.be.null;
+        expect(credentials).to.have.length(1);
+        expect(credentials[0].name).to.equal('test1');
+        expect(credentials[0].value).to.equal('8e7rty9wrfhofhd98@92382093ue09udjo8dfsyu');
+      } catch (err) {
+        assert.fail(`Failed to get credentials: ${err}`);
+      }
+    });
 
-  it('delete non-existent credential works as expected', async () => {
-    try {
-      const result = await credStore.deleteCredential('test2');
-      expect(result).to.be.false;
-    } catch (err) {
-      assert.fail(`Failed to handle delete for non-existent credential: ${err}`);
-    }
-  });
+    it('delete non-existent credential works as expected', async () => {
+      try {
+        const result = await credStore.deleteCredential('test2');
+        expect(result).to.be.false;
+      } catch (err) {
+        assert.fail(`Failed to handle delete for non-existent credential: ${err}`);
+      }
+    });
 
-  it('delete existing credential works as expected', async () => {
-    try {
-      const result = await credStore.deleteCredential('test1');
-      expect(result).to.be.true;
-    } catch (err) {
-      assert.fail(`Failed to handle delete for existing credential: ${err}`);
-    }
-  });
+    it('delete existing credential works as expected', async () => {
+      try {
+        const result = await credStore.deleteCredential('test1');
+        expect(result).to.be.true;
+      } catch (err) {
+        assert.fail(`Failed to handle delete for existing credential: ${err}`);
+      }
+    });
 
-  it('find credentials when there are none works as expected', async () => {
-    try {
-      const credentials = await credStore.findCredentials();
-      expect(credentials).to.not.be.null;
-      expect(credentials).to.have.length(0);
-    } catch (err) {
-      assert.fail(`Failed to get credentials when there were none: ${err}`);
-    }
-  });
-}
+    it('find credentials when there are none works as expected', async () => {
+      try {
+        const credentials = await credStore.findCredentials();
+        expect(credentials).to.not.be.null;
+        expect(credentials).to.have.length(0);
+      } catch (err) {
+        assert.fail(`Failed to get credentials when there were none: ${err}`);
+      }
+    });
+  }
+});