@saooti/octopus-sdk 41.12.0-beta3 → 41.12.0

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

@@ -0,0 +1,163 @@
+import '@tests/mocks/i18n';
+
+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']);
+        });
+    });
+});

package/tests/components/display/emission/EmissionPresentationItem.spec.ts

@@ -0,0 +1,45 @@
+import '@tests/mocks/i18n';
+
+const tagsFor = vi.fn();
+const additionalInfoFor = vi.fn();
+
+vi.mock('@/components/composable/usePresentationItem', () => ({
+    usePresentationItem: () => ({ tagsFor, additionalInfoFor }),
+}));
+
+import EmissionPresentationItem from '@/components/display/emission/EmissionPresentationItem.vue';
+import { emptyEmissionData } from '@/stores/class/general/emission';
+import { mount as testMount } from '@tests/utils';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { nextTick } from 'vue';
+
+const mount = (props: Record<string, unknown>) => testMount(EmissionPresentationItem, { shallow: true, props });
+
+beforeEach(() => {
+    tagsFor.mockReset().mockResolvedValue([]);
+    additionalInfoFor.mockReset().mockReturnValue(undefined);
+});
+
+describe('EmissionPresentationItem', () => {
+    it('calls tagsFor with the emission prop', async () => {
+        const emission = { ...emptyEmissionData(), emissionId: 42 };
+        await mount({ emission });
+        expect(tagsFor).toHaveBeenCalledWith(emission);
+    });
+
+    it('resolves tagsFor asynchronously and forwards the result as the tags prop', async () => {
+        tagsFor.mockResolvedValue(['News']);
+        const wrapper = await mount({ emission: emptyEmissionData() });
+        await nextTick();
+        await nextTick();
+        const presentationItem = wrapper.findComponent({ name: 'PresentationItem' });
+        expect(presentationItem.props('tags')).toEqual(['News']);
+    });
+
+    it('forwards additionalInfoFor result as the additional-info prop', async () => {
+        additionalInfoFor.mockReturnValue(['Saooti']);
+        const wrapper = await mount({ emission: emptyEmissionData() });
+        const presentationItem = wrapper.findComponent({ name: 'PresentationItem' });
+        expect(presentationItem.props('additionalInfo')).toEqual(['Saooti']);
+    });
+});

package/tests/components/display/podcasts/PodcastPresentationList.spec.ts

@@ -0,0 +1,107 @@
+import '@tests/mocks/i18n';
+import '@tests/mocks/useRouter';
+
+vi.mock('@/api/classicApi', () => ({
+    default: { fetchData: vi.fn() },
+}));
+vi.mock('@/api/podcastApi', () => ({
+    podcastApi: { search: vi.fn() },
+    PodcastSort: { DATE: 'DATE' },
+}));
+
+const tagsFor = vi.fn();
+const additionalInfoFor = vi.fn();
+vi.mock('@/components/composable/usePresentationItem', () => ({
+    usePresentationItem: () => ({ tagsFor, additionalInfoFor }),
+}));
+
+import classicApi from '@/api/classicApi';
+import { podcastApi } from '@/api/podcastApi';
+import PodcastPresentationList from '@/components/display/podcasts/PodcastPresentationList.vue';
+import { emptyEmissionData, Emission } from '@/stores/class/general/emission';
+import { PodcastType, SimplifiedPodcast } from '@/stores/class/general/podcast';
+import { mount as testMount } from '@tests/utils';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { flushPromises } from '@vue/test-utils';
+
+function makeEmission(emissionId: number): Emission {
+    return { ...emptyEmissionData(), emissionId, name: `Emission ${emissionId}`, orga: { id: 'org-1', name: 'Orga', imageUrl: '' } };
+}
+
+function makeSimplifiedPodcast(emissionId: number, podcastId: number, pubDate: string): SimplifiedPodcast {
+    return {
+        podcastId,
+        emissionId,
+        organisationId: 'org-1',
+        audioUrl: '',
+        audioStorageUrl: '',
+        article: '',
+        imageUrl: '',
+        title: `Podcast ${podcastId}`,
+        description: undefined,
+        tags: [],
+        beneficiaries: [],
+        availability: { visibility: true, date: undefined },
+        monetisable: 'UNDEFINED',
+        pubDate,
+        conferenceId: undefined,
+        duration: 0,
+        seasonEpisodeType: PodcastType.FULL,
+    };
+}
+
+const mount = (props: Record<string, unknown> = {}) => testMount(PodcastPresentationList, {
+    props,
+    stubs: ['PresentationItem', 'PodcastPlayButton'],
+});
+
+beforeEach(() => {
+    tagsFor.mockReset();
+    additionalInfoFor.mockReset().mockReturnValue(undefined);
+});
+
+describe('PodcastPresentationList', () => {
+    it('populates the tags prop of each item once tagsFor resolves', async () => {
+        vi.mocked(classicApi.fetchData).mockResolvedValue({ count: 1, sort: '', result: [makeEmission(1)] });
+        vi.mocked(podcastApi.search).mockResolvedValue({
+            count: 1, sort: '', result: [makeSimplifiedPodcast(1, 10, '2025-01-01T00:00:00.000Z')],
+        });
+        tagsFor.mockResolvedValue(['News']);
+
+        const wrapper = await mount();
+        await flushPromises();
+
+        const items = wrapper.findAllComponents({ name: 'PresentationItem' });
+        expect(items).toHaveLength(1);
+        expect(items[0].props('tags')).toEqual(['News']);
+    });
+
+    it('fetches tags only once per podcast', async () => {
+        vi.mocked(classicApi.fetchData).mockResolvedValue({ count: 1, sort: '', result: [makeEmission(1)] });
+        vi.mocked(podcastApi.search).mockResolvedValue({
+            count: 1, sort: '', result: [makeSimplifiedPodcast(1, 10, '2025-01-01T00:00:00.000Z')],
+        });
+        tagsFor.mockResolvedValue(['News']);
+
+        await mount();
+        await flushPromises();
+        await flushPromises();
+
+        expect(tagsFor).toHaveBeenCalledTimes(1);
+    });
+
+    it('forwards additionalInfoFor result as the additional-info prop of each item', async () => {
+        vi.mocked(classicApi.fetchData).mockResolvedValue({ count: 1, sort: '', result: [makeEmission(1)] });
+        vi.mocked(podcastApi.search).mockResolvedValue({
+            count: 1, sort: '', result: [makeSimplifiedPodcast(1, 10, '2025-01-01T00:00:00.000Z')],
+        });
+        tagsFor.mockResolvedValue([]);
+        additionalInfoFor.mockReturnValue(['Orga']);
+
+        const wrapper = await mount();
+        await flushPromises();
+
+        const items = wrapper.findAllComponents({ name: 'PresentationItem' });
+        expect(items[0].props('additionalInfo')).toEqual(['Orga']);
+    });
+});

package/tests/components/form/ClassicButtonGroup.spec.ts

@@ -49,4 +49,30 @@ describe('ClassicButtonGroup', () => {
         await wrapper.findAll('button')[0].trigger('click');
         expect(wrapper.emitted('update:value')).toBeUndefined();
     });
+
+    describe('solo prop', () => {
+        it('emits only the clicked value when clicking an inactive button', async () => {
+            const wrapper = await mount(ClassicButtonGroup, {
+                props: { options, value: ['PODCAST'], solo: true },
+            });
+            await wrapper.findAll('button')[1].trigger('click');
+            expect(wrapper.emitted('update:value')?.[0]).toEqual([['VIDEO']]);
+        });
+
+        it('emits only the clicked value when clicking the already active button', async () => {
+            const wrapper = await mount(ClassicButtonGroup, {
+                props: { options, value: ['PODCAST'], solo: true },
+            });
+            await wrapper.findAll('button')[0].trigger('click');
+            expect(wrapper.emitted('update:value')?.[0]).toEqual([['PODCAST']]);
+        });
+
+        it('replaces multiple active values with the clicked one', async () => {
+            const wrapper = await mount(ClassicButtonGroup, {
+                props: { options, value: ['PODCAST', 'VIDEO'], solo: true },
+            });
+            await wrapper.findAll('button')[2].trigger('click');
+            expect(wrapper.emitted('update:value')?.[0]).toEqual([['LIVE']]);
+        });
+    });
 });

package/tests/components/layouts/PresentationItem.spec.ts

@@ -0,0 +1,36 @@
+import '@tests/mocks/i18n';
+import '@tests/mocks/useRouter';
+
+import PresentationItem from '@/components/layouts/PresentationItem.vue';
+import { mount as testMount } from '@tests/utils';
+import { describe, expect, it } from 'vitest';
+
+const baseProps = {
+    route: 'podcast',
+    imageUrl: 'https://example.com/img.png',
+    name: 'Item name',
+};
+
+const mount = (props: Record<string, unknown>) => testMount(PresentationItem, {
+    props: { ...baseProps, ...props },
+});
+
+describe('PresentationItem', () => {
+    describe('additionalInfo', () => {
+        it('renders each additionalInfo entry when a description is set', async () => {
+            const wrapper = await mount({ description: 'Some description', additionalInfo: ['1 décembre 2025', 'Saooti'] });
+            const info = wrapper.findAll('.text-secondary');
+            expect(info.map(el => el.text())).toEqual(['1 décembre 2025', 'Saooti']);
+        });
+
+        it('does not render additionalInfo when it is not provided', async () => {
+            const wrapper = await mount({ description: 'Some description' });
+            expect(wrapper.find('.text-secondary').exists()).toBe(false);
+        });
+
+        it('does not render additionalInfo when there is no description', async () => {
+            const wrapper = await mount({ additionalInfo: ['Saooti'] });
+            expect(wrapper.find('.text-secondary').exists()).toBe(false);
+        });
+    });
+});

package/tests/stores/CacheStore.spec.ts

@@ -0,0 +1,109 @@
+import '@tests/mocks/i18n';
+
+import { useCacheStore } from '@/stores/CacheStore';
+import { setupPinia } from '@tests/utils';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+describe('CacheStore', () => {
+    beforeEach(() => {
+        setupPinia();
+    });
+
+    describe('getData', () => {
+        it('returns the value resolved by the callback', async () => {
+            const store = useCacheStore();
+            const result = await store.getData('key', () => Promise.resolve('value'));
+            expect(result).toBe('value');
+        });
+
+        it('does not call the callback again for a cached key', async () => {
+            const store = useCacheStore();
+            const callback = vi.fn().mockResolvedValue('value');
+            await store.getData('key', callback);
+            await store.getData('key', callback);
+            expect(callback).toHaveBeenCalledTimes(1);
+        });
+
+        it('shares the in-flight promise between concurrent callers', async () => {
+            const store = useCacheStore();
+            const callback = vi.fn().mockResolvedValue('value');
+            const [a, b] = await Promise.all([
+                store.getData('key', callback),
+                store.getData('key', callback),
+            ]);
+            expect(a).toBe('value');
+            expect(b).toBe('value');
+            expect(callback).toHaveBeenCalledTimes(1);
+        });
+
+        it('keeps separate cache entries per key', async () => {
+            const store = useCacheStore();
+            const callbackA = vi.fn().mockResolvedValue('value-a');
+            const callbackB = vi.fn().mockResolvedValue('value-b');
+            expect(await store.getData('key-a', callbackA)).toBe('value-a');
+            expect(await store.getData('key-b', callbackB)).toBe('value-b');
+            expect(callbackA).toHaveBeenCalledTimes(1);
+            expect(callbackB).toHaveBeenCalledTimes(1);
+        });
+
+        it('does not cache a rejected fetch, allowing the next call to retry', async () => {
+            const store = useCacheStore();
+            const callback = vi.fn()
+                .mockRejectedValueOnce(new Error('boom'))
+                .mockResolvedValueOnce('value');
+
+            await expect(store.getData('key', callback)).rejects.toThrow('boom');
+            // Let the internal `.catch(() => invalidate(key))` microtask run
+            await Promise.resolve();
+            await Promise.resolve();
+
+            const result = await store.getData('key', callback);
+            expect(result).toBe('value');
+            expect(callback).toHaveBeenCalledTimes(2);
+        });
+
+        describe('expiration', () => {
+            beforeEach(() => {
+                vi.useFakeTimers();
+            });
+
+            afterEach(() => {
+                vi.useRealTimers();
+            });
+
+            it('does not refetch before the 30 minute expiration', async () => {
+                const store = useCacheStore();
+                const callback = vi.fn().mockResolvedValue('value');
+                await store.getData('key', callback);
+                vi.advanceTimersByTime(29 * 60 * 1000);
+                await store.getData('key', callback);
+                expect(callback).toHaveBeenCalledTimes(1);
+            });
+
+            it('refetches after the 30 minute expiration', async () => {
+                const store = useCacheStore();
+                const callback = vi.fn().mockResolvedValue('value');
+                await store.getData('key', callback);
+                vi.advanceTimersByTime(31 * 60 * 1000);
+                await store.getData('key', callback);
+                expect(callback).toHaveBeenCalledTimes(2);
+            });
+        });
+    });
+
+    describe('invalidate', () => {
+        it('forces the next call to refetch', async () => {
+            const store = useCacheStore();
+            const callback = vi.fn().mockResolvedValue('value');
+            await store.getData('key', callback);
+            store.invalidate('key');
+            await store.getData('key', callback);
+            expect(callback).toHaveBeenCalledTimes(2);
+        });
+
+        it('does nothing for an unknown key', () => {
+            const store = useCacheStore();
+            expect(() => store.invalidate('unknown')).not.toThrow();
+        });
+    });
+});