puls-dev 0.3.6 → 0.3.7

package/dist/providers/aws/cloudfront.test.js

@@ -0,0 +1,170 @@
+import { test, describe, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import { CloudFrontClient } from '@aws-sdk/client-cloudfront';
+import { CloudFrontBuilder } from './cloudfront.js';
+import { Config } from '../../core/config.js';
+describe('CloudFrontBuilder Unit Tests', () => {
+    let originalSend;
+    let calls = [];
+    let mockResponses = {};
+    beforeEach(() => {
+        Config.set({ dryRun: false, providers: { aws: { region: 'us-east-1' } } });
+        calls = [];
+        mockResponses = {};
+        originalSend = CloudFrontClient.prototype.send;
+        CloudFrontClient.prototype.send = async function (command) {
+            const commandName = command.constructor.name;
+            calls.push({ commandName, input: command.input });
+            const handler = mockResponses[commandName];
+            if (handler) {
+                if (typeof handler === 'function')
+                    return handler(command.input);
+                if (handler instanceof Error)
+                    throw handler;
+                return handler;
+            }
+            return {};
+        };
+    });
+    afterEach(() => {
+        CloudFrontClient.prototype.send = originalSend;
+    });
+    test('returns null when distribution is not found during discovery', async () => {
+        mockResponses['ListDistributionsCommand'] = { DistributionList: { Items: [] } };
+        const builder = new CloudFrontBuilder('my-cdn');
+        const result = await builder.discoveryPromise;
+        assert.strictEqual(result, null);
+        assert.strictEqual(calls[0].commandName, 'ListDistributionsCommand');
+    });
+    test('discovers existing distribution by comment name', async () => {
+        mockResponses['ListDistributionsCommand'] = {
+            DistributionList: {
+                Items: [
+                    { Comment: 'my-cdn', Id: 'd-abc123', ARN: 'arn:aws:cloudfront::123:distribution/d-abc123' },
+                ],
+            },
+        };
+        const builder = new CloudFrontBuilder('my-cdn');
+        const result = await builder.discoveryPromise;
+        assert.ok(result);
+        assert.strictEqual(result.Comment, 'my-cdn');
+        assert.strictEqual(builder.resolvedId, 'd-abc123');
+        assert.strictEqual(builder.resolvedArn, 'arn:aws:cloudfront::123:distribution/d-abc123');
+    });
+    test('performs dry-run without creating the distribution', async () => {
+        Config.set({ dryRun: true, providers: { aws: { region: 'us-east-1' } } });
+        mockResponses['ListDistributionsCommand'] = { DistributionList: { Items: [] } };
+        const builder = new CloudFrontBuilder('my-cdn');
+        builder.origin('origin.example.com').dns('cdn.example.com');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, 'my-cdn');
+        assert.strictEqual(result.id, 'PENDING');
+        const writeCalls = calls.filter((c) => c.commandName !== 'ListDistributionsCommand');
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test('creates new distribution from scratch when not found', async () => {
+        mockResponses['ListDistributionsCommand'] = { DistributionList: { Items: [] } };
+        mockResponses['CreateDistributionCommand'] = {
+            Distribution: {
+                Id: 'd-new123',
+                ARN: 'arn:aws:cloudfront::123:distribution/d-new123',
+                DomainName: 'abcdef.cloudfront.net',
+                Status: 'Deployed',
+            },
+        };
+        mockResponses['GetDistributionCommand'] = {
+            Distribution: { Status: 'Deployed' },
+        };
+        const builder = new CloudFrontBuilder('my-cdn');
+        builder.origin('origin.example.com');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.id, 'd-new123');
+        const createCall = calls.find((c) => c.commandName === 'CreateDistributionCommand');
+        assert.ok(createCall);
+        assert.strictEqual(createCall.input.DistributionConfig.Comment, 'my-cdn');
+    });
+    test('returns existing distribution without re-creating it', async () => {
+        mockResponses['ListDistributionsCommand'] = {
+            DistributionList: {
+                Items: [{ Comment: 'my-cdn', Id: 'd-abc', ARN: 'arn:aws:cloudfront::123:distribution/d-abc' }],
+            },
+        };
+        const builder = new CloudFrontBuilder('my-cdn');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.id, 'd-abc');
+        assert.ok(!calls.some((c) => c.commandName === 'CreateDistributionCommand'));
+    });
+    test('runs cache invalidation on an existing distribution', async () => {
+        mockResponses['ListDistributionsCommand'] = {
+            DistributionList: {
+                Items: [{ Comment: 'my-cdn', Id: 'd-abc', ARN: 'arn:aws:cloudfront::123:distribution/d-abc' }],
+            },
+        };
+        mockResponses['CreateInvalidationCommand'] = { Invalidation: { Id: 'inv-1' } };
+        const builder = new CloudFrontBuilder('my-cdn');
+        builder.invalidate(['/*', '/index.html']);
+        await builder.deploy();
+        const invCall = calls.find((c) => c.commandName === 'CreateInvalidationCommand');
+        assert.ok(invCall);
+        assert.deepStrictEqual(invCall.input.InvalidationBatch.Paths.Items, ['/*', '/index.html']);
+        assert.strictEqual(invCall.input.InvalidationBatch.Paths.Quantity, 2);
+    });
+    test('dry-run prints invalidation plan without executing it', async () => {
+        Config.set({ dryRun: true, providers: { aws: { region: 'us-east-1' } } });
+        mockResponses['ListDistributionsCommand'] = {
+            DistributionList: {
+                Items: [{ Comment: 'my-cdn', Id: 'd-abc', ARN: 'arn:aws:cloudfront::123:distribution/d-abc' }],
+            },
+        };
+        const builder = new CloudFrontBuilder('my-cdn');
+        builder.invalidate(['/assets/*']);
+        await builder.deploy();
+        assert.ok(!calls.some((c) => c.commandName === 'CreateInvalidationCommand'));
+    });
+    test('clones config from a reference distribution', async () => {
+        mockResponses['ListDistributionsCommand'] = { DistributionList: { Items: [] } };
+        mockResponses['GetDistributionConfigCommand'] = {
+            DistributionConfig: {
+                Comment: 'source-cdn',
+                Enabled: true,
+                Origins: { Quantity: 1, Items: [{ Id: 'orig-1', DomainName: 'source.example.com' }] },
+                DefaultCacheBehavior: {
+                    TargetOriginId: 'orig-1',
+                    ViewerProtocolPolicy: 'redirect-to-https',
+                    CachePolicyId: 'cache-policy-id',
+                    ForwardedValues: { QueryString: false, Cookies: { Forward: 'none' } },
+                    MinTTL: 0,
+                },
+                CallerReference: 'old-ref',
+                PriceClass: 'PriceClass_All',
+                HttpVersion: 'http2',
+            },
+        };
+        mockResponses['CreateDistributionCommand'] = {
+            Distribution: {
+                Id: 'd-cloned',
+                ARN: 'arn:aws:cloudfront::123:distribution/d-cloned',
+                DomainName: 'cloned.cloudfront.net',
+                Status: 'Deployed',
+            },
+        };
+        mockResponses['GetDistributionCommand'] = { Distribution: { Status: 'Deployed' } };
+        const builder = new CloudFrontBuilder('my-cdn');
+        builder.copyFrom('d-source');
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.id, 'd-cloned');
+        const getConfigCall = calls.find((c) => c.commandName === 'GetDistributionConfigCommand');
+        assert.ok(getConfigCall);
+        assert.strictEqual(getConfigCall.input.Id, 'd-source');
+        const createCall = calls.find((c) => c.commandName === 'CreateDistributionCommand');
+        assert.ok(createCall);
+        // CallerReference from the original clone is deleted; puls inserts a fresh one
+        const newRef = createCall.input.DistributionConfig.CallerReference;
+        assert.ok(newRef.startsWith('puls-my-cdn-'));
+        assert.notStrictEqual(newRef, 'old-ref');
+    });
+});

package/dist/providers/aws/fargate.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/providers/aws/fargate.test.js

@@ -0,0 +1,244 @@
+import { test, describe, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import { ECSClient } from "@aws-sdk/client-ecs";
+import { EC2Client } from "@aws-sdk/client-ec2";
+import { IAMClient } from "@aws-sdk/client-iam";
+import { CloudWatchLogsClient } from "@aws-sdk/client-cloudwatch-logs";
+import { FargateBuilder } from "./fargate.js";
+import { Config } from "../../core/config.js";
+describe("FargateBuilder Unit Tests", () => {
+    let originalEcsSend;
+    let originalEc2Send;
+    let originalIamSend;
+    let originalCwSend;
+    let ecsCalls = [];
+    let ec2Calls = [];
+    let iamCalls = [];
+    let cwCalls = [];
+    let mockEcsResponses = {};
+    let mockEc2Responses = {};
+    let mockIamResponses = {};
+    let mockCwResponses = {};
+    function stubSend(calls, responses) {
+        return async function (command) {
+            const commandName = command.constructor.name;
+            calls.push({ commandName, input: command.input });
+            const handler = responses[commandName];
+            if (handler) {
+                if (typeof handler === "function")
+                    return handler(command.input);
+                if (handler instanceof Error)
+                    throw handler;
+                return handler;
+            }
+            return {};
+        };
+    }
+    beforeEach(() => {
+        Config.set({ dryRun: false, providers: { aws: { region: "us-east-1" } } });
+        ecsCalls = [];
+        ec2Calls = [];
+        iamCalls = [];
+        cwCalls = [];
+        mockEcsResponses = {};
+        mockEc2Responses = {};
+        mockIamResponses = {};
+        mockCwResponses = {};
+        originalEcsSend = ECSClient.prototype.send;
+        originalEc2Send = EC2Client.prototype.send;
+        originalIamSend = IAMClient.prototype.send;
+        originalCwSend = CloudWatchLogsClient.prototype.send;
+        ECSClient.prototype.send = stubSend(ecsCalls, mockEcsResponses);
+        EC2Client.prototype.send = stubSend(ec2Calls, mockEc2Responses);
+        IAMClient.prototype.send = stubSend(iamCalls, mockIamResponses);
+        CloudWatchLogsClient.prototype.send = stubSend(cwCalls, mockCwResponses);
+    });
+    afterEach(() => {
+        ECSClient.prototype.send = originalEcsSend;
+        EC2Client.prototype.send = originalEc2Send;
+        IAMClient.prototype.send = originalIamSend;
+        CloudWatchLogsClient.prototype.send = originalCwSend;
+        mock.restoreAll();
+    });
+    test("returns null when cluster does not exist during discovery", async () => {
+        mockEcsResponses["DescribeClustersCommand"] = { clusters: [] };
+        const builder = new FargateBuilder("my-svc");
+        const result = await builder.discoveryPromise;
+        assert.strictEqual(result, null);
+        assert.strictEqual(ecsCalls[0].commandName, "DescribeClustersCommand");
+    });
+    test("discovers existing service when cluster and service are active", async () => {
+        mockEcsResponses["DescribeClustersCommand"] = {
+            clusters: [
+                {
+                    status: "ACTIVE",
+                    clusterArn: "arn:aws:ecs:us-east-1:123:cluster/puls",
+                },
+            ],
+        };
+        mockEcsResponses["DescribeServicesCommand"] = {
+            services: [
+                {
+                    status: "ACTIVE",
+                    serviceArn: "arn:aws:ecs:us-east-1:123:service/puls/my-svc",
+                },
+            ],
+        };
+        const builder = new FargateBuilder("my-svc");
+        const result = await builder.discoveryPromise;
+        assert.ok(result);
+        assert.strictEqual(result.status, "ACTIVE");
+        assert.strictEqual(builder.resolvedArn, "arn:aws:ecs:us-east-1:123:service/puls/my-svc");
+    });
+    test("performs dry-run without any write API calls", async () => {
+        Config.set({ dryRun: true, providers: { aws: { region: "us-east-1" } } });
+        mockEcsResponses["DescribeClustersCommand"] = { clusters: [] };
+        const builder = new FargateBuilder("my-svc");
+        builder
+            .image("my-org/api:latest")
+            .cpu(512)
+            .memory(1024)
+            .port(3000)
+            .replicas(2);
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, "my-svc");
+        assert.ok(result.arn.includes("DRYRUN"));
+        const writeCalls = [
+            ...ecsCalls,
+            ...ec2Calls,
+            ...iamCalls,
+            ...cwCalls,
+        ].filter((c) => !c.commandName.startsWith("Describe"));
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test("creates new service- registers task def, creates cluster, role, log group, and service", async () => {
+        // Discovery: no cluster
+        mockEcsResponses["DescribeClustersCommand"] = { clusters: [] };
+        // ensureCluster
+        mockEcsResponses["CreateClusterCommand"] = {
+            cluster: { clusterArn: "arn:aws:ecs:us-east-1:123:cluster/puls" },
+        };
+        // ensureExecutionRole
+        const noRole = new Error("no such entity");
+        noRole.name = "NoSuchEntityException";
+        mockIamResponses["GetRoleCommand"] = noRole;
+        mockIamResponses["CreateRoleCommand"] = {
+            Role: { Arn: "arn:aws:iam::123:role/puls-fargate-my-svc-exec-role" },
+        };
+        // ensureLogGroup
+        mockCwResponses["DescribeLogGroupsCommand"] = { logGroups: [] };
+        // discoverDefaultVpc
+        mockEc2Responses["DescribeVpcsCommand"] = { Vpcs: [{ VpcId: "vpc-abc" }] };
+        mockEc2Responses["DescribeSubnetsCommand"] = {
+            Subnets: [{ SubnetId: "subnet-1" }, { SubnetId: "subnet-2" }],
+        };
+        // ensureSecurityGroup
+        mockEc2Responses["DescribeSecurityGroupsCommand"] = { SecurityGroups: [] };
+        mockEc2Responses["CreateSecurityGroupCommand"] = { GroupId: "sg-xyz" };
+        // RegisterTaskDefinition + CreateService
+        mockEcsResponses["RegisterTaskDefinitionCommand"] = {
+            taskDefinition: {
+                taskDefinitionArn: "arn:aws:ecs:us-east-1:123:task-def/my-svc:1",
+                revision: 1,
+            },
+        };
+        mockEcsResponses["CreateServiceCommand"] = {
+            service: { serviceArn: "arn:aws:ecs:us-east-1:123:service/puls/my-svc" },
+        };
+        const builder = new FargateBuilder("my-svc");
+        builder
+            .image("my-org/api:latest")
+            .cpu(512)
+            .memory(1024)
+            .port(3000)
+            .replicas(2);
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.strictEqual(result.name, "my-svc");
+        assert.strictEqual(result.arn, "arn:aws:ecs:us-east-1:123:service/puls/my-svc");
+        const createSvc = ecsCalls.find((c) => c.commandName === "CreateServiceCommand");
+        assert.ok(createSvc);
+        assert.strictEqual(createSvc.input.desiredCount, 2);
+        const registerDef = ecsCalls.find((c) => c.commandName === "RegisterTaskDefinitionCommand");
+        assert.ok(registerDef);
+        assert.strictEqual(registerDef.input.cpu, "512");
+        assert.strictEqual(registerDef.input.memory, "1024");
+    });
+    test("updates existing service with new task definition", async () => {
+        mockEcsResponses["DescribeClustersCommand"] = {
+            clusters: [
+                {
+                    status: "ACTIVE",
+                    clusterArn: "arn:aws:ecs:us-east-1:123:cluster/puls",
+                },
+            ],
+        };
+        mockEcsResponses["DescribeServicesCommand"] = {
+            services: [
+                {
+                    status: "ACTIVE",
+                    serviceArn: "arn:aws:ecs:us-east-1:123:service/puls/my-svc",
+                },
+            ],
+        };
+        // ensureCluster (existing)
+        mockEcsResponses["CreateClusterCommand"] = {};
+        // ensureExecutionRole (existing)
+        mockIamResponses["GetRoleCommand"] = {
+            Role: { Arn: "arn:aws:iam::123:role/puls-fargate-my-svc-exec-role" },
+        };
+        // ensureLogGroup (existing)
+        mockCwResponses["DescribeLogGroupsCommand"] = {
+            logGroups: [{ logGroupName: "/puls/my-svc" }],
+        };
+        // networking (existing SGs provided)
+        const builder = new FargateBuilder("my-svc");
+        builder
+            .image("my-org/api:v2")
+            .subnets(["subnet-1"])
+            .securityGroups(["sg-1"])
+            .replicas(3);
+        mockEcsResponses["RegisterTaskDefinitionCommand"] = {
+            taskDefinition: {
+                taskDefinitionArn: "arn:aws:ecs:us-east-1:123:task-def/my-svc:2",
+                revision: 2,
+            },
+        };
+        mockEcsResponses["UpdateServiceCommand"] = {};
+        await builder.deploy();
+        const updateSvc = ecsCalls.find((c) => c.commandName === "UpdateServiceCommand");
+        assert.ok(updateSvc);
+        assert.strictEqual(updateSvc.input.desiredCount, 3);
+        assert.strictEqual(updateSvc.input.forceNewDeployment, true);
+    });
+    test("drains and deletes service on destroy", async () => {
+        mockEcsResponses["DescribeClustersCommand"] = {
+            clusters: [{ status: "ACTIVE" }],
+        };
+        mockEcsResponses["DescribeServicesCommand"] = {
+            services: [
+                {
+                    status: "ACTIVE",
+                    serviceArn: "arn:aws:ecs:us-east-1:123:service/puls/my-svc",
+                },
+            ],
+        };
+        const builder = new FargateBuilder("my-svc");
+        await builder.discoveryPromise;
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: "my-svc" });
+        const drain = ecsCalls.find((c) => c.commandName === "UpdateServiceCommand" && c.input.desiredCount === 0);
+        assert.ok(drain);
+        const del = ecsCalls.find((c) => c.commandName === "DeleteServiceCommand");
+        assert.ok(del);
+        assert.strictEqual(del.input.force, true);
+    });
+    test("skips destroy when service does not exist", async () => {
+        mockEcsResponses["DescribeClustersCommand"] = { clusters: [] };
+        const builder = new FargateBuilder("my-svc");
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: "my-svc" });
+        assert.ok(!ecsCalls.some((c) => c.commandName === "DeleteServiceCommand"));
+    });
+});

package/dist/providers/aws/rds.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/providers/aws/rds.test.js

@@ -0,0 +1,219 @@
+import { test, describe, beforeEach, afterEach, mock } from "node:test";
+import assert from "node:assert";
+import { RDSClient } from "@aws-sdk/client-rds";
+import { EC2Client } from "@aws-sdk/client-ec2";
+import { RDSBuilder } from "./rds.js";
+import { Config } from "../../core/config.js";
+describe("RDSBuilder Unit Tests", () => {
+    let originalRdsSend;
+    let originalEc2Send;
+    let rdsCalls = [];
+    let ec2Calls = [];
+    let mockRdsResponses = {};
+    let mockEc2Responses = {};
+    function stubSend(calls, responses) {
+        return async function (command) {
+            const commandName = command.constructor.name;
+            calls.push({ commandName, input: command.input });
+            const handler = responses[commandName];
+            if (handler) {
+                if (typeof handler === "function")
+                    return handler(command.input);
+                if (handler instanceof Error)
+                    throw handler;
+                return handler;
+            }
+            return {};
+        };
+    }
+    beforeEach(() => {
+        Config.set({ dryRun: false, providers: { aws: { region: "us-east-1" } } });
+        rdsCalls = [];
+        ec2Calls = [];
+        mockRdsResponses = {};
+        mockEc2Responses = {};
+        originalRdsSend = RDSClient.prototype.send;
+        originalEc2Send = EC2Client.prototype.send;
+        RDSClient.prototype.send = stubSend(rdsCalls, mockRdsResponses);
+        EC2Client.prototype.send = stubSend(ec2Calls, mockEc2Responses);
+    });
+    afterEach(() => {
+        RDSClient.prototype.send = originalRdsSend;
+        EC2Client.prototype.send = originalEc2Send;
+        mock.restoreAll();
+    });
+    test("returns null when DB instance is not found during discovery", async () => {
+        const err = new Error("not found");
+        err.name = "DBInstanceNotFound";
+        mockRdsResponses["DescribeDBInstancesCommand"] = err;
+        const builder = new RDSBuilder("my-db");
+        const result = await builder.discoveryPromise;
+        assert.strictEqual(result, null);
+        assert.strictEqual(rdsCalls[0].commandName, "DescribeDBInstancesCommand");
+    });
+    test("discovers existing instance and populates resolved fields", async () => {
+        mockRdsResponses["DescribeDBInstancesCommand"] = {
+            DBInstances: [
+                {
+                    DBInstanceIdentifier: "my-db",
+                    DBInstanceStatus: "available",
+                    DBInstanceArn: "arn:aws:rds:us-east-1:123:db:my-db",
+                    Endpoint: {
+                        Address: "my-db.xyz.us-east-1.rds.amazonaws.com",
+                        Port: 5432,
+                    },
+                },
+            ],
+        };
+        const builder = new RDSBuilder("my-db");
+        const result = await builder.discoveryPromise;
+        assert.ok(result);
+        assert.strictEqual(builder.resolvedArn, "arn:aws:rds:us-east-1:123:db:my-db");
+        assert.strictEqual(builder.resolvedEndpoint, "my-db.xyz.us-east-1.rds.amazonaws.com");
+        assert.strictEqual(builder.resolvedPort, 5432);
+    });
+    test("performs dry-run without any write API calls", async () => {
+        Config.set({ dryRun: true, providers: { aws: { region: "us-east-1" } } });
+        const err = new Error("not found");
+        err.name = "DBInstanceNotFound";
+        mockRdsResponses["DescribeDBInstancesCommand"] = err;
+        const builder = new RDSBuilder("my-db");
+        builder
+            .engine({ engine: "postgres", version: "16" })
+            .size("db.t3.micro")
+            .storage(20);
+        const result = await builder.deploy();
+        assert.ok(result);
+        assert.ok(result.endpoint.includes("DRYRUN"));
+        assert.strictEqual(result.port, 5432);
+        const writeCalls = rdsCalls.filter((c) => !c.commandName.startsWith("Describe"));
+        assert.strictEqual(writeCalls.length, 0);
+    });
+    test("creates new DB instance with subnet group and security group", async () => {
+        const err = new Error("not found");
+        err.name = "DBInstanceNotFound";
+        mockRdsResponses["DescribeDBInstancesCommand"] = err;
+        // ensureSubnetGroup
+        const noGroup = new Error("not found");
+        noGroup.name = "DBSubnetGroupNotFoundFault";
+        mockRdsResponses["DescribeDBSubnetGroupsCommand"] = noGroup;
+        mockRdsResponses["CreateDBSubnetGroupCommand"] = {};
+        // ensureSecurityGroup
+        mockEc2Responses["DescribeVpcsCommand"] = {
+            Vpcs: [{ VpcId: "vpc-1", CidrBlock: "10.0.0.0/16" }],
+        };
+        mockEc2Responses["DescribeSubnetsCommand"] = {
+            Subnets: [{ SubnetId: "subnet-1" }],
+        };
+        mockEc2Responses["DescribeSecurityGroupsCommand"] = { SecurityGroups: [] };
+        mockEc2Responses["CreateSecurityGroupCommand"] = { GroupId: "sg-1" };
+        // CreateDBInstance- return available immediately so the waitFor resolves
+        mockRdsResponses["CreateDBInstanceCommand"] = {};
+        let describeCount = 0;
+        mockRdsResponses["DescribeDBInstancesCommand"] = (input) => {
+            describeCount++;
+            if (describeCount === 1) {
+                // First call: discovery in constructor- instance not found
+                const notFound = new Error("not found");
+                notFound.name = "DBInstanceNotFound";
+                throw notFound;
+            }
+            // Subsequent calls: waitFor polling- instance now available
+            return {
+                DBInstances: [
+                    {
+                        DBInstanceIdentifier: "my-db",
+                        DBInstanceStatus: "available",
+                        DBInstanceArn: "arn:aws:rds:us-east-1:123:db:my-db",
+                        Endpoint: { Address: "my-db.xyz.rds.amazonaws.com", Port: 5432 },
+                    },
+                ],
+            };
+        };
+        // Fast-forward poll timer
+        mock.method(global, "setTimeout", (fn) => fn());
+        const builder = new RDSBuilder("my-db");
+        builder
+            .engine({ engine: "postgres", version: "16" })
+            .size("db.t3.small")
+            .storage(40)
+            .credentials("admin", "secret");
+        const result = await builder.deploy();
+        assert.ok(result);
+        const createCall = rdsCalls.find((c) => c.commandName === "CreateDBInstanceCommand");
+        assert.ok(createCall);
+        assert.strictEqual(createCall.input.DBInstanceIdentifier, "my-db");
+        assert.strictEqual(createCall.input.Engine, "postgres");
+        assert.strictEqual(createCall.input.EngineVersion, "16");
+        assert.strictEqual(createCall.input.DBInstanceClass, "db.t3.small");
+        assert.strictEqual(createCall.input.AllocatedStorage, 40);
+    });
+    test("modifies existing instance on update", async () => {
+        mockRdsResponses["DescribeDBInstancesCommand"] = {
+            DBInstances: [
+                {
+                    DBInstanceIdentifier: "my-db",
+                    DBInstanceStatus: "available",
+                    DBInstanceArn: "arn:aws:rds:us-east-1:123:db:my-db",
+                    Endpoint: { Address: "my-db.xyz.rds.amazonaws.com", Port: 5432 },
+                },
+            ],
+        };
+        // ensureSubnetGroup (existing)
+        mockRdsResponses["DescribeDBSubnetGroupsCommand"] = {
+            DBSubnetGroups: [{ DBSubnetGroupName: "puls-my-db-subnet-group" }],
+        };
+        const builder = new RDSBuilder("my-db");
+        builder
+            .engine({ engine: "postgres", version: "16" })
+            .size("db.t3.medium")
+            .subnets(["subnet-1"])
+            .securityGroups(["sg-1"])
+            .credentials("admin", "secret");
+        await builder.deploy();
+        const modifyCall = rdsCalls.find((c) => c.commandName === "ModifyDBInstanceCommand");
+        assert.ok(modifyCall);
+        assert.strictEqual(modifyCall.input.DBInstanceClass, "db.t3.medium");
+        assert.strictEqual(modifyCall.input.ApplyImmediately, true);
+    });
+    test("deletes instance on destroy", async () => {
+        mockRdsResponses["DescribeDBInstancesCommand"] = {
+            DBInstances: [
+                {
+                    DBInstanceIdentifier: "my-db",
+                    DBInstanceStatus: "available",
+                    DBInstanceArn: "arn:aws:rds:us-east-1:123:db:my-db",
+                    Endpoint: { Address: "my-db.xyz.rds.amazonaws.com", Port: 5432 },
+                },
+            ],
+        };
+        const builder = new RDSBuilder("my-db");
+        await builder.discoveryPromise;
+        const result = await builder.destroy();
+        assert.deepStrictEqual(result, { destroyed: "my-db" });
+        const deleteCall = rdsCalls.find((c) => c.commandName === "DeleteDBInstanceCommand");
+        assert.ok(deleteCall);
+        assert.strictEqual(deleteCall.input.DBInstanceIdentifier, "my-db");
+        assert.strictEqual(deleteCall.input.SkipFinalSnapshot, true);
+    });
+    test("getDiff returns field changes against live state", () => {
+        const err = new Error("not found");
+        err.name = "DBInstanceNotFound";
+        mockRdsResponses["DescribeDBInstancesCommand"] = err;
+        const builder = new RDSBuilder("my-db");
+        builder
+            .engine({ engine: "postgres", version: "16" })
+            .size("db.t3.small")
+            .storage(40);
+        const diffs = builder.getDiff({
+            Engine: "postgres",
+            EngineVersion: "15", // differs
+            DBInstanceClass: "db.t3.micro", // differs
+            AllocatedStorage: 40,
+            PubliclyAccessible: false,
+        });
+        assert.strictEqual(diffs.length, 2);
+        assert.ok(diffs.some((d) => d.field === "engineVersion"));
+        assert.ok(diffs.some((d) => d.field === "instanceClass"));
+    });
+});

package/dist/providers/aws/sqs.test.d.ts

@@ -0,0 +1 @@
+export {};