botframework-webchat-core 4.18.1 → 4.19.0

package/src/reducers/activities/sort/deleteActivityByLocalId.activity.spec.ts

@@ -0,0 +1,144 @@
+/* eslint-disable no-restricted-globals */
+import { expect } from '@jest/globals';
+import { scenario } from '@testduet/given-when-then';
+import deleteActivityByLocalId from './deleteActivityByLocalId';
+import { getLocalIdFromActivity, type LocalId } from './property/LocalId';
+import { type Activity, type ActivityMapEntry, type SortedChatHistoryEntry } from './types';
+import upsert, { INITIAL_STATE } from './upsert';
+
+function activityToExpectation(activity: Activity, expectedPosition: number = expect.any(Number) as any): Activity {
+  return {
+    ...activity,
+    channelData: {
+      ...activity.channelData,
+      'webchat:internal:position': expectedPosition
+    } as any
+  };
+}
+
+scenario('deleting activity', bdd => {
+  const activity1: Activity = {
+    channelData: {
+      'webchat:internal:local-id': '_:a-00001' as LocalId,
+      'webchat:internal:position': 0,
+      'webchat:send-status': undefined
+    },
+    from: { id: 'bot', role: 'bot' },
+    id: 'a-00001',
+    text: 'Hello, World!',
+    timestamp: new Date(1_000).toISOString(),
+    type: 'message'
+  };
+
+  const activity2: Activity = {
+    channelData: {
+      'webchat:internal:local-id': '_:a-00002' as LocalId,
+      'webchat:internal:position': 0,
+      'webchat:send-status': undefined
+    },
+    from: { id: 'bot', role: 'bot' },
+    id: 'a-00002',
+    text: 'Aloha!',
+    timestamp: new Date(2_000).toISOString(),
+    type: 'message'
+  };
+
+  bdd
+    .given('an initial state', () => INITIAL_STATE)
+    .when('2 activities are upserted', state => upsert({ Date }, upsert({ Date }, state, activity1), activity2))
+    .then('should have 2 activities', (_, state) => {
+      expect(state.activityIdToLocalIdMap).toHaveProperty('size', 2);
+      expect(state.activityMap).toHaveProperty('size', 2);
+      expect(state.howToGroupingMap).toHaveProperty('size', 0);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 0);
+      expect(state.sortedActivities).toHaveLength(2);
+      expect(state.sortedChatHistoryList).toHaveLength(2);
+    })
+    .when('the first activity is deleted', (_, state) =>
+      deleteActivityByLocalId(state, getLocalIdFromActivity(state.sortedActivities[0]!))
+    )
+    .then('should have 1 activity', (_, state) => {
+      expect(state.activityIdToLocalIdMap).toHaveProperty('size', 1);
+      expect(state.activityMap).toHaveProperty('size', 1);
+      expect(state.howToGroupingMap).toHaveProperty('size', 0);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 0);
+      expect(state.sortedActivities).toHaveLength(1);
+      expect(state.sortedChatHistoryList).toHaveLength(1);
+    })
+    .and('`activityIdToLocalIdMap` should match', (_, state) => {
+      expect(state.activityIdToLocalIdMap).toEqual(new Map<string, LocalId>([['a-00002', '_:a-00002' as LocalId]]));
+    })
+    .and('`activityMap` should match', (_, state) => {
+      expect(state.activityMap).toEqual(
+        new Map<LocalId, ActivityMapEntry>([
+          [
+            '_:a-00002' as LocalId,
+            {
+              activity: activityToExpectation(activity2, 2_000),
+              activityLocalId: '_:a-00002' as LocalId,
+              logicalTimestamp: 2_000,
+              type: 'activity'
+            } satisfies ActivityMapEntry
+          ]
+        ])
+      );
+    })
+    .and('`sortedActivities` should match', (_, state) => {
+      expect(state.sortedActivities).toEqual([activityToExpectation(activity2, 2_000)]);
+    })
+    .and('`sortedChatHistoryList` should match', (_, state) => {
+      expect(state.sortedChatHistoryList).toEqual([
+        {
+          activityLocalId: '_:a-00002' as LocalId,
+          logicalTimestamp: 2_000,
+          type: 'activity'
+        } satisfies SortedChatHistoryEntry
+      ]);
+    });
+});
+
+scenario('deleting an outgoing activity', bdd => {
+  const activity1: Activity = {
+    channelData: {
+      clientActivityID: 'caid-00001',
+      'webchat:internal:local-id': '_:a-00001' as LocalId,
+      'webchat:internal:position': 0,
+      'webchat:send-status': 'sending'
+    } as any,
+    from: { id: 'user', role: 'user' },
+    id: 'a-00001',
+    text: 'Hello, World!',
+    timestamp: new Date(1_000).toISOString(),
+    type: 'message'
+  };
+
+  bdd
+    .given('an initial state', () => INITIAL_STATE)
+    .when('1 activity are upserted', state => upsert({ Date }, state, activity1))
+    .then('should have 1 activity', (_, state) => {
+      expect(state.activityIdToLocalIdMap).toHaveProperty('size', 1);
+      expect(state.activityMap).toHaveProperty('size', 1);
+      expect(state.clientActivityIdToLocalIdMap).toHaveProperty('size', 1);
+      expect(state.howToGroupingMap).toHaveProperty('size', 0);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 0);
+      expect(state.sortedActivities).toHaveLength(1);
+      expect(state.sortedChatHistoryList).toHaveLength(1);
+    })
+    .and('`clientActivityIdToLocalMap` should match', (_, state) => {
+      expect(state.clientActivityIdToLocalIdMap).toEqual(
+        new Map<string, LocalId>([['caid-00001', '_:a-00001' as LocalId]])
+      );
+    })
+    .when('the first activity is deleted', (_, state) =>
+      deleteActivityByLocalId(state, getLocalIdFromActivity(state.sortedActivities[0]!))
+    )
+    .then('should have no activities', (_, state) => {
+      expect(state.activityIdToLocalIdMap).toHaveProperty('size', 0);
+      expect(state.activityMap).toHaveProperty('size', 0);
+      expect(state.clientActivityIdToLocalIdMap).toHaveProperty('size', 0);
+      expect(state.howToGroupingMap).toHaveProperty('size', 0);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 0);
+      expect(state.sortedActivities).toHaveLength(0);
+      expect(state.sortedChatHistoryList).toHaveLength(0);
+    });
+});

package/src/reducers/activities/sort/deleteActivityByLocalId.howTo.spec.ts

@@ -0,0 +1,148 @@
+/* eslint-disable no-restricted-globals */
+import { expect } from '@jest/globals';
+import { scenario } from '@testduet/given-when-then';
+import { parse } from 'valibot';
+import type { WebChatActivity } from '../../../types/WebChatActivity';
+import deleteActivityByLocalId from './deleteActivityByLocalId';
+import { getLocalIdFromActivity, LocalIdSchema, type LocalId } from './property/LocalId';
+import type {
+  Activity,
+  ActivityMapEntry,
+  HowToGroupingId,
+  HowToGroupingMapEntry,
+  SortedChatHistoryEntry
+} from './types';
+import upsert, { INITIAL_STATE } from './upsert';
+
+type SingularOrPlural<T> = T | readonly T[];
+
+function activityToExpectation(activity: Activity, expectedPosition: number = expect.any(Number) as any): Activity {
+  return {
+    ...activity,
+    channelData: {
+      ...activity.channelData,
+      'webchat:internal:position': expectedPosition
+    } as any
+  };
+}
+
+function buildActivity(
+  activity: { id: string; text: string; timestamp: string },
+  messageEntity: { isPartOf: SingularOrPlural<{ '@id': string; '@type': string }>; position: number } | undefined
+): WebChatActivity {
+  const { id } = activity;
+
+  return {
+    channelData: {
+      'webchat:internal:local-id': parse(LocalIdSchema, `_:${id}`),
+      'webchat:internal:position': 0,
+      'webchat:send-status': undefined
+    },
+    ...(messageEntity
+      ? {
+          entities: [
+            {
+              '@context': 'https://schema.org',
+              '@id': '',
+              '@type': 'Message',
+              type: 'https://schema.org/Message',
+              ...messageEntity
+            } as any
+          ]
+        }
+      : {}),
+    from: { id: 'bot', role: 'bot' },
+    type: 'message',
+    ...activity
+  };
+}
+
+scenario('deleting an activity in the same grouping', bdd => {
+  const activity1 = buildActivity(
+    { id: 'a-00001', text: 'Hello, World!', timestamp: new Date(1_000).toISOString() },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  const activity2 = buildActivity(
+    { id: 'a-00002', text: 'Aloha!', timestamp: new Date(2_000).toISOString() },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 2 }
+  );
+
+  bdd
+    .given('an initial state', () => INITIAL_STATE)
+    .when('2 activities are upserted', state => upsert({ Date }, upsert({ Date }, state, activity1), activity2))
+    .then('should have 2 activities', (_, state) => {
+      expect(state.activityMap).toHaveProperty('size', 2);
+      expect(state.howToGroupingMap).toHaveProperty('size', 1);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 0);
+      expect(state.sortedActivities).toHaveLength(2);
+      expect(state.sortedChatHistoryList).toHaveLength(1);
+    })
+    .when('the second activity is deleted', (_, state) =>
+      deleteActivityByLocalId(state, getLocalIdFromActivity(state.sortedActivities[1]))
+    )
+    .then('should have 1 activity', (_, state) => {
+      expect(state.activityMap).toHaveProperty('size', 1);
+      expect(state.howToGroupingMap).toHaveProperty('size', 1);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 0);
+      expect(state.sortedActivities).toHaveLength(1);
+      expect(state.sortedChatHistoryList).toHaveLength(1);
+    })
+    .and('`activityMap` should match', (_, state) => {
+      expect(state.activityMap).toEqual(
+        new Map<LocalId, ActivityMapEntry>([
+          [
+            '_:a-00001' as LocalId,
+            {
+              activity: activityToExpectation(activity1, 1_000),
+              activityLocalId: '_:a-00001' as LocalId,
+              logicalTimestamp: 1_000,
+              type: 'activity'
+            } satisfies ActivityMapEntry
+          ]
+        ])
+      );
+    })
+    .and('`howToGroupingMap` should match', (_, state) => {
+      expect(state.howToGroupingMap).toEqual(
+        new Map<HowToGroupingId, HowToGroupingMapEntry>([
+          [
+            '_:how-to:00001' as HowToGroupingId,
+            {
+              logicalTimestamp: 1_000,
+              partList: [
+                {
+                  activityLocalId: '_:a-00001' as LocalId,
+                  logicalTimestamp: 1_000,
+                  position: 1,
+                  type: 'activity'
+                }
+              ]
+            }
+          ]
+        ])
+      );
+    })
+    .and('`sortedActivities` should match', (_, state) => {
+      expect(state.sortedActivities).toEqual([activityToExpectation(activity1, 1_000)]);
+    })
+    .and('`sortedChatHistoryList` should match', (_, state) => {
+      expect(state.sortedChatHistoryList).toEqual([
+        {
+          howToGroupingId: '_:how-to:00001' as HowToGroupingId,
+          logicalTimestamp: 1_000,
+          type: 'how to grouping'
+        } satisfies SortedChatHistoryEntry
+      ]);
+    })
+    .when('the first activity is deleted', (_, state) =>
+      deleteActivityByLocalId(state, getLocalIdFromActivity(state.sortedActivities[0]))
+    )
+    .then('should have no activities', (_, state) => {
+      expect(state.activityMap).toHaveProperty('size', 0);
+      expect(state.howToGroupingMap).toHaveProperty('size', 0);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 0);
+      expect(state.sortedActivities).toHaveLength(0);
+      expect(state.sortedChatHistoryList).toHaveLength(0);
+    });
+});

package/src/reducers/activities/sort/deleteActivityByLocalId.howToWithLivestream.spec.ts

@@ -0,0 +1,248 @@
+/* eslint-disable no-restricted-globals */
+import { expect } from '@jest/globals';
+import { scenario } from '@testduet/given-when-then';
+import { parse } from 'valibot';
+import type { WebChatActivity } from '../../../types/WebChatActivity';
+import deleteActivityByLocalId from './deleteActivityByLocalId';
+import { getLocalIdFromActivity, LocalIdSchema, type LocalId } from './property/LocalId';
+import {
+  HowToGroupingId,
+  type HowToGroupingMapEntry,
+  type LivestreamSessionId,
+  type LivestreamSessionMapEntry,
+  type LivestreamSessionMapEntryActivityEntry
+} from './types';
+import upsert, { INITIAL_STATE } from './upsert';
+
+type SingularOrPlural<T> = T | readonly T[];
+
+function buildActivity(
+  activity:
+    | {
+        channelData:
+          | {
+              streamId: string;
+              streamSequence?: never;
+              streamType: 'final';
+            }
+          | undefined;
+        id: string;
+        text: string;
+        timestamp: string;
+        type: 'message';
+      }
+    | {
+        channelData:
+          | {
+              streamId: string;
+              streamSequence: number;
+              streamType: 'informative' | 'streaming';
+            }
+          | {
+              streamId?: never;
+              streamSequence: 1;
+              streamType: 'informative' | 'streaming';
+            }
+          | undefined;
+        id: string;
+        text: string;
+        timestamp: string;
+        type: 'typing';
+      },
+  messageEntity: { isPartOf: SingularOrPlural<{ '@id': string; '@type': string }>; position: number } | undefined
+): WebChatActivity {
+  const { id } = activity;
+
+  return {
+    ...(messageEntity
+      ? {
+          entities: [
+            {
+              '@context': 'https://schema.org',
+              '@id': '',
+              '@type': 'Message',
+              type: 'https://schema.org/Message',
+              ...messageEntity
+            } as any
+          ]
+        }
+      : {}),
+    from: { id: 'bot', role: 'bot' },
+    ...activity,
+    channelData: {
+      'webchat:internal:local-id': parse(LocalIdSchema, `_:${id}`),
+      'webchat:internal:position': 0,
+      'webchat:send-status': undefined,
+      ...activity.channelData
+    }
+  } as any;
+}
+
+scenario('delete livestream activities in part grouping', bdd => {
+  const activity1 = buildActivity(
+    {
+      channelData: { streamSequence: 1, streamType: 'streaming' },
+      id: 'a-00001',
+      text: 'A quick',
+      timestamp: new Date(1_000).toISOString(),
+      type: 'typing'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  const activity2 = buildActivity(
+    {
+      channelData: { streamId: 'a-00001', streamSequence: 2, streamType: 'streaming' },
+      id: 'a-00002',
+      text: 'A quick brown fox',
+      timestamp: new Date(2_000).toISOString(),
+      type: 'typing'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  const activity3 = buildActivity(
+    {
+      channelData: { streamId: 'a-00001', streamType: 'final' },
+      id: 'a-00003',
+      text: 'A quick brown fox jumped over the lazy dogs.',
+      timestamp: new Date(3_000).toISOString(),
+      type: 'message'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 1 }
+  );
+
+  const activity4 = buildActivity(
+    {
+      channelData: undefined,
+      id: 'a-00004',
+      text: 'Hello, World!',
+      timestamp: new Date(4_000).toISOString(),
+      type: 'message'
+    },
+    { isPartOf: [{ '@id': '_:how-to:00001', '@type': 'HowTo' }], position: 2 }
+  );
+
+  bdd
+    .given('an initial state', () => INITIAL_STATE)
+    .when('4 activities are upserted', state =>
+      upsert(
+        { Date },
+        upsert({ Date }, upsert({ Date }, upsert({ Date }, state, activity1), activity2), activity3),
+        activity4
+      )
+    )
+    .then('should have 4 activities in map, 2 visible', (_, state) => {
+      expect(state.activityMap).toHaveProperty('size', 4);
+      expect(state.howToGroupingMap).toHaveProperty('size', 1);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 1);
+      expect(state.sortedActivities).toHaveLength(2);
+      expect(state.sortedChatHistoryList).toHaveLength(1);
+    })
+    .when('the last livestream activity is delete', (_, state) =>
+      deleteActivityByLocalId(state, getLocalIdFromActivity(state.sortedActivities[0]))
+    )
+    .then('should have 3 activities', (_, state) => {
+      expect(state.activityMap).toHaveProperty('size', 3);
+      expect(state.howToGroupingMap).toHaveProperty('size', 1);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 1);
+      expect(state.sortedActivities).toHaveLength(3);
+      expect(state.sortedChatHistoryList).toHaveLength(1);
+    })
+    .and('`livestreamSessionMap` should match', (_, state) => {
+      expect(state.livestreamSessionMap).toEqual(
+        new Map<LivestreamSessionId, LivestreamSessionMapEntry>([
+          [
+            'a-00001' as LivestreamSessionId,
+            {
+              activities: [
+                {
+                  activityLocalId: '_:a-00001' as LocalId,
+                  logicalTimestamp: 1_000,
+                  sequenceNumber: 1,
+                  type: 'activity'
+                } satisfies LivestreamSessionMapEntryActivityEntry,
+                {
+                  activityLocalId: '_:a-00002' as LocalId,
+                  logicalTimestamp: 2_000,
+                  sequenceNumber: 2,
+                  type: 'activity'
+                } satisfies LivestreamSessionMapEntryActivityEntry
+              ],
+              finalized: false,
+              logicalTimestamp: 1_000
+            }
+          ]
+        ])
+      );
+    })
+    .and('`howToGroupingMap` should match', (_, state) => {
+      expect(state.howToGroupingMap).toEqual(
+        new Map<HowToGroupingId, HowToGroupingMapEntry>([
+          [
+            '_:how-to:00001' as HowToGroupingId,
+            {
+              logicalTimestamp: 4_000,
+              partList: [
+                {
+                  livestreamSessionId: 'a-00001' as LivestreamSessionId,
+                  logicalTimestamp: 1_000,
+                  position: 1,
+                  type: 'livestream session'
+                },
+                {
+                  activityLocalId: '_:a-00004' as LocalId,
+                  logicalTimestamp: 4_000,
+                  position: 2,
+                  type: 'activity'
+                }
+              ]
+            }
+          ]
+        ])
+      );
+    })
+    .when('all livestream activities are delete', (_, state) =>
+      deleteActivityByLocalId(
+        deleteActivityByLocalId(state, getLocalIdFromActivity(state.sortedActivities[1])),
+        getLocalIdFromActivity(state.sortedActivities[0])
+      )
+    )
+    .then('should have 1 activity', (_, state) => {
+      expect(state.activityMap).toHaveProperty('size', 1);
+      expect(state.howToGroupingMap).toHaveProperty('size', 1);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 0);
+      expect(state.sortedActivities).toHaveLength(1);
+      expect(state.sortedChatHistoryList).toHaveLength(1);
+    })
+    .and('`howToGroupingMap` should match', (_, state) => {
+      expect(state.howToGroupingMap).toEqual(
+        new Map<HowToGroupingId, HowToGroupingMapEntry>([
+          [
+            '_:how-to:00001' as HowToGroupingId,
+            {
+              logicalTimestamp: 4_000,
+              partList: [
+                {
+                  activityLocalId: '_:a-00004' as LocalId,
+                  logicalTimestamp: 4_000,
+                  position: 2,
+                  type: 'activity'
+                }
+              ]
+            }
+          ]
+        ])
+      );
+    })
+    .when('all activities are delete', (_, state) =>
+      deleteActivityByLocalId(state, getLocalIdFromActivity(state.sortedActivities[0]))
+    )
+    .then('should have no activities', (_, state) => {
+      expect(state.activityMap).toHaveProperty('size', 0);
+      expect(state.howToGroupingMap).toHaveProperty('size', 0);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 0);
+      expect(state.sortedActivities).toHaveLength(0);
+      expect(state.sortedChatHistoryList).toHaveLength(0);
+    });
+});

package/src/reducers/activities/sort/deleteActivityByLocalId.livestream.spec.ts

@@ -0,0 +1,156 @@
+/* eslint-disable no-restricted-globals */
+import { expect } from '@jest/globals';
+import { scenario } from '@testduet/given-when-then';
+import { parse } from 'valibot';
+import type { WebChatActivity } from '../../../types/WebChatActivity';
+import deleteActivityByLocalId from './deleteActivityByLocalId';
+import { getLocalIdFromActivity, LocalIdSchema, type LocalId } from './property/LocalId';
+import { LivestreamSessionId, type LivestreamSessionMapEntry } from './types';
+import upsert, { INITIAL_STATE } from './upsert';
+
+function buildActivity(
+  activity:
+    | {
+        channelData:
+          | {
+              streamId: string;
+              streamSequence?: never;
+              streamType: 'final';
+            }
+          | undefined;
+        id: string;
+        text: string;
+        timestamp: string;
+        type: 'message';
+      }
+    | {
+        channelData:
+          | {
+              streamId: string;
+              streamSequence: number;
+              streamType: 'informative' | 'streaming';
+            }
+          | {
+              streamId?: never;
+              streamSequence: 1;
+              streamType: 'informative' | 'streaming';
+            }
+          | undefined;
+        id: string;
+        text: string;
+        timestamp: string;
+        type: 'typing';
+      }
+): WebChatActivity {
+  const { id } = activity;
+
+  return {
+    from: { id: 'bot', role: 'bot' },
+    ...activity,
+    channelData: {
+      'webchat:internal:local-id': parse(LocalIdSchema, `_:${id}`),
+      'webchat:internal:position': 0,
+      'webchat:send-status': undefined,
+      ...activity.channelData
+    }
+  } as any;
+}
+
+scenario('deleting an activity', bdd => {
+  const activity1 = buildActivity({
+    channelData: {
+      streamSequence: 1,
+      streamType: 'streaming'
+    },
+    id: 'a-00001',
+    text: 'A quick',
+    timestamp: new Date(1_000).toISOString(),
+    type: 'typing'
+  });
+
+  const activity2 = buildActivity({
+    channelData: {
+      streamId: 'a-00001',
+      streamSequence: 2,
+      streamType: 'streaming'
+    },
+    id: 'a-00002',
+    text: 'A quick brown fox',
+    timestamp: new Date(2_000).toISOString(),
+    type: 'typing'
+  });
+
+  const activity3 = buildActivity({
+    channelData: {
+      streamId: 'a-00001',
+      streamType: 'final'
+    },
+    id: 'a-00003',
+    text: 'A quick brown fox jumped over the lazy dogs.',
+    timestamp: new Date(3_000).toISOString(),
+    type: 'message'
+  });
+
+  bdd
+    .given('an initial state', () => INITIAL_STATE)
+    .when('3 activities are upserted', state =>
+      upsert({ Date }, upsert({ Date }, upsert({ Date }, state, activity1), activity2), activity3)
+    )
+    .then('should have 3 activities in map, 1 visible', (_, state) => {
+      expect(state.activityMap).toHaveProperty('size', 3);
+      expect(state.howToGroupingMap).toHaveProperty('size', 0);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 1);
+      expect(state.sortedActivities).toHaveLength(1);
+      expect(state.sortedChatHistoryList).toHaveLength(1);
+    })
+    .when('the last activity is delete', (_, state) =>
+      deleteActivityByLocalId(state, getLocalIdFromActivity(state.sortedActivities[0]))
+    )
+    .then('should have 2 activities', (_, state) => {
+      expect(state.activityMap).toHaveProperty('size', 2);
+      expect(state.howToGroupingMap).toHaveProperty('size', 0);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 1);
+      expect(state.sortedActivities).toHaveLength(2);
+      expect(state.sortedChatHistoryList).toHaveLength(1);
+    })
+    .and('`livestreamSessionMap` should match', (_, state) => {
+      expect(state.livestreamSessionMap).toEqual(
+        new Map<LivestreamSessionId, LivestreamSessionMapEntry>([
+          [
+            'a-00001' as LivestreamSessionId,
+            {
+              activities: [
+                {
+                  activityLocalId: '_:a-00001' as LocalId,
+                  logicalTimestamp: 1_000,
+                  sequenceNumber: 1,
+                  type: 'activity'
+                },
+                {
+                  activityLocalId: '_:a-00002' as LocalId,
+                  logicalTimestamp: 2_000,
+                  sequenceNumber: 2,
+                  type: 'activity'
+                }
+              ],
+              finalized: false,
+              logicalTimestamp: 1_000
+            }
+          ]
+        ])
+      );
+    })
+    .when('all activities are delete', (_, state) =>
+      deleteActivityByLocalId(
+        deleteActivityByLocalId(state, getLocalIdFromActivity(state.sortedActivities[1])),
+        getLocalIdFromActivity(state.sortedActivities[0])
+      )
+    )
+    .then('should have no activities', (_, state) => {
+      expect(state.activityMap).toHaveProperty('size', 0);
+      expect(state.howToGroupingMap).toHaveProperty('size', 0);
+      expect(state.livestreamSessionMap).toHaveProperty('size', 0);
+      expect(state.sortedActivities).toHaveLength(0);
+      expect(state.sortedChatHistoryList).toHaveLength(0);
+    });
+});