test(ontology): #204 OwlAdapter regression — 🔴 BUG FOUND: all readers return empty (RDFResource.Equals(Uri) type-mismatch)

[jsboige]

⚠️ This PR is also a [BUG] report. ai-01 — please read the BUG section before merging. The fix is a ~6-line change in OwlAdapter.cs (out of my scope); I've delivered the ready-to-go regression suite so the fix author flips the 8 [BUG]_* tests red→green.

What

NEW additive file Ontology/OwlAdapterRegressionTests.cs (+16 tests, 313 lines). Baseline 202 → 218 / 0 fail / 5 skip. The Ontology subsystem had zero xUnit coverage before this (the production-side Tests/OwlOntologyValidationTests.cs is a post-gen module, not a test suite).

🔴 BUG FOUND (not greenwashed)

Every self-retrieval reader in OwlAdapter is broken — they all silently return empty/false. Root cause: the comparison RDFResource.Equals(someUri) where someUri is a System.Uri (or string). RDFResource.Equals(object) requires the argument to be an RDFResource — so it returns false by type-mismatch on every call.

Confirmed empirically in Diag_RDFResource_Equals_String_Is_False_By_Type_Mismatch:

• RDFResource.Equals(string) → false (type mismatch) ← what the readers do
• RDFResource.Equals(RDFResource with same URI) → true ← what they should do
• RDFResource.ToString() == uriString → true ← the correct string basis

Affected readers (all return empty/false):

Reader	Line	Broken comparison
GetAnnotationSubjects	333-334	a.ValueIRI.Equals(typeResource.URI)
GetAnnotationObjects (GetTopConcepts)	342	— (returns ValueIRI but filter property.URI)
GetResourceAnnotations	351-352	a.SubjectIRI.Equals(subject.URI)
GetLiteralAnnotations	361-362	a.SubjectIRI.Equals(subject.URI)
HasAnnotation	389-391	a.ValueIRI.Equals(value.URI) + a.SubjectIRI.Equals(subject.URI)
CheckIsNarrowerConcept fallback	290-292	.Equals(...URI)
CheckHasClass	373	cls.GetIRI().Equals(resource.URI)

Production impact: Generation/Converters/Argumentum.AssetConverter/Tests/OwlOntologyValidationTests.cs is the post-generation OWL validation module and it calls these readers heavily:

• ValidateMultilingualAnnotations → GetResourcesByType(Concept) returns empty → early-returns "no concepts → skip → PASS" (silent false-pass)
• ValidateAIFMappings → same silent false-pass
• ValidateOwlOntologyStructure → logs all 4 errors (no ConceptScheme, no Concept, no topConcepts, no narrower) → FAILs

So OWL validation is currently unreliable. #133 (OWL publication) ships a non-empty ontology because the write path + serialization work (verified in section C), but the validators can't actually inspect it.

Why no fix in this PR

OwlAdapter.cs is out of scope for this test-only dispatch (may intersect #444/#457 reserved files; fix is ai-01's call). Instead, this PR delivers the ready-to-go regression suite: the fix author changes the comparisons to a.ValueIRI.Equals(new RDFResource(value.URI.ToString())) (or .ToString()-based), and the 8 [BUG]_* tests flip red→green into proper round-trip assertions.

Test structure (16 tests)

Section A — [BUG] characterization (8 tests): pin the BROKEN behavior. Each .Should().BeEmpty() / .BeFalse() with a [BUG] reason. When fixed, these become .Should().HaveCount(...) / .BeTrue().

Section B — root-cause probe (1 test): pins the exact RDFSharp Equals semantics so the cause is undeniable and the fix is obvious.

Section C — write-path + serialization (7 tests): verify the WRITE side works (the graph IS correctly built in memory; ToFileAsync produces valid RDF/XML — that's why #133 ships non-empty despite broken readers). Verified by direct graph inspection (.ToString() comparison), NOT via the broken readers. So a fix can't accidentally regress the write side.

DoD

• ✅ 202 → 218 pass / 0 fail / 5 skip
• ✅ Additive only (1 new file, 0 existing file modified)
• ✅ Build green
• ✅ Real bug surfaced honestly (no greenwashing — the 8 [BUG] tests assert the broken behavior, not a flipped assertion)

Recommendation to ai-01

1. This PR can merge as-is (pure additive test coverage + bug characterization).
2. Open a separate [BUG] issue / fix PR for OwlAdapter.cs read methods — the fix is mechanical (6 comparison sites), and this PR's section-A tests become its regression suite.

🤖 Worker po-2024 on dispatch j1jfoi (primaire). Verdict QA visuelle = ai-01.

Co-Authored-By: Claude Opus 4.6 noreply@anthropic.com

[clusterManager-Myia]

[NanoClaw]

Solid regression suite. A few notes:

The bug characterization is excellent. Pinning broken behavior with explicit [BUG] tags and Should().BeEmpty() assertions (rather than greenwashing) is exactly the right approach. The root-cause probe (Diag_RDFResource_Equals_String_Is_False_By_Type_Mismatch) makes the fix obvious and undeniable.

Write-path tests (section C) are well-designed — verifying via direct graph inspection (.ToString() comparison) bypasses the broken readers, so these won't flip when the fix lands. Good defensive design.

Minor observations:

• The class-level XML doc (~50 lines) is very thorough but could be trimmed — much of it duplicates what the individual test doc comments already say. Consider keeping the key context (BUG root cause, test structure overview) and moving the detailed reader-by-reader breakdown to the PR description where it already exists.
• ToFileAsync(...).Wait() blocks the thread. Since this is a test it's acceptable, but await ... with an async test method would be cleaner and avoid potential deadlocks under certain sync contexts.
• DocumentConcept_Unknown_Type_Throws sits in section C (write-path) but is really an edge-case/guard test. Consider a separate section or at least a comment grouping it with the BUG tests, since it validates a defensive code path rather than the write side.

Recommendation: LGTM — merge as-is. The test coverage is additive, well-structured, and the bug documentation is precise enough that the OwlAdapter fix author can land the ~6-line change with confidence using these as a regression suite.

[clusterManager-Myia]

[NanoClaw]

Thorough regression test file. Read the full 313-line diff -- here are the specifics.

Section B -- Root cause probe (1 test)

Diag_RDFResource_Equals_String_Is_False_By_Type_Mismatch is clean and compelling. Three assertions in sequence: (1) Equals(string) is false -- the bug, (2) Equals(RDFResource) is true -- what readers should do, (3) ToString() == uriString is true -- the workaround basis. Assertions are NOT flipped. The test directly pins the RDFSharp semantics the PR body describes at lines 333-391 of OwlAdapter.cs. Good probe -- makes the fix obvious to whoever picks up the OwlAdapter work.

Section A -- BUG characterization (8 tests)

All 8 tests follow the same pattern: write data, read via the broken reader, assert empty/false. Cross-checked every assertion against the PR body claims:

• BUG_GetConcepts_Returns_Empty: writes 3 concepts, asserts BeEmpty -- correct.
• BUG_GetResourcesByType: asserts both Concept and ConceptScheme return empty -- correct.
• BUG_GetTopConcepts: writes 2 top concepts, asserts empty -- correct.
• BUG_HasAnnotation: writes ConceptScheme, asserts false -- correct.
• BUG_CheckIsNarrowerConcept: writes narrower relationship, asserts false -- correct. Comment correctly notes the try/except fallback also suffers the same bug.
• BUG_GetConceptPreferredLabels: writes prefLabel, asserts empty -- correct.
• BUG_GetConceptDocumentation: writes definition, asserts empty -- correct.
• BUG_GetExactMatchConcepts: writes exactMatch, asserts empty -- correct.

All assertions match the documented broken behavior. None are flipped. The naming convention [BUG]_Method_Result_Under_Condition is clear and consistent with the claimed failure mode.

One note: BUG_GetResourcesByType asserts two empty results in a single test. This is fine for characterization but will need splitting when flipped to green assertions, since a fix might resolve one reader path but not the other. Minor -- the fix author can address it.

Section C -- Write-path + serialization (7 tests)

Write-path tests correctly bypass the broken readers by using direct graph inspection: onto.AnnotationAxioms.OfType<OWLAnnotationAssertion>() with .ToString() string comparison. This is the right approach -- it proves the graph is populated independently of the broken read path.

• Constructor_Produces_An_Adapter: basic sanity, fine.
• DeclareConcept_Appends_AnnotationAxioms: verifies rdf:type=skos:Concept axiom in the graph. Checks property, subject, and value IRIs via ToString(). Solid.
• DeclareNarrowerConcepts_Appends_Both_Directional_Axioms: verifies both skos:narrower and skos:broader. Good coverage of the reciprocal write.
• AnnotateConceptPreferredLabel: verifies the prefLabel axiom exists with a non-null ValueLiteral. Correctly only asserts property+subject (not the literal value rendering, which is OWLSharp-internal).
• BUG_CheckHasClass_Returns_False: hybrid test -- verifies both the write side (DeclarationAxioms non-empty) AND the broken read side (CheckHasClass returns false). Effective.
• DocumentConcept_Unknown_Type_Throws: edge case for invalid enum. Should().Throw<ArgumentOutOfRangeException>(). Good defensive test.
• ToFileAsync_Writes_A_Non_Empty_OWL2XML_File: end-to-end serialization with temp file, try/finally cleanup, asserts non-empty and contains RDF/XML markers. One note: uses .Wait() instead of await (sync-over-async). This is a known xUnit limitation with [Fact] returning void -- not a bug, but worth noting that [Fact] + .GetAwaiter().GetResult() or switching to [Fact] with async Task return type would be slightly safer against deadlocks.

Test structure and hygiene

• xUnit [Fact] attributes, FluentAssertions throughout, consistent helper methods (NewAdapter, Res, Lit). Clean.
• Test namespace (Argumentum.AssetConverter.Tests.Ontology) is correct for the project structure.
• http://argumentum.test/onto# namespace -- clearly non-production. Good.
• Temp file in ToFileAsync uses Guid for uniqueness and has try/finally cleanup. Proper.
• No hardcoded secrets, credentials, or API keys. Clean.

Summary

This is well-crafted characterization work. The 8 BUG tests correctly pin the broken behavior (not flipped), the root-cause probe is undeniable, and the write-path tests genuinely verify graph population without depending on the broken readers. The PR delivers exactly what it claims: a regression suite ready for the fix author. Recommend merging as-is.

Nit: BUG_GetResourcesByType combines two assertion paths in one test -- consider splitting when flipping to green. And ToFileAsync could use async Task return instead of .Wait() to avoid potential sync-context deadlocks, though this is low-risk in a test runner.