@fishawack/lab-env 5.3.0 → 5.4.0-beta.1

package/CHANGELOG.md

@@ -1,5 +1,29 @@
 ## Changelog
 
+### 5.4.0-beta.1 (2026-03-12)
+
+#### Features
+
+* added a prune command ([0775617](https://bitbucket.org/fishawackdigital/lab-env/commits/0775617e763d9833e78633df48d5560ac4bb4ea5))
+* added more consistent prune flags to handle all clients and regions at once ([c2ff371](https://bitbucket.org/fishawackdigital/lab-env/commits/c2ff37189aa137291d1dc906b187ab808f0ec3c2))
+* added new cloudfront methods ([8c9acf3](https://bitbucket.org/fishawackdigital/lab-env/commits/8c9acf39899147affb95476fd89b967eea57826c))
+* created prune command for cloudfront and application version pruning ([be3ba54](https://bitbucket.org/fishawackdigital/lab-env/commits/be3ba5468187e5733a94e0bd266c8dfc2748e821))
+* ignore double dollar for webdriverio shorthand ([044c457](https://bitbucket.org/fishawackdigital/lab-env/commits/044c4570c1d09161eb97835e9d1947d046866e1a))
+
+#### Bug Fixes
+
+* add missing elasticcache permission on eb managed update profile ([a21bf3d](https://bitbucket.org/fishawackdigital/lab-env/commits/a21bf3de4e4014adde912711e7d47ed9b25904f2))
+* add retrys and backoff and store the client and region on delete command ([36024b9](https://bitbucket.org/fishawackdigital/lab-env/commits/36024b96fe1ba42054efd280c08cb411dfc9a16e))
+* added elastic cache to fulsltack deploy permissions ([c94dc47](https://bitbucket.org/fishawackdigital/lab-env/commits/c94dc47a971a6fe6818127573d306a9bcf28b19f))
+* own venv dir so ci can remove correcty ([9b42c77](https://bitbucket.org/fishawackdigital/lab-env/commits/9b42c7729411142101b2f5b2f07f79a5b8363178))
+* python now maps like other containers with user and ssh for private packages ([fb04737](https://bitbucket.org/fishawackdigital/lab-env/commits/fb047378844d44b5f79dc67e0d089819cfdde82f))
+* remove client from iam signature as it broke permissions ([777f58f](https://bitbucket.org/fishawackdigital/lab-env/commits/777f58fa20403940ba2cd6cb4aa384fbf7f4553a))
+
+#### Build Updates
+
+* bumped fishawack/lab-env-python-0 to 1.1.0 ([db2ffd1](https://bitbucket.org/fishawackdigital/lab-env/commits/db2ffd1a9fe9be7029fc1b434072bbbccaa670b4))
+* bumped fishawack/lab-env-python-0 to 1.1.1 ([9a70106](https://bitbucket.org/fishawackdigital/lab-env/commits/9a70106dd9778ee23ab04039eed692788b7199c8))
+
 ### 5.3.0 (2026-02-23)
 
 #### Features

package/_Test/provision.js

@@ -43,6 +43,8 @@ describe("provision", () => {
 
     describe("fullstack", () => {
         before(async () => {
+            setAWSClientDefaults(account);
+
             fetch = (await import("node-fetch")).default;
 
             process.env.REPO = repo;

package/_Test/prune.js

@@ -0,0 +1,291 @@
+"use strict";
+
+const expect = require("chai").expect;
+const aws = require("../commands/create/services/aws/index.js");
+const {
+    setAWSClientDefaults,
+} = require("../commands/create/services/aws/misc.js");
+
+const APP_NAME = "lab-env-prune-test";
+const VERSION_COUNT = 15;
+const VERSIONS_TO_KEEP = 10;
+const STALE_MONTHS = 3;
+const ACCOUNT = "test";
+const REGION = "us-east-1";
+
+describe("prune", () => {
+    before(async () => {
+        setAWSClientDefaults(ACCOUNT, REGION);
+
+        await aws.elasticbeanstalk.createElasticBeanstalkApplication(APP_NAME);
+
+        for (let i = 1; i <= VERSION_COUNT; i++) {
+            await aws.elasticbeanstalk.createApplicationVersion(
+                APP_NAME,
+                `v${i}`,
+            );
+        }
+    });
+
+    it("Should list all applications in a given account and region", async () => {
+        setAWSClientDefaults(ACCOUNT, REGION);
+
+        const applications = await aws.elasticbeanstalk.listApplications();
+        const names = applications.map((app) => app.ApplicationName);
+
+        expect(names).to.include(APP_NAME);
+    });
+
+    it("Should list all application versions for a specific app", async () => {
+        const versions =
+            await aws.elasticbeanstalk.listApplicationVersions(APP_NAME);
+
+        expect(versions).to.have.lengthOf(VERSION_COUNT);
+    });
+
+    it("Should identify prunable versions keeping the 10 most recent", async () => {
+        const versions =
+            await aws.elasticbeanstalk.listApplicationVersions(APP_NAME);
+
+        versions.sort(
+            (a, b) => new Date(b.DateCreated) - new Date(a.DateCreated),
+        );
+
+        const keep = versions.slice(0, VERSIONS_TO_KEEP);
+        const prunable = versions.slice(VERSIONS_TO_KEEP);
+
+        expect(keep).to.have.lengthOf(VERSIONS_TO_KEEP);
+        expect(prunable).to.have.lengthOf(VERSION_COUNT - VERSIONS_TO_KEEP);
+
+        const oldestKept = new Date(
+            keep[keep.length - 1].DateCreated,
+        ).getTime();
+        const newestPrunable = new Date(prunable[0].DateCreated).getTime();
+
+        expect(oldestKept).to.be.at.least(newestPrunable);
+    });
+
+    it("Should delete prunable application versions", async () => {
+        const versions =
+            await aws.elasticbeanstalk.listApplicationVersions(APP_NAME);
+
+        versions.sort(
+            (a, b) => new Date(b.DateCreated) - new Date(a.DateCreated),
+        );
+
+        const prunable = versions.slice(VERSIONS_TO_KEEP);
+
+        expect(prunable.length).to.be.greaterThan(0);
+
+        for (const v of prunable) {
+            await aws.elasticbeanstalk.deleteApplicationVersion(
+                APP_NAME,
+                v.VersionLabel,
+            );
+        }
+
+        const remaining =
+            await aws.elasticbeanstalk.listApplicationVersions(APP_NAME);
+
+        expect(remaining).to.have.lengthOf(VERSIONS_TO_KEEP);
+    });
+
+    it("Should have only the most recent versions remaining after prune", async () => {
+        const remaining =
+            await aws.elasticbeanstalk.listApplicationVersions(APP_NAME);
+
+        remaining.sort(
+            (a, b) => new Date(b.DateCreated) - new Date(a.DateCreated),
+        );
+
+        const labels = remaining.map((v) => v.VersionLabel);
+
+        // v11-v15 should remain (the 5 newest created last)
+        for (
+            let i = VERSION_COUNT - VERSIONS_TO_KEEP + 1;
+            i <= VERSION_COUNT;
+            i++
+        ) {
+            expect(labels).to.include(`v${i}`);
+        }
+
+        // v1-v5 should be gone (the 5 oldest created first)
+        for (let i = 1; i <= VERSION_COUNT - VERSIONS_TO_KEEP; i++) {
+            expect(labels).to.not.include(`v${i}`);
+        }
+    });
+
+    it("Should handle switching accounts gracefully", async () => {
+        // Switching to a different region should not see our test app
+        setAWSClientDefaults(ACCOUNT, "eu-west-1");
+
+        const applications = await aws.elasticbeanstalk.listApplications();
+        const names = applications.map((app) => app.ApplicationName);
+
+        // Test app was created in us-east-1, should not appear in eu-west-1
+        // (unless it happens to exist there too — either way this validates
+        // that setAWSClientDefaults switches context correctly)
+        expect(names).to.be.an("array");
+
+        // Switch back for cleanup
+        setAWSClientDefaults(ACCOUNT, REGION);
+    });
+
+    after(async () => {
+        try {
+            await aws.elasticbeanstalk.removeElasticBeanstalkApplication(
+                APP_NAME,
+            );
+        } catch {
+            /* empty */
+        }
+    });
+
+    describe("cloudfront static distributions", () => {
+        const CF_REPO = "lab-env-prune-cf-test";
+        const CF_BRANCH = "development";
+        let cfDistributionId;
+        let cfName;
+
+        before(async () => {
+            setAWSClientDefaults(ACCOUNT, REGION);
+
+            cfName = aws.slug(CF_REPO, ACCOUNT, CF_BRANCH);
+
+            const result = await aws.static(
+                cfName,
+                [
+                    { Key: "repository", Value: CF_REPO },
+                    { Key: "environment", Value: CF_BRANCH },
+                    { Key: "automated", Value: "true" },
+                ],
+                [],
+                CF_REPO,
+                CF_BRANCH,
+            );
+
+            cfDistributionId = result.cloudfront;
+        });
+
+        it("Should list distributions for a given account and region", async () => {
+            setAWSClientDefaults(ACCOUNT, REGION);
+
+            const distributions = await aws.cloudfront.listDistributions();
+
+            expect(distributions).to.be.an("array");
+            expect(distributions.length).to.be.greaterThan(0);
+
+            const ids = distributions.map((d) => d.Id);
+
+            expect(ids).to.include(cfDistributionId);
+        });
+
+        it("Should fetch tags for a distribution", async () => {
+            const distributions = await aws.cloudfront.listDistributions();
+            const dist = distributions.find((d) => d.Id === cfDistributionId);
+
+            expect(dist).to.exist;
+
+            const tags = await aws.cloudfront.getDistributionTags(dist.ARN);
+
+            expect(tags).to.be.an("array");
+
+            const keys = tags.map((t) => t.Key);
+
+            expect(keys).to.include("automated");
+            expect(keys).to.include("environment");
+            expect(keys).to.include("repository");
+        });
+
+        it("Should identify automated distributions via tags", () => {
+            const automated = [{ Key: "automated", Value: "true" }];
+            const manual = [{ Key: "environment", Value: "dev" }];
+
+            expect(automated.some((t) => t.Key === "automated")).to.be.true;
+            expect(manual.some((t) => t.Key === "automated")).to.be.false;
+        });
+
+        it("Should identify production distributions via tags", () => {
+            const prod = [{ Key: "environment", Value: "production" }];
+            const staging = [{ Key: "environment", Value: "staging" }];
+            const prodShort = [{ Key: "environment", Value: "prod" }];
+            const noEnv = [{ Key: "automated", Value: "true" }];
+
+            const isProduction = (tags) => {
+                const env = tags.find((t) => t.Key === "environment");
+                if (!env) return false;
+                return /prod/i.test(env.Value);
+            };
+
+            expect(isProduction(prod)).to.be.true;
+            expect(isProduction(prodShort)).to.be.true;
+            expect(isProduction(staging)).to.be.false;
+            expect(isProduction(noEnv)).to.be.false;
+        });
+
+        it("Should identify stale distributions older than threshold", () => {
+            const now = new Date();
+
+            const staleDate = new Date(now);
+            staleDate.setMonth(staleDate.getMonth() - STALE_MONTHS - 1);
+
+            const recentDate = new Date(now);
+            recentDate.setMonth(recentDate.getMonth() - 1);
+
+            const isStale = (lastModified) => {
+                const cutoff = new Date();
+                cutoff.setMonth(cutoff.getMonth() - STALE_MONTHS);
+                return new Date(lastModified) < cutoff;
+            };
+
+            expect(isStale(staleDate.toISOString())).to.be.true;
+            expect(isStale(recentDate.toISOString())).to.be.false;
+            expect(isStale(now.toISOString())).to.be.false;
+        });
+
+        it("Should not flag a recently created distribution as prunable", async () => {
+            const distributions = await aws.cloudfront.listDistributions();
+            const dist = distributions.find((d) => d.Id === cfDistributionId);
+
+            const cutoff = new Date();
+            cutoff.setMonth(cutoff.getMonth() - STALE_MONTHS);
+
+            // Just created, so it should be newer than cutoff
+            expect(new Date(dist.LastModifiedTime) >= cutoff).to.be.true;
+        });
+
+        it("Should tear down a static distribution completely", async () => {
+            setAWSClientDefaults(ACCOUNT, REGION);
+
+            await aws.staticTerminate(
+                cfName,
+                CF_REPO,
+                CF_BRANCH,
+                cfDistributionId,
+            );
+
+            // Allow propagation time
+            await new Promise((r) => setTimeout(r, 5000));
+
+            const distributions = await aws.cloudfront.listDistributions();
+            const ids = distributions.map((d) => d.Id);
+
+            expect(ids).to.not.include(cfDistributionId);
+        });
+
+        after(async () => {
+            // Safety cleanup in case test failed mid-way
+            try {
+                setAWSClientDefaults(ACCOUNT, REGION);
+                await aws.staticTerminate(
+                    cfName,
+                    CF_REPO,
+                    CF_BRANCH,
+                    cfDistributionId,
+                );
+            } catch {
+                /* empty */
+            }
+        });
+    });
+});

package/cli.js

@@ -169,6 +169,7 @@ const args = hideBin(process.argv);
                 "delete",
                 "key",
                 "dekey",
+                "prune",
             ].forEach((d) =>
                 cli.command(...require(`./commands/create/cmds/${d}.js`)),
             );

package/commands/create/cmds/key.js

@@ -97,7 +97,6 @@ module.exports = [
 
                 let res = await aws.iam.createFWIAMUser(
                     `fw-automation-${user}`,
-                    client,
                     _.config.users.find((d) => d.username === user).permissions,
                 );