feat: ✨ initial setup, fake source for testing

Author: cif

package-lock.json

@@ -4,8 +4,13 @@
   "description": "A plugin for vitest that generates a coverage summary in json format",
   "main": "index.js",
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "coverage": "vitest run --coverage"
   },
   "author": "Typeguard Inc.",
-  "license": "MIT"
+  "license": "MIT",
+  "devDependencies": {
+    "@vitest/coverage-v8": "^3.2.4",
+    "vitest": "^3.2.4"
+  }
 }

package.json

@@ -0,0 +1,31 @@
+export function calculateBananaRipeness(bananaColor) {
+  if (bananaColor === "green") {
+    return "not ready yet, you impatient monkey!";
+  } else if (bananaColor === "yellow") {
+    return "perfect for eating!";
+  } else if (bananaColor === "brown") {
+    return "time to make banana bread!";
+  } else {
+    return "that's not a banana color, silly!";
+  }
+}
+
+export function countBananasInBunch(bunchSize) {
+  let totalBananas = 0;
+  for (let i = 0; i < bunchSize; i++) {
+    totalBananas += 1;
+  }
+  return totalBananas;
+}
+
+export function estimateBananaCalories(bananaCount) {
+  const caloriesPerBanana = 105;
+  return bananaCount * caloriesPerBanana;
+}
+
+// This function won't be tested to achieve ~85% coverage
+export function secretBananaRecipe() {
+  const ingredients = ["bananas", "flour", "sugar", "eggs"];
+  const secretIngredient = "love";
+  return `Mix ${ingredients.join(", ")} and add ${secretIngredient}`;
+}

test-src/bananaCalculator.js

@@ -0,0 +1,48 @@
+import { describe, it, expect } from "vitest";
+import {
+  calculateBananaRipeness,
+  countBananasInBunch,
+  estimateBananaCalories,
+} from "./bananaCalculator.js";
+
+describe("Banana Calculator", () => {
+  describe("calculateBananaRipeness", () => {
+    it("should return message for green bananas", () => {
+      expect(calculateBananaRipeness("green")).toBe(
+        "not ready yet, you impatient monkey!"
+      );
+    });
+
+    it("should return message for yellow bananas", () => {
+      expect(calculateBananaRipeness("yellow")).toBe("perfect for eating!");
+    });
+
+    it("should return message for brown bananas", () => {
+      expect(calculateBananaRipeness("brown")).toBe(
+        "time to make banana bread!"
+      );
+    });
+
+    it("should return message for unknown color", () => {
+      expect(calculateBananaRipeness("purple")).toBe(
+        "that's not a banana color, silly!"
+      );
+    });
+  });
+
+  describe("countBananasInBunch", () => {
+    it("should count bananas correctly", () => {
+      expect(countBananasInBunch(5)).toBe(5);
+      expect(countBananasInBunch(0)).toBe(0);
+      expect(countBananasInBunch(10)).toBe(10);
+    });
+  });
+
+  describe("estimateBananaCalories", () => {
+    it("should calculate calories correctly", () => {
+      expect(estimateBananaCalories(1)).toBe(105);
+      expect(estimateBananaCalories(3)).toBe(315);
+      expect(estimateBananaCalories(0)).toBe(0);
+    });
+  });
+});

test-src/bananaCalculator.test.js

@@ -0,0 +1,37 @@
+export function throwPizzaShuriken(target) {
+  if (target === "enemy") {
+    return "Pizza shuriken hits! Enemy is now covered in cheese!";
+  } else if (target === "friend") {
+    return "Friendly pizza shuriken! Sharing is caring!";
+  } else {
+    return "Pizza shuriken missed! The floor is now delicious.";
+  }
+}
+
+export function calculatePizzaSlices(pizzaDiameter) {
+  const baseSlices = 8;
+  if (pizzaDiameter > 16) {
+    return baseSlices * 2;
+  } else if (pizzaDiameter > 12) {
+    return baseSlices;
+  } else {
+    return baseSlices / 2;
+  }
+}
+
+export function ninjaPizzaDelivery(distance) {
+  const deliveryTime = distance * 2;
+  if (deliveryTime < 10) {
+    return "Lightning fast ninja delivery!";
+  } else if (deliveryTime < 20) {
+    return "Standard ninja speed delivery.";
+  } else {
+    return "Ninja got lost in the shadows...";
+  }
+}
+
+// This function won't be tested to achieve ~85% coverage
+export function secretNinjaTechnique() {
+  const techniques = ["shadow clone", "pizza jutsu", "cheese transformation"];
+  return `Mastered: ${techniques.join(", ")}`;
+}

test-src/pizzaNinja.js

@@ -0,0 +1,56 @@
+import { describe, it, expect } from "vitest";
+import {
+  throwPizzaShuriken,
+  calculatePizzaSlices,
+  ninjaPizzaDelivery,
+} from "./pizzaNinja.js";
+
+describe("Pizza Ninja", () => {
+  describe("throwPizzaShuriken", () => {
+    it("should hit enemy with pizza shuriken", () => {
+      expect(throwPizzaShuriken("enemy")).toBe(
+        "Pizza shuriken hits! Enemy is now covered in cheese!"
+      );
+    });
+
+    it("should share pizza with friend", () => {
+      expect(throwPizzaShuriken("friend")).toBe(
+        "Friendly pizza shuriken! Sharing is caring!"
+      );
+    });
+
+    it("should miss other targets", () => {
+      expect(throwPizzaShuriken("wall")).toBe(
+        "Pizza shuriken missed! The floor is now delicious."
+      );
+    });
+  });
+
+  describe("calculatePizzaSlices", () => {
+    it("should calculate slices for large pizza", () => {
+      expect(calculatePizzaSlices(18)).toBe(16);
+    });
+
+    it("should calculate slices for medium pizza", () => {
+      expect(calculatePizzaSlices(14)).toBe(8);
+    });
+
+    it("should calculate slices for small pizza", () => {
+      expect(calculatePizzaSlices(10)).toBe(4);
+    });
+  });
+
+  describe("ninjaPizzaDelivery", () => {
+    it("should deliver lightning fast", () => {
+      expect(ninjaPizzaDelivery(3)).toBe("Lightning fast ninja delivery!");
+    });
+
+    it("should deliver at standard speed", () => {
+      expect(ninjaPizzaDelivery(8)).toBe("Standard ninja speed delivery.");
+    });
+
+    it("should get lost on long distances", () => {
+      expect(ninjaPizzaDelivery(15)).toBe("Ninja got lost in the shadows...");
+    });
+  });
+});

test-src/pizzaNinja.test.js

@@ -0,0 +1,35 @@
+export function launchHamsterRocket(hamsterName) {
+  if (hamsterName === "Astro") {
+    return "Astro is ready for space exploration!";
+  } else if (hamsterName === "Cosmo") {
+    return "Cosmo is floating in zero gravity!";
+  } else {
+    return "Unknown hamster astronaut!";
+  }
+}
+
+export function calculateHamsterOrbit(planetSize) {
+  const orbitTime = planetSize * 3.14;
+  if (orbitTime < 10) {
+    return "Quick hamster orbit!";
+  } else if (orbitTime < 30) {
+    return "Standard hamster orbit.";
+  } else {
+    return "Long hamster journey through space!";
+  }
+}
+
+export function feedSpaceHamster(foodType) {
+  const spaceFoods = ["moon cheese", "star seeds", "galaxy pellets"];
+  if (spaceFoods.includes(foodType)) {
+    return `Hamster loves ${foodType}!`;
+  } else {
+    return "Hamster prefers space food!";
+  }
+}
+
+// This function won't be tested to achieve ~85% coverage
+export function hamsterSpaceSuit() {
+  const suitParts = ["helmet", "oxygen tank", "mini jetpack"];
+  return `Space hamster equipped with: ${suitParts.join(", ")}`;
+}

test-src/spaceHamster.js

@@ -0,0 +1,64 @@
+import { describe, it, expect } from "vitest";
+import {
+  launchHamsterRocket,
+  calculateHamsterOrbit,
+  feedSpaceHamster,
+} from "./spaceHamster.js";
+
+describe("Space Hamster", () => {
+  describe("launchHamsterRocket", () => {
+    it("should launch Astro hamster", () => {
+      expect(launchHamsterRocket("Astro")).toBe(
+        "Astro is ready for space exploration!"
+      );
+    });
+
+    it("should launch Cosmo hamster", () => {
+      expect(launchHamsterRocket("Cosmo")).toBe(
+        "Cosmo is floating in zero gravity!"
+      );
+    });
+
+    it("should handle unknown hamster", () => {
+      expect(launchHamsterRocket("Fluffy")).toBe("Unknown hamster astronaut!");
+    });
+  });
+
+  describe("calculateHamsterOrbit", () => {
+    it("should calculate quick orbit", () => {
+      expect(calculateHamsterOrbit(2)).toBe("Quick hamster orbit!");
+    });
+
+    it("should calculate standard orbit", () => {
+      expect(calculateHamsterOrbit(8)).toBe("Standard hamster orbit.");
+    });
+
+    it("should calculate long orbit", () => {
+      expect(calculateHamsterOrbit(12)).toBe(
+        "Long hamster journey through space!"
+      );
+    });
+  });
+
+  describe("feedSpaceHamster", () => {
+    it("should feed moon cheese", () => {
+      expect(feedSpaceHamster("moon cheese")).toBe(
+        "Hamster loves moon cheese!"
+      );
+    });
+
+    it("should feed star seeds", () => {
+      expect(feedSpaceHamster("star seeds")).toBe("Hamster loves star seeds!");
+    });
+
+    it("should feed galaxy pellets", () => {
+      expect(feedSpaceHamster("galaxy pellets")).toBe(
+        "Hamster loves galaxy pellets!"
+      );
+    });
+
+    it("should reject non-space food", () => {
+      expect(feedSpaceHamster("carrots")).toBe("Hamster prefers space food!");
+    });
+  });
+});

test-src/spaceHamster.test.js

@@ -0,0 +1,11 @@
+import { defineConfig } from "vitest/config";
+
+export default defineConfig({
+  test: {
+    coverage: {
+      provider: "v8",
+      reporter: ["text", "json"],
+      reportsDirectory: "./coverage",
+    },
+  },
+});