EF Core Oracle test asserts a lowercase PK column name the mapping never produces

[jeremydmiller]

Weasel.EntityFrameworkCore.Tests.Oracle.end_to_end.can_map_entity_to_table fails against a live Oracle instance:

Shouldly.ShouldAssertException : table.PrimaryKeyColumns
    should contain
"id"
    but was actually
["Id"]

src/Weasel.EntityFrameworkCore.Tests/Oracle/end_to_end.cs:77

What's inconsistent

In the same test, immediately above the failing line, every ordinary column asserts successfully in lowercase — table.HasColumn("id"), HasColumn("intvalue"), HasColumn("null_dt_offset_val") and so on all pass. So MapToTable is lowercasing column names for Oracle as intended.

table.PrimaryKeyColumns, though, comes back as ["Id"] — the EF property casing, unnormalized. The primary-key column list appears to be populated from a different path than the column list, and that path skips whatever lowercasing the Oracle mapping applies elsewhere.

Whether the right fix is to normalize PrimaryKeyColumns at the same point the columns are normalized, or to make the test assert Oracle's uppercase convention, is worth deciding deliberately — the mismatch between HasColumn("id") passing and PrimaryKeyColumns containing "Id" is the actual bug regardless of which side moves.

This is pre-existing, not from the xUnit v3 migration

Verified by checking out pre-migration master in a separate worktree and running the same single test against the same Oracle container: it produces a byte-identical failure. Filed as follow-up from #393, where it surfaced.

Why CI doesn't catch it

.github/workflows/ci-build-efcore.yml runs with --filter "FullyQualifiedName!~Oracle", because that workflow has no Oracle service — the comment in the workflow says the Oracle EF suite "only runs locally against docker-compose". So the whole Oracle/ folder, including this test, never executes in CI.

That means this suite's Oracle coverage is only ever exercised by someone running it locally, and it has been red there. Two things could help beyond the fix itself:

• an Oracle service in the EF Core workflow so the folder actually runs (the standalone ci-build-oracle.yml already starts one via docker compose), or
• failing that, marking the known-bad test Skip with a link here, so a local run is green and the gap is explicit rather than discovered by surprise.

Repro

docker compose up -d oracle
dotnet test src/Weasel.EntityFrameworkCore.Tests/Weasel.EntityFrameworkCore.Tests.csproj \
  --framework net9.0 \
  --filter "FullyQualifiedName~Oracle.end_to_end.can_map_entity_to_table"

Related

Oracle/end_to_end.cs already carries a second, separately skipped test: [Fact(Skip = "Skipped due to pre-existing bug in Weasel.Oracle schema detection SQL (ORA-03048)")]. Different root cause, but the same corner of the codebase is accumulating known-broken Oracle EF behaviour that CI cannot see.

[jeremydmiller]

Correction: my original diagnosis above is wrong, and the title with it. There is no product bug here — the test assertion was wrong.

What's actually happening

MapToTable sets PreserveIdentifierCase = true, deliberately, so column names carry EF Core's casing verbatim. Dumping the mapped table confirms it:

Id, BoolValue, CASCADE_VAL, DateOnlyValue, DT_OFFSET_VAL, DateTimeValue,
GuidValue, IntValue, NULL_BOOL_VAL, NULL_CASCADE_VAL, NULL_DATE_VAL,
NULL_DT_OFFSET_VAL, NULL_DT_VAL, NULL_GUID_VAL, NULL_INT_VAL,
NULL_TIME_VAL, StringValue, TimeOnlyValue

Columns get the name passed to HasColumnName() where the model configures one (DT_OFFSET_VAL, NULL_*), and the CLR property name otherwise (Id, IntValue, StringValue). Nothing is lowercased. MyEntity.Id has no HasColumnName(), so the key column is "Id" and PrimaryKeyColumns returning ["Id"] is correct.

My claim that PrimaryKeyColumns "keeps EF casing while every other column is lowercased" was simply false — the other columns aren't lowercased either.

Why it looked like a mapping inconsistency

Weasel.Oracle's Table overrides NameComparison to StringComparison.OrdinalIgnoreCase (src/Weasel.Oracle/Tables/Table.cs:74), and HasColumn uses it (src/Weasel.Core/TableBase.cs:147). So every one of the surrounding assertions —

table.HasColumn("intvalue").ShouldBeTrue();

— succeeds against a column actually named "IntValue", and would succeed for any casing. They assert nothing about names beyond their letters.

PrimaryKeyColumns.ShouldContain("id") was the single case-sensitive assertion in the test. That is the whole reason it was the only one that failed, and why the test read as a casing inconsistency in the mapping rather than what it was: fourteen assertions that couldn't fail, plus one that was written against a convention the code never had.

Fix

PR #395. The HasColumn series is replaced with one assertion on the full column-name set, so the test pins the casing contract rather than passing regardless of it, and the // Oracle lowercases column names in Weasel comment is corrected.

The two observations in the original report that do still stand:

• This predates the xUnit v3 migration (Migrate all test projects to xUnit v3 #393) — verified identical failure on the pre-migration commit.
• CI cannot see it: ci-build-efcore.yml has no Oracle service and runs with --filter "FullyQualifiedName!~Oracle", so the folder never executes. That gap is what let a test sit red for anyone running it locally. Worth considering separately from this fix.