@bsv/wallet-toolbox 1.7.18 → 2.0.0-beta.0

package/out/test/storage/update.test.js

@@ -1,919 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const TestUtilsWalletStorage_1 = require("../utils/TestUtilsWalletStorage");
-const index_all_1 = require("../../src/index.all");
-const TestUtilsWalletStorage_2 = require("../utils/TestUtilsWalletStorage");
-(0, TestUtilsWalletStorage_2.setLogging)(false);
-describe('update tests', () => {
-    jest.setTimeout(99999999);
-    const chain = 'test';
-    const env = TestUtilsWalletStorage_1._tu.getEnvFlags(chain);
-    const testName = () => expect.getState().currentTestName || 'test';
-    let storages;
-    let setups;
-    beforeEach(async () => {
-        setups = [];
-        storages = [];
-        const databaseName = testName();
-        const localSQLiteFile = await TestUtilsWalletStorage_1._tu.newTmpFile(`${databaseName}.sqlite`, false, false, true);
-        const knexSQLite = TestUtilsWalletStorage_1._tu.createLocalSQLite(localSQLiteFile);
-        storages.push(new index_all_1.StorageKnex({
-            ...index_all_1.StorageKnex.defaultOptions(),
-            chain,
-            knex: knexSQLite
-        }));
-        if (env.runMySQL) {
-            const knexMySQL = TestUtilsWalletStorage_1._tu.createLocalMySQL(`${databaseName}.mysql`);
-            storages.push(new index_all_1.StorageKnex({
-                ...index_all_1.StorageKnex.defaultOptions(),
-                chain,
-                knex: knexMySQL
-            }));
-        }
-        for (const storage of storages) {
-            await storage.dropAllData();
-            await storage.migrate('update tests', '1'.repeat(64));
-            await storage.makeAvailable();
-            setups.push({ storage, setup: await TestUtilsWalletStorage_1._tu.createTestSetup1(storage) });
-        }
-    });
-    afterEach(async () => {
-        for (const storage of storages) {
-            await storage.destroy();
-        }
-    });
-    test('0_update ProvenTx', async () => {
-        for (const { storage } of setups) {
-            const records = await storage.findProvenTxs({ partial: {} });
-            const time = new Date('2001-01-02T12:00:00.000Z');
-            for (const record of records) {
-                await storage.updateProvenTx(record.provenTxId, {
-                    blockHash: 'fred',
-                    updated_at: time
-                });
-                const t = (0, index_all_1.verifyOne)(await storage.findProvenTxs({
-                    partial: { provenTxId: record.provenTxId }
-                }));
-                expect(t.provenTxId).toBe(record.provenTxId);
-                expect(t.blockHash).toBe('fred');
-                expect(t.updated_at.getTime()).toBe(time.getTime());
-            }
-        }
-    });
-    test('1_update ProvenTx', async () => {
-        const primaryKey = 'provenTxId';
-        for (const { storage } of setups) {
-            const referenceTime = new Date();
-            const records = await storage.findProvenTxs({ partial: {} });
-            for (const record of records) {
-                try {
-                    const testValues = {
-                        provenTxId: record.provenTxId,
-                        txid: 'mockTxid',
-                        created_at: new Date('2024-12-30T23:00:00Z'),
-                        updated_at: new Date('2024-12-30T23:05:00Z'),
-                        blockHash: 'mockBlockHash',
-                        height: 12345,
-                        index: 1,
-                        merklePath: [1, 2, 3, 4],
-                        merkleRoot: '1234',
-                        rawTx: [4, 3, 2, 1]
-                    };
-                    await (0, TestUtilsWalletStorage_2.updateTable)(storage.updateProvenTx.bind(storage), record[primaryKey], testValues);
-                    const updatedTx = (0, index_all_1.verifyOne)(await storage.findProvenTxs({
-                        partial: { [primaryKey]: record[primaryKey] }
-                    }));
-                    (0, TestUtilsWalletStorage_2.verifyValues)(updatedTx, testValues, referenceTime);
-                    for (const [key, value] of Object.entries(testValues)) {
-                        if (key === primaryKey) {
-                            continue;
-                        }
-                        if (typeof value === 'string') {
-                            const validString = `valid${key}`;
-                            const r1 = await storage.updateProvenTx(record[primaryKey], {
-                                [key]: validString
-                            });
-                            expect(r1).toBe(1);
-                            const updatedRow = (0, index_all_1.verifyOne)(await storage.findProvenTxs({
-                                partial: { [primaryKey]: record[primaryKey] }
-                            }));
-                            expect(updatedRow[key]).toBe(validString);
-                        }
-                        if (typeof value === 'number') {
-                            const validNumber = value + 1;
-                            const r1 = await storage.updateProvenTx(record[primaryKey], {
-                                [key]: validNumber
-                            });
-                            expect(r1).toBe(1);
-                            const updatedRow = (0, index_all_1.verifyOne)(await storage.findProvenTxs({
-                                partial: { [primaryKey]: record[primaryKey] }
-                            }));
-                            expect(updatedRow[key]).toBe(validNumber);
-                        }
-                        if (value instanceof Date) {
-                            const validDate = new Date('2024-12-31T00:00:00Z');
-                            const r1 = await storage.updateProvenTx(record[primaryKey], {
-                                [key]: validDate
-                            });
-                            expect(r1).toBe(1);
-                            const updatedRow = (0, index_all_1.verifyOne)(await storage.findProvenTxs({
-                                partial: { [primaryKey]: record[primaryKey] }
-                            }));
-                            expect(new Date(updatedRow[key]).toISOString()).toBe(validDate.toISOString());
-                        }
-                        if (Array.isArray(value)) {
-                            const validArray = value.map(v => v + 1);
-                            const r1 = await storage.updateProvenTx(record[primaryKey], {
-                                [key]: validArray
-                            });
-                            expect(r1).toBe(1);
-                            const updatedRow = (0, index_all_1.verifyOne)(await storage.findProvenTxs({
-                                partial: { [primaryKey]: record[primaryKey] }
-                            }));
-                            expect(updatedRow[key]).toEqual(validArray);
-                        }
-                    }
-                }
-                catch (error) {
-                    console.error(`Error updating or verifying ProvenTx record with ${primaryKey}=${record[primaryKey]}:`, error.message);
-                    throw error;
-                }
-            }
-        }
-    });
-    test('2_update ProvenTxReq', async () => {
-        const primaryKey = 'provenTxReqId';
-        for (const { storage } of setups) {
-            const records = await storage.findProvenTxReqs({ partial: {} });
-            for (const record of records) {
-                try {
-                    const testValues = {
-                        provenTxReqId: record.provenTxReqId,
-                        provenTxId: 1,
-                        batch: `batch-001`,
-                        status: 'completed',
-                        txid: `mockTxid-${Date.now()}`,
-                        created_at: new Date('2024-12-30T23:00:00Z'),
-                        updated_at: new Date('2024-12-30T23:05:00Z'),
-                        attempts: 3,
-                        history: JSON.stringify({ validated: true, timestamp: Date.now() }),
-                        inputBEEF: [5, 6, 7, 8],
-                        notified: true,
-                        notify: JSON.stringify({ email: 'test@example.com', sent: true }),
-                        rawTx: [1, 2, 3, 4]
-                    };
-                    const r1 = await storage.updateProvenTxReq(record[primaryKey], testValues);
-                    expect(r1).toBe(1);
-                    const updatedRow = (0, index_all_1.verifyOne)(await storage.findProvenTxReqs({
-                        partial: { [primaryKey]: record[primaryKey] }
-                    }));
-                    for (const [key, value] of Object.entries(testValues)) {
-                        const actualValue = updatedRow[key];
-                        const normalizedActual = (0, TestUtilsWalletStorage_2.normalizeDate)(actualValue);
-                        const normalizedExpected = (0, TestUtilsWalletStorage_2.normalizeDate)(value);
-                        if (normalizedActual && normalizedExpected) {
-                            expect(normalizedActual).toBe(normalizedExpected);
-                            continue;
-                        }
-                        if (typeof value === 'string' && value.startsWith('{') && value.endsWith('}')) {
-                            expect(JSON.parse(actualValue)).toStrictEqual(JSON.parse(value));
-                            continue;
-                        }
-                        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
-                            expect(actualValue).toBe(value);
-                            continue;
-                        }
-                        if (typeof actualValue === 'object' && (actualValue === null || actualValue === void 0 ? void 0 : actualValue.type) === 'Buffer') {
-                            const actualArray = actualValue.data || actualValue;
-                            const expectedArray = Buffer.isBuffer(value) || Array.isArray(value) ? Array.from(value) : value;
-                            expect(actualArray).toStrictEqual(expectedArray);
-                            continue;
-                        }
-                        expect(JSON.stringify({ type: 'Buffer', data: actualValue })).toStrictEqual(JSON.stringify(value));
-                    }
-                }
-                catch (error) {
-                    console.error(`Error updating or verifying ProvenTxReq record with ${primaryKey}=${record[primaryKey]}:`, error.message);
-                    throw error;
-                }
-            }
-        }
-    });
-    test('3_update User', async () => {
-        const primaryKey = 'userId';
-        for (const { storage } of setups) {
-            const records = await storage.findUsers({ partial: {} });
-            for (const record of records) {
-                try {
-                    const testValues = {
-                        userId: record.userId,
-                        identityKey: `mockUpdatedIdentityKey-${record[primaryKey]}`,
-                        created_at: new Date('2024-12-30T23:00:00Z'),
-                        updated_at: new Date('2024-12-30T23:05:00Z'),
-                        activeStorage: storage.getSettings().storageIdentityKey
-                    };
-                    const updateResult = await storage.updateUser(record[primaryKey], testValues);
-                    expect(updateResult).toBe(1);
-                    const updatedRow = (0, index_all_1.verifyOne)(await storage.findUsers({
-                        partial: { [primaryKey]: record[primaryKey] }
-                    }));
-                    for (const [key, value] of Object.entries(testValues)) {
-                        const actualValue = updatedRow[key];
-                        const normalizedActual = (0, TestUtilsWalletStorage_2.normalizeDate)(actualValue);
-                        const normalizedExpected = (0, TestUtilsWalletStorage_2.normalizeDate)(value);
-                        if (normalizedActual && normalizedExpected) {
-                            expect(normalizedActual).toBe(normalizedExpected);
-                            continue;
-                        }
-                        expect(actualValue).toBe(value);
-                    }
-                }
-                catch (error) {
-                    console.error(`Error updating or verifying User record with ${primaryKey}=${record[primaryKey]}:`, error.message);
-                    throw error;
-                }
-            }
-        }
-    });
-    test('4_update Certificate', async () => {
-        for (const { storage } of setups) {
-            const primaryKey = 'certificateId';
-            const records = await storage.findCertificates({ partial: {} });
-            for (const record of records) {
-                try {
-                    const testValues = {
-                        certificateId: record.certificateId,
-                        userId: 1,
-                        certifier: `mockCertifier${record.certificateId}`,
-                        serialNumber: `mockSerialNumber${record.certificateId}`,
-                        type: `mockType${record.certificateId}`,
-                        created_at: new Date('2024-12-30T23:00:00Z'),
-                        updated_at: new Date('2024-12-30T23:05:00Z'),
-                        isDeleted: false,
-                        revocationOutpoint: 'mockRevocationOutpoint',
-                        signature: 'mockSignature',
-                        subject: 'mockSubject'
-                    };
-                    const r1 = await storage.updateCertificate(record[primaryKey], testValues);
-                    expect(r1).toBe(1);
-                    const updatedRow = (0, index_all_1.verifyOne)(await storage.findCertificates({
-                        partial: { [primaryKey]: record[primaryKey] }
-                    }));
-                    for (const [key, value] of Object.entries(testValues)) {
-                        const actualValue = updatedRow[key];
-                        const normalizedActual = (0, TestUtilsWalletStorage_2.normalizeDate)(actualValue);
-                        const normalizedExpected = (0, TestUtilsWalletStorage_2.normalizeDate)(value);
-                        if (normalizedActual && normalizedExpected) {
-                            expect(normalizedActual).toBe(normalizedExpected);
-                            continue;
-                        }
-                        if (typeof value === 'string' && value.startsWith('{') && value.endsWith('}')) {
-                            expect(JSON.parse(actualValue)).toStrictEqual(JSON.parse(value));
-                            continue;
-                        }
-                        if (typeof actualValue === 'boolean') {
-                            if (value === 1) {
-                                expect(actualValue).toBe(true);
-                            }
-                            else if (value === 0) {
-                                expect(actualValue).toBe(false);
-                            }
-                            else {
-                                throw new Error(`Unexpected value for expectedValue: ${value}. Must be 0 or 1.`);
-                            }
-                            continue;
-                        }
-                        if (typeof value === 'string' || typeof value === 'number') {
-                            expect(actualValue).toBe(value);
-                            continue;
-                        }
-                        if (typeof actualValue === 'object' && (actualValue === null || actualValue === void 0 ? void 0 : actualValue.type) === 'Buffer') {
-                            const actualArray = actualValue.data || actualValue;
-                            const expectedArray = Buffer.isBuffer(value) || Array.isArray(value) ? Array.from(value) : value;
-                            expect(actualArray).toStrictEqual(expectedArray);
-                            continue;
-                        }
-                        expect(JSON.stringify({ type: 'Buffer', data: actualValue })).toStrictEqual(JSON.stringify(value));
-                    }
-                }
-                catch (error) {
-                    console.error(`Error updating or verifying Certificate record with ${primaryKey}=${record[primaryKey]}:`, error.message);
-                    throw error;
-                }
-            }
-        }
-    });
-    test('5_update CertificateField', async () => {
-        var _a;
-        const primaryKey = 'certificateId';
-        for (const { storage } of setups) {
-            const records = await storage.findCertificateFields({
-                partial: { fieldName: 'bob' }
-            });
-            for (const record of records) {
-                try {
-                    const testValues = {
-                        certificateId: record.certificateId,
-                        userId: (_a = record.userId) !== null && _a !== void 0 ? _a : 1,
-                        created_at: new Date('2024-12-30T23:00:00Z'),
-                        updated_at: new Date('2024-12-30T23:05:00Z'),
-                        fieldName: record.fieldName || 'defaultFieldName',
-                        fieldValue: 'your uncle',
-                        masterKey: 'key'
-                    };
-                    const updateResult = await storage.updateCertificateField(record.certificateId, testValues.fieldName, testValues);
-                    expect(updateResult).toBe(1);
-                    const updatedRecords = await storage.findCertificateFields({
-                        partial: {
-                            certificateId: record.certificateId,
-                            fieldName: testValues.fieldName
-                        }
-                    });
-                    const updatedRow = (0, index_all_1.verifyOne)(updatedRecords, `Updated CertificateField with certificateId=${record.certificateId}, fieldName=${testValues.fieldName} was not unique or missing.`);
-                    for (const [key, value] of Object.entries(testValues)) {
-                        const actualValue = updatedRow[key];
-                        const normalizedActual = (0, TestUtilsWalletStorage_2.normalizeDate)(actualValue);
-                        const normalizedExpected = (0, TestUtilsWalletStorage_2.normalizeDate)(value);
-                        if (normalizedActual && normalizedExpected) {
-                            expect(normalizedActual).toBe(normalizedExpected);
-                            continue;
-                        }
-                        expect(actualValue).toBe(value);
-                    }
-                }
-                catch (error) {
-                    console.error(`Error updating or verifying CertificateField record with certificateId=${record[primaryKey]}:`, error.message);
-                    throw error;
-                }
-            }
-        }
-    });
-    test('6_update OutputBasket', async () => {
-        var _a;
-        const primaryKey = 'basketId';
-        for (const { storage } of setups) {
-            const records = await storage.findOutputBaskets({ partial: {} });
-            for (const record of records) {
-                try {
-                    const testValues = {
-                        basketId: record.basketId,
-                        userId: (_a = record.userId) !== null && _a !== void 0 ? _a : 1,
-                        created_at: new Date('2024-12-30T23:00:00Z'),
-                        updated_at: new Date('2024-12-30T23:05:00Z'),
-                        name: record.name || 'defaultName',
-                        numberOfDesiredUTXOs: 99,
-                        minimumDesiredUTXOValue: 5000,
-                        isDeleted: false
-                    };
-                    const updateResult = await storage.updateOutputBasket(record.basketId, testValues);
-                    expect(updateResult).toBe(1);
-                    const updatedRecords = await storage.findOutputBaskets({
-                        partial: { basketId: record.basketId, name: testValues.name }
-                    });
-                    const updatedRow = (0, index_all_1.verifyOne)(updatedRecords, `Updated OutputBasket with basketId=${record.basketId}, name=${testValues.name} was not unique or missing.`);
-                    for (const [key, value] of Object.entries(testValues)) {
-                        const actualValue = updatedRow[key];
-                        if (typeof actualValue === 'boolean') {
-                            if (value === 1) {
-                                expect(actualValue).toBe(true);
-                            }
-                            else if (value === 0) {
-                                expect(actualValue).toBe(false);
-                            }
-                            else {
-                                throw new Error(`Unexpected value for expectedValue: ${value}. Must be 0 or 1.`);
-                            }
-                            continue;
-                        }
-                        const normalizedActual = (0, TestUtilsWalletStorage_2.normalizeDate)(actualValue);
-                        const normalizedExpected = (0, TestUtilsWalletStorage_2.normalizeDate)(value);
-                        if (normalizedActual && normalizedExpected) {
-                            expect(normalizedActual).toBe(normalizedExpected);
-                            continue;
-                        }
-                        expect(actualValue).toBe(value);
-                    }
-                }
-                catch (error) {
-                    console.error(`Error updating or verifying OutputBasket record with basketId=${record[primaryKey]}:`, error.message);
-                    throw error;
-                }
-            }
-        }
-    });
-    test('7_update Transaction', async () => {
-        var _a;
-        const primaryKey = 'transactionId';
-        for (const { storage } of setups) {
-            const records = await storage.findTransactions({ partial: {} });
-            for (const record of records) {
-                try {
-                    const testValues = {
-                        transactionId: record.transactionId,
-                        userId: (_a = record.userId) !== null && _a !== void 0 ? _a : 1,
-                        provenTxId: 1,
-                        reference: `updated_reference_string_${record.transactionId}==`,
-                        status: 'confirmed',
-                        txid: `updated_txid_example_${record.transactionId}`,
-                        created_at: new Date('2024-12-30T23:00:00Z'),
-                        updated_at: new Date('2024-12-30T23:05:00Z'),
-                        description: 'Updated transaction description',
-                        isOutgoing: false,
-                        lockTime: 600000000,
-                        satoshis: 20000,
-                        version: 2
-                    };
-                    const updateResult = await storage.updateTransaction(record.transactionId, testValues);
-                    expect(updateResult).toBe(1);
-                    const updatedRecords = await storage.findTransactions({
-                        partial: { transactionId: record.transactionId }
-                    });
-                    const updatedRow = (0, index_all_1.verifyOne)(updatedRecords, `Updated Transaction with transactionId=${record.transactionId} was not unique or missing.`);
-                    for (const [key, value] of Object.entries(testValues)) {
-                        const actualValue = updatedRow[key];
-                        const normalizedActual = (0, TestUtilsWalletStorage_2.normalizeDate)(actualValue);
-                        const normalizedExpected = (0, TestUtilsWalletStorage_2.normalizeDate)(value);
-                        if (normalizedActual && normalizedExpected) {
-                            expect(normalizedActual).toBe(normalizedExpected);
-                            continue;
-                        }
-                        expect(actualValue).toBe(value);
-                    }
-                }
-                catch (error) {
-                    console.error(`Error updating or verifying Transaction record with transactionId=${record[primaryKey]}:`, error.message);
-                    throw error;
-                }
-            }
-        }
-    });
-    test('7a updateTransactionStatus', async () => {
-        const { activeStorage: storage } = await TestUtilsWalletStorage_1._tu.createLegacyWalletSQLiteCopy('updateTransactionStatus7a');
-        let tx = (0, index_all_1.verifyOne)(await storage.findTransactions({
-            partial: { status: 'unproven' },
-            paged: { limit: 1 }
-        }));
-        expect(tx.status).toBe('unproven');
-        await storage.updateTransactionStatus('completed', tx.transactionId);
-        tx = (0, index_all_1.verifyOne)(await storage.findTransactions({
-            partial: { transactionId: tx.transactionId }
-        }));
-        expect(tx.status).toBe('completed');
-        await storage.destroy();
-    });
-    test('8_update Commission', async () => {
-        var _a, _b;
-        const primaryKey = 'commissionId';
-        for (const { storage } of setups) {
-            const records = await storage.findCommissions({ partial: {} });
-            for (const record of records) {
-                try {
-                    const testValues = {
-                        commissionId: record.commissionId,
-                        userId: (_a = record.userId) !== null && _a !== void 0 ? _a : 1,
-                        transactionId: (_b = record.transactionId) !== null && _b !== void 0 ? _b : 1,
-                        created_at: new Date('2024-12-30T23:00:00Z'),
-                        updated_at: new Date('2024-12-30T23:05:00Z'),
-                        satoshis: 300,
-                        keyOffset: `updated_key_offset_${record.commissionId}`,
-                        isRedeemed: true,
-                        lockingScript: [1, 2, 3, 4]
-                    };
-                    const updateResult = await storage.updateCommission(record.commissionId, testValues);
-                    expect(updateResult).toBe(1);
-                    const updatedRecords = await storage.findCommissions({
-                        partial: { commissionId: record.commissionId }
-                    });
-                    const updatedRow = (0, index_all_1.verifyOne)(updatedRecords, `Updated Commission with commissionId=${record.commissionId} was not unique or missing.`);
-                    for (const [key, value] of Object.entries(testValues)) {
-                        const actualValue = updatedRow[key];
-                        const normalizedActual = (0, TestUtilsWalletStorage_2.normalizeDate)(actualValue);
-                        const normalizedExpected = (0, TestUtilsWalletStorage_2.normalizeDate)(value);
-                        if (normalizedActual && normalizedExpected) {
-                            expect(normalizedActual).toBe(normalizedExpected);
-                            continue;
-                        }
-                        if (Buffer.isBuffer(actualValue) || Array.isArray(actualValue)) {
-                            expect(JSON.stringify({ type: 'Buffer', data: actualValue })).toStrictEqual(JSON.stringify(value));
-                            continue;
-                        }
-                        expect(actualValue).toBe(value);
-                    }
-                }
-                catch (error) {
-                    console.error(`Error updating or verifying Commission record with commissionId=${record[primaryKey]}:`, error.message);
-                    throw error;
-                }
-            }
-        }
-    });
-    test('9_update Output', async () => {
-        var _a;
-        const primaryKey = 'outputId';
-        for (const { storage } of setups) {
-            const records = await storage.findOutputs({ partial: {} });
-            for (const record of records) {
-                if (!record.transactionId)
-                    record.transactionId = 1;
-                if (!record.basketId)
-                    record.basketId = 1;
-                if (!record.userId || !record.transactionId || !record.basketId) {
-                    throw new Error(`Missing required foreign keys for record ${JSON.stringify(record)}`);
-                }
-            }
-            for (const record of records) {
-                const existingRecords = await storage.findOutputs({ partial: {} });
-                const usedCombinations = new Set(existingRecords.map(r => `${r.transactionId}-${r.vout}-${r.userId}`));
-                let testTransactionId = record.transactionId;
-                let testVout = record.vout + 1;
-                let testUserId = record.userId;
-                while (usedCombinations.has(`${testTransactionId}-${testVout}-${testUserId}`)) {
-                    testVout += 1;
-                }
-                try {
-                    const testValues = {
-                        outputId: record.outputId,
-                        basketId: (_a = record.basketId) !== null && _a !== void 0 ? _a : 1,
-                        transactionId: testTransactionId,
-                        userId: testUserId,
-                        vout: testVout,
-                        created_at: new Date('2024-12-30T23:00:00Z'),
-                        updated_at: new Date('2024-12-30T23:05:00Z'),
-                        change: true,
-                        customInstructions: 'Updated instructions',
-                        derivationPrefix: 'updated_prefix==',
-                        derivationSuffix: 'updated_suffix==',
-                        lockingScript: [0x01, 0x02, 0x03, 0x04],
-                        providedBy: 'you',
-                        purpose: 'updated_purpose',
-                        satoshis: 3000,
-                        scriptLength: 150,
-                        scriptOffset: 5,
-                        senderIdentityKey: 'updated_sender_key',
-                        sequenceNumber: 10,
-                        spendingDescription: 'Updated spending description',
-                        spendable: false,
-                        spentBy: 3,
-                        txid: 'updated_txid',
-                        type: 'updated_type',
-                        outputDescription: 'outputDescription'
-                    };
-                    const updateResult = await storage.updateOutput(record.outputId, testValues);
-                    expect(updateResult).toBe(1);
-                    const updatedRecords = await storage.findOutputs({
-                        partial: { outputId: record.outputId }
-                    });
-                    const updatedRow = (0, index_all_1.verifyOne)(updatedRecords, `Updated Output with outputId=${record.outputId} was not unique or missing.`);
-                    for (const [key, value] of Object.entries(testValues)) {
-                        const actualValue = updatedRow[key];
-                        const normalizedActual = (0, TestUtilsWalletStorage_2.normalizeDate)(actualValue);
-                        const normalizedExpected = (0, TestUtilsWalletStorage_2.normalizeDate)(value);
-                        if (normalizedActual && normalizedExpected) {
-                            expect(normalizedActual).toBe(normalizedExpected);
-                            continue;
-                        }
-                        if (Buffer.isBuffer(actualValue) || Array.isArray(actualValue)) {
-                            expect(JSON.stringify({ type: 'Buffer', data: actualValue })).toStrictEqual(JSON.stringify(value));
-                            continue;
-                        }
-                        expect(actualValue).toBe(value);
-                    }
-                }
-                catch (error) {
-                    console.error(`Error updating or verifying Output record with outputId=${record[primaryKey]}:`, error.message);
-                    throw error;
-                }
-            }
-        }
-    });
-    test('10_update OutputTag', async () => {
-        const primaryKey = 'outputTagId';
-        for (const { storage } of setups) {
-            const records = await storage.findOutputTags({ partial: {} });
-            for (const record of records) {
-                if (!record.userId)
-                    record.userId = 1;
-                if (!record.tag)
-                    record.tag = `default_tag_${record.outputTagId}`;
-                if (!record.userId || !record.tag) {
-                    throw new Error(`Missing required fields for record ${JSON.stringify(record)}`);
-                }
-            }
-            for (const record of records) {
-                const uniqueTag = `updated_tag_${record.outputTagId}`;
-                const testValues = {
-                    outputTagId: record.outputTagId,
-                    userId: record.userId,
-                    tag: uniqueTag,
-                    created_at: new Date('2024-12-30T23:00:00Z'),
-                    updated_at: new Date('2024-12-30T23:05:00Z'),
-                    isDeleted: false
-                };
-                try {
-                    const updateResult = await storage.updateOutputTag(record.outputTagId, testValues);
-                    expect(updateResult).toBe(1);
-                    const updatedRecords = await storage.findOutputTags({
-                        partial: { outputTagId: record.outputTagId }
-                    });
-                    const updatedRow = (0, index_all_1.verifyOne)(updatedRecords, `Updated OutputTag with outputTagId=${record.outputTagId} was not unique or missing.`);
-                    for (const [key, value] of Object.entries(testValues)) {
-                        const actualValue = updatedRow[key];
-                        if (typeof actualValue === 'boolean') {
-                            if (value === 1) {
-                                expect(actualValue).toBe(true);
-                            }
-                            else if (value === 0) {
-                                expect(actualValue).toBe(false);
-                            }
-                            else {
-                                throw new Error(`Unexpected value for expectedValue: ${value}. Must be 0 or 1.`);
-                            }
-                            continue;
-                        }
-                        const normalizedActual = (0, TestUtilsWalletStorage_2.normalizeDate)(actualValue);
-                        const normalizedExpected = (0, TestUtilsWalletStorage_2.normalizeDate)(value);
-                        if (normalizedActual && normalizedExpected) {
-                            expect(normalizedActual).toBe(normalizedExpected);
-                            continue;
-                        }
-                        expect(actualValue).toBe(value);
-                    }
-                }
-                catch (error) {
-                    console.error(`Error updating or verifying OutputTag record with outputTagId=${record[primaryKey]}:`, error.message);
-                    throw error;
-                }
-            }
-        }
-    });
-    test('11_update OutputTagMap', async () => {
-        const primaryKey = ['outputTagId', 'outputId'];
-        for (const { storage } of setups) {
-            const records = await storage.findOutputTagMaps({ partial: {} });
-            for (const record of records) {
-                if (!record.outputTagId)
-                    throw new Error(`Missing outputTagId for record: ${JSON.stringify(record)}`);
-                if (!record.outputId)
-                    throw new Error(`Missing outputId for record: ${JSON.stringify(record)}`);
-                try {
-                    const testValues = {
-                        outputTagId: record.outputTagId,
-                        outputId: record.outputId,
-                        created_at: new Date('2024-12-30T23:00:00Z'),
-                        updated_at: new Date('2024-12-30T23:05:00Z'),
-                        isDeleted: false
-                    };
-                    const updateResult = await storage.updateOutputTagMap(record.outputId, record.outputTagId, testValues);
-                    expect(updateResult).toBe(1);
-                    const updatedRecords = await storage.findOutputTagMaps({
-                        partial: {
-                            outputTagId: record.outputTagId,
-                            outputId: record.outputId
-                        }
-                    });
-                    const updatedRow = (0, index_all_1.verifyOne)(updatedRecords, `Updated OutputTagMap with outputTagId=${record.outputTagId} and outputId=${record.outputId} was not unique or missing.`);
-                    for (const [key, value] of Object.entries(testValues)) {
-                        const actualValue = updatedRow[key];
-                        if (typeof actualValue === 'boolean') {
-                            if (value === 1) {
-                                expect(actualValue).toBe(true);
-                            }
-                            else if (value === 0) {
-                                expect(actualValue).toBe(false);
-                            }
-                            else {
-                                throw new Error(`Unexpected value for expectedValue: ${value}. Must be 0 or 1.`);
-                            }
-                            continue;
-                        }
-                        const normalizedActual = (0, TestUtilsWalletStorage_2.normalizeDate)(actualValue);
-                        const normalizedExpected = (0, TestUtilsWalletStorage_2.normalizeDate)(value);
-                        if (normalizedActual && normalizedExpected) {
-                            expect(normalizedActual).toBe(normalizedExpected);
-                            continue;
-                        }
-                        expect(actualValue).toBe(value);
-                    }
-                }
-                catch (error) {
-                    console.error(`Error updating or verifying OutputTagMap record with outputTagId=${record.outputTagId} and outputId=${record.outputId}:`, error.message);
-                    throw error;
-                }
-            }
-        }
-    });
-    test('12_update TxLabel', async () => {
-        const primaryKey = 'txLabelId';
-        for (const { storage } of setups) {
-            const records = await storage.findTxLabels({ partial: {} });
-            for (const record of records) {
-                if (!record.userId) {
-                    throw new Error(`Missing required foreign key userId for record ${JSON.stringify(record)}`);
-                }
-            }
-            for (const record of records) {
-                const uniqueLabel = `unique_label_${record.txLabelId}`;
-                const testValues = {
-                    txLabelId: record.txLabelId,
-                    userId: record.userId,
-                    label: uniqueLabel,
-                    isDeleted: false,
-                    created_at: new Date('2024-12-30T23:00:00Z'),
-                    updated_at: new Date('2024-12-30T23:05:00Z')
-                };
-                const existingLabel = await storage.findTxLabels({
-                    partial: { label: testValues.label, userId: testValues.userId }
-                });
-                if (existingLabel.length > 0) {
-                    continue;
-                }
-                const updateResult = await storage.updateTxLabel(record.txLabelId, testValues);
-                expect(updateResult).toBe(1);
-                const updatedRecords = await storage.findTxLabels({
-                    partial: { txLabelId: record.txLabelId }
-                });
-                const updatedRow = (0, index_all_1.verifyOne)(updatedRecords, `Updated TxLabel with txLabelId=${record.txLabelId} was not unique or missing.`);
-                for (const [key, value] of Object.entries(testValues)) {
-                    const actualValue = updatedRow[key];
-                    if (typeof actualValue === 'boolean') {
-                        if (value === 1) {
-                            expect(actualValue).toBe(true);
-                        }
-                        else if (value === 0) {
-                            expect(actualValue).toBe(false);
-                        }
-                        else {
-                            throw new Error(`Unexpected value for expectedValue: ${value}. Must be 0 or 1.`);
-                        }
-                        continue;
-                    }
-                    const normalizedActual = (0, TestUtilsWalletStorage_2.normalizeDate)(actualValue);
-                    const normalizedExpected = (0, TestUtilsWalletStorage_2.normalizeDate)(value);
-                    if (normalizedActual && normalizedExpected) {
-                        expect(normalizedActual).toBe(normalizedExpected);
-                        continue;
-                    }
-                    expect(actualValue).toBe(value);
-                }
-            }
-        }
-    });
-    test('13_update TxLabelMap', async () => {
-        const primaryKeyTransaction = 'transactionId';
-        const primaryKeyLabel = 'txLabelId';
-        for (const { storage, setup } of setups) {
-            const records = await storage.findTxLabelMaps({ partial: {} });
-            for (const record of records) {
-                if (!record.transactionId || !record.txLabelId) {
-                    throw new Error(`Missing required foreign keys for record ${JSON.stringify(record)}`);
-                }
-            }
-            for (const record of records) {
-                const testValues = {
-                    transactionId: record.transactionId,
-                    txLabelId: record.txLabelId,
-                    created_at: new Date('2024-12-30T23:00:00Z'),
-                    updated_at: new Date('2024-12-30T23:05:00Z'),
-                    isDeleted: false
-                };
-                const existingRecord = await storage.findTxLabelMaps({
-                    partial: {
-                        transactionId: testValues.transactionId,
-                        txLabelId: testValues.txLabelId
-                    }
-                });
-                if (existingRecord.length > 0) {
-                    continue;
-                }
-                try {
-                    const updateResult = await storage.updateTxLabelMap(record.transactionId, record.txLabelId, testValues);
-                    expect(updateResult).toBe(1);
-                    const updatedRecords = await storage.findTxLabelMaps({
-                        partial: {
-                            transactionId: record.transactionId,
-                            txLabelId: record.txLabelId
-                        }
-                    });
-                    const updatedRow = (0, index_all_1.verifyOne)(updatedRecords, `Updated TxLabelMap with transactionId=${record[primaryKeyTransaction]} and txLabelId=${record[primaryKeyLabel]} was not unique or missing.`);
-                    for (const [key, value] of Object.entries(testValues)) {
-                        const actualValue = updatedRow[key];
-                        const normalizedActual = (0, TestUtilsWalletStorage_2.normalizeDate)(actualValue);
-                        const normalizedExpected = (0, TestUtilsWalletStorage_2.normalizeDate)(value);
-                        if (normalizedActual && normalizedExpected) {
-                            expect(normalizedActual).toBe(normalizedExpected);
-                            continue;
-                        }
-                        expect(actualValue).toBe(value);
-                    }
-                }
-                catch (error) {
-                    console.error(`Error updating or verifying TxLabelMap record with transactionId=${record[primaryKeyTransaction]} and txLabelId=${record[primaryKeyLabel]}:`, error.message);
-                    throw error;
-                }
-            }
-        }
-    });
-    test('14_update MonitorEvent', async () => {
-        const primaryKey = 'id';
-        for (const { storage, setup } of setups) {
-            const records = await storage.findMonitorEvents({ partial: {} });
-            for (const record of records) {
-                try {
-                    const testValues = {
-                        id: record.id,
-                        created_at: new Date('2024-12-30T23:00:00Z'),
-                        updated_at: new Date('2024-12-30T23:05:00Z'),
-                        event: 'updated_event',
-                        details: 'Updated details'
-                    };
-                    const updateResult = await storage.updateMonitorEvent(record.id, testValues);
-                    expect(updateResult).toBe(1);
-                    const updatedRecords = await storage.findMonitorEvents({
-                        partial: { id: record.id }
-                    });
-                    const updatedRow = (0, index_all_1.verifyOne)(updatedRecords, `Updated MonitorEvent with id=${record.id} was not unique or missing.`);
-                    for (const [key, value] of Object.entries(testValues)) {
-                        const actualValue = updatedRow[key];
-                        const normalizedActual = (0, TestUtilsWalletStorage_2.normalizeDate)(actualValue);
-                        const normalizedExpected = (0, TestUtilsWalletStorage_2.normalizeDate)(value);
-                        if (normalizedActual && normalizedExpected) {
-                            expect(normalizedActual).toBe(normalizedExpected);
-                            continue;
-                        }
-                        expect(actualValue).toBe(value);
-                    }
-                }
-                catch (error) {
-                    console.error(`Error updating or verifying MonitorEvent record with id=${record[primaryKey]}:`, error.message);
-                    throw error;
-                }
-            }
-        }
-    });
-    test('15_update SyncState', async () => {
-        const primaryKey = 'syncStateId';
-        for (const { storage } of setups) {
-            const records = await storage.findSyncStates({ partial: {} });
-            for (const record of records) {
-                if (!record.userId) {
-                    throw new Error(`Missing required foreign key userId for record ${JSON.stringify(record)}`);
-                }
-            }
-            for (const record of records) {
-                const testValues = {
-                    syncStateId: record.syncStateId,
-                    userId: record.userId,
-                    refNum: 'test_refNum',
-                    created_at: new Date('2025-01-01T00:00:00.000Z'),
-                    updated_at: new Date('2025-01-01T00:00:00.000Z'),
-                    errorLocal: 'Example local error',
-                    errorOther: 'Example other error',
-                    init: false,
-                    satoshis: 1000,
-                    status: 'success',
-                    storageIdentityKey: 'test_identity_key',
-                    storageName: 'test_storage',
-                    syncMap: '{}',
-                    when: new Date('2025-01-01T02:00:00.000Z')
-                };
-                const updateResult = await storage.updateSyncState(record.syncStateId, testValues);
-                expect(updateResult).toBe(1);
-                const updatedRecords = await storage.findSyncStates({
-                    partial: { syncStateId: record.syncStateId }
-                });
-                const updatedRow = (0, index_all_1.verifyOne)(updatedRecords, `Updated SyncState with syncStateId=${record.syncStateId} was not unique or missing.`);
-                for (const [key, value] of Object.entries(testValues)) {
-                    const actualValue = updatedRow[key];
-                    if (typeof actualValue === 'boolean') {
-                        if (value === 1) {
-                            expect(actualValue).toBe(true);
-                        }
-                        else if (value === 0) {
-                            expect(actualValue).toBe(false);
-                        }
-                        else {
-                            throw new Error(`Unexpected value for expectedValue: ${value}. Must be 0 or 1.`);
-                        }
-                        continue;
-                    }
-                    if (actualValue instanceof Date) {
-                        const actualDate = new Date(actualValue);
-                        const expectedDate = new Date(value);
-                        expect(actualDate.getTime()).toBe(expectedDate.getTime());
-                        continue;
-                    }
-                    if (value === undefined || value === null) {
-                        expect(actualValue).toBeNull();
-                        continue;
-                    }
-                    if (key === 'refNum') {
-                        expect(actualValue).toBe('test_refNum');
-                        continue;
-                    }
-                    expect(actualValue).toStrictEqual(value);
-                }
-            }
-        }
-    });
-});
-//# sourceMappingURL=update.test.js.map