chore: handle exception on load

Author: benoitf

src/ibmcloud-extension.spec.ts

@@ -18,9 +18,10 @@
 
 import type { ExtensionContext } from '@podman-desktop/api';
 import { beforeEach, expect, test, vi } from 'vitest';
-import type { Container } from 'inversify';
+import type { Container, ServiceIdentifier } from 'inversify';
 import { IBMCloudExtension } from './ibmcloud-extension';
 import { AuthenticationProviderManager } from './manager/authentication-provider-manager';
+import { InversifyBinding } from './inject/inversify-binding';
 
 let extensionContextMock: ExtensionContext;
 let ibmCloudExtension: TestIBMCloudExtension;
@@ -98,3 +99,25 @@ test('should log error if deferActivate throws', async () => {
 
   spyConsoleError.mockRestore();
 });
+
+test('should log error if getAsync for AuthenticationProviderManager throws', async () => {
+  expect.assertions(2);
+
+  const error = new Error('getAsync failure');
+  const spyConsoleError = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+  // Mock the initBindings to return a container with a throwing getAsync
+  const fakeContainer = {
+    getAsync: vi.fn<(serviceIdentifier: ServiceIdentifier) => Promise<unknown>>().mockRejectedValueOnce(error),
+  } as unknown as Container;
+  const initBindingsMock = vi.fn<() => Promise<Container>>().mockResolvedValue(fakeContainer);
+  const spyInitBindings = vi.spyOn(InversifyBinding.prototype, 'initBindings');
+  spyInitBindings.mockImplementation(initBindingsMock);
+
+  await ibmCloudExtension.activate();
+
+  expect(fakeContainer.getAsync).toHaveBeenCalledWith(AuthenticationProviderManager);
+  expect(spyConsoleError).toHaveBeenCalledWith('Error while creating the authentication provider manager', error);
+
+  spyConsoleError.mockRestore();
+});

src/ibmcloud-extension.ts

@@ -39,7 +39,12 @@ export class IBMCloudExtension {
     this.#inversifyBinding = new InversifyBinding(this.#extensionContext, telemetryLogger);
     this.#container = await this.#inversifyBinding.initBindings();
 
-    this.#authenticationProviderManager = await this.#container.getAsync(AuthenticationProviderManager);
+    try {
+      this.#authenticationProviderManager = await this.getContainer()?.getAsync(AuthenticationProviderManager);
+    } catch (e) {
+      console.error('Error while creating the authentication provider manager', e);
+      return;
+    }
 
     // Perform the registration after the startup to not hold up the startup
     this.deferActivate().catch((e: unknown) => {

src/manager/authentication-provider-manager.spec.ts

@@ -158,6 +158,22 @@ describe('init/post construct', () => {
       expect(console.error).toHaveBeenCalledWith('Error monitoring tokens', expect.any(Error));
     });
   });
+
+  it('should handle error during initial monitorTokens in init()', async () => {
+    expect.assertions(2);
+
+    // Spy and force monitorTokens to throw on first call
+    const monitorTokensSpy = vi
+      .spyOn(authenticationProviderManager, 'monitorTokens')
+      .mockRejectedValueOnce(new Error('Initial monitor failure'));
+
+    // Call postConstruct
+    await authenticationProviderManager.postConstruct();
+
+    // Should call monitorTokens and handle the error
+    expect(monitorTokensSpy).toHaveBeenCalledTimes(1);
+    expect(console.error).toHaveBeenCalledWith('Error while the initial monitoring of tokens', expect.any(Error));
+  });
 });
 
 test('destroy', async () => {
@@ -360,4 +376,33 @@ describe('monitorTokens', () => {
     expect(authenticationProviderManager.getOnDidChangeSessions().fire).not.toHaveBeenCalled();
     expect(PersistentSessionHelper.prototype.save).toHaveBeenCalledWith([freshSession]);
   });
+
+  it('should remove session and fire removed event on refresh error', async () => {
+    expect.assertions(4);
+
+    const now = Math.round(Date.now() / 1000);
+    const expiringSession: IAMSession = { session_id: 'fail-session', expiration: now + 10 } as unknown as IAMSession;
+    const convertedSession = { id: 'fail-session' } as unknown as AuthenticationSession;
+
+    authenticationProviderManager.getIamSessions().push(expiringSession);
+
+    vi.mocked(IamSessionRefreshTokenHelper.prototype.refreshToken).mockRejectedValue(new Error('refresh fail'));
+    vi.mocked(IamSessionConverterHelper.prototype.convertToAuthenticationSession).mockReturnValue(convertedSession);
+
+    await authenticationProviderManager.monitorTokens();
+
+    // Should have removed session
+    expect(authenticationProviderManager.getIamSessions()).toHaveLength(0);
+
+    // Should have fired removed event
+    expect(authenticationProviderManager.getOnDidChangeSessions().fire).toHaveBeenCalledWith({
+      removed: [convertedSession],
+    });
+
+    // Should have saved sessions (empty)
+    expect(PersistentSessionHelper.prototype.save).toHaveBeenCalledWith([]);
+
+    // Should log error
+    expect(console.error).toHaveBeenCalledWith('Error refreshing token', expect.any(Error));
+  });
 });

src/manager/authentication-provider-manager.ts

@@ -70,7 +70,11 @@ export class AuthenticationProviderManager {
     this.iamSessions = await this.persistentSessionHelper.restoreSessions();
 
     // Monitor the token expiration
-    await this.monitorTokens();
+    try {
+      await this.monitorTokens();
+    } catch (error: unknown) {
+      console.error('Error while the initial monitoring of tokens', error);
+    }
 
     this.checkTimeout = setInterval(() => {
       this.monitorTokens().catch((error: unknown) => {
@@ -97,7 +101,21 @@ export class AuthenticationProviderManager {
     for (const session of this.iamSessions) {
       const delta = session.expiration - now;
       if (delta < 60) {
-        const updatedSession = await this.iamSessionRefreshTokenHelper.refreshToken(session);
+        let updatedSession: IAMSession;
+        try {
+          updatedSession = await this.iamSessionRefreshTokenHelper.refreshToken(session);
+        } catch (error: unknown) {
+          console.error('Error refreshing token', error);
+          // Remove this session from the list
+          const sessionIndex = this.iamSessions.findIndex(s => s.session_id === session.session_id);
+          if (sessionIndex !== -1) {
+            this.iamSessions.splice(sessionIndex, 1);
+          }
+          // Fire the event to notify the change
+          const authenticationSession = this.iamSessionConverterHelper.convertToAuthenticationSession(session);
+          this._onDidChangeSessions.fire({ removed: [authenticationSession] });
+          continue;
+        }
         // Update the session in the list
         const sessionIndex = this.iamSessions.findIndex(s => s.session_id === session.session_id);
         if (sessionIndex !== -1) {