@glossarist/concept-browser 0.7.51 → 0.7.53

package/src/__tests__/concept-rdf/use-rdf-document.test.ts

@@ -0,0 +1,246 @@
+import { describe, it, expect } from 'vitest';
+import { computed, ref, nextTick } from 'vue';
+import { Concept } from 'glossarist';
+import { useRdfDocument } from '../../components/concept-rdf/use-rdf-document';
+import { RDF_PREFIXES, findPrefix } from '../../components/concept-rdf/rdf-prefixes';
+
+function makeConcept(): Concept {
+  return Concept.fromJSON({
+    id: '3.1.1',
+    uri: 'https://glossarist.org/test/concept/3.1.1',
+    status: 'valid',
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [
+          { type: 'expression', designation: 'atomic data unit', normative_status: 'preferred' },
+          { type: 'expression', designation: 'ADU', normative_status: 'admitted' },
+        ],
+        definition: [{ content: 'A data unit that cannot be subdivided.' }],
+        notes: [{ content: 'Note here.' }],
+      },
+    },
+  });
+}
+
+function makeConceptWithNonVerbal(): Concept {
+  return Concept.fromJSON({
+    id: '3.1.2',
+    uri: 'https://glossarist.org/test/concept/3.1.2',
+    status: 'valid',
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [{ type: 'expression', designation: 'angle of repose', normative_status: 'preferred' }],
+        definition: [{ content: 'Angle formed by a material at rest.' }],
+        non_verbal_rep: [
+          { type: 'figure', caption: 'Angle of repose diagram', description: 'Schematic diagram showing the angle', images: [{ src: 'fig_A.23.svg' }] },
+          { type: 'formula', caption: 'tan(θ) = μ' },
+        ],
+      },
+    },
+  });
+}
+
+describe('useRdfDocument — Turtle emission contract', () => {
+  it('declares skosxl: prefix and never xl:', () => {
+    const c = ref(makeConcept());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(turtle.value).toContain('@prefix skosxl: <http://www.w3.org/2008/05/skos-xl#>');
+    expect(turtle.value).not.toContain('@prefix xl:');
+    expect(turtle.value).not.toMatch(/\bxl:/);
+  });
+
+  it('emits BOTH skosxl:prefLabel AND skos:prefLabel', () => {
+    const c = ref(makeConcept());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(turtle.value).toMatch(/skosxl:prefLabel\s+<[^>]+\/eng\/desig\//);
+    expect(turtle.value).toMatch(/skos:prefLabel "atomic data unit"@eng/);
+  });
+
+  it('emits BOTH skosxl:altLabel AND skos:altLabel for admitted designations', () => {
+    const c = ref(makeConcept());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(turtle.value).toMatch(/skosxl:altLabel\s+<[^>]+\/eng\/desig\//);
+    expect(turtle.value).toMatch(/skos:altLabel "ADU"@eng/);
+  });
+
+  it('emits skos:definition with language tag', () => {
+    const c = ref(makeConcept());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(turtle.value).toMatch(/skos:definition "A data unit that cannot be subdivided\."@eng/);
+  });
+
+  it('emits gloss:hasDefinition as a typed gloss:DetailedDefinition with rdf:value', () => {
+    const c = ref(makeConcept());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(turtle.value).toMatch(/gloss:hasDefinition \[ (a|rdf:type) gloss:DetailedDefinition ; rdf:value "[^"]+"@eng \]/);
+  });
+
+  it('terminates the concept resource with a full stop (not a trailing semicolon)', () => {
+    const c = ref(makeConcept());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    const block = turtle.value.split('\n\n')[1] ?? '';
+    expect(block).toMatch(/<[^>]+> a gloss:Concept, skos:Concept ;[\s\S]+gloss:hasLocalization <[^>]+>/);
+    expect(block).toMatch(/\.$/);
+    expect(block).not.toMatch(/;\s*$/);
+  });
+
+  it('attaches provenance triples to the concept resource', () => {
+    const c = ref(makeConcept());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(turtle.value).toMatch(/prov:wasGeneratedBy <activity\/serializers\/concept-browser\//);
+    expect(turtle.value).toMatch(/prov:generatedAtTime "[^"]+"\^\^xsd:dateTime/);
+  });
+});
+
+describe('useRdfDocument — JSON-LD emission contract', () => {
+  it('produces a parseable JSON-LD document with @context and @graph', () => {
+    const c = ref(makeConcept());
+    const { jsonld } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    const doc = JSON.parse(jsonld.value);
+    expect(doc['@context']).toBeDefined();
+    expect(Array.isArray(doc['@graph'])).toBe(true);
+    expect(doc['@context'].skosxl).toBe('http://www.w3.org/2008/05/skos-xl#');
+  });
+
+  it('emits the concept node and at least one localized concept', () => {
+    const c = ref(makeConcept());
+    const { jsonld } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    const doc = JSON.parse(jsonld.value);
+    const types = doc['@graph'].map((n: any) => n['@type']);
+    expect(types.some((t: any) => Array.isArray(t) && t.includes('gloss:Concept'))).toBe(true);
+    expect(types.some((t: any) => Array.isArray(t) && t.includes('gloss:LocalizedConcept'))).toBe(true);
+  });
+});
+
+describe('useRdfDocument — non-verbal representation emission (WS K)', () => {
+  it('emits gloss:hasNonVerbalRepresentation for NVR with caption (K4 URI form)', () => {
+    const c = ref(makeConceptWithNonVerbal());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(turtle.value).toMatch(/gloss:hasNonVerbalRepresentation <[^>]+\/nvr\/[^>]+>/);
+    expect(turtle.value).toMatch(/(a|rdf:type) gloss:NonVerbalRep/);
+    expect(turtle.value).toMatch(/skosxl:prefLabel \[/);
+  });
+
+  it('emits gloss:image as xsd:anyURI on the NVR resource', () => {
+    const c = ref(makeConceptWithNonVerbal());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(turtle.value).toMatch(/gloss:image "fig_A\.23\.svg"\^\^xsd:anyURI/);
+  });
+
+  it('emits NVR URIs in JSON-LD with NonVerbalRep type', () => {
+    const c = ref(makeConceptWithNonVerbal());
+    const { jsonld } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    const doc = JSON.parse(jsonld.value);
+    const nvrNodes = doc['@graph'].filter((n: any) => {
+      const t = n['@type'];
+      return Array.isArray(t) ? t.includes('gloss:NonVerbalRep') : t === 'gloss:NonVerbalRep';
+    });
+    expect(nvrNodes.length).toBeGreaterThanOrEqual(1);
+    const lcNode = doc['@graph'].find((n: any) => Array.isArray(n['@type']) && n['@type'].includes('gloss:LocalizedConcept'));
+    expect(lcNode).toBeDefined();
+    const refRaw = lcNode['gloss:hasNonVerbalRepresentation'];
+    const refArr = Array.isArray(refRaw) ? refRaw : [refRaw];
+    expect(refArr.length).toBeGreaterThanOrEqual(1);
+    expect(refArr[0]['@id']).toMatch(/\/nvr\/[^/]+$/);
+  });
+
+  it('includes non-verbal reps in the sections view', () => {
+    const c = ref(makeConceptWithNonVerbal());
+    const { sections } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    const lcSection = sections.value.find(s => s.classId === 'gloss:LocalizedConcept');
+    expect(lcSection).toBeDefined();
+    const nvrProps = lcSection!.props.filter(p =>
+      p.predicate === 'gloss:hasNonVerbalRepresentation' || p.predicate === 'gloss:hasNonVerbalRep',
+    );
+    expect(nvrProps.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('omits non-verbal emission when the concept has no non-verbal reps', () => {
+    const c = ref(makeConcept());
+    const { turtle, jsonld } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(turtle.value).not.toMatch(/gloss:hasNonVerbalRep/);
+    expect(turtle.value).not.toMatch(/gloss:hasNonVerbalRepresentation/);
+    const doc = JSON.parse(jsonld.value);
+    const lcNode = doc['@graph'].find((n: any) => Array.isArray(n['@type']) && n['@type'].includes('gloss:LocalizedConcept'));
+    expect(lcNode['gloss:hasNonVerbalRep']).toBeUndefined();
+  });
+});
+
+describe('useRdfDocument — reactivity', () => {
+  it('recomputes turtle when the concept changes', async () => {
+    const c = ref(makeConcept());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    const before = turtle.value;
+    expect(before).toContain('atomic data unit');
+
+    const next = Concept.fromJSON({
+      id: '4.5.6',
+      uri: 'https://glossarist.org/test/concept/4.5.6',
+      status: 'valid',
+      localizations: {
+        eng: {
+          language_code: 'eng',
+          entry_status: 'valid',
+          terms: [{ type: 'expression', designation: 'different designation', normative_status: 'preferred' }],
+          definition: [{ content: 'Different definition.' }],
+        },
+      },
+    });
+    c.value = next;
+    await nextTick();
+    expect(turtle.value).not.toBe(before);
+    expect(turtle.value).toContain('different designation');
+  });
+
+  it('returns one section per concept + localized concept + designation', () => {
+    const c = ref(makeConcept());
+    const { sections } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    const labels = sections.value.map(s => s.classId);
+    expect(labels).toContain('gloss:Concept');
+    expect(labels).toContain('gloss:LocalizedConcept');
+    expect(labels.filter(l => l === 'gloss:Expression').length).toBe(2);
+  });
+
+  it('emits a type chain ending in gloss:Concept', () => {
+    const c = ref(makeConcept());
+    const { typeChain } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    expect(typeChain.value[typeChain.value.length - 1]).toBe('gloss:Concept');
+  });
+
+  it('can be consumed inside another computed without re-triggering the emitter', () => {
+    const c = ref(makeConcept());
+    const { turtle } = useRdfDocument(() => c.value, () => c.value.uri ?? '');
+    const upper = computed(() => turtle.value.split('\n').length);
+    const initial = upper.value;
+    expect(initial).toBeGreaterThan(5);
+    // No mutation: reading upper twice doesn't recompute turtle.
+    expect(upper.value).toBe(initial);
+  });
+});
+
+describe('rdf-prefixes legend', () => {
+  it('declares all canonical prefixes used by the emitter', () => {
+    const declared = new Set(RDF_PREFIXES.map(p => p.prefix));
+    for (const required of ['gloss', 'skos', 'skosxl', 'rdf', 'dcterms']) {
+      expect(declared.has(required)).toBe(true);
+    }
+  });
+
+  it('lookup returns the matching prefix entry', () => {
+    expect(findPrefix('skosxl')?.iri).toBe('http://www.w3.org/2008/05/skos-xl#');
+  });
+
+  it('returns undefined for unknown prefixes', () => {
+    expect(findPrefix('does-not-exist')).toBeUndefined();
+  });
+
+  it('skosxl prefix resolves to the canonical IRI (settlement decision)', () => {
+    const skosxl = findPrefix('skosxl');
+    expect(skosxl).toBeDefined();
+    expect(skosxl!.iri).toBe('http://www.w3.org/2008/05/skos-xl#');
+  });
+});

package/src/__tests__/concept-rdf/version-emitter.test.ts

@@ -0,0 +1,120 @@
+import { describe, it, expect } from 'vitest';
+import { Parser, Store } from 'n3';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import { emitVersionGraph, emitVersionHistory } from '../../components/concept-rdf/version-emitter';
+
+const PROV = 'http://www.w3.org/ns/prov#';
+const DCTERMS = 'http://purl.org/dc/terms/';
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+const VERSION_IRI = 'https://glossarist.org/test/versions/1.0';
+
+function makeInput() {
+  return {
+    registerId: 'test',
+    version: '1.0',
+    versionIri: VERSION_IRI,
+    datasetIri: 'https://glossarist.org/test/',
+    generatedAt: '2026-06-28T12:00:00Z',
+  };
+}
+
+describe('emitVersionGraph — J6 dataset versioning', () => {
+  it('types the version as prov:Entity', () => {
+    const graph = emitVersionGraph(makeInput());
+    const store = parse(writeTurtle(graph));
+    const types = store.getObjects(VERSION_IRI, RDF_TYPE, null).map(q => q.value);
+    expect(types).toContain(`${PROV}Entity`);
+  });
+
+  it('emits dcterms:isVersionOf pointing at the canonical dataset IRI', () => {
+    const graph = emitVersionGraph(makeInput());
+    const store = parse(writeTurtle(graph));
+    const targets = store.getObjects(VERSION_IRI, `${DCTERMS}isVersionOf`, null).map(q => q.value);
+    expect(targets).toContain('https://glossarist.org/test/');
+  });
+
+  it('emits prov:generatedAtTime as xsd:dateTime', () => {
+    const graph = emitVersionGraph(makeInput());
+    const store = parse(writeTurtle(graph));
+    const ts = store.getObjects(VERSION_IRI, `${PROV}generatedAtTime`, null).map(q => q.value);
+    expect(ts).toContain('2026-06-28T12:00:00Z');
+  });
+
+  it('emits prov:wasRevisionOf when a previous version is provided', () => {
+    const graph = emitVersionGraph({ ...makeInput(), previousVersionIri: 'https://glossarist.org/test/versions/0.9' });
+    const store = parse(writeTurtle(graph));
+    const prev = store.getObjects(VERSION_IRI, `${PROV}wasRevisionOf`, null).map(q => q.value);
+    expect(prev).toContain('https://glossarist.org/test/versions/0.9');
+  });
+
+  it('omits prov:wasRevisionOf when no previous version', () => {
+    const graph = emitVersionGraph(makeInput());
+    const store = parse(writeTurtle(graph));
+    const prev = store.getObjects(VERSION_IRI, `${PROV}wasRevisionOf`, null);
+    expect(prev).toHaveLength(0);
+  });
+
+  it('records change summary and associated agent when provided', () => {
+    const graph = emitVersionGraph({
+      ...makeInput(),
+      changeSummary: 'Initial release',
+      associatedAgentIri: 'https://glossarist.org/agent/ci-bot',
+    });
+    const store = parse(writeTurtle(graph));
+    const summaries = store.getObjects(VERSION_IRI, `${DCTERMS}description`, null).map(q => q.value);
+    expect(summaries).toContain('Initial release');
+    const agents = store.getObjects(VERSION_IRI, `${PROV}wasAssociatedWith`, null).map(q => q.value);
+    expect(agents).toContain('https://glossarist.org/agent/ci-bot');
+  });
+});
+
+describe('emitVersionHistory', () => {
+  it('emits a chain of versions with prov:wasRevisionOf links', () => {
+    const graph = emitVersionHistory({
+      registerId: 'test',
+      datasetIri: 'https://glossarist.org/test/',
+      versions: [
+        { version: '1.0', generatedAt: '2024-01-01T00:00:00Z' },
+        { version: '1.1', generatedAt: '2024-06-01T00:00:00Z', changeSummary: 'Add 50 terms' },
+        { version: '2.0', generatedAt: '2025-01-01T00:00:00Z', changeSummary: 'Major release' },
+      ],
+      associatedAgentIri: 'https://glossarist.org/agent/ci-bot',
+    });
+
+    const store = parse(writeTurtle(graph));
+    const iri10 = 'https://glossarist.org/test/versions/1.0';
+    const iri11 = 'https://glossarist.org/test/versions/1.1';
+    const iri20 = 'https://glossarist.org/test/versions/2.0';
+
+    expect(store.getObjects(iri10, RDF_TYPE, null).length).toBeGreaterThan(0);
+    expect(store.getObjects(iri11, RDF_TYPE, null).length).toBeGreaterThan(0);
+    expect(store.getObjects(iri20, RDF_TYPE, null).length).toBeGreaterThan(0);
+
+    const v11Prev = store.getObjects(iri11, `${PROV}wasRevisionOf`, null).map(q => q.value);
+    expect(v11Prev).toContain(iri10);
+
+    const v20Prev = store.getObjects(iri20, `${PROV}wasRevisionOf`, null).map(q => q.value);
+    expect(v20Prev).toContain(iri11);
+
+    const v10Prev = store.getObjects(iri10, `${PROV}wasRevisionOf`, null);
+    expect(v10Prev).toHaveLength(0);
+  });
+
+  it('emits an empty graph when versions array is empty', () => {
+    const graph = emitVersionHistory({
+      registerId: 'test',
+      datasetIri: 'https://glossarist.org/test/',
+      versions: [],
+    });
+    const resources = Array.from(graph.resources());
+    expect(resources.length).toBe(0);
+  });
+});

package/src/__tests__/concept-rdf/vocabulary-ssot.test.ts

@@ -0,0 +1,100 @@
+import { describe, it, expect } from 'vitest';
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { Parser, Store } from 'n3';
+import { writeTurtle } from '../../components/concept-rdf/turtle-writer';
+import { emitVocabularyGraph, VOCAB_SCHEMES } from '../../components/concept-rdf/vocabulary-emitter';
+
+const VOCAB_JSON = JSON.parse(readFileSync(join(process.cwd(), 'data', 'glossarist-vocab.json'), 'utf8'));
+
+function parse(turtle: string): Store {
+  const parser = new Parser({ format: 'Turtle' });
+  const store = new Store();
+  store.addQuads(parser.parse(turtle));
+  return store;
+}
+
+const SKOS = 'http://www.w3.org/2004/02/skos/core#';
+const RDF_TYPE = 'http://www.w3.org/1999/02/22-rdf-syntax-ns#type';
+
+const EXPECTED_REL_TYPES = [
+  'deprecates', 'deprecated_by', 'supersedes', 'superseded_by', 'replaces', 'replaced_by',
+  'invalidates', 'invalidated_by', 'retires', 'retired_by',
+  'narrower', 'broader', 'broader_generic', 'narrower_generic',
+  'broader_partitive', 'narrower_partitive', 'has_part', 'is_part_of',
+  'broader_instantial', 'narrower_instantial', 'instance_of', 'has_instance',
+  'equivalent', 'exact_match', 'close_match', 'broad_match', 'narrow_match', 'related_match',
+  'compare', 'contrast',
+  'see', 'references', 'related_concept', 'related_concept_broader', 'related_concept_narrower',
+  'sequentially_related', 'spatially_related', 'temporally_related',
+  'homograph', 'false_friend',
+  'has_concept', 'is_concept_of', 'has_definition', 'definition_of',
+  'inherits', 'inherited_by',
+  'has_version', 'version_of', 'current_version', 'current_version_of',
+  'derived',
+];
+
+describe('A1/A2/C1 — vocabulary SSOT', () => {
+  it('VOCAB_SCHEMES loads from data/glossarist-vocab.json at module init', () => {
+    expect(VOCAB_SCHEMES.length).toBe(VOCAB_JSON.schemes.length);
+  });
+
+  it('every scheme entry in JSON appears in VOCAB_SCHEMES', () => {
+    const expected = new Set(VOCAB_JSON.schemes.map((s: any) => s.schemeIri));
+    const actual = new Set(VOCAB_SCHEMES.map(s => s.schemeIri));
+    expect(actual).toEqual(expected);
+  });
+
+  it('TS and mjs consumers read the same JSON file (single source of truth)', () => {
+    const tsCount = VOCAB_SCHEMES.reduce((acc, s) => acc + s.terms.length, 0);
+    const jsonCount = VOCAB_JSON.schemes.reduce(
+      (acc: number, s: any) => acc + s.terms.length, 0,
+    );
+    expect(tsCount).toBe(jsonCount);
+  });
+});
+
+describe('C1 — all 52 relationship types are declared', () => {
+  it('relationship-type scheme declares every type in EXPECTED_REL_TYPES', () => {
+    const relScheme = VOCAB_SCHEMES.find(s => s.schemeIri === 'gloss:rel-scheme');
+    expect(relScheme).toBeDefined();
+    const declared = new Set(relScheme!.terms.map(t => t.label));
+    for (const expected of EXPECTED_REL_TYPES) {
+      expect(declared.has(expected)).toBe(true);
+    }
+  });
+
+  it('relationship-type count matches glossarist-ruby config.yml (50 canonical + legacy)', () => {
+    const relScheme = VOCAB_SCHEMES.find(s => s.schemeIri === 'gloss:rel-scheme');
+    // glossarist-ruby config.yml related_concept.type lists 50 types. We add 'derived' as a legacy alias.
+    expect(relScheme!.terms.length).toBeGreaterThanOrEqual(50);
+  });
+
+  it('every relationship type IRI follows the gloss:rel/{type} pattern', () => {
+    const relScheme = VOCAB_SCHEMES.find(s => s.schemeIri === 'gloss:rel-scheme');
+    for (const term of relScheme!.terms) {
+      expect(term.iri).toMatch(/^gloss:rel\/[a-z_]+$/);
+    }
+  });
+
+  it('every relationship type is a skos:Concept in the emitted graph', () => {
+    const ttl = writeTurtle(emitVocabularyGraph());
+    const store = parse(ttl);
+    for (const term of VOCAB_SCHEMES.find(s => s.schemeIri === 'gloss:rel-scheme')!.terms) {
+      const iri = `https://www.glossarist.org/ontologies/rel/${term.label}`;
+      const types = store.getObjects(iri, RDF_TYPE, null).map(q => q.value);
+      expect(types).toContain(`${SKOS}Concept`);
+    }
+  });
+});
+
+describe('C1 — vocabulary emits without drift between TS and mjs', () => {
+  it('emitted Turtle contains every scheme and every term', () => {
+    const ttl = writeTurtle(emitVocabularyGraph());
+    for (const scheme of VOCAB_SCHEMES) {
+      for (const term of scheme.terms) {
+        expect(ttl).toContain(term.label);
+      }
+    }
+  });
+});

package/src/__tests__/concept-rdf-view.test.ts

@@ -0,0 +1,136 @@
+import { describe, it, expect } from 'vitest';
+import { mount } from '@vue/test-utils';
+import { createPinia } from 'pinia';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import ConceptRdfView from '../components/ConceptRdfView.vue';
+import { Concept } from 'glossarist';
+import { CONCEPT_FIXTURES } from './__fixtures__/concepts';
+
+function makeConcept(): Concept {
+  return Concept.fromJSON({
+    id: '3.1.1',
+    uri: 'https://glossarist.org/test/concept/3.1.1',
+    status: 'valid',
+    localizations: {
+      eng: {
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [
+          { type: 'expression', designation: 'atomic data unit', normative_status: 'preferred' },
+          { type: 'expression', designation: 'ADU', normative_status: 'admitted' },
+        ],
+        definition: [{ content: 'A data unit that cannot be subdivided.' }],
+        notes: [{ content: 'Note here.' }],
+      },
+    },
+  });
+}
+
+async function mountRdfView() {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [{ path: '/', name: 'home', component: { template: '<div/>' } }],
+  });
+  const wrapper = mount(ConceptRdfView, {
+    global: {
+      plugins: [createPinia(), router],
+    },
+    props: {
+      concept: makeConcept(),
+      registerId: 'test',
+      conceptUriValue: 'https://glossarist.org/test/concept/3.1.1',
+    },
+  });
+  await router.isReady();
+  return wrapper;
+}
+
+async function openRdfSourcePanel(wrapper: ReturnType<typeof mount>) {
+  const toggle = wrapper.find('button.w-full');
+  await toggle.trigger('click');
+}
+
+async function mountFixture(uri: string, concept: Concept) {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [{ path: '/', name: 'home', component: { template: '<div/>' } }],
+  });
+  const wrapper = mount(ConceptRdfView, {
+    global: { plugins: [createPinia(), router] },
+    props: { concept, registerId: 'fixtures', conceptUriValue: uri },
+  });
+  await router.isReady();
+  await openRdfSourcePanel(wrapper);
+  return wrapper;
+}
+
+describe('ConceptRdfView — Turtle emission', () => {
+  it('declares the skosxl: prefix (not xl:)', async () => {
+    const wrapper = await mountRdfView();
+    await openRdfSourcePanel(wrapper);
+    const pre = wrapper.find('pre');
+    const text = pre.text();
+    expect(text).toContain('@prefix skosxl: <http://www.w3.org/2008/05/skos-xl#>');
+    expect(text).not.toContain('@prefix xl:');
+  });
+
+  it('uses skosxl: consistently (no stray xl: references)', async () => {
+    const wrapper = await mountRdfView();
+    await openRdfSourcePanel(wrapper);
+    const text = wrapper.find('pre').text();
+    expect(text).not.toMatch(/\bxl:/);
+    expect(text).toContain('skosxl:Label');
+    expect(text).toContain('skosxl:literalForm');
+  });
+
+  it('emits BOTH skosxl:prefLabel (reified) AND skos:prefLabel (direct literal)', async () => {
+    const wrapper = await mountRdfView();
+    await openRdfSourcePanel(wrapper);
+    const text = wrapper.find('pre').text();
+    expect(text).toMatch(/skosxl:prefLabel\s+<[^>]+\/eng\/desig\//);
+    expect(text).toMatch(/skos:prefLabel "atomic data unit"@eng/);
+  });
+
+  it('emits BOTH skosxl:altLabel AND skos:altLabel for non-preferred designations', async () => {
+    const wrapper = await mountRdfView();
+    await openRdfSourcePanel(wrapper);
+    const text = wrapper.find('pre').text();
+    expect(text).toMatch(/skosxl:altLabel\s+<[^>]+\/eng\/desig\//);
+    expect(text).toMatch(/skos:altLabel "ADU"@eng/);
+  });
+
+  it('emits skos:definition as a direct language-tagged literal', async () => {
+    const wrapper = await mountRdfView();
+    await openRdfSourcePanel(wrapper);
+    const text = wrapper.find('pre').text();
+    expect(text).toMatch(/skos:definition "A data unit that cannot be subdivided\."@eng/);
+  });
+
+  it('emits gloss:hasDefinition with a typed DetailedDefinition and language-tagged rdf:value', async () => {
+    const wrapper = await mountRdfView();
+    await openRdfSourcePanel(wrapper);
+    const text = wrapper.find('pre').text();
+    expect(text).toMatch(/gloss:hasDefinition \[ (a|rdf:type) gloss:DetailedDefinition ; rdf:value "[^"]+"@eng \]/);
+  });
+});
+
+describe('ConceptRdfView — Layer 6 fixture corpus snapshots', () => {
+  for (const fixture of CONCEPT_FIXTURES) {
+    it(`${fixture.name}: mounts and renders RDF for the fixture concept`, async () => {
+      const wrapper = await mountFixture(fixture.uri, fixture.concept);
+      const text = wrapper.find('pre').text();
+      expect(text).toContain('@prefix gloss:');
+      expect(text).toContain('@prefix skos:');
+      expect(text).toContain(`@prefix skosxl:`);
+      expect(text).toContain(fixture.uri);
+    });
+
+    it(`${fixture.name}: contains at least one skos:prefLabel per localization`, async () => {
+      const wrapper = await mountFixture(fixture.uri, fixture.concept);
+      const text = wrapper.find('pre').text();
+      for (const lang of fixture.concept.languages) {
+        expect(text).toMatch(new RegExp(`skos:prefLabel "[^"]+"@${lang}`));
+      }
+    });
+  }
+});

package/src/__tests__/config/group-renderers.test.ts

@@ -0,0 +1,35 @@
+import { describe, it, expect } from 'vitest';
+import { GROUP_RENDERERS, groupRendererFor } from '../../config/group-renderers';
+import type { DatasetGroupKind } from '../../config/types';
+
+describe('GROUP_RENDERERS registry', () => {
+  it('has an entry for every DatasetGroupKind', () => {
+    const expected: DatasetGroupKind[] = ['lineage', 'topic', 'family', 'collection', 'default'];
+    for (const kind of expected) {
+      expect(GROUP_RENDERERS[kind], `missing ${kind}`).toBeDefined();
+      expect(GROUP_RENDERERS[kind].sidebar, `missing sidebar for ${kind}`).toBeDefined();
+    }
+  });
+
+  it('lineage uses a distinct sidebar component', () => {
+    expect(GROUP_RENDERERS.lineage.sidebar).not.toBe(GROUP_RENDERERS.default.sidebar);
+  });
+
+  it('topic, family, collection, default share the DefaultGroupSidebar', () => {
+    const defaultSidebar = GROUP_RENDERERS.default.sidebar;
+    expect(GROUP_RENDERERS.topic.sidebar).toBe(defaultSidebar);
+    expect(GROUP_RENDERERS.family.sidebar).toBe(defaultSidebar);
+    expect(GROUP_RENDERERS.collection.sidebar).toBe(defaultSidebar);
+  });
+});
+
+describe('groupRendererFor', () => {
+  it('returns the correct renderer for each kind', () => {
+    expect(groupRendererFor('lineage').kind).toBe('lineage');
+    expect(groupRendererFor('topic').kind).toBe('topic');
+  });
+
+  it('falls back to default for unknown kinds', () => {
+    expect(groupRendererFor('nonexistent' as DatasetGroupKind)).toBe(GROUP_RENDERERS.default);
+  });
+});