trac-msb 0.2.13 → 0.2.15

package/tests/unit/network/v1/v1ValidationSchema/common.test.js

@@ -1,308 +0,0 @@
-import b4a from 'b4a';
-
-export const describeValue = (value) => {
-    if (value === null) return 'null';
-    if (value === undefined) return 'undefined';
-    if (b4a.isBuffer(value)) return `buffer(len=${value.length})`;
-    if (Number.isNaN(value)) return 'NaN';
-    if (value === Infinity) return 'Infinity';
-    if (Array.isArray(value)) return 'array';
-    if (value instanceof Map) return 'map';
-    if (value instanceof Set) return 'set';
-    if (value instanceof Date) return 'date';
-    if (value instanceof RegExp) return 'regexp';
-    if (value instanceof Error) return `error(${value.message})`;
-    if (typeof value === 'bigint') return `bigint(${value})`;
-    return typeof value;
-};
-
-export const assertNoThrowAndAbsent = (t, validateFn, input, message) => {
-    let result;
-    t.execution(() => {
-        result = validateFn(input);
-    }, `${message} (no throw)`);
-    t.absent(result, `${message} (should fail)`);
-};
-
-export function topLevelValidationTests(
-    t,
-    validateFn,
-    validFixture,
-    valueKey,
-    notAllowedDataTypes,
-    topFields,
-    expectedType
-) {
-    t.test('strict mode', t => {
-        const extraTopLevel = {
-            ...validFixture,
-            extra: b4a.from('redundant field', 'utf-8'),
-        };
-        t.absent(validateFn(extraTopLevel), 'Extra field should fail due to $$strict');
-        t.absent(validateFn({}), 'Empty object should fail');
-    });
-
-    t.test('operation type', t => {
-        const invalidOperationType = { ...validFixture, type: 'invalid-op' };
-        t.absent(validateFn(invalidOperationType), 'Invalid operation type should fail');
-
-        const notDefinedOperationType = { ...validFixture, type: 999 };
-        t.absent(validateFn(notDefinedOperationType), 'Invalid operation type should fail');
-
-        const zeroValue = { ...validFixture, type: 0 };
-        t.absent(validateFn(zeroValue), 'Type with value 0 should fail');
-
-        const negativeValue = { ...validFixture, type: -1 };
-        t.absent(validateFn(negativeValue), 'Negative type value should fail');
-
-        const wrongKnownType = { ...validFixture, type: expectedType + 1 };
-        t.absent(validateFn(wrongKnownType), 'Wrong known type should fail');
-    });
-
-    t.test('nested objects', t => {
-        const nestedObjectInsideValue = {
-            ...validFixture,
-            [valueKey]: {
-                ...validFixture[valueKey],
-                nested: { foo: b4a.from('bar', 'utf-8') }
-            }
-        };
-        t.absent(validateFn(nestedObjectInsideValue), `Unexpected nested field inside -${valueKey}- should fail due to strict`);
-
-        const nestedObjectInsideValue2 = {
-            ...validFixture,
-            nested: { foo: b4a.from('bar', 'utf-8') }
-        };
-        t.absent(validateFn(nestedObjectInsideValue2), 'Unexpected nested field inside general object should fail due to strict');
-
-        const nestedObjectInsideType = {
-            ...validFixture,
-            type: {
-                foo: b4a.from('bar', 'utf-8'),
-                nested: { foo: b4a.from('bar', 'utf-8') }
-            }
-        };
-        t.absent(validateFn(nestedObjectInsideType), 'Unexpected nested field inside `type` field should fail');
-
-        const nestedObjectInsideId = {
-            ...validFixture,
-            id: {
-                foo: b4a.from('bar', 'utf-8'),
-                nested: { foo: b4a.from('bar', 'utf-8') }
-            }
-        };
-        t.absent(validateFn(nestedObjectInsideId), 'Unexpected nested field inside `id` field should fail');
-
-        const nestedObjectInsideTimestamp = {
-            ...validFixture,
-            timestamp: {
-                foo: b4a.from('bar', 'utf-8'),
-                nested: { foo: b4a.from('bar', 'utf-8') }
-            }
-        };
-        t.absent(validateFn(nestedObjectInsideTimestamp), 'Unexpected nested field inside `timestamp` field should fail');
-
-        const nestedObjectInsideCapabilities = {
-            ...validFixture,
-            capabilities: {
-                foo: b4a.from('bar', 'utf-8'),
-                nested: { foo: b4a.from('bar', 'utf-8') }
-            }
-        };
-        t.absent(validateFn(nestedObjectInsideCapabilities), 'Unexpected nested field inside `capabilities` field should fail');
-    });
-
-    t.test('invalid data types', t => {
-        for (const invalidDataType of notAllowedDataTypes) {
-            if (typeof invalidDataType !== 'number') {
-                const invalidTypeForType = { ...validFixture, type: invalidDataType };
-                t.absent(
-                    validateFn(invalidTypeForType),
-                    `Invalid data type for 'type' key ${describeValue(invalidDataType)} should fail`
-                );
-            }
-
-            if (typeof invalidDataType !== 'string') {
-                const invalidTypeForId = { ...validFixture, id: invalidDataType };
-                t.absent(
-                    validateFn(invalidTypeForId),
-                    `Invalid data type for 'id' key ${describeValue(invalidDataType)} should fail`
-                );
-            }
-
-            if (typeof invalidDataType !== 'number') {
-                const invalidTypeForTimestamp = { ...validFixture, timestamp: invalidDataType };
-                t.absent(
-                    validateFn(invalidTypeForTimestamp),
-                    `Invalid data type for 'timestamp' key ${describeValue(invalidDataType)} should fail`
-                );
-            }
-
-            if (!Array.isArray(invalidDataType)) {
-                const invalidTypeForCapabilities = { ...validFixture, capabilities: invalidDataType };
-                t.absent(
-                    validateFn(invalidTypeForCapabilities),
-                    `Invalid data type for 'capabilities' key ${describeValue(invalidDataType)} should fail`
-                );
-            }
-
-            if (String(invalidDataType) !== '[object Object]') {
-                const invalidTypeForPayload = { ...validFixture, [valueKey]: invalidDataType };
-                t.absent(
-                    validateFn(invalidTypeForPayload),
-                    `Invalid data type for ${valueKey} key ${describeValue(invalidDataType)} should fail`
-                );
-            }
-        }
-
-        const invalidOperationTypeDiffType = { ...validFixture, type: "string" }
-        t.absent(validateFn(invalidOperationTypeDiffType), 'Wrong type for `type` should fail')
-
-        for (const mainField of topFields) {
-            const missingFieldInvalidInput = { ...validFixture }
-            delete missingFieldInvalidInput[mainField]
-            t.absent(validateFn(missingFieldInvalidInput), `Missing ${mainField} should fail`);
-        }
-    });
-}
-
-export function headerFieldValueValidationTests(t, validateFn, validFixture) {
-    t.absent(
-        validateFn({...validFixture, id: ''}),
-        'empty id should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, id: 'x'.repeat(65)}),
-        'id longer than 64 chars should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, timestamp: 0}),
-        'timestamp 0 should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, timestamp: -1}),
-        'negative timestamp should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, timestamp: 1.1}),
-        'non-integer timestamp should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, timestamp: NaN}),
-        'timestamp NaN should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, timestamp: Infinity}),
-        'timestamp Infinity should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, timestamp: Number.MAX_SAFE_INTEGER + 1}),
-        'timestamp above MAX_SAFE_INTEGER should fail'
-    );
-
-    t.absent(
-        validateFn({...validFixture, capabilities: 'cap:a'}),
-        'capabilities must be an array'
-    );
-
-    t.absent(
-        validateFn({...validFixture, capabilities: [1]}),
-        'capabilities items must be strings'
-    );
-}
-
-export function valueLevelValidationTests(
-    t,
-    validateFn,
-    validFixture,
-    valueKey,
-    valueFields,
-    notAllowedDataTypes,
-    opts = {}
-) {
-    const skipInvalidType = opts.skipInvalidType || (() => false);
-
-    for (const field of valueFields) {
-        const missing = structuredClone(validFixture);
-        delete missing[valueKey][field];
-        t.absent(validateFn(missing), `Missing ${valueKey}.${field} should fail`);
-    }
-
-    t.test(`Invalid data types for each field in ${valueKey}`, t => {
-        for (const field of valueFields) {
-            for (const invalidType of notAllowedDataTypes) {
-                if (skipInvalidType(field, invalidType)) continue;
-
-                const withInvalidDataType = structuredClone(validFixture);
-                withInvalidDataType[valueKey][field] = invalidType;
-                t.absent(
-                    validateFn(withInvalidDataType),
-                    `Invalid data type for ${valueKey}.${field}: ${describeValue(invalidType)} should fail`
-                );
-            }
-        }
-    });
-
-    t.test("Extra field in value", t => {
-        const extraInValue = structuredClone(validFixture);
-        extraInValue[valueKey].extraField = b4a.from('redundant', 'utf-8');
-        t.absent(validateFn(extraInValue), 'Extra field should fail due to strict')
-    });
-}
-
-export function fieldsBufferLengthTest(
-    t,
-    validateFn,
-    validFixture,
-    valueKey,
-    requiredFieldLengthsForValue
-) {
-    for (const [field, expectedLen] of Object.entries(requiredFieldLengthsForValue)) {
-        const emptyBuffer = b4a.alloc(0);
-        const oneTooShort = b4a.alloc(expectedLen - 1, 0x01);
-        const tooShort = b4a.alloc(expectedLen - 2, 0x01);
-        const exact = b4a.alloc(expectedLen, 0x01);
-        const oneTooLong = b4a.alloc(expectedLen + 1, 0x01);
-        const tooLong = b4a.alloc(expectedLen + 2, 0x01);
-
-        const buildValueLevel = (val) => ({
-            ...validFixture,
-            [valueKey]: {
-                ...validFixture[valueKey],
-                [field]: val
-            }
-        });
-
-        const inputs = {
-            emptyBufferInput: buildValueLevel(emptyBuffer),
-            shortInput: buildValueLevel(tooShort),
-            oneTooShortInput: buildValueLevel(oneTooShort),
-            exactInput: buildValueLevel(exact),
-            oneTooLongInput: buildValueLevel(oneTooLong),
-            longInput: buildValueLevel(tooLong),
-        };
-
-        t.absent(validateFn(inputs.emptyBufferInput), `${valueKey}.${field} empty buffer (length ${emptyBuffer.length}) should fail`);
-        t.absent(validateFn(inputs.shortInput), `${valueKey}.${field} too short (length ${tooShort.length}) should fail`);
-        t.absent(validateFn(inputs.oneTooShortInput), `${valueKey}.${field} one too short (length ${oneTooShort.length}) should fail`);
-        t.ok(validateFn(inputs.exactInput), `${valueKey}.${field} exact length (length ${exact.length}) should pass`);
-        t.absent(validateFn(inputs.oneTooLongInput), `${valueKey}.${field} one too long (length ${oneTooLong.length}) should fail`);
-        t.absent(validateFn(inputs.longInput), `${valueKey}.${field} too long (length ${tooLong.length}) should fail`);
-    }
-}
-
-export function fieldsNonZeroBufferTest(t, validateFn, validFixture, valueKey, fields) {
-    for (const field of fields) {
-        const zeroFilled = structuredClone(validFixture);
-        const len = zeroFilled[valueKey][field]?.length ?? 0;
-        zeroFilled[valueKey][field] = b4a.alloc(len, 0);
-        t.absent(validateFn(zeroFilled), `${valueKey}.${field} all-zero buffer should fail`);
-    }
-}

package/tests/unit/network/v1/v1ValidationSchema/livenessRequest.test.js

@@ -1,90 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-
-import V1ValidationSchema from '../../../../../src/core/network/protocols/v1/validators/V1ValidationSchema.js';
-import {
-    NetworkOperationType,
-    NONCE_BYTE_LENGTH,
-    SIGNATURE_BYTE_LENGTH,
-} from '../../../../../src/utils/constants.js';
-import {not_allowed_data_types} from '../../../../fixtures/check.fixtures.js';
-
-import {
-    fieldsBufferLengthTest,
-    fieldsNonZeroBufferTest,
-    headerFieldValueValidationTests,
-    topLevelValidationTests,
-    valueLevelValidationTests,
-} from './common.test.js';
-
-const v = new V1ValidationSchema();
-
-const validFixture = {
-    type: NetworkOperationType.LIVENESS_REQUEST,
-    id: 'test-id',
-    timestamp: Date.now(),
-    liveness_request: {
-        nonce: b4a.alloc(NONCE_BYTE_LENGTH, 1),
-        signature: b4a.alloc(SIGNATURE_BYTE_LENGTH, 2),
-    },
-    capabilities: ['cap:a', 'cap:b'],
-};
-
-const topFields = ['type', 'id', 'timestamp', 'liveness_request', 'capabilities'];
-const valueFields = ['nonce', 'signature'];
-const requiredLengths = {
-    nonce: NONCE_BYTE_LENGTH,
-    signature: SIGNATURE_BYTE_LENGTH,
-};
-
-test('V1ValidationSchema.validateV1LivenessRequest - happy path', t => {
-    t.ok(v.validateV1LivenessRequest(validFixture), 'valid LIVENESS_REQUEST should pass');
-});
-
-test('V1ValidationSchema.validateV1LivenessRequest - top level validation', t => {
-    topLevelValidationTests(
-        t,
-        v.validateV1LivenessRequest.bind(v),
-        validFixture,
-        'liveness_request',
-        not_allowed_data_types,
-        topFields,
-        NetworkOperationType.LIVENESS_REQUEST
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessRequest - header field values', t => {
-    headerFieldValueValidationTests(t, v.validateV1LivenessRequest.bind(v), validFixture);
-});
-
-test('V1ValidationSchema.validateV1LivenessRequest - payload validation', t => {
-    valueLevelValidationTests(
-        t,
-        v.validateV1LivenessRequest.bind(v),
-        validFixture,
-        'liveness_request',
-        valueFields,
-        not_allowed_data_types,
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessRequest - buffer lengths', t => {
-    fieldsBufferLengthTest(
-        t,
-        v.validateV1LivenessRequest.bind(v),
-        validFixture,
-        'liveness_request',
-        requiredLengths
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessRequest - non-zero buffers', t => {
-    fieldsNonZeroBufferTest(
-        t,
-        v.validateV1LivenessRequest.bind(v),
-        validFixture,
-        'liveness_request',
-        ['nonce', 'signature']
-    );
-});
-

package/tests/unit/network/v1/v1ValidationSchema/livenessResponse.test.js

@@ -1,133 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-
-import V1ValidationSchema from '../../../../../src/core/network/protocols/v1/validators/V1ValidationSchema.js';
-import {
-    NetworkOperationType,
-    NONCE_BYTE_LENGTH,
-    ResultCode,
-    SIGNATURE_BYTE_LENGTH,
-} from '../../../../../src/utils/constants.js';
-import {not_allowed_data_types} from '../../../../fixtures/check.fixtures.js';
-
-import {
-    assertNoThrowAndAbsent,
-    fieldsBufferLengthTest,
-    fieldsNonZeroBufferTest,
-    headerFieldValueValidationTests,
-    topLevelValidationTests,
-    valueLevelValidationTests,
-} from './common.test.js';
-
-const v = new V1ValidationSchema();
-
-const validFixture = {
-    type: NetworkOperationType.LIVENESS_RESPONSE,
-    id: 'test-id',
-    timestamp: Date.now(),
-    liveness_response: {
-        nonce: b4a.alloc(NONCE_BYTE_LENGTH, 1),
-        signature: b4a.alloc(SIGNATURE_BYTE_LENGTH, 2),
-        result: ResultCode.OK,
-    },
-    capabilities: ['cap:a'],
-};
-
-const topFields = ['type', 'id', 'timestamp', 'liveness_response', 'capabilities'];
-const valueFields = ['nonce', 'signature', 'result'];
-const requiredLengths = {
-    nonce: NONCE_BYTE_LENGTH,
-    signature: SIGNATURE_BYTE_LENGTH,
-};
-
-test('V1ValidationSchema.validateV1LivenessResponse - happy path', t => {
-    t.ok(v.validateV1LivenessResponse(validFixture), 'valid LIVENESS_RESPONSE should pass');
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - payload/type mismatch (request payload + response type)', t => {
-    const op = structuredClone(validFixture);
-    delete op.liveness_response;
-    op.liveness_request = {
-        nonce: b4a.alloc(NONCE_BYTE_LENGTH, 1),
-        signature: b4a.alloc(SIGNATURE_BYTE_LENGTH, 2),
-    };
-
-    assertNoThrowAndAbsent(
-        t,
-        v.validateV1LivenessResponse.bind(v),
-        op,
-        'liveness_request payload with type=LIVENESS_RESPONSE'
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - top level validation', t => {
-    topLevelValidationTests(
-        t,
-        v.validateV1LivenessResponse.bind(v),
-        validFixture,
-        'liveness_response',
-        not_allowed_data_types,
-        topFields,
-        NetworkOperationType.LIVENESS_RESPONSE
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - header field values', t => {
-    headerFieldValueValidationTests(t, v.validateV1LivenessResponse.bind(v), validFixture);
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - payload validation', t => {
-    valueLevelValidationTests(
-        t,
-        v.validateV1LivenessResponse.bind(v),
-        validFixture,
-        'liveness_response',
-        valueFields,
-        not_allowed_data_types,
-        {
-            skipInvalidType: (field, invalidType) => field === 'result' && typeof invalidType === 'number',
-        }
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - result value validation', t => {
-    const negative = structuredClone(validFixture);
-    negative.liveness_response.result = -1;
-    t.absent(v.validateV1LivenessResponse(negative), 'negative result should fail');
-
-    const nonInteger = structuredClone(validFixture);
-    nonInteger.liveness_response.result = 1.1;
-    t.absent(v.validateV1LivenessResponse(nonInteger), 'non-integer result should fail');
-
-    const nan = structuredClone(validFixture);
-    nan.liveness_response.result = NaN;
-    t.absent(v.validateV1LivenessResponse(nan), 'result NaN should fail');
-
-    const infinity = structuredClone(validFixture);
-    infinity.liveness_response.result = Infinity;
-    t.absent(v.validateV1LivenessResponse(infinity), 'result Infinity should fail');
-
-    const unknownCode = structuredClone(validFixture);
-    unknownCode.liveness_response.result = Math.max(...Object.values(ResultCode)) + 1;
-    t.absent(v.validateV1LivenessResponse(unknownCode), 'unknown result code should fail');
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - buffer lengths', t => {
-    fieldsBufferLengthTest(
-        t,
-        v.validateV1LivenessResponse.bind(v),
-        validFixture,
-        'liveness_response',
-        requiredLengths
-    );
-});
-
-test('V1ValidationSchema.validateV1LivenessResponse - non-zero buffers', t => {
-    fieldsNonZeroBufferTest(
-        t,
-        v.validateV1LivenessResponse.bind(v),
-        validFixture,
-        'liveness_response',
-        ['nonce', 'signature']
-    );
-});

package/tests/unit/utils/deepEqualApplyPayload/deepEqualApplyPayload.test.js

@@ -1,102 +0,0 @@
-import test from 'brittle';
-import b4a from 'b4a';
-
-import fixtures from '../../../fixtures/protobuf.fixtures.js';
-import { isDeepEqualApplyPayload } from '../../../../src/utils/deepEqualApplyPayload.js';
-
-const applyPayloads = new Map([
-    ['txComplete', fixtures.validTransactionOperation],
-    ['txPartial', fixtures.validPartialTransactionOperation],
-    ['addIndexer', fixtures.validAddIndexer],
-    ['removeIndexer', fixtures.validRemoveIndexer],
-    ['appendWhitelist', fixtures.validAppendWhitelist],
-    ['banValidator', fixtures.validBanValidator],
-    ['addAdmin', fixtures.validAddAdmin],
-    ['addWriterComplete', fixtures.validCompleteAddWriter],
-    ['addWriterPartial', fixtures.validPartialAddWriter],
-    ['removeWriterComplete', fixtures.validCompleteRemoveWriter],
-    ['removeWriterPartial', fixtures.validPartialRemoveWriter],
-    ['adminRecoveryComplete', fixtures.validCompleteAdminRecovery],
-    ['adminRecoveryPartial', fixtures.validPartialAdminRecovery],
-    ['bootstrapDeploymentComplete', fixtures.validCompleteBootstrapDeployment],
-    ['bootstrapDeploymentPartial', fixtures.validPartialBootstrapDeployment],
-    ['transferComplete', fixtures.validTransferOperation],
-    ['transferPartial', fixtures.validPartialTransferOperation],
-    ['balanceInitialization', fixtures.validBalanceInitOperation],
-    ['disableInitialization', fixtures.validDisableInitialization],
-]);
-
-const cloneDeep = (value) => {
-    if (b4a.isBuffer(value)) return b4a.from(value);
-
-    if (Array.isArray(value)) {
-        return value.map(cloneDeep);
-    }
-
-    if (value && typeof value === 'object') {
-        const clone = {};
-        for (const key of Object.keys(value)) {
-            clone[key] = cloneDeep(value[key]);
-        }
-        return clone;
-    }
-
-    return value;
-};
-
-const mutateFirstBuffer = (value) => {
-    if (!value || typeof value !== 'object') return false;
-
-    if (Array.isArray(value)) {
-        for (let i = 0; i < value.length; i++) {
-            if (mutateFirstBuffer(value[i])) return true;
-        }
-        return false;
-    }
-
-    for (const key of Object.keys(value)) {
-        const current = value[key];
-
-        if (b4a.isBuffer(current)) {
-            if (current.length === 0) {
-                value[key] = b4a.from([0x01]);
-                return true;
-            }
-
-            current[0] = current[0] ^ 0xff;
-            return true;
-        }
-
-        if (current && typeof current === 'object') {
-            if (mutateFirstBuffer(current)) return true;
-        }
-    }
-
-    return false;
-};
-
-test('isDeepEqualApplyPayload returns true for deep-equal apply payload fixtures', t => {
-    for (const [name, payload] of applyPayloads) {
-        const cloned = cloneDeep(payload);
-        t.ok(isDeepEqualApplyPayload(payload, cloned), `${name} should be deep-equal`);
-    }
-});
-
-test('isDeepEqualApplyPayload returns false when payload content differs', t => {
-    for (const [name, payload] of applyPayloads) {
-        const mutated = cloneDeep(payload);
-        const didMutate = mutateFirstBuffer(mutated);
-
-        t.ok(didMutate, `${name} mutation should modify at least one buffer`);
-        t.absent(isDeepEqualApplyPayload(payload, mutated), `${name} should not be deep-equal after mutation`);
-    }
-});
-
-test('isDeepEqualApplyPayload handles primitive and structural mismatches', t => {
-    t.ok(isDeepEqualApplyPayload(null, null), 'null equals null');
-    t.absent(isDeepEqualApplyPayload(null, undefined), 'null and undefined differ');
-    t.absent(isDeepEqualApplyPayload(1, '1'), 'number and string differ');
-    t.absent(isDeepEqualApplyPayload([], {}), 'array and object differ');
-    t.absent(isDeepEqualApplyPayload({ type: 1 }, { type: 1, extra: true }), 'missing/extra keys differ');
-});
-