packages/sync/src/providers/http-polling/test/utils.test.ts - trunk - githubmirror/gutenberg

packages/sync/src/providers/http-polling/test/utils.test.ts
789 строк20 KB
Marco Ciampini
ESLint: Remove legacy import suppressions (#81338)
07 авг 2026, 15:52
07 авг 2026, 15:528181ec4
import { describe, expect, it, jest, beforeEach } from '@jest/globals';
// Mock @wordpress/api-fetch
jest.mock( '@wordpress/api-fetch', () => ( {
	__esModule: true,
	default: jest.fn(),
} ) );
import apiFetch from '@wordpress/api-fetch';
import { SyncUpdateType } from '../types';
import { MAX_UPDATE_SIZE_IN_BYTES } from '../config';
import {
	base64ToUint8Array,
	createSyncUpdate,
	createUpdateQueue,
	intValueOrDefault,
	postSyncUpdate,
	rotateWindow,
	uint8ArrayToBase64,
} from '../utils';

const mockApiFetch = jest.mocked( apiFetch );
const SERVER_MAX_UPDATE_DATA_SIZE_IN_BYTES = 1024 * 1024;

describe( 'http-polling utils', () => {
	describe( 'SyncUpdateType', () => {
		it( 'has the expected enum values', () => {
			expect( SyncUpdateType.COMPACTION ).toBe( 'compaction' );
			expect( SyncUpdateType.SYNC_STEP_1 ).toBe( 'sync_step1' );
			expect( SyncUpdateType.SYNC_STEP_2 ).toBe( 'sync_step2' );
			expect( SyncUpdateType.UPDATE ).toBe( 'update' );
		} );
	} );

	describe( 'uint8ArrayToBase64', () => {
		it( 'converts an empty array', () => {
			const input = new Uint8Array( [] );
			const result = uint8ArrayToBase64( input );

			expect( result ).toBe( '' );
		} );

		it( 'converts a simple byte array', () => {
			// "Hello" in ASCII
			const input = new Uint8Array( [ 72, 101, 108, 108, 111 ] );
			const result = uint8ArrayToBase64( input );

			expect( result ).toBe( 'SGVsbG8=' );
		} );

		it( 'converts binary data with all byte values', () => {
			const input = new Uint8Array( [ 0, 127, 128, 255 ] );
			const result = uint8ArrayToBase64( input );

			// Verify round-trip
			const decoded = base64ToUint8Array( result );
			expect( decoded ).toEqual( input );
		} );

		it( 'handles large arrays', () => {
			const input = new Uint8Array( 1000 );
			for ( let i = 0; i < 1000; i++ ) {
				input[ i ] = i % 256;
			}

			const result = uint8ArrayToBase64( input );
			const decoded = base64ToUint8Array( result );

			expect( decoded ).toEqual( input );
		} );
	} );

	describe( 'base64ToUint8Array', () => {
		it( 'converts an empty string', () => {
			const result = base64ToUint8Array( '' );

			expect( result ).toEqual( new Uint8Array( [] ) );
		} );

		it( 'converts a simple base64 string', () => {
			// "SGVsbG8=" is "Hello" in base64
			const result = base64ToUint8Array( 'SGVsbG8=' );

			expect( result ).toEqual(
				new Uint8Array( [ 72, 101, 108, 108, 111 ] )
			);
		} );

		it( 'handles base64 without padding', () => {
			// Some base64 implementations omit padding
			const withPadding = base64ToUint8Array( 'YQ==' );
			const withoutPadding = base64ToUint8Array( 'YQ' );

			expect( withPadding ).toEqual( new Uint8Array( [ 97 ] ) ); // 'a'
			expect( withoutPadding ).toEqual( new Uint8Array( [ 97 ] ) );
		} );
	} );

	describe( 'base64 round-trip', () => {
		it( 'maintains data integrity through encode/decode cycle', () => {
			const testCases = [
				new Uint8Array( [] ),
				new Uint8Array( [ 0 ] ),
				new Uint8Array( [ 255 ] ),
				new Uint8Array( [ 1, 2, 3, 4, 5 ] ),
				new Uint8Array( [ 0, 0, 0, 0 ] ),
				new Uint8Array( [ 255, 255, 255, 255 ] ),
			];

			for ( const original of testCases ) {
				const encoded = uint8ArrayToBase64( original );
				const decoded = base64ToUint8Array( encoded );
				expect( decoded ).toEqual( original );
			}
		} );

		it( 'handles random binary data', () => {
			const original = new Uint8Array( 256 );
			for ( let i = 0; i < 256; i++ ) {
				original[ i ] = i;
			}

			const encoded = uint8ArrayToBase64( original );
			const decoded = base64ToUint8Array( encoded );

			expect( decoded ).toEqual( original );
		} );
	} );

	describe( 'createSyncUpdate', () => {
		it( 'keeps the largest allowed raw update within the server encoded update limit', () => {
			const result = createSyncUpdate(
				new Uint8Array( MAX_UPDATE_SIZE_IN_BYTES ),
				SyncUpdateType.UPDATE
			);

			expect( result.data.length ).toBeLessThanOrEqual(
				SERVER_MAX_UPDATE_DATA_SIZE_IN_BYTES
			);
		} );

		it( 'creates a typed update with UPDATE type', () => {
			const data = new Uint8Array( [ 1, 2, 3 ] );
			const result = createSyncUpdate( data, SyncUpdateType.UPDATE );

			expect( result.type ).toBe( SyncUpdateType.UPDATE );
			expect( result.data ).toBe( uint8ArrayToBase64( data ) );
		} );

		it( 'creates a typed update with COMPACTION type', () => {
			const data = new Uint8Array( [ 4, 5, 6 ] );
			const result = createSyncUpdate( data, SyncUpdateType.COMPACTION );

			expect( result.type ).toBe( SyncUpdateType.COMPACTION );
			expect( result.data ).toBe( uint8ArrayToBase64( data ) );
		} );

		it( 'creates a typed update with SYNC_STEP_1 type', () => {
			const data = new Uint8Array( [ 7, 8, 9 ] );
			const result = createSyncUpdate( data, SyncUpdateType.SYNC_STEP_1 );

			expect( result.type ).toBe( SyncUpdateType.SYNC_STEP_1 );
			expect( result.data ).toBe( uint8ArrayToBase64( data ) );
		} );

		it( 'creates a typed update with SYNC_STEP_2 type', () => {
			const data = new Uint8Array( [ 10, 11, 12 ] );
			const result = createSyncUpdate( data, SyncUpdateType.SYNC_STEP_2 );

			expect( result.type ).toBe( SyncUpdateType.SYNC_STEP_2 );
			expect( result.data ).toBe( uint8ArrayToBase64( data ) );
		} );

		it( 'handles empty data', () => {
			const data = new Uint8Array( [] );
			const result = createSyncUpdate( data, SyncUpdateType.UPDATE );

			expect( result.type ).toBe( SyncUpdateType.UPDATE );
			expect( result.data ).toBe( '' );
		} );
	} );

	describe( 'createUpdateQueue', () => {
		describe( 'initialization', () => {
			it( 'creates an empty queue by default', () => {
				const queue = createUpdateQueue();

				expect( queue.size() ).toBe( 0 );
			} );

			it( 'creates a queue with initial updates', () => {
				const initial = [
					createSyncUpdate(
						new Uint8Array( [ 1 ] ),
						SyncUpdateType.UPDATE
					),
					createSyncUpdate(
						new Uint8Array( [ 2 ] ),
						SyncUpdateType.UPDATE
					),
				];

				const queue = createUpdateQueue( initial );

				expect( queue.size() ).toBe( 2 );
			} );

			it( 'creates a paused queue by default', () => {
				const queue = createUpdateQueue();
				queue.add(
					createSyncUpdate(
						new Uint8Array( [ 1 ] ),
						SyncUpdateType.UPDATE
					)
				);

				// get() returns empty when paused
				expect( queue.get() ).toEqual( [] );
				expect( queue.size() ).toBe( 1 ); // still has the update
			} );

			it( 'can create an unpaused queue', () => {
				const queue = createUpdateQueue( [], false );
				queue.add(
					createSyncUpdate(
						new Uint8Array( [ 1 ] ),
						SyncUpdateType.UPDATE
					)
				);

				expect( queue.get() ).toHaveLength( 1 );
			} );

			it( 'does not modify the initial array', () => {
				const initial = [
					createSyncUpdate(
						new Uint8Array( [ 1 ] ),
						SyncUpdateType.UPDATE
					),
				];
				const initialCopy = [ ...initial ];

				const queue = createUpdateQueue( initial );
				queue.add(
					createSyncUpdate(
						new Uint8Array( [ 2 ] ),
						SyncUpdateType.UPDATE
					)
				);

				expect( initial ).toEqual( initialCopy );
			} );
		} );

		describe( 'add', () => {
			it( 'adds a single update to the queue', () => {
				const queue = createUpdateQueue();
				const update = createSyncUpdate(
					new Uint8Array( [ 1 ] ),
					SyncUpdateType.UPDATE
				);

				queue.add( update );

				expect( queue.size() ).toBe( 1 );
			} );

			it( 'adds multiple updates in order', () => {
				const queue = createUpdateQueue( [], false );
				const update1 = createSyncUpdate(
					new Uint8Array( [ 1 ] ),
					SyncUpdateType.UPDATE
				);
				const update2 = createSyncUpdate(
					new Uint8Array( [ 2 ] ),
					SyncUpdateType.UPDATE
				);

				queue.add( update1 );
				queue.add( update2 );

				const result = queue.get();
				expect( result ).toHaveLength( 2 );
				expect( result[ 0 ] ).toEqual( update1 );
				expect( result[ 1 ] ).toEqual( update2 );
			} );
		} );

		describe( 'addBulk', () => {
			it( 'adds multiple updates at once', () => {
				const queue = createUpdateQueue();
				const updates = [
					createSyncUpdate(
						new Uint8Array( [ 1 ] ),
						SyncUpdateType.UPDATE
					),
					createSyncUpdate(
						new Uint8Array( [ 2 ] ),
						SyncUpdateType.UPDATE
					),
					createSyncUpdate(
						new Uint8Array( [ 3 ] ),
						SyncUpdateType.UPDATE
					),
				];

				queue.addBulk( updates );

				expect( queue.size() ).toBe( 3 );
			} );

			it( 'handles empty array', () => {
				const queue = createUpdateQueue();

				queue.addBulk( [] );

				expect( queue.size() ).toBe( 0 );
			} );

			it( 'appends to existing updates', () => {
				const queue = createUpdateQueue();
				const existing = createSyncUpdate(
					new Uint8Array( [ 0 ] ),
					SyncUpdateType.UPDATE
				);
				const newUpdates = [
					createSyncUpdate(
						new Uint8Array( [ 1 ] ),
						SyncUpdateType.UPDATE
					),
					createSyncUpdate(
						new Uint8Array( [ 2 ] ),
						SyncUpdateType.UPDATE
					),
				];

				queue.add( existing );
				queue.addBulk( newUpdates );

				expect( queue.size() ).toBe( 3 );
			} );
		} );

		describe( 'get', () => {
			it( 'returns empty array when paused', () => {
				const queue = createUpdateQueue();
				const update = createSyncUpdate(
					new Uint8Array( [ 1 ] ),
					SyncUpdateType.UPDATE
				);

				queue.add( update );
				const result = queue.get();

				expect( result ).toEqual( [] );
				expect( queue.size() ).toBe( 1 ); // update still in queue
			} );

			it( 'returns and clears the queue when not paused', () => {
				const queue = createUpdateQueue( [], false );
				const update = createSyncUpdate(
					new Uint8Array( [ 1 ] ),
					SyncUpdateType.UPDATE
				);

				queue.add( update );
				const result = queue.get();

				expect( result ).toHaveLength( 1 );
				expect( result[ 0 ] ).toEqual( update );
				expect( queue.size() ).toBe( 0 );
				expect( queue.get() ).toEqual( [] );
			} );

			it( 'returns updates in FIFO order', () => {
				const queue = createUpdateQueue( [], false );
				const updates = [
					createSyncUpdate(
						new Uint8Array( [ 1 ] ),
						SyncUpdateType.SYNC_STEP_1
					),
					createSyncUpdate(
						new Uint8Array( [ 2 ] ),
						SyncUpdateType.UPDATE
					),
					createSyncUpdate(
						new Uint8Array( [ 3 ] ),
						SyncUpdateType.COMPACTION
					),
				];

				updates.forEach( ( u ) => queue.add( u ) );
				const result = queue.get();

				expect( result ).toEqual( updates );
			} );
		} );

		describe( 'clear', () => {
			it( 'removes all updates from the queue', () => {
				const queue = createUpdateQueue();
				queue.add(
					createSyncUpdate(
						new Uint8Array( [ 1 ] ),
						SyncUpdateType.UPDATE
					)
				);
				queue.add(
					createSyncUpdate(
						new Uint8Array( [ 2 ] ),
						SyncUpdateType.UPDATE
					)
				);

				expect( queue.size() ).toBe( 2 );
				queue.clear();
				expect( queue.size() ).toBe( 0 );
			} );
		} );

		describe( 'pause and resume', () => {
			it( 'pause prevents get from returning updates', () => {
				const queue = createUpdateQueue( [], false );
				queue.add(
					createSyncUpdate(
						new Uint8Array( [ 1 ] ),
						SyncUpdateType.UPDATE
					)
				);

				expect( queue.get() ).toHaveLength( 1 );

				queue.add(
					createSyncUpdate(
						new Uint8Array( [ 2 ] ),
						SyncUpdateType.UPDATE
					)
				);
				queue.pause();

				expect( queue.get() ).toEqual( [] );
				expect( queue.size() ).toBe( 1 );
			} );

			it( 'resume allows get to return updates', () => {
				const queue = createUpdateQueue(); // paused by default
				queue.add(
					createSyncUpdate(
						new Uint8Array( [ 1 ] ),
						SyncUpdateType.UPDATE
					)
				);

				expect( queue.get() ).toEqual( [] );

				queue.resume();
				const result = queue.get();

				expect( result ).toHaveLength( 1 );
			} );
		} );

		describe( 'restore', () => {
			it( 'restores updates to the front of the queue', () => {
				const queue = createUpdateQueue( [], false );
				const existing = createSyncUpdate(
					new Uint8Array( [ 2 ] ),
					SyncUpdateType.UPDATE
				);
				const toRestore = [
					createSyncUpdate(
						new Uint8Array( [ 1 ] ),
						SyncUpdateType.UPDATE
					),
				];

				queue.add( existing );
				queue.restore( toRestore );

				const result = queue.get();
				expect( result[ 0 ] ).toEqual( toRestore[ 0 ] );
				expect( result[ 1 ] ).toEqual( existing );
			} );

			it( 'filters out compaction updates', () => {
				const queue = createUpdateQueue( [], false );
				const toRestore = [
					createSyncUpdate(
						new Uint8Array( [ 1 ] ),
						SyncUpdateType.UPDATE
					),
					createSyncUpdate(
						new Uint8Array( [ 2 ] ),
						SyncUpdateType.COMPACTION
					),
					createSyncUpdate(
						new Uint8Array( [ 3 ] ),
						SyncUpdateType.UPDATE
					),
				];

				queue.restore( toRestore );

				const result = queue.get();
				expect( result ).toHaveLength( 2 );
				expect( result[ 0 ].type ).toBe( SyncUpdateType.UPDATE );
				expect( result[ 1 ].type ).toBe( SyncUpdateType.UPDATE );
			} );

			it( 'handles empty restore array', () => {
				const queue = createUpdateQueue();
				const existing = createSyncUpdate(
					new Uint8Array( [ 1 ] ),
					SyncUpdateType.UPDATE
				);

				queue.add( existing );
				queue.restore( [] );

				expect( queue.size() ).toBe( 1 );
			} );

			it( 'handles restore array with only compaction updates', () => {
				const queue = createUpdateQueue();
				const existing = createSyncUpdate(
					new Uint8Array( [ 1 ] ),
					SyncUpdateType.UPDATE
				);
				const toRestore = [
					createSyncUpdate(
						new Uint8Array( [ 2 ] ),
						SyncUpdateType.COMPACTION
					),
				];

				queue.add( existing );
				queue.restore( toRestore );

				// Only the existing update should remain
				expect( queue.size() ).toBe( 1 );
			} );
		} );

		describe( 'size', () => {
			it( 'returns 0 for empty queue', () => {
				const queue = createUpdateQueue();

				expect( queue.size() ).toBe( 0 );
			} );

			it( 'returns correct size after operations', () => {
				const queue = createUpdateQueue( [], false );
				const update = createSyncUpdate(
					new Uint8Array( [ 1 ] ),
					SyncUpdateType.UPDATE
				);

				expect( queue.size() ).toBe( 0 );

				queue.add( update );
				expect( queue.size() ).toBe( 1 );

				queue.add( update );
				expect( queue.size() ).toBe( 2 );

				queue.get();
				expect( queue.size() ).toBe( 0 );
			} );
		} );
	} );

	describe( 'postSyncUpdate', () => {
		beforeEach( () => {
			jest.clearAllMocks();
		} );

		it( 'sends a POST request to the sync endpoint', async () => {
			mockApiFetch.mockResolvedValue( { rooms: [] } );

			const payload = {
				rooms: [
					{
						after: 0,
						awareness: {},
						client_id: 123,
						room: 'test-room',
						updates: [],
					},
				],
			};

			await postSyncUpdate( payload );

			expect( mockApiFetch ).toHaveBeenCalledWith( {
				data: payload,
				method: 'POST',
				path: '/wp-sync/v1/updates',
			} );
		} );

		it( 'returns the parsed response', async () => {
			const expectedResponse = {
				rooms: [
					{
						awareness: {},
						end_cursor: 1000,
						room: 'test-room',
						updates: [],
					},
				],
			};
			mockApiFetch.mockResolvedValue( expectedResponse );

			const result = await postSyncUpdate( { rooms: [] } );

			expect( result ).toEqual( expectedResponse );
		} );

		it( 'propagates errors from apiFetch', async () => {
			mockApiFetch.mockRejectedValue( {
				code: 'internal_server_error',
				message: 'Internal Server Error',
			} );

			await expect( postSyncUpdate( { rooms: [] } ) ).rejects.toEqual( {
				code: 'internal_server_error',
				message: 'Internal Server Error',
			} );
		} );

		it( 'propagates network errors', async () => {
			mockApiFetch.mockRejectedValue( new Error( 'Network error' ) );

			await expect( postSyncUpdate( { rooms: [] } ) ).rejects.toThrow(
				'Network error'
			);
		} );
	} );

	describe( 'intValueOrDefault', () => {
		it( 'returns the integer value when parsing succeeds', () => {
			expect( intValueOrDefault( '42', 0 ) ).toBe( 42 );
			expect( intValueOrDefault( '-10', 0 ) ).toBe( -10 );
			expect( intValueOrDefault( '0', 1 ) ).toBe( 0 );
		} );

		it( 'returns the default value when parsing fails', () => {
			expect( intValueOrDefault( 'abc', 100 ) ).toBe( 100 );
			expect( intValueOrDefault( '', 50 ) ).toBe( 50 );
			expect( intValueOrDefault( {}, 10 ) ).toBe( 10 );
			expect( intValueOrDefault( [], 20 ) ).toBe( 20 );
			expect( intValueOrDefault( null, 25 ) ).toBe( 25 );
			expect( intValueOrDefault( undefined, 75 ) ).toBe( 75 );
		} );

		it( 'handles non-string inputs gracefully', () => {
			expect( intValueOrDefault( 123, 0 ) ).toBe( 123 );
			expect( intValueOrDefault( 45.67, 0 ) ).toBe( 45 ); // parseInt truncates
			expect( intValueOrDefault( 0x10, 0 ) ).toBe( 16 ); // hex
		} );

		it( 'handles edge cases', () => {
			expect( intValueOrDefault( '   15   ', 0 ) ).toBe( 15 ); // whitespace
			expect( intValueOrDefault( '08', 0 ) ).toBe( 8 ); // leading zero
		} );
	} );

	describe( 'rotateWindow', () => {
		it( 'returns an empty window for an empty list', () => {
			expect( rotateWindow( [], 0, 3 ) ).toEqual( {
				window: [],
				nextOffset: 0,
			} );
		} );

		it( 'returns an empty window for any offset when the list is empty', () => {
			expect( rotateWindow( [], 42, 10 ) ).toEqual( {
				window: [],
				nextOffset: 0,
			} );
		} );

		it( 'returns every item and advances the offset when size fits', () => {
			const items = [ 'a', 'b', 'c', 'd' ];

			expect( rotateWindow( items, 0, 4 ) ).toEqual( {
				window: [ 'a', 'b', 'c', 'd' ],
				nextOffset: 0,
			} );
		} );

		it( 'returns a prefix window when size is smaller than the list', () => {
			const items = [ 'a', 'b', 'c', 'd', 'e' ];

			expect( rotateWindow( items, 0, 2 ) ).toEqual( {
				window: [ 'a', 'b' ],
				nextOffset: 2,
			} );
		} );

		it( 'starts the window at the given offset', () => {
			const items = [ 'a', 'b', 'c', 'd', 'e' ];

			expect( rotateWindow( items, 2, 2 ) ).toEqual( {
				window: [ 'c', 'd' ],
				nextOffset: 4,
			} );
		} );

		it( 'wraps around the end of the list', () => {
			const items = [ 'a', 'b', 'c', 'd', 'e' ];

			expect( rotateWindow( items, 4, 3 ) ).toEqual( {
				window: [ 'e', 'a', 'b' ],
				nextOffset: 2,
			} );
		} );

		it( 'normalizes offsets larger than the list length', () => {
			const items = [ 'a', 'b', 'c' ];

			// offset 7 mod 3 === 1, so the window starts at 'b'.
			expect( rotateWindow( items, 7, 2 ) ).toEqual( {
				window: [ 'b', 'c' ],
				nextOffset: 0,
			} );
		} );

		it( 'normalizes negative offsets into the valid range', () => {
			const items = [ 'a', 'b', 'c' ];

			// -1 should resolve to the last element.
			expect( rotateWindow( items, -1, 2 ) ).toEqual( {
				window: [ 'c', 'a' ],
				nextOffset: 1,
			} );
		} );

		it( 'clamps the window when size exceeds the list length', () => {
			const items = [ 'a', 'b', 'c' ];

			expect( rotateWindow( items, 0, 10 ) ).toEqual( {
				window: [ 'a', 'b', 'c' ],
				nextOffset: 1,
			} );
		} );

		it( 'returns an empty window and leaves offset unchanged for size 0', () => {
			const items = [ 'a', 'b', 'c' ];

			expect( rotateWindow( items, 2, 0 ) ).toEqual( {
				window: [],
				nextOffset: 2,
			} );
		} );

		it( 'treats negative sizes as zero', () => {
			const items = [ 'a', 'b', 'c' ];

			expect( rotateWindow( items, 1, -5 ) ).toEqual( {
				window: [],
				nextOffset: 1,
			} );
		} );

		it( 'does not mutate the input list', () => {
			const items = [ 'a', 'b', 'c', 'd' ];
			const snapshot = [ ...items ];

			rotateWindow( items, 2, 3 );

			expect( items ).toEqual( snapshot );
		} );

		it( 'supports successive calls that cover every item exactly once', () => {
			const items = [ 'a', 'b', 'c', 'd', 'e' ];
			const seen: string[] = [];
			let offset = 0;

			for ( let i = 0; i < 3; i++ ) {
				const { window, nextOffset } = rotateWindow( items, offset, 2 );
				seen.push( ...window );
				offset = nextOffset;
			}

			// Three rotations of size 2 => 6 slots; across 5 items that means
			// each item is seen at least once.
			expect( new Set( seen ) ).toEqual( new Set( items ) );
		} );
	} );
} );