@zeix/cause-effect 0.17.0 → 0.17.2

package/test/ref.test.ts

@@ -0,0 +1,381 @@
+import { expect, mock, test } from 'bun:test'
+import { isRef, Ref } from '../src/classes/ref'
+import { createEffect } from '../src/effect'
+import { HOOK_WATCH } from '../src/system'
+
+test('Ref - basic functionality', () => {
+	const obj = { name: 'test', value: 42 }
+	const ref = new Ref(obj)
+
+	expect(ref.get()).toBe(obj)
+	expect(ref[Symbol.toStringTag]).toBe('Ref')
+})
+
+test('Ref - isRef type guard', () => {
+	const ref = new Ref({ test: true })
+	const notRef = { test: true }
+
+	expect(isRef(ref)).toBe(true)
+	expect(isRef(notRef)).toBe(false)
+	expect(isRef(null)).toBe(false)
+	expect(isRef(undefined)).toBe(false)
+})
+
+test('Ref - validation with guard function', () => {
+	const isConfig = (
+		value: unknown,
+	): value is { host: string; port: number } =>
+		typeof value === 'object' &&
+		value !== null &&
+		'host' in value &&
+		'port' in value &&
+		typeof value.host === 'string' &&
+		typeof value.port === 'number'
+
+	const validConfig = { host: 'localhost', port: 3000 }
+	const invalidConfig = { host: 'localhost' } // missing port
+
+	expect(() => new Ref(validConfig, isConfig)).not.toThrow()
+	expect(() => new Ref(invalidConfig, isConfig)).toThrow()
+})
+
+test('Ref - reactive subscriptions', () => {
+	const server = { status: 'offline', connections: 0 }
+	const ref = new Ref(server)
+
+	let effectRunCount = 0
+	let lastStatus: string = ''
+
+	createEffect(() => {
+		const current = ref.get()
+		lastStatus = current.status
+		effectRunCount++
+	})
+
+	expect(effectRunCount).toBe(1)
+	expect(lastStatus).toBe('offline')
+
+	// Simulate external change without going through reactive system
+	server.status = 'online'
+	server.connections = 5
+
+	// Effect shouldn't re-run yet (reference hasn't changed)
+	expect(effectRunCount).toBe(1)
+
+	// Notify that the external object has changed
+	ref.notify()
+
+	expect(effectRunCount).toBe(2)
+	expect(lastStatus).toBe('online')
+})
+
+test('Ref - notify triggers watchers even with same reference', () => {
+	const fileObj = { path: '/test.txt', size: 100, modified: Date.now() }
+	const ref = new Ref(fileObj)
+
+	const mockCallback = mock(() => {})
+
+	createEffect(() => {
+		ref.get()
+		mockCallback()
+	})
+
+	expect(mockCallback).toHaveBeenCalledTimes(1)
+
+	// Simulate file modification (same object reference, different content)
+	fileObj.size = 200
+	fileObj.modified = Date.now()
+
+	// Notify about external change
+	ref.notify()
+
+	expect(mockCallback).toHaveBeenCalledTimes(2)
+
+	// Multiple notifies should trigger multiple times
+	ref.notify()
+	expect(mockCallback).toHaveBeenCalledTimes(3)
+})
+
+test('Ref - multiple effects with same ref', () => {
+	const database = { connected: false, queries: 0 }
+	const ref = new Ref(database)
+
+	const effect1Mock = mock(() => {})
+	const effect2Mock = mock((_connected: boolean) => {})
+
+	createEffect(() => {
+		ref.get()
+		effect1Mock()
+	})
+
+	createEffect(() => {
+		const db = ref.get()
+		effect2Mock(db.connected)
+	})
+
+	expect(effect1Mock).toHaveBeenCalledTimes(1)
+	expect(effect2Mock).toHaveBeenCalledTimes(1)
+	expect(effect2Mock).toHaveBeenCalledWith(false)
+
+	// Simulate database connection change
+	database.connected = true
+	database.queries = 10
+	ref.notify()
+
+	expect(effect1Mock).toHaveBeenCalledTimes(2)
+	expect(effect2Mock).toHaveBeenCalledTimes(2)
+	expect(effect2Mock).toHaveBeenLastCalledWith(true)
+})
+
+test('Ref - with Bun.file() scenario', () => {
+	// Mock a file-like object that could change externally
+	const fileRef = {
+		name: 'config.json',
+		size: 1024,
+		lastModified: Date.now(),
+		// Simulate file methods
+		exists: () => true,
+		text: () => Promise.resolve('{"version": "1.0"}'),
+	}
+
+	const ref = new Ref(fileRef)
+
+	let sizeChanges = 0
+	createEffect(() => {
+		const file = ref.get()
+		if (file.size > 1000) sizeChanges++
+	})
+
+	expect(sizeChanges).toBe(1) // Initial run
+
+	// Simulate file growing (external change)
+	fileRef.size = 2048
+	fileRef.lastModified = Date.now()
+	ref.notify()
+
+	expect(sizeChanges).toBe(2) // Effect re-ran and condition still met
+
+	// Simulate file shrinking
+	fileRef.size = 500
+	ref.notify()
+
+	expect(sizeChanges).toBe(2) // Effect re-ran but condition no longer met
+})
+
+test('Ref - validation errors', () => {
+	// @ts-expect-error deliberatly provoked error
+	expect(() => new Ref(null)).toThrow()
+	// @ts-expect-error deliberatly provoked error
+	expect(() => new Ref(undefined)).toThrow()
+})
+
+test('Ref - server config object scenario', () => {
+	const config = {
+		host: 'localhost',
+		port: 3000,
+		ssl: false,
+		maxConnections: 100,
+	}
+
+	const configRef = new Ref(config)
+	const connectionAttempts: string[] = []
+
+	createEffect(() => {
+		const cfg = configRef.get()
+		const protocol = cfg.ssl ? 'https' : 'http'
+		connectionAttempts.push(`${protocol}://${cfg.host}:${cfg.port}`)
+	})
+
+	expect(connectionAttempts).toEqual(['http://localhost:3000'])
+
+	// Simulate config reload from file/environment
+	config.ssl = true
+	config.port = 8443
+	configRef.notify()
+
+	expect(connectionAttempts).toEqual([
+		'http://localhost:3000',
+		'https://localhost:8443',
+	])
+})
+
+test('Ref - handles complex nested objects', () => {
+	const apiResponse = {
+		status: 200,
+		data: {
+			users: [{ id: 1, name: 'Alice' }],
+			pagination: { page: 1, total: 1 },
+		},
+		headers: { 'content-type': 'application/json' },
+	}
+
+	const ref = new Ref(apiResponse)
+	let userCount = 0
+
+	createEffect(() => {
+		const response = ref.get()
+		userCount = response.data.users.length
+	})
+
+	expect(userCount).toBe(1)
+
+	// Simulate API response update
+	apiResponse.data.users.push({ id: 2, name: 'Bob' })
+	apiResponse.data.pagination.total = 2
+	ref.notify()
+
+	expect(userCount).toBe(2)
+})
+
+test('Ref - HOOK_WATCH lazy resource management', async () => {
+	// 1. Create Ref with current Date
+	const currentDate = new Date()
+	const ref = new Ref(currentDate)
+
+	let counter = 0
+	let intervalId: Timer | undefined
+
+	// 2. Add HOOK_WATCH callback that starts setInterval and returns cleanup
+	const cleanupHookCallback = ref.on(HOOK_WATCH, () => {
+		intervalId = setInterval(() => {
+			counter++
+		}, 10) // Use short interval for faster test
+
+		// Return cleanup function to clear interval
+		return () => {
+			if (intervalId) {
+				clearInterval(intervalId)
+				intervalId = undefined
+			}
+		}
+	})
+
+	// 3. Counter should not be running yet
+	expect(counter).toBe(0)
+
+	// Wait a bit to ensure counter doesn't increment
+	await new Promise(resolve => setTimeout(resolve, 50))
+	expect(counter).toBe(0)
+	expect(intervalId).toBeUndefined()
+
+	// 4. Effect subscribes by .get()ting the signal value
+	const effectCleanup = createEffect(() => {
+		ref.get()
+	})
+
+	// 5. Counter should now be running
+	await new Promise(resolve => setTimeout(resolve, 50))
+	expect(counter).toBeGreaterThan(0)
+	expect(intervalId).toBeDefined()
+
+	// 6. Call effect cleanup, which should stop internal watcher and unsubscribe
+	effectCleanup()
+	const counterAfterStop = counter
+
+	// 7. Ref signal should call #unwatch() and counter should stop incrementing
+	await new Promise(resolve => setTimeout(resolve, 50))
+	expect(counter).toBe(counterAfterStop) // Counter should not have incremented
+	expect(intervalId).toBeUndefined() // Interval should be cleared
+
+	// Clean up hook callback registration
+	cleanupHookCallback()
+})
+
+test('Ref - HOOK_WATCH exception handling', async () => {
+	const ref = new Ref({ test: 'value' })
+
+	// Mock console.error to capture error logs
+	const originalError = console.error
+	const errorSpy = mock(() => {})
+	console.error = errorSpy
+
+	let successfulCallbackCalled = false
+	let throwingCallbackCalled = false
+
+	// Add callback that throws an exception
+	const cleanup1 = ref.on(HOOK_WATCH, () => {
+		throwingCallbackCalled = true
+		throw new Error('Test error in HOOK_WATCH callback')
+	})
+
+	// Add callback that works normally
+	const cleanup2 = ref.on(HOOK_WATCH, () => {
+		successfulCallbackCalled = true
+		return () => {
+			// cleanup function
+		}
+	})
+
+	// Subscribe to trigger HOOK_WATCH callbacks
+	const effectCleanup = createEffect(() => {
+		ref.get()
+	})
+
+	// Both callbacks should have been called despite the exception
+	expect(throwingCallbackCalled).toBe(true)
+	expect(successfulCallbackCalled).toBe(true)
+
+	// Error should have been logged
+	expect(errorSpy).toHaveBeenCalledWith(
+		'Error in effect callback:',
+		expect.any(Error),
+	)
+
+	// Cleanup
+	effectCleanup()
+	cleanup1()
+	cleanup2()
+	console.error = originalError
+})
+
+test('Ref - cleanup function exception handling', async () => {
+	const ref = new Ref({ test: 'value' })
+
+	// Mock console.error to capture error logs
+	const originalError = console.error
+	const errorSpy = mock(() => {})
+	console.error = errorSpy
+
+	let cleanup1Called = false
+	let cleanup2Called = false
+
+	// Add callbacks with cleanup functions, one throws
+	const hookCleanup1 = ref.on(HOOK_WATCH, () => {
+		return () => {
+			cleanup1Called = true
+			throw new Error('Test error in cleanup function')
+		}
+	})
+
+	const hookCleanup2 = ref.on(HOOK_WATCH, () => {
+		return () => {
+			cleanup2Called = true
+		}
+	})
+
+	// Subscribe and then unsubscribe to trigger cleanup
+	const effectCleanup = createEffect(() => {
+		ref.get()
+	})
+
+	// Unsubscribe to trigger cleanup functions
+	effectCleanup()
+
+	// Wait a bit for cleanup to complete
+	await new Promise(resolve => setTimeout(resolve, 10))
+
+	// Both cleanup functions should have been called despite the exception
+	expect(cleanup1Called).toBe(true)
+	expect(cleanup2Called).toBe(true)
+
+	// Error should have been logged
+	expect(errorSpy).toHaveBeenCalledWith(
+		'Error in effect cleanup:',
+		expect.any(Error),
+	)
+
+	// Cleanup
+	hookCleanup1()
+	hookCleanup2()
+	console.error = originalError
+})

package/test/state.test.ts

@@ -125,12 +125,12 @@ describe('State', () => {
 				expect(() => {
 					// @ts-expect-error - Testing invalid input
 					new State(null)
-				}).toThrow('Nullish signal values are not allowed in state')
+				}).toThrow('Nullish signal values are not allowed in State')
 
 				expect(() => {
 					// @ts-expect-error - Testing invalid input
 					new State(undefined)
-				}).toThrow('Nullish signal values are not allowed in state')
+				}).toThrow('Nullish signal values are not allowed in State')
 			})
 
 			test('should throw NullishSignalValueError when newValue is nullish in set()', () => {
@@ -139,12 +139,12 @@ describe('State', () => {
 				expect(() => {
 					// @ts-expect-error - Testing invalid input
 					state.set(null)
-				}).toThrow('Nullish signal values are not allowed in state')
+				}).toThrow('Nullish signal values are not allowed in State')
 
 				expect(() => {
 					// @ts-expect-error - Testing invalid input
 					state.set(undefined)
-				}).toThrow('Nullish signal values are not allowed in state')
+				}).toThrow('Nullish signal values are not allowed in State')
 			})
 
 			test('should throw specific error types for nullish values', () => {
@@ -156,7 +156,7 @@ describe('State', () => {
 					expect(error).toBeInstanceOf(TypeError)
 					expect(error.name).toBe('NullishSignalValueError')
 					expect(error.message).toBe(
-						'Nullish signal values are not allowed in state',
+						'Nullish signal values are not allowed in State',
 					)
 				}
 
@@ -169,7 +169,7 @@ describe('State', () => {
 					expect(error).toBeInstanceOf(TypeError)
 					expect(error.name).toBe('NullishSignalValueError')
 					expect(error.message).toBe(
-						'Nullish signal values are not allowed in state',
+						'Nullish signal values are not allowed in State',
 					)
 				}
 			})
@@ -213,22 +213,22 @@ describe('State', () => {
 				expect(() => {
 					// @ts-expect-error - Testing invalid input
 					state.update(null)
-				}).toThrow('Invalid state update callback null')
+				}).toThrow('Invalid State update callback null')
 
 				expect(() => {
 					// @ts-expect-error - Testing invalid input
 					state.update(undefined)
-				}).toThrow('Invalid state update callback undefined')
+				}).toThrow('Invalid State update callback undefined')
 
 				expect(() => {
 					// @ts-expect-error - Testing invalid input
 					state.update('not a function')
-				}).toThrow('Invalid state update callback "not a function"')
+				}).toThrow('Invalid State update callback "not a function"')
 
 				expect(() => {
 					// @ts-expect-error - Testing invalid input
 					state.update(42)
-				}).toThrow('Invalid state update callback 42')
+				}).toThrow('Invalid State update callback 42')
 			})
 
 			test('should throw specific error type for non-function updater', () => {
@@ -242,7 +242,7 @@ describe('State', () => {
 					expect(error).toBeInstanceOf(TypeError)
 					expect(error.name).toBe('InvalidCallbackError')
 					expect(error.message).toBe(
-						'Invalid state update callback null',
+						'Invalid State update callback null',
 					)
 				}
 			})
@@ -266,12 +266,12 @@ describe('State', () => {
 				expect(() => {
 					// @ts-expect-error - Testing invalid return value
 					state.update(() => null)
-				}).toThrow('Nullish signal values are not allowed in state')
+				}).toThrow('Nullish signal values are not allowed in State')
 
 				expect(() => {
 					// @ts-expect-error - Testing invalid return value
 					state.update(() => undefined)
-				}).toThrow('Nullish signal values are not allowed in state')
+				}).toThrow('Nullish signal values are not allowed in State')
 
 				// State should remain unchanged after error
 				expect(state.get()).toBe(42)