@vida-global/release 1.0.0 → 1.0.1

package/.github/workflows/npm-publish.yml

@@ -0,0 +1,28 @@
+# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
+# For more information see: https://docs.github.com/en/actions/publishing-packages/publishing-nodejs-packages
+
+name: Node.js Package
+
+on:
+  push:
+    branches:
+      - release/production
+
+permissions:
+  id-token: write
+  contents: read
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24'
+          registry-url: 'https://registry.npmjs.org'
+      - run: npm ci
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_READ_TOKEN }}
+      - run: npm test
+      - run: npm publish

package/package.json

@@ -1,15 +1,31 @@
 {
     "name": "@vida-global/release",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "description": "Tools for releasing Vida tools",
     "author": "",
     "license": "ISC",
     "main": "index.js",
+        "repository": {
+        "type": "git",
+        "url": "https://github.com/VIDA-Global/release"
+    },
+    "scripts": {
+        "test": "NODE_NO_WARNINGS=1 node --experimental-vm-modules node_modules/jest/bin/jest.js"
+    },
+    "jest": {
+        "collectCoverage": true,
+        "coveragePathIgnorePatterns": [
+            "/helpers/"
+        ],
+        "setupFilesAfterEnv": ["jest-extended/all"]
+    },
     "dependencies": {
         "commander": "^13.1.0",
         "pino": "^9.6.0",
         "pino-pretty": "^13.0.0"
+    },
+    "devDependencies": {
+        "jest": "^29.6.2",
+        "jest-extended": "^7.0.0"
     }
 }
-
-

package/test/develop.test.js

@@ -0,0 +1,57 @@
+const { develop }   = require('../lib/release/develop');
+const   Git         = require('../lib/release/git');
+const   TestHelpers = require('./helpers');
+const   utils       = require('../lib/release/utils');
+
+
+jest.mock('../lib/release/git', () => {
+    return { createBranch: jest.fn(), getCurrentUser: jest.fn() }
+});
+jest.mock('../lib/release/utils', () => {
+    return { confirmContinue: jest.fn() };
+});
+
+
+let branchType;
+let description;
+let firstName;
+let issueNumber;
+let lastName;
+let sourceBranch;
+beforeEach(() => {
+    jest.resetAllMocks();
+    utils.confirmContinue.mockImplementation(() => true);
+
+    firstName = TestHelpers.Faker.User.randomFirstName();
+    lastName  = TestHelpers.Faker.User.randomLastName();
+    Git.getCurrentUser.mockImplementation(() => `${firstName} ${lastName}`);
+
+    branchType   = TestHelpers.Faker.Text.randomString();
+    sourceBranch = TestHelpers.Faker.Text.randomString();
+    description  = TestHelpers.Faker.Text.randomSentence();
+    issueNumber  = TestHelpers.Faker.Math.randomNumber();
+});
+
+
+describe('develop', () => {
+    it ('confirms and creates a branch once', async () => {
+        await develop(branchType, issueNumber, description, sourceBranch);
+        expect(utils.confirmContinue).toHaveBeenCalledTimes(1);
+        expect(Git.createBranch).toHaveBeenCalledTimes(1);
+    });
+
+    it ('generates the correct branch name', async () => {
+        const initials   = `${firstName[0]}${lastName[0]}`.toLowerCase();
+        const branchName = `${branchType}/${issueNumber}/${initials}/${description.replace(/\s+/g, '-').toLowerCase().replace(/[^a-z0-9-]/g, '')}`;
+        await develop(branchType, issueNumber, description, sourceBranch);
+
+        expect(utils.confirmContinue).toHaveBeenCalledWith(`Do you want to create branch ${branchName}?`);
+        expect(Git.createBranch).toHaveBeenCalledWith(branchName, sourceBranch);
+    });
+
+    it ('does not create a branch if the user does not confirm', async () => {
+        utils.confirmContinue.mockImplementation(() => false);
+        await develop(branchType, issueNumber, description, sourceBranch);
+        expect(Git.createBranch).not.toHaveBeenCalled();
+    });
+});

package/test/git.test.js

@@ -0,0 +1,189 @@
+const { execSync }  = require('child_process');
+const   Git         = require('../lib/release/git');
+const   TestHelpers = require('./helpers');
+
+
+jest.mock('child_process', () => {
+    const execSync = jest.fn();
+    return { execSync };
+});
+
+
+beforeEach(() => {
+    jest.resetAllMocks();
+});
+
+
+describe('Git.add', () => {
+    it ('calls git add with the file name', () => {
+        const fileName = TestHelpers.Faker.Text.randomString();
+        Git.add(fileName);
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(execSync).toHaveBeenCalledWith(`git add ${fileName}`);
+    });
+});
+
+
+describe('Git.branches', () => {
+    it ('calls git branch and returns an array of the resulting strings', () => {
+        const b1        = TestHelpers.Faker.Text.randomString();
+        const b2        = TestHelpers.Faker.Text.randomString();
+        const b3        = TestHelpers.Faker.Text.randomString();
+        const branchStr = `    ${b1}  \n    ${b2}\n${b3}    `;
+        execSync.mockImplementation(() => branchStr);
+
+        const branches = Git.branches();
+
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(branches).toEqual([b1, b2, b3]);
+        expect(execSync).toHaveBeenCalledWith(`git branch -r`);
+    });
+
+    it ('does not include the remote option when needed', () => {
+        execSync.mockImplementation(() => '');
+        const branches = Git.branches(false);
+        expect(execSync).toHaveBeenCalledWith(`git branch`);
+    });
+});
+
+
+describe('Git.checkout', () => {
+    it ('calls git checkout with the branch name', () => {
+        const branchName = TestHelpers.Faker.Text.randomString();
+        Git.checkout(branchName);
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(execSync).toHaveBeenCalledWith(`git checkout ${branchName}`);
+    });
+});
+
+
+describe('Git.commit', () => {
+    it ('calls git commit with comment', () => {
+        const comment = TestHelpers.Faker.Text.randomString();
+        Git.commit(comment);
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(execSync).toHaveBeenCalledWith(`git commit -m '${comment}'`);
+    });
+});
+
+
+describe('Git.createBranch', () => {
+    it ('creates a branch and switches to it', () => {
+        const branch1 = TestHelpers.Faker.Text.randomString();
+        const branch2 = TestHelpers.Faker.Text.randomString();
+
+        Git.createBranch(branch1, branch2);
+
+        expect(execSync).toHaveBeenCalledTimes(2);
+        expect(execSync).toHaveBeenNthCalledWith(1, `git branch ${branch1} ${branch2}`);
+        expect(execSync).toHaveBeenNthCalledWith(2, `git checkout ${branch1}`);
+    });
+
+    it ('defaults to the primary branch', () => {
+        const branch1 = TestHelpers.Faker.Text.randomString();
+
+        execSync.mockImplementation(() => 'origin/main');
+
+        Git.createBranch(branch1);
+
+        expect(execSync).toHaveBeenCalledTimes(3);
+        expect(execSync).toHaveBeenNthCalledWith(2, `git branch ${branch1} origin/main`);
+    });
+});
+
+
+describe('Git.forceRemotePush', () => {
+    it ('calls git push with the origin', () => {
+        const branch1 = TestHelpers.Faker.Text.randomString();
+        const branch2 = TestHelpers.Faker.Text.randomString();
+
+        Git.forceRemotePush(branch1, branch2);
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(execSync).toHaveBeenCalledWith(`git push origin origin/${branch1}:${branch2} --force`)
+    });
+});
+
+
+describe('Git.getCurrentUser', () => {
+    it ('returns the result of git config.name', () => {
+        const name = TestHelpers.Faker.User.randomName();
+        execSync.mockImplementation(() => name);
+
+        const response = Git.getCurrentUser();
+
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(execSync).toHaveBeenCalledWith(`git config user.name`);
+        expect(response).toEqual(name);
+    });
+});
+
+
+describe('Git.getPrimaryBranch', () => {
+    it ('returns master when that is the primary branch', () => {
+        const branch1    = TestHelpers.Faker.Text.randomString();
+        const branch2    = TestHelpers.Faker.Text.randomString();
+        const branchStr  = `   origin/${branch1}\n  origin/master \n  origin/${branch2}`;
+        execSync.mockImplementation(() => branchStr);
+
+        const branch = Git.getPrimaryBranch();
+
+        expect(branch).toEqual('origin/master');
+    });
+
+    it ('returns main when that is the primary branch', () => {
+        const branch1    = TestHelpers.Faker.Text.randomString();
+        const branch2    = TestHelpers.Faker.Text.randomString();
+        const branchStr  = `origin/${branch1}\norigin/${branch2}\n  origin/main  `;
+        execSync.mockImplementation(() => branchStr);
+
+        const branch = Git.getPrimaryBranch();
+
+        expect(branch).toEqual('origin/main');
+    });
+
+    it ('returns undefined when it cannot determine the primary branch', () => {
+        const branch1    = TestHelpers.Faker.Text.randomString();
+        const branch2    = TestHelpers.Faker.Text.randomString();
+        const branch3    = TestHelpers.Faker.Text.randomString();
+        const branchStr  = `origin/${branch1}\norigin/${branch2}\n  origin/${branch3}  `;
+        execSync.mockImplementation(() => branchStr);
+
+        const branch = Git.getPrimaryBranch();
+
+        expect(branch).toBeUndefined();
+    });
+});
+
+
+describe('Git.getCurrentBranch', () => {
+    it ('returns the branch with the *', () => {
+        const branch1    = TestHelpers.Faker.Text.randomString();
+        const branch2    = TestHelpers.Faker.Text.randomString();
+        const branch3    = TestHelpers.Faker.Text.randomString();
+        const branchStr  = `   origin/${branch1}\n  *  ${branch3} \n  origin/${branch2}`;
+        execSync.mockImplementation(() => branchStr);
+
+        const branch = Git.getCurrentBranch();
+
+        expect(branch).toEqual(branch3);
+    });
+});
+
+
+describe('Git.pull', () => {
+    it ('calls git pull with the prune option', () => {
+        Git.pull();
+        expect(execSync).toHaveBeenCalledTimes(1);
+        expect(execSync).toHaveBeenCalledWith(`git pull --prune`);
+    });
+});
+
+
+describe('Git.push', () => {
+    it ('pushes to the current branch', () => {
+        const branch = TestHelpers.Faker.Text.randomString();
+        execSync.mockImplementation(() => `* ${branch}`);
+        Git.push();
+        expect(execSync).toHaveBeenCalledWith(`git push -u origin ${branch}`);
+    });
+});

package/test/helpers/index.js

@@ -0,0 +1,63 @@
+const { FirstNames, LastNames} = require('./names');
+
+
+const Faker = {
+    Math: {
+        randomNumber: function(max=1000) {
+            return Math.ceil(Math.random() * max)
+        }
+    },
+
+
+    Text: {
+        randomString: function(length=10) {
+            let result = '';
+            const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+            const charactersLength = characters.length;
+            while (result.length < length) {
+                let idx = Faker.Math.randomNumber(charactersLength-1);
+                result += characters.charAt(idx);
+            }
+            return result;
+        },
+
+
+        randomSentence({ numWords=5, maxWordLength=10, punctuationOptions='.!?', includeComma=true }={}) {
+            const words = [...Array(numWords)].map(() => Faker.Text.randomString(maxWordLength));
+
+            if (includeComma && numWords > 2) {
+                const commaIdx = Math.floor(Math.random() * (numWords - 1));
+                words[commaIdx] = `${words[commaIdx]},`;
+            }
+
+            const puncIdx     = Math.floor(Math.random() * punctuationOptions.length);
+            const punctuation = punctuationOptions[puncIdx];
+
+            return words.join(' ') + punctuation;
+        }
+    },
+
+
+    User: {
+        randomName: function() {
+            return `${this.randomFirstName()} ${this.randomLastName()}`;
+        },
+
+
+        randomFirstName: function() {
+            const idx = Faker.Math.randomNumber(FirstNames.length-1);
+            return FirstNames[idx];
+        },
+
+
+        randomLastName: function() {
+            const idx = Faker.Math.randomNumber(LastNames.length-1);
+            return LastNames[idx];
+        }
+    }
+};
+
+
+module.exports = {
+  Faker
+}

package/test/helpers/names.js

@@ -0,0 +1,311 @@
+const FirstNames = [
+    "Aaron",
+    "Abigail",
+    "Adam",
+    "Alan",
+    "Albert",
+    "Alexander",
+    "Alexis",
+    "Alice",
+    "Amanda",
+    "Amber",
+    "Amy",
+    "Andrea",
+    "Andrew",
+    "Angela",
+    "Ann",
+    "Anna",
+    "Anthony",
+    "Arthur",
+    "Ashley",
+    "Austin",
+    "Barbara",
+    "Benjamin",
+    "Betty",
+    "Beverly",
+    "Billy",
+    "Bobby",
+    "Bradley",
+    "Brandon",
+    "Brenda",
+    "Brian",
+    "Brittany",
+    "Bruce",
+    "Bryan",
+    "Caleb",
+    "Carl",
+    "Carol",
+    "Carolyn",
+    "Catherine",
+    "Charles",
+    "Charlotte",
+    "Cheryl",
+    "Christian",
+    "Christina",
+    "Christine",
+    "Christopher",
+    "Cynthia",
+    "Daniel",
+    "Danielle",
+    "David",
+    "Deborah",
+    "Debra",
+    "Denise",
+    "Dennis",
+    "Diana",
+    "Diane",
+    "Donald",
+    "Donna",
+    "Doris",
+    "Dorothy",
+    "Douglas",
+    "Dylan",
+    "Edward",
+    "Elijah",
+    "Elizabeth",
+    "Emily",
+    "Emma",
+    "Eric",
+    "Ethan",
+    "Evelyn",
+    "Frances",
+    "Frank",
+    "Gabriel",
+    "Gary",
+    "George",
+    "Gerald",
+    "Gloria",
+    "Grace",
+    "Gregory",
+    "Hannah",
+    "Harold",
+    "Heather",
+    "Helen",
+    "Henry",
+    "Isabella",
+    "Jack",
+    "Jacob",
+    "Jacqueline",
+    "James",
+    "Janet",
+    "Janice",
+    "Jason",
+    "Jean",
+    "Jeffrey",
+    "Jennifer",
+    "Jeremy",
+    "Jerry",
+    "Jesse",
+    "Jessica",
+    "Joan",
+    "Joe",
+    "John",
+    "Jonathan",
+    "Jordan",
+    "Jose",
+    "Joseph",
+    "Joshua",
+    "Joyce",
+    "Juan",
+    "Judith",
+    "Judy",
+    "Julia",
+    "Julie",
+    "Justin",
+    "Karen",
+    "Katherine",
+    "Kathleen",
+    "Kathryn",
+    "Kayla",
+    "Keith",
+    "Kelly",
+    "Kenneth",
+    "Kevin",
+    "Kimberly",
+    "Kyle",
+    "Larry",
+    "Laura",
+    "Lauren",
+    "Lawrence",
+    "Liam",
+    "Linda",
+    "Lisa",
+    "Logan",
+    "Lori",
+    "Lucas",
+    "Madison",
+    "Margaret",
+    "Maria",
+    "Marilyn",
+    "Mark",
+    "Martha",
+    "Mary",
+    "Mason",
+    "Matthew",
+    "Megan",
+    "Melissa",
+    "Michael",
+    "Michelle",
+    "Nancy",
+    "Natalie",
+    "Nathan",
+    "Nicholas",
+    "Nicole",
+    "Noah",
+    "Olivia",
+    "Pamela",
+    "Patricia",
+    "Patrick",
+    "Paul",
+    "Peter",
+    "Rachel",
+    "Randy",
+    "Raymond",
+    "Rebecca",
+    "Richard",
+    "Robert",
+    "Roger",
+    "Ronald",
+    "Roy",
+    "Russell",
+    "Ruth",
+    "Ryan",
+    "Samantha",
+    "Samuel",
+    "Sandra",
+    "Sara",
+    "Sarah",
+    "Scott",
+    "Sean",
+    "Sharon",
+    "Shirley",
+    "Sophia",
+    "Stephanie",
+    "Stephen",
+    "Steven",
+    "Susan",
+    "Teresa",
+    "Terry",
+    "Theresa",
+    "Thomas",
+    "Tiffany",
+    "Timothy",
+    "Tyler",
+    "Victoria",
+    "Vincent",
+    "Virginia",
+    "Walter",
+    "Wayne",
+    "William",
+    "Willie",
+    "Zachary",
+];
+
+
+const LastNames = [
+    "Adams",
+    "Allen",
+    "Alvarez",
+    "Anderson",
+    "Bailey",
+    "Baker",
+    "Bennett",
+    "Brooks",
+    "Brown",
+    "Campbell",
+    "Carter",
+    "Castillo",
+    "Chavez",
+    "Clark",
+    "Collins",
+    "Cook",
+    "Cooper",
+    "Cox",
+    "Cruz",
+    "Davis",
+    "Diaz",
+    "Edwards",
+    "Evans",
+    "Flores",
+    "Foster",
+    "Garcia",
+    "Gomez",
+    "Gonzalez",
+    "Gray",
+    "Green",
+    "Gutierrez",
+    "Hall",
+    "Harris",
+    "Hernandez",
+    "Hill",
+    "Howard",
+    "Hughes",
+    "Jackson",
+    "James",
+    "Jimenez,",
+    "Johnson",
+    "Jones",
+    "Kelly",
+    "Kim",
+    "King",
+    "Lee",
+    "Lewis",
+    "Long",
+    "Lopez",
+    "Martin",
+    "Martinez",
+    "Mendoza",
+    "Miller",
+    "Mitchell",
+    "Moore",
+    "Morales",
+    "Morgan",
+    "Morris",
+    "Murphy",
+    "Myers",
+    "Nelson",
+    "Nguyen",
+    "Ortiz",
+    "Parker",
+    "Patel",
+    "Perez",
+    "Peterson",
+    "Phillips",
+    "Price",
+    "Ramirez",
+    "Ramos",
+    "Reed",
+    "Reyes",
+    "Richardson",
+    "Rivera",
+    "Roberts",
+    "Robinson",
+    "Rodriguez",
+    "Rogers",
+    "Ross",
+    "Ruiz",
+    "Sanchez",
+    "Sanders",
+    "Scott",
+    "Smith",
+    "Stewart",
+    "Taylor",
+    "Thomas",
+    "Thompson",
+    "Torres",
+    "Turner",
+    "Walker",
+    "Ward",
+    "Watson",
+    "White",
+    "Williams",
+    "Wilson",
+    "Wood",
+    "Wright"
+];
+
+
+module.exports = {
+    FirstNames,
+    LastNames,
+};

package/test/increment.test.js

@@ -0,0 +1,145 @@
+const   fs          = require('fs');
+const { increment } = require('../lib/release/increment');
+const   Git         = require('../lib/release/git');
+const   TestHelpers = require('./helpers');
+const   utils       = require('../lib/release/utils');
+
+
+jest.mock('../lib/release/git', () => {
+    return { add: jest.fn(), createBranch: jest.fn(), commit: jest.fn(), pull: jest.fn(), push: jest.fn() };
+});
+jest.mock('../lib/release/utils', () => {
+    return { getCurrentVersion: jest.fn(), confirmContinue: jest.fn() };
+});
+jest.mock('fs', () => {
+    return { readFileSync: jest.fn(), writeFileSync: jest.fn() };
+});
+
+
+let   config;
+let   version;
+const packageJsonPath = `${process.cwd()}/package.json`;
+beforeEach(() => {
+    jest.resetAllMocks();
+    version = [TestHelpers.Faker.Math.randomNumber(),
+               TestHelpers.Faker.Math.randomNumber(),
+               TestHelpers.Faker.Math.randomNumber()];
+    utils.getCurrentVersion.mockImplementation(() => version);
+    utils.confirmContinue.mockImplementation(() => true);
+
+    config = {
+      [TestHelpers.Faker.Text.randomString()]: TestHelpers.Faker.Text.randomString(),
+      [TestHelpers.Faker.Text.randomString()]: TestHelpers.Faker.Text.randomString(),
+      version: version.join('.')
+    }
+    fs.readFileSync.mockImplementation(() => JSON.stringify(config, null, 4));
+});
+
+
+describe('increment', () => {
+    it ('runs steps in the proper order', async () => {
+        await increment('point');
+
+        expect(Git.pull).toHaveBeenCalledTimes(1);
+        expect(utils.getCurrentVersion).toHaveBeenCalledTimes(1);
+        expect(Git.pull).toHaveBeenCalledBefore(utils.getCurrentVersion);
+
+        expect(utils.confirmContinue).toHaveBeenCalledTimes(1);
+        expect(utils.getCurrentVersion).toHaveBeenCalledBefore(utils.confirmContinue);
+
+        expect(Git.createBranch).toHaveBeenCalledTimes(1);
+        expect(utils.confirmContinue).toHaveBeenCalledBefore(Git.createBranch);
+
+        expect(fs.readFileSync).toHaveBeenCalledTimes(1);
+        expect(Git.createBranch).toHaveBeenCalledBefore(fs.readFileSync);
+
+        expect(fs.writeFileSync).toHaveBeenCalledTimes(1);
+        expect(fs.readFileSync).toHaveBeenCalledBefore(fs.writeFileSync);
+
+        expect(Git.push).toHaveBeenCalledTimes(1);
+        expect(fs.writeFileSync).toHaveBeenCalledBefore(Git.push);
+    });
+
+
+    describe('getNewVersion', () => {
+        it ('increments the major version', async () => {
+            await increment('major');
+            const newVersion = [...version];
+            newVersion[0]    = newVersion[0] + 1;
+            newVersion[1]    = 0;
+            newVersion[2]    = 0;
+            expect(Git.createBranch).toHaveBeenCalledWith(`release/${newVersion.join('.')}`);
+        });
+
+        it ('increments the minor version', async () => {
+            await increment('minor');
+            const newVersion = [...version];
+            newVersion[1]    = newVersion[1] + 1;
+            newVersion[2]    = 0;
+            expect(Git.createBranch).toHaveBeenCalledWith(`release/${newVersion.join('.')}`);
+        });
+
+        it ('increments the point version', async () => {
+            await increment('point');
+            const newVersion = [...version];
+            newVersion[2]    = newVersion[2] + 1;
+            expect(Git.createBranch).toHaveBeenCalledWith(`release/${newVersion.join('.')}`);
+        });
+
+        it ('throws an error for an invalid type', async () => {
+            expect(async () => {await increment('foo')}).rejects.toThrow();;
+        });
+    });
+
+
+    describe('confirmation', () => {
+        it ('asks the user if they want to upgrade to the new version', async () => {
+            await increment('point');
+            const newVersion = [version[0], version[1], version[2]+1].join('.');
+            expect(utils.confirmContinue).toHaveBeenCalledWith(`Do you want to create version ${newVersion}?`);
+        });
+
+        it ('does not continue if the user responds "n"', async () => {
+            utils.confirmContinue.mockImplementation(() => false);
+            await increment('point');
+
+            expect(Git.createBranch).not.toHaveBeenCalled();
+            expect(fs.readFileSync).not.toHaveBeenCalled();
+            expect(fs.writeFileSync).not.toHaveBeenCalled();
+            expect(Git.push).not.toHaveBeenCalled();
+        });
+    });
+
+
+    describe('createBranch', () => {
+        it ('creates a release branch for the new version', async () => {
+            await increment('point');
+            const newVersion = [version[0], version[1], version[2]+1].join('.');
+            expect(Git.createBranch).toHaveBeenCalledWith(`release/${newVersion}`);
+        });
+    });
+
+
+    describe('updatePackageVersion', () => {
+        it ('writes the new package version to package.json', async () => {
+            const newVersion = [version[0], version[1], version[2]+1].join('.');
+            const newConfig  = structuredClone(config);
+            newConfig.version = newVersion;
+
+            await increment('point');
+            
+            expect(fs.writeFileSync).toHaveBeenCalledWith(packageJsonPath, JSON.stringify(newConfig, null, 4));
+        });
+
+        it ('adds package.json to be committed', async () => {
+            await increment('point');
+            expect(Git.add).toHaveBeenCalledWith(packageJsonPath);
+        });
+
+        it ('adds a descriptive commit message', async () => {
+            const newVersion = [version[0], version[1], version[2]+1].join('.');
+            await increment('point');
+            expect(Git.commit).toHaveBeenCalledWith(`build: incrementing build to ${newVersion}`);
+        });
+    });
+});

package/test/release.test.js

@@ -0,0 +1,72 @@
+const { release }   = require('../lib/release/release');
+const   Git         = require('../lib/release/git');
+const   TestHelpers = require('./helpers');
+const   utils       = require('../lib/release/utils');
+
+
+jest.mock('../lib/release/git', () => {
+    return { pull: jest.fn(), forceRemotePush: jest.fn(), branches: jest.fn() };
+});
+jest.mock('../lib/release/utils', () => {
+    return { getCurrentVersion: jest.fn(), confirmContinue: jest.fn() };
+});
+
+
+let env;
+let version;
+beforeEach(() => {
+    jest.resetAllMocks();
+    env = TestHelpers.Faker.Text.randomString();
+    version = [TestHelpers.Faker.Math.randomNumber(),
+               TestHelpers.Faker.Math.randomNumber(),
+               TestHelpers.Faker.Math.randomNumber()];
+    utils.getCurrentVersion.mockImplementation(() => version);
+    utils.confirmContinue.mockImplementation(() => true);
+});
+
+
+describe('release', () => {
+    it ('runs steps in the proper order', async () => {
+        await release(env);
+
+        expect(Git.pull).toHaveBeenCalledTimes(1)
+        expect(utils.confirmContinue).toHaveBeenCalledTimes(1)
+        expect(Git.pull).toHaveBeenCalledBefore(utils.confirmContinue)
+
+        expect(Git.forceRemotePush).toHaveBeenCalledTimes(1)
+        expect(utils.confirmContinue).toHaveBeenCalledBefore(Git.forceRemotePush)
+    });
+
+    it ('defaults to the current version', async () => {
+        await release(env);
+        const versionStr = version.join('.');
+        expect(utils.confirmContinue).toHaveBeenCalledWith(`Do you want to release version ${versionStr} to ${env}?`);
+        expect(Git.forceRemotePush).toHaveBeenCalledWith(`release/${versionStr}`, `release/${env}`);
+    });
+    
+    it ('accepts an alternate version', async () => {
+        const altVersion = [TestHelpers.Faker.Math.randomNumber(),
+                            TestHelpers.Faker.Math.randomNumber(),
+                            TestHelpers.Faker.Math.randomNumber()].join('.');
+        Git.branches.mockImplementation(() => [`origin/release/${version.join('.')}`, `origin/release/${altVersion}`, TestHelpers.Faker.Text.randomString()]);
+        await release(env, altVersion);
+        expect(utils.confirmContinue).toHaveBeenCalledWith(`Do you want to release version ${altVersion} to ${env}?`);
+        expect(Git.forceRemotePush).toHaveBeenCalledWith(`release/${altVersion}`, `release/${env}`);
+    });
+
+    it ('does not continue if the user responds "n"', async () => {
+        utils.confirmContinue.mockImplementation(() => false);
+        await release(env);
+
+        expect(Git.forceRemotePush).not.toHaveBeenCalled();
+    });
+
+    it ('throws an error if the version does not exist', async () => {
+        const altVersion = [TestHelpers.Faker.Math.randomNumber(),
+                            TestHelpers.Faker.Math.randomNumber(),
+                            TestHelpers.Faker.Math.randomNumber()].join('.');
+        Git.branches.mockImplementation(() => [`origin/release/${version.join('.')}`, TestHelpers.Faker.Text.randomString()]);
+        expect(async () => { await release(env, altVersion)}).rejects.toThrow();
+    });
+});
+

package/test/utils.test.js

@@ -0,0 +1,148 @@
+const Git         = require('../lib/release/git');
+const TestHelpers = require('./helpers');
+const utils       = require('../lib/release/utils');
+const readline    = require('node:readline/promises');
+
+
+jest.mock('node:readline/promises', () => {
+    return { createInterface: jest.fn(), question: jest.fn(), close: jest.fn() };
+});
+
+jest.mock('../lib/release/git', () => {
+    return {branches: jest.fn()};
+});
+
+
+beforeEach(() => {
+    jest.resetAllMocks();
+    readline.createInterface.mockImplementation(() => {
+        return {question: readline.question, close: readline.close};
+    });
+});
+
+
+describe('getCurrentVersion', () => {
+    const major1 = TestHelpers.Faker.Math.randomNumber();
+    const minor1 = TestHelpers.Faker.Math.randomNumber();
+    const point1 = TestHelpers.Faker.Math.randomNumber();
+    const diff1  = TestHelpers.Faker.Math.randomNumber();
+    const diff2  = TestHelpers.Faker.Math.randomNumber();
+
+    const b1     = `origin/release/${major1}/${minor1}/${point1}`;
+
+    it ('sorts branches by primary version first', () => {
+        const b2 = `origin/release/${major1 + diff1        }.${minor1 + diff2}.${point1 + diff1}`;
+        const b3 = `origin/release/${major1 + diff1 + diff2}.${minor1        }.${point1}`;
+        Git.branches.mockImplementation(() => [b1, b3, b2]);
+        expect(utils.getCurrentVersion()).toEqual([major1+diff1+diff2, minor1, point1]);
+    });
+
+    it ('sorts branches by minor version second', () => {
+        const b2 = `origin/release/${major1 + diff1}.${minor1 + diff1 + diff2}.${point1}`;
+        const b3 = `origin/release/${major1 + diff1}.${minor1 + diff1        }.${point1 + diff1}`;
+        Git.branches.mockImplementation(() => [b1, b3, b2]);
+        expect(utils.getCurrentVersion()).toEqual([major1+diff1, minor1+diff1+diff2, point1]);
+    });
+
+    it ('sorts branches by point version last', () => {
+        const b2 = `origin/release/${major1 + diff1}.${minor1 + diff1}.${point1 + diff1}`;
+        const b3 = `origin/release/${major1 + diff1}.${minor1 + diff1}.${point1 + diff1 + diff2}`;
+        Git.branches.mockImplementation(() => [b1, b3, b2]);
+        expect(utils.getCurrentVersion()).toEqual([major1+diff1, minor1+diff1, point1+diff1+diff2]);
+    });
+
+    it ('ignores branches that don not fit the pattern', () => {
+        const b2 = `origin/release/${major1 + diff1}.${minor1}.${point1}`;
+        const b3 = `origin/release/${TestHelpers.Faker.Text.randomString()}`;
+        const b4 = TestHelpers.Faker.Text.randomString();
+        Git.branches.mockImplementation(() => [b1, b3, b2, b4]);
+        expect(utils.getCurrentVersion()).toEqual([major1+diff1, minor1, point1]);
+    });
+
+    it ('defaults to 1.0.0', () => {
+        const b2 = `origin/release/${TestHelpers.Faker.Text.randomString()}`;
+        const b3 = `origin/release/${TestHelpers.Faker.Text.randomString()}`;
+        const b4 = TestHelpers.Faker.Text.randomString();
+        Git.branches.mockImplementation(() => [b3, b2, b4]);
+        expect(utils.getCurrentVersion()).toEqual([1, 0, 0]);
+    });
+});
+
+
+describe('getInput', () => {
+    let question;
+    let numOptions;
+    let options;
+    let answer;
+    beforeEach(() => {
+        question   = TestHelpers.Faker.Text.randomSentence();
+        numOptions = TestHelpers.Faker.Math.randomNumber(10);
+        options    = [...Array(numOptions)].map(() => TestHelpers.Faker.Text.randomString());
+        answer     = options[Math.floor(Math.random() * numOptions)];
+        readline.question.mockImplementation(() => answer);
+    });
+
+    it ('asks the question and appends the options', async () => {
+        await utils.getInput(question, options)
+        expect(readline.question).toHaveBeenCalledWith(`${question} [${options.join(',')}] `);
+    });
+
+    it ('asks the question once if it gets a valid answer', async () => {
+        const theAnswer = await utils.getInput(question, options)
+        expect(readline.question).toHaveBeenCalledTimes(1);
+        expect(theAnswer).toEqual(answer);
+    });
+
+    it ('closes the input after getting an answer', async () => {
+        await utils.getInput(question, options)
+        expect(readline.question).toHaveBeenCalledTimes(1);
+        expect(readline.close).toHaveBeenCalledTimes(1);
+        expect(readline.question).toHaveBeenCalledBefore(readline.close);
+    });
+
+    it ('repeats the question until it gets a valid answer', async () => {
+        const numAttempts   = TestHelpers.Faker.Math.randomNumber(10);
+        let   attemptNumber = 1;
+
+        readline.question.mockImplementation(() => {
+            if (attemptNumber == numAttempts) return answer;
+            attemptNumber = attemptNumber + 1;
+            return TestHelpers.Faker.Text.randomString();
+        });
+
+        const theAnswer = await utils.getInput(question, options)
+        expect(readline.question).toHaveBeenCalledTimes(numAttempts);
+        expect(readline.close).toHaveBeenCalledTimes(numAttempts);
+        expect(theAnswer).toEqual(answer);
+
+        for(let i=1; i <= numAttempts; i++){
+            expect(readline.question).toHaveBeenNthCalledWith(i, `${question} [${options.join(',')}] `);
+        }
+    });
+});
+
+
+describe('confirmContinue', () => {
+    let question;
+    beforeEach(() => {
+        question = TestHelpers.Faker.Text.randomSentence();
+    });
+
+    it ('asks the question with "y" or "n" as options', async () => {
+        readline.question.mockImplementation(() => 'y');
+        await utils.confirmContinue(question);
+        expect(readline.question).toHaveBeenCalledWith(`${question} [y,n] `);
+    });
+
+    it ('returns true if the user answers "y"', async () => {
+        readline.question.mockImplementation(() => 'y');
+        const confirmed = await utils.confirmContinue(question);
+        expect(confirmed).toBeTruthy();
+    });
+
+    it ('returns false if the user answers "n"', async () => {
+        readline.question.mockImplementation(() => 'n');
+        const confirmed = await utils.confirmContinue(question);
+        expect(confirmed).toBeFalsy();
+    });
+});