@kapeta/local-cluster-service 0.46.0 → 0.47.1

package/test/storm/event-parser.test.ts

@@ -0,0 +1,182 @@
+/**
+ * Copyright 2023 Kapeta Inc.
+ * SPDX-License-Identifier: BUSL-1.1
+ */
+
+import { StormEventParser } from '../../src/storm/event-parser';
+import { StormEvent } from '../../src/storm/events';
+
+const parserOptions = {
+    serviceKind: 'kapeta/block-service:local',
+    serviceLanguage: 'kapeta/language-target-nodejs-ts:local',
+
+    frontendKind: 'kapeta/block-type-frontend:local',
+    frontendLanguage: 'kapeta/language-target-react-ts:local',
+
+    cliKind: 'kapeta/block-type-cli:local',
+    cliLanguage: 'kapeta/language-target-nodejs-ts:local',
+
+    desktopKind: 'kapeta/block-type-desktop:local',
+    desktopLanguage: 'kapeta/language-target-electron-ts:local',
+
+    gatewayKind: 'kapeta/block-type-gateway:local',
+
+    mqKind: 'kapeta/block-type-mq:local',
+    exchangeKind: 'kapeta/resource-type-exchange:local',
+    queueKind: 'kapeta/resource-type-queue:local',
+    publisherKind: 'kapeta/resource-type-publisher:local',
+    subscriberKind: 'kapeta/resource-type-subscriber:local',
+    databaseKind: 'kapeta/block-type-database:local',
+
+    apiKind: 'kapeta/block-type-api:local',
+    clientKind: 'kapeta/block-type-client:local',
+
+    webPageKind: 'kapeta/block-type-web-page:local',
+    webFragmentKind: 'kapeta/block-type-web-fragment:local',
+
+    jwtProviderKind: 'kapeta/resource-type-jwt-provider:local',
+    jwtConsumerKind: 'kapeta/resource-type-jwt-consumer:local',
+
+    smtpKind: 'kapeta/resource-type-smtp:local',
+    externalApiKind: 'kapeta/resource-type-external-api:local',
+};
+
+const events: StormEvent[] = [
+    {
+        type: 'CREATE_PLAN_PROPERTIES',
+        created: Date.now(),
+        reason: 'create plan properties',
+        payload: {
+            name: 'my-plan',
+            description: 'my plan description',
+        },
+    },
+    {
+        type: 'CREATE_BLOCK',
+        reason: 'create backend',
+        created: Date.now(),
+        payload: {
+            name: 'service',
+            description: 'A service block',
+            type: 'BACKEND',
+            resources: [
+                {
+                    name: 'entities',
+                    type: 'DATABASE',
+                    description: 'A database resource',
+                },
+                {
+                    type: 'API',
+                    name: 'entities',
+                    description: 'An API resource',
+                },
+            ],
+        },
+    },
+    {
+        type: 'CREATE_BLOCK',
+        reason: 'create frontend',
+        created: Date.now(),
+        payload: {
+            name: 'ui',
+            description: 'A frontend block',
+            type: 'FRONTEND',
+            resources: [
+                {
+                    name: 'web',
+                    type: 'WEBPAGE',
+                    description: 'A web page',
+                },
+                {
+                    type: 'CLIENT',
+                    name: 'entities',
+                    description: 'Client for backend',
+                },
+            ],
+        },
+    },
+    {
+        type: 'CREATE_CONNECTION',
+        created: Date.now(),
+        reason: 'connect service to ui',
+        payload: {
+            fromComponent: 'service',
+            fromResource: 'entities',
+            fromResourceType: 'API',
+            toComponent: 'ui',
+            toResource: 'entities',
+            toResourceType: 'CLIENT',
+        },
+    },
+    {
+        type: 'CREATE_API',
+        reason: 'create api',
+        created: Date.now(),
+        payload: {
+            blockName: 'service',
+            content: `controller Entities('/entities') {
+                        @GET('/')
+                        list(): string[]
+                    }`,
+        },
+    },
+    {
+        type: 'CREATE_MODEL',
+        created: Date.now(),
+        reason: 'create model',
+        payload: {
+            blockName: 'service',
+            content: `type Entity {
+                        @Id
+                        id: string
+                        
+                        name: string
+                    }`,
+        },
+    },
+];
+
+describe('event-parser', () => {
+    it('it can parse events into a plan and blocks with proper layout', () => {
+        const parser = new StormEventParser(parserOptions);
+        events.forEach((event) => parser.addEvent('kapeta', event));
+
+        const result = parser.toResult('kapeta');
+
+        expect(result.plan.metadata.name).toBe('kapeta/my-plan');
+        expect(result.plan.metadata.description).toBe('my plan description');
+        expect(result.blocks.length).toBe(2);
+        expect(result.blocks[0].content.metadata.name).toBe('kapeta/service');
+        expect(result.blocks[1].content.metadata.name).toBe('kapeta/ui');
+
+        const dbResource = result.blocks[0].content.spec.consumers?.[0];
+        const apiResource = result.blocks[0].content.spec.providers?.[0];
+        const clientResource = result.blocks[1].content.spec.consumers?.[0];
+        const pageResource = result.blocks[1].content.spec.providers?.[0];
+
+        expect(apiResource).toBeDefined();
+        expect(clientResource).toBeDefined();
+        expect(dbResource).toBeDefined();
+        expect(pageResource).toBeDefined();
+
+        expect(apiResource?.kind).toBe(parserOptions.apiKind);
+        expect(clientResource?.kind).toBe(parserOptions.clientKind);
+        expect(dbResource?.kind).toBe(parserOptions.databaseKind);
+        expect(pageResource?.kind).toBe(parserOptions.webPageKind);
+
+        expect(apiResource?.spec).toEqual(clientResource?.spec);
+        expect(dbResource?.spec.source.value).toContain('type Entity');
+
+        const serviceBlockInstance = result.plan.spec.blocks[0];
+        expect(serviceBlockInstance.name).toBe('service');
+
+        const uiBlockInstance = result.plan.spec.blocks[1];
+        expect(uiBlockInstance.name).toBe('ui');
+
+        expect(result.plan.spec.connections.length).toBe(1);
+        expect(result.plan.spec.connections[0].consumer.blockId).toBe(uiBlockInstance.id);
+        expect(result.plan.spec.connections[0].consumer.resourceName).toBe(clientResource?.metadata.name);
+        expect(result.plan.spec.connections[0].provider.blockId).toBe(serviceBlockInstance.id);
+        expect(result.plan.spec.connections[0].provider.resourceName).toBe(apiResource?.metadata.name);
+    });
+});