@bsv/wallet-toolbox 1.1.0

package/src/storage/schema/entities/__tests/CertificateTests.test.ts

@@ -0,0 +1,527 @@
+import { entity, table, sdk } from '../../../../../src'
+import {
+  TestUtilsWalletStorage as _tu,
+  TestWalletNoSetup
+} from '../../../../../test/utils/TestUtilsWalletStorage'
+import { Certificate } from '../../../../../src/storage/schema/entities/Certificate'
+
+describe('Certificate class method tests', () => {
+  jest.setTimeout(99999999)
+
+  const env = _tu.getEnv('test')
+  const ctxs: TestWalletNoSetup[] = []
+  const ctxs2: TestWalletNoSetup[] = []
+
+  beforeAll(async () => {
+    if (env.runMySQL) {
+      ctxs.push(await _tu.createLegacyWalletMySQLCopy('CertificateTests'))
+      ctxs2.push(await _tu.createLegacyWalletMySQLCopy('CertificateTests2'))
+    }
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('CertificateTests'))
+    ctxs2.push(await _tu.createLegacyWalletSQLiteCopy('CertificateTests2'))
+  })
+
+  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 Certificate entities', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Insert initial Certificate record
+      const now = new Date()
+      const certificateId = 500 // Unique ID for this test
+      const certificateData: table.Certificate = {
+        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)
+
+      // Create two Certificate entities from the same data
+      const entity1 = new Certificate(certificateData)
+      const entity2 = new Certificate(certificateData)
+
+      // Validate equals returns true for identical entities
+      expect(entity1.equals(entity2.toApi())).toBe(true)
+    }
+  })
+
+  test('1_equals identifies non-matching Certificate entities', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Insert initial Certificate record
+      const now = new Date()
+      const certificateId1 = 501
+      const certificateId2 = 502
+      const certificateData1: table.Certificate = {
+        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
+      }
+      const certificateData2: table.Certificate = {
+        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
+      }
+
+      await activeStorage.insertCertificate(certificateData1)
+      await activeStorage.insertCertificate(certificateData2)
+
+      // Create Certificate entities with mismatched data
+      const entity1 = new Certificate(certificateData1)
+      const entity2 = new Certificate(certificateData2)
+
+      // Validate equals returns false for mismatched entities
+      expect(entity1.equals(entity2.toApi())).toBe(false)
+
+      // Test each mismatched field individually
+      const mismatchedEntities: Partial<table.Certificate>[] = [
+        { type: 'differentType' },
+        { subject: 'differentSubject' },
+        { serialNumber: 'differentSerialNumber' },
+        { revocationOutpoint: 'differentOutpoint:0' },
+        { signature: 'differentSignature' },
+        { verifier: 'differentVerifier' },
+        { isDeleted: !certificateData1.isDeleted }
+      ]
+
+      for (const mismatch of mismatchedEntities) {
+        const mismatchedEntity = new Certificate({
+          ...certificateData1,
+          ...mismatch
+        })
+        expect(entity1.equals(mismatchedEntity.toApi())).toBe(false)
+      }
+    }
+  })
+
+  test('2_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 = 600
+      const certificateData: table.Certificate = {
+        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
+      }
+
+      await activeStorage.insertCertificate(certificateData)
+
+      // Create a Certificate entity from the initial data
+      const entity = new Certificate(certificateData)
+
+      // Simulate the `ei` argument with a later `updated_at`
+      const updatedData: table.Certificate = {
+        ...certificateData,
+        updated_at: new Date(now.getTime() + 1000), // Later timestamp
+        type: 'updatedType',
+        subject: 'updatedSubject',
+        serialNumber: 'updatedSerialNumber',
+        revocationOutpoint: 'updatedOutpoint:1',
+        signature: 'updatedSignature',
+        verifier: 'updatedVerifier',
+        isDeleted: true
+      }
+
+      // Call mergeExisting
+      const wasMergedRaw = await entity.mergeExisting(
+        activeStorage,
+        undefined, // `since` is not used in this method
+        updatedData,
+        {
+          certificate: {
+            idMap: { [certificateId]: certificateId },
+            entityName: 'Certificate',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          outputBasket: {
+            idMap: {},
+            entityName: 'OutputBasket',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          transaction: {
+            idMap: {},
+            entityName: 'Transaction',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          output: {
+            idMap: {},
+            entityName: 'Output',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          provenTx: {
+            idMap: {},
+            entityName: 'ProvenTx',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          outputTag: {
+            idMap: {},
+            entityName: 'OutputTag',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          provenTxReq: {
+            idMap: {},
+            entityName: 'ProvenTxReq',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          txLabel: {
+            idMap: {},
+            entityName: 'TxLabel',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          txLabelMap: {
+            idMap: {},
+            entityName: 'TxLabelMap',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          outputTagMap: {
+            idMap: {},
+            entityName: 'OutputTagMap',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          certificateField: {
+            idMap: {},
+            entityName: 'CertificateField',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          commission: {
+            idMap: {},
+            entityName: 'Commission',
+            maxUpdated_at: undefined,
+            count: 0
+          }
+        },
+        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.type).toBe('updatedType')
+      expect(entity.subject).toBe('updatedSubject')
+      expect(entity.serialNumber).toBe('updatedSerialNumber')
+      expect(entity.revocationOutpoint).toBe('updatedOutpoint:1')
+      expect(entity.signature).toBe('updatedSignature')
+      expect(entity.verifier).toBe('updatedVerifier')
+      expect(entity.isDeleted).toBe(1)
+
+      // Verify that the database is updated
+      const updatedRecord = await activeStorage.findCertificates({
+        partial: { certificateId }
+      })
+      expect(updatedRecord.length).toBe(1)
+      expect(updatedRecord[0]).toBeDefined()
+      expect(updatedRecord[0].type).toBe('updatedType')
+      expect(updatedRecord[0].subject).toBe('updatedSubject')
+      expect(updatedRecord[0].serialNumber).toBe('updatedSerialNumber')
+      expect(updatedRecord[0].revocationOutpoint).toBe('updatedOutpoint:1')
+      expect(updatedRecord[0].signature).toBe('updatedSignature')
+      expect(updatedRecord[0].verifier).toBe('updatedVerifier')
+      expect(updatedRecord[0].isDeleted).toBe(true)
+    }
+  })
+
+  test('3_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 = 601
+      const certificateData: table.Certificate = {
+        certificateId,
+        created_at: now,
+        updated_at: now,
+        userId: 1,
+        type: 'exampleType',
+        serialNumber: 'exampleSerialNumber',
+        certifier:
+          '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef1234',
+        subject:
+          '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef5678',
+        revocationOutpoint:
+          'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890:0',
+        signature:
+          'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
+        isDeleted: false
+      }
+
+      await activeStorage.insertCertificate(certificateData)
+
+      // Create a Certificate entity from the initial data
+      const entity = new Certificate(certificateData)
+
+      // Simulate the `ei` argument with the same or earlier `updated_at`
+      const sameUpdatedData: table.Certificate = {
+        ...certificateData,
+        updated_at: now, // Same timestamp
+        type: 'unchangedType',
+        subject: 'unchangedSubject',
+        serialNumber: 'unchangedSerialNumber',
+        revocationOutpoint: 'unchangedOutpoint:0',
+        signature: 'unchangedSignature',
+        verifier: 'unchangedVerifier',
+        isDeleted: false
+      }
+
+      // Call mergeExisting
+      const wasMergedRaw = await entity.mergeExisting(
+        activeStorage,
+        undefined, // `since` is not used
+        sameUpdatedData,
+        {
+          certificate: {
+            idMap: { [certificateId]: certificateId },
+            entityName: 'Certificate',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          outputBasket: {
+            idMap: {},
+            entityName: 'OutputBasket',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          transaction: {
+            idMap: {},
+            entityName: 'Transaction',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          output: {
+            idMap: {},
+            entityName: 'Output',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          provenTx: {
+            idMap: {},
+            entityName: 'ProvenTx',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          outputTag: {
+            idMap: {},
+            entityName: 'OutputTag',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          provenTxReq: {
+            idMap: {},
+            entityName: 'ProvenTxReq',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          txLabel: {
+            idMap: {},
+            entityName: 'TxLabel',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          txLabelMap: {
+            idMap: {},
+            entityName: 'TxLabelMap',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          outputTagMap: {
+            idMap: {},
+            entityName: 'OutputTagMap',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          certificateField: {
+            idMap: {},
+            entityName: 'CertificateField',
+            maxUpdated_at: undefined,
+            count: 0
+          },
+          commission: {
+            idMap: {},
+            entityName: 'Commission',
+            maxUpdated_at: undefined,
+            count: 0
+          }
+        },
+        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.type).toBe('exampleType')
+      expect(entity.subject).toBe(
+        '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef5678'
+      )
+      expect(entity.serialNumber).toBe('exampleSerialNumber')
+      expect(entity.revocationOutpoint).toBe(
+        'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890:0'
+      )
+      expect(entity.signature).toBe(
+        'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890'
+      )
+      expect(entity.isDeleted).toBe(0)
+
+      // Verify that the database is not updated
+      const unchangedRecord = await activeStorage.findCertificates({
+        partial: { certificateId }
+      })
+      expect(unchangedRecord.length).toBe(1)
+      expect(unchangedRecord[0]).toBeDefined()
+      expect(unchangedRecord[0].type).toBe('exampleType')
+      expect(unchangedRecord[0].subject).toBe(
+        '02c123eabcdeff1234567890abcdef1234567890abcdef1234567890abcdef5678'
+      )
+      expect(unchangedRecord[0].serialNumber).toBe('exampleSerialNumber')
+      expect(unchangedRecord[0].revocationOutpoint).toBe(
+        'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890:0'
+      )
+      expect(unchangedRecord[0].signature).toBe(
+        'abcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890'
+      )
+      expect(unchangedRecord[0].isDeleted).toBe(false)
+    }
+  })
+
+  test('4_Certificate class getters and setters', async () => {
+    for (const { activeStorage } of ctxs) {
+      const now = new Date()
+
+      // Initial test data
+      const initialData: table.Certificate = {
+        certificateId: 701,
+        created_at: now,
+        updated_at: now,
+        userId: 1,
+        type: 'initialType',
+        subject: 'initialSubject',
+        verifier: 'initialVerifier',
+        serialNumber: 'initialSerialNumber',
+        certifier: 'initialCertifier',
+        revocationOutpoint: 'initialOutpoint:0',
+        signature: 'initialSignature',
+        isDeleted: false
+      }
+
+      // Create the Certificate entity
+      const entity = new Certificate(initialData)
+
+      // Validate getters
+      expect(entity.certificateId).toBe(initialData.certificateId)
+      expect(entity.created_at).toEqual(initialData.created_at)
+      expect(entity.updated_at).toEqual(initialData.updated_at)
+      expect(entity.userId).toBe(initialData.userId)
+      expect(entity.type).toBe(initialData.type)
+      expect(entity.subject).toBe(initialData.subject)
+      expect(entity.verifier).toBe(initialData.verifier)
+      expect(entity.serialNumber).toBe(initialData.serialNumber)
+      expect(entity.certifier).toBe(initialData.certifier)
+      expect(entity.revocationOutpoint).toBe(initialData.revocationOutpoint)
+      expect(entity.signature).toBe(initialData.signature)
+      expect(entity.isDeleted).toBe(initialData.isDeleted)
+      expect(entity.id).toBe(initialData.certificateId)
+      expect(entity.entityName).toBe('entity.Certificate')
+      expect(entity.entityTable).toBe('certificates')
+
+      // Validate setters
+      entity.certificateId = 800
+      entity.created_at = new Date('2025-01-01')
+      entity.updated_at = new Date('2025-01-02')
+      entity.userId = 2
+      entity.type = 'updatedType'
+      entity.subject = 'updatedSubject'
+      entity.verifier = 'updatedVerifier'
+      entity.serialNumber = 'updatedSerialNumber'
+      entity.certifier = 'updatedCertifier'
+      entity.revocationOutpoint = 'updatedOutpoint:1'
+      entity.signature = 'updatedSignature'
+      entity.isDeleted = true
+      entity.id = 900
+
+      // Validate updated values via getters
+      expect(entity.certificateId).toBe(900)
+      expect(entity.created_at).toEqual(new Date('2025-01-01'))
+      expect(entity.updated_at).toEqual(new Date('2025-01-02'))
+      expect(entity.userId).toBe(2)
+      expect(entity.type).toBe('updatedType')
+      expect(entity.subject).toBe('updatedSubject')
+      expect(entity.verifier).toBe('updatedVerifier')
+      expect(entity.serialNumber).toBe('updatedSerialNumber')
+      expect(entity.certifier).toBe('updatedCertifier')
+      expect(entity.revocationOutpoint).toBe('updatedOutpoint:1')
+      expect(entity.signature).toBe('updatedSignature')
+      expect(entity.isDeleted).toBe(true)
+      expect(entity.id).toBe(900)
+      expect(entity.entityName).toBe('entity.Certificate')
+      expect(entity.entityTable).toBe('certificates')
+    }
+  })
+})