@friggframework/devtools 2.0.0-next.44 → 2.0.0-next.46

package/infrastructure/domains/health/domain/entities/issue.test.js

@@ -0,0 +1,528 @@
+/**
+ * Tests for Issue Entity
+ */
+
+const Issue = require('./issue');
+const ResourceState = require('../value-objects/resource-state');
+const PropertyMismatch = require('./property-mismatch');
+const PropertyMutability = require('../value-objects/property-mutability');
+
+describe('Issue', () => {
+    describe('constructor', () => {
+        it('should create an orphaned resource issue', () => {
+            const issue = new Issue({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-app-prod-aurora',
+                description: 'Aurora cluster exists in AWS but not managed by CloudFormation',
+                resolution: 'Import resource into CloudFormation stack',
+                canAutoFix: true,
+            });
+
+            expect(issue.type).toBe('ORPHANED_RESOURCE');
+            expect(issue.severity).toBe('critical');
+            expect(issue.resourceType).toBe('AWS::RDS::DBCluster');
+            expect(issue.resourceId).toBe('my-app-prod-aurora');
+            expect(issue.description).toBe('Aurora cluster exists in AWS but not managed by CloudFormation');
+            expect(issue.resolution).toBe('Import resource into CloudFormation stack');
+            expect(issue.canAutoFix).toBe(true);
+        });
+
+        it('should create a missing resource issue', () => {
+            const issue = new Issue({
+                type: 'MISSING_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::KMS::Key',
+                resourceId: 'FriggKMSKey',
+                description: 'KMS key defined in stack but does not exist in AWS',
+                resolution: 'Verify resource was not manually deleted',
+                canAutoFix: false,
+            });
+
+            expect(issue.type).toBe('MISSING_RESOURCE');
+            expect(issue.severity).toBe('critical');
+        });
+
+        it('should create a property mismatch issue', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: [{ Key: 'Environment', Value: 'production' }],
+                actualValue: [{ Key: 'Env', Value: 'prod' }],
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            const issue = new Issue({
+                type: 'PROPERTY_MISMATCH',
+                severity: 'warning',
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-0abc123',
+                description: 'VPC tags differ from expected configuration',
+                resolution: 'Update VPC tags to match desired state',
+                canAutoFix: true,
+                propertyMismatch: mismatch,
+            });
+
+            expect(issue.type).toBe('PROPERTY_MISMATCH');
+            expect(issue.propertyMismatch).toBe(mismatch);
+            expect(issue.canAutoFix).toBe(true);
+        });
+
+        it('should require type', () => {
+            expect(() => {
+                new Issue({
+                    severity: 'critical',
+                    resourceType: 'AWS::S3::Bucket',
+                    resourceId: 'my-bucket',
+                    description: 'Test',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('type is required');
+        });
+
+        it('should require severity', () => {
+            expect(() => {
+                new Issue({
+                    type: 'ORPHANED_RESOURCE',
+                    resourceType: 'AWS::S3::Bucket',
+                    resourceId: 'my-bucket',
+                    description: 'Test',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('severity is required');
+        });
+
+        it('should require resourceType', () => {
+            expect(() => {
+                new Issue({
+                    type: 'ORPHANED_RESOURCE',
+                    severity: 'critical',
+                    resourceId: 'my-bucket',
+                    description: 'Test',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('resourceType is required');
+        });
+
+        it('should require resourceId', () => {
+            expect(() => {
+                new Issue({
+                    type: 'ORPHANED_RESOURCE',
+                    severity: 'critical',
+                    resourceType: 'AWS::S3::Bucket',
+                    description: 'Test',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('resourceId is required');
+        });
+
+        it('should require description', () => {
+            expect(() => {
+                new Issue({
+                    type: 'ORPHANED_RESOURCE',
+                    severity: 'critical',
+                    resourceType: 'AWS::S3::Bucket',
+                    resourceId: 'my-bucket',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('description is required');
+        });
+
+        it('should validate issue type', () => {
+            expect(() => {
+                new Issue({
+                    type: 'INVALID_TYPE',
+                    severity: 'critical',
+                    resourceType: 'AWS::S3::Bucket',
+                    resourceId: 'my-bucket',
+                    description: 'Test',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('Invalid issue type: INVALID_TYPE');
+        });
+
+        it('should validate severity', () => {
+            expect(() => {
+                new Issue({
+                    type: 'ORPHANED_RESOURCE',
+                    severity: 'invalid',
+                    resourceType: 'AWS::S3::Bucket',
+                    resourceId: 'my-bucket',
+                    description: 'Test',
+                    resolution: 'Fix it',
+                });
+            }).toThrow('Invalid severity: invalid');
+        });
+
+        it('should default canAutoFix to false', () => {
+            const issue = new Issue({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::S3::Bucket',
+                resourceId: 'my-bucket',
+                description: 'Test',
+                resolution: 'Fix it',
+            });
+
+            expect(issue.canAutoFix).toBe(false);
+        });
+    });
+
+    describe('type checks', () => {
+        it('should check if issue is orphaned resource', () => {
+            const issue = new Issue({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-cluster',
+                description: 'Test',
+                resolution: 'Import',
+            });
+
+            expect(issue.isOrphanedResource()).toBe(true);
+            expect(issue.isMissingResource()).toBe(false);
+            expect(issue.isPropertyMismatch()).toBe(false);
+            expect(issue.isDrifted()).toBe(false);
+        });
+
+        it('should check if issue is missing resource', () => {
+            const issue = new Issue({
+                type: 'MISSING_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::KMS::Key',
+                resourceId: 'FriggKMSKey',
+                description: 'Test',
+                resolution: 'Verify deletion',
+            });
+
+            expect(issue.isOrphanedResource()).toBe(false);
+            expect(issue.isMissingResource()).toBe(true);
+            expect(issue.isPropertyMismatch()).toBe(false);
+            expect(issue.isDrifted()).toBe(false);
+        });
+
+        it('should check if issue is property mismatch', () => {
+            const issue = new Issue({
+                type: 'PROPERTY_MISMATCH',
+                severity: 'warning',
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                description: 'Test',
+                resolution: 'Update',
+            });
+
+            expect(issue.isOrphanedResource()).toBe(false);
+            expect(issue.isMissingResource()).toBe(false);
+            expect(issue.isPropertyMismatch()).toBe(true);
+            expect(issue.isDrifted()).toBe(false);
+        });
+
+        it('should check if issue is drifted', () => {
+            const issue = new Issue({
+                type: 'DRIFTED_RESOURCE',
+                severity: 'warning',
+                resourceType: 'AWS::S3::Bucket',
+                resourceId: 'my-bucket',
+                description: 'Test',
+                resolution: 'Reconcile',
+            });
+
+            expect(issue.isOrphanedResource()).toBe(false);
+            expect(issue.isMissingResource()).toBe(false);
+            expect(issue.isPropertyMismatch()).toBe(false);
+            expect(issue.isDrifted()).toBe(true);
+        });
+    });
+
+    describe('severity checks', () => {
+        it('should check if issue is critical', () => {
+            const issue = new Issue({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-cluster',
+                description: 'Test',
+                resolution: 'Import',
+            });
+
+            expect(issue.isCritical()).toBe(true);
+            expect(issue.isWarning()).toBe(false);
+            expect(issue.isInfo()).toBe(false);
+        });
+
+        it('should check if issue is warning', () => {
+            const issue = new Issue({
+                type: 'PROPERTY_MISMATCH',
+                severity: 'warning',
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                description: 'Test',
+                resolution: 'Update',
+            });
+
+            expect(issue.isCritical()).toBe(false);
+            expect(issue.isWarning()).toBe(true);
+            expect(issue.isInfo()).toBe(false);
+        });
+
+        it('should check if issue is info', () => {
+            const issue = new Issue({
+                type: 'MISSING_TAG',
+                severity: 'info',
+                resourceType: 'AWS::Lambda::Function',
+                resourceId: 'my-function',
+                description: 'Test',
+                resolution: 'Add tag',
+            });
+
+            expect(issue.isCritical()).toBe(false);
+            expect(issue.isWarning()).toBe(false);
+            expect(issue.isInfo()).toBe(true);
+        });
+    });
+
+    describe('toString', () => {
+        it('should return string representation', () => {
+            const issue = new Issue({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-app-prod-aurora',
+                description: 'Aurora cluster exists in AWS but not managed by CloudFormation',
+                resolution: 'Import resource into CloudFormation stack',
+            });
+
+            const str = issue.toString();
+            expect(str).toContain('ORPHANED_RESOURCE');
+            expect(str).toContain('critical');
+            expect(str).toContain('AWS::RDS::DBCluster');
+            expect(str).toContain('my-app-prod-aurora');
+        });
+    });
+
+    describe('toJSON', () => {
+        it('should serialize to JSON', () => {
+            const issue = new Issue({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-app-prod-aurora',
+                description: 'Aurora cluster exists in AWS but not managed by CloudFormation',
+                resolution: 'Import resource into CloudFormation stack',
+                canAutoFix: true,
+            });
+
+            const json = issue.toJSON();
+
+            expect(json).toEqual({
+                type: 'ORPHANED_RESOURCE',
+                severity: 'critical',
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-app-prod-aurora',
+                description: 'Aurora cluster exists in AWS but not managed by CloudFormation',
+                resolution: 'Import resource into CloudFormation stack',
+                canAutoFix: true,
+                propertyMismatch: null,
+            });
+        });
+
+        it('should include property mismatch in JSON', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: [{ Key: 'Env', Value: 'prod' }],
+                actualValue: [{ Key: 'Env', Value: 'dev' }],
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            const issue = new Issue({
+                type: 'PROPERTY_MISMATCH',
+                severity: 'warning',
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                description: 'VPC tags differ',
+                resolution: 'Update tags',
+                canAutoFix: true,
+                propertyMismatch: mismatch,
+            });
+
+            const json = issue.toJSON();
+
+            expect(json.propertyMismatch).toBeDefined();
+            expect(json.propertyMismatch.propertyPath).toBe('Properties.Tags');
+        });
+    });
+
+    describe('static factory methods', () => {
+        it('should create orphaned resource issue', () => {
+            const issue = Issue.orphanedResource({
+                resourceType: 'AWS::RDS::DBCluster',
+                resourceId: 'my-cluster',
+                description: 'Cluster not in stack',
+            });
+
+            expect(issue.type).toBe('ORPHANED_RESOURCE');
+            expect(issue.severity).toBe('critical');
+            expect(issue.canAutoFix).toBe(true);
+        });
+
+        it('should create missing resource issue', () => {
+            const issue = Issue.missingResource({
+                resourceType: 'AWS::KMS::Key',
+                resourceId: 'FriggKMSKey',
+                description: 'Key not in AWS',
+            });
+
+            expect(issue.type).toBe('MISSING_RESOURCE');
+            expect(issue.severity).toBe('critical');
+            expect(issue.canAutoFix).toBe(false);
+        });
+
+        it('should create property mismatch issue', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: ['tag1'],
+                actualValue: ['tag2'],
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            const issue = Issue.propertyMismatch({
+                resourceType: 'AWS::EC2::VPC',
+                resourceId: 'vpc-123',
+                mismatch,
+            });
+
+            expect(issue.type).toBe('PROPERTY_MISMATCH');
+            expect(issue.severity).toBe('warning'); // Default for mutable
+            expect(issue.propertyMismatch).toBe(mismatch);
+        });
+
+        it('should create property mismatch with critical severity for immutable', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.BucketName',
+                expectedValue: 'bucket-v2',
+                actualValue: 'bucket-v1',
+                mutability: PropertyMutability.IMMUTABLE,
+            });
+
+            const issue = Issue.propertyMismatch({
+                resourceType: 'AWS::S3::Bucket',
+                resourceId: 'my-bucket',
+                mismatch,
+            });
+
+            expect(issue.severity).toBe('critical'); // Critical for immutable
+            expect(issue.canAutoFix).toBe(false); // Can't auto-fix immutable
+        });
+    });
+
+    describe('_formatValue', () => {
+        it('should format primitive values', () => {
+            expect(Issue._formatValue('test')).toBe('test');
+            expect(Issue._formatValue(123)).toBe('123');
+            expect(Issue._formatValue(true)).toBe('true');
+            expect(Issue._formatValue(null)).toBe('null');
+            expect(Issue._formatValue(undefined)).toBe('undefined');
+        });
+
+        it('should format simple arrays', () => {
+            expect(Issue._formatValue(['a', 'b', 'c'])).toBe('["a","b","c"]');
+            expect(Issue._formatValue([1, 2, 3])).toBe('[1,2,3]');
+        });
+
+        it('should format arrays of objects (like Tags)', () => {
+            const tags = [
+                { Key: 'Name', Value: 'test' },
+                { Key: 'Environment', Value: 'prod' },
+            ];
+            const result = Issue._formatValue(tags);
+            expect(result).toContain('Key');
+            expect(result).toContain('Name');
+            expect(result).toContain('test');
+        });
+
+        it('should truncate long arrays of objects', () => {
+            const manyTags = [
+                { Key: 'Tag1', Value: 'val1' },
+                { Key: 'Tag2', Value: 'val2' },
+                { Key: 'Tag3', Value: 'val3' },
+                { Key: 'Tag4', Value: 'val4' },
+            ];
+            const result = Issue._formatValue(manyTags);
+            expect(result).toContain('4 total');
+            expect(result).toContain('...');
+        });
+
+        it('should format small objects', () => {
+            const obj = { a: 1, b: 2 };
+            expect(Issue._formatValue(obj)).toBe('{"a":1,"b":2}');
+        });
+
+        it('should truncate large objects', () => {
+            const largeObj = { a: 1, b: 2, c: 3, d: 4, e: 5 };
+            const result = Issue._formatValue(largeObj);
+            expect(result).toContain('5 keys total');
+            expect(result).toContain('...');
+        });
+
+        it('should format empty collections', () => {
+            expect(Issue._formatValue([])).toBe('[]');
+            expect(Issue._formatValue({})).toBe('{}');
+        });
+    });
+
+    describe('propertyMismatch with formatted values', () => {
+        it('should format Tags arrays correctly in description', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.Tags',
+                expectedValue: [
+                    { Key: 'Name', Value: 'test' },
+                    { Key: 'Environment', Value: 'prod' },
+                ],
+                actualValue: [
+                    { Key: 'Name', Value: 'test' },
+                    { Key: 'Environment', Value: 'prod' },
+                    { Key: 'ManagedBy', Value: 'Frigg' },
+                ],
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            const issue = Issue.propertyMismatch({
+                resourceType: 'AWS::EC2::Subnet',
+                resourceId: 'subnet-123',
+                mismatch,
+            });
+
+            // Should not contain [object Object]
+            expect(issue.description).not.toContain('[object Object]');
+            // Should contain JSON representation
+            expect(issue.description).toContain('Key');
+            expect(issue.description).toContain('Name');
+        });
+
+        it('should handle complex nested objects', () => {
+            const mismatch = new PropertyMismatch({
+                propertyPath: 'Properties.VpcConfig',
+                expectedValue: {
+                    SubnetIds: ['subnet-1', 'subnet-2'],
+                    SecurityGroupIds: ['sg-1'],
+                },
+                actualValue: {
+                    SubnetIds: ['subnet-3', 'subnet-4'],
+                    SecurityGroupIds: ['sg-2'],
+                },
+                mutability: PropertyMutability.MUTABLE,
+            });
+
+            const issue = Issue.propertyMismatch({
+                resourceType: 'AWS::Lambda::Function',
+                resourceId: 'my-function',
+                mismatch,
+            });
+
+            // Should not contain [object Object]
+            expect(issue.description).not.toContain('[object Object]');
+            // Should contain structured representation
+            expect(issue.description).toContain('SubnetIds');
+        });
+    });
+});

package/infrastructure/domains/health/domain/entities/property-mismatch.js

@@ -0,0 +1,108 @@
+/**
+ * PropertyMismatch Entity
+ *
+ * Represents a difference between expected and actual property values
+ * for a CloudFormation resource.
+ */
+
+const PropertyMutability = require('../value-objects/property-mutability');
+
+class PropertyMismatch {
+    /**
+     * Create a new PropertyMismatch
+     *
+     * @param {Object} params
+     * @param {string} params.propertyPath - Path to the property (e.g., 'Properties.BucketName')
+     * @param {*} params.expectedValue - Expected property value
+     * @param {*} params.actualValue - Actual property value
+     * @param {PropertyMutability} params.mutability - Property mutability
+     */
+    constructor({ propertyPath, expectedValue, actualValue, mutability }) {
+        // Validate required fields
+        if (!propertyPath) {
+            throw new Error('propertyPath is required');
+        }
+
+        // Note: expectedValue and actualValue can be undefined (for missing properties)
+        // They can also be null (explicit null value)
+        // Only check if they're provided in the params object at all
+        if (!('expectedValue' in arguments[0])) {
+            throw new Error('expectedValue must be provided (can be null or undefined)');
+        }
+
+        if (!('actualValue' in arguments[0])) {
+            throw new Error('actualValue must be provided (can be null or undefined)');
+        }
+
+        if (!mutability) {
+            throw new Error('mutability is required');
+        }
+
+        if (!(mutability instanceof PropertyMutability)) {
+            throw new Error('mutability must be a PropertyMutability instance');
+        }
+
+        this.propertyPath = propertyPath;
+        this.expectedValue = expectedValue;
+        this.actualValue = actualValue;
+        this.mutability = mutability;
+    }
+
+    /**
+     * Check if fixing this mismatch requires resource replacement
+     *
+     * @returns {boolean}
+     */
+    requiresReplacement() {
+        return this.mutability.requiresReplacement();
+    }
+
+    /**
+     * Check if this mismatch can be automatically fixed
+     *
+     * @returns {boolean}
+     */
+    canAutoFix() {
+        return this.mutability.canChange();
+    }
+
+    /**
+     * Get severity level of this mismatch
+     *
+     * @returns {'critical' | 'warning'}
+     */
+    getSeverity() {
+        return this.mutability.isImmutable() ? 'critical' : 'warning';
+    }
+
+    /**
+     * Get string representation
+     *
+     * @returns {string}
+     */
+    toString() {
+        const expectedStr = this.expectedValue === null ? 'null' : this.expectedValue;
+        const actualStr = this.actualValue === null ? 'null' : this.actualValue;
+
+        return `PropertyMismatch: ${this.propertyPath} (expected: ${expectedStr}, actual: ${actualStr}, mutability: ${this.mutability.toString()})`;
+    }
+
+    /**
+     * Serialize to JSON
+     *
+     * @returns {Object}
+     */
+    toJSON() {
+        return {
+            propertyPath: this.propertyPath,
+            expectedValue: this.expectedValue,
+            actualValue: this.actualValue,
+            mutability: this.mutability.toString(),
+            severity: this.getSeverity(),
+            canAutoFix: this.canAutoFix(),
+            requiresReplacement: this.requiresReplacement(),
+        };
+    }
+}
+
+module.exports = PropertyMismatch;