puls-dev 0.3.5 → 0.3.7

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

@@ -0,0 +1,167 @@
+import { test, describe, beforeEach, afterEach, mock } from 'node:test';
+import assert from 'node:assert';
+import { ACMClient } from '@aws-sdk/client-acm';
+import { Route53Client } from '@aws-sdk/client-route-53';
+import { ACMCertificateBuilder } from './acm.js';
+import { Config } from '../../core/config.js';
+describe('ACMCertificateBuilder Unit Tests', () => {
+    let originalAcmSend;
+    let originalR53Send;
+    let acmCalls = [];
+    let r53Calls = [];
+    let mockAcmResponses = {};
+    let mockR53Responses = {};
+    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' } } });
+        acmCalls = [];
+        r53Calls = [];
+        mockAcmResponses = {};
+        mockR53Responses = {};
+        originalAcmSend = ACMClient.prototype.send;
+        originalR53Send = Route53Client.prototype.send;
+        ACMClient.prototype.send = stubSend(acmCalls, mockAcmResponses);
+        Route53Client.prototype.send = stubSend(r53Calls, mockR53Responses);
+    });
+    afterEach(() => {
+        ACMClient.prototype.send = originalAcmSend;
+        Route53Client.prototype.send = originalR53Send;
+        mock.restoreAll();
+    });
+    test('returns null when no matching certificate is found', async () => {
+        mockAcmResponses['ListCertificatesCommand'] = { CertificateSummaryList: [] };
+        const builder = new ACMCertificateBuilder('example.com');
+        const result = await builder.discoveryPromise;
+        assert.strictEqual(result, null);
+        assert.strictEqual(acmCalls[0].commandName, 'ListCertificatesCommand');
+    });
+    test('discovers existing wildcard certificate by domain name', async () => {
+        mockAcmResponses['ListCertificatesCommand'] = {
+            CertificateSummaryList: [
+                {
+                    DomainName: '*.example.com',
+                    CertificateArn: 'arn:aws:acm:us-east-1:123:certificate/abc',
+                },
+            ],
+        };
+        const builder = new ACMCertificateBuilder('example.com', true);
+        const result = await builder.discoveryPromise;
+        assert.ok(result);
+        assert.strictEqual(builder.resolvedArn, 'arn:aws:acm:us-east-1:123:certificate/abc');
+    });
+    test('returns existing cert without requesting a new one', async () => {
+        mockAcmResponses['ListCertificatesCommand'] = {
+            CertificateSummaryList: [
+                {
+                    DomainName: '*.example.com',
+                    CertificateArn: 'arn:aws:acm:us-east-1:123:certificate/abc',
+                    Status: 'ISSUED',
+                },
+            ],
+        };
+        const builder = new ACMCertificateBuilder('example.com');
+        const result = await builder.deploy();
+        assert.strictEqual(result.arn, 'arn:aws:acm:us-east-1:123:certificate/abc');
+        assert.ok(!acmCalls.some((c) => c.commandName === 'RequestCertificateCommand'));
+    });
+    test('performs dry-run without requesting a certificate', async () => {
+        Config.set({ dryRun: true, providers: { aws: { region: 'us-east-1' } } });
+        mockAcmResponses['ListCertificatesCommand'] = { CertificateSummaryList: [] };
+        const builder = new ACMCertificateBuilder('example.com');
+        const result = await builder.deploy();
+        assert.ok(result.arn.includes('DRYRUN'));
+        assert.ok(!acmCalls.some((c) => c.commandName === 'RequestCertificateCommand'));
+    });
+    test('requests wildcard cert and writes DNS validation records to Route53', async () => {
+        mockAcmResponses['ListCertificatesCommand'] = { CertificateSummaryList: [] };
+        mockAcmResponses['RequestCertificateCommand'] = {
+            CertificateArn: 'arn:aws:acm:us-east-1:123:certificate/new-cert',
+        };
+        let describeCallCount = 0;
+        mockAcmResponses['DescribeCertificateCommand'] = () => {
+            describeCallCount++;
+            if (describeCallCount === 1) {
+                // First call: validation records ready
+                return {
+                    Certificate: {
+                        Status: 'PENDING_VALIDATION',
+                        DomainValidationOptions: [
+                            {
+                                ResourceRecord: {
+                                    Name: '_abc.example.com',
+                                    Value: '_xyz.acm-validations.aws.',
+                                },
+                            },
+                        ],
+                    },
+                };
+            }
+            // Second call: ISSUED
+            return { Certificate: { Status: 'ISSUED' } };
+        };
+        mockR53Responses['ChangeResourceRecordSetsCommand'] = {};
+        // Fast-forward poll timers
+        mock.method(global, 'setTimeout', (fn) => fn());
+        const builder = new ACMCertificateBuilder('example.com', true);
+        builder.forZone({ zoneId: 'Z123456', zoneName: 'example.com' });
+        const result = await builder.deploy();
+        assert.strictEqual(result.arn, 'arn:aws:acm:us-east-1:123:certificate/new-cert');
+        const requestCall = acmCalls.find((c) => c.commandName === 'RequestCertificateCommand');
+        assert.ok(requestCall);
+        assert.strictEqual(requestCall.input.DomainName, '*.example.com');
+        assert.strictEqual(requestCall.input.ValidationMethod, 'DNS');
+        const r53Call = r53Calls.find((c) => c.commandName === 'ChangeResourceRecordSetsCommand');
+        assert.ok(r53Call);
+        assert.strictEqual(r53Call.input.HostedZoneId, 'Z123456');
+        const changes = r53Call.input.ChangeBatch.Changes;
+        assert.strictEqual(changes.length, 1);
+        assert.strictEqual(changes[0].Action, 'UPSERT');
+        assert.ok(changes[0].ResourceRecordSet.Name.includes('_abc'));
+    });
+    test('deduplicates validation CNAME records before writing to Route53', async () => {
+        mockAcmResponses['ListCertificatesCommand'] = { CertificateSummaryList: [] };
+        mockAcmResponses['RequestCertificateCommand'] = {
+            CertificateArn: 'arn:aws:acm:us-east-1:123:certificate/new-cert',
+        };
+        let describeCount = 0;
+        mockAcmResponses['DescribeCertificateCommand'] = () => {
+            describeCount++;
+            if (describeCount === 1) {
+                return {
+                    Certificate: {
+                        Status: 'PENDING_VALIDATION',
+                        // wildcard + apex SANs produce the same CNAME - duplicated
+                        DomainValidationOptions: [
+                            { ResourceRecord: { Name: '_dup.example.com', Value: '_val.aws.' } },
+                            { ResourceRecord: { Name: '_dup.example.com', Value: '_val.aws.' } },
+                        ],
+                    },
+                };
+            }
+            return { Certificate: { Status: 'ISSUED' } };
+        };
+        mockR53Responses['ChangeResourceRecordSetsCommand'] = {};
+        mock.method(global, 'setTimeout', (fn) => fn());
+        const builder = new ACMCertificateBuilder('example.com', true);
+        builder.forZone({ zoneId: 'Z123456', zoneName: 'example.com' });
+        await builder.deploy();
+        const r53Call = r53Calls.find((c) => c.commandName === 'ChangeResourceRecordSetsCommand');
+        assert.ok(r53Call);
+        // Should be deduplicated to 1 record
+        assert.strictEqual(r53Call.input.ChangeBatch.Changes.length, 1);
+    });
+});

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

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

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 {};