chore: refactor usage of connection object. fix more tests

Author: sfdctaka

src/commands/lightning/preview/app.ts

@@ -21,7 +21,7 @@ import chalk from 'chalk';
 import { OrgUtils } from '../../../shared/orgUtils.js';
 import { startLWCServer } from '../../../lwc-dev-server/index.js';
 import { PreviewUtils } from '../../../shared/previewUtils.js';
-import { ConfigUtils } from '../../../shared/configUtils.js';
+import { AppServerIdentityTokenService, ConfigUtils } from '../../../shared/configUtils.js';
 
 Messages.importMessagesDirectoryFromMetaUrl(import.meta.url);
 const messages = Messages.loadMessages('@salesforce/plugin-lightning-dev', 'lightning.preview.app');
@@ -165,7 +165,8 @@ export default class LightningPreviewApp extends SfCommand<void> {
       return Promise.reject(new Error(messages.getMessage('error.username')));
     }
 
-    const token = await ConfigUtils.getOrCreateIdentityToken(username, connection);
+    const tokenService = new AppServerIdentityTokenService(connection);
+    const token = await ConfigUtils.getOrCreateIdentityToken(username, tokenService);
 
     let appId: string | undefined;
     if (appName) {

src/shared/configUtils.ts

@@ -10,6 +10,27 @@ import { CryptoUtils, SSLCertificateData } from '@salesforce/lwc-dev-mobile-core
 import { Config, ConfigAggregator, Connection } from '@salesforce/core';
 import configMeta, { ConfigVars, SerializedSSLCertificateData } from './../configMeta.js';
 
+// eslint-disable-next-line @typescript-eslint/consistent-type-definitions
+export interface IdentityTokenService {
+  saveTokenToServer(token: string): Promise<string>;
+}
+
+export class AppServerIdentityTokenService implements IdentityTokenService {
+  private connection: Connection;
+  public constructor(connection: Connection) {
+    this.connection = connection;
+  }
+
+  public async saveTokenToServer(token: string): Promise<string> {
+    const sobject = this.connection.sobject('UserLocalWebServerIdentity');
+    const result = await sobject.insert({ LocalWebServerIdentityToken: token });
+    if (result.success) {
+      return result.id;
+    }
+    throw new Error('Could not save the token to the server');
+  }
+}
+
 export const LOCAL_DEV_SERVER_DEFAULT_PORT = 8081;
 export const LOCAL_DEV_SERVER_DEFAULT_WORKSPACE = Workspace.SfCli;
 
@@ -40,11 +61,11 @@ export class ConfigUtils {
     return this.#globalConfig;
   }
 
-  public static async getOrCreateIdentityToken(username: string, connection: Connection): Promise<string> {
+  public static async getOrCreateIdentityToken(username: string, tokenService: IdentityTokenService): Promise<string> {
     let identityData = await this.getIdentityData();
     if (!identityData) {
       const token = CryptoUtils.generateIdentityToken();
-      const entityId = await this.saveIdentityTokenToServer(token, connection);
+      const entityId = await tokenService.saveTokenToServer(token);
       identityData = {
         identityToken: token,
         usernameToServerEntityIdMap: {},
@@ -53,7 +74,7 @@ export class ConfigUtils {
       await this.writeIdentityData(identityData);
       return token;
     } else {
-      const entityId = await this.saveIdentityTokenToServer(identityData.identityToken, connection);
+      const entityId = await tokenService.saveTokenToServer(identityData.identityToken);
       identityData.usernameToServerEntityIdMap[username] = entityId;
       await this.writeIdentityData(identityData);
       return identityData.identityToken;
@@ -62,7 +83,9 @@ export class ConfigUtils {
 
   public static async writeIdentityData(identityData: LocalWebServerIdentityData): Promise<void> {
     const config = await this.getConfig();
-    config.set(ConfigVars.LOCAL_WEB_SERVER_IDENTITY_DATA, identityData);
+    // TODO: JSON needs to be stringified in order for config.write to encrypt. When config.write()
+    //       can encrypt JSON data to write it into config we shall remove stringify().
+    config.set(ConfigVars.LOCAL_WEB_SERVER_IDENTITY_DATA, JSON.stringify(identityData));
     await config.write();
   }
 
@@ -116,17 +139,8 @@ export class ConfigUtils {
     const identityJson = config.getPropertyValue(ConfigVars.LOCAL_WEB_SERVER_IDENTITY_DATA);
 
     if (identityJson) {
-      return identityJson as LocalWebServerIdentityData;
+      return JSON.parse(identityJson as string) as LocalWebServerIdentityData;
     }
     return undefined;
   }
-
-  private static async saveIdentityTokenToServer(token: string, connection: Connection): Promise<string> {
-    const sobject = connection.sobject('UserLocalWebServerIdentity');
-    const result = await sobject.insert({ LocalWebServerIdentityToken: token });
-    if (result.success) {
-      return result.id;
-    }
-    throw new Error('Could not save the token to the server');
-  }
 }

test/commands/lightning/preview/app.test.ts

@@ -7,7 +7,7 @@
 
 import path from 'node:path';
 import { Config as OclifConfig } from '@oclif/core';
-import { Config as SfConfig, Messages } from '@salesforce/core';
+import { Config as SfConfig, Messages, Connection } from '@salesforce/core';
 import { MockTestOrgData, TestContext } from '@salesforce/core/testSetup';
 import {
   AndroidVirtualDevice,
@@ -98,6 +98,16 @@ describe('lightning preview app', () => {
     }
   });
 
+  it('throws when username not found', async () => {
+    try {
+      $$.SANDBOX.stub(OrgUtils, 'getAppId').resolves(undefined);
+      $$.SANDBOX.stub(Connection.prototype, 'getUsername').returns(undefined);
+      await MockedLightningPreviewApp.run(['--name', 'blah', '-o', testOrgData.username]);
+    } catch (err) {
+      expect(err).to.be.an('error').with.property('message', messages.getMessage('error.username'));
+    }
+  });
+
   it('throws when cannot determine ldp server url', async () => {
     try {
       $$.SANDBOX.stub(OrgUtils, 'getAppId').resolves(testAppId);

test/shared/configUtils.test.ts

@@ -10,13 +10,22 @@ import { Workspace } from '@lwc/lwc-dev-server';
 import { Config, ConfigAggregator, Connection } from '@salesforce/core';
 import { TestContext } from '@salesforce/core/testSetup';
 import { CryptoUtils } from '@salesforce/lwc-dev-mobile-core';
-import { ConfigUtils, LocalWebServerIdentityData } from '../../src/shared/configUtils.js';
+import { ConfigUtils, LocalWebServerIdentityData, IdentityTokenService } from '../../src/shared/configUtils.js';
 import { ConfigVars } from '../../src/configMeta.js';
 
 describe('configUtils', () => {
   const $$ = new TestContext();
   const fakeIdentityToken = 'PFT1vw8v65aXd2b9HFvZ3Zu4OcKZwjI60bq7BEjj5k4=';
   const username = 'SalesforceDeveloper';
+  const fakeEntityId = 'entityId';
+
+  class TestIdentityTokenService implements IdentityTokenService {
+    // eslint-disable-next-line class-methods-use-this, @typescript-eslint/no-unused-vars
+    public saveTokenToServer(token: string): Promise<string> {
+      return Promise.resolve(fakeEntityId);
+    }
+  }
+  const testTokenService = new TestIdentityTokenService();
 
   afterEach(() => {
     $$.restore();
@@ -27,27 +36,22 @@ describe('configUtils', () => {
       identityToken: fakeIdentityToken,
       usernameToServerEntityIdMap: {},
     };
-    identityData.usernameToServerEntityIdMap[username] = 'entityId';
-    const stubConnection = $$.SANDBOX.createStubInstance(Connection);
+    identityData.usernameToServerEntityIdMap[username] = fakeEntityId;
     $$.SANDBOX.stub(ConfigUtils, 'getIdentityData').resolves(identityData);
     $$.SANDBOX.stub(Connection, 'create').resolves(Connection.prototype);
+    $$.SANDBOX.stub(ConfigUtils, 'writeIdentityData').resolves();
 
-    const resolved = await ConfigUtils.getOrCreateIdentityToken(username, stubConnection);
+    const resolved = await ConfigUtils.getOrCreateIdentityToken(username, testTokenService);
 
     expect(resolved).to.equal(fakeIdentityToken);
   });
 
   it('getOrCreateIdentityToken resolves and writeIdentityData is called when there is no identity data', async () => {
-    const stubConnection = $$.SANDBOX.createStubInstance(Connection);
     $$.SANDBOX.stub(ConfigUtils, 'getIdentityData').resolves(undefined);
     $$.SANDBOX.stub(CryptoUtils, 'generateIdentityToken').resolves(fakeIdentityToken);
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    $$.SANDBOX.stub(ConfigUtils as any, 'saveIdentityTokenToServer')
-      .withArgs(fakeIdentityToken, stubConnection)
-      .resolves('entityId');
     const writeIdentityTokenStub = $$.SANDBOX.stub(ConfigUtils, 'writeIdentityData').resolves();
 
-    const resolved = await ConfigUtils.getOrCreateIdentityToken(username, stubConnection);
+    const resolved = await ConfigUtils.getOrCreateIdentityToken(username, testTokenService);
 
     expect(resolved).to.equal(fakeIdentityToken);
     expect(writeIdentityTokenStub.calledOnce).to.be.true;
@@ -63,12 +67,17 @@ describe('configUtils', () => {
   });
 
   it('getIdentityData resolves when identity data is available', async () => {
+    const identityData: LocalWebServerIdentityData = {
+      identityToken: fakeIdentityToken,
+      usernameToServerEntityIdMap: {},
+    };
+    const stringifiedData = JSON.stringify(identityData);
     $$.SANDBOX.stub(ConfigAggregator, 'create').resolves(ConfigAggregator.prototype);
     $$.SANDBOX.stub(ConfigAggregator.prototype, 'reload').resolves();
-    $$.SANDBOX.stub(ConfigAggregator.prototype, 'getPropertyValue').returns(fakeIdentityToken);
+    $$.SANDBOX.stub(ConfigAggregator.prototype, 'getPropertyValue').returns(stringifiedData);
 
     const resolved = await ConfigUtils.getIdentityData();
-    expect(resolved).to.equal(fakeIdentityToken);
+    expect(resolved).to.deep.equal(identityData);
   });
 
   it('writeIdentityData resolves', async () => {

test/shared/previewUtils.test.ts

@@ -112,11 +112,11 @@ describe('previewUtils', () => {
   it('generateDesktopPreviewLaunchArguments', async () => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     $$.SANDBOX.stub(PreviewUtils as any, 'getEntityId')
-      .withArgs([username])
+      .withArgs(username)
       .resolves(entityId);
 
     expect(
-      PreviewUtils.generateDesktopPreviewLaunchArguments(
+      await PreviewUtils.generateDesktopPreviewLaunchArguments(
         'MyLdpServerUrl',
         username,
         'MyAppId',
@@ -130,7 +130,7 @@ describe('previewUtils', () => {
       'MyTargetOrg',
     ]);
 
-    expect(PreviewUtils.generateDesktopPreviewLaunchArguments('MyLdpServerUrl', username)).to.deep.equal([
+    expect(await PreviewUtils.generateDesktopPreviewLaunchArguments('MyLdpServerUrl', username)).to.deep.equal([
       '--path',
       `lightning?0.aura.ldpServerUrl=MyLdpServerUrl&0.aura.ldpServerId=${entityId}&0.aura.mode=DEVPREVIEW`,
     ]);
@@ -139,19 +139,26 @@ describe('previewUtils', () => {
   it('generateMobileAppPreviewLaunchArguments', async () => {
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
     $$.SANDBOX.stub(PreviewUtils as any, 'getEntityId')
-      .withArgs([username])
+      .withArgs(username)
       .resolves(entityId);
 
     expect(
-      PreviewUtils.generateMobileAppPreviewLaunchArguments('MyLdpServerUrl', 'MyAppName', 'MyAppId', 'MyAuraMode')
+      await PreviewUtils.generateMobileAppPreviewLaunchArguments(
+        'MyLdpServerUrl',
+        username,
+        'MyAppName',
+        'MyAppId',
+        'MyAuraMode'
+      )
     ).to.deep.equal([
       { name: 'LightningExperienceAppName', value: 'MyAppName' },
       { name: 'LightningExperienceAppID', value: 'MyAppId' },
       { name: '0.aura.ldpServerUrl', value: 'MyLdpServerUrl' },
       { name: '0.aura.mode', value: 'MyAuraMode' },
+      { name: '0.aura.ldpServerId', value: entityId },
     ]);
 
-    expect(PreviewUtils.generateMobileAppPreviewLaunchArguments('MyLdpServerUrl', username)).to.deep.equal([
+    expect(await PreviewUtils.generateMobileAppPreviewLaunchArguments('MyLdpServerUrl', username)).to.deep.equal([
       { name: '0.aura.ldpServerUrl', value: 'MyLdpServerUrl' },
       { name: '0.aura.mode', value: 'DEVPREVIEW' },
       { name: '0.aura.ldpServerId', value: entityId },