@amityco/ts-sdk 0.0.1-beta.29 → 0.0.1-beta.30

package/src/core/tests/query/query.test.ts

@@ -1,19 +1,101 @@
-import { isFetcher } from '~/core/query';
+import {
+  isFetcher,
+  isMutator,
+  isOffline,
+  isCachable,
+  isLocal,
+  isFresh,
+  queryOptions,
+} from '~/core/query';
 
-type isFetcherMockType = jest.Mock<any, any> & {
-  locally?: jest.Mock<any, any>;
-};
+describe('Core/Query', () => {
+  type isFetcherMockType = jest.Mock<any, any> & {
+    locally?: jest.Mock<any, any>;
+  };
 
-describe('Core/Query/Query', () => {
-  const isFetcherMock: isFetcherMockType = jest.fn();
+  type isMutatorMockType = jest.Mock<any, any> & {
+    optimistically?: jest.Mock<any, any>;
+  };
 
-  test('isFetcher without locally', () => {
-    expect(isFetcher(isFetcherMock)).toBe(false);
+  describe('isFetcher', () => {
+    const isFetcherMock: isFetcherMockType = jest.fn();
+
+    test('should return false if func is not a fetcher', () => {
+      expect(isFetcher(isFetcherMock)).toBe(false);
+    });
+
+    test('should return true if func is a fetcher', () => {
+      isFetcherMock.locally = jest.fn();
+
+      expect(isFetcher(isFetcherMock)).toBe(true);
+    });
+  });
+
+  describe('isMutator', () => {
+    const isMutatorMock: isMutatorMockType = jest.fn();
+
+    test('should return false if func is not a mutator', () => {
+      expect(isMutator(isMutatorMock)).toBe(false);
+    });
+
+    test('should return true if func is a mutator', () => {
+      isMutatorMock.optimistically = jest.fn();
+
+      expect(isMutator(isMutatorMock)).toBe(true);
+    });
+  });
+
+  describe('isOffline', () => {
+    const isMutatorMock: isMutatorMockType = jest.fn();
+
+    test('should return false if func is not a mutator or fetcher', () => {
+      expect(isOffline(isMutatorMock)).toBe(false);
+    });
+
+    test('should return true if func is a mutator', () => {
+      isMutatorMock.optimistically = jest.fn();
+
+      expect(isMutator(isMutatorMock)).toBe(true);
+    });
+  });
+
+  describe('isCachable', () => {
+    test('should return false if object is not cachable', () => {
+      expect(isCachable({})).toBe(false);
+    });
+
+    test('should return true if object is cachable', () => {
+      expect(isCachable({ cachedAt: -1 })).toBe(true);
+    });
+  });
+
+  describe('isLocal', () => {
+    test('should return false if object is not local', () => {
+      expect(isLocal({ cachedAt: 0 })).toBe(false);
+    });
+
+    test('should return true if object is local', () => {
+      expect(isLocal({ cachedAt: -1 })).toBe(true);
+    });
+  });
+
+  describe('isFresh', () => {
+    test('should return false if object is not fresh', () => {
+      expect(isFresh({ cachedAt: -1 })).toBe(false);
+    });
+
+    test('should return true if object is fresh', () => {
+      expect(isFresh({ cachedAt: Date.now() })).toBe(true);
+    });
   });
 
-  test('isFetcher with locally', () => {
-    isFetcherMock.locally = jest.fn();
+  describe('queryOptions', () => {
+    test('should return lifespan 0 if server only', () => {
+      expect(queryOptions('server_only').lifeSpan).toBe(0);
+    });
 
-    expect(isFetcher(isFetcherMock)).toBe(true);
+    test('should return lifespan Infinity if cache only', () => {
+      expect(queryOptions('cache_only').lifeSpan).toBe(Infinity);
+    });
   });
 });

package/src/utils/tests/dummy/channel.ts

@@ -1,16 +1,27 @@
-import { date, rolesAndPermissions, user11 } from '.';
+import { date, rolesAndPermissions, user11, user12, user13 } from '.';
+
+const mockPage = {
+  paging: {
+    previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+    next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  },
+};
 
 export const channelRaw1: Amity.ChannelRaw = {
+  tags: ['tag2'],
   messageCount: 1,
   createdAt: date,
+  isDeleted: false,
   type: 'community',
   channelId: 'channelId11',
 };
 
 export const channelRaw2: Amity.ChannelRaw = {
+  tags: ['tag1'],
   messageCount: 3,
   createdAt: date,
-  type: 'community',
+  isDeleted: true,
+  type: 'conversation',
   channelId: 'channelId12',
 };
 
@@ -26,17 +37,12 @@ export const channel11: Amity.Channel = {
   hasMention: false,
   unreadCount: 0,
   type: 'community',
-  isDeleted: false,
-  tags: ['tag2'],
 };
 
 export const channel12: Amity.Channel = {
   ...channelRaw2,
-  hasMention: false,
-  unreadCount: 0,
-  type: 'conversation',
-  isDeleted: true,
-  tags: ['tag1'],
+  hasMention: true,
+  unreadCount: 2,
 };
 
 export const channel21: Amity.Channel = {
@@ -69,16 +75,33 @@ export const channelUser2: Amity.Membership<'channel'> = {
   channelId: channel12.channelId,
 };
 
+export const channelUser3: Amity.Membership<'channel'> = {
+  isMuted: false,
+  createdAt: date,
+  muteTimeout: '',
+  isBanned: false,
+  readToSegment: 1,
+  lastActivity: date,
+  userId: user12.userId,
+  ...rolesAndPermissions,
+  membership: 'none',
+  roles: ['test-role'],
+  lastMentionedSegment: 0,
+  channelId: channel11.channelId,
+};
+
+export const channelUser4: Amity.Membership<'channel'> = {
+  ...channelUser3,
+  userId: user13.userId,
+};
+
 export const channelQueryResponse = {
   data: {
     channels: [channel11, channel12],
     channelUsers: [],
     files: [],
     users: [],
-    paging: {
-      previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-      next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-    },
+    ...mockPage,
   },
 };
 
@@ -88,9 +111,26 @@ export const channelQueryResponsePage2 = {
     channelUsers: [],
     files: [],
     users: [],
-    paging: {
-      previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-      next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-    },
+    ...mockPage,
+  },
+};
+
+export const channelUserQueryResponse = {
+  data: {
+    channels: [channel11],
+    channelUsers: [channelUser1, channelUser3],
+    users: [],
+    files: [],
+    ...mockPage,
+  },
+};
+
+export const channelUserQueryResponsePage2 = {
+  data: {
+    channels: [channel11],
+    channelUsers: [channelUser4],
+    users: [],
+    files: [],
+    ...mockPage,
   },
 };

package/src/utils/tests/utils.ts

@@ -1,3 +1,13 @@
 import { encode } from 'js-base64';
 
 export const encodeJson = (value: Record<string, any>) => encode(JSON.stringify(value));
+
+/*
+ * Used instead of asserting an async request is completed, when the async
+ * request is not the API being tested. This util makes tests readable by moving
+ * all assertions to the end of the test
+ */
+export const pause = (ms = 50) =>
+  new Promise(resolve => {
+    setTimeout(resolve, ms);
+  });