test: add tests for Subscription and shallowEqual

Author: crutchcorn

projects/angular-redux/src/lib/utils/Subscription.ts

@@ -1,5 +1,3 @@
-import { defaultNoopBatch as batch } from './batch'
-
 // encapsulates the subscription logic for connecting a component to the redux store, as
 // well as nesting subscriptions of descendant components, so that we can ensure the
 // ancestor components re-render before descendants
@@ -23,13 +21,11 @@ function createListenerCollection() {
     },
 
     notify() {
-      batch(() => {
         let listener = first
         while (listener) {
           listener.callback()
           listener = listener.next
         }
-      })
     },
 
     get() {

projects/angular-redux/src/lib/utils/batch.ts

@@ -8,3 +8,4 @@ export * from './lib/inject-store';
 export * from './lib/provide-redux';
 export * from "./lib/provider"
 export * from "./lib/utils/shallowEqual"
+export type { Subscription } from './lib/utils/Subscription'

projects/angular-redux/src/public-api.ts

@@ -0,0 +1,58 @@
+import {  createSubscription, Subscription } from '../../lib/utils/Subscription'
+import { Store } from 'redux'
+
+describe('Subscription', () => {
+  let notifications: string[]
+  let store: Store
+  let parent: Subscription
+
+  beforeEach(() => {
+    notifications = []
+    store = { subscribe: () => jest.fn() } as unknown as Store
+
+    parent = createSubscription(store)
+    parent.onStateChange = () => {}
+    parent.trySubscribe()
+  })
+
+  function subscribeChild(name: string) {
+    const child = createSubscription(store, parent)
+    child.onStateChange = () => notifications.push(name)
+    child.trySubscribe()
+    return child
+  }
+
+  it('listeners are notified in order', () => {
+    subscribeChild('child1')
+    subscribeChild('child2')
+    subscribeChild('child3')
+    subscribeChild('child4')
+
+    parent.notifyNestedSubs()
+
+    expect(notifications).toEqual(['child1', 'child2', 'child3', 'child4'])
+  })
+
+  it('listeners can be unsubscribed', () => {
+    const child1 = subscribeChild('child1')
+    const child2 = subscribeChild('child2')
+    const child3 = subscribeChild('child3')
+
+    child2.tryUnsubscribe()
+    parent.notifyNestedSubs()
+
+    expect(notifications).toEqual(['child1', 'child3'])
+    notifications.length = 0
+
+    child1.tryUnsubscribe()
+    parent.notifyNestedSubs()
+
+    expect(notifications).toEqual(['child3'])
+    notifications.length = 0
+
+    child3.tryUnsubscribe()
+    parent.notifyNestedSubs()
+
+    expect(notifications).toEqual([])
+  })
+})

projects/angular-redux/src/tests/utils/Subscription.spec.ts

@@ -0,0 +1,83 @@
+import { shallowEqual } from '../../public-api'
+
+describe('Utils', () => {
+  describe('shallowEqual', () => {
+    it('should return true if arguments fields are equal', () => {
+      expect(
+        shallowEqual(
+          { a: 1, b: 2, c: undefined },
+          { a: 1, b: 2, c: undefined },
+        ),
+      ).toBe(true)
+
+      expect(shallowEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2, c: 3 })).toBe(
+        true,
+      )
+
+      const o = {}
+      expect(shallowEqual({ a: 1, b: 2, c: o }, { a: 1, b: 2, c: o })).toBe(
+        true,
+      )
+
+      const d = function () {
+        return 1
+      }
+      expect(
+        shallowEqual({ a: 1, b: 2, c: o, d }, { a: 1, b: 2, c: o, d }),
+      ).toBe(true)
+    })
+
+    it('should return false if arguments fields are different function identities', () => {
+      expect(
+        shallowEqual(
+          {
+            a: 1,
+            b: 2,
+            d: function () {
+              return 1
+            },
+          },
+          {
+            a: 1,
+            b: 2,
+            d: function () {
+              return 1
+            },
+          },
+        ),
+      ).toBe(false)
+    })
+
+    it('should return false if first argument has too many keys', () => {
+      expect(shallowEqual({ a: 1, b: 2, c: 3 }, { a: 1, b: 2 })).toBe(false)
+    })
+
+    it('should return false if second argument has too many keys', () => {
+      expect(shallowEqual({ a: 1, b: 2 }, { a: 1, b: 2, c: 3 })).toBe(false)
+    })
+
+    it('should return false if arguments have different keys', () => {
+      expect(
+        shallowEqual(
+          { a: 1, b: 2, c: undefined },
+          { a: 1, bb: 2, c: undefined },
+        ),
+      ).toBe(false)
+    })
+
+    it('should compare two NaN values', () => {
+      expect(shallowEqual(NaN, NaN)).toBe(true)
+    })
+
+    it('should compare empty objects, with false', () => {
+      expect(shallowEqual({}, false)).toBe(false)
+      expect(shallowEqual(false, {})).toBe(false)
+      expect(shallowEqual([], false)).toBe(false)
+      expect(shallowEqual(false, [])).toBe(false)
+    })
+
+    it('should compare two zero values', () => {
+      expect(shallowEqual(0, 0)).toBe(true)
+    })
+  })
+})