@bsv/wallet-toolbox 1.1.0

package/out/test/storage/update2.test.js

@@ -0,0 +1,766 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* Additional update tests for setting edge cases and exercising contraints (unique/foreign) */
+/* Requires a new DB for each test                                                           */
+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);
+const knex_1 = __importDefault(require("knex"));
+describe('update2 tests', () => {
+    const storages = [];
+    const setups = [];
+    const chain = 'test';
+    const createDB = async (databaseName) => {
+        const localSQLiteFile = await TestUtilsWalletStorage_1._tu.newTmpFile(`${databaseName}.sqlite`, false, false, true);
+        // Need to pool connections
+        const knexSQLite = (0, knex_1.default)({
+            client: 'sqlite3',
+            connection: {
+                filename: localSQLiteFile
+            },
+            useNullAsDefault: true,
+            pool: {
+                min: 1,
+                max: 5
+            }
+        });
+        const storage = new index_all_1.StorageKnex({
+            ...index_all_1.StorageKnex.defaultOptions(),
+            knex: knexSQLite,
+            chain
+        });
+        storages.push(storage);
+        await storage.dropAllData();
+        await storage.migrate('test setup', '1'.repeat(64));
+        const setup = await TestUtilsWalletStorage_1._tu.createTestSetup1(storage);
+        setups.push({ setup, storage });
+    };
+    afterEach(async () => {
+        for (const storage of storages) {
+            if (storage instanceof index_all_1.StorageKnex) {
+                await storage.knex.destroy();
+            }
+        }
+        storages.length = 0;
+        setups.length = 0;
+    });
+    test('1_update ProvenTx', async () => {
+        await createDB('ProvenTx1');
+        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('2_update ProvenTx', async () => {
+        await createDB('ProvenTx2');
+        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('3_update ProvenTx set created_at and updated_at time', async () => {
+        await createDB('ProvenTx3');
+        for (const { storage } of setups) {
+            const scenarios = [
+                {
+                    description: 'Invalid created_at time',
+                    updates: {
+                        created_at: new Date('3000-01-01T00:00:00Z'),
+                        updated_at: new Date('2024-12-30T23:05:00Z')
+                    }
+                },
+                {
+                    description: 'Invalid updated_at time',
+                    updates: {
+                        created_at: new Date('2024-12-30T23:00:00Z'),
+                        updated_at: new Date('3000-01-01T00:00:00Z')
+                    }
+                },
+                {
+                    description: 'created_at time overwrites updated_at time',
+                    updates: {
+                        created_at: new Date('2024-12-30T23:00:00Z'),
+                        updated_at: new Date('2024-12-30T23:05:00Z')
+                    }
+                }
+            ];
+            for (const { updates } of scenarios) {
+                const referenceTime = new Date();
+                const records = await storage.findProvenTxs({ partial: {} });
+                for (const record of records) {
+                    await storage.updateProvenTx(record.provenTxId, {
+                        created_at: updates.created_at
+                    });
+                    await storage.updateProvenTx(record.provenTxId, {
+                        updated_at: updates.updated_at
+                    });
+                    const t = (0, index_all_1.verifyOne)(await storage.findProvenTxs({
+                        partial: { provenTxId: record.provenTxId }
+                    }));
+                    expect((0, TestUtilsWalletStorage_2.validateUpdateTime)(t.created_at, updates.created_at, referenceTime, 10, false)).toBe(true);
+                    expect((0, TestUtilsWalletStorage_2.validateUpdateTime)(t.updated_at, updates.updated_at, referenceTime, 10, false)).toBe(true);
+                }
+            }
+        }
+    });
+    test('4_update ProvenTx setting individual values', async () => {
+        var _a;
+        await createDB('ProvenTx4');
+        for (const { storage } of setups) {
+            const initialRecord = {
+                provenTxId: 3,
+                txid: 'mockTxid',
+                created_at: new Date(),
+                updated_at: new Date(),
+                blockHash: '',
+                height: 1,
+                index: 1,
+                merklePath: [],
+                merkleRoot: '',
+                rawTx: []
+            };
+            try {
+                const r = await storage.insertProvenTx(initialRecord);
+                expect(r).toBeGreaterThan(0);
+                const insertedRecords = await storage.findProvenTxs({ partial: {} });
+                expect(insertedRecords.length).toBeGreaterThan(0);
+                const foundRecord = insertedRecords.find(record => record.provenTxId === 3);
+                expect(foundRecord).toBeDefined();
+                expect(foundRecord === null || foundRecord === void 0 ? void 0 : foundRecord.txid).toBe('mockTxid');
+            }
+            catch (error) {
+                console.error('Error inserting initial record:', error.message);
+                return;
+            }
+            await expect(storage.updateProvenTx(1, { provenTxId: 0 })).rejects.toThrow(/FOREIGN KEY constraint failed/);
+            const r1 = await storage.updateProvenTx(3, { provenTxId: 0 });
+            await expect(Promise.resolve(r1)).resolves.toBe(1);
+            const r2 = await storage.findProvenTxs({ partial: {} });
+            expect(r2[0].provenTxId).toBe(0);
+            expect(r2[1].provenTxId).toBe(1);
+            const r3 = await storage.updateProvenTx(0, { provenTxId: 3 });
+            await expect(Promise.resolve(r3)).resolves.toBe(1);
+            const r4 = await storage.findProvenTxs({ partial: {} });
+            expect(r4[0].provenTxId).toBe(1);
+            expect(r4[1].provenTxId).toBe(3);
+            const r8 = await storage.updateProvenTx(3, { txid: 'mockValidTxid' });
+            await expect(Promise.resolve(r8)).resolves.toBe(1);
+            const r9 = await storage.findProvenTxs({ partial: {} });
+            expect((_a = r9.find(r => r.provenTxId === 3)) === null || _a === void 0 ? void 0 : _a.txid).toBe('mockValidTxid');
+        }
+    });
+    test('5_update ProvenTxReq', async () => {
+        await createDB('ProvenTx5');
+        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('6_update ProvenTxReq set created_at and updated_at time', async () => {
+        await createDB('ProvenTxReq6');
+        for (const { storage } of setups) {
+            const scenarios = [
+                {
+                    description: 'Invalid created_at time',
+                    updates: {
+                        created_at: new Date('3000-01-01T00:00:00Z'),
+                        updated_at: new Date('2024-12-30T23:05:00Z')
+                    }
+                },
+                {
+                    description: 'Invalid updated_at time',
+                    updates: {
+                        created_at: new Date('2024-12-30T23:00:00Z'),
+                        updated_at: new Date('3000-01-01T00:00:00Z')
+                    }
+                },
+                {
+                    description: 'created_at time overwrites updated_at time',
+                    updates: {
+                        created_at: new Date('2024-12-30T23:00:00Z'),
+                        updated_at: new Date('2024-12-30T23:05:00Z')
+                    }
+                }
+            ];
+            for (const { updates } of scenarios) {
+                const referenceTime = new Date();
+                const records = await storage.findProvenTxReqs({ partial: {} });
+                for (const record of records) {
+                    await storage.updateProvenTxReq(record.provenTxReqId, {
+                        created_at: updates.created_at
+                    });
+                    await storage.updateProvenTxReq(record.provenTxReqId, {
+                        updated_at: updates.updated_at
+                    });
+                    const t = (0, index_all_1.verifyOne)(await storage.findProvenTxReqs({
+                        partial: { provenTxReqId: record.provenTxReqId }
+                    }));
+                    expect((0, TestUtilsWalletStorage_2.validateUpdateTime)(t.created_at, updates.created_at, referenceTime)).toBe(true);
+                    expect((0, TestUtilsWalletStorage_2.validateUpdateTime)(t.updated_at, updates.updated_at, referenceTime)).toBe(true);
+                }
+            }
+        }
+    });
+    test('7_update ProvenTxReq setting individual values', async () => {
+        var _a, _b;
+        await createDB('ProvenTxReq7');
+        for (const { storage } of setups) {
+            const referenceTime = new Date();
+            const initialRecord = {
+                provenTxReqId: 3,
+                provenTxId: 1,
+                batch: 'batch',
+                status: 'nosend',
+                txid: 'mockTxid1',
+                created_at: referenceTime,
+                updated_at: referenceTime,
+                attempts: 0,
+                history: '{}',
+                inputBEEF: [],
+                notified: false,
+                notify: '{}',
+                rawTx: []
+            };
+            await storage.insertProvenTxReq(initialRecord);
+            const secondRecord = {
+                ...initialRecord,
+                provenTxReqId: 4,
+                txid: 'mockTxid2'
+            };
+            await storage.insertProvenTxReq(secondRecord);
+            const recordToUpdate3 = await storage.findProvenTxReqs({
+                partial: { provenTxReqId: 3 }
+            });
+            expect(recordToUpdate3.length).toBeGreaterThan(0);
+            const recordToUpdate4 = await storage.findProvenTxReqs({
+                partial: { provenTxReqId: 4 }
+            });
+            expect(recordToUpdate4.length).toBeGreaterThan(0);
+            const r3 = await storage.updateProvenTxReq(3, { batch: 'updatedBatch' });
+            await expect(Promise.resolve(r3)).resolves.toBe(1);
+            const updatedRecords = await storage.findProvenTxReqs({ partial: {} });
+            const updatedBatch = (_a = updatedRecords.find(r => r.provenTxReqId === 3)) === null || _a === void 0 ? void 0 : _a.batch;
+            expect(updatedBatch).toBe('updatedBatch');
+            try {
+                const r4 = await storage.updateProvenTxReq(4, { batch: 'updatedBatch' });
+                if (r4 === 0) {
+                    console.warn('No rows updated. Ensure UNIQUE constraint exists on the batch column if rejection is expected.');
+                }
+                else {
+                    await expect(Promise.resolve(r4)).resolves.toBe(1);
+                }
+            }
+            catch (error) {
+                expect(error.message).toMatch(/UNIQUE constraint failed/);
+            }
+            const r5 = await storage.updateProvenTxReq(3, { txid: 'newValidTxid' });
+            await expect(Promise.resolve(r5)).resolves.toBe(1);
+            await expect(storage.updateProvenTxReq(4, { txid: 'newValidTxid' })).rejects.toThrow(/UNIQUE constraint failed/);
+            const finalRecords = await storage.findProvenTxReqs({ partial: {} });
+            expect((_b = finalRecords.find(r => r.provenTxReqId === 4)) === null || _b === void 0 ? void 0 : _b.txid).toBe('mockTxid2');
+            await storage.updateProvenTxReq(3, { batch: 'batch', txid: 'mockTxid1' });
+        }
+    });
+    test('8_update User', async () => {
+        await createDB('User8');
+        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')
+                    };
+                    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('9_update User set created_at and updated_at time', async () => {
+        await createDB('User9');
+        for (const { storage } of setups) {
+            const scenarios = [
+                {
+                    description: 'Invalid created_at time',
+                    updates: {
+                        created_at: new Date('3000-01-01T00:00:00Z'),
+                        updated_at: new Date('2024-12-30T23:05:00Z')
+                    }
+                },
+                {
+                    description: 'Invalid updated_at time',
+                    updates: {
+                        created_at: new Date('2024-12-30T23:00:00Z'),
+                        updated_at: new Date('3000-01-01T00:00:00Z')
+                    }
+                },
+                {
+                    description: 'created_at time overwrites updated_at time',
+                    updates: {
+                        created_at: new Date('2024-12-30T23:00:00Z'),
+                        updated_at: new Date('2024-12-30T23:05:00Z')
+                    }
+                }
+            ];
+            for (const { description, updates } of scenarios) {
+                const referenceTime = new Date();
+                const records = await storage.findUsers({ partial: {} });
+                for (const record of records) {
+                    await storage.updateUser(record.userId, {
+                        created_at: updates.created_at
+                    });
+                    await storage.updateUser(record.userId, {
+                        updated_at: updates.updated_at
+                    });
+                    const t = (0, index_all_1.verifyOne)(await storage.findUsers({ partial: { userId: record.userId } }));
+                    expect((0, TestUtilsWalletStorage_2.validateUpdateTime)(t.created_at, updates.created_at, referenceTime)).toBe(true);
+                    expect((0, TestUtilsWalletStorage_2.validateUpdateTime)(t.updated_at, updates.updated_at, referenceTime)).toBe(true);
+                }
+            }
+        }
+    });
+    test('10_update User trigger DB unique constraint errors', async () => {
+        await createDB('User10');
+        for (const { storage } of setups) {
+            try {
+                const r = await storage.updateUser(2, {
+                    identityKey: 'mockDupIdentityKey'
+                });
+                await expect(Promise.resolve(r)).resolves.toBe(1);
+            }
+            catch (error) {
+                console.error('Error updating second record:', error.message);
+                return;
+            }
+            const r1 = await (0, TestUtilsWalletStorage_2.triggerUniqueConstraintError)(storage, 'findUsers', 'updateUser', 'users', 'userId', { userId: 2 });
+            await expect(Promise.resolve(r1)).resolves.toBe(true);
+            const r2 = await (0, TestUtilsWalletStorage_2.triggerUniqueConstraintError)(storage, 'findUsers', 'updateUser', 'users', 'userId', { identityKey: 'mockDupIdentityKey' });
+            await expect(Promise.resolve(r2)).resolves.toBe(true);
+            const r3 = await (0, TestUtilsWalletStorage_2.triggerUniqueConstraintError)(storage, 'findUsers', 'updateUser', 'users', 'userId', { identityKey: 'mockUniqueIdentityKey' });
+            await expect(Promise.resolve(r3)).resolves.toBe(false);
+        }
+    });
+    test('11_update User trigger DB foreign key constraint errors', async () => {
+        await createDB('User11');
+        for (const { storage } of setups) {
+            const r1 = await (0, TestUtilsWalletStorage_2.triggerForeignKeyConstraintError)(storage, 'findUsers', 'updateUser', 'users', 'userId', { userId: 0 });
+            await expect(Promise.resolve(r1)).resolves.toBe(true);
+            const r2 = await (0, TestUtilsWalletStorage_2.triggerForeignKeyConstraintError)(storage, 'findUsers', 'updateUser', 'users', 'userId', { userId: 3 }, 0);
+            await expect(Promise.resolve(r2)).resolves.toBe(false);
+        }
+    });
+    test('12_update User table setting individual values', async () => {
+        await createDB('User12');
+        for (const { storage } of setups) {
+            const initialRecord = {
+                userId: 3,
+                identityKey: '',
+                created_at: new Date(),
+                updated_at: new Date()
+            };
+            try {
+                const r = await storage.insertUser(initialRecord);
+                expect(r).toBeGreaterThan(1);
+            }
+            catch (error) {
+                console.error('Error inserting initial record:', error.message);
+                return;
+            }
+            await expect(storage.updateUser(1, { userId: 0 })).rejects.toThrow(/FOREIGN KEY constraint failed/);
+            await expect(storage.updateUser(2, { userId: 0 })).rejects.toThrow(/FOREIGN KEY constraint failed/);
+            const r1 = await storage.updateUser(3, { userId: 0 });
+            await expect(Promise.resolve(r1)).resolves.toBe(1);
+            const r2 = await storage.findUsers({ partial: {} });
+            expect(r2[0].userId).toBe(0);
+            expect(r2[1].userId).toBe(1);
+            expect(r2[2].userId).toBe(2);
+            const r3 = await storage.updateUser(0, { userId: 3 });
+            await expect(Promise.resolve(r3)).resolves.toBe(1);
+            const r4 = await storage.findUsers({ partial: {} });
+            expect(r4[0].userId).toBe(1);
+            expect(r4[1].userId).toBe(2);
+            expect(r4[2].userId).toBe(3);
+            const r5 = await storage.updateUser(3, { userId: 9999 });
+            await expect(Promise.resolve(r5)).resolves.toBe(1);
+            const r6 = await storage.findUsers({ partial: {} });
+            expect(r6[0].userId).toBe(1);
+            expect(r6[1].userId).toBe(2);
+            expect(r6[2].userId).toBe(9999);
+            await expect(storage.updateUser(1, { userId: 9999 })).rejects.toThrow(/UNIQUE constraint failed/);
+            const r7 = await storage.findUsers({ partial: {} });
+            expect(r7[0].userId).toBe(1);
+            expect(r7[1].userId).toBe(2);
+            expect(r7[2].userId).toBe(9999);
+            const r8 = await storage.updateUser(9999, {
+                identityKey: 'mockValidIdentityKey'
+            });
+            await expect(Promise.resolve(r8)).resolves.toBe(1);
+            const r9 = await storage.findUsers({ partial: {} });
+            expect(r9[0].identityKey).not.toBe('mockValidIdentityKey');
+            expect(r9[1].identityKey).not.toBe('mockValidIdentityKey');
+            expect(r9[2].identityKey).toBe('mockValidIdentityKey');
+            await expect(storage.updateUser(2, { identityKey: 'mockValidIdentityKey' })).rejects.toThrow(/UNIQUE constraint failed/);
+            const r10 = await storage.findUsers({ partial: {} });
+            expect(r10[0].identityKey).not.toBe('mockValidIdentityKey');
+            expect(r10[1].identityKey).not.toBe('mockValidIdentityKey');
+            expect(r10[2].identityKey).toBe('mockValidIdentityKey');
+            const r11 = await storage.updateUser(9999, { userId: 3 });
+            await expect(Promise.resolve(r11)).resolves.toBe(1);
+            const r12 = await storage.findUsers({ partial: {} });
+            expect(r12[0].userId).toBe(1);
+            expect(r12[1].userId).toBe(2);
+            expect(r12[2].userId).toBe(3);
+            const createdAt = new Date('2024-12-30T23:00:00Z');
+            const updatedAt = new Date('2024-12-30T23:05:00Z');
+            const r13 = await storage.updateUser(3, {
+                created_at: createdAt,
+                updated_at: updatedAt
+            });
+            await expect(Promise.resolve(r13)).resolves.toBe(1);
+            const r14 = await storage.findUsers({ partial: {} });
+            const updatedRecord = r14.find(record => record.userId === 3);
+            expect(updatedRecord === null || updatedRecord === void 0 ? void 0 : updatedRecord.created_at).toEqual(createdAt);
+            expect(updatedRecord === null || updatedRecord === void 0 ? void 0 : updatedRecord.updated_at).toEqual(updatedAt);
+        }
+    });
+    test('13_update Certificate', async () => {
+        await createDB('Certificate13');
+        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('14_update Certificate set created_at and updated_at time', async () => {
+        await createDB('Certificate14');
+        for (const { storage } of setups) {
+            const scenarios = [
+                {
+                    description: 'Invalid created_at time',
+                    updates: {
+                        created_at: new Date('3000-01-01T00:00:00Z'),
+                        updated_at: new Date('2024-12-30T23:05:00Z')
+                    }
+                },
+                {
+                    description: 'Invalid updated_at time',
+                    updates: {
+                        created_at: new Date('2024-12-30T23:00:00Z'),
+                        updated_at: new Date('3000-01-01T00:00:00Z')
+                    }
+                },
+                {
+                    description: 'created_at time overwrites updated_at time',
+                    updates: {
+                        created_at: new Date('2024-12-30T23:00:00Z'),
+                        updated_at: new Date('2024-12-30T23:05:00Z')
+                    }
+                }
+            ];
+            for (const { updates } of scenarios) {
+                const referenceTime = new Date();
+                const records = await storage.findCertificates({ partial: {} });
+                for (const record of records) {
+                    await storage.updateUser(record.certificateId, {
+                        created_at: updates.created_at
+                    });
+                    await storage.updateUser(record.certificateId, {
+                        updated_at: updates.updated_at
+                    });
+                    const t = (0, index_all_1.verifyOne)(await storage.findCertificates({
+                        partial: { certificateId: record.certificateId }
+                    }));
+                    expect((0, TestUtilsWalletStorage_2.validateUpdateTime)(t.created_at, updates.created_at, referenceTime)).toBe(true);
+                    expect((0, TestUtilsWalletStorage_2.validateUpdateTime)(t.updated_at, updates.updated_at, referenceTime)).toBe(true);
+                }
+            }
+        }
+    });
+    test('15_update Certificate trigger DB unique constraint errors', async () => {
+        await createDB('Certificate15');
+        for (const { storage } of setups) {
+            const initMockDupValues = {
+                userId: 2,
+                type: `mockType2`,
+                certifier: `mockCertifier2`,
+                serialNumber: `mockSerialNumber2`
+            };
+            try {
+                const r = await storage.updateCertificate(2, initMockDupValues);
+                await expect(Promise.resolve(r)).resolves.toBe(1);
+            }
+            catch (error) {
+                console.error('Error updating second record:', error.message);
+            }
+            const mockDupValues = {
+                userId: 2,
+                type: `mockType2`,
+                certifier: `mockCertifier2`,
+                serialNumber: `mockSerialNumber2`
+            };
+            const mockUniqueValues = {
+                userId: 2,
+                type: `mockTypeUnique`,
+                certifier: `mockCertifier2`,
+                serialNumber: `mockSerialNumber2`
+            };
+            const r1 = await (0, TestUtilsWalletStorage_2.triggerUniqueConstraintError)(storage, 'findCertificates', 'updateCertificate', 'certificates', 'certificateId', { certificateId: 2 });
+            await expect(Promise.resolve(r1)).resolves.toBe(true);
+            const r2 = await (0, TestUtilsWalletStorage_2.triggerUniqueConstraintError)(storage, 'findCertificates', 'updateCertificate', 'certificates', 'certificateId', mockDupValues);
+            await expect(Promise.resolve(r2)).resolves.toBe(true);
+            const r3 = await (0, TestUtilsWalletStorage_2.triggerUniqueConstraintError)(storage, 'findCertificates', 'updateCertificate', 'certificates', 'certificateId', mockUniqueValues);
+            await expect(Promise.resolve(r3)).resolves.toBe(false);
+        }
+    });
+    test('16_update Certificate trigger DB foreign key constraint errors', async () => {
+        await createDB('Certificate16');
+        for (const { storage } of setups) {
+            const r1 = await (0, TestUtilsWalletStorage_2.triggerForeignKeyConstraintError)(storage, 'findCertificates', 'updateCertificate', 'certificates', 'certificateId', { certificateId: 0 });
+            await expect(Promise.resolve(r1)).resolves.toBe(true);
+            const r2 = await (0, TestUtilsWalletStorage_2.triggerForeignKeyConstraintError)(storage, 'findCertificates', 'updateCertificate', 'certificates', 'certificateId', { certificateId: 1 }, 0);
+            await expect(Promise.resolve(r2)).resolves.toBe(false);
+            const r3 = await (0, TestUtilsWalletStorage_2.triggerForeignKeyConstraintError)(storage, 'findCertificates', 'updateCertificate', 'certificates', 'certificateId', { userId: 0 });
+            await expect(Promise.resolve(r3)).resolves.toBe(true);
+            const r4 = await (0, TestUtilsWalletStorage_2.triggerForeignKeyConstraintError)(storage, 'findCertificates', 'updateCertificate', 'certificates', 'certificateId', { userId: 1 }, 2);
+            await expect(Promise.resolve(r4)).resolves.toBe(false);
+        }
+    });
+});
+//# sourceMappingURL=update2.test.js.map