test(conformance): Phase B Unit 6 — retire divergent per-port normalization unit tests

Wire-type normalization (uuid/float/double/jsonb/timestamp/timestamptz/date/
time) and projection reads (passthrough + sum/avg/min/max/count) are now gated
end-to-end by the SHARED persistence-conformance round-trip corpus on all five
ports. The per-port normalization UNIT tests had drifted in coverage (TS ~9
cases, Java/Kotlin 4, Python 3) and are now subsumed by those round-trips:

  - REAL/DOUBLE plain-decimal strings  -> queries/measurement-floats.yaml
  - INTEGER->number / BIGINT->string / NUMERIC->no-trailing-zeros
                                       -> queries/projection-aggregates.yaml
  - uuid/jsonb/timestamp(tz)/date/time -> queries/normalization-wire-types.yaml

Delete the subsumed happy-path cases from each port's unit test. KEEP the
out-of-band float guard (canonicalFloat / normalize_value must throw on
exponential-notation values) as a standalone unit test in every port that had
one (TS / Java / Kotlin / Python) — a throwing value cannot be expressed as a
successful round-trip seed. C# never had a separate normalization unit test
(runner + helper only), so nothing changed there.

Each port's Normalization HELPER module is left intact (the runner uses it).
No shared fixtures changed. Document the new gating + retirement in
spec/conformance-tests.md.

Tests: TS 47 pass; Java QueryScenario 14 + ApiContract 20 + NormalizationFloat
2; Kotlin QueryScenario 14 + ApiContract 20 + NormalizationFloat 2; Python 35
pass (all via Testcontainers Postgres). Docker was available.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: dmealing

server/java/integration-tests-kotlin/src/test/kotlin/com/metaobjects/integration/kotlin/NormalizationFloatTest.kt

@@ -1,24 +1,18 @@
 package com.metaobjects.integration.kotlin
 
 import kotlin.test.Test
-import kotlin.test.assertEquals
 import kotlin.test.assertFailsWith
 
 /**
- * R6: REAL/DOUBLE wire normalization (mirror of the TS `normalization.test.ts` and Java
- * `NormalizationFloatTest` cases). [Normalization.normalizeValue] routes Float/Double through
- * the canonical-float stringifier: in-band values become plain-decimal strings (trailing zeros
- * + bare decimal point stripped); out-of-band (exponential) values fail loudly so a bad fixture
- * surfaces immediately instead of silently corrupting the cross-port byte-equality compare.
+ * R6: out-of-band REAL/DOUBLE guard — the ONLY normalization case that cannot be a shared
+ * round-trip scenario (you can't seed a value that must THROW). [Normalization.normalizeValue]
+ * routes Float/Double through the canonical-float stringifier; out-of-band (exponential) values
+ * fail loudly so a bad fixture surfaces immediately instead of silently corrupting the cross-port
+ * byte-equality compare. The happy-path float/integer/bigint/numeric cases formerly here are now
+ * gated end-to-end by the shared persistence-conformance round-trip corpus (REAL/DOUBLE →
+ * queries/measurement-floats.yaml; INTEGER/BIGINT/NUMERIC → queries/projection-aggregates.yaml).
  */
 class NormalizationFloatTest {
-    @Test fun `in-band float is plain decimal string`() {
-        assertEquals("1.5", Normalization.normalizeValue(1.5f))   // REAL (float4)
-        assertEquals("0.25", Normalization.normalizeValue(0.25)) // DOUBLE (float8)
-    }
-    @Test fun `integer-valued double strips trailing zero and point`() {
-        assertEquals("2", Normalization.normalizeValue(2.0)) // "2.0" -> "2." -> "2"
-    }
     @Test fun `out-of-band double throws`() {
         assertFailsWith<IllegalArgumentException> { Normalization.normalizeValue(1.0e-10) } // "1.0E-10"
     }

server/java/integration-tests/src/test/java/com/metaobjects/integration/NormalizationFloatTest.java

@@ -2,24 +2,18 @@
 
 import org.junit.jupiter.api.Test;
 
-import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 
 /**
- * R6: REAL/DOUBLE wire normalization (mirror of the TS {@code normalization.test.ts} cases).
- * {@link Normalization#normalizeValue} routes Float/Double through the canonical-float
- * stringifier: in-band values become plain-decimal strings (trailing zeros + bare decimal
- * point stripped); out-of-band (exponential) values fail loudly so a bad fixture surfaces
- * immediately instead of silently corrupting the cross-port byte-equality compare.
+ * R6: out-of-band REAL/DOUBLE guard — the ONLY normalization case that cannot be a shared
+ * round-trip scenario (you can't seed a value that must THROW). {@link Normalization#normalizeValue}
+ * routes Float/Double through the canonical-float stringifier; out-of-band (exponential) values
+ * fail loudly so a bad fixture surfaces immediately instead of silently corrupting the cross-port
+ * byte-equality compare. The happy-path float/integer/bigint/numeric cases formerly here are now
+ * gated end-to-end by the shared persistence-conformance round-trip corpus (REAL/DOUBLE →
+ * queries/measurement-floats.yaml; INTEGER/BIGINT/NUMERIC → queries/projection-aggregates.yaml).
  */
 class NormalizationFloatTest {
-    @Test void inBandFloat_isPlainDecimalString() {
-        assertEquals("1.5", Normalization.normalizeValue(1.5f));   // REAL (float4)
-        assertEquals("0.25", Normalization.normalizeValue(0.25d)); // DOUBLE (float8)
-    }
-    @Test void integerValuedDouble_stripsTrailingZeroAndPoint() {
-        assertEquals("2", Normalization.normalizeValue(2.0d)); // "2.0" -> "2." -> "2"
-    }
     @Test void outOfBandDouble_throws() {
         assertThrows(IllegalArgumentException.class,
             () -> Normalization.normalizeValue(1.0e-10d)); // Double.toString -> "1.0E-10"

server/python/tests/integration/test_normalization.py

@@ -1,11 +1,15 @@
-"""R6: REAL/DOUBLE wire-normalization unit tests.
-
-Parity with the other ports' standalone float-normalization tests
-(``NormalizationFloatTest.java`` / ``NormalizationFloatTest.kt`` /
-``normalization.test.ts``). ``_canonical_float`` renders in-band dyadic values as
-plain-decimal strings (trailing zeros + a bare decimal point stripped) and raises on
-out-of-band (exponential) values so a bad fixture surfaces loudly instead of silently
-corrupting the cross-port byte-equality compare. These run without a database.
+"""R6: out-of-band REAL/DOUBLE guard.
+
+The ONLY normalization case that cannot be a shared round-trip scenario (you can't
+seed a value that must RAISE). ``_canonical_float`` raises on out-of-band (exponential)
+values so a bad fixture surfaces loudly instead of silently corrupting the cross-port
+byte-equality compare. Runs without a database.
+
+The happy-path float/integer/bigint/numeric normalization cases formerly here are now
+gated end-to-end by the shared persistence-conformance round-trip corpus:
+REAL/DOUBLE → ``queries/measurement-floats.yaml``; INTEGER/BIGINT/NUMERIC →
+``queries/projection-aggregates.yaml``. See
+``fixtures/persistence-conformance/normalization.md``.
 """
 
 from __future__ import annotations
@@ -15,18 +19,6 @@
 from .normalization import _canonical_float, normalize_value
 
 
-def test_in_band_float_is_plain_decimal_string():
-    assert _canonical_float(1.5) == "1.5"  # REAL (float4)
-    assert _canonical_float(0.25) == "0.25"  # DOUBLE (float8)
-    # and via the public route floats take through _canonical_float
-    assert normalize_value(1.5) == "1.5"
-
-
-def test_integer_valued_float_strips_trailing_zero_and_point():
-    assert _canonical_float(2.0) == "2"  # repr "2.0" -> "2." -> "2"
-    assert normalize_value(2.0) == "2"
-
-
 def test_out_of_band_float_raises():
     # repr(1e-10) == "1e-10" -> exponential -> loud failure, not silent corruption.
     with pytest.raises(ValueError):

server/typescript/packages/integration-tests/test/normalization.test.ts

@@ -1,48 +1,17 @@
-// Unit tests for normalization helpers — no DB required.
+// Out-of-band float guard — the ONLY normalization case that cannot be a shared
+// round-trip scenario (you can't seed a value that must THROW). The happy-path
+// float/integer/bigint normalization cases formerly here are now gated end-to-end
+// by the shared persistence-conformance round-trip corpus:
+//   - REAL/DOUBLE plain-decimal strings  → queries/measurement-floats.yaml
+//   - INTEGER stays a JSON number        → queries/projection-aggregates.yaml (min/max)
+//   - BIGINT → string                    → queries/projection-aggregates.yaml (weekCount/totalMinutes)
+//   - NUMERIC no-trailing-zeros string   → queries/projection-aggregates.yaml (avgMinutes)
+// See fixtures/persistence-conformance/normalization.md.
 
 import { describe, test, expect } from "bun:test";
 import { normalizeValue, canonicalFloat } from "../src/normalization.ts";
 
-describe("normalizeValue — floats (REAL/DOUBLE)", () => {
-  test("1.5 → '1.5'", () => {
-    expect(normalizeValue(1.5)).toBe("1.5");
-  });
-
-  test("0.125 → '0.125'", () => {
-    expect(normalizeValue(0.125)).toBe("0.125");
-  });
-
-  test("-3.25 → '-3.25'", () => {
-    expect(normalizeValue(-3.25)).toBe("-3.25");
-  });
-
-  test("1234.5 → '1234.5'", () => {
-    expect(normalizeValue(1234.5)).toBe("1234.5");
-  });
-
-  test("trailing zeros are stripped: 1.500 → '1.5'", () => {
-    // JS String() already produces '1.5' for 1.5, but canonicalFloat handles the strip
-    expect(canonicalFloat(1.5)).toBe("1.5");
-  });
-});
-
-describe("normalizeValue — integers", () => {
-  test("100 stays as number 100", () => {
-    expect(normalizeValue(100)).toBe(100);
-  });
-
-  test("0 stays as number 0", () => {
-    expect(normalizeValue(0)).toBe(0);
-  });
-});
-
-describe("normalizeValue — bigint", () => {
-  test("123n → '123' (string)", () => {
-    expect(normalizeValue(123n)).toBe("123");
-  });
-});
-
-describe("canonicalFloat — out-of-band guard", () => {
+describe("canonicalFloat — out-of-band guard (not round-trippable)", () => {
   test("1.5e-10 throws (exponential notation)", () => {
     expect(() => canonicalFloat(1.5e-10)).toThrow(
       "canonicalFloat: 1.5e-10 is outside the plain-decimal band (exponential notation)",

spec/conformance-tests.md

@@ -204,6 +204,13 @@ that ledger is loader-corpus only.
 Two further corpora cover the **runtime** tier and are exercised by **all five ports, including Kotlin**, on demand against Testcontainers Postgres via `scripts/integration-test.sh` (these are **not** in the default `test` path for the JVM/.NET ports — see the hardening review):
 
 - **`fixtures/persistence-conformance/`** — CRUD / filter / projection round-trips. The **query** scenarios run on every port; each port provisions its test DB by **executing the committed, TS-produced `canonical/schema.postgres.sql`** (no port synthesizes schema) and then exercises its runtime data-access layer. Per ADR-0015 schema migrations are TS-owned, so the **migration** scenarios are run by **TS only**, and the cross-port query corpus is **Postgres-only** (Derby was dropped for it).
+
+  **Wire-type normalization + projection reads are gated by these shared round-trips on all five ports** (see `fixtures/persistence-conformance/normalization.md` for the per-type canonical rules):
+  - **REAL/DOUBLE** → plain-decimal strings, no trailing zeros, no exponential notation (`queries/measurement-floats.yaml`).
+  - **uuid** (lowercase canonicalization), **jsonb** (key-sorting), **TIMESTAMPTZ** (seeded with a non-UTC offset, read back as UTC `Z` — proving normalization, not mere formatting), plain **TIMESTAMP** (no `Z`), **DATE**, **TIME** (`queries/normalization-wire-types.yaml`, with companion coverage in `queries/asset-uuid-roundtrip.yaml`).
+  - **projection reads** — passthrough-view read (`queries/projection-passthrough.yaml`) and `sum`/`avg`/`min`/`max`/`count` aggregates over a VIEW, including the aggregate-over-zero-rows NULL semantics (`queries/projection-aggregates.yaml`, `queries/projection-aggregate.yaml`). These also pin INTEGER→number, BIGINT→string, and NUMERIC→no-trailing-zeros-string.
+
+  Because this end-to-end round-trip enforces the canonical wire shape identically across ports, the **divergent per-port normalization _unit_ tests were retired** (they had drifted in coverage — TS ~9 cases, Java/Kotlin 4, Python 3 — and are now subsumed). Each port keeps its `Normalization` **helper module** (the runner depends on it). The **only** unit assertion kept per port is the out-of-band float guard (`canonicalFloat`/`normalize_value` must **throw/raise** on exponential-notation values) — a value that must throw cannot be expressed as a successful round-trip seed, so it stays a standalone unit test (TS `normalization.test.ts`, Java/Kotlin `NormalizationFloatTest`, Python `test_normalization.py`). C# never had a separate normalization unit test (only the runner + helper), so nothing was removed there.
 - **`fixtures/api-contract-conformance/`** — emitted CRUD routes answered over real HTTP (URL grammar + wire format).
 
 A `fixtures/render-conformance/template-generator/` sub-corpus additionally exercises the codegen *walk* (file-per-entity inventory + render) in TS, C#, Java, and Python.