@bsv/wallet-toolbox
Version:
BRC100 conforming wallet, wallet storage and wallet signer components
301 lines • 15.8 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const src_1 = require("../../../../../src");
const TestUtilsWalletStorage_1 = require("../../../../../test/utils/TestUtilsWalletStorage");
const EntityCertificateField_1 = require("../EntityCertificateField");
describe('CertificateField class method tests', () => {
jest.setTimeout(99999999);
const env = TestUtilsWalletStorage_1.TestUtilsWalletStorage.getEnv('test');
const ctxs = [];
const ctxs2 = [];
beforeAll(async () => {
if (env.runMySQL) {
ctxs.push(await TestUtilsWalletStorage_1.TestUtilsWalletStorage.createLegacyWalletMySQLCopy('CertificateFieldTests'));
ctxs2.push(await TestUtilsWalletStorage_1.TestUtilsWalletStorage.createLegacyWalletMySQLCopy('CertificateFieldTests2'));
}
ctxs.push(await TestUtilsWalletStorage_1.TestUtilsWalletStorage.createLegacyWalletSQLiteCopy('CertificateFieldTests'));
ctxs2.push(await TestUtilsWalletStorage_1.TestUtilsWalletStorage.createLegacyWalletSQLiteCopy('CertificateFieldTests2'));
});
afterAll(async () => {
for (const ctx of ctxs) {
await ctx.storage.destroy();
}
for (const ctx of ctxs2) {
await ctx.storage.destroy();
}
});
test('0_equals identifies matching CertificateField entities', async () => {
for (const { activeStorage } of ctxs) {
// Insert a valid Certificate to satisfy foreign key constraints
const now = new Date();
const certificateId = 300; // Ensure this ID is unique in the `certificates` table
const certificateData = {
certificateId,
created_at: now,
updated_at: now,
userId: 1,
type: Buffer.from('exampleType').toString('base64'), // Base64-encoded string
serialNumber: Buffer.from('serial123').toString('base64'), // Base64-encoded string
certifier: '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef1234', // PubKeyHex
subject: '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef5678', // PubKeyHex
revocationOutpoint: 'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890:0', // OutpointString
signature: 'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890', // HexString
isDeleted: false
};
await activeStorage.insertCertificate(certificateData);
// Insert initial CertificateField record
const initialData = {
certificateId,
created_at: now,
updated_at: now,
userId: 1,
fieldName: 'field1',
fieldValue: 'value1',
masterKey: 'masterKey1'
};
await activeStorage.insertCertificateField(initialData);
// Create two CertificateField entities from the same data
const entity1 = new EntityCertificateField_1.EntityCertificateField(initialData);
const entity2 = new EntityCertificateField_1.EntityCertificateField(initialData);
// Create a valid SyncMap
const syncMap = (0, src_1.createSyncMap)();
syncMap.certificate.idMap[certificateId] = certificateId;
// Test: equals returns true for identical entities without SyncMap
expect(entity1.equals(entity2.toApi())).toBe(true);
// Test: equals returns true for identical entities with SyncMap
expect(entity1.equals(entity2.toApi(), syncMap)).toBe(true);
}
});
test('1_equals identifies non-matching CertificateField entities', async () => {
for (const { activeStorage } of ctxs) {
// Insert a valid Certificate to satisfy foreign key constraints
const now = new Date();
const certificateId1 = 301; // Ensure this ID is unique in the `certificates` table
const certificateId2 = 302;
// Adjusted certificate data for uniqueness
await activeStorage.insertCertificate({
certificateId: certificateId1,
created_at: now,
updated_at: now,
userId: 1,
type: Buffer.from('exampleType1').toString('base64'), // Unique Base64-encoded string
serialNumber: Buffer.from('serial123-1').toString('base64'), // Unique Base64-encoded string
certifier: '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef1234', // Same PubKeyHex
subject: '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef5678', // Same PubKeyHex
revocationOutpoint: 'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890:0', // Same OutpointString
signature: 'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890', // Same HexString
isDeleted: false
});
await activeStorage.insertCertificate({
certificateId: certificateId2,
created_at: now,
updated_at: now,
userId: 1,
type: Buffer.from('exampleType2').toString('base64'), // Unique Base64-encoded string
serialNumber: Buffer.from('serial123-2').toString('base64'), // Unique Base64-encoded string
certifier: '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef5678', // Same PubKeyHex
subject: '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef5678', // Same PubKeyHex
revocationOutpoint: 'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890:1', // Unique OutpointString
signature: 'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890', // Same HexString
isDeleted: false
});
// Insert initial CertificateField record
const initialData = {
certificateId: certificateId1,
created_at: now,
updated_at: now,
userId: 1,
fieldName: 'field1',
fieldValue: 'value1',
masterKey: 'masterKey1'
};
await activeStorage.insertCertificateField(initialData);
// Create a CertificateField entity from the initial data
const entity1 = new EntityCertificateField_1.EntityCertificateField(initialData);
// Create mismatched entities and test each condition
const mismatchedEntities = [
{ certificateId: certificateId2 }, // Requires valid certificate
{ fieldName: 'field2' },
{ fieldValue: 'value2' },
{ masterKey: 'masterKey2' }
];
for (const mismatch of mismatchedEntities) {
const mismatchedEntity = new EntityCertificateField_1.EntityCertificateField({
...initialData,
...mismatch
});
expect(entity1.equals(mismatchedEntity.toApi())).toBe(false);
// Test with SyncMap, where certificateId is resolved
const syncMap = (0, src_1.createSyncMap)();
syncMap.certificate.idMap[certificateId1] = certificateId1;
syncMap.certificate.idMap[certificateId2] = certificateId2;
expect(entity1.equals(mismatchedEntity.toApi(), syncMap)).toBe(false);
}
}
});
test('mergeExisting updates entity and database when ei.updated_at > this.updated_at', async () => {
for (const { activeStorage } of ctxs) {
// Insert a valid Certificate to satisfy foreign key constraints
const now = new Date();
const certificateId = 400;
await activeStorage.insertCertificate({
certificateId,
created_at: now,
updated_at: now,
userId: 1,
type: Buffer.from('exampleTypeMerge').toString('base64'),
serialNumber: Buffer.from('serialMerge123').toString('base64'),
certifier: '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef1234',
subject: '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef5678',
revocationOutpoint: 'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890:0',
signature: 'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
isDeleted: false
});
// Insert the initial CertificateField record
const initialData = {
certificateId,
created_at: now,
updated_at: now,
userId: 1,
fieldName: 'field1',
fieldValue: 'value1',
masterKey: 'masterKey1'
};
await activeStorage.insertCertificateField(initialData);
// Create a CertificateField entity from the initial data
const entity = new EntityCertificateField_1.EntityCertificateField(initialData);
// Simulate the `ei` argument with a later `updated_at`
const updatedData = {
...initialData,
updated_at: new Date(now.getTime() + 1000), // Later timestamp
fieldValue: 'updatedValue',
masterKey: 'updatedMasterKey'
};
const syncMap = (0, src_1.createSyncMap)();
syncMap.certificate.idMap[certificateId] = certificateId;
// Call mergeExisting
const wasMergedRaw = await entity.mergeExisting(activeStorage, undefined, // `since` is not used in this method
updatedData, syncMap, undefined // `trx` is not used
);
const wasMerged = Boolean(wasMergedRaw);
// Verify that wasMerged is true
expect(wasMerged).toBe(true);
// Verify that the entity is updated
expect(entity.fieldValue).toBe('updatedValue');
expect(entity.masterKey).toBe('updatedMasterKey');
// Verify that the database is updated
const updatedRecord = await activeStorage.findCertificateFields({
partial: { certificateId, fieldName: 'field1' }
});
expect(updatedRecord.length).toBe(1);
expect(updatedRecord[0]).toBeDefined();
expect(updatedRecord[0].fieldValue).toBe('updatedValue');
expect(updatedRecord[0].masterKey).toBe('updatedMasterKey');
}
});
test('mergeExisting does not update entity when ei.updated_at <= this.updated_at', async () => {
for (const { activeStorage } of ctxs) {
// Insert a valid Certificate to satisfy foreign key constraints
const now = new Date();
const certificateId = 401;
await activeStorage.insertCertificate({
certificateId,
created_at: now,
updated_at: now,
userId: 1,
type: Buffer.from('exampleTypeNoMerge').toString('base64'),
serialNumber: Buffer.from('serialNoMerge123').toString('base64'),
certifier: '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef1234',
subject: '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef5678',
revocationOutpoint: 'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890:0',
signature: 'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
isDeleted: false
});
// Insert the initial CertificateField record
const initialData = {
certificateId,
created_at: now,
updated_at: now,
userId: 1,
fieldName: 'field1',
fieldValue: 'value1',
masterKey: 'masterKey1'
};
await activeStorage.insertCertificateField(initialData);
// Create a CertificateField entity from the initial data
const entity = new EntityCertificateField_1.EntityCertificateField(initialData);
// Simulate the `ei` argument with the same `updated_at`
const sameUpdatedData = {
...initialData,
updated_at: now, // Same timestamp
fieldValue: 'unchangedValue',
masterKey: 'unchangedMasterKey'
};
const syncMap = (0, src_1.createSyncMap)();
syncMap.certificate.idMap[certificateId] = certificateId;
// Call mergeExisting
const wasMergedRaw = await entity.mergeExisting(activeStorage, undefined, // `since` is not used
sameUpdatedData, syncMap, undefined // `trx` is not used
);
const wasMerged = Boolean(wasMergedRaw);
// Verify that wasMerged is false
expect(wasMerged).toBe(false);
// Verify that the entity is not updated
expect(entity.fieldValue).toBe('value1');
expect(entity.masterKey).toBe('masterKey1');
// Verify that the database is not updated
const unchangedRecord = await activeStorage.findCertificateFields({
partial: { certificateId, fieldName: 'field1' }
});
expect(unchangedRecord.length).toBe(1);
expect(unchangedRecord[0]).toBeDefined();
expect(unchangedRecord[0].fieldValue).toBe('value1');
expect(unchangedRecord[0].masterKey).toBe('masterKey1');
}
});
test('CertificateField getters and setters', async () => {
const now = new Date();
// Initial data for the test
const initialData = {
userId: 1,
certificateId: 500,
created_at: now,
updated_at: now,
fieldName: 'fieldName1',
fieldValue: 'fieldValue1',
masterKey: 'masterKey1'
};
// Create a CertificateField entity
const entity = new EntityCertificateField_1.EntityCertificateField(initialData);
// Validate getters
expect(entity.userId).toBe(1);
expect(entity.certificateId).toBe(500);
expect(entity.created_at).toEqual(now);
expect(entity.updated_at).toEqual(now);
expect(entity.fieldName).toBe('fieldName1');
expect(entity.fieldValue).toBe('fieldValue1');
expect(entity.masterKey).toBe('masterKey1');
// Validate overridden properties
expect(() => entity.id).toThrowError('entity has no "id" value');
expect(entity.entityName).toBe('certificateField');
expect(entity.entityTable).toBe('certificate_fields');
// Validate setters
const newDate = new Date(now.getTime() + 1000);
entity.userId = 2;
entity.certificateId = 600;
entity.created_at = new Date('2025-01-01');
entity.updated_at = newDate;
entity.fieldName = 'updatedFieldName';
entity.fieldValue = 'updatedFieldValue';
entity.masterKey = 'updatedMasterKey';
// Assert the updated values
expect(entity.userId).toBe(2);
expect(entity.certificateId).toBe(600);
expect(entity.created_at).toEqual(new Date('2025-01-01'));
expect(entity.updated_at).toEqual(newDate);
expect(entity.fieldName).toBe('updatedFieldName');
expect(entity.fieldValue).toBe('updatedFieldValue');
expect(entity.masterKey).toBe('updatedMasterKey');
});
});
//# sourceMappingURL=CertificateFieldTests.test.js.map