@glossarist/concept-browser 0.3.4 → 0.4.0

package/src/__tests__/dataset-adapter.test.ts

@@ -1,5 +1,6 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { DatasetAdapter } from '../adapters/DatasetAdapter';
+import { conceptFromJson } from '../adapters/model-bridge';
 
 // Mock fetch globally
 const mockFetch = vi.fn();
@@ -98,13 +99,13 @@ describe('DatasetAdapter', () => {
       mockFetch.mockReturnValue(mockJsonResponse(concept));
 
       const result = await adapter.fetchConcept('103-01-02');
-      expect(result['gl:identifier']).toBe('103-01-02');
+      expect(result.id).toBe('103-01-02');
       expect(mockFetch).toHaveBeenCalledWith('/data/test/concepts/103-01-02.json');
 
       // Second call should use cache
       mockFetch.mockReset();
       const cached = await adapter.fetchConcept('103-01-02');
-      expect(cached['gl:identifier']).toBe('103-01-02');
+      expect(cached.id).toBe('103-01-02');
       expect(mockFetch).not.toHaveBeenCalled();
     });
 
@@ -195,12 +196,56 @@ describe('DatasetAdapter', () => {
       const hits = adapter.search('xyznotfound');
       expect(hits.length).toBe(0);
     });
+
+    it('ranks exact matches above starts-with above contains', async () => {
+      const index = {
+        registerId: 'test',
+        schemaVersion: '1.0.0',
+        conceptCount: 3,
+        chunkSize: 500,
+        chunks: [],
+        concepts: [
+          { id: '1', designations: { eng: 'mass' }, eng: 'mass', status: 'valid' },
+          { id: '2', designations: { eng: 'mass flow rate' }, eng: 'mass flow rate', status: 'valid' },
+          { id: '3', designations: { eng: 'center of mass' }, eng: 'center of mass', status: 'valid' },
+        ],
+      };
+      mockFetch.mockReturnValue(mockJsonResponse(index));
+      await adapter.loadIndex();
+
+      const hits = adapter.search('mass');
+      // Exact match first, then starts-with, then contains
+      expect(hits[0].conceptId).toBe('1');
+      expect(hits[1].conceptId).toBe('2');
+      expect(hits[2].conceptId).toBe('3');
+    });
+
+    it('ranks ID exact match highest', async () => {
+      const index = {
+        registerId: 'test',
+        schemaVersion: '1.0.0',
+        conceptCount: 2,
+        chunkSize: 500,
+        chunks: [],
+        concepts: [
+          { id: '102-01-01', designations: { eng: 'field' }, eng: 'field', status: 'valid' },
+          { id: '102-01-02', designations: { eng: 'electromagnetic field' }, eng: 'electromagnetic field', status: 'valid' },
+        ],
+      };
+      mockFetch.mockReturnValue(mockJsonResponse(index));
+      await adapter.loadIndex();
+
+      const hits = adapter.search('102-01-01');
+      expect(hits[0].conceptId).toBe('102-01-01');
+      expect(hits[0].matchField).toBe('id');
+    });
   });
 
   describe('extractEdges', () => {
     it('extracts cross-reference edges from gl:references', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/102-01-01',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {
           eng: {
             'gl:references': [
@@ -209,18 +254,38 @@ describe('DatasetAdapter', () => {
             ],
           },
         },
-      };
+      });
 
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(2);
       expect(edges[0].target).toBe('https://glossarist.org/iev/concept/103-01-02');
       expect(edges[0].type).toBe('references');
       expect(edges[0].label).toBe('functional');
     });
 
+    it('tags reference edges with language', () => {
+      const concept = conceptFromJson({
+        '@id': 'https://glossarist.org/test/concept/1',
+        '@type': 'gl:Concept',
+        'gl:localizedConcept': {
+          eng: { 'gl:references': [
+            { '@id': 'https://glossarist.org/test/concept/2', 'gl:term': 'other' },
+          ]},
+          fra: { 'gl:references': [
+            { '@id': 'https://glossarist.org/test/concept/3', 'gl:term': 'autre' },
+          ]},
+        },
+      });
+      const edges = adapter.extractEdges(concept);
+      expect(edges.length).toBe(2);
+      expect(edges.find(e => e.lang === 'eng')?.target).toContain('/concept/2');
+      expect(edges.find(e => e.lang === 'fra')?.target).toContain('/concept/3');
+    });
+
     it('skips self-references', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/102-01-01',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {
           eng: {
             'gl:references': [
@@ -228,37 +293,40 @@ describe('DatasetAdapter', () => {
             ],
           },
         },
-      };
+      });
 
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(0);
     });
 
     it('handles concepts with no references', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/102-01-01',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {
           eng: {},
         },
-      };
+      });
 
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(0);
     });
 
     it('handles empty localizedConcept', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/102-01-01',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {},
-      };
+      });
 
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(0);
     });
 
     it('collects references from multiple languages without duplication', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/102-01-01',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {
           eng: {
             'gl:references': [
@@ -271,16 +339,17 @@ describe('DatasetAdapter', () => {
             ],
           },
         },
-      };
+      });
 
       // Same target from two languages — both edges are kept (different labels)
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(2);
     });
 
     it('extracts inline IEV cross-references from gl:references', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/112-01-01',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {
           eng: {
             'gl:references': [
@@ -289,9 +358,9 @@ describe('DatasetAdapter', () => {
             ],
           },
         },
-      };
+      });
 
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(2);
       expect(edges[0].target).toBe('https://glossarist.org/iev/concept/102-02-18');
       expect(edges[0].label).toBe('scalar');
@@ -300,8 +369,9 @@ describe('DatasetAdapter', () => {
     });
 
     it('extracts inline URN cross-references from gl:references', () => {
-      const concept = {
+      const concept = conceptFromJson({
         '@id': 'https://glossarist.org/test/concept/3.1.1.1',
+        '@type': 'gl:Concept',
         'gl:localizedConcept': {
           eng: {
             'gl:references': [
@@ -309,15 +379,94 @@ describe('DatasetAdapter', () => {
             ],
           },
         },
-      };
+      });
 
-      const edges = adapter.extractEdges(concept as any);
+      const edges = adapter.extractEdges(concept);
       expect(edges.length).toBe(1);
       expect(edges[0].target).toBe('https://glossarist.org/isotc204/concept/3.1.1.6');
       expect(edges[0].label).toBe('entity');
     });
   });
 
+  describe('extractDomainEdges', () => {
+    it('extracts domain edges from gl:domain field per language', () => {
+      const concept = conceptFromJson({
+        '@id': 'https://glossarist.org/test/concept/3',
+        '@type': 'gl:Concept',
+        'gl:localizedConcept': {
+          eng: { 'gl:domain': 'geometry' },
+          fra: { 'gl:domain': 'géométrie' },
+        },
+      });
+      const edges = adapter.extractDomainEdges(concept);
+      expect(edges.length).toBe(2);
+      expect(edges.every(e => e.type === 'domain')).toBe(true);
+      expect(edges.find(e => e.lang === 'eng')?.target).toContain('/domain/geometry');
+      expect(edges.find(e => e.lang === 'fra')?.target).toContain('/domain/gomtrie');
+      expect(edges.find(e => e.lang === 'eng')?.label).toBe('geometry');
+      expect(edges.find(e => e.lang === 'fra')?.label).toBe('géométrie');
+    });
+
+    it('handles same domain across languages', () => {
+      const concept = conceptFromJson({
+        '@id': 'https://glossarist.org/test/concept/1',
+        '@type': 'gl:Concept',
+        'gl:localizedConcept': {
+          eng: { 'gl:domain': 'metadata' },
+          fra: { 'gl:domain': 'metadata' },
+        },
+      });
+      const edges = adapter.extractDomainEdges(concept);
+      expect(edges.length).toBe(2);
+      expect(edges[0].target).toBe(edges[1].target);
+      expect(edges[0].target).toContain('/domain/metadata');
+    });
+
+    it('skips concepts without gl:domain', () => {
+      const concept = conceptFromJson({
+        '@id': 'https://glossarist.org/test/concept/1',
+        '@type': 'gl:Concept',
+        'gl:localizedConcept': { eng: {} },
+      });
+      const edges = adapter.extractDomainEdges(concept);
+      expect(edges.length).toBe(0);
+    });
+
+    it('handles empty localizedConcept', () => {
+      const concept = conceptFromJson({
+        '@id': 'https://glossarist.org/test/concept/1',
+        '@type': 'gl:Concept',
+        'gl:localizedConcept': {},
+      });
+      const edges = adapter.extractDomainEdges(concept);
+      expect(edges.length).toBe(0);
+    });
+  });
+
+  describe('loadDomainNodes', () => {
+    it('loads domain nodes from domain-nodes.json', async () => {
+      mockFetch.mockReturnValue(mockJsonResponse({
+        registerId: 'test',
+        domainNodes: [
+          { uri: 'https://glossarist.org/test/domain/iso-19107', label: 'ISO 19107', registerId: 'test', conceptCount: 147 },
+        ],
+      }));
+      const nodes = await adapter.loadDomainNodes();
+      expect(nodes.length).toBe(1);
+      expect(nodes[0].nodeType).toBe('domain');
+      expect(nodes[0].status).toBe('domain');
+      expect(nodes[0].loaded).toBe(true);
+      expect(nodes[0].designations.eng).toBe('ISO 19107');
+      expect(mockFetch).toHaveBeenCalledWith('/data/test/domain-nodes.json');
+    });
+
+    it('returns empty array on fetch failure', async () => {
+      mockFetch.mockReturnValue(Promise.resolve({ ok: false, status: 404 } as Response));
+      const nodes = await adapter.loadDomainNodes();
+      expect(nodes).toEqual([]);
+    });
+  });
+
   describe('getLanguages', () => {
     it('returns languages from manifest', async () => {
       const manifest = {

package/src/__tests__/dataset-view.test.ts

@@ -0,0 +1,232 @@
+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 DatasetView from '../views/DatasetView.vue';
+import { useVocabularyStore } from '../stores/vocabulary';
+import type { Manifest, ConceptSummary } from '../adapters/types';
+
+function makeManifest(overrides: Partial<Manifest> = {}): 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: 100,
+    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',
+    ...overrides,
+  };
+}
+
+function makeConcepts(count: number): ConceptSummary[] {
+  return Array.from({ length: count }, (_, i) => ({
+    id: String(i + 1),
+    designations: { eng: `term ${i + 1}` },
+    eng: `term ${i + 1}`,
+    status: i % 10 === 0 ? 'superseded' : 'valid',
+  }));
+}
+
+function makeAdapter(concepts: ConceptSummary[] = []) {
+  const dense = concepts.filter(Boolean);
+  return {
+    registerId: 'test',
+    index: dense,
+    manifest: null,
+    getConceptCount: () => dense.length,
+    getConcepts: () => dense,
+    isRangeLoaded: () => true,
+    ensureChunksForRange: async () => {},
+    ensureAllChunksLoaded: async () => {},
+    getAdjacentConcepts: () => ({ prev: null, next: null }),
+  } as any;
+}
+
+async function createTestRouter() {
+  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: '/dataset/:registerId/stats', name: 'stats', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId/about', name: 'about', component: { template: '<div/>' } },
+    ],
+  });
+  router.push('/dataset/test');
+  await router.isReady();
+  return router;
+}
+
+describe('DatasetView', () => {
+  let pinia: ReturnType<typeof createPinia>;
+  let router: Awaited<ReturnType<typeof createTestRouter>>;
+
+  beforeEach(async () => {
+    pinia = createPinia();
+    setActivePinia(pinia);
+    router = await createTestRouter();
+  });
+
+  function mountDataset(concepts: ConceptSummary[] = [], manifestOverrides: Partial<Manifest> = {}) {
+    const store = useVocabularyStore();
+    const manifest = makeManifest(manifestOverrides);
+    store.manifests.set('test', manifest);
+    store.datasets.set('test', makeAdapter(concepts));
+    return mount(DatasetView, {
+      global: { plugins: [pinia, router] },
+      props: { registerId: 'test' },
+    });
+  }
+
+  it('renders dataset title and description', async () => {
+    const wrapper = mountDataset(makeConcepts(10));
+    await flushPromises();
+    expect(wrapper.text()).toContain('Test Dataset');
+    expect(wrapper.text()).toContain('A test dataset');
+  });
+
+  it('shows concept count badge', async () => {
+    const wrapper = mountDataset(makeConcepts(100));
+    await flushPromises();
+    expect(wrapper.text()).toContain('100 concepts');
+  });
+
+  it('shows language count badge', async () => {
+    const wrapper = mountDataset(makeConcepts(10));
+    await flushPromises();
+    expect(wrapper.text()).toContain('2 languages');
+  });
+
+  it('shows owner badge', async () => {
+    const wrapper = mountDataset(makeConcepts(10));
+    await flushPromises();
+    expect(wrapper.text()).toContain('ISO');
+  });
+
+  it('shows concept cards for loaded concepts', async () => {
+    const wrapper = mountDataset(makeConcepts(3));
+    await flushPromises();
+    expect(wrapper.text()).toContain('term 1');
+    expect(wrapper.text()).toContain('term 2');
+    expect(wrapper.text()).toContain('term 3');
+  });
+
+  it('paginates at 50 concepts per page', async () => {
+    const wrapper = mountDataset(makeConcepts(120));
+    await flushPromises();
+    // Should show 50 on first page
+    expect(wrapper.text()).toContain('term 1');
+    expect(wrapper.text()).not.toContain('term 51');
+    // Should show pagination
+    expect(wrapper.text()).toContain('Prev');
+    expect(wrapper.text()).toContain('Next');
+  });
+
+  it('shows correct page count in pagination', async () => {
+    const wrapper = mountDataset(makeConcepts(120));
+    await flushPromises();
+    // 120 / 50 = 3 pages (ceil)
+    const pageButtons = wrapper.findAll('button').filter(b => /^\d+$/.test(b.text().trim()));
+    const pageNumbers = pageButtons.map(b => parseInt(b.text().trim()));
+    expect(pageNumbers).toContain(1);
+    expect(pageNumbers).toContain(3);
+  });
+
+  it('filters concepts by term', async () => {
+    const concepts: ConceptSummary[] = [
+      { id: '1', designations: { eng: 'road network' }, eng: 'road network', status: 'valid' },
+      { id: '2', designations: { eng: 'bridge design' }, eng: 'bridge design', status: 'valid' },
+      { id: '3', designations: { eng: 'road user' }, eng: 'road user', status: 'valid' },
+    ];
+    const wrapper = mountDataset(concepts);
+    await flushPromises();
+    const input = wrapper.find('input[aria-label="Filter concepts"]');
+    await input.setValue('road');
+    await flushPromises();
+    expect(wrapper.text()).toContain('road network');
+    expect(wrapper.text()).toContain('road user');
+    expect(wrapper.text()).not.toContain('bridge design');
+  });
+
+  it('filters concepts by ID', async () => {
+    const concepts: ConceptSummary[] = [
+      { id: '3.1.1.1', designations: { eng: 'term one' }, eng: 'term one', status: 'valid' },
+      { id: '3.1.1.2', designations: { eng: 'term two' }, eng: 'term two', status: 'valid' },
+    ];
+    const wrapper = mountDataset(concepts);
+    await flushPromises();
+    const input = wrapper.find('input[aria-label="Filter concepts"]');
+    await input.setValue('3.1.1.1');
+    await flushPromises();
+    expect(wrapper.text()).toContain('term one');
+    expect(wrapper.text()).not.toContain('term two');
+  });
+
+  it('shows empty state when filter matches nothing', async () => {
+    const wrapper = mountDataset(makeConcepts(5));
+    await flushPromises();
+    const input = wrapper.find('input[aria-label="Filter concepts"]');
+    await input.setValue('zzzznonexistent');
+    await flushPromises();
+    expect(wrapper.text()).toContain('No concepts match your filter');
+  });
+
+  it('shows clear filter button on empty state', async () => {
+    const wrapper = mountDataset(makeConcepts(5));
+    await flushPromises();
+    const input = wrapper.find('input[aria-label="Filter concepts"]');
+    await input.setValue('zzzznonexistent');
+    await flushPromises();
+    expect(wrapper.text()).toContain('Clear filter');
+  });
+
+  it('shows links to stats and about pages', async () => {
+    const wrapper = mountDataset(makeConcepts(5));
+    await flushPromises();
+    expect(wrapper.text()).toContain('Statistics');
+    expect(wrapper.text()).toContain('About');
+  });
+
+  it('shows bulk downloads when manifest has bulkFormats', async () => {
+    const wrapper = mountDataset(makeConcepts(5), {
+      bulkFormats: [
+        { file: 'all.ttl', format: 'turtle', size: 1024 },
+        { file: 'all.jsonld', format: 'jsonld', size: 2048 },
+      ],
+    });
+    await flushPromises();
+    expect(wrapper.text()).toContain('Download');
+    expect(wrapper.text()).toContain('1.0 KB');
+  });
+
+  it('shows 0 of N concepts in filter count', async () => {
+    const wrapper = mountDataset(makeConcepts(10));
+    await flushPromises();
+    const input = wrapper.find('input[aria-label="Filter concepts"]');
+    await input.setValue('term 5');
+    await flushPromises();
+    expect(wrapper.text()).toContain('of 10 concepts');
+  });
+
+  it('disables Prev on first page', async () => {
+    const wrapper = mountDataset(makeConcepts(120));
+    await flushPromises();
+    const prevBtn = wrapper.findAll('button').find(b => b.text().includes('Prev'));
+    expect(prevBtn).toBeDefined();
+    expect(prevBtn!.attributes('disabled')).toBeDefined();
+  });
+});