import { describe, expect, it, vi } from "vitest"; import { assertKwpReadOperationAllowed, buildKwpSemanticContract, createKwpResourceTransport, KWP_ADDRESS_DETAILS_PATH, KWP_PROJECT_CATALOG_PATH, KWP_PROJECT_DETAILS_PATH, KWP_PROJECT_SEARCH_PATH, } from "./resource-client.js"; import { KWP_OIDC_ISSUER, KWP_REQUIRED_OAUTH_SCOPES, type KwpCredentials, type KwpOutboundRequestOptions } from "./client.js"; import { KWP_SCOPED_OPERATIONS } from "./scoped-contract.js"; const CREDENTIALS: KwpCredentials = { accessToken: "access-secret", refreshToken: "refresh-secret", expiresAt: "2026-07-23T12:00:00.000Z", issuer: KWP_OIDC_ISSUER, clientId: "_extern-geerkens2", clientSecret: "client-secret", customerCode: "geerkens2", scopes: [...KWP_REQUIRED_OAUTH_SCOPES], mandantBinding: { kind: "selected", code: "mandant1" }, }; const PUBLIC_ADDRESS_RESOLVER = async (): Promise => ["93.184.216.34"]; describe("KWP project resource transport", () => { it("executes only targeted search and normalizes the consumed fields", async () => { const fetchMock = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce( jsonResponse([ { projNr: " P-100 ", projBezeichnung: " Heizung Schule ", projAdr: "ADR-1", rechAdr: "ADR-2", bauHrAdr: "ADR-3", auftragStatus: 8, }, ]) ); const consumeBudget = vi.fn().mockResolvedValue(undefined); const resource = createKwpResourceTransport(CREDENTIALS, { consumeBudget, outboundOptions: outboundOptions(fetchMock), }); await expect(resource.searchProjects(" Schule ")).resolves.toEqual([ { externalProjectNumber: "P-100", name: "Heizung Schule", projectAddressCode: "ADR-1", invoiceAddressCode: "ADR-2", clientAddressCode: "ADR-3", status: 8, statusLabel: "Erhalten", }, ]); expect(consumeBudget).toHaveBeenCalledTimes(2); const [url, init] = fetchMock.mock.calls[1] as [string, RequestInit]; expect(new URL(url).pathname).toBe(`/relay/geerkens2/pwa${KWP_PROJECT_SEARCH_PATH}`); expect(new URL(url).searchParams.get("mandant")).toBe("mandant1"); expect(init.method).toBe("POST"); expect(JSON.parse(String(init.body))).toEqual({ value: "Schule" }); }); it("skips search rows without the optional routing status while keeping routable results available", async () => { const fetchMock = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce( jsonResponse([ { projNr: "P-NO-STATUS", projBezeichnung: "Noch nicht routbar", }, { projNr: "P-ROUTABLE", projBezeichnung: "Routbares Projekt", auftragStatus: 7, }, ]) ); const resource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(fetchMock), }); await expect(resource.searchProjects("Projekt")).resolves.toEqual([ { externalProjectNumber: "P-ROUTABLE", name: "Routbares Projekt", projectAddressCode: null, invoiceAddressCode: null, clientAddressCode: null, status: 7, statusLabel: "Zugesagt", }, ]); }); it("discovers the setting-visible project catalog without an empty search", async () => { const fetchMock = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce( jsonResponse([ { projNr: " P-100 ", anzahlAktivitaeten: 3 }, { projNr: "P-200", anzahlAktivitaeten: 0 }, { projNr: "P-100", anzahlAktivitaeten: 4 }, { projNr: null, anzahlAktivitaeten: 0 }, ]) ); const resource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(fetchMock), }); await expect(resource.listProjectNumbers()).resolves.toEqual(["P-100", "P-200"]); const [url, init] = fetchMock.mock.calls[1] as [string, RequestInit]; expect(new URL(url).pathname).toBe(`/relay/geerkens2/pwa${KWP_PROJECT_CATALOG_PATH}`); expect(new URL(url).searchParams.get("mandant")).toBe("mandant1"); expect(init.method).toBe("GET"); expect(init.body).toBeUndefined(); }); it("still rejects a present search status outside the consumed KWP enum", async () => { const fetchMock = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce( jsonResponse([ { projNr: "P-INVALID-STATUS", projBezeichnung: "Ungültiger Status", auftragStatus: 10, }, ]) ); const resource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(fetchMock), }); await expect(resource.searchProjects("Projekt")).rejects.toMatchObject({ code: "contract_drift", }); }); it("accepts omitted optional fields from live project and address responses", async () => { const detailsFetch = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce( jsonResponse({ projNr: "P-100", projBezeichnung: "Heizung Schule", adresse: { adrNrGes: "ADR-1", name: "Schule", zusatz: "Altbau", strasse: "Dorfstraße 1", ort: { ortId: 1, plz: "12345", ort: "Berlin" }, }, auftragssumme: 42_500, }) ); const detailsResource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(detailsFetch), }); await expect(detailsResource.loadProjectDetails("P-100")).resolves.toEqual({ externalProjectNumber: "P-100", name: "Heizung Schule", startDate: null, orderValue: 42_500, addressCode: "ADR-1", addressName: "Schule", }); const addressFetch = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce( jsonResponse({ adrNrGes: "ADR-1", name: "Schule", zusatz: "Altbau", strasse: "Dorfstraße 1", ort: { ortId: 1, plz: "12345", ort: "Berlin" }, // Real KWP tenants return null for these documented object fields. // They are not consumed by project import and must not create a // capability-wide false-positive contract pause. ortPstf: null, briefanrede: null, selekt1: null, selekt2: null, bank: null, kontakte: [ { kontaktId: 1, kontaktart: 2, kontakt: "info@example.test", kontaktartTyp: 0, kontaktName: "E-Mail", ansprechpartnerId: null, }, ], ansprechpartner: [], }) ); const addressResource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(addressFetch), }); await expect(addressResource.loadAddressDetails("ADR-1")).resolves.toMatchObject({ externalAddressCode: "ADR-1", firstName: null, country: null, invoiceEmail: null, email: "info@example.test", contactPeople: [], }); }); it("still rejects an invalid consumed address field while ignoring unconsumed nullable drift", async () => { const fetchMock = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce( jsonResponse({ adrNrGes: "ADR-1", name: "Schule", ortPstf: null, briefanrede: null, selekt1: null, selekt2: null, bank: null, kontakte: [{ kontaktart: 99, kontakt: "invalid@example.test", ansprechpartnerId: null }], }) ); const resource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(fetchMock), }); await expect(resource.loadAddressDetails("ADR-1")).rejects.toMatchObject({ code: "contract_drift", }); }); it("rejects empty or one-character search without provider I/O", async () => { const fetchMock = vi.fn(); const consumeBudget = vi.fn(); const resource = createKwpResourceTransport(CREDENTIALS, { consumeBudget, outboundOptions: outboundOptions(fetchMock), }); await expect(resource.searchProjects(" ")).rejects.toMatchObject({ code: "invalid_credentials" }); await expect(resource.searchProjects("x")).rejects.toMatchObject({ code: "invalid_credentials" }); expect(consumeBudget).not.toHaveBeenCalled(); expect(fetchMock).not.toHaveBeenCalled(); }); it("loads project details by GET and detects a renamed consumed field", async () => { const validFetch = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce( jsonResponse({ projNr: "P-100", projBezeichnung: "Heizung Schule", beginn: "2026-07-01T00:00:00+02:00", adresse: { adrNrGes: "ADR-1", name: "Schule", vorname: null, zusatz: null, strasse: "Dorfstraße 1", ort: { ortId: 1, land: "DE", plz: "12345", ort: "Berlin" }, debitKreditNr: 987654, }, sachBearb: null, vertrieb: null, auftragssumme: 42_500, }) ); const validResource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(validFetch), }); await expect(validResource.loadProjectDetails("P-100")).resolves.toEqual({ externalProjectNumber: "P-100", name: "Heizung Schule", startDate: "2026-06-30T22:00:00.000Z", orderValue: 42_500, addressCode: "ADR-1", addressName: "Schule", }); const [url, init] = validFetch.mock.calls[1] as [string, RequestInit]; expect(new URL(url).pathname).toBe(`/relay/geerkens2/pwa${KWP_PROJECT_DETAILS_PATH}`); expect(new URL(url).searchParams.get("projNr")).toBe("P-100"); expect(init.method).toBe("GET"); expect(init.body).toBeUndefined(); const driftFetch = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce( jsonResponse({ projektNummer: "P-100", projBezeichnung: "Heizung Schule", beginn: null, adresse: { adrNrGes: null, name: null, vorname: null, zusatz: null, strasse: null, ort: { ortId: 1, land: null, plz: null, ort: null } }, sachBearb: null, vertrieb: null, auftragssumme: null, }) ); const driftResource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(driftFetch), }); await expect(driftResource.loadProjectDetails("P-100")).rejects.toMatchObject({ code: "contract_drift" }); }); it("discards prohibited financial, tax, birthday, note and user fields", async () => { const fetchMock = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce( jsonResponse({ adrNrGes: "ADR-1", name: "Geerkens GmbH", vorname: null, zusatz: "Niederlassung", strasse: "Werkstraße 7", ort: { ortId: 1, land: "DE", plz: "52511", ort: "Geilenkirchen" }, rechnungsmailadresse: "rechnung@example.test", kontakte: [ { kontaktId: 1, kontaktart: 2, kontakt: "info@example.test", kontaktName: "E-Mail", bemerkung: "secret", ansprechpartnerId: null }, { kontaktId: 2, kontaktart: 0, kontakt: "+49 123", kontaktName: "Telefon", bemerkung: null, ansprechpartnerId: null }, ], ansprechpartner: [ { nachname: "Muster", vorname: "Maria", ansprechpartnerId: 99, zusatz: null, geburtstag: "1980-01-01T00:00:00Z", benutzerFeld1: "never-store", bemerkung: "internal", kontakte: [{ kontaktId: 3, kontaktart: 2, kontakt: "maria@example.test", kontaktName: "E-Mail", bemerkung: null, ansprechpartnerId: 99 }], }, ], iban: "DE001234", bank: { bezeichnung: "Secret Bank" }, kreditLimit: 100_000, ustId: "DE123", hinweis: "internal", benutzerFeld1: "never-store", }) ); const resource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(fetchMock), }); const address = await resource.loadAddressDetails("ADR-1"); expect(address).toMatchObject({ externalAddressCode: "ADR-1", name: "Geerkens GmbH", invoiceEmail: "rechnung@example.test", email: "info@example.test", phone: "+49 123", contactPeople: [ { externalContactId: "99", firstName: "Maria", lastName: "Muster", email: "maria@example.test", }, ], }); const persisted = JSON.stringify(address).toLowerCase(); for (const prohibited of [ '"iban"', '"bank"', '"kreditlimit"', '"ustid"', '"geburtstag"', '"hinweis"', '"benutzerfeld1"', '"bemerkung"', "de001234", "never-store", ]) { expect(persisted).not.toContain(prohibited.toLowerCase()); } expect(new URL(String(fetchMock.mock.calls[1]?.[0])).pathname).toBe(`/relay/geerkens2/pwa${KWP_ADDRESS_DETAILS_PATH}`); }); it("blocks every KWP write or non-allowlisted read before transport", () => { for (const operation of KWP_SCOPED_OPERATIONS) { const assertion = () => assertKwpReadOperationAllowed(operation.method, operation.path); if (operation.mode === "read") expect(assertion).not.toThrow(); else expect(assertion).toThrow(); } expect(() => assertKwpReadOperationAllowed("GET", "/api/Core/GetApiVersion")).toThrow(); expect(() => assertKwpReadOperationAllowed("GET", KWP_PROJECT_DETAILS_PATH)).not.toThrow(); }); it("executes exact generic GET and read-POST operation ids without exposing a free path", async () => { const fetchMock = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce(jsonResponse({})) .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce(jsonResponse([])); const resource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(fetchMock), }); await expect(resource.executeReadOperation("monteursteuerungGetSetup")).resolves.toEqual({}); await expect(resource.executeReadOperation("vorgangAnzeigeLoadPositionen", { body: {} })).resolves.toEqual([]); const getUrl = new URL(String(fetchMock.mock.calls[1]?.[0])); expect(getUrl.pathname).toBe("/relay/geerkens2/pwa/api/Monteursteuerung/GetSetup"); expect(getUrl.searchParams.get("mandant")).toBe("mandant1"); expect((fetchMock.mock.calls[1]?.[1] as RequestInit).method).toBe("GET"); const postUrl = new URL(String(fetchMock.mock.calls[3]?.[0])); expect(postUrl.pathname).toBe("/relay/geerkens2/pwa/api/VorgangAnzeige/LoadPositionen"); expect(postUrl.searchParams.get("mandant")).toBe("mandant1"); expect((fetchMock.mock.calls[3]?.[1] as RequestInit).method).toBe("POST"); expect(JSON.parse(String((fetchMock.mock.calls[3]?.[1] as RequestInit).body))).toEqual({}); }); it("fails closed for an unconfirmed mandant and classifies 403 without exposing the provider body", async () => { const { mandantBinding: _binding, ...unconfirmed } = CREDENTIALS; expect(() => createKwpResourceTransport(unconfirmed, { consumeBudget: async () => undefined, }) ).toThrowError(expect.objectContaining({ code: "mandant_unconfirmed" })); const fetchMock = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce(jsonResponse({ token: CREDENTIALS.accessToken }, 403)); const resource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(fetchMock), }); const error = await resource.searchProjects("Projekt").catch((caught: unknown) => caught); expect(error).toMatchObject({ code: "auth_scope_missing", httpStatus: 403 }); expect(JSON.stringify(error)).not.toContain(CREDENTIALS.accessToken); }); it.each([ [401, "auth_token_invalid"], [429, "rate_limit_exceeded"], [503, "provider_outage"], ])("classifies HTTP %i without hidden refresh or request retry", async (status, code) => { const fetchMock = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce(jsonResponse({ token: CREDENTIALS.accessToken }, status)); const resource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(fetchMock), }); await expect(resource.searchProjects("Projekt")).rejects.toMatchObject({ code, httpStatus: status, }); expect(fetchMock).toHaveBeenCalledTimes(2); expect(JSON.stringify(fetchMock.mock.results)).not.toContain(CREDENTIALS.refreshToken); }); it("fingerprints only the consumed semantic OpenAPI slice", () => { const base = openApiFixture(); const first = buildKwpSemanticContract(base); const unrelated = structuredClone(base); unrelated.paths["/api/Unrelated/Save"] = { post: { responses: { 200: {} } } }; unrelated.components.schemas.Unrelated = { type: "object", properties: { value: { type: "string" } } }; expect(buildKwpSemanticContract(unrelated).semanticFingerprint).toBe(first.semanticFingerprint); const architectOnly = structuredClone(base); architectOnly.components.schemas["Kwp.Api.Service.Dto.Projekte.DtoSearchResultProjekt"].properties.archAdr = { type: "integer", }; expect(buildKwpSemanticContract(architectOnly).semanticFingerprint).toBe(first.semanticFingerprint); const changed = structuredClone(base); changed.components.schemas["Kwp.Api.Model.Values.ProjektHauptstatus"].enum.push(10); expect(buildKwpSemanticContract(changed).semanticFingerprint).not.toBe(first.semanticFingerprint); const renamed = structuredClone(base); delete renamed.components.schemas["Kwp.Api.Service.Dto.Projekte.DtoSearchResultProjekt"].properties.projNr; expect(() => buildKwpSemanticContract(renamed)).toThrowError(expect.objectContaining({ code: "contract_drift" })); }); it("accepts the larger tenant OpenAPI while keeping business responses capped at one MiB", async () => { const openApi = openApiFixture(); openApi.paths["/api/Unrelated/Large"] = { get: { description: "x".repeat(2 * 1024 * 1024), responses: { 200: {} }, }, }; const openApiFetch = vi.fn().mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")).mockResolvedValueOnce(jsonResponse(openApi)); const openApiResource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(openApiFetch), }); await expect(openApiResource.loadSemanticContract()).resolves.toMatchObject({ apiVersion: "v1", }); const oversizedBusinessResponse = [ { projNr: "P-100", projBezeichnung: "Heizung Schule", auftragStatus: 8, ignored: "x".repeat(1024 * 1024), }, ]; const searchFetch = vi .fn() .mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")) .mockResolvedValueOnce(jsonResponse(oversizedBusinessResponse)); const searchResource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(searchFetch), }); await expect(searchResource.searchProjects("Projekt")).rejects.toMatchObject({ code: "contract_drift", }); }); it("rejects an OpenAPI response above the dedicated eight MiB ceiling", async () => { const openApi = openApiFixture(); openApi.paths["/api/Unrelated/Oversized"] = { get: { description: "x".repeat(8 * 1024 * 1024), responses: { 200: {} }, }, }; const fetchMock = vi.fn().mockResolvedValueOnce(new Response("https://geerkens2.app04.kwp-online.de")).mockResolvedValueOnce(jsonResponse(openApi)); const resource = createKwpResourceTransport(CREDENTIALS, { consumeBudget: async () => undefined, outboundOptions: outboundOptions(fetchMock), }); await expect(resource.loadSemanticContract()).rejects.toMatchObject({ code: "contract_drift", }); }); }); function outboundOptions(fetchImpl: typeof fetch): KwpOutboundRequestOptions { return { fetchImpl, addressResolver: PUBLIC_ADDRESS_RESOLVER }; } function jsonResponse(body: unknown, status = 200): Response { return new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } }); } function openApiFixture(): { info: { version: string }; paths: Record; components: { schemas: Record }; } { const response = (schema: string) => ({ "200": { content: { "application/json": { schema: { $ref: `#/components/schemas/${schema}` } } } }, }); const property = (type: string) => ({ type, nullable: true }); return { info: { version: "v1" }, paths: { [KWP_PROJECT_SEARCH_PATH]: { post: { parameters: [{ name: "mandant", in: "query", schema: { type: "string" } }], requestBody: { content: { "application/json": { schema: { $ref: "#/components/schemas/Kwp.Api.Service.Dto.DtoValue" } } } }, responses: response("Kwp.Api.Service.Dto.Projekte.DtoSearchResultProjekt"), }, }, [KWP_PROJECT_DETAILS_PATH]: { get: { parameters: [{ name: "projNr", in: "query", schema: { type: "string" } }], responses: response("Kwp.Api.Service.Dto.Projektampel.DtoProjektampelProjekt"), }, }, [KWP_ADDRESS_DETAILS_PATH]: { get: { parameters: [{ name: "adresskuerzel", in: "query", schema: { type: "string" } }], responses: response("Kwp.Api.Service.Dto.Adressen.DtoAdresseKomplett"), }, }, }, components: { schemas: { "Kwp.Api.Service.Dto.DtoValue": { type: "object", properties: { value: property("string") } }, "Kwp.Api.Service.Dto.Projekte.DtoSearchResultProjekt": { type: "object", properties: Object.fromEntries( ["projNr", "projBezeichnung", "projAdr", "rechAdr", "archAdr", "bauHrAdr", "auftragStatus"].map((name) => [ name, property(name === "auftragStatus" ? "integer" : "string"), ]) ), }, "Kwp.Api.Model.Values.ProjektHauptstatus": { type: "integer", format: "int32", enum: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9] }, "Kwp.Api.Service.Dto.Projektampel.DtoProjektampelProjekt": { type: "object", properties: Object.fromEntries( ["projNr", "projBezeichnung", "beginn", "adresse", "sachBearb", "vertrieb", "auftragssumme"].map((name) => [name, property("string")]) ), }, "Kwp.Api.Service.Dto.Adressen.DtoAdresse": { type: "object", properties: Object.fromEntries(["adrNrGes", "name", "vorname", "zusatz", "strasse", "ort"].map((name) => [name, property("string")])), }, "Kwp.Api.Service.Dto.Adressen.DtoAdresseKomplett": { type: "object", properties: Object.fromEntries( ["adrNrGes", "name", "vorname", "zusatz", "strasse", "ort", "rechnungsmailadresse", "kontakte", "ansprechpartner"].map((name) => [ name, property("string"), ]) ), }, "Kwp.Api.Service.Dto.Adressen.DtoOrt": { type: "object", properties: Object.fromEntries(["ortId", "land", "plz", "ort"].map((name) => [name, property("string")])), }, "Kwp.Api.Service.Dto.Adressen.DtoKontakt": { type: "object", properties: Object.fromEntries(["kontaktId", "kontaktart", "kontakt", "kontaktName", "ansprechpartnerId"].map((name) => [name, property("string")])), }, "Kwp.Api.Service.Dto.Adressen.DtoAnsprechpartner": { type: "object", properties: Object.fromEntries(["nachname", "vorname", "ansprechpartnerId", "zusatz", "kontakte"].map((name) => [name, property("string")])), }, "Kwp.Api.Model.Values.Adresse.Kontaktart": { type: "integer", format: "int32", enum: [0, 1, 2, 3, 4, 5] }, }, }, }; }