@yopdev/dev-server 3.0.3-beta.6 → 3.0.3-beta.7

package/__tests__/cloudformation-event-proxy.test.ts

@@ -0,0 +1,137 @@
+import { describe, expect, it } from "@jest/globals";
+import { snsEventsFromCloudFormationTemplate } from "../src/cloudformation-event-proxy";
+import { Network } from "testcontainers"
+
+const SUBJECT_IS_UNUSED = 'anything'
+const emptyDevServerConfig = async () =>
+    new Network().start().then((network) => ({
+        raw: {
+            region: "",
+            endpoint: "",
+            credentials: {
+                accessKeyId: "",
+                secretAccessKey: ""
+            }
+        },
+        network: network,
+        sqs: undefined,
+        sns: undefined,
+        s3: undefined,
+        dynamo: undefined,
+        eventsProxy: {
+            topic: {
+                arn: ""
+            }
+        }
+    }))
+
+describe('the cloudformation event proxy', () => {
+    describe('the handler matchers', () => {
+        const promisedEvents = emptyDevServerConfig().then((config) => snsEventsFromCloudFormationTemplate('test-events', {
+            template: () => './__tests__/event-proxy.template',
+            handlers: () => '../dist/__tests__/stub-handlers.js',
+            handlerNameResolver: (n) => n,
+        }).start(config))
+
+        describe('unfiltered event', () => {
+            const UNFILTERED_FUNCTION_TEMPLATE_POSITION = 0
+            it('unfiltered event returns true', async () => {
+                const events = await promisedEvents;
+                return expect(events[UNFILTERED_FUNCTION_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {})).toBe(true)
+            })
+        })
+
+        describe('single attribute filter', () => {
+            const SINGLE_ATTRIBUTE_FILTER_TEMPLATE_POSITION = 1
+            it.each(['filter-1-value-1', 'filter-1-value-2'])('returns true when matched', async (validFilterValue) => {
+                const events = await promisedEvents;
+                return expect(events[SINGLE_ATTRIBUTE_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter1: { Type: 'String', Value: validFilterValue }
+                })).toBe(true)
+            })
+
+            it('returns false when missing', async () => {
+                const events = await promisedEvents;
+                return expect(events[SINGLE_ATTRIBUTE_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {})).toBe(false)
+            })
+
+            it('returns false when not matched', async () => {
+                const events = await promisedEvents;
+                return expect(events[SINGLE_ATTRIBUTE_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Unexpected: { Type: 'String', Value: 'filter-1-value-1' }
+                })).toBe(false)
+            })
+
+            it('returns false when not matched', async () => {
+                const events = await promisedEvents;
+                return expect(events[SINGLE_ATTRIBUTE_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter1: { Type: 'String', Value: 'unexpected-value' }
+                })).toBe(false)
+            })
+        })
+
+        describe('many attributes filter', () => {
+            const MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION = 2
+            it.each([
+                { Filter1: 'filter-1-value-1', Filter2: 'filter-2-value-1' },
+                { Filter1: 'filter-1-value-1', Filter2: 'filter-2-value-2' },
+                { Filter1: 'filter-1-value-2', Filter2: 'filter-2-value-1' },
+                { Filter1: 'filter-1-value-2', Filter2: 'filter-2-value-2' },
+            ])('returns true when all matched', async (expectedFilters) => {
+                const events = await promisedEvents;
+                const filters = Object.entries(expectedFilters).reduce((acc, [key, value]) => {
+                    acc[key] = {
+                        Type: 'String',
+                        Value: value
+                    };
+                    return acc;
+                }, {})
+
+                return expect(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, filters)).toBe(true)
+            })
+
+            it('returns false when both attributes missing', async () => {
+                const events = await promisedEvents;
+                return expect(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {})).toBe(false)
+            })
+
+            it('returns false when first filter missing', async () => {
+                const events = await promisedEvents;
+                return expect(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter2: { Type: 'String', Value: 'filter-2-value-1' }
+                })).toBe(false)
+            })
+
+            it('returns false when second filter missing', async () => {
+                const events = await promisedEvents;
+                return expect(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter1: { Type: 'String', Value: 'filter-2-value-1' }
+                })).toBe(false)
+            })
+
+            it('returns false when first filter does not match', async () => {
+                const events = await promisedEvents;
+                return expect(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter1: { Type: 'String', Value: 'unmatched' },
+                    Filter2: { Type: 'String', Value: 'filter-2-value-1' }
+                })).toBe(false)
+            })
+
+            it('returns false when second filter does not match', async () => {
+                const events = await promisedEvents;
+                return expect(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter1: { Type: 'String', Value: 'filter-1-value-1' },
+                    Filter2: { Type: 'String', Value: 'unmatched' }
+                })).toBe(false)
+            })
+
+            it('returns false when both filters dont match', async () => {
+                const events = await promisedEvents;
+                return expect(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter1: { Type: 'String', Value: 'unmatched-1' },
+                    Filter2: { Type: 'String', Value: 'unmatched-2' }
+                })).toBe(false)
+            })
+        })
+    })
+})

package/__tests__/event-proxy.template

@@ -0,0 +1,35 @@
+Resources:
+    Unfiltered:
+        Type: AWS::Serverless::Function
+        Properties:
+            Handler: stubHandler
+            Events:
+                Test:
+                    Type: SNS
+    OrFilter:
+        Type: AWS::Serverless::Function
+        Properties:
+            Handler: stubHandler
+            Events:
+                Test:
+                    Type: SNS
+                    Properties:
+                        FilterPolicy:
+                            Filter1:
+                                - filter-1-value-1
+                                - filter-1-value-2
+    AndFilter:
+        Type: AWS::Serverless::Function
+        Properties:
+            Handler: stubHandler
+            Events:
+                Test:
+                    Type: SNS
+                    Properties:
+                        FilterPolicy:
+                            Filter1:
+                                - filter-1-value-1
+                                - filter-1-value-2
+                            Filter2:
+                                - filter-2-value-1
+                                - filter-2-value-2

package/dist/__tests__/cloudformation-event-proxy.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/cloudformation-event-proxy.test.js

@@ -0,0 +1,123 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const globals_1 = require("@jest/globals");
+const cloudformation_event_proxy_1 = require("../src/cloudformation-event-proxy");
+const testcontainers_1 = require("testcontainers");
+const SUBJECT_IS_UNUSED = 'anything';
+const emptyDevServerConfig = async () => new testcontainers_1.Network().start().then((network) => ({
+    raw: {
+        region: "",
+        endpoint: "",
+        credentials: {
+            accessKeyId: "",
+            secretAccessKey: ""
+        }
+    },
+    network: network,
+    sqs: undefined,
+    sns: undefined,
+    s3: undefined,
+    dynamo: undefined,
+    eventsProxy: {
+        topic: {
+            arn: ""
+        }
+    }
+}));
+(0, globals_1.describe)('the cloudformation event proxy', () => {
+    (0, globals_1.describe)('the handler matchers', () => {
+        const promisedEvents = emptyDevServerConfig().then((config) => (0, cloudformation_event_proxy_1.snsEventsFromCloudFormationTemplate)('test-events', {
+            template: () => './__tests__/event-proxy.template',
+            handlers: () => '../dist/__tests__/stub-handlers.js',
+            handlerNameResolver: (n) => n,
+        }).start(config));
+        (0, globals_1.describe)('unfiltered event', () => {
+            const UNFILTERED_FUNCTION_TEMPLATE_POSITION = 0;
+            (0, globals_1.it)('unfiltered event returns true', async () => {
+                const events = await promisedEvents;
+                return (0, globals_1.expect)(events[UNFILTERED_FUNCTION_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {})).toBe(true);
+            });
+        });
+        (0, globals_1.describe)('single attribute filter', () => {
+            const SINGLE_ATTRIBUTE_FILTER_TEMPLATE_POSITION = 1;
+            globals_1.it.each(['filter-1-value-1', 'filter-1-value-2'])('returns true when matched', async (validFilterValue) => {
+                const events = await promisedEvents;
+                return (0, globals_1.expect)(events[SINGLE_ATTRIBUTE_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter1: { Type: 'String', Value: validFilterValue }
+                })).toBe(true);
+            });
+            (0, globals_1.it)('returns false when missing', async () => {
+                const events = await promisedEvents;
+                return (0, globals_1.expect)(events[SINGLE_ATTRIBUTE_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {})).toBe(false);
+            });
+            (0, globals_1.it)('returns false when not matched', async () => {
+                const events = await promisedEvents;
+                return (0, globals_1.expect)(events[SINGLE_ATTRIBUTE_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Unexpected: { Type: 'String', Value: 'filter-1-value-1' }
+                })).toBe(false);
+            });
+            (0, globals_1.it)('returns false when not matched', async () => {
+                const events = await promisedEvents;
+                return (0, globals_1.expect)(events[SINGLE_ATTRIBUTE_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter1: { Type: 'String', Value: 'unexpected-value' }
+                })).toBe(false);
+            });
+        });
+        (0, globals_1.describe)('many attributes filter', () => {
+            const MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION = 2;
+            globals_1.it.each([
+                { Filter1: 'filter-1-value-1', Filter2: 'filter-2-value-1' },
+                { Filter1: 'filter-1-value-1', Filter2: 'filter-2-value-2' },
+                { Filter1: 'filter-1-value-2', Filter2: 'filter-2-value-1' },
+                { Filter1: 'filter-1-value-2', Filter2: 'filter-2-value-2' },
+            ])('returns true when all matched', async (expectedFilters) => {
+                const events = await promisedEvents;
+                const filters = Object.entries(expectedFilters).reduce((acc, [key, value]) => {
+                    acc[key] = {
+                        Type: 'String',
+                        Value: value
+                    };
+                    return acc;
+                }, {});
+                return (0, globals_1.expect)(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, filters)).toBe(true);
+            });
+            (0, globals_1.it)('returns false when both attributes missing', async () => {
+                const events = await promisedEvents;
+                return (0, globals_1.expect)(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {})).toBe(false);
+            });
+            (0, globals_1.it)('returns false when first filter missing', async () => {
+                const events = await promisedEvents;
+                return (0, globals_1.expect)(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter2: { Type: 'String', Value: 'filter-2-value-1' }
+                })).toBe(false);
+            });
+            (0, globals_1.it)('returns false when second filter missing', async () => {
+                const events = await promisedEvents;
+                return (0, globals_1.expect)(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter1: { Type: 'String', Value: 'filter-2-value-1' }
+                })).toBe(false);
+            });
+            (0, globals_1.it)('returns false when first filter does not match', async () => {
+                const events = await promisedEvents;
+                return (0, globals_1.expect)(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter1: { Type: 'String', Value: 'unmatched' },
+                    Filter2: { Type: 'String', Value: 'filter-2-value-1' }
+                })).toBe(false);
+            });
+            (0, globals_1.it)('returns false when second filter does not match', async () => {
+                const events = await promisedEvents;
+                return (0, globals_1.expect)(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter1: { Type: 'String', Value: 'filter-1-value-1' },
+                    Filter2: { Type: 'String', Value: 'unmatched' }
+                })).toBe(false);
+            });
+            (0, globals_1.it)('returns false when both filters dont match', async () => {
+                const events = await promisedEvents;
+                return (0, globals_1.expect)(events[MANY_ATTRIBUTES_FILTER_TEMPLATE_POSITION].matcher(SUBJECT_IS_UNUSED, {
+                    Filter1: { Type: 'String', Value: 'unmatched-1' },
+                    Filter2: { Type: 'String', Value: 'unmatched-2' }
+                })).toBe(false);
+            });
+        });
+    });
+});

package/dist/src/cloudformation-event-proxy.js

@@ -10,11 +10,12 @@ class CloudFormationEventsProxy extends cloudformation_1.CloudFormationSetup {
             name: handler.name,
             handler: handler,
             matcher: (_, attributes) => {
-                const required = Object.entries(event.Properties.FilterPolicy ?? []).flatMap((entry) => entry[1].map((value) => value + entry[0]));
+                const filters = Object.entries(event.Properties?.FilterPolicy ?? []);
+                const required = filters.flatMap((entry) => entry[1].map((value) => value + entry[0]));
                 if (required.length == 0)
                     return true;
                 const actual = Object.entries(attributes).flatMap((entry) => entry[1].Value + entry[0]);
-                return required.filter((e) => actual.includes(e)).length > 0;
+                return required.filter((e) => actual.includes(e)).length == filters.length;
             },
         }), config.prepare, config);
         this.afterStart = (_name, _config, routes) => routes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yopdev/dev-server",
-  "version": "3.0.3-beta.6",
+  "version": "3.0.3-beta.7",
   "scripts": {
     "compile": "tsc",
     "pretest": "npm run compile",

package/src/cloudformation-event-proxy.ts

@@ -12,12 +12,6 @@ export const snsEventsFromCloudFormationTemplate = (
     new CloudFormationEventsProxy(name, config);
 class CloudFormationEventsProxy extends CloudFormationSetup<
     {
-        SqsSubscription: {
-            BatchSize: string;
-            QueueArn: string;
-            QueueUrl: string;
-        };
-        Topic: string;
         FilterPolicy: {
             [name: string]: string[];
         };
@@ -34,12 +28,11 @@ class CloudFormationEventsProxy extends CloudFormationSetup<
                 name: handler.name,
                 handler: handler,
                 matcher: (_, attributes) => {
-                    const required = Object.entries(event.Properties.FilterPolicy ?? []).flatMap((entry) =>
-                        entry[1].map((value) => value + entry[0]),
-                    );
+                    const filters = Object.entries(event.Properties?.FilterPolicy ?? [])
+                    const required = filters.flatMap((entry) => entry[1].map((value) => value + entry[0]));
                     if (required.length == 0) return true;
                     const actual = Object.entries(attributes).flatMap((entry) => entry[1].Value + entry[0]);
-                    return required.filter((e) => actual.includes(e)).length > 0;
+                    return required.filter((e) => actual.includes(e)).length == filters.length;
                 },
             }),
             config.prepare,