cdk-cost-analyzer 0.1.1

package/.kiro/specs/nlb-calculator-test-coverage/requirements.md

@@ -0,0 +1,84 @@
+# Requirements Document
+
+## Introduction
+
+The NLBCalculator class currently has very low test coverage (15.82% statements, 40% functions) with most functionality untested. This feature will implement comprehensive test coverage to ensure the Network Load Balancer cost calculation logic is reliable and maintainable.
+
+## Glossary
+
+- **NLBCalculator**: The class responsible for calculating AWS Network Load Balancer costs
+- **NLCU**: Network Load Balancer Capacity Units - AWS pricing metric for NLB usage
+- **PricingClient**: Interface for fetching AWS pricing data
+- **MonthlyCost**: Data structure containing cost amount, currency, confidence level, and assumptions
+- **ResourceWithId**: CDK resource representation with properties and metadata
+
+## Requirements
+
+### Requirement 1: Core Functionality Testing
+
+**User Story:** As a developer, I want comprehensive tests for the NLBCalculator core methods, so that I can trust the cost calculations are accurate.
+
+#### Acceptance Criteria
+
+1. WHEN the supports method is called with "AWS::ElasticLoadBalancingV2::LoadBalancer", THE NLBCalculator SHALL return true
+2. WHEN the supports method is called with any other resource type, THE NLBCalculator SHALL return false
+3. WHEN calculateCost is called with a network load balancer resource, THE NLBCalculator SHALL return a valid MonthlyCost object
+4. WHEN calculateCost is called with a non-network load balancer resource, THE NLBCalculator SHALL return zero cost with appropriate assumptions
+
+### Requirement 2: NLCU Calculation Testing
+
+**User Story:** As a developer, I want to verify NLCU calculations are correct, so that cost estimates reflect actual AWS billing logic.
+
+#### Acceptance Criteria
+
+1. WHEN calculating NLCU from new connections per second, THE NLBCalculator SHALL divide by 800 to get NLCU consumption
+2. WHEN calculating NLCU from active connections per minute, THE NLBCalculator SHALL divide by 100,000 to get NLCU consumption  
+3. WHEN calculating NLCU from processed bytes, THE NLBCalculator SHALL convert monthly GB to hourly GB for NLCU calculation
+4. WHEN multiple NLCU calculations are performed, THE NLBCalculator SHALL use the highest value for billing
+5. WHEN custom usage parameters are provided, THE NLBCalculator SHALL use those instead of defaults
+
+### Requirement 3: Region Handling Testing
+
+**User Story:** As a developer, I want to ensure region normalization works correctly, so that pricing lookups succeed for all supported regions.
+
+#### Acceptance Criteria
+
+1. WHEN normalizeRegion is called with a supported AWS region code, THE NLBCalculator SHALL return the corresponding AWS pricing region name
+2. WHEN normalizeRegion is called with an unsupported region, THE NLBCalculator SHALL return the original region string
+3. WHEN getRegionPrefix is called with a supported AWS region code, THE NLBCalculator SHALL return the correct pricing prefix
+4. WHEN getRegionPrefix is called with an unsupported region, THE NLBCalculator SHALL return an empty string
+
+### Requirement 4: Error Handling Testing
+
+**User Story:** As a developer, I want to verify error scenarios are handled gracefully, so that the application doesn't crash when pricing data is unavailable.
+
+#### Acceptance Criteria
+
+1. WHEN pricing client returns null for hourly rate, THE NLBCalculator SHALL return zero cost with appropriate assumptions
+2. WHEN pricing client returns null for NLCU rate, THE NLBCalculator SHALL return zero cost with appropriate assumptions
+3. WHEN pricing client throws an exception, THE NLBCalculator SHALL return zero cost with error message in assumptions
+4. WHEN both pricing calls succeed, THE NLBCalculator SHALL return calculated cost with detailed assumptions
+
+### Requirement 5: Default Values Testing
+
+**User Story:** As a developer, I want to verify default usage parameters are applied correctly, so that cost calculations work without custom configuration.
+
+#### Acceptance Criteria
+
+1. WHEN no custom parameters are provided, THE NLBCalculator SHALL use 25 new connections per second
+2. WHEN no custom parameters are provided, THE NLBCalculator SHALL use 3000 active connections per minute
+3. WHEN no custom parameters are provided, THE NLBCalculator SHALL use 100 GB processed bytes per month
+4. WHEN custom parameters are provided, THE NLBCalculator SHALL override the corresponding defaults
+5. THE NLBCalculator SHALL use 730 hours per month for all time-based calculations
+
+### Requirement 6: Cost Calculation Accuracy Testing
+
+**User Story:** As a developer, I want to verify the final cost calculation combines all components correctly, so that users get accurate monthly cost estimates.
+
+#### Acceptance Criteria
+
+1. WHEN calculating total cost, THE NLBCalculator SHALL add hourly cost and NLCU cost
+2. WHEN calculating hourly cost, THE NLBCalculator SHALL multiply hourly rate by 730 hours
+3. WHEN calculating NLCU cost, THE NLBCalculator SHALL multiply NLCU rate by NLCU per hour by 730 hours
+4. WHEN returning cost results, THE NLBCalculator SHALL include detailed breakdown in assumptions
+5. WHEN calculations succeed, THE NLBCalculator SHALL set confidence level to "medium"

package/.kiro/specs/nlb-calculator-test-coverage/tasks.md

@@ -0,0 +1,150 @@
+# Implementation Plan: NLBCalculator Test Coverage Enhancement
+
+## Overview
+
+This implementation plan will create comprehensive test coverage for the NLBCalculator class, improving coverage from 15.82% to over 90% through unit tests and property-based tests.
+
+## Tasks
+
+- [ ] 1. Set up test infrastructure and dependencies
+  - Install fast-check for property-based testing if not already available
+  - Create test directory structure for NLBCalculator tests
+  - Set up TypeScript configuration for test files
+  - _Requirements: All requirements (foundation for testing)_
+
+- [ ] 2. Create test utilities and mocks
+  - [ ] 2.1 Implement MockPricingClient test double
+    - Create mock implementation of PricingClient interface
+    - Add methods to configure pricing responses and errors
+    - _Requirements: 4.1, 4.2, 4.3_
+
+  - [ ] 2.2 Create test resource factory
+    - Implement factory methods for creating test resources
+    - Support network load balancer, application load balancer, and generic resources
+    - _Requirements: 1.1, 1.2, 1.3, 1.4_
+
+  - [ ] 2.3 Create test data generators
+    - Implement generators for usage parameters, regions, and pricing data
+    - Support both valid and edge case scenarios
+    - _Requirements: 2.1, 2.2, 2.3, 2.4, 2.5_
+
+- [ ] 3. Implement basic method tests
+  - [ ] 3.1 Test supports method functionality
+    - Test with AWS::ElasticLoadBalancingV2::LoadBalancer resource type
+    - Test with various other resource types
+    - _Requirements: 1.1, 1.2_
+
+  - [ ] 3.2 Write property test for supports method
+    - **Property 1: Resource Type Rejection**
+    - **Validates: Requirements 1.2**
+
+  - [ ] 3.3 Test region normalization methods
+    - Test normalizeRegion with supported and unsupported regions
+    - Test getRegionPrefix with supported and unsupported regions
+    - _Requirements: 3.1, 3.2, 3.3, 3.4_
+
+  - [ ] 3.4 Write property tests for region methods
+    - **Property 9: Unsupported Region Passthrough**
+    - **Property 10: Unsupported Region Empty Prefix**
+    - **Validates: Requirements 3.2, 3.4**
+
+- [ ] 4. Implement NLCU calculation tests
+  - [ ] 4.1 Test individual NLCU calculations
+    - Test new connections per second calculation
+    - Test active connections per minute calculation
+    - Test processed bytes calculation
+    - _Requirements: 2.1, 2.2, 2.3_
+
+  - [ ] 4.2 Write property tests for NLCU calculations
+    - **Property 4: New Connections NLCU Calculation**
+    - **Property 5: Active Connections NLCU Calculation**
+    - **Property 6: Processed Bytes NLCU Calculation**
+    - **Validates: Requirements 2.1, 2.2, 2.3**
+
+  - [ ] 4.3 Test maximum NLCU selection logic
+    - Test with various combinations of NLCU values
+    - Verify highest value is always selected
+    - _Requirements: 2.4_
+
+  - [ ] 4.4 Write property test for maximum NLCU selection
+    - **Property 7: Maximum NLCU Selection**
+    - **Validates: Requirements 2.4**
+
+- [ ] 5. Checkpoint - Ensure basic functionality tests pass
+  - Ensure all tests pass, ask the user if questions arise.
+
+- [ ] 6. Implement cost calculation tests
+  - [ ] 6.1 Test default parameter usage
+    - Test constructor with no custom parameters
+    - Verify default values are used in calculations
+    - _Requirements: 5.1, 5.2, 5.3, 5.5_
+
+  - [ ] 6.2 Test custom parameter override
+    - Test constructor with custom parameters
+    - Verify custom values override defaults
+    - _Requirements: 5.4_
+
+  - [ ] 6.3 Write property test for custom parameter override
+    - **Property 8: Custom Parameter Override**
+    - **Validates: Requirements 2.5, 5.4**
+
+  - [ ] 6.4 Test cost calculation mathematics
+    - Test hourly cost calculation (rate × 730)
+    - Test NLCU cost calculation (rate × NLCU × 730)
+    - Test total cost addition
+    - _Requirements: 6.1, 6.2, 6.3_
+
+  - [ ] 6.5 Write property tests for cost calculations
+    - **Property 13: Cost Addition**
+    - **Property 14: Hourly Cost Calculation**
+    - **Property 15: NLCU Cost Calculation**
+    - **Validates: Requirements 6.1, 6.2, 6.3**
+
+- [ ] 7. Implement error handling tests
+  - [ ] 7.1 Test null pricing responses
+    - Test when hourly rate is null
+    - Test when NLCU rate is null
+    - Verify zero cost and appropriate assumptions
+    - _Requirements: 4.1, 4.2_
+
+  - [ ] 7.2 Test pricing client exceptions
+    - Test various exception types
+    - Verify graceful error handling
+    - _Requirements: 4.3_
+
+  - [ ] 7.3 Write property test for exception handling
+    - **Property 11: Exception Handling**
+    - **Validates: Requirements 4.3**
+
+- [ ] 8. Implement comprehensive integration tests
+  - [ ] 8.1 Test successful cost calculation flow
+    - Test end-to-end calculation with valid data
+    - Verify MonthlyCost structure and assumptions
+    - _Requirements: 1.3, 4.4, 6.4, 6.5_
+
+  - [ ] 8.2 Write property tests for successful calculations
+    - **Property 2: Valid MonthlyCost Structure**
+    - **Property 12: Successful Calculation Structure**
+    - **Validates: Requirements 1.3, 4.4, 6.4**
+
+  - [ ] 8.3 Test non-network load balancer handling
+    - Test with application load balancer
+    - Test with resources missing Type property
+    - Verify zero cost response
+    - _Requirements: 1.4_
+
+  - [ ] 8.4 Write property test for non-NLB resources
+    - **Property 3: Non-NLB Resource Zero Cost**
+    - **Validates: Requirements 1.4**
+
+- [ ] 9. Final checkpoint and coverage verification
+  - Run test coverage analysis
+  - Verify coverage exceeds 90% for statements, branches, and functions
+  - Ensure all tests pass, ask the user if questions arise.
+
+## Notes
+
+- Each task references specific requirements for traceability
+- Property tests validate universal correctness properties using fast-check
+- Unit tests validate specific examples and edge cases
+- Both testing approaches are complementary and necessary for comprehensive coverage