@saooti/octopus-sdk 42.0.0-beta → 42.0.0-beta2

package/eslint-config.d.ts

@@ -0,0 +1,3 @@
+import type { ConfigArray } from 'typescript-eslint';
+declare const config: ConfigArray;
+export default config;

package/eslint-config.mjs

@@ -0,0 +1,54 @@
+import eslint from '@eslint/js';
+import eslintPluginVue from 'eslint-plugin-vue';
+import globals from 'globals';
+import typescriptEslint from 'typescript-eslint';
+import stylistic from '@stylistic/eslint-plugin';
+
+export default typescriptEslint.config(
+  { ignores: ['*.d.ts', '**/coverage', '**/dist'] },
+  {
+    extends: [
+      eslint.configs.recommended,
+      ...typescriptEslint.configs.recommended,
+      ...eslintPluginVue.configs['flat/recommended'],
+    ],
+    plugins: {
+      '@stylistic': stylistic,
+    },
+    files: ['**/*.{ts,vue}'],
+    languageOptions: {
+      ecmaVersion: 'latest',
+      sourceType: 'module',
+      globals: globals.browser,
+      parserOptions: {
+        parser: typescriptEslint.parser,
+      },
+    },
+    rules: {
+      // your rules
+      "curly": ['error'],
+
+      // Please don't use console statements and duplicated imports, TODOs are marked
+      "no-console": ['warn', { allow: ['warn', 'error'] }],
+      "no-warning-comments": ['warn'],
+      "no-duplicate-imports": ['warn'],
+
+      // Prevent errors when testing on refs (instead of value of ref)
+      "vue/no-ref-as-operand": ['error'],
+
+      // Indentation
+      "@stylistic/indent": ['warn', 4, { "SwitchCase": 0 }],
+      "vue/html-indent": ['warn', 4],
+      "vue/script-indent": ['warn', 4],
+      "@stylistic/no-mixed-spaces-and-tabs": ["error", "smart-tabs"],
+
+      // Number of attributes per line (increase because sometimes two is not a lot)
+      "vue/max-attributes-per-line": ['warn', { singleline: 2 } ],
+
+      // Disable default values required for props
+      "vue/require-default-prop": ['off'],
+
+      "@typescript-eslint/no-unused-vars": "warn"
+    }
+  }
+);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@saooti/octopus-sdk",
-  "version": "42.0.0-beta",
+  "version": "42.0.0-beta2",
   "private": false,
   "description": "Javascript SDK for using octopus",
   "author": "Saooti",
@@ -123,6 +123,9 @@
   },
   "files": [
     "dist",
-    "src"
+    "src",
+    "tests",
+    "eslint-config.mjs",
+    "eslint-config.d.ts"
   ]
 }

package/tests/api/podcastApi.spec.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+
+vi.mock('../../src/api/classicApi', () => ({
+    default: {
+        fetchData: vi.fn()
+    }
+}));
+
+import classicApi from '../../src/api/classicApi';
+import { podcastApi } from '../../src/api/podcastApi';
+
+const baseOptions = { organisationId: ['org-1'] };
+
+describe('podcastApi', () => {
+    describe('count', () => {
+        beforeEach(() => {
+            vi.mocked(classicApi.fetchData).mockResolvedValue({ count: 42, result: [], sort: null });
+        });
+
+        it('returns the count from search results', async () => {
+            const result = await podcastApi.count(baseOptions);
+            expect(result).toBe(42);
+        });
+
+        it('calls search with size 0', async () => {
+            await podcastApi.count(baseOptions);
+            expect(classicApi.fetchData).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    parameters: expect.objectContaining({ size: 0 })
+                })
+            );
+        });
+
+        it('forwards other options to search', async () => {
+            await podcastApi.count({ ...baseOptions, emissionId: 5 });
+            expect(classicApi.fetchData).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    parameters: expect.objectContaining({ organisationId: ['org-1'], emissionId: 5 })
+                })
+            );
+        });
+    });
+});

package/tests/api/transcriptionApi.spec.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+
+vi.mock('../../src/api/classicApi', () => ({
+    default: {
+        fetchData: vi.fn()
+    }
+}));
+
+import classicApi from '../../src/api/classicApi';
+import { transcriptionApi } from '../../src/api/transcriptionApi';
+import { ModuleApi } from '../../src/api/apiConnection';
+
+describe('transcriptionApi', () => {
+    beforeEach(() => {
+        vi.mocked(classicApi.fetchData).mockResolvedValue('');
+    });
+
+    describe('getTranslations', () => {
+        it('calls the SPEECHTOTEXT api with the correct path', async () => {
+            await transcriptionApi.getTranslations(42);
+            expect(classicApi.fetchData).toHaveBeenCalledWith({
+                api: ModuleApi.SPEECHTOTEXT,
+                path: 'transcription/42/languages',
+            });
+        });
+    });
+
+    describe('getTranslation', () => {
+        it('calls the SPEECHTOTEXT api with the correct path', async () => {
+            await transcriptionApi.getTranslation(42, 'en');
+            expect(classicApi.fetchData).toHaveBeenCalledWith({
+                api: ModuleApi.SPEECHTOTEXT,
+                path: 'transcription/42/languages/en/srt',
+            });
+        });
+
+        it.each([
+            [true, 'true'],
+            [false, 'false'],
+        ])('appends mayCreateIfNotExists=%s to path when mayCreate is %s', async (mayCreate, suffix) => {
+            await transcriptionApi.getTranslation(42, 'en', mayCreate);
+            expect(classicApi.fetchData).toHaveBeenCalledWith({
+                api: ModuleApi.SPEECHTOTEXT,
+                path: `transcription/42/languages/en/srt?mayCreateIfNotExists=${suffix}`,
+            });
+        });
+    });
+
+    describe('getRawTranscription', () => {
+        it('calls the SPEECHTOTEXT api with the correct path', async () => {
+            await transcriptionApi.getRawTranscription(42);
+            expect(classicApi.fetchData).toHaveBeenCalledWith({
+                api: ModuleApi.SPEECHTOTEXT,
+                path: 'transcription/text/42',
+            });
+        });
+    });
+});

package/tests/components/composable/player/usePlayerTranscript.spec.ts

@@ -0,0 +1,238 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { defineComponent } from 'vue';
+import { mount as _mount } from '@vue/test-utils';
+import { flushPromises } from '@vue/test-utils';
+import { setupPinia } from '@tests/utils';
+import { usePlayerStore } from '@/stores/PlayerStore';
+import { useVastStore } from '@/stores/VastStore';
+import { usePlayerTranscript } from '@/components/composable/player/usePlayerTranscript';
+
+vi.mock('@/components/composable/useTranslation', () => ({
+    useTranslation: vi.fn(),
+}));
+
+vi.mock('@/api/classicApi', () => ({
+    default: { fetchData: vi.fn() },
+}));
+
+vi.mock('@/api/transcriptionApi', () => ({
+    transcriptionApi: {
+        getTranslations: vi.fn().mockResolvedValue({
+            podcastId: 42,
+            nativeLanguage: 'fr',
+            translations: [],
+        }),
+        getTranslation: vi.fn().mockResolvedValue(''),
+    },
+    TranslationState: { FINISHED: 'FINISHED' },
+}));
+
+import { useTranslation } from '@/components/composable/useTranslation';
+import { transcriptionApi } from '@/api/transcriptionApi';
+import classicApi from '@/api/classicApi';
+
+const SRT_FROM_ZERO = '1\n00:00:00,000 --> 00:00:02,000\nHello\n\n2\n00:00:02,000 --> 00:00:04,000\nWorld\n\n';
+const SRT_DELAYED_START = '1\n00:00:01,000 --> 00:00:02,000\nHello\n\n';
+
+describe('usePlayerTranscript', () => {
+    let composable: ReturnType<typeof usePlayerTranscript>;
+    let playerStore: ReturnType<typeof usePlayerStore>;
+    let mockGetMostRelevantLanguage: ReturnType<typeof vi.fn>;
+
+    beforeEach(() => {
+        vi.clearAllMocks();
+        mockGetMostRelevantLanguage = vi.fn().mockResolvedValue({ ready: 'fr' });
+        vi.mocked(useTranslation).mockReturnValue({
+            getMostRelevantLanguage: mockGetMostRelevantLanguage,
+        } as unknown as ReturnType<typeof useTranslation>);
+
+        const pinia = setupPinia();
+
+        let result!: ReturnType<typeof usePlayerTranscript>;
+        _mount(defineComponent({
+            setup() {
+                playerStore = usePlayerStore();
+                result = usePlayerTranscript();
+                return {};
+            },
+            template: '<div/>',
+        }), { global: { plugins: [pinia] } });
+        composable = result;
+        composable.generatingTranscriptLanguage.value = null;
+    });
+
+    describe('getTranscription', () => {
+        it('clears transcript when playerPodcast is undefined', async () => {
+            const spy = vi.spyOn(playerStore, 'playerUpdateTranscript');
+
+            await composable.getTranscription();
+
+            expect(spy).toHaveBeenCalledWith();
+            expect(mockGetMostRelevantLanguage).not.toHaveBeenCalled();
+        });
+
+        it('sets actualText from the first entry when it starts at 0', async () => {
+            playerStore.$patch({ playerPodcast: { podcastId: 42 } as never });
+            vi.mocked(transcriptionApi.getTranslation).mockResolvedValue(SRT_FROM_ZERO);
+            const spy = vi.spyOn(playerStore, 'playerUpdateTranscript');
+
+            await composable.getTranscription();
+
+            expect(transcriptionApi.getTranslations).toHaveBeenCalledWith(42);
+            expect(transcriptionApi.getTranslation).toHaveBeenCalledWith(42, 'fr');
+            expect(spy).toHaveBeenCalledWith({
+                actual: 0,
+                actualText: 'Hello',
+                value: [
+                    { startTime: 0, endTime: 2, text: 'Hello' },
+                    { startTime: 2, endTime: 4, text: 'World' },
+                ],
+            });
+        });
+
+        it('sets empty actualText when the first entry starts after 0', async () => {
+            playerStore.$patch({ playerPodcast: { podcastId: 42 } as never });
+            vi.mocked(transcriptionApi.getTranslation).mockResolvedValue(SRT_DELAYED_START);
+            const spy = vi.spyOn(playerStore, 'playerUpdateTranscript');
+
+            await composable.getTranscription();
+
+            expect(spy).toHaveBeenCalledWith(expect.objectContaining({ actualText: '' }));
+        });
+    });
+
+    describe('generatingTranscriptLanguage', () => {
+        it('is null initially', () => {
+            expect(composable.generatingTranscriptLanguage.value).toBeNull();
+        });
+
+        it('is reset to null when getTranscription starts', async () => {
+            composable.generatingTranscriptLanguage.value = 'de';
+
+            await composable.getTranscription(); // no podcast → returns early
+
+            expect(composable.generatingTranscriptLanguage.value).toBeNull();
+        });
+
+        it('is set to the available language while a better translation is being generated', async () => {
+            playerStore.$patch({ playerPodcast: { podcastId: 42 } as never });
+            mockGetMostRelevantLanguage.mockResolvedValue({ ready: 'fr', available: 'en' });
+
+            let resolveGeneration!: (value: string) => void;
+            vi.mocked(transcriptionApi.getTranslation)
+                .mockResolvedValueOnce('') // first call: ready='fr'
+                .mockReturnValueOnce(new Promise(resolve => { resolveGeneration = resolve; }));
+
+            const promise = composable.getTranscription();
+            await flushPromises();
+
+            expect(composable.generatingTranscriptLanguage.value).toBe('en');
+
+            resolveGeneration('');
+            await flushPromises();
+
+            expect(composable.generatingTranscriptLanguage.value).toBeNull();
+            await promise;
+        });
+
+        it('updates transcript with the better translation once generated', async () => {
+            playerStore.$patch({ playerPodcast: { podcastId: 42 } as never });
+            mockGetMostRelevantLanguage.mockResolvedValue({ ready: 'fr', available: 'en' });
+            vi.mocked(transcriptionApi.getTranslation)
+                .mockResolvedValueOnce('') // for ready='fr'
+                .mockResolvedValueOnce(SRT_FROM_ZERO); // for available='en'
+
+            const spy = vi.spyOn(playerStore, 'playerUpdateTranscript');
+
+            await composable.getTranscription();
+
+            expect(transcriptionApi.getTranslation).toHaveBeenCalledWith(42, 'en', true);
+            expect(spy).toHaveBeenCalledWith(expect.objectContaining({
+                actualText: 'Hello',
+                value: [
+                    { startTime: 0, endTime: 2, text: 'Hello' },
+                    { startTime: 2, endTime: 4, text: 'World' },
+                ],
+            }));
+        });
+    });
+
+    describe('onTimeUpdateTranscript', () => {
+        it('does nothing when there is no transcript', () => {
+            composable.onTimeUpdateTranscript(1);
+            expect(playerStore.playerTranscript).toBeUndefined();
+        });
+
+        it('sets actualText when currentTime reaches startTime', () => {
+            playerStore.playerUpdateTranscript({
+                actual: 0, actualText: '',
+                value: [{ startTime: 1, endTime: 3, text: 'Hello' }],
+            });
+
+            composable.onTimeUpdateTranscript(1.5);
+
+            expect(playerStore.playerTranscript?.actualText).toBe('Hello');
+            expect(playerStore.playerTranscript?.actual).toBe(0);
+        });
+
+        it('advances to the next entry when currentTime exceeds endTime', () => {
+            playerStore.playerUpdateTranscript({
+                actual: 0, actualText: '',
+                value: [
+                    { startTime: 0, endTime: 2, text: 'Hello' },
+                    { startTime: 2, endTime: 4, text: 'World' },
+                ],
+            });
+
+            composable.onTimeUpdateTranscript(3);
+
+            expect(playerStore.playerTranscript?.actual).toBe(1);
+            expect(playerStore.playerTranscript?.actualText).toBe('World');
+        });
+    });
+
+    describe('onSeekedTranscript', () => {
+        it('does nothing when there is no transcript', () => {
+            composable.onSeekedTranscript(5);
+            expect(playerStore.playerTranscript).toBeUndefined();
+        });
+
+        it('seeks to the correct entry index', () => {
+            playerStore.playerUpdateTranscript({
+                actual: 0, actualText: '',
+                value: [
+                    { startTime: 0, endTime: 2, text: 'Hello' },
+                    { startTime: 2, endTime: 4, text: 'World' },
+                    { startTime: 4, endTime: 6, text: 'Bye' },
+                ],
+            });
+
+            composable.onSeekedTranscript(3);
+
+            expect(playerStore.playerTranscript?.actual).toBe(1);
+        });
+    });
+
+    describe('checkDelaytWithStitching', () => {
+        it('always resets the stitching delay to 0', async () => {
+            const spy = vi.spyOn(playerStore, 'playerUpdateDelayStitching');
+            useVastStore().$patch({ useVastPlayerPodcast: true });
+
+            await composable.checkDelaytWithStitching();
+
+            expect(spy).toHaveBeenCalledWith(0);
+        });
+
+        it.each([
+            ['useVastPlayerPodcast is true', () => useVastStore().$patch({ useVastPlayerPodcast: true })],
+            ['no #audio-player element exists', () => playerStore.$patch({
+                playerPodcast: { podcastId: 1 } as never,
+                playerTranscript: { actual: 0, actualText: '', value: [] },
+            })],
+        ])('returns early when %s', async (_, setup) => {
+            setup();
+            await composable.checkDelaytWithStitching();
+            expect(classicApi.fetchData).not.toHaveBeenCalled();
+        });
+    });
+});

package/tests/components/composable/useAdvancedParamInit.spec.ts

@@ -0,0 +1,91 @@
+import { mockUseRouter } from '@tests/mocks';
+vi.mock('vue-router', () => mockUseRouter());
+
+import { describe, expect, it, vi, beforeEach } from 'vitest';
+import { defineComponent, nextTick } from 'vue';
+import { mount as _mount } from '@vue/test-utils';
+
+import { useAdvancedParamInit } from '@/components/composable/route/useAdvancedParamInit';
+import { state } from '@/stores/ParamSdkStore';
+import { setupPinia, setupAuthStore } from '@tests/utils';
+import type { RouteProps } from '@/components/composable/route/types';
+
+vi.mock('@/api/groupsApi', () => ({
+    groupsApi: { getAllById: vi.fn().mockResolvedValue({}) }
+}));
+
+async function setupComposable(
+    props: RouteProps,
+    isEmission: boolean,
+    patchStores?: () => void | Promise<void>
+): Promise<ReturnType<typeof useAdvancedParamInit>> {
+    let result!: ReturnType<typeof useAdvancedParamInit>;
+
+    const pinia = setupPinia();
+    await patchStores?.();
+
+    _mount(defineComponent({
+        setup() { result = useAdvancedParamInit(props, isEmission); return {}; },
+        template: '<div/>'
+    }), { global: { plugins: [pinia] } });
+
+    await nextTick(); // allow onMounted
+    await nextTick(); // allow isInit via nextTick in initAdvancedParams
+
+    return result;
+}
+
+describe('useAdvancedParamInit', () => {
+    beforeEach(() => {
+        state.generalParameters.podcastmaker = false;
+    });
+
+    describe('initValidity', () => {
+        const propsWithHidden: RouteProps = { routeValidity: 'false', routeIncludeHidden: 'true' };
+        const withOrg = (roles: string[]) => setupAuthStore({ roles, organisationId: 'test-org-id' });
+
+        describe('forces validity to "true"', () => {
+            it('when isEmission is true', async () => {
+                const { validity } = await setupComposable(propsWithHidden, true, withOrg(['PRODUCTION']));
+                expect(validity.value).toBe('true');
+            });
+
+            it('when isPodcastmaker is true', async () => {
+                state.generalParameters.podcastmaker = true;
+                const { validity } = await setupComposable(propsWithHidden, false, withOrg(['PRODUCTION']));
+                expect(validity.value).toBe('true');
+            });
+
+            it('when includeHidden is false (no org)', async () => {
+                // authOrgaId starts undefined → filterOrgaId undefined → organisation undefined → includeHidden false
+                const { validity } = await setupComposable(propsWithHidden, false);
+                expect(validity.value).toBe('true');
+            });
+
+            it('when routeIncludeHidden is "false"', async () => {
+                const { validity } = await setupComposable(
+                    { routeValidity: 'false', routeIncludeHidden: 'false' },
+                    false,
+                    withOrg(['PRODUCTION'])
+                );
+                expect(validity.value).toBe('true');
+            });
+
+            (['PODCAST_CRUD', 'RESTRICTED_PRODUCTION', 'PLAYLISTS'] as const).forEach(role => {
+                it(`when role cannot validate (${role})`, async () => {
+                    const { validity } = await setupComposable(propsWithHidden, false, withOrg([role]));
+                    expect(validity.value).toBe('true');
+                });
+            });
+        });
+
+        describe('uses routeValidity when canValidatePodcast() is true', () => {
+            (['ADMIN', 'ORGANISATION', 'PRODUCTION', 'PODCAST_VALIDATION'] as const).forEach(role => {
+                it(`allows role ${role}`, async () => {
+                    const { validity } = await setupComposable(propsWithHidden, false, withOrg([role]));
+                    expect(validity.value).toBe('false');
+                });
+            });
+        });
+    });
+});

package/tests/components/composable/usePresentationItem.spec.ts

@@ -0,0 +1,164 @@
+import { mockI18n } from '@tests/mocks';
+vi.mock('vue-i18n', () => mockI18n());
+
+vi.mock('@/api', () => ({
+    rubriquesApi: { getCachedRubrique: vi.fn() },
+}));
+
+import { rubriquesApi } from '@/api';
+import { usePresentationItem } from '@/components/composable/usePresentationItem';
+import { emptyEmissionData, Emission } from '@/stores/class/general/emission';
+import { emptyPodcastData, Podcast } from '@/stores/class/general/podcast';
+import { Rubrique } from '@/stores/class/rubrique/rubrique';
+import { useGeneralStore } from '@/stores/GeneralStore';
+import { state } from '@/stores/ParamSdkStore';
+import { setupPinia } from '@tests/utils';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+function rubrique(rubriqueId: number, name: string, rubriquageId?: number): Rubrique {
+    return { rubriqueId, name, rubriquageId };
+}
+
+beforeEach(() => {
+    setupPinia();
+    state.presentationItems = { tags: 'none' };
+    vi.mocked(rubriquesApi.getCachedRubrique).mockReset();
+});
+
+describe('usePresentationItem', () => {
+    describe('tagsFor', () => {
+        it('returns undefined when tags type is none', async () => {
+            const { tagsFor } = usePresentationItem();
+            expect(await tagsFor(emptyEmissionData())).toBeUndefined();
+        });
+
+        describe('iab type', () => {
+            beforeEach(() => {
+                state.presentationItems.tags = 'iab';
+                useGeneralStore().storedUpdateCategories([
+                    { id: 1, name: 'News' },
+                    { id: 2, name: 'Sport' },
+                ]);
+            });
+
+            it('returns the names of categories matching the emission iabIds', async () => {
+                const { tagsFor } = usePresentationItem();
+                const emission: Emission = { ...emptyEmissionData(), iabIds: [2] };
+                expect(await tagsFor(emission)).toEqual(['Sport']);
+            });
+
+            it('reads iabIds from the podcast emission', async () => {
+                const { tagsFor } = usePresentationItem();
+                const podcast: Podcast = emptyPodcastData();
+                podcast.emission = { ...emptyEmissionData(), iabIds: [1, 2] };
+                expect(await tagsFor(podcast)).toEqual(['News', 'Sport']);
+            });
+        });
+
+        describe('rubrique type', () => {
+            beforeEach(() => {
+                state.presentationItems.tags = 'rubrique';
+            });
+
+            it('fetches tags for an emission rubriqueIds', async () => {
+                vi.mocked(rubriquesApi.getCachedRubrique).mockImplementation(
+                    (id) => Promise.resolve(rubrique(id, `Rubrique ${id}`))
+                );
+                const { tagsFor } = usePresentationItem();
+                const emission: Emission = { ...emptyEmissionData(), rubriqueIds: [1, 2] };
+                expect(await tagsFor(emission)).toEqual(['Rubrique 1', 'Rubrique 2']);
+            });
+
+            it('combines a podcast rubriqueIds with its emission rubriqueIds', async () => {
+                vi.mocked(rubriquesApi.getCachedRubrique).mockImplementation(
+                    (id) => Promise.resolve(rubrique(id, `Rubrique ${id}`))
+                );
+                const { tagsFor } = usePresentationItem();
+                const podcast: Podcast = emptyPodcastData();
+                podcast.rubriqueIds = [1];
+                podcast.emission = { ...emptyEmissionData(), rubriqueIds: [2] };
+                expect(await tagsFor(podcast)).toEqual(['Rubrique 1', 'Rubrique 2']);
+            });
+
+            it('filters rubriques by tagsRubriquageId when set', async () => {
+                vi.mocked(rubriquesApi.getCachedRubrique).mockImplementation((id) => {
+                    if (id === 1) { return Promise.resolve(rubrique(1, 'Kept', 10)); }
+                    return Promise.resolve(rubrique(2, 'Discarded', 20));
+                });
+                state.presentationItems.tagsRubriquageId = 10;
+                const { tagsFor } = usePresentationItem();
+                const emission: Emission = { ...emptyEmissionData(), rubriqueIds: [1, 2] };
+                expect(await tagsFor(emission)).toEqual(['Kept']);
+            });
+        });
+
+        it('limits the number of tags when tagsLimit is set', async () => {
+            state.presentationItems.tags = 'iab';
+            state.presentationItems.tagsLimit = 1;
+            useGeneralStore().storedUpdateCategories([
+                { id: 1, name: 'News' },
+                { id: 2, name: 'Sport' },
+            ]);
+            const { tagsFor } = usePresentationItem();
+            const emission: Emission = { ...emptyEmissionData(), iabIds: [1, 2] };
+            expect(await tagsFor(emission)).toEqual(['News']);
+        });
+    });
+
+    describe('additionalInfoFor', () => {
+        it('returns undefined when additionalInfo is not configured', () => {
+            const { additionalInfoFor } = usePresentationItem();
+            expect(additionalInfoFor(emptyEmissionData())).toBeUndefined();
+        });
+
+        it('returns undefined when additionalInfo is empty', () => {
+            state.presentationItems.additionalInfo = [];
+            const { additionalInfoFor } = usePresentationItem();
+            expect(additionalInfoFor(emptyEmissionData())).toBeUndefined();
+        });
+
+        it('resolves productor from the emission organisation name for an emission', () => {
+            state.presentationItems.additionalInfo = ['productor'];
+            const { additionalInfoFor } = usePresentationItem();
+            const emission: Emission = { ...emptyEmissionData(), orga: { id: '1', name: 'Saooti', imageUrl: '' } };
+            expect(additionalInfoFor(emission)).toEqual(['Saooti']);
+        });
+
+        it('resolves productor from the podcast emission organisation name', () => {
+            state.presentationItems.additionalInfo = ['productor'];
+            const { additionalInfoFor } = usePresentationItem();
+            const podcast: Podcast = emptyPodcastData();
+            podcast.emission = { ...emptyEmissionData(), orga: { id: '1', name: 'Saooti', imageUrl: '' } };
+            expect(additionalInfoFor(podcast)).toEqual(['Saooti']);
+        });
+
+        it('formats the podcast pubDate for the date info', () => {
+            state.presentationItems.additionalInfo = ['date'];
+            const { additionalInfoFor } = usePresentationItem();
+            const podcast: Podcast = emptyPodcastData();
+            podcast.pubDate = '2025-12-01T10:21:31.000+00:00';
+            expect(additionalInfoFor(podcast)).toEqual(['1 décembre 2025']);
+        });
+
+        it('omits the date info for an emission (no pubDate)', () => {
+            state.presentationItems.additionalInfo = ['date'];
+            const { additionalInfoFor } = usePresentationItem();
+            expect(additionalInfoFor(emptyEmissionData())).toEqual([]);
+        });
+
+        it('omits the date info for a podcast without a pubDate', () => {
+            state.presentationItems.additionalInfo = ['date'];
+            const { additionalInfoFor } = usePresentationItem();
+            expect(additionalInfoFor(emptyPodcastData())).toEqual([]);
+        });
+
+        it('combines multiple info entries in order', () => {
+            state.presentationItems.additionalInfo = ['date', 'productor'];
+            const { additionalInfoFor } = usePresentationItem();
+            const podcast: Podcast = emptyPodcastData();
+            podcast.pubDate = '2025-12-01T10:21:31.000+00:00';
+            podcast.emission = { ...emptyEmissionData(), orga: { id: '1', name: 'Saooti', imageUrl: '' } };
+            expect(additionalInfoFor(podcast)).toEqual(['1 décembre 2025', 'Saooti']);
+        });
+    });
+});