@saooti/octopus-sdk 41.12.0-beta2 → 41.12.0

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

@@ -3,6 +3,7 @@ import '@tests/mocks/i18n';
 import OctopusSelect from '@/components/form/OctopusSelect.vue';
 import { DOMWrapper, type VueWrapper } from '@vue/test-utils';
 import { mount } from '@tests/utils';
+import { nextTick } from 'vue';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 
 const options = [
@@ -16,6 +17,20 @@ function getDropdown(): Element | null {
     return document.body.querySelector('.octopus-select-dropdown');
 }
 
+function getOptionLabels(): string[] {
+    return Array.from(document.body.querySelectorAll('.octopus-select-option'))
+        .map((el) => el.textContent?.trim() ?? '');
+}
+
+// Simulates a click outside the component to trigger onClickOutside's closeDropdown.
+async function clickOutside(): Promise<void> {
+    const outsideElement = document.createElement('div');
+    document.body.appendChild(outsideElement);
+    outsideElement.dispatchEvent(new MouseEvent('click', { bubbles: true, cancelable: true }));
+    await nextTick();
+    document.body.removeChild(outsideElement);
+}
+
 describe('OctopusSelect', () => {
     // The dropdown teleports to .octopus-app, which is normally the app root (see App.vue).
     // It doesn't exist in the test DOM, so it must be created before mount.
@@ -165,4 +180,60 @@ describe('OctopusSelect', () => {
         const optionButtons = document.body.querySelectorAll('.octopus-select-option');
         expect(optionButtons[0].classList).toContain('selected');
     });
+
+    describe('pullSelectedToTop', () => {
+        it('does not reorder options when pullSelectedToTop is not set', async () => {
+            wrapper = await mount(OctopusSelect, {
+                props: { options, optionLabel: 'name', value: options[1] },
+            });
+            await wrapper.find('input').trigger('focus');
+            expect(getOptionLabels()).toEqual(['Alpha', 'Beta', 'Gamma']);
+        });
+
+        it('moves the selected option to the top when pullSelectedToTop is true', async () => {
+            wrapper = await mount(OctopusSelect, {
+                props: { options, optionLabel: 'name', value: options[1], pullSelectedToTop: true },
+            });
+            await wrapper.find('input').trigger('focus');
+            expect(getOptionLabels()).toEqual(['Beta', 'Alpha', 'Gamma']);
+        });
+
+        it('does not reorder while the dropdown stays open as the value changes', async () => {
+            wrapper = await mount(OctopusSelect, {
+                props: { options, optionLabel: 'name', pullSelectedToTop: true },
+            });
+            await wrapper.find('input').trigger('focus');
+            await wrapper.setProps({ value: options[2] });
+            expect(getOptionLabels()).toEqual(['Alpha', 'Beta', 'Gamma']);
+        });
+
+        it('re-pins using the latest value after closing and reopening', async () => {
+            wrapper = await mount(OctopusSelect, {
+                props: { options, optionLabel: 'name', value: options[2], pullSelectedToTop: true },
+            });
+            await wrapper.find('input').trigger('focus');
+            await clickOutside();
+            await wrapper.find('input').trigger('focus');
+            expect(getOptionLabels()).toEqual(['Gamma', 'Alpha', 'Beta']);
+        });
+
+        it('pins by optionKey even when the value is a different reference', async () => {
+            const value = { id: 2, name: 'Beta' };
+            wrapper = await mount(OctopusSelect, {
+                props: { options, optionLabel: 'name', optionKey: 'id', value, pullSelectedToTop: true },
+            });
+            await wrapper.find('input').trigger('focus');
+            expect(getOptionLabels()).toEqual(['Beta', 'Alpha', 'Gamma']);
+        });
+
+        it('still respects the active search filter when pinning', async () => {
+            wrapper = await mount(OctopusSelect, {
+                props: { options, optionLabel: 'name', value: options[2], pullSelectedToTop: true },
+            });
+            await wrapper.find('input').trigger('focus');
+            await wrapper.find('input').setValue('be');
+            await wrapper.find('input').trigger('input');
+            expect(getOptionLabels()).toEqual(['Beta']);
+        });
+    });
 });

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();
+        });
+    });
+});