@fractary/faber 2.4.41 → 2.4.43

package/dist/cloud/__tests__/resource-manager.test.js

@@ -0,0 +1,741 @@
+/**
+ * @fractary/faber - ResourceManager Tests
+ *
+ * Unit tests for ResourceManager with mocked TerraformManager
+ */
+import * as fs from 'fs';
+import * as path from 'path';
+import { ResourceManager } from '../resource-manager';
+import { TerraformManager } from '../terraform-manager';
+// Mock TerraformManager
+jest.mock('../terraform-manager');
+const MockedTerraformManager = TerraformManager;
+describe('ResourceManager', () => {
+    const testDir = path.join(__dirname, '__test-resource-manager__');
+    const tfDir = path.join(testDir, 'terraform');
+    let manager;
+    let mockTerraformManager;
+    beforeEach(() => {
+        // Clean up test directory before each test
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+        fs.mkdirSync(tfDir, { recursive: true });
+        // Reset mocks
+        jest.clearAllMocks();
+        // Create mock instance
+        mockTerraformManager = {
+            isInitialized: jest.fn(),
+            show: jest.fn(),
+            output: jest.fn(),
+        };
+        // Mock constructor to return our mock instance
+        MockedTerraformManager.mockImplementation(() => mockTerraformManager);
+        // Create manager
+        manager = new ResourceManager({
+            environment: 'production',
+            terraformDir: tfDir,
+            awsProfile: 'prod',
+        });
+    });
+    afterEach(() => {
+        // Clean up test directory after each test
+        if (fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    describe('Constructor', () => {
+        it('should construct with required config', () => {
+            const mgr = new ResourceManager({
+                environment: 'dev',
+            });
+            expect(mgr).toBeDefined();
+        });
+        it('should construct with terraform directory', () => {
+            const mgr = new ResourceManager({
+                environment: 'staging',
+                terraformDir: tfDir,
+            });
+            expect(mgr).toBeDefined();
+        });
+        it('should construct with AWS profile', () => {
+            const mgr = new ResourceManager({
+                environment: 'prod',
+                awsProfile: 'production',
+            });
+            expect(mgr).toBeDefined();
+        });
+    });
+    describe('getEnvironment', () => {
+        it('should return configured environment', () => {
+            expect(manager.getEnvironment()).toBe('production');
+        });
+    });
+    describe('list', () => {
+        const mockTerraformState = {
+            format_version: '1.0',
+            terraform_version: '1.5.0',
+            resources: [
+                {
+                    type: 'aws_instance',
+                    name: 'web',
+                    mode: 'managed',
+                    provider: 'registry.terraform.io/hashicorp/aws',
+                    instances: [{
+                            schema_version: 1,
+                            attributes: {
+                                id: 'i-12345',
+                                arn: 'arn:aws:ec2:us-west-2:123456789012:instance/i-12345',
+                                instance_type: 't3.micro',
+                                instance_state: 'running',
+                                availability_zone: 'us-west-2a',
+                                tags: { Name: 'web-server', Environment: 'production' },
+                            },
+                        }],
+                },
+                {
+                    type: 'aws_s3_bucket',
+                    name: 'assets',
+                    mode: 'managed',
+                    provider: 'registry.terraform.io/hashicorp/aws',
+                    instances: [{
+                            schema_version: 0,
+                            attributes: {
+                                id: 'my-assets-bucket',
+                                arn: 'arn:aws:s3:::my-assets-bucket',
+                                region: 'us-west-2',
+                                tags: { Name: 'assets', Environment: 'production' },
+                            },
+                        }],
+                },
+                {
+                    type: 'aws_lambda_function',
+                    name: 'api',
+                    mode: 'managed',
+                    provider: 'registry.terraform.io/hashicorp/aws',
+                    instances: [{
+                            schema_version: 0,
+                            attributes: {
+                                id: 'my-api-function',
+                                arn: 'arn:aws:lambda:us-west-2:123456789012:function:my-api',
+                                function_name: 'my-api',
+                                region: 'us-west-2',
+                            },
+                        }],
+                },
+            ],
+            outputs: {},
+        };
+        beforeEach(() => {
+            mockTerraformManager.isInitialized.mockResolvedValue(true);
+            mockTerraformManager.show.mockResolvedValue(mockTerraformState);
+        });
+        it('should list all resources from terraform state', async () => {
+            const resources = await manager.list();
+            expect(resources).toHaveLength(3);
+            expect(resources.map(r => r.type)).toContain('aws_instance');
+            expect(resources.map(r => r.type)).toContain('aws_s3_bucket');
+            expect(resources.map(r => r.type)).toContain('aws_lambda_function');
+        });
+        it('should map AWS provider correctly', async () => {
+            const resources = await manager.list();
+            resources.forEach(r => {
+                expect(r.provider).toBe('aws');
+            });
+        });
+        it('should extract resource name from tags', async () => {
+            const resources = await manager.list();
+            const webInstance = resources.find(r => r.type === 'aws_instance');
+            expect(webInstance?.name).toBe('web-server');
+        });
+        it('should use terraform resource name as fallback', async () => {
+            const resources = await manager.list();
+            // Lambda function doesn't have attrs.name, so falls back to resource.name
+            const lambda = resources.find(r => r.type === 'aws_lambda_function');
+            expect(lambda?.name).toBe('api'); // Uses terraform resource name as fallback
+        });
+        it('should extract region from availability zone', async () => {
+            const resources = await manager.list();
+            const webInstance = resources.find(r => r.type === 'aws_instance');
+            expect(webInstance?.region).toBe('us-west-2');
+        });
+        it('should include terraform_address in metadata', async () => {
+            const resources = await manager.list();
+            const webInstance = resources.find(r => r.type === 'aws_instance');
+            expect(webInstance?.metadata?.terraform_address).toBe('aws_instance.web');
+        });
+        it('should filter by type', async () => {
+            const resources = await manager.list({ type: 'aws_instance' });
+            expect(resources).toHaveLength(1);
+            expect(resources[0].type).toBe('aws_instance');
+        });
+        it('should filter by status', async () => {
+            const resources = await manager.list({ status: 'running' });
+            // All resources in our mock are running
+            expect(resources.length).toBeGreaterThan(0);
+            resources.forEach(r => {
+                expect(r.status).toBe('running');
+            });
+        });
+        it('should filter by region', async () => {
+            const resources = await manager.list({ region: 'us-west-2' });
+            expect(resources.length).toBeGreaterThan(0);
+            resources.forEach(r => {
+                expect(r.region).toBe('us-west-2');
+            });
+        });
+        it('should filter by tag', async () => {
+            const resources = await manager.list({
+                tag: { key: 'Environment', value: 'production' },
+            });
+            expect(resources).toHaveLength(2); // web instance and s3 bucket have Environment tag
+        });
+        it('should return empty array when terraform not initialized', async () => {
+            mockTerraformManager.isInitialized.mockResolvedValue(false);
+            const resources = await manager.list();
+            expect(resources).toEqual([]);
+        });
+        it('should return empty array when no terraform directory', async () => {
+            const mgr = new ResourceManager({
+                environment: 'dev',
+                // No terraformDir
+            });
+            const resources = await mgr.list();
+            expect(resources).toEqual([]);
+        });
+        it('should handle terraform show error gracefully', async () => {
+            mockTerraformManager.show.mockRejectedValue(new Error('State not found'));
+            const resources = await manager.list();
+            expect(resources).toEqual([]);
+        });
+    });
+    describe('Resource Status Mapping', () => {
+        beforeEach(() => {
+            mockTerraformManager.isInitialized.mockResolvedValue(true);
+        });
+        it('should map EC2 running state', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'aws_instance',
+                        name: 'web',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: {
+                                    id: 'i-12345',
+                                    instance_state: 'running',
+                                },
+                            }],
+                    }],
+                outputs: {},
+            });
+            const resources = await manager.list();
+            expect(resources[0].status).toBe('running');
+        });
+        it('should map EC2 stopped state', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'aws_instance',
+                        name: 'web',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: {
+                                    id: 'i-12345',
+                                    instance_state: 'stopped',
+                                },
+                            }],
+                    }],
+                outputs: {},
+            });
+            const resources = await manager.list();
+            expect(resources[0].status).toBe('stopped');
+        });
+        it('should map EC2 pending state', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'aws_instance',
+                        name: 'web',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: {
+                                    id: 'i-12345',
+                                    instance_state: 'pending',
+                                },
+                            }],
+                    }],
+                outputs: {},
+            });
+            const resources = await manager.list();
+            expect(resources[0].status).toBe('pending');
+        });
+        it('should map RDS available state to running', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'aws_db_instance',
+                        name: 'db',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: {
+                                    id: 'mydb',
+                                    status: 'available',
+                                },
+                            }],
+                    }],
+                outputs: {},
+            });
+            const resources = await manager.list();
+            expect(resources[0].status).toBe('running');
+        });
+        it('should map Lambda function to running', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'aws_lambda_function',
+                        name: 'api',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: {
+                                    id: 'my-function',
+                                },
+                            }],
+                    }],
+                outputs: {},
+            });
+            const resources = await manager.list();
+            expect(resources[0].status).toBe('running');
+        });
+        it('should map ECS service with desired_count > 0 to running', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'aws_ecs_service',
+                        name: 'api',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: {
+                                    id: 'my-service',
+                                    desired_count: 2,
+                                },
+                            }],
+                    }],
+                outputs: {},
+            });
+            const resources = await manager.list();
+            expect(resources[0].status).toBe('running');
+        });
+        it('should map ECS service with desired_count = 0 to stopped', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'aws_ecs_service',
+                        name: 'api',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: {
+                                    id: 'my-service',
+                                    desired_count: 0,
+                                },
+                            }],
+                    }],
+                outputs: {},
+            });
+            const resources = await manager.list();
+            expect(resources[0].status).toBe('stopped');
+        });
+    });
+    describe('status', () => {
+        beforeEach(() => {
+            mockTerraformManager.isInitialized.mockResolvedValue(true);
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [
+                    {
+                        type: 'aws_instance',
+                        name: 'web1',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: { id: 'i-1', instance_state: 'running', region: 'us-west-2' },
+                            }],
+                    },
+                    {
+                        type: 'aws_instance',
+                        name: 'web2',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: { id: 'i-2', instance_state: 'stopped', region: 'us-west-2' },
+                            }],
+                    },
+                    {
+                        type: 'aws_s3_bucket',
+                        name: 'assets',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: { id: 'bucket', region: 'us-east-1' },
+                            }],
+                    },
+                ],
+                outputs: {},
+            });
+        });
+        it('should return total resource count', async () => {
+            const summary = await manager.status();
+            expect(summary.total).toBe(3);
+        });
+        it('should count resources by type', async () => {
+            const summary = await manager.status();
+            expect(summary.by_type['aws_instance']).toBe(2);
+            expect(summary.by_type['aws_s3_bucket']).toBe(1);
+        });
+        it('should count resources by status', async () => {
+            const summary = await manager.status();
+            expect(summary.by_status.running).toBe(2); // 1 running EC2 + 1 S3 (always running)
+            expect(summary.by_status.stopped).toBe(1);
+        });
+        it('should count resources by region', async () => {
+            const summary = await manager.status();
+            expect(summary.by_region['us-west-2']).toBe(2);
+            expect(summary.by_region['us-east-1']).toBe(1);
+        });
+    });
+    describe('get', () => {
+        beforeEach(() => {
+            mockTerraformManager.isInitialized.mockResolvedValue(true);
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'aws_instance',
+                        name: 'web',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: { id: 'i-12345', instance_state: 'running' },
+                            }],
+                    }],
+                outputs: {},
+            });
+        });
+        it('should return resource by ID', async () => {
+            const resource = await manager.get('i-12345');
+            expect(resource).not.toBeNull();
+            expect(resource?.id).toBe('i-12345');
+        });
+        it('should return null for unknown ID', async () => {
+            const resource = await manager.get('i-unknown');
+            expect(resource).toBeNull();
+        });
+    });
+    describe('getByType', () => {
+        beforeEach(() => {
+            mockTerraformManager.isInitialized.mockResolvedValue(true);
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [
+                    {
+                        type: 'aws_instance',
+                        name: 'web',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{ attributes: { id: 'i-1' } }],
+                    },
+                    {
+                        type: 'aws_s3_bucket',
+                        name: 'assets',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{ attributes: { id: 'bucket' } }],
+                    },
+                ],
+                outputs: {},
+            });
+        });
+        it('should return resources of specified type', async () => {
+            const resources = await manager.getByType('aws_instance');
+            expect(resources).toHaveLength(1);
+            expect(resources[0].type).toBe('aws_instance');
+        });
+    });
+    describe('getByTag', () => {
+        beforeEach(() => {
+            mockTerraformManager.isInitialized.mockResolvedValue(true);
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [
+                    {
+                        type: 'aws_instance',
+                        name: 'web',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: {
+                                    id: 'i-1',
+                                    tags: { Environment: 'production', Team: 'engineering' },
+                                },
+                            }],
+                    },
+                    {
+                        type: 'aws_instance',
+                        name: 'dev',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: {
+                                    id: 'i-2',
+                                    tags: { Environment: 'development', Team: 'engineering' },
+                                },
+                            }],
+                    },
+                ],
+                outputs: {},
+            });
+        });
+        it('should return resources with matching tag', async () => {
+            const resources = await manager.getByTag('Environment', 'production');
+            expect(resources).toHaveLength(1);
+            expect(resources[0].id).toBe('i-1');
+        });
+    });
+    describe('hasResources', () => {
+        beforeEach(() => {
+            mockTerraformManager.isInitialized.mockResolvedValue(true);
+        });
+        it('should return true when resources exist', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'aws_instance',
+                        name: 'web',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{ attributes: { id: 'i-1' } }],
+                    }],
+                outputs: {},
+            });
+            expect(await manager.hasResources()).toBe(true);
+        });
+        it('should return false when no resources', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [],
+                outputs: {},
+            });
+            expect(await manager.hasResources()).toBe(false);
+        });
+    });
+    describe('count', () => {
+        beforeEach(() => {
+            mockTerraformManager.isInitialized.mockResolvedValue(true);
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [
+                    {
+                        type: 'aws_instance',
+                        name: 'web1',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{ attributes: { id: 'i-1' } }],
+                    },
+                    {
+                        type: 'aws_instance',
+                        name: 'web2',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{ attributes: { id: 'i-2' } }],
+                    },
+                    {
+                        type: 'aws_s3_bucket',
+                        name: 'assets',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{ attributes: { id: 'bucket' } }],
+                    },
+                ],
+                outputs: {},
+            });
+        });
+        it('should return total count', async () => {
+            const count = await manager.count();
+            expect(count).toBe(3);
+        });
+        it('should return filtered count', async () => {
+            const count = await manager.count({ type: 'aws_instance' });
+            expect(count).toBe(2);
+        });
+    });
+    describe('getOutputs', () => {
+        beforeEach(() => {
+            mockTerraformManager.isInitialized.mockResolvedValue(true);
+        });
+        it('should return terraform outputs', async () => {
+            mockTerraformManager.output.mockResolvedValue({
+                instance_id: { value: 'i-12345', type: 'string', sensitive: false },
+                public_ip: { value: '1.2.3.4', type: 'string', sensitive: false },
+            });
+            const outputs = await manager.getOutputs();
+            expect(outputs['instance_id']).toBe('i-12345');
+            expect(outputs['public_ip']).toBe('1.2.3.4');
+        });
+        it('should return empty object when not initialized', async () => {
+            mockTerraformManager.isInitialized.mockResolvedValue(false);
+            const outputs = await manager.getOutputs();
+            expect(outputs).toEqual({});
+        });
+        it('should return empty object on error', async () => {
+            mockTerraformManager.output.mockRejectedValue(new Error('No outputs'));
+            const outputs = await manager.getOutputs();
+            expect(outputs).toEqual({});
+        });
+    });
+    describe('healthCheck', () => {
+        beforeEach(() => {
+            mockTerraformManager.isInitialized.mockResolvedValue(true);
+        });
+        it('should return healthy when all resources are healthy', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [
+                    {
+                        type: 'aws_instance',
+                        name: 'web',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: { id: 'i-1', instance_state: 'running' },
+                            }],
+                    },
+                    {
+                        type: 'aws_s3_bucket',
+                        name: 'assets',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{ attributes: { id: 'bucket' } }],
+                    },
+                ],
+                outputs: {},
+            });
+            const health = await manager.healthCheck();
+            expect(health.healthy).toBe(true);
+            expect(health.issues).toHaveLength(0);
+            expect(health.checked).toBe(2);
+        });
+        it('should report stopped EC2 instances', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'aws_instance',
+                        name: 'web',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: { id: 'i-1', instance_state: 'stopped' },
+                            }],
+                    }],
+                outputs: {},
+            });
+            const health = await manager.healthCheck();
+            expect(health.healthy).toBe(false);
+            expect(health.issues).toContain('1 EC2 instance(s) are stopped');
+        });
+        it('should report terminated resources', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'aws_instance',
+                        name: 'web',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/aws',
+                        instances: [{
+                                attributes: { id: 'i-1', instance_state: 'terminated' },
+                            }],
+                    }],
+                outputs: {},
+            });
+            const health = await manager.healthCheck();
+            expect(health.healthy).toBe(false);
+            expect(health.issues.some(i => i.includes('terminated'))).toBe(true);
+        });
+    });
+    describe('Provider Detection', () => {
+        beforeEach(() => {
+            mockTerraformManager.isInitialized.mockResolvedValue(true);
+        });
+        it('should detect GCP provider', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'google_compute_instance',
+                        name: 'web',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/google',
+                        instances: [{ attributes: { id: 'vm-1' } }],
+                    }],
+                outputs: {},
+            });
+            const resources = await manager.list();
+            expect(resources[0].provider).toBe('gcp');
+        });
+        it('should detect Azure provider', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'azurerm_virtual_machine',
+                        name: 'web',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/azurerm',
+                        instances: [{ attributes: { id: 'vm-1' } }],
+                    }],
+                outputs: {},
+            });
+            const resources = await manager.list();
+            expect(resources[0].provider).toBe('azure');
+        });
+        it('should fallback to other for unknown provider', async () => {
+            mockTerraformManager.show.mockResolvedValue({
+                format_version: '1.0',
+                terraform_version: '1.5.0',
+                resources: [{
+                        type: 'kubernetes_deployment',
+                        name: 'web',
+                        mode: 'managed',
+                        provider: 'registry.terraform.io/hashicorp/kubernetes',
+                        instances: [{ attributes: { id: 'deploy-1' } }],
+                    }],
+                outputs: {},
+            });
+            const resources = await manager.list();
+            expect(resources[0].provider).toBe('other');
+        });
+    });
+});
+//# sourceMappingURL=resource-manager.test.js.map