@friggframework/serverless-plugin 2.0.0--canary.461.44b70fc.0 → 2.0.0--canary.461.35d292b.0

package/index.test.js

@@ -1,183 +1,306 @@
 const FriggServerlessPlugin = require('./index');
+const fs = require('fs');
+const path = require('path');
 
-// Mock dependencies
-jest.mock('aws-sdk');
+// Mock fs module
+jest.mock('fs');
 
 describe('FriggServerlessPlugin', () => {
     let plugin;
     let mockServerless;
     let mockOptions;
-    const originalEnv = process.env;
+    let mockServicePath;
 
     beforeEach(() => {
-
-        // Mock serverless object
+        mockServicePath = '/test/service/path';
+        
         mockServerless = {
+            config: {
+                servicePath: mockServicePath,
+            },
             cli: {
-                log: jest.fn()
+                log: jest.fn(),
             },
             service: {
+                custom: {},
                 provider: {
-                    name: 'aws',
-                    region: 'us-east-1'
+                    environment: {},
                 },
-                plugins: [],
-                custom: {},
-                functions: {}
             },
             processedInput: {
-                commands: []
+                commands: [],
             },
-            getProvider: jest.fn(() => ({})),
-            extendConfiguration: jest.fn()
+            getProvider: jest.fn().mockReturnValue({}),
+            extendConfiguration: jest.fn(),
         };
 
         mockOptions = {
-            stage: 'test'
+            stage: 'test',
         };
 
-        // Reset environment
-        process.env = { ...originalEnv };
-
+        // Clear all mocks before each test
         jest.clearAllMocks();
-        
-        plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
     });
 
-    afterEach(() => {
-        process.env = originalEnv;
-    });
+    describe('Constructor', () => {
+        it('should initialize with serverless instance and options', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
 
-    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)
-            });
+            expect(plugin.hooks).toBeDefined();
         });
 
-        it('should get AWS provider from serverless', () => {
-            expect(mockServerless.getProvider).toHaveBeenCalledWith('aws');
+        it('should register required hooks', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+
+            expect(plugin.hooks).toHaveProperty('initialize');
+            expect(plugin.hooks).toHaveProperty('before:package:initialize');
+            expect(plugin.hooks).toHaveProperty('after:package:package');
+            expect(plugin.hooks).toHaveProperty('before:deploy:deploy');
         });
     });
 
-    describe('beforePackageInitialize', () => {
-        it('should log pre-package hook message', async () => {
-            await plugin.beforePackageInitialize();
+    describe('asyncInit - Directory Creation', () => {
+        it('should create .esbuild/.serverless directory if it does not exist', async () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+            
+            // Mock fs.existsSync to return false (directory doesn't exist)
+            fs.existsSync.mockReturnValue(false);
+            fs.mkdirSync.mockImplementation(() => {});
 
-            expect(mockServerless.cli.log).toHaveBeenCalledWith('Frigg Serverless Plugin: Pre-package hook');
-        });
-    });
+            // Spy on console.log
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
 
+            await plugin.asyncInit();
 
-    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()
-                }
-            }));
+            const expectedPath = path.join(mockServicePath, '.esbuild', '.serverless');
 
-            mockServerless.service.custom = {
-                TestQueue: 'test-queue-name',
-                AnotherQueue: 'another-queue-name'
-            };
+            // Verify directory existence check
+            expect(fs.existsSync).toHaveBeenCalledWith(expectedPath);
+            
+            // Verify directory creation
+            expect(fs.mkdirSync).toHaveBeenCalledWith(expectedPath, { recursive: true });
+            
+            // Verify success message
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Created')
+            );
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('.esbuild')
+            );
 
-            mockServerless.service.provider.environment = {
-                TEST_QUEUE_URL: { Ref: 'TestQueue' },
-                ANOTHER_QUEUE_URL: { Ref: 'AnotherQueue' },
-                NORMAL_VAR: 'normal-value'
-            };
+            consoleLogSpy.mockRestore();
         });
 
-        it('should create queues in offline mode', async () => {
-            mockServerless.processedInput.commands = ['offline'];
+        it('should not create directory if it already exists', async () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
             
-            const AWS = require('aws-sdk');
-            const mockSQS = new AWS.SQS();
-            mockSQS.createQueue.mockImplementation((params, callback) => {
-                callback(null, { QueueUrl: `http://localhost:4566/000000000000/${params.QueueName}` });
-            });
+            // Mock fs.existsSync to return true (directory exists)
+            fs.existsSync.mockReturnValue(true);
+            fs.mkdirSync.mockImplementation(() => {});
+
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
 
             await plugin.asyncInit();
 
-            expect(AWS.config.update).toHaveBeenCalledWith({
-                region: 'us-east-1',
-                endpoint: 'localhost:4566'
-            });
+            const expectedPath = path.join(mockServicePath, '.esbuild', '.serverless');
 
-            expect(mockSQS.createQueue).toHaveBeenCalledWith(
-                { QueueName: 'test-queue-name' },
-                expect.any(Function)
+            // Verify directory existence check
+            expect(fs.existsSync).toHaveBeenCalledWith(expectedPath);
+            
+            // Verify directory creation was NOT called
+            expect(fs.mkdirSync).not.toHaveBeenCalled();
+            
+            // Verify success message was NOT logged
+            expect(consoleLogSpy).not.toHaveBeenCalledWith(
+                expect.stringContaining('Created')
             );
 
-            expect(mockSQS.createQueue).toHaveBeenCalledWith(
-                { QueueName: 'another-queue-name' },
-                expect.any(Function)
-            );
+            consoleLogSpy.mockRestore();
+        });
+
+        it('should use process.cwd() if servicePath is not available', async () => {
+            // Remove servicePath from config
+            mockServerless.config.servicePath = undefined;
+            
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+            
+            fs.existsSync.mockReturnValue(false);
+            fs.mkdirSync.mockImplementation(() => {});
+
+            await plugin.asyncInit();
 
-            expect(mockServerless.extendConfiguration).toHaveBeenCalled();
+            const expectedPath = path.join(process.cwd(), '.esbuild', '.serverless');
+
+            expect(fs.existsSync).toHaveBeenCalledWith(expectedPath);
+            expect(fs.mkdirSync).toHaveBeenCalledWith(expectedPath, { recursive: true });
         });
 
-        it('should skip queue creation in online mode', async () => {
+        it('should log initialization messages', async () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+            
+            fs.existsSync.mockReturnValue(true);
+
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+            await plugin.asyncInit();
+
+            // Verify plugin initialization messages
+            expect(mockServerless.cli.log).toHaveBeenCalledWith('Initializing Frigg Serverless Plugin...');
+            expect(consoleLogSpy).toHaveBeenCalledWith('Hello from Frigg Serverless Plugin!');
+
+            consoleLogSpy.mockRestore();
+        });
+    });
+
+    describe('asyncInit - Offline Mode', () => {
+        it('should not create SQS queues when not in offline mode', async () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+            
+            fs.existsSync.mockReturnValue(true);
+            
+            // Not in offline mode
             mockServerless.processedInput.commands = ['deploy'];
 
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
             await plugin.asyncInit();
 
-            const AWS = require('aws-sdk');
-            expect(AWS.config.update).not.toHaveBeenCalled();
+            expect(consoleLogSpy).toHaveBeenCalledWith('Running in online mode, doing nothing');
+            expect(consoleLogSpy).not.toHaveBeenCalledWith(
+                expect.stringContaining('offline mode')
+            );
+
+            consoleLogSpy.mockRestore();
         });
 
-        it('should handle queue creation errors', async () => {
-            mockServerless.processedInput.commands = ['offline'];
+        it('should create SQS queues when in offline mode', async () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+            
+            fs.existsSync.mockReturnValue(true);
             
-            const AWS = require('aws-sdk');
-            const mockSQS = new AWS.SQS();
-            mockSQS.createQueue.mockImplementation((params, callback) => {
-                callback(new Error('Queue creation failed'));
+            // Set offline mode
+            mockServerless.processedInput.commands = ['offline'];
+            mockServerless.service.custom = {
+                testQueue: 'test-queue-name',
+            };
+
+            // Mock AWS SDK
+            const mockCreateQueue = jest.fn((params, callback) => {
+                callback(null, { QueueUrl: 'http://localhost:4566/queue/test-queue-name' });
             });
 
-            await expect(plugin.asyncInit()).rejects.toThrow('Queue creation failed');
+            jest.mock('aws-sdk', () => ({
+                SQS: jest.fn(() => ({
+                    createQueue: mockCreateQueue,
+                })),
+                config: {
+                    update: jest.fn(),
+                },
+            }));
+
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+            await plugin.asyncInit();
+
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('offline mode')
+            );
+
+            consoleLogSpy.mockRestore();
         });
     });
 
-    describe('hook methods', () => {
-        it('should have init method', () => {
-            expect(plugin.init).toBeDefined();
-            expect(typeof plugin.init).toBe('function');
+    describe('beforePackageInitialize', () => {
+        it('should create .esbuild/.serverless directory', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+            
+            fs.existsSync.mockReturnValue(false);
+            fs.mkdirSync.mockImplementation(() => {});
+
+            plugin.beforePackageInitialize();
+
+            const expectedPath = path.join(mockServicePath, '.esbuild', '.serverless');
+
+            expect(fs.existsSync).toHaveBeenCalledWith(expectedPath);
+            expect(fs.mkdirSync).toHaveBeenCalledWith(expectedPath, { recursive: true });
         });
 
-        it('should have afterPackage method', () => {
-            expect(plugin.afterPackage).toBeDefined();
-            expect(typeof plugin.afterPackage).toBe('function');
+        it('should log pre-package hook message', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
             
-            // Test that it logs correctly
-            const consoleSpy = jest.spyOn(console, 'log');
+            fs.existsSync.mockReturnValue(true);
+
+            plugin.beforePackageInitialize();
+
+            expect(mockServerless.cli.log).toHaveBeenCalledWith('Frigg Serverless Plugin: Pre-package hook');
+        });
+    });
+
+    describe('init', () => {
+        it('should create .esbuild/.serverless directory', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+            
+            fs.existsSync.mockReturnValue(false);
+            fs.mkdirSync.mockImplementation(() => {});
+
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
+            plugin.init();
+
+            const expectedPath = path.join(mockServicePath, '.esbuild', '.serverless');
+
+            expect(fs.existsSync).toHaveBeenCalledWith(expectedPath);
+            expect(fs.mkdirSync).toHaveBeenCalledWith(expectedPath, { recursive: true });
+            expect(consoleLogSpy).toHaveBeenCalledWith(
+                expect.stringContaining('Created')
+            );
+
+            consoleLogSpy.mockRestore();
+        });
+    });
+
+    describe('afterPackage', () => {
+        it('should log after package hook message', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+            
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
             plugin.afterPackage();
-            expect(consoleSpy).toHaveBeenCalledWith('After package hook called');
-            consoleSpy.mockRestore();
+
+            expect(consoleLogSpy).toHaveBeenCalledWith('After package hook called');
+
+            consoleLogSpy.mockRestore();
         });
+    });
 
-        it('should have beforeDeploy method', () => {
-            expect(plugin.beforeDeploy).toBeDefined();
-            expect(typeof plugin.beforeDeploy).toBe('function');
+    describe('beforeDeploy', () => {
+        it('should log before deploy hook message', () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
             
-            // Test that it logs correctly
-            const consoleSpy = jest.spyOn(console, 'log');
+            const consoleLogSpy = jest.spyOn(console, 'log').mockImplementation();
+
             plugin.beforeDeploy();
-            expect(consoleSpy).toHaveBeenCalledWith('Before deploy hook called');
-            consoleSpy.mockRestore();
+
+            expect(consoleLogSpy).toHaveBeenCalledWith('Before deploy hook called');
+
+            consoleLogSpy.mockRestore();
+        });
+    });
+
+    describe('Error Handling', () => {
+        it('should handle fs.mkdirSync errors gracefully', async () => {
+            plugin = new FriggServerlessPlugin(mockServerless, mockOptions);
+            
+            fs.existsSync.mockReturnValue(false);
+            fs.mkdirSync.mockImplementation(() => {
+                throw new Error('Permission denied');
+            });
+
+            // Should not throw - error should be caught or allowed to propagate
+            await expect(plugin.asyncInit()).rejects.toThrow('Permission denied');
         });
     });
+});
 
-});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friggframework/serverless-plugin",
-  "version": "2.0.0--canary.461.44b70fc.0",
+  "version": "2.0.0--canary.461.35d292b.0",
   "description": "Plugin to help dynamically load frigg resources",
   "main": "index.js",
   "scripts": {
@@ -11,5 +11,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "44b70fce55d47259bf67cc71056376941940ba9b"
+  "gitHead": "35d292ba0c73d3a112e8fda3c930ba0dcfeb4c4f"
 }