@aleph-alpha/chat-kit 0.9.0 → 1.1.0

package/src/composables/useConversations.spec.ts

@@ -0,0 +1,557 @@
+import type {
+  HttpClient,
+  RawConversation,
+  RawConversationList,
+} from '../services/types';
+import { useConversations } from './useConversations';
+import { nextTick } from 'vue';
+
+function makeRawConversation(
+  overrides: Partial<RawConversation> & { id: string },
+): RawConversation {
+  return {
+    object: 'conversation',
+    metadata: { title: 'Untitled', application: 'tiger-chat' },
+    created_at: 1_777_456_700,
+    updated_at: 1_777_456_700,
+    ...overrides,
+  };
+}
+
+function makeRawList(
+  data: RawConversation[],
+  options: { hasMore?: boolean; lastId?: string | null } = {},
+): RawConversationList {
+  return {
+    object: 'list',
+    data,
+    has_more: options.hasMore ?? false,
+    first_id: data[0]?.id ?? null,
+    last_id: options.lastId ?? data[data.length - 1]?.id ?? null,
+  };
+}
+
+interface FakeHttp {
+  get: ReturnType<typeof vi.fn>;
+  post: ReturnType<typeof vi.fn>;
+  delete: ReturnType<typeof vi.fn>;
+}
+
+function makeFakeHttp(): FakeHttp {
+  return {
+    get: vi.fn(),
+    post: vi.fn(),
+    delete: vi.fn(),
+  };
+}
+
+function asHttp(fake: FakeHttp): HttpClient {
+  return fake as unknown as HttpClient;
+}
+
+describe('useConversations', () => {
+  describe('fetch', () => {
+    it('maps the raw list response into ConversationSummary[]', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeRawList([
+          makeRawConversation({
+            id: 'conv_a',
+            metadata: { title: 'hey again' },
+            created_at: 1_777_456_746,
+            updated_at: 1_777_456_750,
+          }),
+        ]),
+      );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+
+      expect(http.get).toHaveBeenCalledWith('/conversations', {
+        params: { limit: 20, order: 'desc' },
+      });
+      expect(conv.conversations.value).toHaveLength(1);
+      expect(conv.conversations.value[0]).toEqual({
+        id: 'conv_a',
+        title: 'hey again',
+        createdAt: new Date(1_777_456_746 * 1000),
+        updatedAt: new Date(1_777_456_750 * 1000),
+      });
+    });
+
+    it('falls back to an empty title when metadata.title is missing', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeRawList([makeRawConversation({ id: 'conv_a', metadata: null })]),
+      );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+
+      expect(conv.conversations.value[0].title).toBe('');
+    });
+
+    it('uses the configured pageSize as the default limit', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(makeRawList([]));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+        pageSize: 5,
+      });
+      await conv.fetch();
+
+      expect(http.get).toHaveBeenCalledWith('/conversations', {
+        params: { limit: 5, order: 'desc' },
+      });
+    });
+
+    it('lets the caller override the limit per call', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(makeRawList([]));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch({ limit: 50 });
+
+      expect(http.get).toHaveBeenCalledWith('/conversations', {
+        params: { limit: 50, order: 'desc' },
+      });
+    });
+
+    it('replaces the list on subsequent fetches', async () => {
+      const http = makeFakeHttp();
+      http.get
+        .mockResolvedValueOnce(makeRawList([makeRawConversation({ id: 'a' })]))
+        .mockResolvedValueOnce(
+          makeRawList([
+            makeRawConversation({ id: 'b' }),
+            makeRawConversation({ id: 'c' }),
+          ]),
+        );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+      await conv.fetch();
+
+      expect(conv.conversations.value.map((c) => c.id)).toEqual(['b', 'c']);
+    });
+
+    it('sets hasMore=true and stores the cursor when has_more is true', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeRawList([makeRawConversation({ id: 'a' })], {
+          hasMore: true,
+          lastId: 'a',
+        }),
+      );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+
+      expect(conv.hasMore.value).toBe(true);
+    });
+
+    it('sets hasMore=false when has_more is false', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeRawList([makeRawConversation({ id: 'a' })]),
+      );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+
+      expect(conv.hasMore.value).toBe(false);
+    });
+
+    it('toggles isLoading around the call', async () => {
+      const http = makeFakeHttp();
+      let resolve!: (value: RawConversationList) => void;
+      http.get.mockReturnValue(new Promise((r) => (resolve = r)));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      const promise = conv.fetch();
+
+      await nextTick();
+      expect(conv.isLoading.value).toBe(true);
+
+      resolve(makeRawList([]));
+      await promise;
+
+      expect(conv.isLoading.value).toBe(false);
+    });
+
+    it('records and re-throws errors', async () => {
+      const http = makeFakeHttp();
+      http.get.mockRejectedValue(new Error('boom'));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+
+      await expect(conv.fetch()).rejects.toThrow('boom');
+      expect(conv.error.value?.message).toBe('boom');
+      expect(conv.isLoading.value).toBe(false);
+    });
+  });
+
+  describe('fetchMore', () => {
+    it('appends the next page using the stored cursor', async () => {
+      const http = makeFakeHttp();
+      http.get
+        .mockResolvedValueOnce(
+          makeRawList([makeRawConversation({ id: 'a' })], {
+            hasMore: true,
+            lastId: 'a',
+          }),
+        )
+        .mockResolvedValueOnce(
+          makeRawList([makeRawConversation({ id: 'b' })], {
+            hasMore: false,
+          }),
+        );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+      await conv.fetchMore();
+
+      expect(http.get).toHaveBeenNthCalledWith(2, '/conversations', {
+        params: { limit: 20, order: 'desc', after: 'a' },
+      });
+      expect(conv.conversations.value.map((c) => c.id)).toEqual(['a', 'b']);
+      expect(conv.hasMore.value).toBe(false);
+    });
+
+    it('is a no-op when hasMore is false', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeRawList([makeRawConversation({ id: 'a' })]),
+      );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+      await conv.fetchMore();
+
+      expect(http.get).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('fetchById', () => {
+    it('GETs the conversation path and returns the mapped result', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeRawConversation({
+          id: 'conv_22',
+          metadata: { title: 'far away' },
+          created_at: 1_777_456_700,
+          updated_at: 1_777_456_701,
+        }),
+      );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+
+      const result = await conv.fetchById('conv_22');
+
+      expect(http.get).toHaveBeenCalledWith('/conversations/conv_22');
+      expect(result).toEqual({
+        id: 'conv_22',
+        title: 'far away',
+        createdAt: new Date(1_777_456_700 * 1000),
+        updatedAt: new Date(1_777_456_701 * 1000),
+      });
+    });
+
+    it('does not modify the list (no insert when missing)', async () => {
+      const http = makeFakeHttp();
+      http.get
+        .mockResolvedValueOnce(makeRawList([makeRawConversation({ id: 'a' })]))
+        .mockResolvedValueOnce(makeRawConversation({ id: 'conv_22' }));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+      await conv.fetchById('conv_22');
+
+      expect(conv.conversations.value.map((c) => c.id)).toEqual(['a']);
+    });
+
+    it('does not modify the list (no replace when present)', async () => {
+      const http = makeFakeHttp();
+      http.get
+        .mockResolvedValueOnce(
+          makeRawList([
+            makeRawConversation({ id: 'a', metadata: { title: 'old' } }),
+            makeRawConversation({ id: 'b' }),
+          ]),
+        )
+        .mockResolvedValueOnce(
+          makeRawConversation({ id: 'a', metadata: { title: 'fresh' } }),
+        );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+      const result = await conv.fetchById('a');
+
+      expect(result.title).toBe('fresh');
+      expect(conv.conversations.value[0].title).toBe('old');
+    });
+  });
+
+  describe('create', () => {
+    it('posts the title under metadata and prepends the result', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeRawList([makeRawConversation({ id: 'existing' })]),
+      );
+      http.post.mockResolvedValue(
+        makeRawConversation({ id: 'new', metadata: { title: 'A new chat' } }),
+      );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+
+      const created = await conv.create({ title: 'A new chat' });
+
+      expect(http.post).toHaveBeenCalledWith('/conversations', {
+        metadata: { title: 'A new chat' },
+      });
+      expect(created.id).toBe('new');
+      expect(conv.conversations.value.map((c) => c.id)).toEqual([
+        'new',
+        'existing',
+      ]);
+    });
+
+    it('merges caller-provided metadata into the request body', async () => {
+      const http = makeFakeHttp();
+      http.post.mockResolvedValue(makeRawConversation({ id: 'new' }));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.create({
+        title: 'hi',
+        metadata: { application: 'tiger-chat', custom: 42 },
+      });
+
+      expect(http.post).toHaveBeenCalledWith('/conversations', {
+        metadata: { application: 'tiger-chat', custom: 42, title: 'hi' },
+      });
+    });
+
+    it('omits title from metadata when not provided', async () => {
+      const http = makeFakeHttp();
+      http.post.mockResolvedValue(makeRawConversation({ id: 'new' }));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.create({ metadata: { application: 'tiger-chat' } });
+
+      expect(http.post).toHaveBeenCalledWith('/conversations', {
+        metadata: { application: 'tiger-chat' },
+      });
+    });
+
+    it('prepends a placeholder immediately when optimistic and replaces it on success', async () => {
+      const http = makeFakeHttp();
+      let resolve!: (value: RawConversation) => void;
+      http.post.mockReturnValue(new Promise((r) => (resolve = r)));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      const promise = conv.create({ title: 'pending' }, { optimistic: true });
+
+      await nextTick();
+      expect(conv.conversations.value).toHaveLength(1);
+      expect(conv.conversations.value[0].title).toBe('pending');
+      expect(conv.conversations.value[0].id).toMatch(/^pending-/);
+
+      resolve(
+        makeRawConversation({ id: 'real', metadata: { title: 'pending' } }),
+      );
+      await promise;
+
+      expect(conv.conversations.value).toHaveLength(1);
+      expect(conv.conversations.value[0].id).toBe('real');
+    });
+
+    it('rolls back the placeholder on failure when optimistic', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeRawList([makeRawConversation({ id: 'existing' })]),
+      );
+      http.post.mockRejectedValue(new Error('nope'));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+
+      await expect(
+        conv.create({ title: 'x' }, { optimistic: true }),
+      ).rejects.toThrow('nope');
+      expect(conv.conversations.value.map((c) => c.id)).toEqual(['existing']);
+      expect(conv.error.value?.message).toBe('nope');
+    });
+  });
+
+  describe('rename', () => {
+    it('posts to the conversation path and replaces the entry in place', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeRawList([
+          makeRawConversation({ id: 'a', metadata: { title: 'old' } }),
+          makeRawConversation({ id: 'b' }),
+        ]),
+      );
+      http.post.mockResolvedValue(
+        makeRawConversation({ id: 'a', metadata: { title: 'new' } }),
+      );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+      await conv.rename('a', 'new');
+
+      expect(http.post).toHaveBeenCalledWith('/conversations/a', {
+        metadata: { title: 'new' },
+      });
+      expect(conv.conversations.value[0]).toMatchObject({
+        id: 'a',
+        title: 'new',
+      });
+      expect(conv.conversations.value[1].id).toBe('b');
+    });
+
+    it('updates the title immediately when optimistic and rolls back on failure', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeRawList([
+          makeRawConversation({ id: 'a', metadata: { title: 'old' } }),
+        ]),
+      );
+      http.post.mockRejectedValue(new Error('nope'));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+
+      await expect(
+        conv.rename('a', 'new', { optimistic: true }),
+      ).rejects.toThrow('nope');
+      expect(conv.conversations.value[0].title).toBe('old');
+    });
+  });
+
+  describe('remove', () => {
+    it('deletes on the server and removes the entry from the list', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeRawList([
+          makeRawConversation({ id: 'a' }),
+          makeRawConversation({ id: 'b' }),
+        ]),
+      );
+      http.delete.mockResolvedValue(undefined);
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+      await conv.remove('a');
+
+      expect(http.delete).toHaveBeenCalledWith('/conversations/a');
+      expect(conv.conversations.value.map((c) => c.id)).toEqual(['b']);
+    });
+
+    it('rolls back when optimistic and the request fails', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeRawList([
+          makeRawConversation({ id: 'a' }),
+          makeRawConversation({ id: 'b' }),
+        ]),
+      );
+      http.delete.mockRejectedValue(new Error('nope'));
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+
+      await expect(conv.remove('a', { optimistic: true })).rejects.toThrow(
+        'nope',
+      );
+      expect(conv.conversations.value.map((c) => c.id)).toEqual(['a', 'b']);
+    });
+  });
+
+  describe('getById', () => {
+    it('returns the matching conversation without fetching', async () => {
+      const http = makeFakeHttp();
+      http.get.mockResolvedValue(
+        makeRawList([makeRawConversation({ id: 'a' })]),
+      );
+
+      const conv = useConversations({
+        httpClient: asHttp(http),
+        path: '/conversations',
+      });
+      await conv.fetch();
+
+      expect(conv.getById('a')?.id).toBe('a');
+      expect(conv.getById('missing')).toBeUndefined();
+    });
+  });
+});