From 5a802b6df87993a7ab1766a7dd82a37721d10897 Mon Sep 17 00:00:00 2001 From: Alexander Schueren Date: Thu, 23 Jan 2025 12:29:42 +0100 Subject: [PATCH 1/4] fix(parser): LambdaFunctionUrl envelope assumes JSON string in body --- packages/parser/src/envelopes/lambda.ts | 41 ++--- packages/parser/tests/events/lambda/base.json | 49 +++++ .../get-request.json} | 0 .../iam-auth.json} | 0 .../parser/tests/events/lambda/invalid.json | 48 +++++ .../with-trailing-slash.json} | 0 .../tests/unit/envelopes/lambda.test.ts | 169 +++++++++++------- .../parser/tests/unit/schema/lambda.test.ts | 38 ++-- 8 files changed, 250 insertions(+), 95 deletions(-) create mode 100644 packages/parser/tests/events/lambda/base.json rename packages/parser/tests/events/{lambdaFunctionUrlEvent.json => lambda/get-request.json} (100%) rename packages/parser/tests/events/{lambdaFunctionUrlIAMEvent.json => lambda/iam-auth.json} (100%) create mode 100644 packages/parser/tests/events/lambda/invalid.json rename packages/parser/tests/events/{lambdaFunctionUrlEventPathTrailingSlash.json => lambda/with-trailing-slash.json} (100%) diff --git a/packages/parser/src/envelopes/lambda.ts b/packages/parser/src/envelopes/lambda.ts index 91d609646f..54947c8433 100644 --- a/packages/parser/src/envelopes/lambda.ts +++ b/packages/parser/src/envelopes/lambda.ts @@ -14,37 +14,38 @@ export const LambdaFunctionUrlEnvelope = { */ [envelopeDiscriminator]: 'object' as const, parse(data: unknown, schema: T): z.infer { - const parsedEnvelope = LambdaFunctionUrlSchema.parse(data); - - if (!parsedEnvelope.body) { - throw new Error('Body field of Lambda function URL event is undefined'); + try { + return LambdaFunctionUrlSchema.extend({ + body: schema, + }).parse(data).body; + } catch (error) { + throw new ParseError('Failed to parse Lambda function URL body', { + cause: error as Error, + }); } - - return Envelope.parse(parsedEnvelope.body, schema); }, - safeParse(data: unknown, schema: T): ParsedResult> { - const parsedEnvelope = LambdaFunctionUrlSchema.safeParse(data); - - if (!parsedEnvelope.success) { - return { - success: false, - error: new ParseError('Failed to parse Lambda function URL envelope'), - originalEvent: data, - }; - } + safeParse( + data: unknown, + schema: T + ): ParsedResult> { + const results = LambdaFunctionUrlSchema.extend({ + body: schema, + }).safeParse(data); - const parsedBody = Envelope.safeParse(parsedEnvelope.data.body, schema); - if (!parsedBody.success) { + if (!results.success) { return { success: false, error: new ParseError('Failed to parse Lambda function URL body', { - cause: parsedBody.error, + cause: results.error, }), originalEvent: data, }; } - return parsedBody; + return { + success: true, + data: results.data.body, + }; }, }; diff --git a/packages/parser/tests/events/lambda/base.json b/packages/parser/tests/events/lambda/base.json new file mode 100644 index 0000000000..33a516428f --- /dev/null +++ b/packages/parser/tests/events/lambda/base.json @@ -0,0 +1,49 @@ +{ + "version": "2.0", + "routeKey": "$default", + "rawPath": "/", + "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", + "cookies": ["cookie1", "cookie2"], + "headers": { + "header1": "value1", + "header2": "value1,value2" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "", + "authentication": null, + "authorizer": { + "iam": { + "accessKey": "AKIA...", + "accountId": "111122223333", + "callerId": "AIDA...", + "cognitoIdentity": null, + "principalOrgId": null, + "userArn": "arn:aws:iam::111122223333:user/example-user", + "userId": "AIDA..." + } + }, + "domainName": ".lambda-url.us-west-2.on.aws", + "domainPrefix": "", + "http": { + "method": "POST", + "path": "/", + "protocol": "HTTP/1.1", + "sourceIp": "123.123.123.123", + "userAgent": "agent" + }, + "requestId": "id", + "routeKey": "$default", + "stage": "$default", + "time": "12/Mar/2020:19:03:58 +0000", + "timeEpoch": 1583348638390 + }, + "body": null, + "pathParameters": null, + "isBase64Encoded": false, + "stageVariables": null +} diff --git a/packages/parser/tests/events/lambdaFunctionUrlEvent.json b/packages/parser/tests/events/lambda/get-request.json similarity index 100% rename from packages/parser/tests/events/lambdaFunctionUrlEvent.json rename to packages/parser/tests/events/lambda/get-request.json diff --git a/packages/parser/tests/events/lambdaFunctionUrlIAMEvent.json b/packages/parser/tests/events/lambda/iam-auth.json similarity index 100% rename from packages/parser/tests/events/lambdaFunctionUrlIAMEvent.json rename to packages/parser/tests/events/lambda/iam-auth.json diff --git a/packages/parser/tests/events/lambda/invalid.json b/packages/parser/tests/events/lambda/invalid.json new file mode 100644 index 0000000000..2832ef9f1a --- /dev/null +++ b/packages/parser/tests/events/lambda/invalid.json @@ -0,0 +1,48 @@ +{ + "version": "2.0", + "routeKey": "$default", + "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", + "cookies": ["cookie1", "cookie2"], + "headers": { + "header1": "value1", + "header2": "value1,value2" + }, + "queryStringParameters": { + "parameter1": "value1,value2", + "parameter2": "value" + }, + "requestContext": { + "accountId": "123456789012", + "apiId": "", + "authentication": null, + "authorizer": { + "iam": { + "accessKey": "AKIA...", + "accountId": "111122223333", + "callerId": "AIDA...", + "cognitoIdentity": null, + "principalOrgId": null, + "userArn": "arn:aws:iam::111122223333:user/example-user", + "userId": "AIDA..." + } + }, + "domainName": ".lambda-url.us-west-2.on.aws", + "domainPrefix": "", + "http": { + "method": "POST", + "path": "/", + "protocol": "HTTP/1.1", + "sourceIp": "123.123.123.123", + "userAgent": "agent" + }, + "requestId": "id", + "routeKey": "$default", + "stage": "$default", + "time": "12/Mar/2020:19:03:58 +0000", + "timeEpoch": 1583348638390 + }, + "body": null, + "pathParameters": null, + "isBase64Encoded": false, + "stageVariables": null +} diff --git a/packages/parser/tests/events/lambdaFunctionUrlEventPathTrailingSlash.json b/packages/parser/tests/events/lambda/with-trailing-slash.json similarity index 100% rename from packages/parser/tests/events/lambdaFunctionUrlEventPathTrailingSlash.json rename to packages/parser/tests/events/lambda/with-trailing-slash.json diff --git a/packages/parser/tests/unit/envelopes/lambda.test.ts b/packages/parser/tests/unit/envelopes/lambda.test.ts index b76228bb6e..be1691cdfa 100644 --- a/packages/parser/tests/unit/envelopes/lambda.test.ts +++ b/packages/parser/tests/unit/envelopes/lambda.test.ts @@ -1,98 +1,137 @@ import { generateMock } from '@anatine/zod-mock'; -import type { - APIGatewayProxyEventV2, - LambdaFunctionURLEvent, -} from 'aws-lambda'; import { describe, expect, it } from 'vitest'; -import { ZodError } from 'zod'; +import { ZodError, z } from 'zod'; import { ParseError } from '../../../src'; import { LambdaFunctionUrlEnvelope } from '../../../src/envelopes/index.js'; -import { TestEvents, TestSchema } from '../schema/utils.js'; +import { JSONStringified } from '../../../src/helpers'; +import type { + APIGatewayProxyEventV2, + LambdaFunctionUrlEvent, +} from '../../../src/types'; +import { TestEvents, TestSchema, getTestEvent, omit } from '../schema/utils.js'; describe('Lambda Functions Url ', () => { - describe('parse', () => { - it('should parse custom schema in envelope', () => { - const testEvent = - TestEvents.lambdaFunctionUrlEvent as APIGatewayProxyEventV2; - const data = generateMock(TestSchema); + const schema = z + .object({ + message: z.string(), + }) + .strict(); - testEvent.body = JSON.stringify(data); + const baseEvent = getTestEvent({ + eventsPath: 'lambda', + filename: 'base', + }); + + describe('parse', () => { + it('should throw if the payload does not match the schema', () => { + // Prepare + const event = structuredClone(baseEvent); - expect(LambdaFunctionUrlEnvelope.parse(testEvent, TestSchema)).toEqual( - data + // Act & Assess + expect(() => LambdaFunctionUrlEnvelope.parse(event, schema)).toThrow( + expect.objectContaining({ + message: expect.stringContaining( + 'Failed to parse Lambda function URL body' + ), + cause: expect.objectContaining({ + issues: [ + { + code: 'invalid_type', + expected: 'object', + received: 'null', + path: ['body'], + message: 'Expected object, received null', + }, + ], + }), + }) ); }); - it('should throw when no body provided', () => { - const testEvent = - TestEvents.lambdaFunctionUrlEvent as LambdaFunctionURLEvent; - testEvent.body = undefined; + it('parses a Lambda function URL event with plain text', () => { + // Prepare + const event = structuredClone(baseEvent); + event.body = 'hello world'; - expect(() => - LambdaFunctionUrlEnvelope.parse(testEvent, TestSchema) - ).toThrow(); + // Act + const result = LambdaFunctionUrlEnvelope.parse(event, z.string()); + + // Assess + expect(result).toEqual('hello world'); }); - it('should throw when envelope is not valid', () => { - expect(() => - LambdaFunctionUrlEnvelope.parse({ foo: 'bar' }, TestSchema) - ).toThrow(); + it('parses a Lambda function URL event with JSON-stringified body', () => { + // Prepare + const event = structuredClone(baseEvent); + event.body = JSON.stringify({ message: 'hello world' }); + + // Act + const result = LambdaFunctionUrlEnvelope.parse( + event, + JSONStringified(schema) + ); + + // Assess + expect(result).toEqual({ message: 'hello world' }); }); - it('should throw when body does not match schema', () => { - const testEvent = - TestEvents.lambdaFunctionUrlEvent as APIGatewayProxyEventV2; - testEvent.body = JSON.stringify({ foo: 'bar' }); + it('parses a Lambda function URL event with binary body', () => { + // Prepare + const event = structuredClone(baseEvent); + event.body = Buffer.from('hello world').toString('base64'); + event.headers['content-type'] = 'application/octet-stream'; + event.isBase64Encoded = true; + + // Act + const result = LambdaFunctionUrlEnvelope.parse(event, z.string()); - expect(() => - LambdaFunctionUrlEnvelope.parse(testEvent, TestSchema) - ).toThrow(); + // Assess + expect(result).toEqual('aGVsbG8gd29ybGQ='); }); }); describe('safeParse', () => { - it('should parse custom schema in envelope', () => { - const testEvent = - TestEvents.lambdaFunctionUrlEvent as APIGatewayProxyEventV2; - const data = generateMock(TestSchema); + it('should parse Lambda function URL event', () => { + const event = structuredClone(baseEvent); + event.body = JSON.stringify({ message: 'hello world' }); - testEvent.body = JSON.stringify(data); + const result = LambdaFunctionUrlEnvelope.safeParse( + event, + JSONStringified(schema) + ); - expect( - LambdaFunctionUrlEnvelope.safeParse(testEvent, TestSchema) - ).toEqual({ + expect(result).toEqual({ success: true, - data, + data: { message: 'hello world' }, }); }); - it('should return original event when envelope is not valid', () => { - expect( - LambdaFunctionUrlEnvelope.safeParse({ foo: 'bar' }, TestSchema) - ).toEqual({ - success: false, - error: expect.any(ParseError), - originalEvent: { foo: 'bar' }, - }); - }); + it('should return error with original event if Lambda function URL event is not valid', () => { + const event = omit(['rawPath'], structuredClone(baseEvent)); - it('should return original event when body does not match schema', () => { - const testEvent = - TestEvents.lambdaFunctionUrlEvent as APIGatewayProxyEventV2; - testEvent.body = JSON.stringify({ foo: 'bar' }); + const result = LambdaFunctionUrlEnvelope.safeParse(event, schema); - const parseResult = LambdaFunctionUrlEnvelope.safeParse( - testEvent, - TestSchema - ); - expect(parseResult).toEqual({ + expect(result).toEqual({ success: false, - error: expect.any(ParseError), - originalEvent: testEvent, + error: new ParseError('Failed to parse Lambda function URL body', { + cause: new ZodError([ + { + code: 'invalid_type', + expected: 'string', + received: 'undefined', + path: ['rawPath'], + message: 'Required', + }, + { + code: 'invalid_type', + expected: 'object', + received: 'null', + path: ['body'], + message: 'Expected object, received null', + }, + ]), + }), + originalEvent: event, }); - - if (!parseResult.success && parseResult.error) { - expect(parseResult.error.cause).toBeInstanceOf(ZodError); - } }); }); }); diff --git a/packages/parser/tests/unit/schema/lambda.test.ts b/packages/parser/tests/unit/schema/lambda.test.ts index c5fd260112..568f4702f1 100644 --- a/packages/parser/tests/unit/schema/lambda.test.ts +++ b/packages/parser/tests/unit/schema/lambda.test.ts @@ -1,19 +1,37 @@ import { describe, expect, it } from 'vitest'; import { LambdaFunctionUrlSchema } from '../../../src/schemas/'; -import { TestEvents } from './utils.js'; +import { TestEvents, getTestEvent } from './utils.js'; -describe('Lambda ', () => { - it('should parse lambda event', () => { - const lambdaFunctionUrlEvent = TestEvents.lambdaFunctionUrlEvent; +describe('Schema: LambdaFunctionUrl ', () => { + const eventsPath = 'lambda'; - expect(LambdaFunctionUrlSchema.parse(lambdaFunctionUrlEvent)).toEqual( - lambdaFunctionUrlEvent - ); + it('should throw when the event is invalid', () => { + const event = getTestEvent({ eventsPath, filename: 'invalid' }); + + expect(() => LambdaFunctionUrlSchema.parse(event)).toThrow(); + }); + + it('parses a valid event', () => { + const event = getTestEvent({ eventsPath, filename: 'get-request' }); + + const parsedEvent = LambdaFunctionUrlSchema.parse(event); + + expect(parsedEvent).toEqual(event); }); - it('should parse url IAM event', () => { - const urlIAMEvent = TestEvents.lambdaFunctionUrlIAMEvent; + it('parses event with trailing slash', () => { + const event = getTestEvent({ eventsPath, filename: 'with-trailing-slash' }); + + const parsedEvent = LambdaFunctionUrlSchema.parse(event); + + expect(parsedEvent).toEqual(event); + }); + + it('parses iam event', () => { + const event = getTestEvent({ eventsPath, filename: 'iam-auth' }); + + const parsedEvent = LambdaFunctionUrlSchema.parse(event); - expect(LambdaFunctionUrlSchema.parse(urlIAMEvent)).toEqual(urlIAMEvent); + expect(parsedEvent).toEqual(event); }); }); From 33d3d558c246e950904fd1665a60e2cbafbefdd5 Mon Sep 17 00:00:00 2001 From: Alexander Schueren Date: Thu, 23 Jan 2025 12:34:44 +0100 Subject: [PATCH 2/4] fix(parser): remove unused imports --- packages/parser/src/envelopes/lambda.ts | 2 +- packages/parser/tests/unit/envelopes/lambda.test.ts | 8 ++------ packages/parser/tests/unit/schema/lambda.test.ts | 2 +- 3 files changed, 4 insertions(+), 8 deletions(-) diff --git a/packages/parser/src/envelopes/lambda.ts b/packages/parser/src/envelopes/lambda.ts index 54947c8433..d68af29a88 100644 --- a/packages/parser/src/envelopes/lambda.ts +++ b/packages/parser/src/envelopes/lambda.ts @@ -2,7 +2,7 @@ import type { ZodSchema, z } from 'zod'; import { ParseError } from '../errors.js'; import { LambdaFunctionUrlSchema } from '../schemas/index.js'; import type { ParsedResult } from '../types/index.js'; -import { Envelope, envelopeDiscriminator } from './envelope.js'; +import { envelopeDiscriminator } from './envelope.js'; /** * Lambda function URL envelope to extract data within body key diff --git a/packages/parser/tests/unit/envelopes/lambda.test.ts b/packages/parser/tests/unit/envelopes/lambda.test.ts index be1691cdfa..9d10855845 100644 --- a/packages/parser/tests/unit/envelopes/lambda.test.ts +++ b/packages/parser/tests/unit/envelopes/lambda.test.ts @@ -1,14 +1,10 @@ -import { generateMock } from '@anatine/zod-mock'; import { describe, expect, it } from 'vitest'; import { ZodError, z } from 'zod'; import { ParseError } from '../../../src'; import { LambdaFunctionUrlEnvelope } from '../../../src/envelopes/index.js'; import { JSONStringified } from '../../../src/helpers'; -import type { - APIGatewayProxyEventV2, - LambdaFunctionUrlEvent, -} from '../../../src/types'; -import { TestEvents, TestSchema, getTestEvent, omit } from '../schema/utils.js'; +import type { LambdaFunctionUrlEvent } from '../../../src/types'; +import { getTestEvent, omit } from '../schema/utils.js'; describe('Lambda Functions Url ', () => { const schema = z diff --git a/packages/parser/tests/unit/schema/lambda.test.ts b/packages/parser/tests/unit/schema/lambda.test.ts index 568f4702f1..6dcf1009ce 100644 --- a/packages/parser/tests/unit/schema/lambda.test.ts +++ b/packages/parser/tests/unit/schema/lambda.test.ts @@ -1,6 +1,6 @@ import { describe, expect, it } from 'vitest'; import { LambdaFunctionUrlSchema } from '../../../src/schemas/'; -import { TestEvents, getTestEvent } from './utils.js'; +import { getTestEvent } from './utils.js'; describe('Schema: LambdaFunctionUrl ', () => { const eventsPath = 'lambda'; From c91159df134b75be79ca88243043c4aff39628ba Mon Sep 17 00:00:00 2001 From: Alexander Schueren Date: Thu, 23 Jan 2025 13:53:31 +0100 Subject: [PATCH 3/4] chore: add comments to tests, aligned test names for convention --- .../events/lambda/with-trailing-slash.json | 49 ------------------- .../tests/unit/envelopes/lambda.test.ts | 18 ++++--- .../parser/tests/unit/schema/lambda.test.ts | 20 ++++---- 3 files changed, 22 insertions(+), 65 deletions(-) delete mode 100644 packages/parser/tests/events/lambda/with-trailing-slash.json diff --git a/packages/parser/tests/events/lambda/with-trailing-slash.json b/packages/parser/tests/events/lambda/with-trailing-slash.json deleted file mode 100644 index 54f6560655..0000000000 --- a/packages/parser/tests/events/lambda/with-trailing-slash.json +++ /dev/null @@ -1,49 +0,0 @@ -{ - "version": "2.0", - "routeKey": "$default", - "rawPath": "/my/path/", - "rawQueryString": "parameter1=value1¶meter1=value2¶meter2=value", - "cookies": ["cookie1", "cookie2"], - "headers": { - "header1": "value1", - "header2": "value1,value2" - }, - "queryStringParameters": { - "parameter1": "value1,value2", - "parameter2": "value" - }, - "requestContext": { - "accountId": "123456789012", - "apiId": "", - "authentication": null, - "authorizer": { - "iam": { - "accessKey": "AKIA...", - "accountId": "111122223333", - "callerId": "AIDA...", - "cognitoIdentity": null, - "principalOrgId": null, - "userArn": "arn:aws:iam::111122223333:user/example-user", - "userId": "AIDA..." - } - }, - "domainName": ".lambda-url.us-west-2.on.aws", - "domainPrefix": "", - "http": { - "method": "POST", - "path": "/my/path", - "protocol": "HTTP/1.1", - "sourceIp": "123.123.123.123", - "userAgent": "agent" - }, - "requestId": "id", - "routeKey": "$default", - "stage": "$default", - "time": "12/Mar/2020:19:03:58 +0000", - "timeEpoch": 1583348638390 - }, - "body": "Hello from client!", - "pathParameters": null, - "isBase64Encoded": false, - "stageVariables": null -} diff --git a/packages/parser/tests/unit/envelopes/lambda.test.ts b/packages/parser/tests/unit/envelopes/lambda.test.ts index 9d10855845..1cb71bdbd8 100644 --- a/packages/parser/tests/unit/envelopes/lambda.test.ts +++ b/packages/parser/tests/unit/envelopes/lambda.test.ts @@ -6,7 +6,7 @@ import { JSONStringified } from '../../../src/helpers'; import type { LambdaFunctionUrlEvent } from '../../../src/types'; import { getTestEvent, omit } from '../schema/utils.js'; -describe('Lambda Functions Url ', () => { +describe('Envelope: Lambda function URL', () => { const schema = z .object({ message: z.string(), @@ -18,8 +18,8 @@ describe('Lambda Functions Url ', () => { filename: 'base', }); - describe('parse', () => { - it('should throw if the payload does not match the schema', () => { + describe('Method: parse', () => { + it('throws if the payload does not match the schema', () => { // Prepare const event = structuredClone(baseEvent); @@ -85,27 +85,33 @@ describe('Lambda Functions Url ', () => { expect(result).toEqual('aGVsbG8gd29ybGQ='); }); }); - describe('safeParse', () => { - it('should parse Lambda function URL event', () => { + describe('Method: safeParse', () => { + it('parses Lambda function URL event', () => { + // Prepare const event = structuredClone(baseEvent); event.body = JSON.stringify({ message: 'hello world' }); + // Act const result = LambdaFunctionUrlEnvelope.safeParse( event, JSONStringified(schema) ); + // Assess expect(result).toEqual({ success: true, data: { message: 'hello world' }, }); }); - it('should return error with original event if Lambda function URL event is not valid', () => { + it('returns an error with original event if Lambda function URL event is not valid', () => { + // Prepare const event = omit(['rawPath'], structuredClone(baseEvent)); + // Act const result = LambdaFunctionUrlEnvelope.safeParse(event, schema); + // Assess expect(result).toEqual({ success: false, error: new ParseError('Failed to parse Lambda function URL body', { diff --git a/packages/parser/tests/unit/schema/lambda.test.ts b/packages/parser/tests/unit/schema/lambda.test.ts index 6dcf1009ce..42adf84ff8 100644 --- a/packages/parser/tests/unit/schema/lambda.test.ts +++ b/packages/parser/tests/unit/schema/lambda.test.ts @@ -2,36 +2,36 @@ import { describe, expect, it } from 'vitest'; import { LambdaFunctionUrlSchema } from '../../../src/schemas/'; import { getTestEvent } from './utils.js'; -describe('Schema: LambdaFunctionUrl ', () => { +describe('Schema: LambdaFunctionUrl', () => { const eventsPath = 'lambda'; - it('should throw when the event is invalid', () => { + it('throw when the event is invalid', () => { + // Prepare const event = getTestEvent({ eventsPath, filename: 'invalid' }); + // Act & Assess expect(() => LambdaFunctionUrlSchema.parse(event)).toThrow(); }); it('parses a valid event', () => { + // Prepare const event = getTestEvent({ eventsPath, filename: 'get-request' }); + // Act const parsedEvent = LambdaFunctionUrlSchema.parse(event); - expect(parsedEvent).toEqual(event); - }); - - it('parses event with trailing slash', () => { - const event = getTestEvent({ eventsPath, filename: 'with-trailing-slash' }); - - const parsedEvent = LambdaFunctionUrlSchema.parse(event); - + // Assess expect(parsedEvent).toEqual(event); }); it('parses iam event', () => { + // Prepare const event = getTestEvent({ eventsPath, filename: 'iam-auth' }); + // Act const parsedEvent = LambdaFunctionUrlSchema.parse(event); + // expect(parsedEvent).toEqual(event); }); }); From e9860e708d5f9bd09d8ab7294b5692929b9cb6a0 Mon Sep 17 00:00:00 2001 From: Alexander Schueren Date: Thu, 23 Jan 2025 13:55:17 +0100 Subject: [PATCH 4/4] small fix in string --- packages/parser/tests/unit/envelopes/lambda.test.ts | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/packages/parser/tests/unit/envelopes/lambda.test.ts b/packages/parser/tests/unit/envelopes/lambda.test.ts index 1cb71bdbd8..eee9ff28e8 100644 --- a/packages/parser/tests/unit/envelopes/lambda.test.ts +++ b/packages/parser/tests/unit/envelopes/lambda.test.ts @@ -104,7 +104,7 @@ describe('Envelope: Lambda function URL', () => { }); }); - it('returns an error with original event if Lambda function URL event is not valid', () => { + it('returns an error when the event is not valid', () => { // Prepare const event = omit(['rawPath'], structuredClone(baseEvent));