@stream-io/feeds-client 0.2.1 → 0.2.3

package/src/feed/event-handlers/activity/handle-activity-added.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleActivityAdded } from './handle-activity-added';
+import {
+  generateActivityAddedEvent,
+  generateActivityResponse,
+  generateFeedResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleActivityAdded.name, () => {
+  let feed: Feed;
+  let client: FeedsClient;
+  let currentUserId: string;
+
+  beforeEach(() => {
+    client = new FeedsClient('mock-api-key');
+    currentUserId = getHumanId();
+    client.state.partialNext({
+      connected_user: generateOwnUser({ id: currentUserId }),
+    });
+
+    const feedResponse = generateFeedResponse({
+      id: 'main',
+      group_id: 'user',
+      created_by: { id: currentUserId },
+    });
+
+    feed = new Feed(
+      client,
+      feedResponse.group_id,
+      feedResponse.id,
+      feedResponse,
+    );
+  });
+
+  it('initializes activities when state is empty and adds new activity to the start', () => {
+    const event = generateActivityAddedEvent();
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.activities).toBeUndefined();
+
+    const hydrateSpy = vi.spyOn(client, 'hydratePollCache');
+
+    handleActivityAdded.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.activities).toBeDefined();
+    expect(stateAfter.activities).toHaveLength(1);
+    expect(stateAfter.activities?.[0]).toBe(event.activity);
+    expect(hydrateSpy).toHaveBeenCalledWith([event.activity]);
+  });
+
+  it('prepends new activity when activities already exist', () => {
+    const existing = generateActivityResponse();
+    feed.state.partialNext({ activities: [existing] });
+
+    const event = generateActivityAddedEvent();
+
+    handleActivityAdded.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.activities).toHaveLength(2);
+    expect(stateAfter.activities?.[0]).toBe(event.activity);
+    expect(stateAfter.activities?.[1]).toBe(existing);
+  });
+
+  it('does not duplicate if activity already exists', () => {
+    const existing = generateActivityResponse();
+    feed.state.partialNext({ activities: [existing] });
+
+    const event = generateActivityAddedEvent({
+      activity: { id: existing.id },
+    });
+
+    const stateBefore = feed.currentState;
+    handleActivityAdded.call(feed, event);
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter).toBe(stateBefore);
+    expect(stateAfter.activities).toHaveLength(1);
+    expect(stateAfter.activities?.[0]).toBe(existing);
+  });
+});

package/src/feed/event-handlers/activity/handle-activity-deleted.test.ts

@@ -0,0 +1,117 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { Feed } from '../../../feed';
+import { FeedsClient } from '../../../feeds-client';
+import { handleActivityDeleted } from './handle-activity-deleted';
+import {
+  generateActivityDeletedEvent,
+  generateActivityPinResponse,
+  generateActivityResponse,
+  generateFeedResponse,
+  generateOwnUser,
+  getHumanId,
+} from '../../../test-utils/response-generators';
+
+describe(handleActivityDeleted.name, () => {
+  let feed: Feed;
+  let client: FeedsClient;
+  let currentUserId: string;
+
+  beforeEach(() => {
+    client = new FeedsClient('mock-api-key');
+    currentUserId = getHumanId();
+    client.state.partialNext({
+      connected_user: generateOwnUser({ id: currentUserId }),
+    });
+
+    const feedResponse = generateFeedResponse({
+      id: 'main',
+      group_id: 'user',
+      created_by: { id: currentUserId },
+    });
+
+    feed = new Feed(
+      client,
+      feedResponse.group_id,
+      feedResponse.id,
+      feedResponse,
+    );
+  });
+
+  it('removes the activity from activities array when present', () => {
+    const activity1 = generateActivityResponse();
+    const activity2 = generateActivityResponse();
+    feed.state.partialNext({ activities: [activity1, activity2] });
+
+    const event = generateActivityDeletedEvent({
+      activity: { id: activity1.id },
+    });
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.activities).toHaveLength(2);
+
+    handleActivityDeleted.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.activities).toHaveLength(1);
+    expect(stateAfter.activities?.[0].id).toBe(activity2.id);
+  });
+
+  it('removes the activity from pinned_activities when present', () => {
+    const pin1 = generateActivityPinResponse();
+    const pin2 = generateActivityPinResponse();
+    feed.state.partialNext({ pinned_activities: [pin1, pin2] });
+
+    const event = generateActivityDeletedEvent({
+      activity: { id: pin1.activity.id },
+    });
+
+    const stateBefore = feed.currentState;
+    expect(stateBefore.pinned_activities).toHaveLength(2);
+
+    handleActivityDeleted.call(feed, event);
+
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter.pinned_activities).toHaveLength(1);
+    expect(stateAfter.pinned_activities?.[0]).toBe(pin2);
+  });
+
+  it('updates both arrays when the activity exists in both activities and pinned_activities', () => {
+    const sharedId = getHumanId();
+    const activity = generateActivityResponse({ id: sharedId });
+    const pinnedActivity = generateActivityPinResponse({
+      activity: { id: sharedId },
+    });
+    feed.state.partialNext({
+      activities: [activity],
+      pinned_activities: [pinnedActivity],
+    });
+
+    const event = generateActivityDeletedEvent({
+      activity: { id: sharedId },
+    });
+
+    handleActivityDeleted.call(feed, event);
+
+    const stateAfter = feed.currentState;
+    expect(stateAfter.activities).toHaveLength(0);
+    expect(stateAfter.pinned_activities).toHaveLength(0);
+  });
+
+  it('does nothing if the activity is not found in either list', () => {
+    const activity = generateActivityResponse();
+    const pinnedActivity = generateActivityPinResponse();
+    feed.state.partialNext({
+      activities: [activity],
+      pinned_activities: [pinnedActivity],
+    });
+
+    const event = generateActivityDeletedEvent({ activity: { id: 'unknown' } });
+
+    const stateBefore = feed.currentState;
+    handleActivityDeleted.call(feed, event);
+    const stateAfter = feed.currentState;
+
+    expect(stateAfter).toBe(stateBefore);
+  });
+});

package/src/feed/event-handlers/activity/handle-activity-deleted.ts

@@ -3,12 +3,14 @@ import type {
   ActivityPinResponse,
   ActivityResponse,
 } from '../../../gen/models';
-import type { EventPayload } from '../../../types-internal';
+import type { EventPayload, UpdateStateResult } from '../../../types-internal';
 
 export const removeActivityFromState = (
   activityResponse: ActivityResponse,
   activities: ActivityResponse[] | undefined,
-) => {
+): UpdateStateResult<{
+  activities: ActivityResponse[] | undefined;
+}> => {
   const index =
     activities?.findIndex((activity) => activity.id === activityResponse.id) ??
     -1;
@@ -25,7 +27,9 @@ export const removeActivityFromState = (
 export const removePinnedActivityFromState = (
   activityResponse: ActivityResponse,
   pinnedActivities: ActivityPinResponse[] | undefined,
-) => {
+): UpdateStateResult<{
+  pinned_activities: ActivityPinResponse[] | undefined;
+}> => {
   const index =
     pinnedActivities?.findIndex(
       (pinnedActivity) => pinnedActivity.activity.id === activityResponse.id,
@@ -34,7 +38,7 @@ export const removePinnedActivityFromState = (
   if (index !== -1) {
     const newActivities = [...pinnedActivities!];
     newActivities.splice(index, 1);
-    return { changed: true, activities: newActivities };
+    return { changed: true, pinned_activities: newActivities };
   } else {
     return { changed: false, pinned_activities: pinnedActivities };
   }

package/src/feed/event-handlers/activity/handle-activity-marked.ts

@@ -0,0 +1,68 @@
+import {
+  ActivityMarkEvent,
+  NotificationStatusResponse,
+} from '../../../gen/models';
+import { EventPayload, UpdateStateResult } from '../../../types-internal';
+import { Feed } from '../../feed';
+
+export const updateNotificationStatusFromActivityMarked = (
+  event: ActivityMarkEvent,
+  currentNotificationStatus: NotificationStatusResponse | undefined,
+  aggregatedActivities: Array<{ group: string }> = [],
+): UpdateStateResult<{
+  data?: { notification_status: NotificationStatusResponse };
+}> => {
+  if (!currentNotificationStatus) {
+    return {
+      changed: false,
+    };
+  }
+
+  const newState = {
+    ...currentNotificationStatus,
+  };
+
+  if (event.mark_all_read) {
+    const allGroupIds = aggregatedActivities.map((activity) => activity.group);
+    newState.read_activities = [
+      ...new Set([
+        ...(currentNotificationStatus.read_activities ?? []),
+        ...allGroupIds,
+      ]),
+    ];
+  }
+
+  if (event.mark_read && event.mark_read.length > 0) {
+    newState.read_activities = [
+      ...new Set([
+        ...(currentNotificationStatus?.read_activities ?? []),
+        ...event.mark_read,
+      ]),
+    ];
+  }
+
+  if (event.mark_all_seen) {
+    newState.last_seen_at = new Date();
+  }
+
+  return {
+    changed: true,
+    data: { notification_status: newState },
+  };
+};
+
+export function handleActivityMarked(
+  this: Feed,
+  event: EventPayload<'feeds.activity.marked'>,
+) {
+  const result = updateNotificationStatusFromActivityMarked(
+    event,
+    this.currentState.notification_status,
+    this.currentState.aggregated_activities,
+  );
+  if (result.changed) {
+    this.state.partialNext({
+      notification_status: result.data?.notification_status,
+    });
+  }
+}

package/src/feed/event-handlers/activity/handle-activity-reaction-added.test.ts

@@ -58,8 +58,8 @@ describe(handleActivityReactionAdded.name, () => {
 
     const stateBefore = feed.currentState;
 
-    expect(stateBefore.activities![0].reaction_count).toEqual(0);
-    expect(stateBefore.pinned_activities![0].activity.reaction_count).toEqual(
+    expect(stateBefore.activities![0].reaction_count).toBe(0);
+    expect(stateBefore.pinned_activities![0].activity.reaction_count).toBe(
       0,
     );
 
@@ -71,14 +71,14 @@ describe(handleActivityReactionAdded.name, () => {
     expect(stateAfter.pinned_activities![0].activity.own_reactions).toContain(
       event.reaction,
     );
-    expect(stateAfter.activities![0].own_bookmarks).toEqual(
+    expect(stateAfter.activities![0].own_bookmarks).toBe(
       stateBefore.activities![0].own_bookmarks,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toBe(
       stateBefore.pinned_activities![0].activity.own_bookmarks,
     );
-    expect(stateAfter.activities![0].reaction_count).toEqual(1);
-    expect(stateAfter.pinned_activities![0].activity.reaction_count).toEqual(1);
+    expect(stateAfter.activities![0].reaction_count).toBe(1);
+    expect(stateAfter.pinned_activities![0].activity.reaction_count).toBe(1);
   });
 
   it('does not add to own_reactions if reaction is from another user but still updates activity', () => {
@@ -102,8 +102,8 @@ describe(handleActivityReactionAdded.name, () => {
 
     const stateBefore = feed.currentState;
 
-    expect(stateBefore.activities![0].reaction_count).toEqual(0);
-    expect(stateBefore.pinned_activities![0].activity.reaction_count).toEqual(
+    expect(stateBefore.activities![0].reaction_count).toBe(0);
+    expect(stateBefore.pinned_activities![0].activity.reaction_count).toBe(
       0,
     );
 
@@ -115,18 +115,18 @@ describe(handleActivityReactionAdded.name, () => {
     expect(
       stateAfter.pinned_activities![0].activity.own_reactions,
     ).toHaveLength(0);
-    expect(stateAfter.activities![0].reaction_count).toEqual(1);
-    expect(stateAfter.pinned_activities![0].activity.reaction_count).toEqual(1);
-    expect(stateAfter.activities![0].own_bookmarks).toEqual(
+    expect(stateAfter.activities![0].reaction_count).toBe(1);
+    expect(stateAfter.pinned_activities![0].activity.reaction_count).toBe(1);
+    expect(stateAfter.activities![0].own_bookmarks).toBe(
       stateBefore.activities![0].own_bookmarks,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toBe(
       stateBefore.pinned_activities![0].activity.own_bookmarks,
     );
-    expect(stateAfter.activities![0].own_reactions).toEqual(
+    expect(stateAfter.activities![0].own_reactions).toBe(
       stateBefore.activities![0].own_reactions,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_reactions).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_reactions).toBe(
       stateBefore.pinned_activities![0].activity.own_reactions,
     );
   });
@@ -152,6 +152,6 @@ describe(handleActivityReactionAdded.name, () => {
 
     const stateAfter = feed.currentState;
 
-    expect(stateAfter).toEqual(stateBefore);
+    expect(stateAfter).toBe(stateBefore);
   });
 });

package/src/feed/event-handlers/activity/handle-activity-reaction-deleted.test.ts

@@ -72,8 +72,8 @@ describe(handleActivityReactionDeleted.name, () => {
     expect(
       stateBefore.pinned_activities![0].activity.own_reactions,
     ).toHaveLength(1);
-    expect(stateBefore.activities![0].reaction_count).toEqual(1);
-    expect(stateBefore.pinned_activities![0].activity.reaction_count).toEqual(
+    expect(stateBefore.activities![0].reaction_count).toBe(1);
+    expect(stateBefore.pinned_activities![0].activity.reaction_count).toBe(
       1,
     );
 
@@ -84,12 +84,12 @@ describe(handleActivityReactionDeleted.name, () => {
     expect(
       stateAfter.pinned_activities![0].activity.own_reactions,
     ).toHaveLength(0);
-    expect(stateAfter.activities![0].reaction_count).toEqual(0);
-    expect(stateAfter.pinned_activities![0].activity.reaction_count).toEqual(0);
-    expect(stateAfter.activities![0].own_bookmarks).toEqual(
+    expect(stateAfter.activities![0].reaction_count).toBe(0);
+    expect(stateAfter.pinned_activities![0].activity.reaction_count).toBe(0);
+    expect(stateAfter.activities![0].own_bookmarks).toBe(
       stateBefore.activities![0].own_bookmarks,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toBe(
       stateBefore.pinned_activities![0].activity.own_bookmarks,
     );
   });
@@ -130,8 +130,8 @@ describe(handleActivityReactionDeleted.name, () => {
     expect(
       stateBefore.pinned_activities![0].activity.own_reactions,
     ).toHaveLength(1);
-    expect(stateBefore.activities![0].reaction_count).toEqual(1);
-    expect(stateBefore.pinned_activities![0].activity.reaction_count).toEqual(
+    expect(stateBefore.activities![0].reaction_count).toBe(1);
+    expect(stateBefore.pinned_activities![0].activity.reaction_count).toBe(
       1,
     );
 
@@ -139,23 +139,23 @@ describe(handleActivityReactionDeleted.name, () => {
 
     const stateAfter = feed.currentState;
     expect(stateAfter.activities![0].own_reactions).toHaveLength(1);
-    expect(stateAfter.activities![0].own_reactions).toEqual(
+    expect(stateAfter.activities![0].own_reactions).toBe(
       stateBefore.activities![0].own_reactions,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_reactions).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_reactions).toBe(
       stateBefore.pinned_activities![0].activity.own_reactions,
     );
-    expect(stateAfter.activities![0].own_bookmarks).toEqual(
+    expect(stateAfter.activities![0].own_bookmarks).toBe(
       stateBefore.activities![0].own_bookmarks,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toBe(
       stateBefore.pinned_activities![0].activity.own_bookmarks,
     );
     expect(
       stateAfter.pinned_activities![0].activity.own_reactions,
     ).toHaveLength(1);
-    expect(stateAfter.activities![0].reaction_count).toEqual(0);
-    expect(stateAfter.pinned_activities![0].activity.reaction_count).toEqual(0);
+    expect(stateAfter.activities![0].reaction_count).toBe(0);
+    expect(stateAfter.pinned_activities![0].activity.reaction_count).toBe(0);
   });
 
   it('does nothing if activity is not found', () => {

package/src/feed/event-handlers/activity/handle-activity-unpinned.test.ts

@@ -22,7 +22,7 @@ function makeUnpinnedEvent(
     pinned_activity: {
       created_at: pinnedActivity.created_at,
       duration: '0',
-      fid: pinnedActivity.feed,
+      feed: pinnedActivity.feed,
       user_id: pinnedActivity.user.id,
       activity: pinnedActivity.activity,
     },
@@ -67,7 +67,7 @@ describe(handleActivityUnpinned.name, () => {
     const stateBefore = feed.currentState;
     handleActivityUnpinned.call(feed, event);
     const stateAfter = feed.currentState;
-    expect(stateAfter.pinned_activities).toEqual(stateBefore.pinned_activities);
+    expect(stateAfter.pinned_activities).toBe(stateBefore.pinned_activities);
   });
 
   it('does nothing if pinned_activities is empty', () => {
@@ -76,9 +76,10 @@ describe(handleActivityUnpinned.name, () => {
       pinned_activities: [],
     }));
     const event = makeUnpinnedEvent(pinnedActivity);
+    const stateBefore = feed.currentState;
     handleActivityUnpinned.call(feed, event);
     const stateAfter = feed.currentState;
-    expect(stateAfter.pinned_activities).toEqual([]);
+    expect(stateAfter).toBe(stateBefore);
   });
 
   it('does nothing if pinned_activities is undefined', () => {

package/src/feed/event-handlers/activity/handle-activity-updated.test.ts

@@ -77,16 +77,16 @@ describe(handleActivityUpdated.name, () => {
       id: 'activity-1',
       text: 'updated text',
     });
-    expect(stateAfter.activities![0].own_reactions).toEqual(
+    expect(stateAfter.activities![0].own_reactions).toBe(
       stateBefore.activities![0].own_reactions,
     );
-    expect(stateAfter.activities![0].own_bookmarks).toEqual(
+    expect(stateAfter.activities![0].own_bookmarks).toBe(
       stateBefore.activities![0].own_bookmarks,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_reactions).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_reactions).toBe(
       stateBefore.pinned_activities![0].activity.own_reactions,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toBe(
       stateBefore.pinned_activities![0].activity.own_bookmarks,
     );
   });

package/src/feed/event-handlers/activity/index.ts

@@ -3,4 +3,5 @@ export * from './handle-activity-deleted';
 export * from './handle-activity-removed-from-feed';
 export * from './handle-activity-updated';
 export * from './handle-activity-reaction-added';
-export * from './handle-activity-reaction-deleted';
+export * from './handle-activity-reaction-deleted';
+export * from './handle-activity-marked';

package/src/feed/event-handlers/bookmark/handle-bookmark-added.test.ts

@@ -65,8 +65,8 @@ describe(handleBookmarkAdded.name, () => {
     expect(
       stateBefore.pinned_activities![0].activity.own_bookmarks,
     ).toHaveLength(0);
-    expect(stateBefore.activities![0].bookmark_count).toEqual(0);
-    expect(stateBefore.pinned_activities![0].activity.bookmark_count).toEqual(
+    expect(stateBefore.activities![0].bookmark_count).toBe(0);
+    expect(stateBefore.pinned_activities![0].activity.bookmark_count).toBe(
       0,
     );
 
@@ -81,14 +81,14 @@ describe(handleBookmarkAdded.name, () => {
     expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toContain(
       event.bookmark,
     );
-    expect(stateAfter.activities![0].own_reactions).toEqual(
+    expect(stateAfter.activities![0].own_reactions).toBe(
       stateBefore.activities![0].own_reactions,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_reactions).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_reactions).toBe(
       stateBefore.pinned_activities![0].activity.own_reactions,
     );
-    expect(stateAfter.activities![0].bookmark_count).toEqual(1);
-    expect(stateAfter.pinned_activities![0].activity.bookmark_count).toEqual(1);
+    expect(stateAfter.activities![0].bookmark_count).toBe(1);
+    expect(stateAfter.pinned_activities![0].activity.bookmark_count).toBe(1);
   });
 
   it('does not add to own_bookmarks if bookmark is from another user but still updates activity', () => {
@@ -120,28 +120,28 @@ describe(handleBookmarkAdded.name, () => {
     expect(
       stateBefore.pinned_activities![0].activity.own_bookmarks,
     ).toHaveLength(0);
-    expect(stateBefore.activities![0].bookmark_count).toEqual(0);
-    expect(stateBefore.pinned_activities![0].activity.bookmark_count).toEqual(
+    expect(stateBefore.activities![0].bookmark_count).toBe(0);
+    expect(stateBefore.pinned_activities![0].activity.bookmark_count).toBe(
       0,
     );
 
     handleBookmarkAdded.call(feed, event);
 
     const stateAfter = feed.currentState;
-    expect(stateAfter.activities![0].own_bookmarks).toEqual(
+    expect(stateAfter.activities![0].own_bookmarks).toBe(
       stateBefore.activities![0].own_bookmarks,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toBe(
       stateBefore.pinned_activities![0].activity.own_bookmarks,
     );
-    expect(stateAfter.activities![0].own_reactions).toEqual(
+    expect(stateAfter.activities![0].own_reactions).toBe(
       stateBefore.activities![0].own_reactions,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_reactions).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_reactions).toBe(
       stateBefore.pinned_activities![0].activity.own_reactions,
     );
-    expect(stateAfter.activities![0].bookmark_count).toEqual(1);
-    expect(stateAfter.pinned_activities![0].activity.bookmark_count).toEqual(1);
+    expect(stateAfter.activities![0].bookmark_count).toBe(1);
+    expect(stateAfter.pinned_activities![0].activity.bookmark_count).toBe(1);
   });
 
   it('does nothing if activity is not found', () => {

package/src/feed/event-handlers/bookmark/handle-bookmark-deleted.test.ts

@@ -71,8 +71,8 @@ describe(handleBookmarkDeleted.name, () => {
     expect(
       stateBefore.pinned_activities![0].activity.own_bookmarks,
     ).toHaveLength(1);
-    expect(stateBefore.activities![0].bookmark_count).toEqual(1);
-    expect(stateBefore.pinned_activities![0].activity.bookmark_count).toEqual(
+    expect(stateBefore.activities![0].bookmark_count).toBe(1);
+    expect(stateBefore.pinned_activities![0].activity.bookmark_count).toBe(
       1,
     );
 
@@ -83,14 +83,14 @@ describe(handleBookmarkDeleted.name, () => {
     expect(
       stateAfter.pinned_activities![0].activity.own_bookmarks,
     ).toHaveLength(0);
-    expect(stateAfter.activities![0].own_reactions).toEqual(
+    expect(stateAfter.activities![0].own_reactions).toBe(
       stateBefore.activities![0].own_reactions,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_reactions).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_reactions).toBe(
       stateBefore.pinned_activities![0].activity.own_reactions,
     );
-    expect(stateAfter.activities![0].bookmark_count).toEqual(0);
-    expect(stateAfter.pinned_activities![0].activity.bookmark_count).toEqual(0);
+    expect(stateAfter.activities![0].bookmark_count).toBe(0);
+    expect(stateAfter.pinned_activities![0].activity.bookmark_count).toBe(0);
   });
 
   it('does not remove from own_bookmarks if bookmark is from another user but still updates activity', () => {
@@ -127,28 +127,28 @@ describe(handleBookmarkDeleted.name, () => {
     expect(
       stateBefore.pinned_activities![0].activity.own_bookmarks,
     ).toHaveLength(1);
-    expect(stateBefore.activities![0].bookmark_count).toEqual(1);
-    expect(stateBefore.pinned_activities![0].activity.bookmark_count).toEqual(
+    expect(stateBefore.activities![0].bookmark_count).toBe(1);
+    expect(stateBefore.pinned_activities![0].activity.bookmark_count).toBe(
       1,
     );
 
     handleBookmarkDeleted.call(feed, event);
 
     const stateAfter = feed.currentState;
-    expect(stateAfter.activities![0].own_bookmarks).toEqual(
+    expect(stateAfter.activities![0].own_bookmarks).toBe(
       stateBefore.activities![0].own_bookmarks,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_bookmarks).toBe(
       stateBefore.pinned_activities![0].activity.own_bookmarks,
     );
-    expect(stateAfter.activities![0].own_reactions).toEqual(
+    expect(stateAfter.activities![0].own_reactions).toBe(
       stateBefore.activities![0].own_reactions,
     );
-    expect(stateAfter.pinned_activities![0].activity.own_reactions).toEqual(
+    expect(stateAfter.pinned_activities![0].activity.own_reactions).toBe(
       stateBefore.pinned_activities![0].activity.own_reactions,
     );
-    expect(stateAfter.activities![0].bookmark_count).toEqual(0);
-    expect(stateAfter.pinned_activities![0].activity.bookmark_count).toEqual(0);
+    expect(stateAfter.activities![0].bookmark_count).toBe(0);
+    expect(stateAfter.pinned_activities![0].activity.bookmark_count).toBe(0);
   });
 
   it('does nothing if activity is not found', () => {