no-mistakes(test): Add live coverage for the map-VO enum-symbol and unvalidated-write fixes

Drives the real generated C# server (Roslyn-compiled generator output hosted on
Kestrel over Testcontainers Postgres) rather than reading source:

- An_enum_valued_map_component_persists_its_symbol_not_its_ordinal — proves the
  MapJsonb JsonStringEnumConverter fix (85f87c1) actually persists a
  field.map @objectref VO's enum members as their symbol, by reading the raw
  jsonb column back with a direct SQL query independent of the app's own
  reader.
- A_map_valued_address_missing_its_required_street_is_silently_accepted_on_create
  — confirms live the exact claim docs/features/field-types.md now carries:
  a nested VO value inside a field.map is unvalidated on the C# create path
  (201, not 400).

Both passed when run against a live Postgres container in this validation
round, alongside the pre-existing MapNullColumnGeneratedServerTest
(NULL-column read/list/PATCH regression, also verified live).

Author: dmealing

server/csharp/MetaObjects.IntegrationTests/Api/MapValueObjectWriteBehaviorGeneratedServerTest.cs

@@ -0,0 +1,316 @@
+// MapValueObjectWriteBehaviorGeneratedServerTest — two live behaviors of a field.map
+// @objectRef's nested value-object values, driven against the REAL generated HTTP API
+// over real Postgres:
+//
+//  1. Enum members persist as their SYMBOL, not their ordinal. The MapJsonb helper
+//     serializes a map's value object with System.Text.Json, which writes enums as
+//     numbers by default. DbContextGenerator now registers a JsonStringEnumConverter on
+//     that helper's shared JsonSerializerOptions (matching the symbol convention the
+//     sibling field.object ToJson path already uses) so a string-backed enum (kind) and
+//     an int-backed one (tier, @intValueMap) both write their member SYMBOL into the
+//     jsonb document — never the ordinal, and never the @intValueMap-mapped int, because
+//     there is no column inside a JSON document to apply that mapping to.
+//
+//  2. Nested VO values are UNVALIDATED on create (docs/features/field-types.md). An
+//     Address missing its @required "street" is silently ACCEPTED, not rejected, because
+//     RoutesGenerator's create-time VO validation walk admits only field.object, never a
+//     field.map's value.
+//
+// Both drive the actual compiled generator output over Kestrel + Testcontainers
+// Postgres (the same JsonbGeneratedServerFactory-style pattern as
+// MapNullColumnGeneratedServerTest). The enum case reads the RAW jsonb text back with a
+// direct SQL query — bypassing the app's own JSON deserializer entirely — so the
+// assertion is on what actually landed in the database, not on what the reading code
+// chooses to show back.
+//
+// Run on-demand (Docker required):
+//   dotnet test server/csharp/MetaObjects.IntegrationTests/MetaObjects.IntegrationTests.csproj \
+//     --filter "FullyQualifiedName~MapValueObjectWriteBehavior"
+
+using System.Reflection;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using Microsoft.AspNetCore.Builder;
+using Microsoft.AspNetCore.Hosting;
+using Microsoft.CodeAnalysis;
+using Microsoft.CodeAnalysis.CSharp;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.Extensions.DependencyInjection;
+using Microsoft.Extensions.Logging;
+using MetaObjects.Codegen;
+using MetaObjects.Codegen.Generators;
+using MetaObjects.IntegrationTests.Runner;
+using MetaObjects.Loader;
+using Npgsql;
+using Xunit;
+using Xunit.Sdk;
+
+namespace MetaObjects.IntegrationTests.Api;
+
+public sealed class MapValueObjectWriteBehaviorGeneratedServerTest
+{
+    private const string GeneratedNamespace = "MetaObjects.IntegrationTests.MapEnumGenerated";
+
+    // Address carries a string-backed enum (kind) and an int-backed one (tier,
+    // @intValueMap A=1,B=2) — the same shape DbContextCompileTests uses to prove the
+    // converter's delegates resolve; this test proves what those delegates ACTUALLY
+    // persist through a real write.
+    private const string ModelTemplate = """
+    { "metadata.root": { "package": "acme", "children": [
+      { "object.value": { "name": "Address", "children": [
+        { "field.string": { "name": "street", "@required": true } },
+        { "field.enum":   { "name": "kind",   "@values": ["HOME", "WORK"] } },
+        { "field.enum":   { "name": "tier",   "@values": ["A", "B"], "@intValueMap": { "A": 1, "B": 2 } } }
+      ]}},
+      { "object.entity": { "name": "Customer", "children": [
+        { "source.rdb": { "@table": "customers" } },
+        { "field.long":   { "name": "id" } },
+        { "field.string": { "name": "name", "@required": true } },
+        { "field.map":    { "name": "sites", "@objectRef": "Address" } },
+        { "identity.primary": { "@fields": "id" } }
+      ]}}
+    ]}}
+    """;
+
+    private const string SchemaDdl = """
+        CREATE TABLE "customers" (
+          "id" BIGINT GENERATED BY DEFAULT AS IDENTITY NOT NULL,
+          "name" VARCHAR(200) NOT NULL,
+          "sites" jsonb,
+          CONSTRAINT "customers_pkey" PRIMARY KEY ("id")
+        );
+        """;
+
+    [Fact]
+    public async Task An_enum_valued_map_component_persists_its_symbol_not_its_ordinal()
+    {
+        await using var pg = await PostgresContainer.StartAsync();
+        await ProvisionAsync(pg.ConnectionString);
+
+        var (baseUrl, app) = await StartGeneratedServerAsync(pg);
+        await using (app)
+        {
+            using var client = new HttpClient { BaseAddress = new Uri(baseUrl) };
+
+            var body = new JsonObject
+            {
+                ["name"] = "acme",
+                ["sites"] = new JsonObject
+                {
+                    ["hq"] = new JsonObject
+                    {
+                        ["street"] = "1 Main",
+                        ["kind"] = "HOME",
+                        ["tier"] = "A",
+                    },
+                },
+            };
+            using var response = await client.PostAsync("/api/customers",
+                new StringContent(body.ToJsonString(), Encoding.UTF8, "application/json"));
+            var text = await response.Content.ReadAsStringAsync();
+            if (!response.IsSuccessStatusCode)
+                throw new XunitException($"POST /api/customers -> {(int)response.StatusCode}: {text}");
+
+            // Read the RAW jsonb text directly from Postgres — not through the app's own
+            // reader, so this proves what was actually WRITTEN, independent of whatever
+            // the read path might tolerate or coerce.
+            await using var conn = new NpgsqlConnection(pg.ConnectionString);
+            await conn.OpenAsync();
+            await using var cmd = conn.CreateCommand();
+            cmd.CommandText = """SELECT "sites"::text FROM "customers" WHERE "name" = 'acme'""";
+            var raw = (string?)await cmd.ExecuteScalarAsync();
+            Assert.NotNull(raw);
+
+            // Parse with a plain JSON reader — independent of the app's own JSON
+            // deserializer/enum handling — so this proves what the DATABASE holds, not
+            // what the reading code is willing to tolerate.
+            var hq = (JsonNode.Parse(raw!) as JsonObject)?["hq"] as JsonObject;
+            Assert.NotNull(hq);
+            Assert.Equal("HOME", (string?)hq!["kind"]);
+            Assert.Equal("A", (string?)hq!["tier"]);
+            Assert.NotEqual(JsonValueKind.Number, hq["kind"]!.GetValueKind());
+            Assert.NotEqual(JsonValueKind.Number, hq["tier"]!.GetValueKind());
+        }
+    }
+
+    // Confirms, live, the exact claim docs/features/field-types.md now carries: a
+    // field.map @objectRef's nested value-object values are UNVALIDATED on the C# create
+    // path — an Address missing its @required "street" is silently ACCEPTED (201), not
+    // rejected (400), because RoutesGenerator.ValueObjectFields (the source AppendCreateVoValidation
+    // walks) admits only field.object, so a map never reaches the recursively-validating
+    // VO arms. This is the failure mode the docs warn about — acceptance, not an error —
+    // proven against the real generated create handler rather than inferred from source.
+    [Fact]
+    public async Task A_map_valued_address_missing_its_required_street_is_silently_accepted_on_create()
+    {
+        await using var pg = await PostgresContainer.StartAsync();
+        await ProvisionAsync(pg.ConnectionString);
+
+        var (baseUrl, app) = await StartGeneratedServerAsync(pg);
+        await using (app)
+        {
+            using var client = new HttpClient { BaseAddress = new Uri(baseUrl) };
+
+            var body = new JsonObject
+            {
+                ["name"] = "acme-invalid",
+                ["sites"] = new JsonObject
+                {
+                    // "street" (@required on Address) is deliberately omitted.
+                    ["hq"] = new JsonObject { ["kind"] = "HOME" },
+                },
+            };
+            using var response = await client.PostAsync("/api/customers",
+                new StringContent(body.ToJsonString(), Encoding.UTF8, "application/json"));
+            var text = await response.Content.ReadAsStringAsync();
+
+            Assert.Equal(System.Net.HttpStatusCode.Created, response.StatusCode);
+            Assert.Contains("acme-invalid", text);
+        }
+    }
+
+    private static async Task ProvisionAsync(string connString)
+    {
+        await using var c = new NpgsqlConnection(connString);
+        await c.OpenAsync();
+        await using var cmd = c.CreateCommand();
+        cmd.CommandText = SchemaDdl;
+        await cmd.ExecuteNonQueryAsync();
+    }
+
+    private static async Task<(string BaseUrl, WebApplication App)> StartGeneratedServerAsync(PostgresContainer pg)
+    {
+        var (assembly, routeEntities) = CompileGeneratedServer();
+        var dbContextType = assembly.GetType($"{GeneratedNamespace}.AppDbContext")
+            ?? throw new InvalidOperationException("generated AppDbContext type not found");
+
+        int port = PickFreePort();
+        string baseUrl = $"http://127.0.0.1:{port}";
+
+        var builder = WebApplication.CreateBuilder();
+        builder.WebHost.UseUrls(baseUrl);
+        builder.Logging.ClearProviders();
+        // The wire contract for an enum field is its member SYMBOL (a real app registers
+        // this at the host level, e.g. via ConfigureHttpJsonOptions — see
+        // TphGeneratedServerFactory). Without it, System.Text.Json's default enum handling
+        // (numeric) rejects the incoming "HOME"/"A" strings before the request ever reaches
+        // the DTO's own map-jsonb persistence path this test is about.
+        builder.Services.ConfigureHttpJsonOptions(o =>
+            o.SerializerOptions.Converters.Add(new System.Text.Json.Serialization.JsonStringEnumConverter()));
+        RegisterGeneratedDbContext(builder.Services, dbContextType, pg.ConnectionString);
+
+        var app = builder.Build();
+        foreach (var entity in routeEntities)
+        {
+            var routesType = assembly.GetType($"{GeneratedNamespace}.{entity}Routes");
+            if (routesType is null) continue;
+            var mapMethod = routesType.GetMethod($"Map{entity}Routes", BindingFlags.Public | BindingFlags.Static);
+            mapMethod?.Invoke(null, new object[] { app, "/api" });
+        }
+
+        await app.StartAsync();
+        return (baseUrl, app);
+    }
+
+    private static (Assembly Assembly, IReadOnlyList<string> RouteEntities) CompileGeneratedServer()
+    {
+        var loadResult = new MetaDataLoader().Load([new InMemoryStringSource(ModelTemplate, id: "map-enum.json")]);
+        if (loadResult.Errors.Count != 0)
+            throw new InvalidOperationException(
+                "map-enum model failed to load: " + string.Join("; ", loadResult.Errors.Select(e => e.ToString())));
+
+        var routeEntities = loadResult.Root.Objects()
+            .Where(o => o.IsEntity())
+            .Select(o => CSharpNaming.Pascal(o.Name))
+            .ToList();
+
+        var ctx = new GenContext
+        {
+            Entities = loadResult.Root.Objects(),
+            Root = loadResult.Root,
+            Config = new GenConfig
+            {
+                OutDir = "/unused",
+                Namespace = GeneratedNamespace,
+                ColumnNamingStrategy = ColumnNamingStrategy.Literal,
+                EmitAbstractShapes = false,
+            },
+        };
+
+        var files = new EntityGenerator().Generate(ctx)
+            .Concat(new DbContextGenerator().Generate(ctx))
+            .Concat(new FilterAllowlistGenerator().Generate(ctx))
+            .Concat(new RoutesGenerator().Generate(ctx))
+            .ToList();
+
+        var trees = files
+            .Select(f => CSharpSyntaxTree.ParseText(f.Content, new CSharpParseOptions(LanguageVersion.CSharp12)))
+            .ToArray();
+
+        var comp = CSharpCompilation.Create(
+            "mapenum_generated_" + Guid.NewGuid().ToString("N"),
+            trees, BuildReferenceSet(),
+            new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
+
+        using var ms = new MemoryStream();
+        var emit = comp.Emit(ms);
+        if (!emit.Success)
+        {
+            var errors = emit.Diagnostics
+                .Where(d => d.Severity == DiagnosticSeverity.Error)
+                .Select(d => $"{d.Id}: {d.GetMessage()}")
+                .ToList();
+            throw new InvalidOperationException(
+                "generated map-enum server failed to compile:\n  " + string.Join("\n  ", errors));
+        }
+
+        ms.Seek(0, SeekOrigin.Begin);
+        return (Assembly.Load(ms.ToArray()), routeEntities);
+    }
+
+    private static List<MetadataReference> BuildReferenceSet()
+    {
+        var byFileName = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+        var tpa = (string?)AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") ?? "";
+        foreach (var path in tpa.Split(Path.PathSeparator))
+            if (path.Length > 0 && path.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
+                byFileName[Path.GetFileName(path)] = path;
+
+        var aspNetDir = Path.GetDirectoryName(typeof(WebApplication).Assembly.Location);
+        if (aspNetDir is not null && Directory.Exists(aspNetDir))
+            foreach (var dll in Directory.EnumerateFiles(aspNetDir, "*.dll"))
+                byFileName[Path.GetFileName(dll)] = dll;
+
+        return byFileName.Values
+            .Select(loc => (MetadataReference)MetadataReference.CreateFromFile(loc))
+            .ToList();
+    }
+
+    private static void RegisterGeneratedDbContext(
+        IServiceCollection services, Type dbContextType, string connString)
+    {
+        var addDbContext = typeof(EntityFrameworkServiceCollectionExtensions)
+            .GetMethods(BindingFlags.Public | BindingFlags.Static)
+            .First(m => m.Name == "AddDbContext"
+                        && m.IsGenericMethodDefinition
+                        && m.GetGenericArguments().Length == 1
+                        && m.GetParameters().Length == 4)
+            .MakeGenericMethod(dbContextType);
+
+        Action<DbContextOptionsBuilder> configure = opts => opts.UseNpgsql(connString);
+        addDbContext.Invoke(null, new object?[]
+        {
+            services, configure, ServiceLifetime.Scoped, ServiceLifetime.Scoped,
+        });
+    }
+
+    private static int PickFreePort()
+    {
+        var l = new System.Net.Sockets.TcpListener(System.Net.IPAddress.Loopback, 0);
+        l.Start();
+        int port = ((System.Net.IPEndPoint)l.LocalEndpoint).Port;
+        l.Stop();
+        return port;
+    }
+}