feat: add comprehensive test suite and CI test workflow

Adds Jest-based tests across three layers:

API handler tests (tests/api/):
- spacecrafts, launchers, customer_satellites, centres, spacecraft_missions
  - Correct HTTP status and Content-Type on all endpoints
  - Correct record counts returned with no filters
  - Filter behaviour: case-insensitive, composable, unknown params ignored,
    empty array (not 404) when no matches
- stats: all top-level sections present; every distribution sums to its
  collection total; total_mass_kg is positive
- spacecrafts/:id and spacecraft_missions/:id: valid ID returns record,
  non-existent ID returns 404, non-integer returns 400, _links present
  and correctly formatted

Data integrity tests (tests/data/integrity.test.js):
- All IDs are unique positive integers
- No trailing whitespace in name fields
- All non-null dates match ISO 8601 format
- All non-null numeric fields are positive numbers
- status and orbit_type constrained to known enums
- country names are title case (regression guard against all-caps)
- centres use lowercase field names (regression against Place/State)
- No values in wrong fields (mass field cannot be a string name)

CI (`.github/workflows/test.yml`):
- Runs on every PR and push to master
- Installs deps, runs jest, then runs schema validation
- Both must pass for CI to go green

Test runner: Jest 29 (devDependency only, zero runtime impact).
All tests pass against current normalized data.

Author: AdityaAsopa

.github/workflows/test.yml

@@ -0,0 +1,28 @@
+name: Tests
+
+on:
+  pull_request:
+  push:
+    branches:
+      - master
+
+jobs:
+  test:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: "20"
+          cache: "npm"
+
+      - name: Install dependencies
+        run: npm install
+
+      - name: Run tests
+        run: npm test
+
+      - name: Validate data schemas
+        run: npm run validate

package.json

@@ -7,10 +7,15 @@
     "author": "isro",
     "license": "MIT",
     "scripts": {
+        "test": "jest --testPathPattern=tests/",
         "validate": "node scripts/validate_schemas.js"
     },
+    "jest": {
+        "testEnvironment": "node"
+    },
     "dependencies": {},
     "devDependencies": {
-        "ajv": "^8.17.1"
+        "ajv": "^8.17.1",
+        "jest": "^29.7.0"
     }
 }

tests/api/centres.test.js

@@ -0,0 +1,41 @@
+const handler = require("../../api/centres");
+const { mockReq, mockRes } = require("../helpers/mock");
+
+describe("GET /api/centres", () => {
+  test("returns 200 with application/json header", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    expect(res._status).toBe(200);
+    expect(res._headers["Content-Type"]).toBe("application/json");
+  });
+
+  test("response has centres wrapper key with 44 records", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    expect(res._body).toHaveProperty("centres");
+    expect(res._body.centres).toHaveLength(44);
+  });
+
+  test("each record has consistent lowercase field names", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    for (const r of res._body.centres) {
+      expect(r).not.toHaveProperty("Place");
+      expect(r).not.toHaveProperty("State");
+      expect(r).toHaveProperty("id");
+      expect(r).toHaveProperty("name");
+    }
+  });
+
+  test("filters by state (case-insensitive)", async () => {
+    const res1 = mockRes();
+    await handler(mockReq({ state: "Karnataka" }), res1);
+    const res2 = mockRes();
+    await handler(mockReq({ state: "karnataka" }), res2);
+    expect(res1._body.centres.length).toBeGreaterThan(0);
+    expect(res1._body.centres).toEqual(res2._body.centres);
+    for (const r of res1._body.centres) {
+      expect(r.state.toLowerCase()).toBe("karnataka");
+    }
+  });
+});

tests/api/customer_satellites.test.js

@@ -0,0 +1,58 @@
+const handler = require("../../api/customer_satellites");
+const { mockReq, mockRes } = require("../helpers/mock");
+
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+
+describe("GET /api/customer_satellites", () => {
+  test("returns 200 with application/json header", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    expect(res._status).toBe(200);
+    expect(res._headers["Content-Type"]).toBe("application/json");
+  });
+
+  test("response has customer_satellites wrapper key with 75 records", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    expect(res._body).toHaveProperty("customer_satellites");
+    expect(res._body.customer_satellites).toHaveLength(75);
+  });
+
+  test("all non-null launch_dates are ISO 8601 format", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    for (const r of res._body.customer_satellites) {
+      if (r.launch_date !== null) {
+        expect(r.launch_date).toMatch(ISO_DATE);
+      }
+    }
+  });
+
+  test("all non-null mass_kg values are positive numbers", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    for (const r of res._body.customer_satellites) {
+      if (r.mass_kg !== null) {
+        expect(typeof r.mass_kg).toBe("number");
+        expect(r.mass_kg).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  test("filters by country", async () => {
+    const res = mockRes();
+    await handler(mockReq({ country: "Germany" }), res);
+    expect(res._body.customer_satellites.length).toBeGreaterThan(0);
+    for (const r of res._body.customer_satellites) {
+      expect(r.country.toLowerCase()).toBe("germany");
+    }
+  });
+
+  test("country filter is case-insensitive", async () => {
+    const res1 = mockRes();
+    await handler(mockReq({ country: "germany" }), res1);
+    const res2 = mockRes();
+    await handler(mockReq({ country: "GERMANY" }), res2);
+    expect(res1._body.customer_satellites).toEqual(res2._body.customer_satellites);
+  });
+});

tests/api/launchers.test.js

@@ -0,0 +1,47 @@
+const handler = require("../../api/launchers");
+const { mockReq, mockRes } = require("../helpers/mock");
+
+describe("GET /api/launchers", () => {
+  test("returns 200 with application/json header", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    expect(res._status).toBe(200);
+    expect(res._headers["Content-Type"]).toBe("application/json");
+  });
+
+  test("response has launchers wrapper key with array of 81 records", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    expect(res._body).toHaveProperty("launchers");
+    expect(res._body.launchers).toHaveLength(81);
+  });
+
+  test("each record has an integer id", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    for (const record of res._body.launchers) {
+      expect(Number.isInteger(record.id)).toBe(true);
+    }
+  });
+
+  test("filters by vehicle_family (case-insensitive)", async () => {
+    const res1 = mockRes();
+    await handler(mockReq({ vehicle_family: "PSLV" }), res1);
+    const res2 = mockRes();
+    await handler(mockReq({ vehicle_family: "pslv" }), res2);
+    expect(res1._body.launchers.length).toBeGreaterThan(0);
+    expect(res1._body.launchers).toEqual(res2._body.launchers);
+    for (const r of res1._body.launchers) {
+      expect(r.vehicle_family).toBe("PSLV");
+    }
+  });
+
+  test("known vehicle families are present in data", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    const families = new Set(res._body.launchers.map((r) => r.vehicle_family));
+    for (const f of ["PSLV", "GSLV", "SLV", "ASLV"]) {
+      expect(families.has(f)).toBe(true);
+    }
+  });
+});

tests/api/spacecraft_missions-id.test.js

@@ -0,0 +1,53 @@
+const handler = require("../../api/spacecraft_missions/[id]");
+const { mockReq, mockRes } = require("../helpers/mock");
+
+describe("GET /api/spacecraft_missions/:id", () => {
+  test("returns the correct record for a valid ID", async () => {
+    const res = mockRes();
+    await handler(mockReq({ id: "1" }), res);
+    expect(res._status).toBe(200);
+    expect(res._body.id).toBe(1);
+    expect(typeof res._body.name).toBe("string");
+  });
+
+  test("returns 200 with application/json header", async () => {
+    const res = mockRes();
+    await handler(mockReq({ id: "1" }), res);
+    expect(res._headers["Content-Type"]).toBe("application/json");
+  });
+
+  test("returns 404 for non-existent ID", async () => {
+    const res = mockRes();
+    await handler(mockReq({ id: "99999" }), res);
+    expect(res._status).toBe(404);
+    expect(res._body).toHaveProperty("error");
+  });
+
+  test("returns 400 for non-integer ID", async () => {
+    const res = mockRes();
+    await handler(mockReq({ id: "abc" }), res);
+    expect(res._status).toBe(400);
+    expect(res._body).toHaveProperty("error");
+  });
+
+  test("record includes _links.self and _links.spacecraft", async () => {
+    const res = mockRes();
+    await handler(mockReq({ id: "1" }), res);
+    expect(res._body._links).toHaveProperty("self", "/api/spacecraft_missions/1");
+    expect(res._body._links).toHaveProperty("spacecraft");
+    expect(res._body._links.spacecraft).toMatch(/^\/api\/spacecrafts\/\d+$/);
+  });
+
+  test("record has the full 17-field normalized schema", async () => {
+    const res = mockRes();
+    await handler(mockReq({ id: "1" }), res);
+    const EXPECTED_FIELDS = [
+      "id", "name", "mission_type", "launch_date", "launch_site", "launch_vehicle",
+      "orbit", "orbit_type", "altitude_km", "inclination_deg", "mass_kg", "power_watts",
+      "mission_life", "status", "payloads", "stabilization", "propulsion",
+    ];
+    for (const field of EXPECTED_FIELDS) {
+      expect(res._body).toHaveProperty(field);
+    }
+  });
+});

tests/api/spacecraft_missions.test.js

@@ -0,0 +1,99 @@
+const handler = require("../../api/spacecraft_missions");
+const { mockReq, mockRes } = require("../helpers/mock");
+
+const ISO_DATE = /^\d{4}-\d{2}-\d{2}$/;
+const VALID_STATUSES = new Set(["active", "decommissioned", "failed", "unknown"]);
+const VALID_ORBIT_TYPES = new Set(["LEO", "SSO", "GEO", "Lunar", "Interplanetary", "Failed"]);
+
+describe("GET /api/spacecraft_missions", () => {
+  test("returns 200 with application/json header", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    expect(res._status).toBe(200);
+    expect(res._headers["Content-Type"]).toBe("application/json");
+  });
+
+  test("response has spacecraft_missions wrapper key with 64 records", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    expect(res._body).toHaveProperty("spacecraft_missions");
+    expect(res._body.spacecraft_missions).toHaveLength(64);
+  });
+
+  test("all records have valid status values", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    for (const r of res._body.spacecraft_missions) {
+      expect(VALID_STATUSES.has(r.status)).toBe(true);
+    }
+  });
+
+  test("all non-null orbit_type values are from known set", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    for (const r of res._body.spacecraft_missions) {
+      if (r.orbit_type !== null) {
+        expect(VALID_ORBIT_TYPES.has(r.orbit_type)).toBe(true);
+      }
+    }
+  });
+
+  test("all non-null launch_dates are ISO 8601 format", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    for (const r of res._body.spacecraft_missions) {
+      if (r.launch_date !== null) {
+        expect(r.launch_date).toMatch(ISO_DATE);
+      }
+    }
+  });
+
+  test("all non-null mass_kg values are positive numbers", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    for (const r of res._body.spacecraft_missions) {
+      if (r.mass_kg !== null) {
+        expect(typeof r.mass_kg).toBe("number");
+        expect(r.mass_kg).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  test("all non-null power_watts values are positive numbers", async () => {
+    const res = mockRes();
+    await handler(mockReq(), res);
+    for (const r of res._body.spacecraft_missions) {
+      if (r.power_watts !== null) {
+        expect(typeof r.power_watts).toBe("number");
+        expect(r.power_watts).toBeGreaterThan(0);
+      }
+    }
+  });
+
+  test("filters by status", async () => {
+    const res = mockRes();
+    await handler(mockReq({ status: "active" }), res);
+    expect(res._body.spacecraft_missions.length).toBeGreaterThan(0);
+    for (const r of res._body.spacecraft_missions) {
+      expect(r.status).toBe("active");
+    }
+  });
+
+  test("filters by orbit_type", async () => {
+    const res = mockRes();
+    await handler(mockReq({ orbit_type: "SSO" }), res);
+    expect(res._body.spacecraft_missions.length).toBeGreaterThan(0);
+    for (const r of res._body.spacecraft_missions) {
+      expect(r.orbit_type).toBe("SSO");
+    }
+  });
+
+  test("combined filters return intersection", async () => {
+    const res = mockRes();
+    await handler(mockReq({ orbit_type: "GEO", status: "decommissioned" }), res);
+    for (const r of res._body.spacecraft_missions) {
+      expect(r.orbit_type).toBe("GEO");
+      expect(r.status).toBe("decommissioned");
+    }
+  });
+});

tests/api/spacecrafts-id.test.js

@@ -0,0 +1,46 @@
+const handler = require("../../api/spacecrafts/[id]");
+const { mockReq, mockRes } = require("../helpers/mock");
+
+describe("GET /api/spacecrafts/:id", () => {
+  test("returns the correct record for a valid ID", async () => {
+    const res = mockRes();
+    await handler(mockReq({ id: "1" }), res);
+    expect(res._status).toBe(200);
+    expect(res._body.id).toBe(1);
+    expect(res._body.name).toBe("Aryabhata");
+  });
+
+  test("returns 200 with application/json header", async () => {
+    const res = mockRes();
+    await handler(mockReq({ id: "1" }), res);
+    expect(res._headers["Content-Type"]).toBe("application/json");
+  });
+
+  test("returns 404 for non-existent ID", async () => {
+    const res = mockRes();
+    await handler(mockReq({ id: "99999" }), res);
+    expect(res._status).toBe(404);
+    expect(res._body).toHaveProperty("error");
+  });
+
+  test("returns 400 for non-integer ID", async () => {
+    const res = mockRes();
+    await handler(mockReq({ id: "abc" }), res);
+    expect(res._status).toBe(400);
+    expect(res._body).toHaveProperty("error");
+  });
+
+  test("record includes _links.self", async () => {
+    const res = mockRes();
+    await handler(mockReq({ id: "1" }), res);
+    expect(res._body._links).toHaveProperty("self", "/api/spacecrafts/1");
+  });
+
+  test("record includes _links.mission when a matching mission exists", async () => {
+    const res = mockRes();
+    await handler(mockReq({ id: "1" }), res);
+    // Aryabhata has a mission record
+    expect(res._body._links).toHaveProperty("mission");
+    expect(res._body._links.mission).toMatch(/^\/api\/spacecraft_missions\/\d+$/);
+  });
+});