test(amazonq): performance test for LSP setup. (aws#5677)

## Problem
continuation of reliability work

## Solution
`tryInstallLsp` in `src/amazonq/lsp/lspController.ts` captures many
potentially high risk paths in a single function, such as some I/O
operations, and heavy use of the `admZip` dependency.

Two performance tests were added, one for handling zipping and
maniupulating many small files, and one with few large files. Thresholds
are set very leniently to avoid flaky tests.

The "many files" test does 250 files w/ 10 bytes each. The "large files"
does 10 files w/ 1000 bytes each. These values were chosen to avoid
flakiness in CI.

Included in this PR is removing the use of fs-extra in
`src/amazonq/lsp/lspController.ts`

Author: Hweinstock

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

@@ -5,8 +5,8 @@
 
 import * as vscode from 'vscode'
 import * as path from 'path'
-import { createWriteStream } from 'fs'
 import * as crypto from 'crypto'
+import { createWriteStream } from 'fs'
 import { getLogger } from '../../shared/logger/logger'
 import { CurrentWsFolders, collectFilesForIndex } from '../../shared/utilities/workspaceUtils'
 import fetch from 'node-fetch'

packages/core/src/testInteg/tryInstallLsp.test.ts

@@ -0,0 +1,117 @@
+/*!
+ * 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 { Content } from 'aws-sdk/clients/codecommit'
+import AdmZip from 'adm-zip'
+import path from 'path'
+import { LspController } from '../amazonq'
+import { fs, getRandomString, globals } from '../shared'
+import { createTestWorkspace } from '../test/testUtil'
+import { performanceTest } from '../shared/performance/performance'
+
+// fakeFileContent is matched to fakeQServerContent based on hash.
+const fakeHash = '4eb2865c8f40a322aa04e17d8d83bdaa605d6f1cb363af615240a5442a010e0aef66e21bcf4c88f20fabff06efe8a214'
+
+const fakeQServerContent = {
+    filename: 'qserver-fake.zip',
+    url: 'https://aws-language-servers/fake.zip',
+    hashes: [`sha384:${fakeHash}`],
+    bytes: 93610849,
+    serverVersion: '1.1.1',
+}
+
+const fakeNodeContent = {
+    filename: 'fake-file',
+    url: 'https://aws-language-servers.fake-file',
+    hashes: [`sha384:${fakeHash}`],
+    bytes: 94144448,
+    serverVersion: '1.1.1',
+}
+
+function createStubs(numberOfFiles: number, fileSize: number) {
+    // Avoid making HTTP request or mocking giant manifest, stub what we need directly from request.
+    sinon.stub(LspController.prototype, 'fetchManifest')
+    // Directly feed the runtime specifications.
+    sinon.stub(LspController.prototype, 'getQserverFromManifest').returns(fakeQServerContent)
+    sinon.stub(LspController.prototype, 'getNodeRuntimeFromManifest').returns(fakeNodeContent)
+    // avoid fetch call.
+    sinon.stub(LspController.prototype, '_download').callsFake(getFakeDownload(numberOfFiles, fileSize))
+    // Hard code the hash since we are creating files on the spot, whose hashes can't be predicted.
+    sinon.stub(LspController.prototype, 'getFileSha384').resolves(fakeHash)
+    // Don't allow tryInstallLsp to move runtimes out of temporary folder.
+    sinon.stub(fs, 'rename')
+}
+
+/**
+ * Creates a fake zip with some files in it.
+ * @param filepath where to write the zip to.
+ * @param _content unused parameter, for compatability with real function.
+ */
+const getFakeDownload = function (numberOfFiles: number, fileSize: number) {
+    return async function (filepath: string, _content: Content) {
+        const dummyFilesPath = (
+            await createTestWorkspace(numberOfFiles, {
+                fileNamePrefix: 'fakeFile',
+                fileContent: getRandomString(fileSize),
+                workspaceName: 'workspace',
+            })
+        ).uri.fsPath
+        await fs.writeFile(path.join(dummyFilesPath, 'qserver'), 'this value shouldnt matter')
+        const zip = new AdmZip()
+        zip.addLocalFolder(dummyFilesPath)
+        zip.writeZip(filepath)
+    }
+}
+
+function performanceTestWrapper(numFiles: number, fileSize: number) {
+    return performanceTest(
+        {
+            testRuns: 10,
+            linux: {
+                userCpuUsage: 100,
+                systemCpuUsage: 35,
+                heapTotal: 6,
+                duration: 15,
+            },
+            darwin: {
+                userCpuUsage: 100,
+                systemCpuUsage: 35,
+                heapTotal: 6,
+                duration: 15,
+            },
+            win32: {
+                userCpuUsage: 100,
+                systemCpuUsage: 35,
+                heapTotal: 6,
+                duration: 15,
+            },
+        },
+        'many small files in zip',
+        function () {
+            return {
+                setup: async () => {
+                    createStubs(numFiles, fileSize)
+                },
+                execute: async () => {
+                    return await LspController.instance.tryInstallLsp(globals.context)
+                },
+                verify: async (_setup: any, result: boolean) => {
+                    assert.ok(result)
+                },
+            }
+        }
+    )
+}
+
+describe('tryInstallLsp', function () {
+    afterEach(function () {
+        sinon.restore()
+    })
+    describe('performance tests', function () {
+        performanceTestWrapper(250, 10)
+        performanceTestWrapper(10, 1000)
+    })
+})