@friggframework/devtools 2.0.0--canary.474.27d9425.0 → 2.0.0--canary.474.97bfcf0.0

package/infrastructure/domains/health/domain/value-objects/health-score.test.js

@@ -0,0 +1,267 @@
+/**
+ * Tests for HealthScore Value Object
+ */
+
+const HealthScore = require('./health-score');
+
+describe('HealthScore', () => {
+    describe('constructor', () => {
+        it('should create health score with valid value', () => {
+            const score = new HealthScore(75);
+
+            expect(score.value).toBe(75);
+        });
+
+        it('should accept 0 as minimum score', () => {
+            const score = new HealthScore(0);
+
+            expect(score.value).toBe(0);
+        });
+
+        it('should accept 100 as maximum score', () => {
+            const score = new HealthScore(100);
+
+            expect(score.value).toBe(100);
+        });
+
+        it('should reject negative scores', () => {
+            expect(() => {
+                new HealthScore(-1);
+            }).toThrow('Health score must be between 0 and 100');
+        });
+
+        it('should reject scores above 100', () => {
+            expect(() => {
+                new HealthScore(101);
+            }).toThrow('Health score must be between 0 and 100');
+        });
+
+        it('should reject non-numeric scores', () => {
+            expect(() => {
+                new HealthScore('75');
+            }).toThrow('Health score must be a number');
+        });
+
+        it('should reject NaN', () => {
+            expect(() => {
+                new HealthScore(NaN);
+            }).toThrow('Health score must be a number');
+        });
+
+        it('should reject Infinity', () => {
+            expect(() => {
+                new HealthScore(Infinity);
+            }).toThrow('Health score must be a number');
+        });
+    });
+
+    describe('qualitativeAssessment', () => {
+        it('should return "healthy" for score 100', () => {
+            const score = new HealthScore(100);
+
+            expect(score.qualitativeAssessment()).toBe('healthy');
+        });
+
+        it('should return "healthy" for score 90', () => {
+            const score = new HealthScore(90);
+
+            expect(score.qualitativeAssessment()).toBe('healthy');
+        });
+
+        it('should return "healthy" for score 80', () => {
+            const score = new HealthScore(80);
+
+            expect(score.qualitativeAssessment()).toBe('healthy');
+        });
+
+        it('should return "degraded" for score 79', () => {
+            const score = new HealthScore(79);
+
+            expect(score.qualitativeAssessment()).toBe('degraded');
+        });
+
+        it('should return "degraded" for score 50', () => {
+            const score = new HealthScore(50);
+
+            expect(score.qualitativeAssessment()).toBe('degraded');
+        });
+
+        it('should return "degraded" for score 40', () => {
+            const score = new HealthScore(40);
+
+            expect(score.qualitativeAssessment()).toBe('degraded');
+        });
+
+        it('should return "unhealthy" for score 39', () => {
+            const score = new HealthScore(39);
+
+            expect(score.qualitativeAssessment()).toBe('unhealthy');
+        });
+
+        it('should return "unhealthy" for score 0', () => {
+            const score = new HealthScore(0);
+
+            expect(score.qualitativeAssessment()).toBe('unhealthy');
+        });
+    });
+
+    describe('isHealthy', () => {
+        it('should return true for score 80', () => {
+            const score = new HealthScore(80);
+
+            expect(score.isHealthy()).toBe(true);
+        });
+
+        it('should return true for score 100', () => {
+            const score = new HealthScore(100);
+
+            expect(score.isHealthy()).toBe(true);
+        });
+
+        it('should return false for score 79', () => {
+            const score = new HealthScore(79);
+
+            expect(score.isHealthy()).toBe(false);
+        });
+
+        it('should return false for score 0', () => {
+            const score = new HealthScore(0);
+
+            expect(score.isHealthy()).toBe(false);
+        });
+    });
+
+    describe('isDegraded', () => {
+        it('should return true for score 79', () => {
+            const score = new HealthScore(79);
+
+            expect(score.isDegraded()).toBe(true);
+        });
+
+        it('should return true for score 40', () => {
+            const score = new HealthScore(40);
+
+            expect(score.isDegraded()).toBe(true);
+        });
+
+        it('should return false for score 80', () => {
+            const score = new HealthScore(80);
+
+            expect(score.isDegraded()).toBe(false);
+        });
+
+        it('should return false for score 39', () => {
+            const score = new HealthScore(39);
+
+            expect(score.isDegraded()).toBe(false);
+        });
+    });
+
+    describe('isUnhealthy', () => {
+        it('should return true for score 39', () => {
+            const score = new HealthScore(39);
+
+            expect(score.isUnhealthy()).toBe(true);
+        });
+
+        it('should return true for score 0', () => {
+            const score = new HealthScore(0);
+
+            expect(score.isUnhealthy()).toBe(true);
+        });
+
+        it('should return false for score 40', () => {
+            const score = new HealthScore(40);
+
+            expect(score.isUnhealthy()).toBe(false);
+        });
+
+        it('should return false for score 80', () => {
+            const score = new HealthScore(80);
+
+            expect(score.isUnhealthy()).toBe(false);
+        });
+    });
+
+    describe('toString', () => {
+        it('should return string representation for healthy score', () => {
+            const score = new HealthScore(100);
+
+            expect(score.toString()).toBe('100 (healthy)');
+        });
+
+        it('should return string representation for degraded score', () => {
+            const score = new HealthScore(50);
+
+            expect(score.toString()).toBe('50 (degraded)');
+        });
+
+        it('should return string representation for unhealthy score', () => {
+            const score = new HealthScore(25);
+
+            expect(score.toString()).toBe('25 (unhealthy)');
+        });
+    });
+
+    describe('static factory methods', () => {
+        it('should create perfect score', () => {
+            const score = HealthScore.perfect();
+
+            expect(score.value).toBe(100);
+            expect(score.isHealthy()).toBe(true);
+        });
+
+        it('should create failed score', () => {
+            const score = HealthScore.failed();
+
+            expect(score.value).toBe(0);
+            expect(score.isUnhealthy()).toBe(true);
+        });
+
+        it('should create from percentage (1.0 = 100)', () => {
+            const score = HealthScore.fromPercentage(0.75);
+
+            expect(score.value).toBe(75);
+        });
+
+        it('should create from percentage (0.0 = 0)', () => {
+            const score = HealthScore.fromPercentage(0);
+
+            expect(score.value).toBe(0);
+        });
+
+        it('should create from percentage (1.0 = 100)', () => {
+            const score = HealthScore.fromPercentage(1.0);
+
+            expect(score.value).toBe(100);
+        });
+
+        it('should reject percentage below 0', () => {
+            expect(() => {
+                HealthScore.fromPercentage(-0.1);
+            }).toThrow('Percentage must be between 0 and 1');
+        });
+
+        it('should reject percentage above 1', () => {
+            expect(() => {
+                HealthScore.fromPercentage(1.1);
+            }).toThrow('Percentage must be between 0 and 1');
+        });
+    });
+
+    describe('immutability', () => {
+        it('should not allow modification of value', () => {
+            const score = new HealthScore(75);
+
+            expect(() => {
+                score.value = 50;
+            }).toThrow();
+        });
+
+        it('should be frozen', () => {
+            const score = new HealthScore(75);
+
+            expect(Object.isFrozen(score)).toBe(true);
+        });
+    });
+});

package/infrastructure/domains/health/domain/value-objects/property-mutability.js

@@ -0,0 +1,161 @@
+/**
+ * PropertyMutability Value Object
+ *
+ * Enum-like immutable mutability classification for CloudFormation resource properties
+ *
+ * Types:
+ * - MUTABLE: Property can be changed without replacing the resource (Update requires: No interruption)
+ * - IMMUTABLE: Property cannot be changed - requires resource replacement (Update requires: Replacement)
+ * - CONDITIONAL: Property mutability depends on other properties or conditions (Update requires: Some interruptions)
+ */
+
+class PropertyMutability {
+    /**
+     * Valid mutability types
+     * @type {string[]}
+     */
+    static VALID_TYPES = [
+        'MUTABLE',
+        'IMMUTABLE',
+        'CONDITIONAL',
+    ];
+
+    /**
+     * Create a new PropertyMutability
+     *
+     * @param {string} value - Mutability type
+     */
+    constructor(value) {
+        if (value === undefined || value === null) {
+            throw new Error('Property mutability is required');
+        }
+
+        if (!PropertyMutability.VALID_TYPES.includes(value)) {
+            throw new Error(`Invalid property mutability: ${value}`);
+        }
+
+        this._value = value;
+
+        // Make immutable
+        Object.freeze(this);
+    }
+
+    /**
+     * Get mutability value
+     * @returns {string}
+     */
+    get value() {
+        return this._value;
+    }
+
+    /**
+     * Prevent modification of value
+     * @throws {TypeError}
+     */
+    set value(newValue) {
+        throw new TypeError('Cannot modify immutable property value');
+    }
+
+    /**
+     * Check if property is mutable
+     * @returns {boolean}
+     */
+    isMutable() {
+        return this._value === 'MUTABLE';
+    }
+
+    /**
+     * Check if property is immutable
+     * @returns {boolean}
+     */
+    isImmutable() {
+        return this._value === 'IMMUTABLE';
+    }
+
+    /**
+     * Check if property mutability is conditional
+     * @returns {boolean}
+     */
+    isConditional() {
+        return this._value === 'CONDITIONAL';
+    }
+
+    /**
+     * Check if property can be changed
+     * @returns {boolean}
+     */
+    canChange() {
+        return this._value === 'MUTABLE';
+    }
+
+    /**
+     * Check if changing property requires resource replacement
+     * @returns {boolean}
+     */
+    requiresReplacement() {
+        return this._value === 'IMMUTABLE';
+    }
+
+    /**
+     * Get description of mutability type
+     * @returns {string}
+     */
+    getDescription() {
+        const descriptions = {
+            MUTABLE: 'Property can be changed without replacing the resource',
+            IMMUTABLE: 'Property cannot be changed - requires resource replacement',
+            CONDITIONAL: 'Property mutability depends on other property values or conditions',
+        };
+
+        return descriptions[this._value];
+    }
+
+    /**
+     * Check equality with another PropertyMutability
+     *
+     * @param {PropertyMutability} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (!(other instanceof PropertyMutability)) {
+            return false;
+        }
+
+        return this._value === other._value;
+    }
+
+    /**
+     * Get string representation
+     *
+     * @returns {string}
+     */
+    toString() {
+        return this._value;
+    }
+
+    /**
+     * Predefined mutability: MUTABLE
+     * @type {PropertyMutability}
+     */
+    static get MUTABLE() {
+        return new PropertyMutability('MUTABLE');
+    }
+
+    /**
+     * Predefined mutability: IMMUTABLE
+     * @type {PropertyMutability}
+     */
+    static get IMMUTABLE() {
+        return new PropertyMutability('IMMUTABLE');
+    }
+
+    /**
+     * Predefined mutability: CONDITIONAL
+     * @type {PropertyMutability}
+     */
+    static get CONDITIONAL() {
+        return new PropertyMutability('CONDITIONAL');
+    }
+}
+
+module.exports = PropertyMutability;

package/infrastructure/domains/health/domain/value-objects/property-mutability.test.js

@@ -0,0 +1,198 @@
+/**
+ * Tests for PropertyMutability Value Object
+ */
+
+const PropertyMutability = require('./property-mutability');
+
+describe('PropertyMutability', () => {
+    describe('valid mutability types', () => {
+        it('should accept MUTABLE', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(mutability.value).toBe('MUTABLE');
+        });
+
+        it('should accept IMMUTABLE', () => {
+            const mutability = new PropertyMutability('IMMUTABLE');
+
+            expect(mutability.value).toBe('IMMUTABLE');
+        });
+
+        it('should accept CONDITIONAL', () => {
+            const mutability = new PropertyMutability('CONDITIONAL');
+
+            expect(mutability.value).toBe('CONDITIONAL');
+        });
+    });
+
+    describe('invalid mutability types', () => {
+        it('should reject invalid mutability', () => {
+            expect(() => {
+                new PropertyMutability('INVALID');
+            }).toThrow('Invalid property mutability: INVALID');
+        });
+
+        it('should reject lowercase mutability', () => {
+            expect(() => {
+                new PropertyMutability('mutable');
+            }).toThrow('Invalid property mutability: mutable');
+        });
+
+        it('should reject null', () => {
+            expect(() => {
+                new PropertyMutability(null);
+            }).toThrow('Property mutability is required');
+        });
+
+        it('should reject undefined', () => {
+            expect(() => {
+                new PropertyMutability(undefined);
+            }).toThrow('Property mutability is required');
+        });
+    });
+
+    describe('mutability checks', () => {
+        it('should check if property is mutable', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(mutability.isMutable()).toBe(true);
+            expect(mutability.isImmutable()).toBe(false);
+            expect(mutability.isConditional()).toBe(false);
+        });
+
+        it('should check if property is immutable', () => {
+            const mutability = new PropertyMutability('IMMUTABLE');
+
+            expect(mutability.isMutable()).toBe(false);
+            expect(mutability.isImmutable()).toBe(true);
+            expect(mutability.isConditional()).toBe(false);
+        });
+
+        it('should check if property is conditionally mutable', () => {
+            const mutability = new PropertyMutability('CONDITIONAL');
+
+            expect(mutability.isMutable()).toBe(false);
+            expect(mutability.isImmutable()).toBe(false);
+            expect(mutability.isConditional()).toBe(true);
+        });
+    });
+
+    describe('changeability checks', () => {
+        it('should allow changes for mutable properties', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(mutability.canChange()).toBe(true);
+            expect(mutability.requiresReplacement()).toBe(false);
+        });
+
+        it('should not allow changes for immutable properties', () => {
+            const mutability = new PropertyMutability('IMMUTABLE');
+
+            expect(mutability.canChange()).toBe(false);
+            expect(mutability.requiresReplacement()).toBe(true);
+        });
+
+        it('should conditionally allow changes', () => {
+            const mutability = new PropertyMutability('CONDITIONAL');
+
+            // Conditional means it depends on other factors
+            expect(mutability.canChange()).toBe(false); // Can't change without conditions met
+            expect(mutability.requiresReplacement()).toBe(false); // Doesn't always require replacement
+        });
+    });
+
+    describe('equality', () => {
+        it('should be equal to same mutability', () => {
+            const m1 = new PropertyMutability('MUTABLE');
+            const m2 = new PropertyMutability('MUTABLE');
+
+            expect(m1.equals(m2)).toBe(true);
+        });
+
+        it('should not be equal to different mutability', () => {
+            const m1 = new PropertyMutability('MUTABLE');
+            const m2 = new PropertyMutability('IMMUTABLE');
+
+            expect(m1.equals(m2)).toBe(false);
+        });
+
+        it('should not be equal to non-PropertyMutability', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(mutability.equals('MUTABLE')).toBe(false);
+            expect(mutability.equals(null)).toBe(false);
+        });
+    });
+
+    describe('toString', () => {
+        it('should return string representation', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(mutability.toString()).toBe('MUTABLE');
+        });
+    });
+
+    describe('static constants', () => {
+        it('should provide MUTABLE constant', () => {
+            expect(PropertyMutability.MUTABLE.value).toBe('MUTABLE');
+        });
+
+        it('should provide IMMUTABLE constant', () => {
+            expect(PropertyMutability.IMMUTABLE.value).toBe('IMMUTABLE');
+        });
+
+        it('should provide CONDITIONAL constant', () => {
+            expect(PropertyMutability.CONDITIONAL.value).toBe('CONDITIONAL');
+        });
+
+        it('should provide VALID_TYPES array', () => {
+            expect(PropertyMutability.VALID_TYPES).toEqual([
+                'MUTABLE',
+                'IMMUTABLE',
+                'CONDITIONAL',
+            ]);
+        });
+    });
+
+    describe('immutability', () => {
+        it('should not allow modification of value', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(() => {
+                mutability.value = 'IMMUTABLE';
+            }).toThrow();
+        });
+
+        it('should be frozen', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(Object.isFrozen(mutability)).toBe(true);
+        });
+    });
+
+    describe('description', () => {
+        it('should provide description for MUTABLE', () => {
+            const mutability = new PropertyMutability('MUTABLE');
+
+            expect(mutability.getDescription()).toBe(
+                'Property can be changed without replacing the resource'
+            );
+        });
+
+        it('should provide description for IMMUTABLE', () => {
+            const mutability = new PropertyMutability('IMMUTABLE');
+
+            expect(mutability.getDescription()).toBe(
+                'Property cannot be changed - requires resource replacement'
+            );
+        });
+
+        it('should provide description for CONDITIONAL', () => {
+            const mutability = new PropertyMutability('CONDITIONAL');
+
+            expect(mutability.getDescription()).toBe(
+                'Property mutability depends on other property values or conditions'
+            );
+        });
+    });
+});