test: implement tests for manifestResolver

Author: Hweinstock

packages/core/src/amazonq/lsp/util.ts

@@ -4,6 +4,7 @@
  */
 
 import { LanguageServerSetup, LanguageServerSetupStage, telemetry } from '../../shared/telemetry'
+import { tryFunctions } from '../../shared/utilities/tsUtils'
 
 /**
  * Runs the designated stage within a telemetry span and optionally uses the getMetadata extractor to record metadata from the result of the stage.
@@ -15,14 +16,41 @@ import { LanguageServerSetup, LanguageServerSetupStage, telemetry } from '../../
 export async function lspSetupStage<T>(
     stageName: LanguageServerSetupStage,
     runStage: () => Promise<T>,
-    getMetadata?: (result: T) => Partial<LanguageServerSetup>
+    getMetadata?: MetadataExtracter<T>
 ) {
     return await telemetry.languageServer_setup.run(async (span) => {
-        const result = await runStage()
         span.record({ languageServerSetupStage: stageName })
+        const result = await runStage()
         if (getMetadata) {
             span.record(getMetadata(result))
         }
         return result
     })
 }
+
+export async function tryResolvers<Result>(
+    stageName: LanguageServerSetupStage,
+    resolvers: StageResolver<Result>[],
+    getMetadata: MetadataExtracter<Result>
+) {
+    const fs = resolvers.map((resolver) => async () => {
+        return await lspSetupStage(
+            stageName,
+            async () => {
+                telemetry.record(resolver.telemetryMetadata)
+                const result = await resolver.resolve()
+                return result
+            },
+            getMetadata
+        )
+    })
+
+    return await tryFunctions(fs)
+}
+
+export interface StageResolver<Result> {
+    resolve: () => Promise<Result>
+    telemetryMetadata: Partial<LanguageServerSetup>
+}
+
+type MetadataExtracter<R> = (r: R) => Partial<LanguageServerSetup>

packages/core/src/shared/lsp/manifestResolver.ts

@@ -9,8 +9,7 @@ import { RetryableResourceFetcher } from '../resourcefetcher/httpResourceFetcher
 import { Timeout } from '../utilities/timeoutUtils'
 import globals from '../extensionGlobals'
 import { Manifest } from './types'
-import { lspSetupStage } from '../../amazonq/lsp/util'
-import { tryFunctions } from '../utilities/tsUtils'
+import { StageResolver, tryResolvers } from '../../amazonq/lsp/util'
 
 const logger = getLogger('lsp')
 
@@ -34,22 +33,23 @@ export class ManifestResolver {
      * Fetches the latest manifest, falling back to local cache on failure
      */
     async resolve(): Promise<Manifest> {
-        const resolvers = [async () => await this.fetchRemoteManifest(), async () => await this.getLocalManifest()].map(
-            (resolver) => async () => await resolveManifestWith(resolver)
-        )
-        return await tryFunctions(resolvers)
-
-        async function resolveManifestWith(resolver: () => Promise<Manifest>) {
-            return await lspSetupStage(
-                'getManifest',
-                async () => await resolver(),
-                (result) => {
-                    return {
-                        manifestSchemaVersion: result.manifestSchemaVersion,
-                        manifestLocation: result.location,
-                    }
-                }
-            )
+        const resolvers: StageResolver<Manifest>[] = [
+            {
+                resolve: async () => await this.fetchRemoteManifest(),
+                telemetryMetadata: { id: this.lsName, manifestLocation: 'remote' },
+            },
+            {
+                resolve: async () => await this.getLocalManifest(),
+                telemetryMetadata: { id: this.lsName, manifestLocation: 'cache' },
+            },
+        ]
+
+        return await tryResolvers('getManifest', resolvers, extractMetadata)
+
+        function extractMetadata(r: Manifest) {
+            return {
+                manifestSchemaVersion: r.manifestSchemaVersion,
+            }
         }
     }
 

packages/core/src/test/shared/lsp/manifestResolver.test.ts

@@ -0,0 +1,95 @@
+/*!
+ * Copyright Amazon.com, Inc. or its affiliates. All Rights Reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import assert from 'assert'
+import sinon from 'sinon'
+import { ManifestResolver } from '../../../shared'
+import { assertTelemetry } from '../../testUtil'
+
+describe('manifestResolver', function () {
+    let remoteStub: sinon.SinonStub
+    let localStub: sinon.SinonStub
+
+    before(function () {
+        remoteStub = sinon.stub(ManifestResolver.prototype, 'fetchRemoteManifest' as any)
+        localStub = sinon.stub(ManifestResolver.prototype, 'getLocalManifest' as any)
+    })
+
+    after(function () {
+        sinon.restore()
+    })
+
+    it('attempts to fetch from remote first', async function () {
+        remoteStub.resolves({
+            manifestSchemaVersion: '1.0.0',
+            artifactId: 'artifact-id',
+            artifactDescription: 'artifact-description',
+            isManifestDeprecated: false,
+            versions: [],
+            location: 'remote',
+        })
+
+        const r = await new ManifestResolver('remote-manifest.com', 'myLS').resolve()
+        assert.strictEqual(r.location, 'remote')
+        assertTelemetry('languageServer_setup', {
+            manifestLocation: 'remote',
+            manifestSchemaVersion: '1.0.0',
+            languageServerSetupStage: 'getManifest',
+            id: 'myLS',
+            result: 'Succeeded',
+        })
+    })
+
+    it('uses local cache when remote fails', async function () {
+        remoteStub.rejects(new Error('failed to fetch'))
+        localStub.resolves({
+            manifestSchemaVersion: '1.0.0',
+            artifactId: 'artifact-id',
+            artifactDescription: 'artifact-description',
+            isManifestDeprecated: false,
+            versions: [],
+            location: 'cache',
+        })
+
+        const r = await new ManifestResolver('remote-manifest.com', 'myLS').resolve()
+        assert.strictEqual(r.location, 'cache')
+        assertTelemetry('languageServer_setup', [
+            {
+                manifestLocation: 'remote',
+                languageServerSetupStage: 'getManifest',
+                id: 'myLS',
+                result: 'Failed',
+            },
+            {
+                manifestLocation: 'cache',
+                manifestSchemaVersion: '1.0.0',
+                languageServerSetupStage: 'getManifest',
+                id: 'myLS',
+                result: 'Succeeded',
+            },
+        ])
+    })
+
+    it('fails if both local and remote fail', async function () {
+        remoteStub.rejects(new Error('failed to fetch'))
+        localStub.rejects(new Error('failed to fetch'))
+
+        await assert.rejects(new ManifestResolver('remote-manifest.com', 'myLS').resolve(), /failed to fetch/)
+        assertTelemetry('languageServer_setup', [
+            {
+                manifestLocation: 'remote',
+                languageServerSetupStage: 'getManifest',
+                id: 'myLS',
+                result: 'Failed',
+            },
+            {
+                manifestLocation: 'cache',
+                languageServerSetupStage: 'getManifest',
+                id: 'myLS',
+                result: 'Failed',
+            },
+        ])
+    })
+})