@glossarist/concept-browser 0.3.4 → 0.4.0

package/src/__tests__/language-detail.test.ts

@@ -0,0 +1,203 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mount } from '@vue/test-utils';
+import LanguageDetail from '../components/LanguageDetail.vue';
+import { useVocabularyStore } from '../stores/vocabulary';
+import { conceptFromJson } from '../adapters/model-bridge';
+import { createTestRouter, setupPinia, makeManifest, makeAdapterStub } from './test-helpers';
+
+function makeConceptJson(overrides: Record<string, any> = {}) {
+  return {
+    '@id': 'https://glossarist.org/test/concept/1',
+    '@type': 'gl:Concept',
+    'gl:identifier': '1',
+    'gl:localizedConcept': {
+      eng: {
+        '@type': 'gl:LocalizedConcept',
+        'gl:languageCode': 'eng',
+        'gl:entryStatus': 'valid',
+        ...overrides.eng,
+      },
+      ...(overrides.otherLangs || {}),
+    },
+  };
+}
+
+describe('LanguageDetail', () => {
+  let pinia: ReturnType<typeof setupPinia>;
+  let router: Awaited<ReturnType<typeof createTestRouter>>;
+
+  beforeEach(async () => {
+    pinia = setupPinia();
+    router = await createTestRouter('dataset', '/');
+    const store = useVocabularyStore();
+    store.manifests.set('test', makeManifest({ languages: ['eng', 'fra'] }));
+    store.datasets.set('test', makeAdapterStub());
+  });
+
+  function mountDetail(conceptJson: Record<string, any>, activeLang = 'eng') {
+    const concept = conceptFromJson(conceptJson);
+    return mount(LanguageDetail, {
+      global: { plugins: [pinia, router], directives: { math: () => {} } },
+      props: { concept, activeLang },
+    });
+  }
+
+  it('renders language selector buttons', () => {
+    const json = makeConceptJson({
+      eng: {},
+      otherLangs: {
+        fra: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'fra',
+          'gl:entryStatus': 'valid',
+        },
+      },
+    });
+    const wrapper = mountDetail(json);
+    expect(wrapper.text()).toContain('English');
+    expect(wrapper.text()).toContain('French');
+  });
+
+  it('highlights active language button', () => {
+    const json = makeConceptJson({
+      eng: {},
+      otherLangs: {
+        fra: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'fra',
+          'gl:entryStatus': 'valid',
+        },
+      },
+    });
+    const wrapper = mountDetail(json, 'eng');
+    const buttons = wrapper.findAll('button').filter(b => b.text().includes('English'));
+    expect(buttons[0].classes()).toContain('bg-ink-800');
+  });
+
+  it('emits update:activeLang on language click', async () => {
+    const json = makeConceptJson({
+      eng: {},
+      otherLangs: {
+        fra: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'fra',
+          'gl:entryStatus': 'valid',
+        },
+      },
+    });
+    const wrapper = mountDetail(json, 'eng');
+    const fraBtn = wrapper.findAll('button').find(b => b.text().includes('French'));
+    expect(fraBtn).toBeDefined();
+    await fraBtn!.trigger('click');
+    expect(wrapper.emitted('update:activeLang')?.[0]).toEqual(['fra']);
+  });
+
+  it('shows entry status badge', () => {
+    const json = makeConceptJson({
+      eng: { 'gl:entryStatus': 'valid' },
+    });
+    const wrapper = mountDetail(json);
+    expect(wrapper.text()).toContain('valid');
+  });
+
+  it('shows designations with ontology labels', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:designation': [
+          { '@type': 'gl:Expression', 'gl:term': 'road', 'gl:normativeStatus': 'preferred' },
+        ],
+      },
+    });
+    const wrapper = mountDetail(json);
+    expect(wrapper.text()).toContain('road');
+    expect(wrapper.text()).toContain('expression');
+    expect(wrapper.text()).toContain('preferred');
+  });
+
+  it('shows definition', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:definition': [{ '@type': 'gl:Definition', 'gl:content': 'A paved surface for vehicles.' }],
+      },
+    });
+    const wrapper = mountDetail(json);
+    expect(wrapper.text()).toContain('Definition');
+    expect(wrapper.text()).toContain('paved surface');
+  });
+
+  it('shows notes', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:notes': [{ '@type': 'gl:Note', 'gl:content': 'This is a note.' }],
+      },
+    });
+    const wrapper = mountDetail(json);
+    expect(wrapper.text()).toContain('Notes');
+    expect(wrapper.text()).toContain('This is a note');
+  });
+
+  it('shows examples', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:examples': [{ '@type': 'gl:Example', 'gl:content': 'A highway is a road.' }],
+      },
+    });
+    const wrapper = mountDetail(json);
+    expect(wrapper.text()).toContain('Examples');
+    expect(wrapper.text()).toContain('A highway is a road');
+  });
+
+  it('shows sources', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:source': [{ '@type': 'gl:Source', 'gl:sourceType': 'authoritative', 'gl:origin': { '@type': 'gl:Origin', 'gl:ref': { '@type': 'gl:Ref', 'gl:source': 'ISO 7010' } } }],
+      },
+    });
+    const wrapper = mountDetail(json);
+    expect(wrapper.text()).toContain('Sources');
+    expect(wrapper.text()).toContain('ISO 7010');
+  });
+
+  it('shows term-only state for language without definition', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:designation': [{ '@type': 'gl:Expression', 'gl:term': 'test', 'gl:normativeStatus': 'preferred' }],
+      },
+    });
+    const wrapper = mountDetail(json);
+    expect(wrapper.text()).toContain('Term only in English');
+  });
+
+  it('shows no data message for missing language', () => {
+    const json = makeConceptJson({ eng: {} });
+    const wrapper = mountDetail(json, 'zho');
+    expect(wrapper.text()).toContain('No data available');
+  });
+
+  it('shows designation type badges with ontology labels', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:designation': [
+          { '@type': 'gl:Symbol', 'gl:term': 'H₂O', 'gl:normativeStatus': 'preferred' },
+          { '@type': 'gl:Abbreviation', 'gl:term': 'abbr', 'gl:normativeStatus': 'admitted' },
+        ],
+      },
+    });
+    const wrapper = mountDetail(json);
+    expect(wrapper.text()).toContain('symbol');
+    expect(wrapper.text()).toContain('abbreviation');
+  });
+
+  it('shows grammar info with ontology labels when present', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:designation': [
+          { '@type': 'gl:Expression', 'gl:term': 'route', 'gl:normativeStatus': 'preferred', 'gl:grammarInfo': [{ 'gl:gender': 'f', 'gl:number': 'singular' }] },
+        ],
+      },
+    });
+    const wrapper = mountDetail(json);
+    expect(wrapper.text()).toContain('feminine');
+    expect(wrapper.text()).toContain('singular');
+  });
+});

package/src/__tests__/nav-icon.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import { mount } from '@vue/test-utils';
+import NavIcon from '../components/NavIcon.vue';
+
+describe('NavIcon', () => {
+  it('renders an SVG element', () => {
+    const wrapper = mount(NavIcon, { props: { name: 'home' } });
+    expect(wrapper.find('svg').exists()).toBe(true);
+  });
+
+  it('renders home icon path', () => {
+    const wrapper = mount(NavIcon, { props: { name: 'home' } });
+    const path = wrapper.find('svg path');
+    expect(path.exists()).toBe(true);
+    expect(path.attributes('d')).toBeTruthy();
+  });
+
+  it('renders search icon', () => {
+    const wrapper = mount(NavIcon, { props: { name: 'search' } });
+    expect(wrapper.find('svg').exists()).toBe(true);
+  });
+
+  it('renders graph icon', () => {
+    const wrapper = mount(NavIcon, { props: { name: 'graph' } });
+    expect(wrapper.find('svg').exists()).toBe(true);
+  });
+
+  it('falls back to info icon for unknown name', () => {
+    const wrapper = mount(NavIcon, { props: { name: 'nonexistent' } });
+    expect(wrapper.find('svg').exists()).toBe(true);
+  });
+
+  it('applies correct CSS classes', () => {
+    const wrapper = mount(NavIcon, { props: { name: 'home' } });
+    const svg = wrapper.find('svg');
+    expect(svg.classes()).toContain('w-4');
+    expect(svg.classes()).toContain('h-4');
+    expect(svg.classes()).toContain('text-ink-400');
+  });
+
+  it('renders all known icon types', () => {
+    const icons = ['home', 'search', 'graph', 'newspaper', 'users', 'info', 'chart', 'list'];
+    for (const name of icons) {
+      const wrapper = mount(NavIcon, { props: { name } });
+      expect(wrapper.find('svg').exists()).toBe(true);
+    }
+  });
+});

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

@@ -0,0 +1,87 @@
+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 NewsView from '../views/NewsView.vue';
+
+async function createTestRouter() {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/news', name: 'news', component: { template: '<div/>' } },
+    ],
+  });
+  router.push('/news');
+  await router.isReady();
+  return router;
+}
+
+describe('NewsView', () => {
+  let pinia: ReturnType<typeof createPinia>;
+  let router: Awaited<ReturnType<typeof createTestRouter>>;
+
+  beforeEach(async () => {
+    pinia = createPinia();
+    setActivePinia(pinia);
+    router = await createTestRouter();
+  });
+
+  function mountNews() {
+    return mount(NewsView, {
+      global: { plugins: [pinia, router] },
+    });
+  }
+
+  it('renders breadcrumb navigation', () => {
+    const wrapper = mountNews();
+    expect(wrapper.text()).toContain('Home');
+    expect(wrapper.text()).toContain('News');
+  });
+
+  it('renders News heading', () => {
+    const wrapper = mountNews();
+    expect(wrapper.text()).toContain('News');
+  });
+
+  it('shows loading skeleton initially', () => {
+    const wrapper = mountNews();
+    expect(wrapper.find('.animate-pulse').exists()).toBe(true);
+  });
+
+  it('shows empty state when no posts', async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({ ok: true, json: () => Promise.resolve([]) });
+    const wrapper = mountNews();
+    await flushPromises();
+    expect(wrapper.text()).toContain('No news posts yet');
+  });
+
+  it('shows error state when fetch fails', async () => {
+    globalThis.fetch = vi.fn().mockRejectedValue(new Error('Network error'));
+    const wrapper = mountNews();
+    await flushPromises();
+    expect(wrapper.text()).toContain('Failed to load news posts');
+  });
+
+  it('renders posts when available', async () => {
+    const posts = [
+      { slug: 'test-post', title: 'Test Post', date: '2025-01-15', categories: ['release'], file: '/news/test-post.adoc', excerpt: 'A test excerpt.' },
+    ];
+    globalThis.fetch = vi.fn().mockResolvedValue({ ok: true, json: () => Promise.resolve(posts) });
+    const wrapper = mountNews();
+    await flushPromises();
+    expect(wrapper.text()).toContain('Test Post');
+    expect(wrapper.text()).toContain('release');
+    expect(wrapper.text()).toContain('A test excerpt.');
+  });
+
+  it('formats dates correctly', async () => {
+    const posts = [
+      { slug: 'dated', title: 'Dated', date: '2025-03-15', categories: [], file: '/news/dated.adoc', excerpt: '' },
+    ];
+    globalThis.fetch = vi.fn().mockResolvedValue({ ok: true, json: () => Promise.resolve(posts) });
+    const wrapper = mountNews();
+    await flushPromises();
+    expect(wrapper.text()).toContain('March 15, 2025');
+  });
+});

package/src/__tests__/ontology-registry.test.ts

@@ -0,0 +1,109 @@
+import { describe, it, expect } from 'vitest';
+import { ontology } from '../adapters/ontology-registry';
+
+describe('OntologyRegistry', () => {
+  it('loads all 10 taxonomies', () => {
+    expect(ontology.getAll('conceptStatus').length).toBe(7);
+    expect(ontology.getAll('entryStatus').length).toBe(4);
+    expect(ontology.getAll('normativeStatus').length).toBe(4);
+    expect(ontology.getAll('sourceType').length).toBe(2);
+    expect(ontology.getAll('sourceStatus').length).toBe(10);
+    expect(ontology.getAll('relationshipType').length).toBe(14);
+    expect(ontology.getAll('designationType').length).toBe(5);
+    expect(ontology.getAll('termType').length).toBe(24);
+    expect(ontology.getAll('grammarGender').length).toBe(4);
+    expect(ontology.getAll('grammarNumber').length).toBe(3);
+  });
+
+  it('returns correct labels for conceptStatus', () => {
+    expect(ontology.getLabel('conceptStatus', 'valid')).toBe('valid');
+    expect(ontology.getLabel('conceptStatus', 'superseded')).toBe('superseded');
+    expect(ontology.getLabel('conceptStatus', 'not_valid')).toBe('not valid');
+  });
+
+  it('returns correct labels for grammarGender', () => {
+    expect(ontology.getLabel('grammarGender', 'm')).toBe('masculine');
+    expect(ontology.getLabel('grammarGender', 'f')).toBe('feminine');
+    expect(ontology.getLabel('grammarGender', 'n')).toBe('neuter');
+    expect(ontology.getLabel('grammarGender', 'c')).toBe('common');
+  });
+
+  it('returns altLabel for grammarGender', () => {
+    expect(ontology.getAltLabel('grammarGender', 'm')).toBe('m');
+    expect(ontology.getAltLabel('grammarGender', 'f')).toBe('f');
+  });
+
+  it('returns definitions for every taxonomy value', () => {
+    for (const status of ['draft', 'submitted', 'not_valid', 'invalid', 'valid', 'superseded', 'retired']) {
+      expect(ontology.getDefinition('conceptStatus', status)).toBeTruthy();
+    }
+    for (const gender of ['m', 'f', 'n', 'c']) {
+      expect(ontology.getDefinition('grammarGender', gender)).toBeTruthy();
+    }
+    for (const status of ['identical', 'similar', 'modified', 'restyle', 'context_added', 'generalisation', 'specialisation', 'unspecified', 'related', 'not_equal']) {
+      expect(ontology.getDefinition('sourceStatus', status)).toBeTruthy();
+    }
+  });
+
+  it('returns correct hierarchy for designationType', () => {
+    expect(ontology.getBroader('designationType', 'abbreviation')).toBe('expression');
+    expect(ontology.getBroader('designationType', 'letter_symbol')).toBe('symbol');
+    expect(ontology.getBroader('designationType', 'graphical_symbol')).toBe('symbol');
+    expect(ontology.getBroader('designationType', 'expression')).toBeNull();
+    expect(ontology.getBroader('designationType', 'symbol')).toBeNull();
+  });
+
+  it('returns narrower for designationType', () => {
+    const childrenOfExpression = ontology.getNarrower('designationType', 'expression');
+    expect(childrenOfExpression.map(c => c.id)).toContain('abbreviation');
+
+    const childrenOfSymbol = ontology.getNarrower('designationType', 'symbol');
+    expect(childrenOfSymbol.map(c => c.id)).toEqual(expect.arrayContaining(['letter_symbol', 'graphical_symbol']));
+  });
+
+  it('returns broader for termType', () => {
+    expect(ontology.getBroader('termType', 'acronym')).toBe('abbreviation');
+    expect(ontology.getBroader('termType', 'initialism')).toBe('abbreviation');
+  });
+
+  it('returns null for unknown taxonomy/value', () => {
+    expect(ontology.getConcept('conceptStatus', 'nonexistent')).toBeNull();
+    expect(ontology.getLabel('conceptStatus', 'nonexistent')).toBe('nonexistent');
+    expect(ontology.getDefinition('conceptStatus', 'nonexistent')).toBeNull();
+  });
+
+  it('returns scheme IRIs', () => {
+    expect(ontology.getScheme('conceptStatus')).toContain('status');
+    expect(ontology.getScheme('grammarGender')).toContain('gender');
+  });
+
+  it('has() checks work', () => {
+    expect(ontology.has('conceptStatus', 'valid')).toBe(true);
+    expect(ontology.has('conceptStatus', 'nonexistent')).toBe(false);
+  });
+
+  it('normativeStatus includes correct labels', () => {
+    expect(ontology.getLabel('normativeStatus', 'preferred')).toBe('preferred');
+    expect(ontology.getLabel('normativeStatus', 'admitted')).toBe('admitted');
+    expect(ontology.getLabel('normativeStatus', 'deprecated')).toBe('deprecated');
+    expect(ontology.getLabel('normativeStatus', 'superseded')).toBe('superseded');
+  });
+
+  it('relationshipType has all glossarist-specific types', () => {
+    const types = ontology.getAll('relationshipType').map(c => c.id);
+    expect(types).toContain('deprecates');
+    expect(types).toContain('supersedes');
+    expect(types).toContain('superseded_by');
+    expect(types).toContain('compare');
+    expect(types).toContain('contrast');
+    expect(types).toContain('homograph');
+    expect(types).toContain('false_friend');
+    expect(types).toContain('abbreviated_form_for');
+    expect(types).toContain('short_form_for');
+    expect(types).toContain('sequentially_related');
+    expect(types).toContain('spatially_related');
+    expect(types).toContain('temporally_related');
+    expect(types).toContain('related_concept_broader');
+    expect(types).toContain('related_concept_narrower');
+  });
+});

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

@@ -0,0 +1,83 @@
+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 PageView from '../views/PageView.vue';
+
+async function createTestRouter(path = '/pages/test-page') {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/pages/:slug', name: 'page', component: { template: '<div/>' } },
+    ],
+  });
+  router.push(path);
+  await router.isReady();
+  return router;
+}
+
+describe('PageView', () => {
+  let pinia: ReturnType<typeof createPinia>;
+  let router: Awaited<ReturnType<typeof createTestRouter>>;
+
+  beforeEach(async () => {
+    pinia = createPinia();
+    setActivePinia(pinia);
+    router = await createTestRouter();
+  });
+
+  function mountPage() {
+    return mount(PageView, {
+      global: { plugins: [pinia, router] },
+    });
+  }
+
+  it('shows loading skeleton initially', () => {
+    const wrapper = mountPage();
+    expect(wrapper.find('.animate-pulse').exists()).toBe(true);
+  });
+
+  it('renders breadcrumb navigation', () => {
+    const wrapper = mountPage();
+    expect(wrapper.text()).toContain('Home');
+  });
+
+  it('shows page not found when fetch fails', async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({ ok: false });
+    const wrapper = mountPage();
+    await flushPromises();
+    expect(wrapper.text()).toContain('Page Not Found');
+    expect(wrapper.text()).toContain('test-page');
+  });
+
+  it('shows go home link on not found', async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({ ok: false });
+    const wrapper = mountPage();
+    await flushPromises();
+    const homeLink = wrapper.findAll('a').find(a => a.text() === 'Go Home');
+    expect(homeLink).toBeDefined();
+  });
+
+  it('renders page content when loaded', async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ title: 'About Us', html: '<p>Hello world</p>' }),
+    });
+    const wrapper = mountPage();
+    await flushPromises();
+    expect(wrapper.text()).toContain('About Us');
+    expect(wrapper.text()).toContain('Hello world');
+  });
+
+  it('renders page title in breadcrumb', async () => {
+    globalThis.fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: () => Promise.resolve({ title: 'About Us', html: '<p>Content</p>' }),
+    });
+    const wrapper = mountPage();
+    await flushPromises();
+    const breadcrumb = wrapper.find('nav[aria-label="Breadcrumb"]');
+    expect(breadcrumb.text()).toContain('About Us');
+  });
+});

package/src/__tests__/relationship-categories.test.ts

@@ -0,0 +1,62 @@
+import { describe, it, expect } from 'vitest';
+import { categorizeRelationship, relationshipLabel, RELATIONSHIP_CATEGORIES } from '../utils/relationship-categories';
+
+describe('RELATIONSHIP_CATEGORIES', () => {
+  it('has expected categories', () => {
+    const ids = RELATIONSHIP_CATEGORIES.map(c => c.id);
+    expect(ids).toContain('hierarchical');
+    expect(ids).toContain('mapping');
+    expect(ids).toContain('associative');
+    expect(ids).toContain('lifecycle');
+    expect(ids).toContain('comparative');
+    expect(ids).toContain('spatiotemporal');
+    expect(ids).toContain('lexical');
+    expect(ids).toContain('designation');
+  });
+
+  it('each category has required fields', () => {
+    for (const cat of RELATIONSHIP_CATEGORIES) {
+      expect(cat.id).toBeTruthy();
+      expect(cat.label).toBeTruthy();
+      expect(cat.types.length).toBeGreaterThan(0);
+      expect(cat.color).toBeTruthy();
+    }
+  });
+});
+
+describe('categorizeRelationship', () => {
+  it('categorizes broader as hierarchical', () => {
+    expect(categorizeRelationship('broader').id).toBe('hierarchical');
+  });
+
+  it('categorizes equivalent as mapping', () => {
+    expect(categorizeRelationship('equivalent').id).toBe('mapping');
+  });
+
+  it('categorizes references as associative', () => {
+    expect(categorizeRelationship('references').id).toBe('associative');
+  });
+
+  it('categorizes supersedes as lifecycle', () => {
+    expect(categorizeRelationship('supersedes').id).toBe('lifecycle');
+  });
+
+  it('categorizes compare as comparative', () => {
+    expect(categorizeRelationship('compare').id).toBe('comparative');
+  });
+
+  it('returns other for unknown type', () => {
+    expect(categorizeRelationship('unknown_type').id).toBe('other');
+  });
+});
+
+describe('relationshipLabel', () => {
+  it('formats snake_case as title case', () => {
+    expect(relationshipLabel('broader_generic')).toBe('Broader Generic');
+    expect(relationshipLabel('related_concept')).toBe('Related Concept');
+  });
+
+  it('handles single word', () => {
+    expect(relationshipLabel('broader')).toBe('Broader');
+  });
+});

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

@@ -0,0 +1,77 @@
+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 { resetFactory, getFactory } from '../adapters/factory';
+import ResolveView from '../views/ResolveView.vue';
+
+const TEST_URI = 'https://glossarist.org/test/concept/1';
+
+async function createTestRouter(uri = TEST_URI) {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/dataset/:registerId/concept/:conceptId', name: 'concept', component: { template: '<div/>' } },
+      { path: '/resolve/:uri(.*)', name: 'resolve', component: { template: '<div/>' } },
+    ],
+  });
+  router.push(`/resolve/${encodeURIComponent(uri)}`);
+  await router.isReady();
+  return router;
+}
+
+describe('ResolveView', () => {
+  let pinia: ReturnType<typeof createPinia>;
+  let router: Awaited<ReturnType<typeof createTestRouter>>;
+
+  beforeEach(async () => {
+    resetFactory();
+    pinia = createPinia();
+    setActivePinia(pinia);
+    router = await createTestRouter();
+    // Pre-seed the factory with a stub adapter so discoverDatasets is skipped
+    const factory = getFactory();
+    const adapter = { registerId: 'test', manifest: null };
+    (factory as any).adapters.set('test', adapter);
+  });
+
+  function mountResolve() {
+    return mount(ResolveView, {
+      global: { plugins: [pinia, router] },
+    });
+  }
+
+  it('shows resolving message while loading', () => {
+    const wrapper = mountResolve();
+    expect(wrapper.text()).toContain('Resolving...');
+  });
+
+  it('shows error when concept not found', async () => {
+    const wrapper = mountResolve();
+    await flushPromises();
+    expect(wrapper.text()).toContain('Concept not found');
+  });
+
+  it('displays the URI being resolved', async () => {
+    const wrapper = mountResolve();
+    await flushPromises();
+    expect(wrapper.text()).toContain('glossarist.org/test/concept/1');
+  });
+
+  it('shows return to home link on error', async () => {
+    const wrapper = mountResolve();
+    await flushPromises();
+    const link = wrapper.findAll('a').find(a => a.text().includes('Return to home'));
+    expect(link).toBeDefined();
+  });
+
+  it('resolves the URI via the factory resolver', async () => {
+    const factory = getFactory();
+    factory.resolver.registerDataset('test', ['https://glossarist.org/test/*']);
+    const resolution = factory.resolve(TEST_URI);
+    expect(resolution.type).toBe('internal');
+    expect(resolution).toHaveProperty('registerId', 'test');
+    expect(resolution).toHaveProperty('conceptId', '1');
+  });
+});