add tests

test/signal-remove-during-dispatch.test.ts

@@ -0,0 +1,32 @@
+import createSignal, { Signal } from '../src/nanosignal';
+
+describe('when a listener unsubscribes another listener during dispatch', () => {
+  let dated: Signal<Date>;
+  let listenerA: jest.Mock<any>;
+  let listenerB: jest.Mock<any>;
+  let listenerC: jest.Mock<any>;
+  beforeEach(() => {
+    dated = createSignal();
+    listenerA = jest.fn();
+    const unsubscribeA = dated.subscribe(listenerA);
+    listenerB = jest.fn(unsubscribeA);
+    listenerC = jest.fn();
+    dated.subscribe(listenerB);
+    dated.subscribe(listenerC);
+    // dispatch twice and expect the unsubscribed listener to be called only once
+    dated(new Date());
+    dated(new Date());
+  });
+
+  it('the first listener is called once then unsubscribed', () => {
+    expect(listenerA).toHaveBeenCalledTimes(1);
+  });
+
+  it('no other listener is skipped', () => {
+    expect(listenerB).toHaveBeenCalledTimes(2);
+    expect(listenerC).toHaveBeenCalledTimes(2);
+  });
+});
+
+
+

test/signal.test.ts

@@ -0,0 +1,64 @@
+import createSignal, { Signal, Unsubscriber } from '../src/nanosignal';
+
+describe('Signal', () => {
+  let dated: Signal<Date>;
+  beforeEach(() => {
+    dated = createSignal();
+  });
+  it('is a function', () => expect(typeof dated).toBe('function'));
+
+  describe('given 2 listeners', () => {
+    let listenerA: jest.Mock<any>;
+    let listenerB: jest.Mock<any>;
+    const payload = new Date();
+    beforeEach(() => {
+      listenerA = jest.fn();
+      listenerB = jest.fn();
+      dated.subscribe(listenerA);
+      dated.subscribe(listenerB);
+      dated(payload);
+    });
+
+    it('when the signal fires, the listeners receive the payload', () => {
+      expect(listenerA).toHaveBeenCalledWith(payload);
+      expect(listenerB).toHaveBeenCalledWith(payload);
+    });
+  });
+
+  describe('given a firstListener argument and then subscribe() a second listener', () => {
+    let listenerA: jest.Mock<any>;
+    let listenerB: jest.Mock<any>;
+    const payload = new Date();
+    beforeEach(() => {
+      listenerA = jest.fn();
+      listenerB = jest.fn();
+      dated = createSignal(listenerA);
+      dated.subscribe(listenerB);
+      dated(payload);
+    });
+
+    it('when the signal fires, the listeners receive the payload', () => {
+      expect(listenerA).toHaveBeenCalledWith(payload);
+      expect(listenerB).toHaveBeenCalledWith(payload);
+    });
+  });
+
+  describe('when removing a listener before firing', () => {
+    let listenerA: jest.Mock<any>;
+    let removeA: Unsubscriber;
+    beforeEach(() => {
+      listenerA = jest.fn();
+      removeA = dated.subscribe(listenerA);
+      removeA();
+      dated(new Date());
+    });
+
+    it('the listener is not called', () => {
+      expect(listenerA).not.toBeCalled();
+    });
+  });
+
+});
+
+
+

test/nanosignal-signal0.test.ts → test/signal0.test.ts

@@ -1,6 +1,6 @@
 import createSignal0, { Signal0, Unsubscriber } from '../src/nanosignal0';
 
-describe('signal with 0 arguments', () => {
+describe('Signal0', () => {
   let happened: Signal0;
   beforeEach(() => {
     happened = createSignal0();
@@ -99,6 +99,23 @@ describe('signal with 0 arguments', () => {
 
   });
 
+  describe('given a firstListener argument and then subscribe() a second listener', () => {
+    let listenerA: jest.Mock<any>;
+    let listenerB: jest.Mock<any>;
+    beforeEach(() => {
+      listenerA = jest.fn();
+      listenerB = jest.fn();
+      happened = createSignal0(listenerA);
+      happened.subscribe(listenerB);
+      happened();
+    });
+
+    it('when the signal fires, the listeners are called', () => {
+      expect(listenerA).toHaveBeenCalledTimes(1);
+      expect(listenerB).toHaveBeenCalledTimes(1);
+    });
+  });
+
 });