@fractary/faber 2.5.2 → 2.5.5

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

@@ -1,741 +0,0 @@
-/**
- * @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