CHANGE: @W-18279823@ Hide A4V QF Without Authed Org (#295)

Author: randi274

src/extension.ts

@@ -277,7 +277,8 @@ export async function activate(context: vscode.ExtensionContext): Promise<SFCAEx
     // =================================================================================================================
     const a4dFixAction: A4DFixAction = new A4DFixAction(externalServiceProvider, codeAnalyzer, unifiedDiffService, 
         diagnosticManager, telemetryService, logger, display);
-    const a4dFixActionProvider: A4DFixActionProvider = new A4DFixActionProvider(externalServiceProvider, logger);
+    const a4dFixActionProvider: A4DFixActionProvider = new A4DFixActionProvider(externalServiceProvider, orgConnectionService, logger);
+
     registerCommand(A4DFixAction.COMMAND, async (diagnostic: CodeAnalyzerDiagnostic, document: vscode.TextDocument) => {
         await a4dFixAction.run(diagnostic, document);
     });

src/lib/agentforce/a4d-fix-action-provider.ts

@@ -1,6 +1,7 @@
 import * as vscode from "vscode";
 import {messages} from "../messages";
 import {LLMServiceProvider} from "../external-services/llm-service";
+import {OrgConnectionService} from "../external-services/org-connection-service";
 import {Logger} from "../logger";
 import {CodeAnalyzerDiagnostic} from "../diagnostics";
 import { A4DFixAction } from "./a4d-fix-action";
@@ -13,11 +14,14 @@ export class A4DFixActionProvider implements vscode.CodeActionProvider {
     static readonly providedCodeActionKinds: vscode.CodeActionKind[] = [vscode.CodeActionKind.QuickFix];
 
     private readonly llmServiceProvider: LLMServiceProvider;
+    private readonly orgConnectionService: OrgConnectionService;
     private readonly logger: Logger;
     private hasWarnedAboutUnavailableLLMService: boolean = false;
+    private hasWarnedAboutUnauthenticatedOrg: boolean = false;
 
-    constructor(llmServiceProvider: LLMServiceProvider, logger: Logger) {
+    constructor(llmServiceProvider: LLMServiceProvider, orgConnectionService: OrgConnectionService, logger: Logger) {
         this.llmServiceProvider = llmServiceProvider;
+        this.orgConnectionService = orgConnectionService;
         this.logger = logger;
     }
 
@@ -33,6 +37,15 @@ export class A4DFixActionProvider implements vscode.CodeActionProvider {
             return [];
         }
 
+        // Do not provide quick fix code actions if user is not authenticated to an org
+        if (!this.orgConnectionService.isAuthed()) {
+            if (!this.hasWarnedAboutUnauthenticatedOrg) {
+                this.logger.warn(messages.agentforce.a4dQuickFixUnauthenticatedOrg);
+                this.hasWarnedAboutUnauthenticatedOrg = true;
+            }
+            return [];
+        }
+
         // Do not provide quick fix code actions if LLM service is not available. We warn once to let user know.
         if (!(await this.llmServiceProvider.isLLMServiceAvailable())) {
             if (!this.hasWarnedAboutUnavailableLLMService) {

src/lib/messages.ts

@@ -15,6 +15,7 @@ export const messages = {
     },
     agentforce: {
         a4dQuickFixUnavailable: "The ability to fix violations with 'Agentforce Vibes' is unavailable since a compatible 'Agentforce Vibes' extension was not found or activated. To enable this functionality, please install the 'Agentforce Vibes' extension and restart VS Code.",
+        a4dQuickFixUnauthenticatedOrg: "The ability to fix violations with 'Agentforce Vibes' is unavailable since you are not authenticated to an org. To enable this functionality, please authenticate to an org.",
         failedA4DResponse: "Unable to receive code fix suggestion from Agentforce Vibes."
     },
     unifiedDiff: {

src/test/unit/lib/agentforce/agentforce-code-action-provider.test.ts

@@ -1,6 +1,6 @@
 import * as vscode from "vscode"; // The vscode module is mocked out. See: scripts/setup.jest.ts
 import {A4DFixActionProvider} from "../../../../lib/agentforce/a4d-fix-action-provider";
-import {SpyLLMService, SpyLogger, StubLLMServiceProvider} from "../../stubs";
+import {SpyLLMService, SpyLogger, StubOrgConnectionService, StubLLMServiceProvider} from "../../stubs";
 import {StubCodeActionContext} from "../../vscode-stubs";
 import {messages} from "../../../../lib/messages";
 import {createTextDocument} from "jest-mock-vscode";
@@ -11,13 +11,15 @@ describe('AgentforceCodeActionProvider Tests', () => {
     let spyLLMService: SpyLLMService;
     let llmServiceProvider: StubLLMServiceProvider;
     let spyLogger: SpyLogger;
+    let stubOrgConnectionService: StubOrgConnectionService;
     let actionProvider: A4DFixActionProvider;
 
     beforeEach(() => {
         spyLLMService = new SpyLLMService();
         llmServiceProvider = new StubLLMServiceProvider(spyLLMService);
         spyLogger = new SpyLogger();
-        actionProvider = new A4DFixActionProvider(llmServiceProvider, spyLogger);
+        stubOrgConnectionService = new StubOrgConnectionService();
+        actionProvider = new A4DFixActionProvider(llmServiceProvider, stubOrgConnectionService, spyLogger);
     });
 
     describe('provideCodeActions Tests', () => {
@@ -68,7 +70,8 @@ describe('AgentforceCodeActionProvider Tests', () => {
             expect(codeActions[2].diagnostics).toEqual([supportedDiag3]);
         });
 
-        it('When the LLMService is unavailable, then warn once and return no code actions', async () => {
+        // Authentication and LLM Service Availability Tests
+        it('When the LLMService is unavailable, then warn once and return no code actions and warn only once', async () => {
             llmServiceProvider.isLLMServiceAvailableReturnValue = false;
             const context: vscode.CodeActionContext = new StubCodeActionContext({diagnostics: [supportedDiag1]});
             const codeActions: vscode.CodeAction[] = await actionProvider.provideCodeActions(sampleDocument, range, context);
@@ -78,6 +81,45 @@ describe('AgentforceCodeActionProvider Tests', () => {
             expect(spyLogger.warnCallHistory).toHaveLength(1);
             expect(spyLogger.warnCallHistory[0]).toEqual({msg: messages.agentforce.a4dQuickFixUnavailable});
         });
+
+        it('When user is not authenticated to an org, then return no code actions and warn once', async () => {
+            stubOrgConnectionService.isAuthedReturnValue = false;
+            const context: vscode.CodeActionContext = new StubCodeActionContext({diagnostics: [supportedDiag1]});
+            const codeActions: vscode.CodeAction[] = await actionProvider.provideCodeActions(sampleDocument, range, context);
+            await actionProvider.provideCodeActions(sampleDocument, range, context); // Sanity check that multiple calls do not produce additional warnings
+
+            expect(codeActions).toHaveLength(0);
+            expect(spyLogger.warnCallHistory).toHaveLength(1);
+            expect(spyLogger.warnCallHistory[0]).toEqual({msg: messages.agentforce.a4dQuickFixUnauthenticatedOrg});
+        });
+
+        it('When user is authenticated and LLMService is available, then user does not see any warnings', async () => {
+            stubOrgConnectionService.isAuthedReturnValue = true;
+            llmServiceProvider.isLLMServiceAvailableReturnValue = true;
+            const context: vscode.CodeActionContext = new StubCodeActionContext({diagnostics: [supportedDiag1]});
+            const codeActions: vscode.CodeAction[] = await actionProvider.provideCodeActions(sampleDocument, range, context);
+
+            expect(codeActions).toHaveLength(1);
+            expect(spyLogger.warnCallHistory).toHaveLength(0);
+        });
+
+        it('When no supported diagnostics are in the context and user is not authenticated to an org, then do not warn', async () => {
+            stubOrgConnectionService.isAuthedReturnValue = false;
+            const context: vscode.CodeActionContext = new StubCodeActionContext({diagnostics: [unsupportedDiag1]});
+            const codeActions: vscode.CodeAction[] = await actionProvider.provideCodeActions(sampleDocument, range, context);
+
+            expect(codeActions).toHaveLength(0);
+            expect(spyLogger.warnCallHistory).toHaveLength(0);
+        });
+
+        it('When no supported diagnostics are in the context and LLM Service is unavailable, then do not warn', async () => {
+            llmServiceProvider.isLLMServiceAvailableReturnValue = false;
+            const context: vscode.CodeActionContext = new StubCodeActionContext({diagnostics: [unsupportedDiag1]});
+            const codeActions: vscode.CodeAction[] = await actionProvider.provideCodeActions(sampleDocument, range, context);
+
+            expect(codeActions).toHaveLength(0);
+            expect(spyLogger.warnCallHistory).toHaveLength(0);
+        });
     });
 });
 

src/test/unit/stubs.ts

@@ -16,7 +16,7 @@ import {FileHandler} from "../../lib/fs-utils";
 import {VscodeWorkspace, WindowManager} from "../../lib/vscode-api";
 import {Workspace} from "../../lib/workspace";
 import { ApexGuruAccess, ApexGuruAvailability, ApexGuruService } from "../../lib/apexguru/apex-guru-service";
-
+import { HttpRequest, OrgConnectionService, OrgUserInfo } from "../../lib/external-services/org-connection-service";
 
 export class SpyTelemetryService implements TelemetryService {
     sendExtensionActivationEventCallHistory: { hrStart: number }[] = [];
@@ -384,4 +384,24 @@ export class ThrowingScanApexGuruService extends StubApexGuruService {
     scan(_absFileToScan: string): Promise<Violation[]> {
         throw new Error("Sample error message from scan method");
     }
-}
+}
+
+export class StubOrgConnectionService implements OrgConnectionService {
+    isAuthedReturnValue: boolean = true;
+
+    isAuthed(): boolean {
+        return this.isAuthedReturnValue;
+    }
+
+    getApiVersion(): Promise<string> {
+        return Promise.resolve('64.0');
+    }
+
+    onOrgChange(_callback: (orgUserInfo: OrgUserInfo) => void): void {
+        // No-op
+    }
+
+    request<T>(requestOptions: HttpRequest): Promise<T> {
+        throw new Error(`Not implemented:\n${JSON.stringify(requestOptions, null, 2)}`);
+    }
+}