leistungsbilanz-ts/tests/circuit.controller.test.ts

import assert from "node:assert/strict";
import { describe, it } from "node:test";
import { getNextCircuitIdentifier } from "../src/server/controllers/circuit.controller.js";
import {
  circuitListRepository,
  circuitSectionRepository,
} from "../src/server/composition/application-repositories.js";
import { circuitNumberingService } from "../src/server/composition/circuit-numbering-service.js";

function createMockResponse() {
  let statusCode = 200;
  let body: unknown;
  return {
    response: {
      status(code: number) {
        statusCode = code;
        return this;
      },
      json(value: unknown) {
        body = value;
        return this;
      },
    },
    getStatusCode: () => statusCode,
    getBody: () => body,
  };
}

describe("circuit controller", () => {
  it("returns the next identifier when the section belongs to the project", async () => {
    const originals = {
      findSection: circuitSectionRepository.findById,
      findList: circuitListRepository.findById,
      getNextIdentifier: circuitNumberingService.getNextIdentifier,
    };
    circuitSectionRepository.findById = async () =>
      ({ id: "section-1", circuitListId: "list-1", prefix: "-1F" }) as never;
    circuitListRepository.findById = async (projectId: string, circuitListId: string) =>
      projectId === "project-1" && circuitListId === "list-1"
        ? ({ id: "list-1", projectId: "project-1" } as never)
        : null;
    circuitNumberingService.getNextIdentifier = async () => "-1F3";
    const mock = createMockResponse();
    try {
      await getNextCircuitIdentifier(
        { params: { projectId: "project-1", sectionId: "section-1" } } as never,
        mock.response as never
      );
    } finally {
      circuitSectionRepository.findById = originals.findSection;
      circuitListRepository.findById = originals.findList;
      circuitNumberingService.getNextIdentifier = originals.getNextIdentifier;
    }
    assert.deepEqual(mock.getBody(), {
      sectionId: "section-1",
      nextIdentifier: "-1F3",
    });
  });

  it("returns 404 instead of leaking numbering state for a section from another project", async () => {
    const originals = {
      findSection: circuitSectionRepository.findById,
      findList: circuitListRepository.findById,
    };
    circuitSectionRepository.findById = async () =>
      ({ id: "section-1", circuitListId: "list-1", prefix: "-1F" }) as never;
    // The section exists, but its circuit list does not belong to the requesting project.
    circuitListRepository.findById = async () => null;
    const mock = createMockResponse();
    try {
      await getNextCircuitIdentifier(
        { params: { projectId: "foreign-project", sectionId: "section-1" } } as never,
        mock.response as never
      );
    } finally {
      circuitSectionRepository.findById = originals.findSection;
      circuitListRepository.findById = originals.findList;
    }
    assert.equal(mock.getStatusCode(), 404);
    assert.deepEqual(mock.getBody(), { error: "Section not found" });
  });

  it("returns 404 for a section that does not exist", async () => {
    const originals = {
      findSection: circuitSectionRepository.findById,
    };
    circuitSectionRepository.findById = async () => null;
    const mock = createMockResponse();
    try {
      await getNextCircuitIdentifier(
        { params: { projectId: "project-1", sectionId: "missing" } } as never,
        mock.response as never
      );
    } finally {
      circuitSectionRepository.findById = originals.findSection;
    }
    assert.equal(mock.getStatusCode(), 404);
    assert.deepEqual(mock.getBody(), { error: "Section not found" });
  });
});