@tldraw/sync-core 5.2.0-next.ee0fa4d6244f → 5.2.0

package/src/lib/interval.test.ts

@@ -0,0 +1,43 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
+import { interval } from './interval'
+
+describe('interval', () => {
+	beforeEach(() => {
+		vi.useFakeTimers()
+	})
+
+	afterEach(() => {
+		vi.useRealTimers()
+	})
+
+	it('[IN1] invokes the callback every N milliseconds', () => {
+		const cb = vi.fn()
+		const dispose = interval(cb, 100)
+
+		expect(cb).not.toHaveBeenCalled()
+
+		vi.advanceTimersByTime(99)
+		expect(cb).not.toHaveBeenCalled()
+
+		vi.advanceTimersByTime(1)
+		expect(cb).toHaveBeenCalledTimes(1)
+
+		vi.advanceTimersByTime(300)
+		expect(cb).toHaveBeenCalledTimes(4)
+
+		dispose()
+	})
+
+	it('[IN1] the dispose function stops the interval', () => {
+		const cb = vi.fn()
+		const dispose = interval(cb, 100)
+
+		vi.advanceTimersByTime(250)
+		expect(cb).toHaveBeenCalledTimes(2)
+
+		dispose()
+
+		vi.advanceTimersByTime(1000)
+		expect(cb).toHaveBeenCalledTimes(2)
+	})
+})

package/src/lib/protocol.test.ts

@@ -0,0 +1,43 @@
+import { describe, expect, it } from 'vitest'
+import { getTlsyncProtocolVersion } from './protocol'
+import { TLRemoteSyncError } from './TLRemoteSyncError'
+import { TLSyncErrorCloseEventCode, TLSyncErrorCloseEventReason } from './TLSyncClient'
+
+describe('protocol constants and errors', () => {
+	it('[PV1] getTlsyncProtocolVersion() returns 8', () => {
+		expect(getTlsyncProtocolVersion()).toBe(8)
+	})
+
+	it('[PV2] TLSyncErrorCloseEventCode is 4099', () => {
+		expect(TLSyncErrorCloseEventCode).toBe(4099)
+	})
+
+	describe('TLRemoteSyncError', () => {
+		it('[PV3] has name RemoteSyncError', () => {
+			expect(new TLRemoteSyncError(TLSyncErrorCloseEventReason.FORBIDDEN).name).toBe(
+				'RemoteSyncError'
+			)
+		})
+
+		it('[PV3] formats the message as "sync error: <reason>" and exposes .reason', () => {
+			const error = new TLRemoteSyncError(TLSyncErrorCloseEventReason.NOT_AUTHENTICATED)
+			expect(error.message).toBe('sync error: NOT_AUTHENTICATED')
+			expect(error.reason).toBe('NOT_AUTHENTICATED')
+			expect(error).toBeInstanceOf(Error)
+		})
+
+		it('[PV3] works with every TLSyncErrorCloseEventReason value', () => {
+			for (const reason of Object.values(TLSyncErrorCloseEventReason)) {
+				const error = new TLRemoteSyncError(reason)
+				expect(error.reason).toBe(reason)
+				expect(error.message).toBe(`sync error: ${reason}`)
+			}
+		})
+
+		it('[PV3] works with custom reason strings', () => {
+			const error = new TLRemoteSyncError('ROOM_ARCHIVED')
+			expect(error.reason).toBe('ROOM_ARCHIVED')
+			expect(error.message).toBe('sync error: ROOM_ARCHIVED')
+		})
+	})
+})

package/src/lib/recordDiff.test.ts

@@ -0,0 +1,159 @@
+import { BaseRecord, RecordId, createRecordType } from '@tldraw/store'
+import { vi } from 'vitest'
+import { ValueOpType, type ObjectDiff } from './diff'
+import { applyAndDiffRecord, diffAndValidateRecord, validateRecord } from './recordDiff'
+import { TLSyncError, TLSyncErrorCloseEventReason } from './TLSyncClient'
+
+interface TestRecord extends BaseRecord<'test', RecordId<TestRecord>> {
+	value: number
+	text: string
+}
+
+function setup() {
+	const validate = vi.fn((record: unknown): TestRecord => {
+		const r = record as TestRecord
+		if (r.value < 0) {
+			throw new Error('value must not be negative')
+		}
+		return r
+	})
+	const recordType = createRecordType<TestRecord>('test', {
+		validator: { validate },
+		scope: 'document',
+	})
+	const record = (value: number, text = 'hello'): TestRecord => ({
+		id: 'test:a' as TestRecord['id'],
+		typeName: 'test',
+		value,
+		text,
+	})
+	return { validate, recordType, record }
+}
+
+describe('diffAndValidateRecord (RV1, RV2)', () => {
+	it('[RV1] returns undefined when the records produce no diff', () => {
+		const { recordType, record } = setup()
+		expect(diffAndValidateRecord(record(1), record(1), recordType)).toBeUndefined()
+	})
+
+	it('[RV1] does not call the validator when there is no diff', () => {
+		const { validate, recordType, record } = setup()
+		const prev = record(1)
+
+		diffAndValidateRecord(prev, prev, recordType)
+		diffAndValidateRecord(prev, record(1), recordType)
+
+		expect(validate).not.toHaveBeenCalled()
+	})
+
+	it('[RV2] validates the new state when there is a diff', () => {
+		const { validate, recordType, record } = setup()
+		const next = record(2)
+
+		const diff = diffAndValidateRecord(record(1), next, recordType)
+
+		expect(diff).toEqual({ value: [ValueOpType.Put, 2] })
+		expect(validate).toHaveBeenCalledTimes(1)
+		expect(validate).toHaveBeenCalledWith(next)
+	})
+
+	it('[RV2] rethrows a validator throw as TLSyncError with reason INVALID_RECORD', () => {
+		const { recordType, record } = setup()
+
+		let error: unknown
+		try {
+			diffAndValidateRecord(record(1), record(-1), recordType)
+		} catch (e) {
+			error = e
+		}
+
+		expect(error).toBeInstanceOf(TLSyncError)
+		expect((error as TLSyncError).reason).toBe(TLSyncErrorCloseEventReason.INVALID_RECORD)
+		expect((error as TLSyncError).message).toBe('value must not be negative')
+	})
+})
+
+describe('applyAndDiffRecord (RV3)', () => {
+	it('[RV3] returns undefined when the patch applies to a reference-identical result', () => {
+		const { validate, recordType, record } = setup()
+		const prev = record(1)
+		// a put of the current value has no effect (AD2), so applyObjectDiff
+		// returns the same reference
+		const patch: ObjectDiff = { value: [ValueOpType.Put, 1] }
+
+		expect(applyAndDiffRecord(prev, patch, recordType)).toBeUndefined()
+		expect(validate).not.toHaveBeenCalled()
+	})
+
+	it('[RV3] returns the recomputed effective diff and the new state', () => {
+		const { recordType, record } = setup()
+		const prev = record(1)
+		const patch: ObjectDiff = { value: [ValueOpType.Put, 2] }
+
+		const result = applyAndDiffRecord(prev, patch, recordType)
+
+		expect(result).toBeDefined()
+		const [actualDiff, newState] = result!
+		expect(actualDiff).toEqual({ value: [ValueOpType.Put, 2] })
+		expect(newState).toEqual(record(2))
+		// the input is not mutated (AD1)
+		expect(prev).toEqual(record(1))
+	})
+
+	it('[RV3] drops no-op ops from the returned diff, keeping only the real change', () => {
+		const { recordType, record } = setup()
+		const prev = record(1, 'hello')
+		// the text put is a no-op (same value); the value put is a real change
+		const patch: ObjectDiff = {
+			text: [ValueOpType.Put, 'hello'],
+			value: [ValueOpType.Put, 5],
+		}
+
+		const result = applyAndDiffRecord(prev, patch, recordType)
+
+		expect(result).toBeDefined()
+		const [actualDiff, newState] = result!
+		expect(actualDiff).toEqual({ value: [ValueOpType.Put, 5] })
+		expect(newState).toEqual(record(5, 'hello'))
+	})
+
+	it('[RV3] [RV2] validates the patched state and wraps validator throws', () => {
+		const { recordType, record } = setup()
+		const patch: ObjectDiff = { value: [ValueOpType.Put, -10] }
+
+		let error: unknown
+		try {
+			applyAndDiffRecord(record(1), patch, recordType)
+		} catch (e) {
+			error = e
+		}
+
+		expect(error).toBeInstanceOf(TLSyncError)
+		expect((error as TLSyncError).reason).toBe(TLSyncErrorCloseEventReason.INVALID_RECORD)
+	})
+})
+
+describe('validateRecord (RV4)', () => {
+	it('[RV4] returns normally for a valid record', () => {
+		const { validate, recordType, record } = setup()
+		const state = record(1)
+
+		expect(() => validateRecord(state, recordType)).not.toThrow()
+		expect(validate).toHaveBeenCalledWith(state)
+	})
+
+	it('[RV4] wraps a validator throw as TLSyncError with reason INVALID_RECORD', () => {
+		const { recordType, record } = setup()
+
+		let error: unknown
+		try {
+			validateRecord(record(-1), recordType)
+		} catch (e) {
+			error = e
+		}
+
+		expect(error).toBeInstanceOf(TLSyncError)
+		expect((error as TLSyncError).reason).toBe(TLSyncErrorCloseEventReason.INVALID_RECORD)
+		expect((error as TLSyncError).message).toBe('value must not be negative')
+	})
+})