@bopen-io/wallet-toolbox 1.7.18

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

@@ -0,0 +1,242 @@
+import * as bsv from '@bsv/sdk'
+import { createSyncMap, sdk, SyncMap, TableOutputTagMap } from '../../../../../src'
+import { TestUtilsWalletStorage as _tu, TestWalletNoSetup } from '../../../../../test/utils/TestUtilsWalletStorage'
+import { EntityOutputTagMap } from '../EntityOutputTagMap'
+
+describe('OutputTagMap 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('OutputTagMapTests'))
+      ctxs2.push(await _tu.createLegacyWalletMySQLCopy('OutputTagMapTests2'))
+    }
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('OutputTagMapTests'))
+    ctxs2.push(await _tu.createLegacyWalletSQLiteCopy('OutputTagMapTests2'))
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+    for (const ctx of ctxs2) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('0_OutputTagMap getters and setters', async () => {
+    const now = new Date()
+    const initialData: TableOutputTagMap = {
+      created_at: now,
+      updated_at: now,
+      outputId: 1,
+      outputTagId: 2,
+      isDeleted: false
+    }
+
+    const outputTagMap = new EntityOutputTagMap(initialData)
+
+    // Test getters
+    expect(outputTagMap.outputTagId).toBe(2)
+    expect(outputTagMap.outputId).toBe(1)
+    expect(outputTagMap.created_at).toBe(now)
+    expect(outputTagMap.updated_at).toBe(now)
+    expect(outputTagMap.isDeleted).toBe(false)
+    expect(outputTagMap.entityName).toBe('outputTagMap')
+    expect(outputTagMap.entityTable).toBe('output_tags_map')
+
+    // Test setters
+    const newDate = new Date()
+    outputTagMap.outputTagId = 3
+    outputTagMap.outputId = 4
+    outputTagMap.created_at = newDate
+    outputTagMap.updated_at = newDate
+    outputTagMap.isDeleted = true
+
+    expect(outputTagMap.outputTagId).toBe(3)
+    expect(outputTagMap.outputId).toBe(4)
+    expect(outputTagMap.created_at).toBe(newDate)
+    expect(outputTagMap.updated_at).toBe(newDate)
+    expect(outputTagMap.isDeleted).toBe(true)
+
+    // Test id throws an error
+    expect(() => outputTagMap.id).toThrow(sdk.WERR_INVALID_OPERATION)
+  })
+
+  test('1_equals returns true for matching entities', async () => {
+    const ctx1 = ctxs[0]
+    const ctx2 = ctxs2[0]
+
+    // Insert matching OutputTagMap records into both databases
+    const outputTagMapData: TableOutputTagMap = {
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      outputId: 1,
+      outputTagId: 8,
+      isDeleted: false
+    }
+
+    await ctx1.activeStorage.insertOutputTagMap(outputTagMapData)
+    await ctx2.activeStorage.insertOutputTagMap(outputTagMapData)
+
+    // Create entities from the records
+    const entity1 = new EntityOutputTagMap(outputTagMapData)
+    const entity2 = new EntityOutputTagMap(outputTagMapData)
+
+    const syncMap = createSyncMap()
+    syncMap.output.idMap[1] = 1
+    syncMap.outputTag.idMap[8] = 8
+
+    // Verify that equals returns true
+    expect(entity1.equals(entity2.toApi(), syncMap)).toBe(true)
+  })
+
+  test('2_equals returns false for non-matching entities', async () => {
+    const ctx1 = ctxs[0]
+    const ctx2 = ctxs2[0]
+
+    // Insert mismatched OutputTagMap records into both databases
+    const outputTagMapData1: TableOutputTagMap = {
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      outputId: 1,
+      outputTagId: 9,
+      isDeleted: false
+    }
+
+    const outputTagMapData2: TableOutputTagMap = {
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      outputId: 1, // Mismatched outputId
+      outputTagId: 21, // Mismatched outputTagId
+      isDeleted: true // Mismatched isDeleted
+    }
+
+    await ctx1.activeStorage.insertOutputTagMap(outputTagMapData1)
+    await ctx2.activeStorage.insertOutputTagMap(outputTagMapData2)
+
+    // Create entities from the records
+    const entity1 = new EntityOutputTagMap(outputTagMapData1)
+    const entity2 = new EntityOutputTagMap(outputTagMapData2)
+
+    const syncMap = createSyncMap()
+    syncMap.output.idMap[101] = 101
+
+    // Verify that equals returns false due to mismatched properties
+    expect(entity1.equals(entity2.toApi(), syncMap)).toBe(false)
+
+    // Test without a sync map to hit another branch
+    expect(entity1.equals(entity2.toApi())).toBe(false)
+  })
+
+  test('3_mergeExisting merges and updates entity when ei.updated_at > this.updated_at', async () => {
+    const ctx = ctxs[0]
+
+    // Insert initial OutputTagMap record with valid foreign key IDs
+    const initialData: TableOutputTagMap = {
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      outputId: 2,
+      outputTagId: 8,
+      isDeleted: false
+    }
+    await ctx.activeStorage.insertOutputTagMap(initialData)
+
+    // Create an OutputTagMap entity from the initial data
+    const entity = new EntityOutputTagMap(initialData)
+
+    // Create a new record to simulate the `ei` argument with a later `updated_at`
+    const updatedData: TableOutputTagMap = {
+      ...initialData,
+      updated_at: new Date('2023-01-03'), // Later timestamp
+      isDeleted: true // Simulate a change in `isDeleted`
+    }
+
+    const syncMap = createSyncMap()
+    syncMap.output.idMap[1] = 1
+
+    // Call mergeExisting
+    const wasMergedRaw = await entity.mergeExisting(
+      ctx.activeStorage,
+      undefined, // `since` is not used in this method
+      updatedData,
+      syncMap
+    )
+
+    const wasMerged = Boolean(wasMergedRaw)
+
+    // Verify that wasMerged is true
+    expect(wasMerged).toBe(true)
+
+    // Verify that the entity is updated
+    expect(entity.isDeleted).toBe(1)
+
+    // Debugging: Log the updated record query
+    const updatedRecord = await ctx.activeStorage.findOutputTagMaps({
+      partial: { outputId: 2, outputTagId: 8 }
+    })
+    //console.log('Updated Record:', updatedRecord)
+    //console.log('Updated Record isDeleted:', updatedRecord[0].isDeleted)
+    //console.log('Updted Redord length:', updatedRecord.length)
+
+    // Verify that the database is updated
+    expect(updatedRecord.length).toBe(1)
+    expect(updatedRecord[0]).toBeDefined()
+    expect(updatedRecord[0].isDeleted).toBe(true)
+  })
+
+  test('4_mergeExisting does not merge when ei.updated_at <= this.updated_at', async () => {
+    const ctx = ctxs[0]
+
+    // Insert initial OutputTagMap record
+    const initialData: TableOutputTagMap = {
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      outputId: 2,
+      outputTagId: 11,
+      isDeleted: false
+    }
+    await ctx.activeStorage.insertOutputTagMap(initialData)
+
+    // Create an OutputTagMap entity from the initial data
+    const entity = new EntityOutputTagMap(initialData)
+
+    // Create a new record to simulate the `ei` argument with an earlier `updated_at`
+    const earlierData: TableOutputTagMap = {
+      ...initialData,
+      updated_at: new Date('2023-01-01'), // Earlier timestamp
+      isDeleted: true // Simulate a change in `isDeleted`
+    }
+
+    const syncMap = createSyncMap()
+    syncMap.output.idMap[101] = 101
+
+    // Call mergeExisting
+    const wasMergedRaw = await entity.mergeExisting(
+      ctx.activeStorage,
+      undefined, // `since` is not used in this method
+      earlierData,
+      syncMap
+    )
+
+    // Normalize the result
+    const wasMerged = Boolean(wasMergedRaw)
+
+    // Verify that wasMerged is false
+    expect(wasMerged).toBe(false)
+
+    // Verify that the entity is not updated
+    expect(entity.isDeleted).toBe(0)
+
+    // Verify that the database is not updated
+    const record = await ctx.activeStorage.findOutputTagMaps({
+      partial: { outputId: 2, outputTagId: 11 }
+    })
+    expect(record.length).toBe(1)
+    expect(record[0].isDeleted).toBe(false)
+  })
+})

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

@@ -0,0 +1,288 @@
+import { createSyncMap, sdk, SyncMap, TableOutputTag } from '../../../../../src'
+import { TestUtilsWalletStorage as _tu, TestWalletNoSetup } from '../../../../../test/utils/TestUtilsWalletStorage'
+import { EntityOutputTag } from '../EntityOutputTag'
+
+describe('OutputTag 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('OutputTagTests'))
+      ctxs2.push(await _tu.createLegacyWalletMySQLCopy('OutputTagTests2'))
+    }
+    ctxs.push(await _tu.createLegacyWalletSQLiteCopy('OutputTagTests'))
+    ctxs2.push(await _tu.createLegacyWalletSQLiteCopy('OutputTagTests2'))
+  })
+
+  afterAll(async () => {
+    for (const ctx of ctxs) {
+      await ctx.storage.destroy()
+    }
+    for (const ctx of ctxs2) {
+      await ctx.storage.destroy()
+    }
+  })
+
+  test('0_mergeExisting merges and updates entity when ei.updated_at > this.updated_at', async () => {
+    const ctx = ctxs[0]
+
+    // Insert initial OutputTag record with valid userId
+    const initialData: TableOutputTag = {
+      outputTagId: 401,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      tag: 'tag1',
+      userId: 1,
+      isDeleted: false
+    }
+    await ctx.activeStorage.insertOutputTag(initialData)
+
+    // Create an OutputTag entity from the initial data
+    const entity = new EntityOutputTag(initialData)
+
+    // Simulate the `ei` argument with a later `updated_at`
+    const updatedData: TableOutputTag = {
+      ...initialData,
+      updated_at: new Date('2023-01-03'), // Later timestamp
+      isDeleted: true // Simulate a change in `isDeleted`
+    }
+
+    const syncMap = createSyncMap()
+    syncMap.outputTag.idMap[401] = 401
+
+    // Call mergeExisting
+    const wasMergedRaw = await entity.mergeExisting(
+      ctx.activeStorage,
+      undefined, // `since` is not used in this method
+      updatedData,
+      syncMap,
+      undefined
+    )
+
+    const wasMerged = Boolean(wasMergedRaw)
+
+    // Verify that wasMerged is true
+    expect(wasMerged).toBe(true)
+
+    // Verify that the entity is updated
+    expect(entity.isDeleted).toBe(1)
+
+    // Verify that the database is updated
+    const updatedRecord = await ctx.activeStorage.findOutputTags({
+      partial: { outputTagId: 401 }
+    })
+    expect(updatedRecord.length).toBe(1)
+    expect(updatedRecord[0]).toBeDefined()
+    expect(updatedRecord[0].isDeleted).toBe(true)
+  })
+
+  test('1_mergeExisting does not merge when ei.updated_at <= this.updated_at', async () => {
+    const ctx = ctxs[0]
+
+    // Insert initial OutputTag record with valid userId
+    const initialData: TableOutputTag = {
+      outputTagId: 402,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      tag: 'tag2',
+      userId: 1, // Valid user ID
+      isDeleted: false
+    }
+    await ctx.activeStorage.insertOutputTag(initialData)
+
+    // Create an OutputTag entity from the initial data
+    const entity = new EntityOutputTag(initialData)
+
+    // Simulate the `ei` argument with an earlier or equal `updated_at`
+    const earlierData: TableOutputTag = {
+      ...initialData,
+      updated_at: new Date('2023-01-01'), // Earlier timestamp
+      isDeleted: true // Simulate a change in `isDeleted`
+    }
+
+    const syncMap = createSyncMap()
+    syncMap.outputTag.idMap[1] = 1
+
+    // Call mergeExisting
+    const wasMergedRaw = await entity.mergeExisting(
+      ctx.activeStorage,
+      undefined, // `since` is not used in this method
+      earlierData,
+      syncMap,
+      undefined
+    )
+
+    const wasMerged = Boolean(wasMergedRaw)
+
+    // Verify that wasMerged is false
+    expect(wasMerged).toBe(false)
+
+    // Verify that the entity is not updated
+    expect(entity.isDeleted).toBe(0)
+
+    // Verify that the database is not updated
+    const record = await ctx.activeStorage.findOutputTags({
+      partial: { outputTagId: 1 }
+    })
+    expect(record.length).toBe(1)
+    expect(record[0].isDeleted).toBe(false)
+  })
+
+  test('2_equals identifies matching entities without syncMap', async () => {
+    const ctx = ctxs[0]
+
+    // Insert matching OutputTag record into the database
+    const data: TableOutputTag = {
+      outputTagId: 403,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      tag: 'tag3',
+      userId: 1,
+      isDeleted: false
+    }
+    await ctx.activeStorage.insertOutputTag(data)
+
+    // Create OutputTag entities
+    const entity1 = new EntityOutputTag(data)
+    const entity2 = new EntityOutputTag(data)
+
+    // Verify that equals returns true for matching entities
+    expect(entity1.equals(entity2.toApi())).toBe(true)
+  })
+
+  test('3_equals identifies non-matching entities when tags differ', async () => {
+    const ctx = ctxs[0]
+
+    // Insert differing OutputTag records into the database
+    const data1: TableOutputTag = {
+      outputTagId: 404,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      tag: 'tag4',
+      userId: 1,
+      isDeleted: false
+    }
+    const data2 = { ...data1, tag: 'tag2' }
+
+    await ctx.activeStorage.insertOutputTag(data1)
+
+    // Create OutputTag entities
+    const entity1 = new EntityOutputTag(data1)
+    const entity2 = new EntityOutputTag(data2)
+
+    // Verify that equals returns false when tags differ
+    expect(entity1.equals(entity2.toApi())).toBe(false)
+  })
+
+  test('4_equals identifies non-matching entities when isDeleted differs', async () => {
+    const ctx = ctxs[0]
+
+    // Insert differing OutputTag records into the database
+    const data1: TableOutputTag = {
+      outputTagId: 405,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      tag: 'tag5',
+      userId: 1,
+      isDeleted: false
+    }
+    const data2 = { ...data1, isDeleted: true }
+
+    await ctx.activeStorage.insertOutputTag(data1)
+
+    // Create OutputTag entities
+    const entity1 = new EntityOutputTag(data1)
+    const entity2 = new EntityOutputTag(data2)
+
+    // Verify that equals returns false when isDeleted differs
+    expect(entity1.equals(entity2.toApi())).toBe(false)
+  })
+
+  test('5_equals identifies matching entities with syncMap', async () => {
+    const ctx = ctxs[0]
+
+    // Insert matching OutputTag record into the database
+    const data: TableOutputTag = {
+      outputTagId: 406,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      tag: 'tag6',
+      userId: 1,
+      isDeleted: false
+    }
+    await ctx.activeStorage.insertOutputTag(data)
+
+    // Create OutputTag entities
+    const entity1 = new EntityOutputTag(data)
+    const entity2 = new EntityOutputTag(data)
+
+    const syncMap = createSyncMap()
+    syncMap.outputTag.idMap[1] = 1
+
+    // Verify that equals returns true with syncMap
+    expect(entity1.equals(entity2.toApi(), syncMap)).toBe(true)
+  })
+
+  test('6_equals identifies non-matching entities when userIds differ and no syncMap is provided', async () => {
+    const ctx = ctxs[0]
+
+    // Insert differing OutputTag records into the database
+    const data1: TableOutputTag = {
+      outputTagId: 407,
+      created_at: new Date('2023-01-01'),
+      updated_at: new Date('2023-01-02'),
+      tag: 'tag7',
+      userId: 1,
+      isDeleted: false
+    }
+    const data2 = { ...data1, userId: 2 }
+
+    await ctx.activeStorage.insertOutputTag(data1)
+
+    // Create OutputTag entities
+    const entity1 = new EntityOutputTag(data1)
+    const entity2 = new EntityOutputTag(data2)
+
+    // Verify that equals returns false when userIds differ and no syncMap is provided
+    expect(entity1.equals(entity2.toApi())).toBe(false)
+  })
+
+  test('7_getters and setters work as expected for OutputTag', () => {
+    const now = new Date()
+    const later = new Date(now.getTime() + 1000)
+
+    // Create an OutputTag instance
+    const outputTag = new EntityOutputTag()
+
+    // Set values using setters
+    outputTag.outputTagId = 123
+    outputTag.created_at = now
+    outputTag.updated_at = later
+    outputTag.tag = 'Test Tag'
+    outputTag.userId = 456
+    outputTag.isDeleted = true
+
+    // Validate values using getters
+    expect(outputTag.outputTagId).toBe(123)
+    expect(outputTag.created_at).toBe(now)
+    expect(outputTag.updated_at).toBe(later)
+    expect(outputTag.tag).toBe('Test Tag')
+    expect(outputTag.userId).toBe(456)
+    expect(outputTag.isDeleted).toBe(true)
+
+    // Validate id, entityName, and entityTable
+    expect(outputTag.id).toBe(123)
+    expect(outputTag.entityName).toBe('outputTag')
+    expect(outputTag.entityTable).toBe('output_tags')
+
+    // Update id using override setter
+    outputTag.id = 789
+
+    // Validate id again
+    expect(outputTag.id).toBe(789)
+  })
+})