fix: flushFilePath() with fix for Windows

packages/salesforcedx-utils-vscode/src/helpers/index.ts

@@ -5,14 +5,6 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 
-export { isNullOrUndefined, extractJsonObject } from './utils';
-export {
-  isAlphaNumString,
-  isInteger,
-  isIntegerInRange,
-  isAlphaNumSpaceString,
-  isRecordIdFormat
-} from './validations';
 export {
   ensureDirectoryExists,
   getTestResultsFolder,
@@ -21,3 +13,16 @@ export {
 } from './paths';
 export { TraceFlags } from './traceFlags';
 export { TraceFlagsRemover } from './traceFlagsRemover';
+export {
+  isNullOrUndefined,
+  extractJsonObject,
+  flushFilePath,
+  flushFilePaths
+} from './utils';
+export {
+  isAlphaNumString,
+  isInteger,
+  isIntegerInRange,
+  isAlphaNumSpaceString,
+  isRecordIdFormat
+} from './validations';

packages/salesforcedx-utils-vscode/src/helpers/utils.ts

@@ -5,6 +5,8 @@
  * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
  */
 
+import * as fs from 'fs';
+
 export function isNullOrUndefined(object: any): object is null | undefined {
   if (object === null || object === undefined) {
     return true;
@@ -14,11 +16,40 @@ export function isNullOrUndefined(object: any): object is null | undefined {
 }
 
 export function extractJsonObject(str: string): any {
-
-  const jsonString = str.substring(
-    str.indexOf('{'),
-    str.lastIndexOf('}') + 1
-  );
+  const jsonString = str.substring(str.indexOf('{'), str.lastIndexOf('}') + 1);
 
   return JSON.parse(jsonString);
 }
+
+// There's a bug in VS Code where, after a file has been renamed,
+// the URI that VS Code passes to the command is stale and is the
+// original URI.  See https://github.com/microsoft/vscode/issues/152993.
+//
+// To get around this, fs.realpathSync.native() is called to get the
+// URI with the actual file name.
+export function flushFilePath(filePath: string): string {
+  if (filePath === '') {
+    return filePath;
+  }
+
+  let nativePath = fs.realpathSync.native(filePath);
+  if (/^win32/.test(process.platform)) {
+    // The file path on Windows is in the form of "c:\Users\User Name\foo.cls".
+    // When called, fs.realpathSync.native() is returning the file path back as
+    // "C:\Users\User Name\foo.cls", and the capitalization of the drive letter
+    // causes problems further down stream.  To fix this, we'll use the path
+    // returned from fs.realpathSync.native() and then capitalize the first
+    // character.
+    nativePath = nativePath.charAt(0).toLowerCase() + nativePath.slice(1);
+  }
+
+  return nativePath;
+}
+
+export function flushFilePaths(filePaths: string[]): string[] {
+  for (let i = 0; i < filePaths.length; i++) {
+    filePaths[i] = flushFilePath(filePaths[i]);
+  }
+
+  return filePaths;
+}

packages/salesforcedx-utils-vscode/test/unit/helpers/utils.test.ts

@@ -1,4 +1,3 @@
-
 /*
  * Copyright (c) 2019, salesforce.com, inc.
  * All rights reserved.
@@ -7,20 +6,99 @@
  */
 
 import { expect } from 'chai';
-import { extractJsonObject } from '../../../src/helpers';
+import * as fs from 'fs';
+import * as sinon from 'sinon';
+import {
+  extractJsonObject,
+  flushFilePath,
+  flushFilePaths
+} from '../../../src/helpers';
 
 describe('getConfigSource', () => {
-
   it('should extract a JSON string from larger string and then return as an object', async () => {
-
-    const exampleJsonString = JSON.stringify({ name: 'exampleName', error: 'exampleError' });
+    const exampleJsonString = JSON.stringify({
+      name: 'exampleName',
+      error: 'exampleError'
+    });
     const exampleString = `junk text <junk +text junk text ${exampleJsonString} junk text junk text junk text`;
 
     const testParse = extractJsonObject(exampleString);
 
     expect(testParse.name).to.equal('exampleName');
     expect(testParse.error).to.equal('exampleError');
+  });
+});
+
+describe('flushFilePath', () => {
+  it('should call fs.realpathSync.native() to resolve a path', async () => {
+    const filePath = 'C:\\Users\\temp\\exampleFile.js';
+    const realpathSyncNativeStub = sinon
+      .stub(fs.realpathSync, 'native')
+      .returns(filePath);
+
+    const result = flushFilePath(filePath);
+
+    expect(realpathSyncNativeStub.called).to.equal(true);
+    expect(realpathSyncNativeStub.calledOnce).to.equal(true);
+    expect(realpathSyncNativeStub.args[0][0]).to.equal(filePath);
+
+    realpathSyncNativeStub.restore();
+  });
+
+  it('should return a path when a path is passed in', async () => {
+    const filePath = 'C:\\Users\\temp\\exampleFile.js';
+    const realpathSyncNativeStub = sinon
+      .stub(fs.realpathSync, 'native')
+      .returns(filePath);
+
+    const result = flushFilePath(filePath);
+
+    expect(result).to.equal(filePath);
+
+    realpathSyncNativeStub.restore();
+  });
+
+  it('should return an empty string when an empty sting is passed in', async () => {
+    const filePath = 'c:\\Users\\temp\\exampleFile.js';
+    const realpathSyncNativeStub = sinon
+      .stub(fs.realpathSync, 'native')
+      .returns('');
+
+    const result = flushFilePath(filePath);
+
+    expect(result).to.equal('');
+
+    realpathSyncNativeStub.restore();
+  });
+
+  it('should validate the correct path is returned when running on Windows', async () => {
+    const filePath = 'c:\\Users\\User Name\\foo.cls';
+    const realpathSyncFilePath = 'C:\\Users\\User Name\\foo.cls';
+    const realpathSyncNativeStub = sinon
+      .stub(fs.realpathSync, 'native')
+      .returns(realpathSyncFilePath);
+    const processPlatformStub = sinon.stub(process, 'platform').value('win32');
 
+    const result = flushFilePath(filePath);
+
+    expect(result).to.equal(filePath);
+
+    processPlatformStub.restore();
+    realpathSyncNativeStub.restore();
   });
+});
+
+describe('flushFilePaths', () => {
+  it('should return the same paths that are passed in', async () => {
+    const filePaths = ['file.js', 'file.js', 'file.js'];
+    const realpathSyncNativeStub = sinon
+      .stub(fs.realpathSync, 'native')
+      .returns(filePaths[0]);
 
+    const result = flushFilePaths(filePaths);
+
+    expect(result).to.equal(filePaths);
+
+    realpathSyncNativeStub.restore();
+  });
 });

packages/salesforcedx-vscode-apex/src/commands/forceLaunchApexReplayDebuggerWithCurrentFile.ts

@@ -16,17 +16,12 @@ import {
   Command,
   CommandBuilder
 } from '@salesforce/salesforcedx-utils-vscode/out/src/cli';
-import {
-  notificationService
-} from '@salesforce/salesforcedx-utils-vscode/out/src/commands';
+import { notificationService } from '@salesforce/salesforcedx-utils-vscode/out/src/commands';
+import { flushFilePath } from '@salesforce/salesforcedx-utils-vscode/out/src/helpers';
 import * as vscode from 'vscode';
 import { nls } from '../messages';
-import {
-  testOutlineProvider
-} from '../views/testOutlineProvider';
-import {
-  forceAnonApexDebug
-} from './forceAnonApexExecute';
+import { testOutlineProvider } from '../views/testOutlineProvider';
+import { forceAnonApexDebug } from './forceAnonApexExecute';
 
 export async function forceLaunchApexReplayDebuggerWithCurrentFile() {
   const editor = vscode.window.activeTextEditor;
@@ -75,21 +70,26 @@ function isAnonymousApexFile(sourceUri: vscode.Uri): boolean {
 }
 
 async function launchReplayDebuggerLogFile(sourceUri: vscode.Uri) {
-  await vscode.commands.executeCommand(
-    'sfdx.launch.replay.debugger.logfile',
-    {
-      fsPath: sourceUri.fsPath
-    }
-  );
+  await vscode.commands.executeCommand('sfdx.launch.replay.debugger.logfile', {
+    fsPath: sourceUri.fsPath
+  });
 }
 
-async function getApexTestClassName(sourceUri: vscode.Uri): Promise<string | undefined> {
+async function getApexTestClassName(
+  sourceUri: vscode.Uri
+): Promise<string | undefined> {
   if (!sourceUri) {
     return undefined;
   }
 
   await testOutlineProvider.refresh();
-  const testClassName = testOutlineProvider.getTestClassName(sourceUri);
+  let testClassName = testOutlineProvider.getTestClassName(sourceUri);
+  // This is a little bizarre.  Intellisense is reporting that getTestClassName() returns a string,
+  // but it actually it returns string | undefined.  Well, regardless, since flushFilePath() takes
+  // a string (and guards against empty strings) using the Non-null assertion operator
+  // (https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-0.html#non-null-assertion-operator)
+  // fixes the issue.
+  testClassName = flushFilePath(testClassName!);
 
   return testClassName;
 }
@@ -105,17 +105,16 @@ async function launchAnonymousApexReplayDebugger() {
 
 async function launchApexReplayDebugger(apexTestClassName: string) {
   // Launch using QuickLaunch (the same way the "Debug All Tests" code lens runs)
-  await vscode.commands.executeCommand(
-    'sfdx.force.test.view.debugTests',
-    {
-      name: apexTestClassName
-    }
-  );
+  await vscode.commands.executeCommand('sfdx.force.test.view.debugTests', {
+    name: apexTestClassName
+  });
 }
 
 export class ForceAnonApexLaunchReplayDebuggerExecutor extends SfdxCommandletExecutor<{}> {
   public build(): Command {
-    return new CommandBuilder(nls.localize('force_launch_apex_replay_debugger_with_selected_file'))
+    return new CommandBuilder(
+      nls.localize('force_launch_apex_replay_debugger_with_selected_file')
+    )
       .withLogName('force_launch_apex_replay_debugger_with_selected_file')
       .build();
   }