@glossarist/concept-browser 0.3.4 → 0.4.0

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

@@ -0,0 +1,200 @@
+import { describe, it, expect } from 'vitest';
+import { mount } from '@vue/test-utils';
+import ConceptTimeline from '../components/ConceptTimeline.vue';
+import { conceptFromJson } from '../adapters/model-bridge';
+
+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 || {}),
+    },
+  };
+}
+
+function mountTimeline(conceptJson: Record<string, any>, activeLang = 'eng', languageOrder?: string[]) {
+  const concept = conceptFromJson(conceptJson);
+  return mount(ConceptTimeline, {
+    props: {
+      concept,
+      activeLang,
+      languageOrder,
+    },
+  });
+}
+
+describe('ConceptTimeline', () => {
+  it('shows review metadata even without history entries', () => {
+    const wrapper = mountTimeline(makeConceptJson());
+    expect(wrapper.text()).toContain('Review Details');
+    expect(wrapper.text()).toContain('valid');
+  });
+
+  it('renders review date as timeline entry', () => {
+    const json = makeConceptJson({
+      eng: { 'gl:reviewDate': '2023-05-15' },
+    });
+    const wrapper = mountTimeline(json);
+    expect(wrapper.text()).toContain('Review initiated');
+    expect(wrapper.text()).toContain('2023');
+  });
+
+  it('renders review decision event', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:reviewDecisionEvent': 'Accepted',
+        'gl:reviewDate': '2023-05-15',
+        'gl:reviewDecisionDate': '2023-06-01',
+      },
+    });
+    const wrapper = mountTimeline(json);
+    expect(wrapper.text()).toContain('Accepted');
+  });
+
+  it('renders gl:dates entries', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:dates': [
+          { 'gl:dateType': 'accepted', 'gl:date': '2020-01-01' },
+          { 'gl:dateType': 'amended', 'gl:date': '2022-06-15' },
+        ],
+      },
+    });
+    const wrapper = mountTimeline(json);
+    expect(wrapper.text()).toContain('Concept accepted');
+    expect(wrapper.text()).toContain('Definition amended');
+    expect(wrapper.text()).toContain('2020');
+    expect(wrapper.text()).toContain('2022');
+  });
+
+  it('sorts entries by date ascending', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:dates': [
+          { 'gl:dateType': 'amended', 'gl:date': '2022-06-15' },
+          { 'gl:dateType': 'accepted', 'gl:date': '2020-01-01' },
+        ],
+      },
+    });
+    const wrapper = mountTimeline(json);
+    const texts = wrapper.text();
+    const acceptedIdx = texts.indexOf('Concept accepted');
+    const amendedIdx = texts.indexOf('Definition amended');
+    expect(acceptedIdx).toBeLessThan(amendedIdx);
+  });
+
+  it('shows language selector when multiple languages have history', () => {
+    const json = makeConceptJson({
+      eng: { 'gl:reviewDate': '2023-01-01' },
+      otherLangs: {
+        fra: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'fra',
+          'gl:reviewDate': '2023-02-01',
+        },
+      },
+    });
+    const wrapper = mountTimeline(json, 'eng', ['eng', 'fra']);
+    expect(wrapper.text()).toContain('French');
+  });
+
+  it('does not show language selector for single-language history', () => {
+    const json = makeConceptJson({
+      eng: { 'gl:reviewDate': '2023-01-01' },
+    });
+    const wrapper = mountTimeline(json);
+    const buttons = wrapper.findAll('button');
+    const langButtons = buttons.filter(b => b.text().includes('French'));
+    expect(langButtons.length).toBe(0);
+  });
+
+  it('emits update:activeLang on language button click', async () => {
+    const json = makeConceptJson({
+      eng: { 'gl:reviewDate': '2023-01-01' },
+      otherLangs: {
+        fra: {
+          '@type': 'gl:LocalizedConcept',
+          'gl:languageCode': 'fra',
+          'gl:reviewDate': '2023-02-01',
+        },
+      },
+    });
+    const wrapper = mountTimeline(json, 'eng', ['eng', 'fra']);
+    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 review metadata when present', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:reviewDate': '2023-01-01',
+        'gl:reviewStatus': 'final',
+        'gl:reviewDecision': 'accepted',
+        'gl:entryStatus': 'valid',
+        'gl:release': '3',
+      },
+    });
+    const wrapper = mountTimeline(json);
+    expect(wrapper.text()).toContain('Review Details');
+    expect(wrapper.text()).toContain('final');
+    expect(wrapper.text()).toContain('accepted');
+    expect(wrapper.text()).toContain('valid');
+    expect(wrapper.text()).toContain('3');
+  });
+
+  it('groups by year when more than 3 entries', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:dates': [
+          { 'gl:dateType': 'accepted', 'gl:date': '2019-03-01' },
+          { 'gl:dateType': 'amended', 'gl:date': '2020-06-15' },
+          { 'gl:dateType': 'amended', 'gl:date': '2021-09-20' },
+          { 'gl:dateType': 'published', 'gl:date': '2023-01-10' },
+        ],
+      },
+    });
+    const wrapper = mountTimeline(json);
+    expect(wrapper.text()).toContain('2019');
+    expect(wrapper.text()).toContain('2020');
+    expect(wrapper.text()).toContain('2021');
+    expect(wrapper.text()).toContain('2023');
+  });
+
+  it('uses simple layout for 3 or fewer entries', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:dates': [
+          { 'gl:dateType': 'accepted', 'gl:date': '2020-01-01' },
+          { 'gl:dateType': 'amended', 'gl:date': '2022-06-15' },
+        ],
+      },
+    });
+    const wrapper = mountTimeline(json);
+    expect(wrapper.text()).toContain('Concept accepted');
+    expect(wrapper.text()).toContain('Definition amended');
+  });
+
+  it('deduplicates review date if it matches a gl:date entry', () => {
+    const json = makeConceptJson({
+      eng: {
+        'gl:dates': [
+          { 'gl:dateType': 'review', 'gl:date': '2023-05-15' },
+        ],
+        'gl:reviewDate': '2023-05-15',
+      },
+    });
+    const wrapper = mountTimeline(json);
+    const reviewCount = wrapper.text().split('Review initiated').length - 1;
+    expect(reviewCount).toBeLessThanOrEqual(1);
+  });
+});

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

@@ -0,0 +1,88 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { mount, flushPromises } from '@vue/test-utils';
+import ConceptView from '../views/ConceptView.vue';
+import { useVocabularyStore } from '../stores/vocabulary';
+import { conceptFromJson } from '../adapters/model-bridge';
+import { createTestRouter, setupPinia, makeManifest, makeAdapterStub } from './test-helpers';
+
+describe('ConceptView', () => {
+  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());
+    store.datasets.set('test', makeAdapterStub());
+  });
+
+  function mountConceptView(registerId = 'test', conceptId = '1') {
+    return mount(ConceptView, {
+      global: {
+        plugins: [pinia, router],
+        stubs: { ConceptDetail: true },
+      },
+      props: { registerId, conceptId },
+    });
+  }
+
+  it('shows loading skeleton initially', () => {
+    const wrapper = mountConceptView();
+    expect(wrapper.find('.skeleton').exists()).toBe(true);
+  });
+
+  it('shows error when fetchConcept returns null', async () => {
+    const wrapper = mountConceptView();
+    await flushPromises();
+    expect(wrapper.text()).toContain('Failed to load concept');
+  });
+
+  it('shows retry button on error', async () => {
+    const wrapper = mountConceptView();
+    await flushPromises();
+    const retryBtn = wrapper.findAll('button').find(b => b.text() === 'Retry');
+    expect(retryBtn).toBeDefined();
+  });
+
+  it('shows back to dataset link on error', async () => {
+    const wrapper = mountConceptView();
+    await flushPromises();
+    const link = wrapper.findAll('a').find(a => a.text().includes('Back to dataset'));
+    expect(link).toBeDefined();
+  });
+
+  it('renders ConceptDetail when concept loads', async () => {
+    const concept = conceptFromJson({
+      '@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',
+          'gl:designation': [
+            { '@type': 'gl:Expression', 'gl:term': 'test', 'gl:normativeStatus': 'preferred' },
+          ],
+          'gl:definition': [{ '@type': 'gl:DetailedDefinition', 'gl:content': 'A test concept.' }],
+        },
+      },
+    });
+    const store = useVocabularyStore();
+    store.datasets.set('test', makeAdapterStub({ fetchConcept: () => Promise.resolve(concept) }));
+
+    const wrapper = mountConceptView();
+    await flushPromises();
+    expect(wrapper.findComponent({ name: 'ConceptDetail' }).exists()).toBe(true);
+  });
+
+  it('shows error when dataset not found', async () => {
+    const store = useVocabularyStore();
+    store.datasets.delete('test');
+    store.manifests.delete('test');
+    const wrapper = mountConceptView();
+    await flushPromises();
+    expect(wrapper.text()).toContain('Failed to load concept');
+  });
+});

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

@@ -0,0 +1,103 @@
+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 ContributorsView from '../views/ContributorsView.vue';
+import { useSiteConfig } from '../config/use-site-config';
+
+// Mock useSiteConfig so we can inject contributor data
+vi.mock('../config/use-site-config', () => {
+  let _config: any = {};
+  return {
+    useSiteConfig: () => ({ config: { value: _config } }),
+    __setConfig: (c: any) => { _config = c; },
+  };
+});
+
+async function createTestRouter() {
+  const router = createRouter({
+    history: createMemoryHistory(),
+    routes: [
+      { path: '/', name: 'home', component: { template: '<div/>' } },
+      { path: '/contributors', name: 'contributors', component: { template: '<div/>' } },
+    ],
+  });
+  router.push('/contributors');
+  await router.isReady();
+  return router;
+}
+
+describe('ContributorsView', () => {
+  let pinia: ReturnType<typeof createPinia>;
+  let router: Awaited<ReturnType<typeof createTestRouter>>;
+
+  beforeEach(async () => {
+    pinia = createPinia();
+    setActivePinia(pinia);
+    router = await createTestRouter();
+  });
+
+  function mountContributors() {
+    return mount(ContributorsView, {
+      global: { plugins: [pinia, router] },
+    });
+  }
+
+  it('renders breadcrumb navigation', () => {
+    const wrapper = mountContributors();
+    expect(wrapper.text()).toContain('Home');
+    expect(wrapper.text()).toContain('Contributors');
+  });
+
+  it('renders Contributors heading', () => {
+    const wrapper = mountContributors();
+    expect(wrapper.text()).toContain('Contributors');
+  });
+
+  it('shows empty state when no contributors', () => {
+    const wrapper = mountContributors();
+    expect(wrapper.text()).toContain('No contributor information available');
+  });
+
+  it('shows contributors table when data present', async () => {
+    const { __setConfig } = await import('../config/use-site-config') as any;
+    __setConfig({
+      contributors: [
+        { name: 'Jane Doe', role: 'Editor', organization: 'ISO', email: 'jane@example.com', url: 'https://example.com' },
+        { name: 'John Smith', role: 'Author', organization: 'IEC' },
+      ],
+    });
+    const wrapper = mountContributors();
+    expect(wrapper.text()).toContain('Jane Doe');
+    expect(wrapper.text()).toContain('John Smith');
+    expect(wrapper.text()).toContain('Editor');
+    expect(wrapper.text()).toContain('ISO');
+    expect(wrapper.text()).toContain('jane@example.com');
+    expect(wrapper.text()).toContain('Author');
+    expect(wrapper.text()).toContain('IEC');
+  });
+
+  it('links contributor name when URL present', async () => {
+    const { __setConfig } = await import('../config/use-site-config') as any;
+    __setConfig({
+      contributors: [
+        { name: 'Jane Doe', url: 'https://example.com' },
+      ],
+    });
+    const wrapper = mountContributors();
+    const link = wrapper.findAll('a').find(a => a.text() === 'Jane Doe');
+    expect(link).toBeDefined();
+    expect(link!.attributes('href')).toBe('https://example.com');
+  });
+
+  it('shows dash for missing role/org', async () => {
+    const { __setConfig } = await import('../config/use-site-config') as any;
+    __setConfig({
+      contributors: [{ name: 'Anonymous' }],
+    });
+    const wrapper = mountContributors();
+    const cells = wrapper.findAll('td');
+    const dashCount = cells.filter(c => c.text() === '—');
+    expect(dashCount.length).toBeGreaterThanOrEqual(2);
+  });
+});