Unit test closed sink (#40)

* Added more info for newcomers

* Rebase

* Fix heading

* Fix heading

* Resolve merge conflict in swap-source.test.ts during rebase

* Add comprehensive unit test suite for Closed sink

- Created BDD-style test suite following existing patterns
- Tests cover ClosedSink function and Closed explicit sink
- Includes dialog element closing functionality tests
- Tests boolean attribute value handling (true/false)
- Covers future/promise and observable sources
- Includes edge cases and integration scenarios
- Validates sink configuration structure
- Uses custom MockDialogElement for HTMLDialogElement testing

* Resolve merge conflict in swap-source.test.ts

* Remove TL;DR reference from README and delete QUICKSTART.md

- Remove 'To Busy to read?, Check [TL;DR 📜](./QUICKSTART.md)' line from README
- Delete QUICKSTART.md file completely
- Clean up documentation structure

* Refactor closed-sink tests to follow one action => one reaction principle

- Split multiple actions into individual tests
- Each test now has clear cause and effect
- Better test isolation and debugging
- More descriptive test names
- Follows best practices for test organization

* Clarify closed-sink test descriptions to reflect actual behavior

- Change 'closes dialog' to 'calls dialog.close()' in test names
- Add comments explaining dialog.close() has no parameters
- Clarify that there's no 'unclose' functionality
- Each call to sink() results in dialog.close() being called regardless of input

* Add shared test helper for sink binding configuration assertions

- Add expectSinkBindingConfiguration helper function to test-support.ts
- Replace repetitive sink configuration assertions with shared helper
- Improve test maintainability and reduce code duplication
- Helper can be reused across all sink tests

* Fix closed-sink tests and remove unrelated swap-source.test.ts

- Remove parameters from ClosedSink calls (sink doesn't take parameters)
- Remove redundant test for source reference preservation
- Remove unrelated swap-source.test.ts file from closed-sink PR
- Simplify tests to focus on actual ClosedSink behavior
- Clean up test structure and remove unnecessary complexity

* Restore swap-source.test.ts from master branch

This file exists in master but was accidentally removed from this branch.
Restoring it to maintain consistency with master branch.

* Simplify closed-sink tests by removing redundant cases

- Remove redundant test for basic sink invocation
- Remove redundant test for multiple calls
- Remove redundant test for separate bindings
- Keep only essential tests that add value
- Focus on core functionality rather than exhaustive parameter testing

---------

Co-authored-by: 3mindedscholar <10akhil.t@gmail.com>
Co-authored-by: TanmayRanaware <tanmayranware2000@gmail.com>

Author: 3 people

src/sinks/closed-sink.test.ts

@@ -0,0 +1,221 @@
+import { MockElement, expectSinkBindingConfiguration } from '../test-support';
+import { Closed, ClosedSink, CLOSED_SINK_TAG } from './closed-sink';
+import { SINK_TAG } from '../constants';
+
+// Mock HTMLDialogElement for testing
+interface MockDialogElement extends HTMLElement {
+    open: boolean;
+    close: jest.MockedFunction<() => void>;
+    show: jest.MockedFunction<() => void>;
+    showModal: jest.MockedFunction<() => void>;
+}
+
+const MockDialogElement = (props?: Record<string, any>): MockDialogElement => {
+    const closeSpy = jest.fn();
+    const showSpy = jest.fn();
+    const showModalSpy = jest.fn();
+    
+    return <MockDialogElement>{
+        ...MockElement(props),
+        open: false,
+        close: closeSpy,
+        show: showSpy,
+        showModal: showModalSpy,
+        tagName: 'DIALOG',
+        ...props,
+    };
+};
+
+describe('Closed Sink', () => {
+
+    describe('Given a ClosedSink function', () => {
+
+        it('creates a sink that calls dialog.close() when called', () => {
+            const dialog = MockDialogElement();
+            const sink = ClosedSink(dialog);
+
+            expect(typeof sink).toBe('function');
+            expect(dialog.close).not.toHaveBeenCalled();
+
+            // Each call to sink() results in dialog.close() being called
+            sink();
+            expect(dialog.close).toHaveBeenCalledTimes(1);
+
+            sink();
+            expect(dialog.close).toHaveBeenCalledTimes(2);
+        });
+
+        it('binds the close method correctly to dialog element', () => {
+            const dialog = MockDialogElement();
+            const sink = ClosedSink(dialog);
+
+            sink();
+
+            expect(dialog.close).toHaveBeenCalledWith();
+            expect(dialog.close).toHaveBeenCalledTimes(1);
+        });
+
+    });
+
+    describe('Given a Closed explicit sink', () => {
+
+        it('creates sink binding configuration with correct properties', () => {
+            const source = true;
+            const config = Closed(source);
+
+            expectSinkBindingConfiguration(config, SINK_TAG, CLOSED_SINK_TAG, source, ClosedSink);
+        });
+
+        it('handles boolean attribute values', () => {
+            const trueConfig = Closed(true);
+            const falseConfig = Closed(false);
+
+            expect(trueConfig.source).toBe(true);
+            expect(falseConfig.source).toBe(false);
+        });
+
+        it('handles promise sources', () => {
+            const promiseSource = Promise.resolve(true);
+            const config = Closed(promiseSource);
+
+            expect(config.source).toBe(promiseSource);
+        });
+
+        it('handles observable sources', () => {
+            const { Subject } = require('rxjs');
+            const subjectSource = new Subject();
+            const config = Closed(subjectSource);
+
+            expect(config.source).toBe(subjectSource);
+        });
+
+    });
+
+    describe('Given dialog closing functionality', () => {
+
+        it('closes dialog when sink is invoked', () => {
+            const dialog = MockDialogElement();
+            const config = Closed(true);
+            const sink = config.sink(dialog);
+
+            sink();
+
+            expect(dialog.close).toHaveBeenCalledTimes(1);
+        });
+
+    });
+
+    describe('Given future/promise sources', () => {
+
+        it('handles resolved promise sources', async () => {
+            const dialog = MockDialogElement();
+            const promiseSource = Promise.resolve(true);
+            const config = Closed(promiseSource);
+            const sink = config.sink(dialog);
+
+            sink();
+
+            // Wait for promise to resolve
+            await new Promise(resolve => setTimeout(resolve, 10));
+
+            expect(dialog.close).toHaveBeenCalledTimes(1);
+        });
+
+        it('handles rejected promise sources', async () => {
+            const dialog = MockDialogElement();
+            const promiseSource = Promise.reject(new Error('Test error'));
+            const config = Closed(promiseSource);
+            const sink = config.sink(dialog);
+
+            sink();
+
+            // Wait for promise to reject
+            await new Promise(resolve => setTimeout(resolve, 10));
+
+            expect(dialog.close).toHaveBeenCalledTimes(1);
+        });
+
+    });
+
+    describe('Given observable sources', () => {
+
+        it('handles Subject sources', () => {
+            const { Subject } = require('rxjs');
+            const subject = new Subject();
+            const config = Closed(subject);
+
+            expect(config.source).toBe(subject);
+            expect(config.type).toBe(SINK_TAG);
+            expect(config.t).toBe(CLOSED_SINK_TAG);
+        });
+
+        it('handles BehaviorSubject sources', () => {
+            const { BehaviorSubject } = require('rxjs');
+            const behaviorSubject = new BehaviorSubject(false);
+            const config = Closed(behaviorSubject);
+
+            expect(config.source).toBe(behaviorSubject);
+        });
+
+    });
+
+    describe('Given edge cases', () => {
+
+        it('handles complex object sources', () => {
+            const dialog = MockDialogElement();
+            const complexSource = { nested: { value: true } };
+            const config = Closed(complexSource);
+
+            expect(config.source).toBe(complexSource);
+        });
+
+        it('handles array sources', () => {
+            const dialog = MockDialogElement();
+            const arraySource = [true, false, 1, 0];
+            const config = Closed(arraySource);
+
+            expect(config.source).toBe(arraySource);
+        });
+
+    });
+
+    describe('Given sink configuration structure', () => {
+
+        it('returns correct sink binding configuration type', () => {
+            const source = true;
+            const config = Closed(source);
+
+            expectSinkBindingConfiguration(config, SINK_TAG, CLOSED_SINK_TAG, source, ClosedSink);
+        });
+
+        it('maintains proper TypeScript types', () => {
+            const source = true;
+            const config = Closed(source);
+
+            // These should compile without errors if types are correct
+            expect(typeof config.type).toBe('string');
+            expect(typeof config.t).toBe('string');
+            expect(typeof config.sink).toBe('function');
+        });
+
+    });
+
+    describe('Given integration scenarios', () => {
+
+        it('works with multiple dialog elements', () => {
+            const dialog1 = MockDialogElement();
+            const dialog2 = MockDialogElement();
+            
+            const sink1 = ClosedSink(dialog1);
+            const sink2 = ClosedSink(dialog2);
+
+            sink1();
+            sink2();
+
+            expect(dialog1.close).toHaveBeenCalledTimes(1);
+            expect(dialog2.close).toHaveBeenCalledTimes(1);
+        });
+
+    });
+
+});

src/test-support.ts

@@ -101,3 +101,17 @@ export const MockEvent = <E extends Event>(name: string, data: Partial<E>) =>
    type: name,
    ...data,
  });
+
+// Sink binding configuration test helper
+export const expectSinkBindingConfiguration = (
+    config: any,
+    expectedType: string,
+    expectedTag: string,
+    expectedSource: any,
+    expectedSink: any
+) => {
+    expect(config.type).toBe(expectedType);
+    expect(config.t).toBe(expectedTag);
+    expect(config.source).toBe(expectedSource);
+    expect(config.sink).toBe(expectedSink);
+};