@chimoney.io/iaas-k8s-deployment/dist/src/tests/helm-parameter-coverage.test.js

Kubernetes Infrastructure as a Service deployment package for streamlined multi-cloud environments

import { generateDynamicHelmValues } from "../core/helm/helm-values-generator.js";
import { PlanTier } from "../types/plans.js";
const mockLogger = {
    info: jest.fn(),
    warn: jest.fn(),
    error: jest.fn(),
    debug: jest.fn(),
};
describe("Helm Parameter Coverage Validation", () => {
    const baseOptions = {
        companyName: "test-company",
        namespace: "test-namespace",
        deploymentType: "shared",
        planTier: PlanTier.STANDARD,
        cloudProvider: "gcp",
        defaultDomain: "example.com",
        environment: "production",
        clusterName: "test-cluster",
        prometheusFqdn: "prometheus.example.com",
        managedCertificateEnabled: true,
        createKubernetesSecrets: true,
        action: "up",
        stackName: "test-stack",
        secretsJson: "{}",
    };
    it("should generate all critical monitoring parameters", () => {
        const helmValues = generateDynamicHelmValues(baseOptions, mockLogger);
        // Phase 1 Critical Parameter Generation Validation
        expect(helmValues.monitoring).toBeDefined();
        expect(helmValues.monitoring?.dashboards?.enabled).toBe(true);
        expect(helmValues.tierConfig).toBeDefined();
        expect(helmValues.tierConfig?.standard?.cpu).toBe("8"); // Standard tier CPU
        expect(helmValues.tierConfig?.standard?.memory).toBe("16Gi"); // Standard tier memory
        expect(helmValues.tierResources).toBeDefined();
        expect(helmValues.tierResources?.cpu).toBe("4000m"); // Standard tier CPU limits
        expect(helmValues.tierResources?.memory).toBe("8Gi"); // Standard tier memory limits
    });
    it("should generate all application service parameters", () => {
        const helmValues = generateDynamicHelmValues(baseOptions, mockLogger);
        // Validate core application services are enabled
        expect(helmValues.rafikiAuth).toBeDefined();
        expect(helmValues.rafikiAuth?.enabled).toBe(true);
        expect(helmValues.rafikiBackend).toBeDefined();
        expect(helmValues.rafikiBackend?.enabled).toBe(true);
        expect(helmValues.nginx).toBeDefined();
        expect(helmValues.nginx?.enabled).toBe(true);
        expect(helmValues.redis).toBeDefined();
        expect(helmValues.redis?.enabled).toBe(true);
    });
    it("should generate tier resource quota configuration", () => {
        const helmValues = generateDynamicHelmValues(baseOptions, mockLogger);
        expect(helmValues.tierResourceQuota).toBeDefined();
        expect(helmValues.tierResourceQuota?.enabled).toBe(true); // shared deployment
        expect(helmValues.tierResourceQuota?.requests?.cpu).toBe("2400m");
        expect(helmValues.tierResourceQuota?.requests?.memory).toBe("5Gi");
        expect(helmValues.tierResourceQuota?.requests?.storage).toBe("30Gi");
        expect(helmValues.tierResourceQuota?.limits?.cpu).toBe("4000m");
        expect(helmValues.tierResourceQuota?.limits?.memory).toBe("8Gi");
        expect(helmValues.tierResourceQuota?.limits?.storage).toBe("40Gi");
        expect(helmValues.tierResourceQuota?.claims?.["persistent-volume-claims"]).toBe("6");
    });
    it("should generate enhanced network policy configuration", () => {
        const helmValues = generateDynamicHelmValues({
            ...baseOptions,
            sharedDeploymentNetworkPolicyEnabled: true,
        }, mockLogger);
        expect(helmValues.networkPolicy).toBeDefined();
        expect(helmValues.networkPolicy?.enabled).toBe(true);
        expect(helmValues.networkPolicy?.allowIngressFrom).toHaveLength(3);
        expect(helmValues.networkPolicy?.allowEgressTo).toHaveLength(1);
        expect(helmValues.networkPolicy?.allowEgressPorts).toHaveLength(5);
    });
    it("should generate cloud-specific configurations for GCP", () => {
        const helmValues = generateDynamicHelmValues(baseOptions, mockLogger);
        expect(helmValues.gcp).toBeDefined();
        expect(helmValues.gcp?.backendConfig?.healthCheck).toEqual({
            checkIntervalSec: 60,
            port: 8080,
            type: "HTTP",
            requestPath: "/health",
        });
        expect(helmValues.gcp?.managedCertificate?.enabled).toBe(true);
        expect(helmValues.gcp?.managedCertificate?.domains).toEqual([
            "example.com",
            "*.example.com",
        ]);
    });
    it("should generate cloud-specific configurations for AWS", () => {
        const awsOptions = { ...baseOptions, cloudProvider: "aws" };
        const helmValues = generateDynamicHelmValues(awsOptions, mockLogger);
        expect(helmValues.aws).toBeDefined();
        expect(helmValues.aws?.loadBalancer?.healthCheck).toEqual({
            enabled: true,
            intervalSeconds: 30,
            path: "/health",
            port: "traffic-port",
            protocol: "HTTP",
            timeoutSeconds: 5,
            unhealthyThresholdCount: 2,
            healthyThresholdCount: 2,
        });
    });
    it("should generate kubernetes secrets configuration", () => {
        const helmValues = generateDynamicHelmValues(baseOptions, mockLogger);
        expect(helmValues.kubernetesSecrets).toBeDefined();
        expect(helmValues.kubernetesSecrets?.rafikiAuth?.create).toBe(true);
        expect(helmValues.kubernetesSecrets?.rafikiAuth?.name).toBe("test-company-rafiki-auth-secret");
        expect(helmValues.kubernetesSecrets?.rafikiBackend?.create).toBe(true);
        expect(helmValues.kubernetesSecrets?.rafikiBackend?.name).toBe("test-company-rafiki-backend-secret");
    });
    it("should handle dedicated deployment configuration", () => {
        const dedicatedOptions = {
            ...baseOptions,
            deploymentType: "dedicated",
        };
        const helmValues = generateDynamicHelmValues(dedicatedOptions, mockLogger);
        // Monitoring should still be enabled for dedicated
        expect(helmValues.monitoring?.dashboards?.enabled).toBe(true);
        // HPA should be enabled for dedicated deployments
        expect(helmValues.rafikiAuth?.hpa?.enabled).toBe(true);
        expect(helmValues.rafikiBackend?.hpa?.enabled).toBe(true);
        expect(helmValues.nginx?.hpa?.enabled).toBe(true);
        // Resource quota should be disabled for dedicated
        expect(helmValues.tierResourceQuota?.enabled).toBe(false);
        // Network policy should be disabled for dedicated
        expect(helmValues.networkPolicy?.enabled).toBe(false);
    });
    it("should validate all template parameters match generated values", () => {
        const helmValues = generateDynamicHelmValues(baseOptions, mockLogger);
        // Validate all critical template parameters are covered
        const criticalParams = [
            "monitoring.dashboards.enabled",
            "tierConfig.standard.cpu",
            "tierResources.cpu",
            "tierResources.memory",
            "tierResourceQuota.enabled",
            "tierResourceQuota.requests.cpu",
            "tierResourceQuota.requests.memory",
            "tierResourceQuota.limits.cpu",
            "tierResourceQuota.limits.memory",
            "gcp.backendConfig.healthCheck",
            "gcp.managedCertificate.enabled",
            "kubernetesSecrets.rafikiAuth.create",
            "kubernetesSecrets.rafikiBackend.create",
            "rafikiAuth.enabled",
            "rafikiBackend.enabled",
            "nginx.enabled",
            "redis.enabled",
        ];
        criticalParams.forEach((param) => {
            const value = param
                .split(".")
                .reduce((obj, key) => obj?.[key], helmValues);
            expect(value).toBeDefined();
        });
    });
    it("should validate tier configuration accuracy", () => {
        // Test all tiers have their configuration
        const tiers = [
            PlanTier.BASIC,
            PlanTier.STANDARD,
            PlanTier.PREMIUM,
            PlanTier.ENTERPRISE,
        ];
        const expectedCpuLimits = ["2", "8", "32", "128"];
        tiers.forEach((tier, index) => {
            const tierOptions = { ...baseOptions, planTier: tier };
            const helmValues = generateDynamicHelmValues(tierOptions, mockLogger);
            // Check that the tier config exists and has expected CPU limits
            expect(helmValues.tierConfig).toBeDefined();
            const tierName = tier.toLowerCase();
            const tierConfig = helmValues.tierConfig?.[tierName];
            expect(tierConfig?.cpu).toBe(expectedCpuLimits[index]);
        });
    });
    it("should validate tier resource limits accuracy", () => {
        const standardOptions = { ...baseOptions, planTier: PlanTier.STANDARD };
        const helmValues = generateDynamicHelmValues(standardOptions, mockLogger);
        // Validate Standard tier specific values
        expect(helmValues.tierResources?.cpu).toBe("4000m"); // Standard tier CPU limits
        expect(helmValues.tierResources?.memory).toBe("8Gi"); // Standard tier memory limits
        expect(helmValues.tierResourceQuota?.requests?.cpu).toBe("2400m"); // Standard tier CPU requests
        expect(helmValues.tierResourceQuota?.requests?.memory).toBe("5Gi"); // Standard tier memory requests
    });
});
//# sourceMappingURL=helm-parameter-coverage.test.js.map