@friggframework/serverless-plugin 2.0.0-next.3 → 2.0.0-next.30

package/index.js

@@ -1,16 +1,30 @@
 const { spawn } = require("child_process");
 
+/**
+ * Frigg Serverless Plugin - Handles AWS discovery and local development setup
+ */
 class FriggServerlessPlugin {
+  /**
+   * Creates an instance of FriggServerlessPlugin
+   * @param {Object} serverless - Serverless framework instance
+   * @param {Object} options - Plugin options
+   */
   constructor(serverless, options) {
     this.serverless = serverless;
     this.options = options;
     this.provider = serverless.getProvider("aws");
     this.hooks = {
       initialize: () => this.init(),
+      "before:package:initialize": () => this.beforePackageInitialize(),
       "after:package:package": () => this.afterPackage(),
       "before:deploy:deploy": () => this.beforeDeploy(),
     };
   }
+  /**
+   * Asynchronous initialization for offline mode
+   * Creates SQS queues in localstack for local development
+   * @returns {Promise<void>}
+   */
   async asyncInit() {
     this.serverless.cli.log("Initializing Frigg Serverless Plugin...");
     console.log("Hello from Frigg Serverless Plugin!");
@@ -38,7 +52,7 @@ class FriggServerlessPlugin {
       });
 
       const sqs = new AWS.SQS();
-// Find the environment variables that we need to override and create an easy map
+      // Find the environment variables that we need to override and create an easy map
       const environmentMap = {};
       const environment = this.serverless.service.provider.environment;
 
@@ -83,7 +97,26 @@ class FriggServerlessPlugin {
       console.log("Running in online mode, doing nothing");
     }
   }
-  init() {}
+
+  /**
+   * Hook that runs before serverless package initialization
+   * AWS discovery is now handled in serverless-template.js
+   * @returns {Promise<void>}
+   */
+  async beforePackageInitialize() {
+    // AWS discovery is now handled directly in serverless-template.js
+    // This hook remains for potential future use or other pre-package tasks
+    this.serverless.cli.log("Frigg Serverless Plugin: Pre-package hook");
+  }
+
+
+  /**
+   * Initialization hook (currently empty)
+   */
+  init() { }
+  /**
+   * Hook that runs after serverless package
+   */
   afterPackage() {
     console.log("After package hook called");
     // // const queues = Object.keys(infrastructure.custom)
@@ -123,6 +156,9 @@ class FriggServerlessPlugin {
     // //     });
     // });
   }
+  /**
+   * Hook that runs before serverless deploy
+   */
   beforeDeploy() {
     console.log("Before deploy hook called");
   }

package/index.test.js

@@ -0,0 +1,183 @@
+const FriggServerlessPlugin = require('./index');
+
+// Mock dependencies
+jest.mock('aws-sdk');
+
+describe('FriggServerlessPlugin', () => {
+    let plugin;
+    let mockServerless;
+    let mockOptions;
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+
+        // Mock serverless object
+        mockServerless = {
+            cli: {
+                log: jest.fn()
+            },
+            service: {
+                provider: {
+                    name: 'aws',
+                    region: 'us-east-1'
+                },
+                plugins: [],
+                custom: {},
+                functions: {}
+            },
+            processedInput: {
+                commands: []
+            },
+            getProvider: jest.fn(() => ({})),
+            extendConfiguration: jest.fn()
+        };
+
+        mockOptions = {
+            stage: 'test'
+        };
+
+        // Reset environment
+        process.env = { ...originalEnv };
+
+        jest.clearAllMocks();
+        
+        plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+    });
+
+    afterEach(() => {
+        process.env = originalEnv;
+    });
+
+    describe('constructor', () => {
+        it('should initialize plugin with correct hooks', () => {
+            expect(plugin.serverless).toBe(mockServerless);
+            expect(plugin.options).toBe(mockOptions);
+            expect(plugin.hooks).toEqual({
+                initialize: expect.any(Function),
+                'before:package:initialize': expect.any(Function),
+                'after:package:package': expect.any(Function),
+                'before:deploy:deploy': expect.any(Function)
+            });
+        });
+
+        it('should get AWS provider from serverless', () => {
+            expect(mockServerless.getProvider).toHaveBeenCalledWith('aws');
+        });
+    });
+
+    describe('beforePackageInitialize', () => {
+        it('should log pre-package hook message', async () => {
+            await plugin.beforePackageInitialize();
+
+            expect(mockServerless.cli.log).toHaveBeenCalledWith('Frigg Serverless Plugin: Pre-package hook');
+        });
+    });
+
+
+    describe('asyncInit (offline mode)', () => {
+        beforeEach(() => {
+            // Mock AWS SDK
+            const mockSQS = {
+                createQueue: jest.fn()
+            };
+            
+            jest.doMock('aws-sdk', () => ({
+                SQS: jest.fn(() => mockSQS),
+                config: {
+                    update: jest.fn()
+                }
+            }));
+
+            mockServerless.service.custom = {
+                TestQueue: 'test-queue-name',
+                AnotherQueue: 'another-queue-name'
+            };
+
+            mockServerless.service.provider.environment = {
+                TEST_QUEUE_URL: { Ref: 'TestQueue' },
+                ANOTHER_QUEUE_URL: { Ref: 'AnotherQueue' },
+                NORMAL_VAR: 'normal-value'
+            };
+        });
+
+        it('should create queues in offline mode', async () => {
+            mockServerless.processedInput.commands = ['offline'];
+            
+            const AWS = require('aws-sdk');
+            const mockSQS = new AWS.SQS();
+            mockSQS.createQueue.mockImplementation((params, callback) => {
+                callback(null, { QueueUrl: `http://localhost:4566/000000000000/${params.QueueName}` });
+            });
+
+            await plugin.asyncInit();
+
+            expect(AWS.config.update).toHaveBeenCalledWith({
+                region: 'us-east-1',
+                endpoint: 'localhost:4566'
+            });
+
+            expect(mockSQS.createQueue).toHaveBeenCalledWith(
+                { QueueName: 'test-queue-name' },
+                expect.any(Function)
+            );
+
+            expect(mockSQS.createQueue).toHaveBeenCalledWith(
+                { QueueName: 'another-queue-name' },
+                expect.any(Function)
+            );
+
+            expect(mockServerless.extendConfiguration).toHaveBeenCalled();
+        });
+
+        it('should skip queue creation in online mode', async () => {
+            mockServerless.processedInput.commands = ['deploy'];
+
+            await plugin.asyncInit();
+
+            const AWS = require('aws-sdk');
+            expect(AWS.config.update).not.toHaveBeenCalled();
+        });
+
+        it('should handle queue creation errors', async () => {
+            mockServerless.processedInput.commands = ['offline'];
+            
+            const AWS = require('aws-sdk');
+            const mockSQS = new AWS.SQS();
+            mockSQS.createQueue.mockImplementation((params, callback) => {
+                callback(new Error('Queue creation failed'));
+            });
+
+            await expect(plugin.asyncInit()).rejects.toThrow('Queue creation failed');
+        });
+    });
+
+    describe('hook methods', () => {
+        it('should have init method', () => {
+            expect(plugin.init).toBeDefined();
+            expect(typeof plugin.init).toBe('function');
+        });
+
+        it('should have afterPackage method', () => {
+            expect(plugin.afterPackage).toBeDefined();
+            expect(typeof plugin.afterPackage).toBe('function');
+            
+            // Test that it logs correctly
+            const consoleSpy = jest.spyOn(console, 'log');
+            plugin.afterPackage();
+            expect(consoleSpy).toHaveBeenCalledWith('After package hook called');
+            consoleSpy.mockRestore();
+        });
+
+        it('should have beforeDeploy method', () => {
+            expect(plugin.beforeDeploy).toBeDefined();
+            expect(typeof plugin.beforeDeploy).toBe('function');
+            
+            // Test that it logs correctly
+            const consoleSpy = jest.spyOn(console, 'log');
+            plugin.beforeDeploy();
+            expect(consoleSpy).toHaveBeenCalledWith('Before deploy hook called');
+            consoleSpy.mockRestore();
+        });
+    });
+
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friggframework/serverless-plugin",
-  "version": "2.0.0-next.3",
+  "version": "2.0.0-next.30",
   "description": "Plugin to help dynamically load frigg resources",
   "main": "index.js",
   "scripts": {
@@ -11,5 +11,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "431427564322cdb02a43b686af70b0fb30a17a8b"
+  "gitHead": "5c1c0838a8e2d0d77e557ce11d9ad0899c3f464d"
 }