Refactor tests and add onError callback

- Centralize test helpers in TestHelpers.ts
- Unify test naming convention (Category: Description)
- Add configurable onError callback to SignedRequestsManager and SignedRequester
- Remove console.error from middleware, use optional callback instead

Author: StefanoBalocco

client/dist/SignedRequester.d.ts

@@ -17,6 +17,7 @@ type SignedRequestOptions = {
 declare class SignedRequester {
     private static readonly _primitives;
     private readonly _baseUrl;
+    private readonly _onError?;
     private _sessionId;
     private _token;
     private _sequenceNumber;
@@ -26,7 +27,7 @@ declare class SignedRequester {
     private _semaphoreRelease;
     private _incrementSequenceNumber;
     private _loadFromStorage;
-    constructor(baseUrl?: string);
+    constructor(baseUrl?: string, onError?: (error: unknown) => void);
     setSession(config: SessionConfig): void;
     getSession(): boolean;
     clearSession(): void;

client/dist/SignedRequester.js

@@ -1,4 +1,4 @@
-function _base64url_encode(value) {
+function _base64url_encode(value, onError) {
     let returnValue = '';
     if (0 < value?.length) {
         try {
@@ -9,13 +9,12 @@ function _base64url_encode(value) {
                 .replace(/=+$/, '');
         }
         catch (error) {
+            onError?.(error);
         }
     }
-    else {
-    }
     return returnValue;
 }
-function _base64url_decode(value) {
+function _base64url_decode(value, onError) {
     let returnValue;
     if (0 < value?.length && /^[A-Za-z0-9_-]*$/.test(value)) {
         const padding = value.length % 4;
@@ -26,10 +25,9 @@ function _base64url_decode(value) {
             returnValue = Uint8Array.from(binaryString, (char) => char.charCodeAt(0));
         }
         catch (error) {
+            onError?.(error);
         }
     }
-    else {
-    }
     return returnValue;
 }
 class SignedRequester {
@@ -73,7 +71,7 @@ class SignedRequester {
         if (sessionIdStr && tokenStr && sequenceNumberStr) {
             const sessionId = parseInt(sessionIdStr);
             const sequenceNumber = parseInt(sequenceNumberStr);
-            const token = _base64url_decode(tokenStr);
+            const token = _base64url_decode(tokenStr, this._onError);
             if (!isNaN(sessionId) && !isNaN(sequenceNumber) && token) {
                 this._sessionId = sessionId;
                 this._token = token;
@@ -83,13 +81,14 @@ class SignedRequester {
         }
         return returnValue;
     }
-    constructor(baseUrl) {
+    constructor(baseUrl, onError) {
         this._semaphore = false;
         this._semaphoreQueue = [];
         this._baseUrl = baseUrl;
+        this._onError = onError;
     }
     setSession(config) {
-        const token = _base64url_decode(config.token);
+        const token = _base64url_decode(config.token, this._onError);
         if (token) {
             this._sessionId = config.sessionId;
             this._token = token;
@@ -149,7 +148,7 @@ class SignedRequester {
                 const cryptoKey = await crypto.subtle.importKey('raw', this._token, { name: 'HMAC', hash: 'SHA-256' }, false, ['sign']);
                 const encoder = new TextEncoder();
                 const signatureBuffer = await crypto.subtle.sign('HMAC', cryptoKey, encoder.encode(dataToSign));
-                const signature = _base64url_encode(new Uint8Array(signatureBuffer));
+                const signature = _base64url_encode(new Uint8Array(signatureBuffer), this._onError);
                 const signedPayload = {
                     sessionId: this._sessionId,
                     timestamp: timestamp,

client/dist/SignedRequester.min.js

@@ -29,7 +29,7 @@ type SignedRequestOptions = {
 // Base64URL utilities
 // ============================================================================
 
-function _base64url_encode( value: Uint8Array ): string {
+function _base64url_encode( value: Uint8Array, onError?: ( error: unknown ) => void ): string {
 	let returnValue: string = '';
 	if( 0 < value?.length ) {
 		try {
@@ -39,15 +39,13 @@ function _base64url_encode( value: Uint8Array ): string {
 				.replace( /\//g, '_' )
 				.replace( /=+$/, '' );
 		} catch( error ) {
-			// console.error( `base64url_encode: failed to encode (${ error })` );
+			onError?.( error );
 		}
-	} else {
-		// console.warn( 'base64url_encode: empty value' );
 	}
 	return returnValue;
 }
 
-function _base64url_decode( value: string ): Undefinedable<Uint8Array<ArrayBuffer>> {
+function _base64url_decode( value: string, onError?: ( error: unknown ) => void ): Undefinedable<Uint8Array<ArrayBuffer>> {
 	let returnValue: Undefinedable<Uint8Array<ArrayBuffer>>;
 	if( 0 < value?.length && /^[A-Za-z0-9_-]*$/.test( value ) ) {
 		const padding = value.length % 4;
@@ -62,10 +60,8 @@ function _base64url_decode( value: string ): Undefinedable<Uint8Array<ArrayBuffe
 				char.charCodeAt( 0 )
 			);
 		} catch( error ) {
-			// console.error( `base64url_decode: failed to decode (${ error })` );
+			onError?.( error );
 		}
-	} else {
-		// console.warn( 'base64url_decode: empty or invalid characters' );
 	}
 	return returnValue;
 }
@@ -82,6 +78,7 @@ class SignedRequester {
 	] );
 
 	private readonly _baseUrl: Undefinedable<string>;
+	private readonly _onError?: ( error: unknown ) => void;
 	private _sessionId: Undefinedable<number>;
 	private _token: Undefinedable<Uint8Array<ArrayBuffer>>;
 	private _sequenceNumber: Undefinedable<number>;
@@ -142,7 +139,7 @@ class SignedRequester {
 		if( sessionIdStr && tokenStr && sequenceNumberStr ) {
 			const sessionId: number = parseInt( sessionIdStr );
 			const sequenceNumber: number = parseInt( sequenceNumberStr );
-			const token: Undefinedable<Uint8Array<ArrayBuffer>> = _base64url_decode( tokenStr );
+			const token: Undefinedable<Uint8Array<ArrayBuffer>> = _base64url_decode( tokenStr, this._onError );
 
 			if( !isNaN( sessionId ) && !isNaN( sequenceNumber ) && token ) {
 				this._sessionId = sessionId;
@@ -155,18 +152,20 @@ class SignedRequester {
 	}
 
 	/**
-	 * Initialize the session manager with optional base URL
+	 * Initialize the session manager with optional base URL and error handler
 	 * If baseUrl is not provided, fetch will use relative paths (current host)
+	 * If onError is provided, it will be called when encoding/decoding errors occur
 	 */
-	constructor( baseUrl?: string ) {
+	constructor( baseUrl?: string, onError?: ( error: unknown ) => void ) {
 		this._baseUrl = baseUrl;
+		this._onError = onError;
 	}
 
 	/**
 	 * Set session configuration (call after login)
 	 */
 	public setSession( config: SessionConfig ): void {
-		const token: Undefinedable<Uint8Array<ArrayBuffer>> = _base64url_decode( config.token );
+		const token: Undefinedable<Uint8Array<ArrayBuffer>> = _base64url_decode( config.token, this._onError );
 		if( token ) {
 			this._sessionId = config.sessionId;
 			this._token = token;
@@ -274,7 +273,7 @@ class SignedRequester {
 					encoder.encode( dataToSign )
 				);
 
-				const signature: string = _base64url_encode( new Uint8Array( signatureBuffer ) );
+				const signature: string = _base64url_encode( new Uint8Array( signatureBuffer ), this._onError );
 
 				// Build signed request
 				const signedPayload: SignedRequest = {

client/src/SignedRequester.ts

@@ -6,13 +6,15 @@ type SignedRequestsManagerConfig = {
     validitySignature: number;
     validityToken: number;
     tokenLength: number;
+    onError?: (error: unknown) => void;
 };
 export declare class SignedRequestsManager {
     private static readonly _primitives;
     private readonly _storage;
     private readonly _validitySignature;
     private readonly _validityToken;
     private readonly _tokenLength;
+    private readonly _onError?;
     constructor(storage?: SessionsStorage, options?: Partial<SignedRequestsManagerConfig>);
     createSession(userId: number): Promise<Session>;
     validate(sessionId: number, timestamp: number, parameters: [string, any][], signature: Uint8Array<ArrayBuffer>): Promise<Undefinedable<Session>>;

dist/SignedRequestsManager.d.ts

@@ -6,10 +6,12 @@ export class SignedRequestsManager {
     _validitySignature;
     _validityToken;
     _tokenLength;
+    _onError;
     constructor(storage, options) {
         this._validitySignature = options?.validitySignature ?? 5000;
         this._validityToken = options?.validityToken ?? 60 * 60000;
         this._tokenLength = options?.tokenLength ?? 32;
+        this._onError = options?.onError;
         if (!storage) {
             storage = new SessionsStorageLocal();
         }
@@ -81,7 +83,7 @@ export class SignedRequestsManager {
             }
         }
         catch (error) {
-            console.error('Session validation error:', error);
+            this._onError?.(error);
         }
         if (session) {
             context.set('session', session);

dist/SignedRequestsManager.js

@@ -8,6 +8,7 @@ type SignedRequestsManagerConfig = {
 	validitySignature: number;
 	validityToken: number;
 	tokenLength: number;
+	onError?: ( error: unknown ) => void;
 };
 
 export class SignedRequestsManager {
@@ -16,11 +17,13 @@ export class SignedRequestsManager {
 	private readonly _validitySignature: number;
 	private readonly _validityToken: number;
 	private readonly _tokenLength: number;
+	private readonly _onError?: ( error: unknown ) => void;
 
 	constructor( storage?: SessionsStorage, options?: Partial<SignedRequestsManagerConfig> ) {
 		this._validitySignature = options?.validitySignature ?? 5000;
 		this._validityToken = options?.validityToken ?? 60 * 60000;
 		this._tokenLength = options?.tokenLength ?? 32;
+		this._onError = options?.onError;
 
 		if( !storage ) {
 			storage = new SessionsStorageLocal();
@@ -116,7 +119,7 @@ export class SignedRequestsManager {
 				);
 			}
 		} catch( error ) {
-			console.error( 'Session validation error:', error );
+			this._onError?.( error );
 		}
 
 		if( session ) {

src/SignedRequestsManager.ts

@@ -1,69 +1,69 @@
 import test from 'ava';
 import { constantTimeEqual, fromBase64Url, hmacSha256, randomBytes, randomInt } from '../../dist/Common.js';
-test('fromBase64Url converts base64url to Uint8Array', (t) => {
+test('Common: fromBase64Url converts base64url to Uint8Array', (t) => {
     const base64url = 'SGVsbG8gV29ybGQ';
     const result = fromBase64Url(base64url);
     t.true(result instanceof Uint8Array);
     t.is(result.length, 11);
     t.is(String.fromCharCode(...result), 'Hello World');
 });
-test('fromBase64Url handles padding correctly', (t) => {
+test('Common: fromBase64Url handles padding correctly', (t) => {
     const base64url = 'dGVzdA';
     const result = fromBase64Url(base64url);
     t.is(String.fromCharCode(...result), 'test');
 });
-test('randomBytes generates correct length', (t) => {
+test('Common: randomBytes generates correct length', (t) => {
     const bytes = randomBytes(32);
     t.true(bytes instanceof Uint8Array);
     t.is(bytes.length, 32);
 });
-test('randomBytes generates different values', (t) => {
+test('Common: randomBytes generates different values', (t) => {
     const bytes1 = randomBytes(16);
     const bytes2 = randomBytes(16);
     t.false(constantTimeEqual(bytes1, bytes2));
 });
-test('randomInt generates number in range', (t) => {
+test('Common: randomInt generates number in range', (t) => {
     const min = 100;
     const max = 200;
     for (let i = 0; i < 100; i++) {
         const num = randomInt(min, max);
         t.true(num >= min && num < max);
     }
 });
-test('randomInt throws on invalid range', (t) => {
+test('Common: randomInt throws on invalid range', (t) => {
     t.throws(() => randomInt(100, 100), { message: 'max must be > min' });
     t.throws(() => randomInt(200, 100), { message: 'max must be > min' });
 });
-test('constantTimeEqual returns true for equal arrays', (t) => {
+test('Common: constantTimeEqual returns true for equal arrays', (t) => {
     const a = new Uint8Array([1, 2, 3, 4, 5]);
     const b = new Uint8Array([1, 2, 3, 4, 5]);
     t.true(constantTimeEqual(a, b));
 });
-test('constantTimeEqual returns false for different arrays', (t) => {
+test('Common: constantTimeEqual returns false for different arrays', (t) => {
     const a = new Uint8Array([1, 2, 3, 4, 5]);
     const b = new Uint8Array([1, 2, 3, 4, 6]);
     t.false(constantTimeEqual(a, b));
 });
-test('constantTimeEqual returns false for different lengths', (t) => {
+test('Common: constantTimeEqual returns false for different lengths', (t) => {
     const a = new Uint8Array([1, 2, 3]);
     const b = new Uint8Array([1, 2, 3, 4]);
     t.false(constantTimeEqual(a, b));
 });
-test('hmacSha256 generates correct signature', async (t) => {
+test('Common: hmacSha256 generates correct signature', async (t) => {
     const key = new Uint8Array(32);
     const data = 'test message';
     const signature = await hmacSha256(key, data);
     t.true(signature instanceof Uint8Array);
     t.is(signature.length, 32);
 });
-test('hmacSha256 produces consistent signatures', async (t) => {
+test('Common: hmacSha256 produces consistent signatures', async (t) => {
     const key = new Uint8Array([1, 2, 3, 4]);
     const data = 'consistent test';
     const sig1 = await hmacSha256(key, data);
     const sig2 = await hmacSha256(key, data);
     t.true(constantTimeEqual(sig1, sig2));
 });
-test('hmacSha256 produces different signatures for different keys', async (t) => {
+test('Common: hmacSha256 produces different signatures for different keys', async (t) => {
     const key1 = new Uint8Array([1, 2, 3, 4]);
     const key2 = new Uint8Array([5, 6, 7, 8]);
     const data = 'test';