@saooti/octopus-sdk 41.7.2 → 41.8.0

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/components/composable/useAdvancedParamInit.spec.ts

@@ -0,0 +1,90 @@
+import '@tests/mocks/useRouter';
+
+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/useRights.spec.ts

@@ -0,0 +1,265 @@
+import { describe, expect, it } from 'vitest';
+import { setupPinia, setupAuthStore } from '@tests/utils';
+import { useAuthStore } from '@/stores/AuthStore';
+import { useRights } from '@/components/composable/useRights';
+import type { Organisation } from '@/stores/class/general/organisation';
+import type { Emission } from '@/stores/class/general/emission';
+import type { Podcast } from '@/stores/class/general/podcast';
+
+async function setup(roles: string[], userId = 'test-user-123'): Promise<void> {
+    setupPinia();
+    await setupAuthStore({ roles })();
+    useAuthStore().$patch({ authProfile: { userId } });
+}
+
+describe('useRights', () => {
+    describe('Emission permissions', () => {
+        describe('canCreateEmission', () => {
+            ['ADMIN', 'ORGANISATION', 'PRODUCTION', 'RESTRICTED_PRODUCTION'].forEach(role => {
+                it(`allows ${role}`, async () => {
+                    await setup([role]);
+                    expect(useRights().canCreateEmission()).toBe(true);
+                });
+            });
+
+            it('denies unrelated roles', async () => {
+                await setup(['PLAYLISTS']);
+                expect(useRights().canCreateEmission()).toBe(false);
+            });
+        });
+
+        describe('canEditEmission', () => {
+            it('allows ADMIN to edit any emission', async () => {
+                await setup(['ADMIN']);
+                expect(useRights().canEditEmission({ emissionId: 1, createdByUserId: 'other-user' } as Emission)).toBe(true);
+            });
+
+            it('allows RESTRICTED_PRODUCTION to edit own emission', async () => {
+                await setup(['RESTRICTED_PRODUCTION']);
+                expect(useRights().canEditEmission({ emissionId: 1, createdByUserId: 'test-user-123' } as Emission)).toBe(true);
+            });
+
+            it('denies RESTRICTED_PRODUCTION editing others\' emission', async () => {
+                await setup(['RESTRICTED_PRODUCTION']);
+                expect(useRights().canEditEmission({ emissionId: 1, createdByUserId: 'other-user' } as Emission)).toBe(false);
+            });
+
+            it('allows editing new emissions if can create', async () => {
+                await setup(['PRODUCTION']);
+                const newEmission = {
+                    emissionId: undefined,
+                    beneficiaries: [],
+                    description: '',
+                    monetisable: false,
+                    name: 'New Emission',
+                    orga: {} as Organisation,
+                    rubriqueIds: []
+                } as unknown as Emission;
+                expect(useRights().canEditEmission(newEmission)).toBe(true);
+            });
+        });
+
+        describe('canDeleteEmission', () => {
+            ['ADMIN', 'ORGANISATION', 'PRODUCTION', 'RESTRICTED_PRODUCTION'].forEach(role => {
+                it(`allows ${role}`, async () => {
+                    await setup([role]);
+                    expect(useRights().canDeleteEmission()).toBe(true);
+                });
+            });
+
+            it('denies unrelated roles', async () => {
+                await setup(['PLAYLISTS']);
+                expect(useRights().canDeleteEmission()).toBe(false);
+            });
+        });
+    });
+
+    describe('Podcast permissions', () => {
+        describe('canCreatePodcast', () => {
+            ['ADMIN', 'ORGANISATION', 'PRODUCTION', 'PODCAST_CRUD', 'RESTRICTED_PRODUCTION', 'RESTRICTED_ANIMATION'].forEach(role => {
+                it(`allows ${role}`, async () => {
+                    await setup([role]);
+                    expect(useRights().canCreatePodcast()).toBe(true);
+                });
+            });
+
+            it('denies unrelated roles', async () => {
+                await setup(['PLAYLISTS']);
+                expect(useRights().canCreatePodcast()).toBe(false);
+            });
+        });
+
+        describe('canDuplicatePodcast', () => {
+            ['ADMIN', 'ORGANISATION', 'PRODUCTION', 'RESTRICTED_PRODUCTION'].forEach(role => {
+                it(`allows ${role}`, async () => {
+                    await setup([role]);
+                    expect(useRights().canDuplicatePodcast()).toBe(true);
+                });
+            });
+
+            it('denies unrelated roles', async () => {
+                await setup(['PLAYLISTS']);
+                expect(useRights().canDuplicatePodcast()).toBe(false);
+            });
+        });
+
+        describe('canEditPodcast', () => {
+            const ownPodcast = { podcastId: 1, createdByUserId: 'test-user-123', valid: true } as Podcast;
+            const otherPodcast = { podcastId: 1, createdByUserId: 'other-user', valid: true } as Podcast;
+
+            ['ADMIN', 'ORGANISATION', 'PRODUCTION'].forEach(role => {
+                it(`allows ${role} to edit any podcast`, async () => {
+                    await setup([role]);
+                    expect(useRights().canEditPodcast(otherPodcast)).toBe(true);
+                });
+            });
+
+            it('allows PODCAST_CRUD to edit own non-valid podcast', async () => {
+                await setup(['PODCAST_CRUD']);
+                const podcast = { podcastId: 1, valid: false, publisher: { userId: 'test-user-123' } } as Podcast;
+                expect(useRights().canEditPodcast(podcast)).toBe(true);
+            });
+
+            it('denies PODCAST_CRUD editing own valid podcast', async () => {
+                await setup(['PODCAST_CRUD']);
+                const podcast = { podcastId: 1, valid: true, publisher: { userId: 'test-user-123' } } as Podcast;
+                expect(useRights().canEditPodcast(podcast)).toBe(false);
+            });
+
+            it('denies PODCAST_CRUD editing others\' podcast', async () => {
+                await setup(['PODCAST_CRUD']);
+                const podcast = { podcastId: 1, valid: false, publisher: { userId: 'other-user' } } as Podcast;
+                expect(useRights().canEditPodcast(podcast)).toBe(false);
+            });
+
+            ['RESTRICTED_PRODUCTION', 'RESTRICTED_ANIMATION'].forEach(role => {
+                it(`allows ${role} to edit own podcast`, async () => {
+                    await setup([role]);
+                    expect(useRights().canEditPodcast(ownPodcast)).toBe(true);
+                });
+
+                it(`denies ${role} editing others' podcast`, async () => {
+                    await setup([role]);
+                    expect(useRights().canEditPodcast(otherPodcast)).toBe(false);
+                });
+            });
+
+            it('denies unrelated roles', async () => {
+                await setup(['PLAYLISTS']);
+                expect(useRights().canEditPodcast(ownPodcast)).toBe(false);
+            });
+
+            // Regression: RESTRICTED_* must take priority over PODCAST_CRUD when both roles are present.
+            ['RESTRICTED_PRODUCTION', 'RESTRICTED_ANIMATION'].forEach(role => {
+                it(`allows ${role} + PODCAST_CRUD to edit own valid podcast`, async () => {
+                    await setup([role, 'PODCAST_CRUD']);
+                    const podcast = { podcastId: 1, createdByUserId: 'test-user-123', valid: true, publisher: { userId: 'test-user-123' } } as Podcast;
+                    expect(useRights().canEditPodcast(podcast)).toBe(true);
+                });
+            });
+
+            it('denies RESTRICTED_PRODUCTION + PODCAST_CRUD editing others\' valid podcast', async () => {
+                await setup(['RESTRICTED_PRODUCTION', 'PODCAST_CRUD']);
+                const podcast = { podcastId: 1, createdByUserId: 'other-user', valid: true, publisher: { userId: 'other-user' } } as Podcast;
+                expect(useRights().canEditPodcast(podcast)).toBe(false);
+            });
+        });
+
+        describe('canDeletePodcast', () => {
+            it('delegates to canEditPodcast', async () => {
+                await setup(['RESTRICTED_PRODUCTION']);
+                expect(useRights().canDeletePodcast({ podcastId: 1, createdByUserId: 'test-user-123' } as Podcast)).toBe(true);
+                expect(useRights().canDeletePodcast({ podcastId: 1, createdByUserId: 'other-user' } as Podcast)).toBe(false);
+            });
+        });
+
+        describe('canValidatePodcast', () => {
+            ['ADMIN', 'ORGANISATION', 'PRODUCTION', 'PODCAST_VALIDATION'].forEach(role => {
+                it(`allows ${role}`, async () => {
+                    await setup([role]);
+                    expect(useRights().canValidatePodcast()).toBe(true);
+                });
+            });
+
+            ['PODCAST_CRUD', 'RESTRICTED_PRODUCTION', 'PLAYLISTS'].forEach(role => {
+                it(`denies ${role}`, async () => {
+                    await setup([role]);
+                    expect(useRights().canValidatePodcast()).toBe(false);
+                });
+            });
+        });
+    });
+
+    describe('Playlist permissions', () => {
+        ['canCreatePlaylist', 'canEditPlaylist', 'canDeletePlaylist'].forEach(method => {
+            describe(method, () => {
+                ['ADMIN', 'ORGANISATION', 'PLAYLISTS'].forEach(role => {
+                    it(`allows ${role}`, async () => {
+                        await setup([role]);
+                        expect(useRights()[method as 'canCreatePlaylist']()).toBe(true);
+                    });
+                });
+
+                it('denies unrelated roles', async () => {
+                    await setup(['PRODUCTION']);
+                    expect(useRights()[method as 'canCreatePlaylist']()).toBe(false);
+                });
+            });
+        });
+    });
+
+    describe('Participant permissions', () => {
+        describe('canCreateParticipant', () => {
+            ['ADMIN', 'ORGANISATION', 'PRODUCTION', 'RESTRICTED_PRODUCTION'].forEach(role => {
+                it(`allows ${role}`, async () => {
+                    await setup([role]);
+                    expect(useRights().canCreateParticipant()).toBe(true);
+                });
+            });
+
+            it('denies unrelated roles', async () => {
+                await setup(['PLAYLISTS']);
+                expect(useRights().canCreateParticipant()).toBe(false);
+            });
+        });
+
+        ['canEditParticipant', 'canDeleteParticipant'].forEach(method => {
+            describe(method, () => {
+                ['ADMIN', 'ORGANISATION', 'PRODUCTION', 'RESTRICTED_PRODUCTION'].forEach(role => {
+                    it(`allows ${role}`, async () => {
+                        await setup([role]);
+                        expect(await useRights()[method as 'canEditParticipant'](123)).toBe(true);
+                    });
+                });
+
+                it('allows undefined id (new participant)', async () => {
+                    await setup(['RESTRICTED_PRODUCTION']);
+                    expect(await useRights()[method as 'canEditParticipant'](undefined)).toBe(true);
+                });
+
+                it('denies unrelated roles for existing participant', async () => {
+                    await setup(['PLAYLISTS']);
+                    expect(await useRights()[method as 'canEditParticipant'](123)).toBe(false);
+                });
+            });
+        });
+    });
+
+    describe('Other permissions', () => {
+        describe('canEditCodeInsertPlayer', () => {
+            ['ADMIN', 'ORGANISATION'].forEach(role => {
+                it(`allows ${role}`, async () => {
+                    await setup([role]);
+                    expect(useRights().canEditCodeInsertPlayer()).toBe(true);
+                });
+            });
+
+            ['PRODUCTION', 'PODCAST_CRUD', 'RESTRICTED_PRODUCTION', 'PLAYLISTS'].forEach(role => {
+                it(`denies ${role}`, async () => {
+                    await setup([role]);
+                    expect(useRights().canEditCodeInsertPlayer()).toBe(false);
+                });
+            });
+        });
+    });
+});

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

@@ -0,0 +1,35 @@
+import { describe, expect, it } from 'vitest';
+import { useSeasonsManagement } from '@/components/composable/useSeasonsManagement';
+import { emptyEmissionData, SeasonMode } from '@/stores/class/general/emission';
+import { emptyPodcastData } from '@/stores/class/general/podcast';
+
+const { areSeasonsEnabled, formatSeason } = useSeasonsManagement();
+
+describe('useSeasonsManagement', () => {
+    describe('areSeasonsEnabled', () => {
+        it.each([
+            SeasonMode.SEASON_WITH_PODCAST_NUMBERING,
+            SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING,
+        ])('returns true for %s', (seasonMode) => {
+            expect(areSeasonsEnabled({ ...emptyEmissionData(), seasonMode })).toBe(true);
+        });
+
+        it('returns false for NO_SEASON', () => {
+            expect(areSeasonsEnabled(emptyEmissionData())).toBe(false);
+        });
+    });
+
+    describe('formatSeason', () => {
+        it.each([
+            { seasonMode: SeasonMode.NO_SEASON,                         seasonNumber: 1, seasonEpisodeNumber: 1, expected: null    },
+            { seasonMode: SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING,  seasonNumber: 2, seasonEpisodeNumber: 1, expected: 'S2'    },
+            { seasonMode: SeasonMode.SEASON_WITH_PODCAST_NUMBERING,     seasonNumber: 2, seasonEpisodeNumber: 5, expected: 'S2·E5' },
+        ])('formats $seasonMode as $expected', ({ seasonMode, seasonNumber, seasonEpisodeNumber, expected }) => {
+            const podcast = emptyPodcastData();
+            podcast.seasonNumber = seasonNumber;
+            podcast.seasonEpisodeNumber = seasonEpisodeNumber;
+            podcast.emission.seasonMode = seasonMode;
+            expect(formatSeason(podcast)).toBe(expected);
+        });
+    });
+});

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

@@ -0,0 +1,33 @@
+import '@tests/mocks/i18n';
+
+import PodcastFilterList from '@/components/display/podcasts/PodcastFilterList.vue';
+import { emptyEmissionData, SeasonMode } from '@/stores/class/general/emission';
+import { mount as testMount } from '@tests/utils';
+import { describe, expect, it } from 'vitest';
+
+const mount = (props: Record<string, unknown> = {}) =>
+    testMount(PodcastFilterList, { shallow: true, props });
+
+describe('PodcastFilterList', () => {
+    describe('season display', () => {
+        it.each([
+            { desc: 'no emission provided', props: {} },
+            { desc: 'emission has NO_SEASON mode', props: { emission: { ...emptyEmissionData(), seasonMode: SeasonMode.NO_SEASON, seasonCount: 3 } } },
+            { desc: 'emission has seasons but seasonCount is 0', props: { emission: { ...emptyEmissionData(), seasonMode: SeasonMode.SEASON_WITH_PODCAST_NUMBERING, seasonCount: 0 } } },
+        ])('shows a plain list when $desc', async ({ props }) => {
+            const wrapper = await mount(props);
+            expect(wrapper.find('podcast-list-stub').exists()).toBe(true);
+            expect(wrapper.find('classic-nav-stub').exists()).toBe(false);
+        });
+
+        it.each([
+            SeasonMode.SEASON_WITH_PODCAST_NUMBERING,
+            SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING,
+        ])('shows a season nav when seasonMode is %s', async (seasonMode) => {
+            const emission = { ...emptyEmissionData(), seasonMode, seasonCount: 3 };
+            const wrapper = await mount({ emission });
+            expect(wrapper.find('classic-nav-stub').exists()).toBe(true);
+            expect(wrapper.find('podcast-list-stub').exists()).toBe(false);
+        });
+    });
+});

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

@@ -0,0 +1,23 @@
+import '@tests/mocks/i18n';
+import '@tests/mocks/useRouter';
+
+import PodcastInlineListTemplate from '@/components/display/podcasts/PodcastInlineListTemplate.vue';
+import { mount as testMount } from '@tests/utils';
+import { describe, expect, it } from 'vitest';
+
+const mount = (props: Record<string, unknown> = {}) =>
+    testMount(PodcastInlineListTemplate, { shallow: true, props });
+
+describe('PodcastInlineListTemplate', () => {
+    describe('noSort prop', () => {
+        it('shows sort buttons by default', async () => {
+            const wrapper = await mount();
+            expect(wrapper.find('.btn-underline').exists()).toBe(true);
+        });
+
+        it('hides sort buttons when noSort is true', async () => {
+            const wrapper = await mount({ noSort: true });
+            expect(wrapper.find('.btn-underline').exists()).toBe(false);
+        });
+    });
+});

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

@@ -2,47 +2,74 @@ import '@tests/mocks/i18n';
 import '@tests/mocks/useRouter';
 
 import PodcastModuleBox from '@/components/display/podcasts/PodcastModuleBox.vue';
+import { SeasonMode } from '@/stores/class/general/emission';
 import { emptyPodcastData, Podcast } from '@/stores/class/general/podcast';
-import { mount, setupAuthStore } from '@tests/utils';
+import { mount as testMount, setupAuthStore } from '@tests/utils';
 import { describe, expect, it } from 'vitest';
 import { initialize } from '@/stores/ParamSdkStore';
 
+const mount = (podcast: Podcast) => testMount(PodcastModuleBox, {
+    props: { podcast },
+    stubs: ['ShareAnonymous', 'LikeSection'],
+    beforeMount: setupAuthStore()
+});
+
 describe('PodcastModuleBox', () => {
     describe('date display', () => {
         const podcast: Podcast = emptyPodcastData();
         podcast.pubDate = '2025-12-01T10:21:31.000+00:00';
 
         it('shows the date without time by default', async() => {
-            const wrapper = await mount(PodcastModuleBox, {
-                props: { podcast },
-                stubs: ['ShareAnonymous', 'LikeSection'],
-                beforeMount: setupAuthStore()
-            });
+            const wrapper = await mount(podcast);
             expect(wrapper.text()).toContain('1 December 2025');
             expect(wrapper.text()).not.toContain('11:21');
         });
 
-        it('shows the date without time when disable in SdkParams', async() => {
-            const wrapper = await mount(PodcastModuleBox, {
-                props: { podcast },
-                stubs: ['ShareAnonymous', 'LikeSection'],
-                beforeMount: setupAuthStore()
-            });
+        it('shows the date with time when enabled in SdkParams', async() => {
+            initialize({ generalParameters: { showTimeWithDates: true } });
+            const wrapper = await mount(podcast);
             expect(wrapper.text()).toContain('1 December 2025');
-            expect(wrapper.text()).not.toContain('11:21');
+            expect(wrapper.text()).toContain('11:21');
         });
+    });
 
-        it('shows the date with time when enabled in SdkParams', async() => {
-            initialize({
-                generalParameters: { showTimeWithDates: true }
+    describe('season info', () => {
+        function makePodcast(seasonMode = SeasonMode.NO_SEASON, overrides: Partial<Podcast> = {}) {
+            const podcast = emptyPodcastData();
+            podcast.emission.seasonMode = seasonMode;
+            return { ...podcast, ...overrides };
+        }
+
+        describe('season number', () => {
+            it('hidden when seasonNumber is not set', async () => {
+                const wrapper = await mount(makePodcast(SeasonMode.SEASON_WITH_PODCAST_NUMBERING));
+                expect(wrapper.text()).not.toContain('Podcast - Season');
             });
-            const wrapper = await mount(PodcastModuleBox, {
-                props: { podcast },
-                stubs: ['ShareAnonymous', 'LikeSection'],
-                beforeMount: setupAuthStore()
+
+            it('hidden when emission has no season mode', async () => {
+                const wrapper = await mount(makePodcast(SeasonMode.NO_SEASON, { seasonNumber: 2 }));
+                expect(wrapper.text()).not.toContain('Podcast - Season');
+            });
+
+            it.each([
+                SeasonMode.SEASON_WITH_PODCAST_NUMBERING,
+                SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING,
+            ])('shown for %s', async (seasonMode) => {
+                const wrapper = await mount(makePodcast(seasonMode, { seasonNumber: 2 }));
+                expect(wrapper.text()).toContain('Podcast - Season : 2');
+            });
+        });
+
+        describe('episode number', () => {
+            it('hidden for SEASON_WITHOUT_PODCAST_NUMBERING', async () => {
+                const wrapper = await mount(makePodcast(SeasonMode.SEASON_WITHOUT_PODCAST_NUMBERING, { seasonEpisodeNumber: 5 }));
+                expect(wrapper.text()).not.toContain('Podcast - Episode number');
+            });
+
+            it('shown for SEASON_WITH_PODCAST_NUMBERING', async () => {
+                const wrapper = await mount(makePodcast(SeasonMode.SEASON_WITH_PODCAST_NUMBERING, { seasonEpisodeNumber: 5 }));
+                expect(wrapper.text()).toContain('Podcast - Episode number : 5');
             });
-            expect(wrapper.text()).toContain('1 December 2025');
-            expect(wrapper.text()).toContain('11:21');
         });
     });
 });