Merge master into feature/console-session-profile

Author: aws-toolkit-automation

packages/core/src/lambda/vue/remoteInvoke/invokeLambda.ts

@@ -284,12 +284,10 @@ export class RemoteInvokeWebview extends VueWebview {
  await telemetry.lambda_invokeRemote.run(async (span) => {
  try {
  let funcResponse
- const snapStartDisabled =
- !this.data.LambdaFunctionNode?.configuration.SnapStart &&
- this.data.LambdaFunctionNode?.configuration.State !== 'Active'
+ const isLMI = (this.data.LambdaFunctionNode?.configuration as any)?.CapacityProviderConfig
  if (remoteDebugEnabled) {
  funcResponse = await this.clientDebug.invoke(this.data.FunctionArn, input, qualifier)
- } else if (snapStartDisabled) {
+ } else if (isLMI) {
  funcResponse = await this.client.invoke(this.data.FunctionArn, input, qualifier, 'None')
  } else {
  funcResponse = await this.client.invoke(this.data.FunctionArn, input, qualifier, 'Tail')
@@ -300,7 +298,7 @@ export class RemoteInvokeWebview extends VueWebview {
  const payload = decodedPayload || JSON.stringify({})
 
  this.channel.appendLine(`Invocation result for ${this.data.FunctionArn}`)
- if (!snapStartDisabled) {
+ if (!isLMI) {
  this.channel.appendLine('Logs:')
  this.channel.appendLine(logs)
  this.channel.appendLine('')

packages/core/src/lambda/vue/remoteInvoke/remoteInvoke.vue

@@ -57,8 +57,7 @@
  :disabled="
  !initialData.runtimeSupportsRemoteDebug ||
  !initialData.remoteDebugLayer ||
- (!initialData.LambdaFunctionNode?.configuration.SnapStart &&
- initialData.LambdaFunctionNode?.configuration.State !== 'Active')
+ (initialData.LambdaFunctionNode?.configuration as any)?.CapacityProviderConfig
  "
  class="remote-debug-checkbox"
  />
@@ -95,13 +94,10 @@
  Region {{ initialData.FunctionRegion }} doesn't support remote debugging yet
  </info>
  <info
- v-else-if="
- !initialData.LambdaFunctionNode?.configuration.SnapStart &&
- initialData.LambdaFunctionNode?.configuration.State !== 'Active'
- "
+ v-else-if="(initialData.LambdaFunctionNode?.configuration as any)?.CapacityProviderConfig"
  style="color: var(--vscode-errorForeground)"
  >
- Doesn't support remote debugging yet
+ Lambda Managed Instances Function doesn't support remote debugging yet
  </info>
  </div>
  </div>

packages/core/src/test/lambda/remoteDebugging/ldkClient.test.ts

@@ -24,6 +24,111 @@ import {
  TunnelStatus,
 } from '@aws-sdk/client-iotsecuretunneling'
 import { AwsStub, mockClient } from 'aws-sdk-client-mock'
+import * as http from 'http'
+import { AWSClientBuilderV3 } from '../../../shared/awsClientBuilderV3'
+import { FakeAwsContext } from '../../utilities/fakeAwsContext'
+import { Any } from '../../../shared/utilities/typeConstructors'
+
+describe('Remote Debugging User-Agent test', () => {
+ let sandbox: sinon.SinonSandbox
+ let ldkClient: LdkClient
+ let mockServer: http.Server
+ let capturedHeaders: http.IncomingHttpHeaders | undefined
+ let sdkBuilderTmp: Any
+ let mockLocalProxy: any
+
+ before(async () => {
+ sdkBuilderTmp = globals.sdkClientBuilderV3
+
+ mockServer = http.createServer((req, res) => {
+ capturedHeaders = req.headers
+ res.writeHead(200, { 'Content-Type': 'application/json' })
+ res.end()
+ })
+
+ // Start the mock server
+ await new Promise<void>((resolve) => {
+ mockServer.listen(0, '127.0.0.1', () => {
+ resolve()
+ })
+ })
+
+ const port = (mockServer.address() as any).port
+ globals.sdkClientBuilderV3 = new AWSClientBuilderV3(
+ new FakeAwsContext({
+ contextCredentials: {
+ endpointUrl: `http://127.0.0.1:${port}`,
+ credentials: undefined as any,
+ credentialsId: '',
+ },
+ })
+ )
+ })
+
+ beforeEach(() => {
+ sandbox = sinon.createSandbox()
+ sandbox.stub(telemetryUtil, 'getClientId').returns('test-client-id')
+ capturedHeaders = undefined
+ // Mock LocalProxy
+ mockLocalProxy = {
+ start: sandbox.stub(),
+ stop: sandbox.stub(),
+ }
+ sandbox.stub(LocalProxy.prototype, 'start').callsFake(mockLocalProxy.start)
+ sandbox.stub(LocalProxy.prototype, 'stop').callsFake(mockLocalProxy.stop)
+ ldkClient = LdkClient.instance
+ ;(ldkClient as any).localProxy = mockLocalProxy
+ ldkClient.dispose()
+ })
+
+ afterEach(() => {
+ sandbox.restore()
+ })
+
+ after(async () => {
+ globals.sdkClientBuilderV3 = sdkBuilderTmp
+ // Close the server
+ mockServer.close()
+ })
+
+ for (const scenario of ['Lambda', 'IoT']) {
+ it(`should send ${scenario} request with correct User-Agent header to mock server`, async () => {
+ try {
+ switch (scenario) {
+ case 'Lambda':
+ await ldkClient.getFunctionDetail('arn:aws:lambda:us-east-1:123456789012:function:testFunction')
+ break
+ case 'IoT':
+ await ldkClient.createOrReuseTunnel('us-east-1')
+ break
+ }
+ } catch (e) {
+ // Ignore errors from the mock response, we just want to capture headers
+ }
+
+ // Verify the User-Agent header was sent correctly
+ assert(capturedHeaders, 'Should have captured request headers')
+ const userAgent = capturedHeaders!['user-agent'] || capturedHeaders!['User-Agent']
+ assert(userAgent, 'Should have User-Agent header')
+
+ // The User-Agent should contain our custom user agent pairs
+ assert(
+ userAgent.includes('LAMBDA-DEBUG/1.0.0'),
+ `User-Agent should include LAMBDA-DEBUG/1.0.0, got: ${userAgent}`
+ )
+ // Check for presence of other user agent components without checking specific values
+ assert(
+ userAgent.includes('AWS-Toolkit-For-VSCode/'),
+ `User-Agent should include AWS-Toolkit-For-VSCode/, got: ${userAgent}`
+ )
+ assert(
+ userAgent.includes('Visual-Studio-Code'),
+ `User-Agent should include Visual-Studio-Code, got: ${userAgent}`
+ )
+ assert(userAgent.includes('ClientId/'), `User-Agent should include ClientId/, got: ${userAgent}`)
+ })
+ }
+})
 
 describe('LdkClient', () => {
  let sandbox: sinon.SinonSandbox

packages/core/src/test/lambda/vue/remoteInvoke/remoteInvoke.test.ts

@@ -14,59 +14,74 @@ import { InvocationResponse } from '@aws-sdk/client-lambda'
 
 describe('RemoteInvokeWebview', function () {
  let client: SinonStubbedInstance<LambdaClient>
- let remoteInvokeWebview: RemoteInvokeWebview
  let outputChannel: vscode.OutputChannel
- let mockData: any
- before(async () => {
- client = createStubInstance(DefaultLambdaClient)
+ const mockData = {
+ FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:my-function',
+ } as any
+ const mockDataLMI = {
+ FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:my-function',
+ LambdaFunctionNode: {
+ configuration: {
+ CapacityProviderConfig: {
+ blah: 'blah',
+ },
+ },
+ },
+ } as any
+ const input = '{"key": "value"}'
+ const mockResponse = {
+ LogResult: Buffer.from('Test log').toString('base64'),
+ Payload: new TextEncoder().encode('{"result": "success"}'),
+ } satisfies InvocationResponse
+
+ before(() => {
  outputChannel = {
  appendLine: (line: string) => {},
  show: () => {},
  } as vscode.OutputChannel
- mockData = {
- FunctionArn: 'arn:aws:lambda:us-west-2:123456789012:function:my-function',
- }
- remoteInvokeWebview = new RemoteInvokeWebview(outputChannel, client, client, mockData)
  })
- describe('Invoke Remote Lambda Function with Payload', () => {
- it('should invoke with a simple payload', async function () {
-  const input = '{"key": "value"}'
-  const mockResponse = {
-  LogResult: Buffer.from('Test log').toString('base64'),
-  Payload: new TextEncoder().encode('{"result": "success"}'),
-  } satisfies InvocationResponse
-  client.invoke.resolves(mockResponse)
-  await remoteInvokeWebview.invokeLambda(input)
-  sinon.assert.calledOnce(client.invoke)
-  sinon.assert.calledWith(client.invoke, mockData.FunctionArn, input)
- })
+ beforeEach(() => {
+ client = createStubInstance(DefaultLambdaClient)
+ })
+ afterEach(() => {
+ sinon.restore()
+ })
+ it('should invoke with a simple payload', async function () {
+ const remoteInvokeWebview = new RemoteInvokeWebview(outputChannel, client, client, mockData)
+ client.invoke.resolves(mockResponse)
+ await remoteInvokeWebview.invokeLambda(input)
+ sinon.assert.calledOnce(client.invoke)
+ sinon.assert.calledWith(client.invoke, mockData.FunctionArn, input, undefined, 'Tail')
  })
- describe('Invoke Remote Lambda Function with Saved Events Payload', () => {
- const mockEvent = {
- name: 'TestEvent',
- arn: 'arn:aws:lambda:us-west-2:123456789012:function:myFunction',
- region: 'us-west-2',
- }
- const expectedParams = {
- name: mockEvent.name,
- operation: TestEventsOperation.Get,
- functionArn: mockEvent.arn,
- region: mockEvent.region,
- }
- const mockResponse = 'true'
- let runSamCliRemoteTestEventsStub: sinon.SinonStub
- beforeEach(() => {
- runSamCliRemoteTestEventsStub = sinon.stub(samCliRemoteTestEvent, 'runSamCliRemoteTestEvents')
- })
- afterEach(() => {
- sinon.restore()
- })
- it('should get saved event and invoke with it', async function () {
- runSamCliRemoteTestEventsStub.resolves(mockResponse)
- await remoteInvokeWebview.getRemoteTestEvents(mockEvent)
 
- sinon.assert.calledOnce(runSamCliRemoteTestEventsStub)
- sinon.assert.calledWith(runSamCliRemoteTestEventsStub, expectedParams)
- })
+ it('should invoke with no tail in LMI', async function () {
+ const remoteInvokeWebview = new RemoteInvokeWebview(outputChannel, client, client, mockDataLMI)
+ client.invoke.resolves(mockResponse)
+ await remoteInvokeWebview.invokeLambda(input)
+ sinon.assert.calledOnce(client.invoke)
+ sinon.assert.calledWith(client.invoke, mockData.FunctionArn, input, undefined, 'None')
+ })
+
+ const mockEvent = {
+ name: 'TestEvent',
+ arn: 'arn:aws:lambda:us-west-2:123456789012:function:myFunction',
+ region: 'us-west-2',
+ }
+ const expectedParams = {
+ name: mockEvent.name,
+ operation: TestEventsOperation.Get,
+ functionArn: mockEvent.arn,
+ region: mockEvent.region,
+ }
+ const mockEventResponse = 'true'
+
+ it('should get saved event and invoke with it', async function () {
+ const remoteInvokeWebview = new RemoteInvokeWebview(outputChannel, client, client, mockData)
+ const runSamCliRemoteTestEventsStub = sinon.stub(samCliRemoteTestEvent, 'runSamCliRemoteTestEvents')
+ runSamCliRemoteTestEventsStub.resolves(mockEventResponse)
+ await remoteInvokeWebview.getRemoteTestEvents(mockEvent)
+
+ sinon.assert.calledOnce(runSamCliRemoteTestEventsStub)
+ sinon.assert.calledWith(runSamCliRemoteTestEventsStub, expectedParams)
  })
 })