@glossarist/concept-browser 0.3.4 → 0.4.0

package/src/__tests__/app-sidebar.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mount, flushPromises } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import AppSidebar from '../components/AppSidebar.vue';
+import { useVocabularyStore } from '../stores/vocabulary';
+import { useUiStore } from '../stores/ui';
+import type { Manifest } from '../adapters/types';
+
+function makeManifest(id = 'test'): Manifest {
+  return {
+    id,
+    datasetUri: `https://glossarist.org/${id}/concept`,
+    title: `Test ${id}`,
+    description: 'A test dataset',
+    owner: 'ISO',
+    baseUrl: `/data/${id}`,
+    languages: ['eng'],
+    conceptCount: 50,
+    conceptUrlTemplate: `/data/${id}/concepts/{id}.json`,
+    indexUrl: `/data/${id}/index.json`,
+    contextUrl: `/data/${id}/context.json`,
+    uriBase: 'https://glossarist.org',
+    status: 'published',
+    schemaVersion: '1.0',
+    tags: [],
+    lastUpdated: '2025-01-01',
+    sourceRepo: 'https://example.com/repo',
+    chunkSize: 1000,
+    color: '#3366ff',
+  };
+}
+
+async function createTestRouter(initialPath = '/') {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId', name: 'dataset', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId/concept/:conceptId', name: 'concept', component: { template: '<div/>' } },
+      { path: '/search', name: 'search', component: { template: '<div/>' } },
+      { path: '/graph', name: 'graph', component: { template: '<div/>' } },
+    ],
+  });
+  router.push(initialPath);
+  await router.isReady();
+  return router;
+}
+
+describe('AppSidebar', () => {
+  let pinia: ReturnType<typeof createPinia>;
+
+  beforeEach(() => {
+    pinia = createPinia();
+    setActivePinia(pinia);
+  });
+
+  function seedStore(datasets: string[] = ['test']) {
+    const store = useVocabularyStore();
+    for (const id of datasets) {
+      store.manifests.set(id, makeManifest(id));
+      store.datasets.set(id, { index: [], getConceptCount: () => 0, getConcepts: () => [] } as any);
+    }
+  }
+
+  async function mountSidebar(initialPath = '/') {
+    const router = await createTestRouter(initialPath);
+    return mount(AppSidebar, {
+      global: { plugins: [pinia, router], stubs: { NavIcon: true } },
+    });
+  }
+
+  it('renders navigation section', async () => {
+    seedStore();
+    const wrapper = await mountSidebar();
+    expect(wrapper.text()).toContain('Navigation');
+  });
+
+  it('renders dataset entries in sidebar', async () => {
+    seedStore(['iso1', 'iso2']);
+    const wrapper = await mountSidebar();
+    expect(wrapper.text()).toContain('Test iso1');
+    expect(wrapper.text()).toContain('Test iso2');
+  });
+
+  it('shows concept count for loaded datasets', async () => {
+    seedStore();
+    const wrapper = await mountSidebar();
+    expect(wrapper.text()).toContain('50 concepts');
+  });
+
+  it('navigates to dataset on click', async () => {
+    seedStore();
+    const router = await createTestRouter('/');
+    const wrapper = mount(AppSidebar, {
+      global: { plugins: [pinia, router], stubs: { NavIcon: true } },
+    });
+    const dsBtn = wrapper.findAll('button').find(b => b.text().includes('Test test'));
+    expect(dsBtn).toBeDefined();
+    await dsBtn!.trigger('click');
+    await flushPromises();
+    expect(router.currentRoute.value.name).toBe('dataset');
+    expect(router.currentRoute.value.params.registerId).toBe('test');
+  });
+
+  it('closes sidebar on dataset click (mobile)', async () => {
+    seedStore();
+    const wrapper = await mountSidebar();
+    const ui = useUiStore();
+    ui.sidebarOpen = true;
+    const dsBtn = wrapper.findAll('button').find(b => b.text().includes('Test test'));
+    await dsBtn!.trigger('click');
+    expect(ui.sidebarOpen).toBe(false);
+  });
+
+  it('shows mobile backdrop when sidebar open', async () => {
+    seedStore();
+    const wrapper = await mountSidebar();
+    const ui = useUiStore();
+    ui.sidebarOpen = true;
+    await wrapper.vm.$nextTick();
+    const backdrop = wrapper.find('.fixed.inset-0');
+    expect(backdrop.exists()).toBe(true);
+  });
+
+  it('hides mobile backdrop when sidebar closed', async () => {
+    seedStore();
+    const wrapper = await mountSidebar();
+    const ui = useUiStore();
+    ui.sidebarOpen = false;
+    await wrapper.vm.$nextTick();
+    const backdrop = wrapper.find('.fixed.inset-0');
+    expect(backdrop.exists()).toBe(false);
+  });
+
+  it('closes sidebar on backdrop click', async () => {
+    seedStore();
+    const wrapper = await mountSidebar();
+    const ui = useUiStore();
+    ui.sidebarOpen = true;
+    await wrapper.vm.$nextTick();
+    const backdrop = wrapper.find('.fixed.inset-0');
+    await backdrop.trigger('click');
+    expect(ui.sidebarOpen).toBe(false);
+  });
+
+  it('shows dataset-level nav when on dataset route', async () => {
+    seedStore();
+    const wrapper = await mountSidebar('/dataset/test');
+    // The dataset nav section shows when currentManifest exists
+    expect(wrapper.text()).toContain('Test test');
+  });
+
+  it('shows powered by link', async () => {
+    seedStore();
+    const wrapper = await mountSidebar();
+    expect(wrapper.text()).toContain('Glossarist Concept Browser');
+  });
+});

package/src/__tests__/asciidoc-lite.test.ts

@@ -74,7 +74,7 @@ describe('renderAsciiDocLite', () => {
 
   it('escapes HTML in source blocks', () => {
     const result = renderAsciiDocLite('----\n<a href="evil">\n----');
-    expect(result).toContain('&lt;a href=&quot;evil&quot;&gt;');
+    expect(result).toContain('&lt;a href="evil"&gt;');
     expect(result).not.toContain('<a href="evil">');
   });
 

package/src/__tests__/concept-card.test.ts

@@ -0,0 +1,115 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mount, flushPromises } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import ConceptCard from '../components/ConceptCard.vue';
+import { useVocabularyStore } from '../stores/vocabulary';
+import type { Manifest, ConceptSummary } from '../adapters/types';
+
+function makeManifest(): Manifest {
+  return {
+    id: 'test',
+    datasetUri: 'https://glossarist.org/test/concept',
+    title: 'Test Dataset',
+    description: 'A test dataset',
+    owner: 'ISO',
+    baseUrl: '/data/test',
+    languages: ['eng', 'fra'],
+    conceptCount: 10,
+    conceptUrlTemplate: '/data/test/concepts/{id}.json',
+    indexUrl: '/data/test/index.json',
+    contextUrl: '/data/test/context.json',
+    uriBase: 'https://glossarist.org',
+    status: 'published',
+    schemaVersion: '1.0',
+    tags: [],
+    lastUpdated: '2025-01-01',
+    sourceRepo: 'https://example.com/repo',
+    chunkSize: 1000,
+    color: '#3366ff',
+  };
+}
+
+function makeEntry(overrides: Partial<ConceptSummary> = {}): ConceptSummary {
+  return { id: '3.1.1.1', designations: { eng: 'test term' }, eng: 'test term', status: 'valid', ...overrides };
+}
+
+async function createTestRouter() {
+  return createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId', name: 'dataset', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId/concept/:conceptId', name: 'concept', component: { template: '<div/>' } },
+    ],
+  });
+}
+
+describe('ConceptCard', () => {
+  let pinia: ReturnType<typeof createPinia>;
+  let router: Awaited<ReturnType<typeof createTestRouter>>;
+
+  beforeEach(async () => {
+    pinia = createPinia();
+    setActivePinia(pinia);
+    router = await createTestRouter();
+    router.push('/');
+    await router.isReady();
+    const store = useVocabularyStore();
+    store.manifests.set('test', makeManifest());
+    store.datasets.set('test', { index: [], getConceptCount: () => 0, getConcepts: () => [] } as any);
+  });
+
+  function mountCard(entry = makeEntry(), registerId = 'test') {
+    return mount(ConceptCard, {
+      global: { plugins: [pinia, router] },
+      props: { entry, registerId },
+    });
+  }
+
+  it('renders the English term as title', () => {
+    const wrapper = mountCard();
+    expect(wrapper.text()).toContain('test term');
+  });
+
+  it('renders the concept ID', () => {
+    const wrapper = mountCard();
+    expect(wrapper.text()).toContain('3.1.1.1');
+  });
+
+  it('falls back to ID when no English term', () => {
+    const wrapper = mountCard(makeEntry({ eng: '' }));
+    expect(wrapper.text()).toContain('3.1.1.1');
+  });
+
+  it('shows valid status badge', () => {
+    const wrapper = mountCard();
+    expect(wrapper.text()).toContain('valid');
+  });
+
+  it('shows superseded status with reduced opacity', () => {
+    const wrapper = mountCard(makeEntry({ status: 'superseded' }));
+    expect(wrapper.text()).toContain('superseded');
+    expect(wrapper.find('button').classes()).toContain('opacity-70');
+  });
+
+  it('shows withdrawn status with reduced opacity', () => {
+    const wrapper = mountCard(makeEntry({ status: 'withdrawn' }));
+    expect(wrapper.text()).toContain('withdrawn');
+    expect(wrapper.find('button').classes()).toContain('opacity-70');
+  });
+
+  it('navigates to concept page on click', async () => {
+    const wrapper = mountCard();
+    await wrapper.find('button').trigger('click');
+    await flushPromises();
+    expect(router.currentRoute.value.name).toBe('concept');
+    expect(router.currentRoute.value.params.registerId).toBe('test');
+    expect(router.currentRoute.value.params.conceptId).toBe('3.1.1.1');
+  });
+
+  it('shows language count from manifest', () => {
+    const wrapper = mountCard();
+    expect(wrapper.text()).toContain('2 lang');
+  });
+});

package/src/__tests__/concept-detail-interaction.test.ts

@@ -0,0 +1,273 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { mount, flushPromises } from '@vue/test-utils';
+import { createPinia, setActivePinia } from 'pinia';
+import { createRouter, createMemoryHistory } from 'vue-router';
+import ConceptDetail from '../components/ConceptDetail.vue';
+import { useVocabularyStore } from '../stores/vocabulary';
+import type { Manifest } from '../adapters/types';
+import { conceptFromJson } from '../adapters/model-bridge';
+// Prevent the 2.7MB Opal runtime from loading in tests
+vi.mock('../utils/plurimath', () => ({
+  loadPlurimath: () => new Promise(() => {}),
+  mathToHtml: () => '<code class="math-fallback">x</code>',
+  renderToMathML: () => null,
+}));
+
+import { vMath } from '../directives/v-math';
+
+function makeManifest(): Manifest {
+  return {
+    id: 'test',
+    datasetUri: 'https://glossarist.org/test/concept',
+    title: 'Test Dataset',
+    description: 'A test dataset',
+    owner: 'ISO',
+    baseUrl: '/data/test',
+    languages: ['eng', 'fra'],
+    conceptCount: 1,
+    conceptUrlTemplate: '/data/test/concepts/{id}.json',
+    indexUrl: '/data/test/index.json',
+    contextUrl: '/data/test/context.json',
+    uriBase: 'https://glossarist.org',
+    status: 'published',
+    schemaVersion: '1.0',
+    tags: [],
+    lastUpdated: '2025-01-01',
+    sourceRepo: 'https://example.com/repo',
+    chunkSize: 1000,
+    languageOrder: ['eng', 'fra'],
+    color: '#3366ff',
+  };
+}
+
+function makeConceptJson(overrides: Record<string, any> = {}) {
+  return {
+    '@context': 'https://glossarist.org/context',
+    '@id': 'https://glossarist.org/test/concept/1',
+    '@type': 'gl:Concept',
+    'gl:identifier': '1',
+    'gl:localizedConcept': {
+      eng: {
+        '@id': 'https://glossarist.org/test/concept/1/eng',
+        '@type': 'gl:LocalizedConcept',
+        'gl:languageCode': 'eng',
+        'gl:entryStatus': 'valid',
+        'gl:designation': [
+          { '@type': 'gl:Expression', 'gl:normativeStatus': 'preferred', 'gl:term': 'test term' },
+          { '@type': 'gl:Symbol', 'gl:normativeStatus': 'admitted', 'gl:term': 'stem:[x]' },
+        ],
+        'gl:definition': [
+          { '@type': 'gl:DetailedDefinition', 'gl:content': 'a definition with *italic* text' },
+        ],
+        'gl:notes': [
+          { '@type': 'gl:DetailedDefinition', 'gl:content': 'a note' },
+        ],
+        'gl:examples': [
+          { '@type': 'gl:DetailedDefinition', 'gl:content': 'an example' },
+        ],
+        'gl:source': [{ '@type': 'gl:Source', 'gl:sourceType': 'authoritative' }],
+      },
+      fra: {
+        '@id': 'https://glossarist.org/test/concept/1/fra',
+        '@type': 'gl:LocalizedConcept',
+        'gl:languageCode': 'fra',
+        'gl:entryStatus': 'valid',
+        'gl:designation': [
+          { '@type': 'gl:Expression', 'gl:normativeStatus': 'preferred', 'gl:term': 'terme de test' },
+        ],
+        'gl:definition': [
+          { '@type': 'gl:DetailedDefinition', 'gl:content': 'une définition' },
+        ],
+      },
+    },
+    ...overrides,
+  };
+}
+
+async function createTestRouter() {
+  return createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId', name: 'dataset', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId/concept/:conceptId', name: 'concept', component: { template: '<div/>' } },
+    ],
+  });
+}
+
+describe('ConceptDetail interactions', () => {
+  let pinia: ReturnType<typeof createPinia>;
+  let router: Awaited<ReturnType<typeof createTestRouter>>;
+  let store: ReturnType<typeof useVocabularyStore>;
+
+  beforeEach(async () => {
+    pinia = createPinia();
+    setActivePinia(pinia);
+    router = await createTestRouter();
+    router.push('/');
+    await router.isReady();
+    store = useVocabularyStore();
+    store.manifests.set('test', makeManifest());
+    store.datasets.set('test', { index: [], getConceptCount: () => 0, getConcepts: () => [], getConceptPosition: () => -1, getIndexEntry: () => undefined } as any);
+  });
+
+  function mountDetail(conceptJson: Record<string, any> = makeConceptJson()) {
+    const concept = conceptFromJson(conceptJson);
+    return mount(ConceptDetail, {
+      global: {
+        plugins: [pinia, router],
+        directives: { math: vMath },
+      },
+      props: {
+        concept,
+        manifest: makeManifest(),
+        edges: [],
+        registerId: 'test',
+        adjacent: { prev: null, next: null },
+      },
+    });
+  }
+
+  it('renders the primary term in the header', () => {
+    const wrapper = mountDetail();
+    expect(wrapper.find('h1').html()).toContain('test term');
+  });
+
+  async function switchToDefinition(wrapper: ReturnType<typeof mountDetail>) {
+    const tabs = wrapper.findAll('button[role="tab"]');
+    const defTab = tabs.find(t => t.text().includes('Definition'));
+    if (defTab) {
+      await defTab.trigger('click');
+      await flushPromises();
+    }
+  }
+
+  it('renders concept ID badge', () => {
+    const wrapper = mountDetail();
+    expect(wrapper.text()).toContain('1');
+  });
+
+  it('renders language sections for eng and fra', async () => {
+    const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
+    expect(wrapper.text()).toContain('English');
+    expect(wrapper.text()).toContain('French');
+  });
+
+  it('renders italic text in definition', async () => {
+    const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
+    expect(wrapper.html()).toContain('<em>italic</em>');
+  });
+
+  it('renders stem: notation as math-pending placeholder', async () => {
+    const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
+    expect(wrapper.html()).toContain('math-pending');
+    expect(wrapper.html()).toContain('data-expr="x"');
+  });
+
+  it('renders notes section', async () => {
+    const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
+    expect(wrapper.text()).toContain('Note 1');
+    expect(wrapper.text()).toContain('a note');
+  });
+
+  it('renders examples section', async () => {
+    const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
+    expect(wrapper.text()).toContain('Example 1');
+    expect(wrapper.text()).toContain('an example');
+  });
+
+  it('renders designation types as badges', async () => {
+    const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
+    expect(wrapper.text()).toContain('symbol');
+  });
+
+  it('collapses non-eng languages when 6+ languages present', async () => {
+    const json = makeConceptJson() as Record<string, any>;
+    for (const lang of ['deu', 'spa', 'kor', 'jpn']) {
+      json['gl:localizedConcept'][lang] = {
+        '@id': `https://glossarist.org/test/concept/1/${lang}`,
+        '@type': 'gl:LocalizedConcept',
+        'gl:languageCode': lang,
+        'gl:designation': [
+          { '@type': 'gl:Expression', 'gl:normativeStatus': 'preferred', 'gl:term': `term-${lang}` },
+        ],
+        'gl:definition': [
+          { '@type': 'gl:DetailedDefinition', 'gl:content': `def-${lang}` },
+        ],
+      };
+    }
+    const wrapper = mountDetail(json);
+    await switchToDefinition(wrapper);
+    await flushPromises();
+    expect(wrapper.text()).toContain('6 languages');
+  });
+
+  it('toggles language section on click', async () => {
+    const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
+    const buttons = wrapper.findAll('button');
+    const fraButton = buttons.find(b => b.text().includes('French'));
+    expect(fraButton).toBeDefined();
+
+    await fraButton!.trigger('click');
+    await fraButton!.trigger('click');
+  });
+
+  it('switches between definition and history tabs', async () => {
+    const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
+    expect(wrapper.text()).toContain('a definition with');
+
+    const tabs = wrapper.findAll('button[role="tab"]');
+    const historyTab = tabs.find(t => t.text().includes('History'));
+    expect(historyTab).toBeDefined();
+    await historyTab!.trigger('click');
+    await flushPromises();
+
+    expect(wrapper.text()).not.toContain('a definition with');
+  });
+
+  it('renders cross-reference link and navigates on click', async () => {
+    const json = makeConceptJson();
+    json['gl:localizedConcept'].eng['gl:definition'] = [
+      { '@type': 'gl:DetailedDefinition', 'gl:content': 'see {{urn:iso:std:iso:14812:3.1.1.1,entity}} here' },
+    ];
+
+    // Register the URI pattern via factory so it resolves as internal
+    const { getFactory } = await import('../adapters/factory');
+    const factory = getFactory();
+    factory.router.registerDataset('test', '/data/test', {
+      ...makeManifest(),
+      uriBase: 'https://glossarist.org',
+    });
+    factory.resolver.registerDataset('test', ['https://glossarist.org/test/concept/*']);
+
+    const wrapper = mountDetail(json);
+    await switchToDefinition(wrapper);
+    await flushPromises();
+
+    const xref = wrapper.find('.xref-link');
+    if (xref.exists()) {
+      await xref.trigger('click');
+      await flushPromises();
+      expect(router.currentRoute.value.name).toBe('concept');
+    }
+  });
+
+  it('renders entry status badge', () => {
+    const wrapper = mountDetail();
+    expect(wrapper.text()).toContain('valid');
+  });
+
+  it('renders the language quick-jump sidebar with all languages', async () => {
+    const wrapper = mountDetail();
+    await switchToDefinition(wrapper);
+    expect(wrapper.text()).toContain('Languages (2)');
+  });
+});

package/src/__tests__/concept-formats.test.ts

@@ -1,37 +1,33 @@
 import { describe, it, expect } from 'vitest';
 import { FORMAT_REGISTRY, conceptToTurtle, conceptToSkosJsonLd } from '../utils/concept-formats';
-import type { ConceptDocument } from '../adapters/types';
+import { Concept } from 'glossarist';
 
-function makeConcept(overrides: Partial<ConceptDocument> = {}): ConceptDocument {
-  return {
-    '@context': 'https://glossarist.org/ns/context.jsonld',
-    '@id': 'https://glossarist.org/test/concept/1',
-    '@type': 'gl:Concept',
-    'gl:identifier': '1',
-    'gl:localizedConcept': {
+function makeConcept(overrides: Record<string, unknown> = {}): Concept {
+  return Concept.fromJSON({
+    id: '1',
+    uri: 'https://glossarist.org/test/concept/1',
+    localizations: {
       eng: {
-        '@id': 'https://glossarist.org/test/concept/1/eng',
-        '@type': 'gl:LocalizedConcept',
-        'gl:languageCode': 'eng',
-        'gl:designation': [
-          { '@type': 'gl:Expression', 'gl:normativeStatus': 'preferred', 'gl:term': 'test term' },
-          { '@type': 'gl:Expression', 'gl:normativeStatus': 'admitted', 'gl:term': 'alt term' },
+        language_code: 'eng',
+        entry_status: 'valid',
+        terms: [
+          { type: 'expression', designation: 'test term', normative_status: 'preferred' },
+          { type: 'expression', designation: 'alt term', normative_status: 'admitted' },
         ],
-        'gl:definition': [{ '@type': 'gl:DetailedDefinition', 'gl:content': 'a definition' }],
-        'gl:notes': [{ '@type': 'gl:DetailedDefinition', 'gl:content': 'a note' }],
+        definition: [{ content: 'a definition' }],
+        notes: [{ content: 'a note' }],
       },
       deu: {
-        '@id': 'https://glossarist.org/test/concept/1/deu',
-        '@type': 'gl:LocalizedConcept',
-        'gl:languageCode': 'deu',
-        'gl:designation': [
-          { '@type': 'gl:Expression', 'gl:normativeStatus': 'preferred', 'gl:term': 'Testbegriff' },
+        language_code: 'deu',
+        entry_status: 'valid',
+        terms: [
+          { type: 'expression', designation: 'Testbegriff', normative_status: 'preferred' },
         ],
-        'gl:definition': [{ '@type': 'gl:DetailedDefinition', 'gl:content': 'eine Definition' }],
+        definition: [{ content: 'eine Definition' }],
       },
     },
     ...overrides,
-  };
+  });
 }
 
 describe('FORMAT_REGISTRY', () => {
@@ -64,17 +60,24 @@ describe('conceptToTurtle', () => {
   });
 
   it('escapes special characters in Turtle', () => {
-    const concept = makeConcept();
-    concept['gl:localizedConcept']!.eng!['gl:definition'] = [
-      { '@type': 'gl:DetailedDefinition', 'gl:content': 'has "quotes" and \\backslash' },
-    ];
+    const concept = Concept.fromJSON({
+      id: '1',
+      uri: 'https://glossarist.org/test/concept/1',
+      localizations: {
+        eng: {
+          language_code: 'eng',
+          terms: [{ type: 'expression', designation: 'test', normative_status: 'preferred' }],
+          definition: [{ content: 'has "quotes" and \\backslash' }],
+        },
+      },
+    });
     const ttl = conceptToTurtle(concept);
     expect(ttl).toContain('\\"quotes\\"');
     expect(ttl).toContain('\\\\backslash');
   });
 
   it('handles empty concept gracefully', () => {
-    const ttl = conceptToTurtle({} as ConceptDocument);
+    const ttl = conceptToTurtle(Concept.fromJSON({}));
     expect(ttl).toContain('a skos:Concept');
     expect(ttl).toContain('skos:notation ""');
   });
@@ -100,8 +103,7 @@ describe('conceptToSkosJsonLd', () => {
   });
 
   it('omits empty language maps', () => {
-    const concept = makeConcept();
-    concept['gl:localizedConcept'] = {};
+    const concept = Concept.fromJSON({ id: '1', uri: 'https://glossarist.org/test/concept/1' });
     const parsed = JSON.parse(conceptToSkosJsonLd(concept));
     expect(parsed['skos:prefLabel']).toBeUndefined();
     expect(parsed['skos:definition']).toBeUndefined();