doc-detective/.github/tdd-coverage

# Run tests with coverage
npm run test:coverage
 
# Verify coverage hasn't decreased
npm run test:coverage:ratchet

const sinon = require("sinon");
(async () => {
  const { expect } = await import("chai");
  const { functionUnderTest } = require("../src/module");
  describe("functionUnderTest", function () {
    describe("input validation", function () {
      it("should throw error when required param missing", function () {
        expect(() => functionUnderTest()).to.throw();
      });
    });
    describe("happy path", function () {
      it("should return expected result for valid input", function () {
        const result = functionUnderTest({ validInput: true });
        expect(result).to.deep.equal(expectedOutput);
      });
    });
    describe("edge cases", function () {
      it("should handle boundary condition", function () {
        // test edge case
      });
    });
  });
})();

# Run all tests
npm test
 
# Run tests with coverage report
npm run test:coverage
 
# Run coverage ratchet check
npm run test:coverage:ratchet
 
# Generate HTML coverage report
npm run test:coverage:html

it("should handle async operation", async function () {
  const result = await asyncFunction();
  expect(result).to.exist;
});

const stub = sinon.stub(fs, "readFileSync").returns("mock content");
try {
  const result = functionUnderTest();
  expect(result).to.equal("expected");
} finally {
  stub.restore();
}

it("should throw on invalid input", function () {
  expect(() => functionUnderTest(null)).to.throw(/error message/);
});

it("should transform v2 object to v3", function () {
  const result = transformToSchemaKey({
    currentSchema: "schema_v2",
    targetSchema: "schema_v3",
    object: v2Object,
  });
  expect(result.newProperty).to.equal(expectedValue);
});