@stream-io/feeds-client 0.2.1 → 0.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stream-io/feeds-client",
-  "version": "0.2.1",
+  "version": "0.2.2",
   "packageManager": "yarn@3.2.4",
   "main": "./dist/index.node.js",
   "exports": {

package/src/feed/event-handlers/activity/activity-marked-utils.test.ts

@@ -0,0 +1,208 @@
+import { describe, it, expect } from 'vitest';
+import {
+  ActivityMarkEvent,
+  NotificationStatusResponse,
+} from '../../../gen/models';
+import { updateNotificationStatusFromActivityMarked } from './handle-activity-marked';
+
+const createMockActivityMarkEvent = (
+  overrides: Partial<ActivityMarkEvent> = {},
+): ActivityMarkEvent => ({
+  created_at: new Date(),
+  fid: 'user:notification',
+  custom: {},
+  type: 'feeds.activity.marked',
+  ...overrides,
+});
+
+const createMockNotificationStatus = (
+  overrides: Partial<NotificationStatusResponse> = {},
+): NotificationStatusResponse => ({
+  unread: 0,
+  unseen: 0,
+  ...overrides,
+});
+
+const createMockAggregatedActivity = (group: string) => ({ group });
+
+describe('activity-marked-utils', () => {
+  describe('updateNotificationStatusFromActivityMarked', () => {
+    it('should return unchanged if notification_status is undefined', () => {
+      const event = createMockActivityMarkEvent({ mark_all_read: true });
+      const currentStatus = undefined;
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(false);
+    });
+
+    it('should handle mark_all_read by adding all aggregated activity groups', () => {
+      const event = createMockActivityMarkEvent({ mark_all_read: true });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: ['existing1'],
+      });
+      const aggregatedActivities = [
+        createMockAggregatedActivity('group1'),
+        createMockAggregatedActivity('group2'),
+        createMockAggregatedActivity('group3'),
+      ];
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+        aggregatedActivities,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+        'group1',
+        'group2',
+        'group3',
+      ]);
+    });
+
+    it('should handle mark_read by adding specific activity IDs', () => {
+      const event = createMockActivityMarkEvent({
+        mark_read: ['activity1', 'activity2'],
+      });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: ['existing1'],
+      });
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+        'activity1',
+        'activity2',
+      ]);
+    });
+
+    it('should handle mark_all_seen by setting last_seen_at to current date', () => {
+      const event = createMockActivityMarkEvent({ mark_all_seen: true });
+      const currentStatus = createMockNotificationStatus({
+        last_seen_at: new Date('2023-01-01'),
+      });
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.last_seen_at).toBeInstanceOf(
+        Date,
+      );
+      expect(
+        result.data?.notification_status.last_seen_at!.getTime(),
+      ).toBeGreaterThan(new Date('2023-01-01').getTime());
+    });
+
+    it('should handle multiple mark flags simultaneously', () => {
+      const event = createMockActivityMarkEvent({
+        mark_all_read: true,
+        mark_all_seen: true,
+      });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: ['existing1'],
+        last_seen_at: new Date('2023-01-01'),
+      });
+      const aggregatedActivities = [
+        createMockAggregatedActivity('group1'),
+        createMockAggregatedActivity('group2'),
+      ];
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+        aggregatedActivities,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+        'group1',
+        'group2',
+      ]);
+      expect(result.data?.notification_status.last_seen_at).toBeInstanceOf(
+        Date,
+      );
+    });
+
+    it('should deduplicate read activities when adding new ones', () => {
+      const event = createMockActivityMarkEvent({
+        mark_read: ['activity1', 'activity1', 'activity2'],
+      });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: ['existing1', 'activity1'],
+      });
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+        'activity1',
+        'activity2',
+      ]);
+    });
+
+    it('should preserve existing notification status fields', () => {
+      const event = createMockActivityMarkEvent({ mark_all_seen: true });
+      const currentStatus = createMockNotificationStatus({
+        unread: 5,
+        unseen: 3,
+        read_activities: ['existing1'],
+      });
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.unread).toBe(5);
+      expect(result.data?.notification_status.unseen).toBe(3);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'existing1',
+      ]);
+      expect(result.data?.notification_status.last_seen_at).toBeInstanceOf(
+        Date,
+      );
+    });
+
+    it('should handle mark_all_read with no existing read_activities', () => {
+      const event = createMockActivityMarkEvent({ mark_all_read: true });
+      const currentStatus = createMockNotificationStatus({
+        read_activities: undefined,
+      });
+      const aggregatedActivities = [
+        createMockAggregatedActivity('group1'),
+        createMockAggregatedActivity('group2'),
+      ];
+
+      const result = updateNotificationStatusFromActivityMarked(
+        event,
+        currentStatus,
+        aggregatedActivities,
+      );
+
+      expect(result.changed).toBe(true);
+      expect(result.data?.notification_status.read_activities).toEqual([
+        'group1',
+        'group2',
+      ]);
+    });
+  });
+});

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', () => {