@bopen-io/wallet-toolbox 1.7.18

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

@@ -0,0 +1,371 @@
+import { createSyncMap, sdk, SyncMap, TableCommission, TableTransaction } from '../../../../../src'
+import { TestUtilsWalletStorage as _tu, TestWalletNoSetup } from '../../../../../test/utils/TestUtilsWalletStorage'
+import { EntityCommission } from '../EntityCommission'
+
+describe('Commission 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('CommissionTests'))
+      ctxs2.push(await _tu.createLegacyWalletMySQLCopy('CommissionTests2'))
+    }
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('CommissionTests'))
+    ctxs2.push(await _tu.createLegacyWalletSQLiteCopy('CommissionTests2'))
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+    for (const ctx of ctxs2) {
+      await ctx.storage.destroy()
+    }
+  })
+  // Test: equals returns true for identical Commission entities
+  test('0_equals identifies matching Commission entities', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Generate a unique transactionId
+      const transactionId = 192
+
+      // Insert the transaction to satisfy the foreign key constraint
+      const now = new Date()
+      const transactionData: TableTransaction = {
+        transactionId,
+        created_at: now,
+        updated_at: now,
+        userId: 1,
+        txid: 'unique-txid',
+        status: 'sending',
+        reference: 'test-transaction',
+        isOutgoing: false,
+        satoshis: 1000,
+        description: 'Test transaction'
+      }
+
+      await activeStorage.insertTransaction(transactionData)
+
+      // Insert initial Commission record
+      const initialData: TableCommission = {
+        commissionId: 801,
+        created_at: now,
+        updated_at: now,
+        transactionId,
+        userId: 1,
+        isRedeemed: false,
+        keyOffset: 'offset123',
+        lockingScript: [1, 2, 3],
+        satoshis: 500
+      }
+
+      await activeStorage.insertCommission(initialData)
+
+      // Create two Commission entities from the same data
+      const entity1 = new EntityCommission(initialData)
+      const entity2 = new EntityCommission(initialData)
+
+      const syncMap = createSyncMap()
+      syncMap.transaction.idMap[transactionId] = transactionId
+
+      // 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: equals identifies non-matching Commission entities
+  test('1_equals identifies non-matching Commission entities', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Generate unique transactionIds
+      const transactionId1 = 200
+      const transactionId2 = 201
+
+      // Insert the first transaction to satisfy the foreign key constraint
+      const now = new Date()
+      const transactionData1: TableTransaction = {
+        transactionId: transactionId1,
+        created_at: now,
+        updated_at: now,
+        userId: 1,
+        txid: 'unique-txid-1',
+        status: 'sending',
+        reference: 'test-transaction-1',
+        isOutgoing: false,
+        satoshis: 1000,
+        description: 'Test transaction 1'
+      }
+      await activeStorage.insertTransaction(transactionData1)
+
+      // Insert the second transaction to satisfy the foreign key constraint for mismatched data
+      const transactionData2: TableTransaction = {
+        transactionId: transactionId2,
+        created_at: now,
+        updated_at: now,
+        userId: 1,
+        txid: 'unique-txid-2',
+        status: 'sending',
+        reference: 'test-transaction-2',
+        isOutgoing: false,
+        satoshis: 2000,
+        description: 'Test transaction 2'
+      }
+      await activeStorage.insertTransaction(transactionData2)
+
+      // Insert initial Commission record
+      const initialData: TableCommission = {
+        commissionId: 802,
+        created_at: now,
+        updated_at: now,
+        transactionId: transactionId1,
+        userId: 1,
+        isRedeemed: false,
+        keyOffset: 'offset123',
+        lockingScript: [1, 2, 3],
+        satoshis: 500
+      }
+      await activeStorage.insertCommission(initialData)
+
+      // Create a Commission entity from the initial data
+      const entity1 = new EntityCommission(initialData)
+
+      // Create mismatched entities and test each condition
+      const mismatchedEntities: Partial<TableCommission>[] = [
+        { isRedeemed: true },
+        { transactionId: transactionId2 }, // Requires valid transaction
+        { keyOffset: 'offset456' },
+        { lockingScript: [4, 5, 6] },
+        { satoshis: 1000 }
+      ]
+
+      for (const mismatch of mismatchedEntities) {
+        const mismatchedEntity = new EntityCommission({
+          ...initialData,
+          ...mismatch
+        })
+        expect(entity1.equals(mismatchedEntity.toApi())).toBe(false)
+
+        const syncMap = createSyncMap()
+        syncMap.transaction.idMap[transactionId1] = transactionId1
+        syncMap.transaction.idMap[transactionId2] = transactionId2
+
+        expect(entity1.equals(mismatchedEntity.toApi(), syncMap)).toBe(false)
+      }
+    }
+  })
+
+  // Test: mergeExisting updates entity and database when ei.updated_at > this.updated_at
+  test('2_mergeExisting updates entity and database when ei.updated_at > this.updated_at', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Generate unique transactionId
+      const transactionId = 203
+
+      // Insert a valid transaction to satisfy foreign key constraints
+      const now = new Date()
+      const transactionData: TableTransaction = {
+        transactionId,
+        created_at: now,
+        updated_at: now,
+        userId: 1,
+        txid: 'unique-txid',
+        status: 'sending',
+        reference: 'test-transaction-5',
+        isOutgoing: false,
+        satoshis: 1000,
+        description: 'Test transaction'
+      }
+      await activeStorage.insertTransaction(transactionData)
+
+      // Insert the initial Commission record
+      const initialData: TableCommission = {
+        commissionId: 803,
+        created_at: now,
+        updated_at: now,
+        transactionId,
+        userId: 1,
+        isRedeemed: false,
+        keyOffset: 'offset123',
+        lockingScript: [1, 2, 3],
+        satoshis: 500
+      }
+      await activeStorage.insertCommission(initialData)
+
+      // Create a Commission entity from the initial data
+      const entity = new EntityCommission(initialData)
+
+      // Simulate the `ei` argument with a later `updated_at`
+      const updatedData: TableCommission = {
+        ...initialData,
+        updated_at: new Date(now.getTime() + 1000),
+        isRedeemed: true
+      }
+
+      const syncMap = createSyncMap()
+      syncMap.transaction.idMap[transactionId] = transactionId
+
+      // Call mergeExisting
+      const wasMergedRaw = await entity.mergeExisting(
+        activeStorage,
+        undefined, // `since` is not used
+        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.isRedeemed).toBe(true)
+
+      // Verify that the database is updated
+      const updatedRecord = await activeStorage.findCommissions({
+        partial: { commissionId: 803 }
+      })
+      expect(updatedRecord.length).toBe(1)
+      expect(updatedRecord[0]).toBeDefined()
+      expect(updatedRecord[0].isRedeemed).toBe(true)
+    }
+  })
+
+  // Test: mergeExisting does not update when ei.updated_at <= this.updated_at
+  test('3_mergeExisting does not update when ei.updated_at <= this.updated_at', async () => {
+    for (const { activeStorage } of ctxs) {
+      // Generate unique transactionId
+      const transactionId = 193
+
+      // Insert a valid transaction to satisfy foreign key constraints
+      const now = new Date()
+      const transactionData: TableTransaction = {
+        transactionId,
+        created_at: now,
+        updated_at: now,
+        userId: 1,
+        txid: 'unique-txid-193',
+        status: 'sending',
+        reference: 'test-transaction-6',
+        isOutgoing: false,
+        satoshis: 1000,
+        description: 'Test transaction'
+      }
+      await activeStorage.insertTransaction(transactionData)
+
+      // Insert the initial Commission record
+      const initialData: TableCommission = {
+        commissionId: 804,
+        created_at: now,
+        updated_at: now,
+        transactionId,
+        userId: 1,
+        isRedeemed: false,
+        keyOffset: 'offset123',
+        lockingScript: [1, 2, 3],
+        satoshis: 500
+      }
+      await activeStorage.insertCommission(initialData)
+
+      // Create a Commission entity from the initial data
+      const entity = new EntityCommission(initialData)
+
+      // Simulate the `ei` argument with an earlier or equal `updated_at`
+      const olderOrEqualData: TableCommission = {
+        ...initialData,
+        updated_at: new Date(now.getTime()),
+        isRedeemed: true
+      }
+
+      const syncMap = createSyncMap()
+      syncMap.transaction.idMap[transactionId] = transactionId
+
+      // Call mergeExisting
+      const wasMergedRaw = await entity.mergeExisting(
+        activeStorage,
+        undefined,
+        olderOrEqualData,
+        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.isRedeemed).toBe(false)
+
+      // Verify that the database is not updated
+      const record = await activeStorage.findCommissions({
+        partial: { commissionId: 802 }
+      })
+      expect(record.length).toBe(1)
+      expect(record[0]).toBeDefined()
+      expect(record[0].isRedeemed).toBe(false)
+    }
+  })
+
+  // Test: Commission entity getters and setters
+  test('4_Commission entity getters and setters', async () => {
+    const now = new Date()
+
+    // Initial test data
+    const initialData: TableCommission = {
+      commissionId: 801,
+      created_at: now,
+      updated_at: now,
+      transactionId: 101,
+      userId: 1,
+      isRedeemed: false,
+      keyOffset: 'offset123',
+      lockingScript: [1, 2, 3],
+      satoshis: 500
+    }
+
+    // Create the Commission entity
+    const entity = new EntityCommission(initialData)
+
+    // Validate getters
+    expect(entity.commissionId).toBe(initialData.commissionId)
+    expect(entity.created_at).toEqual(initialData.created_at)
+    expect(entity.updated_at).toEqual(initialData.updated_at)
+    expect(entity.transactionId).toBe(initialData.transactionId)
+    expect(entity.userId).toBe(initialData.userId)
+    expect(entity.isRedeemed).toBe(initialData.isRedeemed)
+    expect(entity.keyOffset).toBe(initialData.keyOffset)
+    expect(entity.lockingScript).toEqual(initialData.lockingScript)
+    expect(entity.satoshis).toBe(initialData.satoshis)
+    expect(entity.id).toBe(initialData.commissionId)
+    expect(entity.entityName).toBe('commission')
+    expect(entity.entityTable).toBe('commissions')
+
+    // Validate setters
+    entity.commissionId = 900
+    entity.created_at = new Date('2024-01-01')
+    entity.updated_at = new Date('2024-01-02')
+    entity.transactionId = 202
+    entity.userId = 2
+    entity.isRedeemed = true
+    entity.keyOffset = 'offset456'
+    entity.lockingScript = [4, 5, 6]
+    entity.satoshis = 1000
+    entity.id = 900
+
+    expect(entity.commissionId).toBe(900)
+    expect(entity.created_at).toEqual(new Date('2024-01-01'))
+    expect(entity.updated_at).toEqual(new Date('2024-01-02'))
+    expect(entity.transactionId).toBe(202)
+    expect(entity.userId).toBe(2)
+    expect(entity.isRedeemed).toBe(true)
+    expect(entity.keyOffset).toBe('offset456')
+    expect(entity.lockingScript).toEqual([4, 5, 6])
+    expect(entity.satoshis).toBe(1000)
+    expect(entity.id).toBe(900)
+  })
+})

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

@@ -0,0 +1,278 @@
+import { createSyncMap, sdk, SyncMap, TableOutputBasket } from '../../../../../src'
+import { TestUtilsWalletStorage as _tu, TestWalletNoSetup } from '../../../../../test/utils/TestUtilsWalletStorage'
+import { EntityOutputBasket } from '../EntityOutputBasket'
+
+describe('OutputBasket 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('OutputBasketTests'))
+      ctxs2.push(await _tu.createLegacyWalletMySQLCopy('OutputBasketTests2'))
+    }
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('OutputBasketTests'))
+    ctxs2.push(await _tu.createLegacyWalletSQLiteCopy('OutputBasketTests2'))
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+    for (const ctx of ctxs2) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('1_mergeExisting merges and updates entity when ei.updated_at > this.updated_at', async () => {
+    const ctx = ctxs[0]
+
+    // Insert initial OutputBasket record with valid data
+    const initialData: TableOutputBasket = {
+      basketId: 100,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      userId: 1,
+      name: 'Basket1',
+      numberOfDesiredUTXOs: 10,
+      minimumDesiredUTXOValue: 5000,
+      isDeleted: false
+    }
+    await ctx.activeStorage.insertOutputBasket(initialData)
+
+    // Create an OutputBasket entity from the initial data
+    const entity = new EntityOutputBasket(initialData)
+
+    // Simulate the `ei` argument with a later `updated_at`
+    const updatedData: TableOutputBasket = {
+      ...initialData,
+      updated_at: new Date('2023-01-03'), // Later timestamp
+      numberOfDesiredUTXOs: 20, // Update this field
+      minimumDesiredUTXOValue: 10000, // Update this field
+      isDeleted: true // Simulate a change in `isDeleted`
+    }
+
+    const syncMap = createSyncMap()
+    syncMap.outputBasket.idMap[100] = 100
+
+    // Call mergeExisting
+    const wasMergedRaw = await entity.mergeExisting(
+      ctx.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.numberOfDesiredUTXOs).toBe(20)
+    expect(entity.minimumDesiredUTXOValue).toBe(10000)
+    expect(entity.isDeleted).toBe(1)
+
+    // Verify that the database is updated
+    const updatedRecord = await ctx.activeStorage.findOutputBaskets({
+      partial: { basketId: 100 }
+    })
+    expect(updatedRecord.length).toBe(1)
+    expect(updatedRecord[0]).toBeDefined() // Ensure record exists
+    expect(updatedRecord[0].numberOfDesiredUTXOs).toBe(20)
+    expect(updatedRecord[0].minimumDesiredUTXOValue).toBe(10000)
+    expect(updatedRecord[0].isDeleted).toBe(true)
+  })
+
+  test('2_mergeExisting does not merge when ei.updated_at <= this.updated_at', async () => {
+    const ctx = ctxs[0]
+
+    // Insert initial OutputBasket record with valid data
+    const initialData: TableOutputBasket = {
+      basketId: 200,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      userId: 1,
+      name: 'Basket2',
+      numberOfDesiredUTXOs: 10,
+      minimumDesiredUTXOValue: 5000,
+      isDeleted: false
+    }
+    await ctx.activeStorage.insertOutputBasket(initialData)
+
+    // Create an OutputBasket entity from the initial data
+    const entity = new EntityOutputBasket(initialData)
+
+    // Simulate the `ei` argument with an earlier `updated_at`
+    const earlierData: TableOutputBasket = {
+      ...initialData,
+      updated_at: new Date('2023-01-01'), // Earlier timestamp
+      numberOfDesiredUTXOs: 20, // Simulate a change
+      minimumDesiredUTXOValue: 10000, // Simulate a change
+      isDeleted: true // Simulate a change
+    }
+
+    const syncMap = createSyncMap()
+    syncMap.outputBasket.idMap[200] = 200
+
+    // Call mergeExisting
+    const wasMergedRaw = await entity.mergeExisting(
+      ctx.activeStorage,
+      undefined, // `since` is not used in this method
+      earlierData,
+      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.numberOfDesiredUTXOs).toBe(10)
+    expect(entity.minimumDesiredUTXOValue).toBe(5000)
+    expect(entity.isDeleted).toBe(0)
+
+    // Verify that the database is not updated
+    const updatedRecord = await ctx.activeStorage.findOutputBaskets({
+      partial: { basketId: 200 }
+    })
+    expect(updatedRecord.length).toBe(1)
+    expect(updatedRecord[0]).toBeDefined() // Ensure record exists
+    expect(updatedRecord[0].numberOfDesiredUTXOs).toBe(10)
+    expect(updatedRecord[0].minimumDesiredUTXOValue).toBe(5000)
+    expect(updatedRecord[0].isDeleted).toBe(false)
+  })
+
+  test('equals identifies matching entities with and without SyncMap', async () => {
+    const ctx = ctxs[0]
+
+    // Insert two identical OutputBasket records in the database
+    const basketData: TableOutputBasket = {
+      basketId: 401,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      userId: 1,
+      name: 'Test Basket',
+      numberOfDesiredUTXOs: 10,
+      minimumDesiredUTXOValue: 1000,
+      isDeleted: false
+    }
+
+    await ctx.activeStorage.insertOutputBasket(basketData)
+
+    // Create two identical entities
+    const entity1 = new EntityOutputBasket(basketData)
+    const entity2 = new EntityOutputBasket(basketData)
+
+    // Test: equals returns true for identical entities without SyncMap
+    expect(entity1.equals(entity2.toApi())).toBe(true)
+
+    const syncMap = createSyncMap()
+    syncMap.outputBasket.idMap[401] = 401
+
+    // Test: equals returns true for identical entities with SyncMap
+    expect(entity1.equals(entity2.toApi(), syncMap)).toBe(true)
+  })
+
+  test('equals identifies non-matching entities', async () => {
+    const ctx = ctxs[0]
+
+    // Insert two different OutputBasket records in the database
+    const basketData1: TableOutputBasket = {
+      basketId: 402,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      userId: 1,
+      name: 'Test Basket 1',
+      numberOfDesiredUTXOs: 10,
+      minimumDesiredUTXOValue: 1000,
+      isDeleted: false
+    }
+
+    const basketData2: TableOutputBasket = {
+      basketId: 403,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      userId: 1,
+      name: 'Test Basket 2',
+      numberOfDesiredUTXOs: 5,
+      minimumDesiredUTXOValue: 500,
+      isDeleted: true
+    }
+
+    await ctx.activeStorage.insertOutputBasket(basketData1)
+    await ctx.activeStorage.insertOutputBasket(basketData2)
+
+    // Create entities
+    const entity1 = new EntityOutputBasket(basketData1)
+    const entity2 = new EntityOutputBasket(basketData2)
+
+    // Test: equals returns false for different entities without SyncMap
+    expect(entity1.equals(entity2.toApi())).toBe(false)
+
+    const syncMap = createSyncMap()
+    syncMap.outputBasket.idMap[1] = 2
+
+    // Test: equals returns false for different entities with SyncMap
+    expect(entity1.equals(entity2.toApi(), syncMap)).toBe(false)
+  })
+
+  test('OutputBasket getters, setters, and updateApi', () => {
+    // Create a mock OutputBasket instance
+    const initialData: TableOutputBasket = {
+      basketId: 123,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      userId: 1,
+      name: 'Test Basket',
+      numberOfDesiredUTXOs: 10,
+      minimumDesiredUTXOValue: 1000,
+      isDeleted: false
+    }
+
+    const entity = new EntityOutputBasket(initialData)
+
+    // Test getters
+    expect(entity.basketId).toBe(123)
+    expect(entity.created_at.getTime()).toBe(new Date('2023-01-01').getTime())
+    expect(entity.updated_at.getTime()).toBe(new Date('2023-01-02').getTime())
+    expect(entity.userId).toBe(1)
+    expect(entity.name).toBe('Test Basket')
+    expect(entity.numberOfDesiredUTXOs).toBe(10)
+    expect(entity.minimumDesiredUTXOValue).toBe(1000)
+    expect(entity.isDeleted).toBe(false)
+    expect(entity.id).toBe(123)
+    expect(entity.entityName).toBe('outputBasket')
+    expect(entity.entityTable).toBe('output_baskets')
+
+    // Test setters
+    entity.basketId = 456
+    entity.created_at = new Date('2023-02-01')
+    entity.updated_at = new Date('2023-02-02')
+    entity.userId = 2
+    entity.name = 'Updated Basket'
+    entity.numberOfDesiredUTXOs = 20
+    entity.minimumDesiredUTXOValue = 2000
+    entity.isDeleted = true
+    entity.id = 456
+
+    expect(entity.basketId).toBe(456)
+    expect(entity.created_at.getTime()).toBe(new Date('2023-02-01').getTime())
+    expect(entity.updated_at.getTime()).toBe(new Date('2023-02-02').getTime())
+    expect(entity.userId).toBe(2)
+    expect(entity.name).toBe('Updated Basket')
+    expect(entity.numberOfDesiredUTXOs).toBe(20)
+    expect(entity.minimumDesiredUTXOValue).toBe(2000)
+    expect(entity.isDeleted).toBe(true)
+    expect(entity.id).toBe(456)
+
+    // Test updateApi (even though it does nothing)
+    expect(() => entity.updateApi()).not.toThrow()
+  })
+})