additional tests, but still work in progress

backend/src/apis/DltConnectorClient.ts

@@ -6,9 +6,9 @@ import { TransactionTypeId } from '@/graphql/enum/TransactionTypeId'
 import { LogError } from '@/server/LogError'
 import { backendLogger as logger } from '@/server/logger'
 
-const mutation = gql`
+const sendTransaction = gql`
   mutation ($input: TransactionInput!) {
-    transmitTransaction(data: $input) {
+    sendTransaction(data: $input) {
       dltTransactionIdHex
     }
   }
@@ -35,7 +35,7 @@ function getTransactionTypeString(id: TransactionTypeId): string {
 export class DltConnectorClient {
   // eslint-disable-next-line no-use-before-define
   private static instance: DltConnectorClient
-  private client: GraphQLClient
+  client: GraphQLClient
   /**
    * The Singleton's constructor should always be private to prevent direct
    * construction calls with the `new` operator.
@@ -59,7 +59,13 @@ export class DltConnectorClient {
     }
     if (!DltConnectorClient.instance.client) {
       try {
-        DltConnectorClient.instance.client = new GraphQLClient(CONFIG.DLT_CONNECTOR_URL)
+        DltConnectorClient.instance.client = new GraphQLClient(CONFIG.DLT_CONNECTOR_URL, {
+          method: 'GET',
+          jsonSerializer: {
+            parse: JSON.parse,
+            stringify: JSON.stringify,
+          },
+        })
       } catch (e) {
         logger.error("couldn't connect to dlt-connector: ", e)
         return
@@ -72,22 +78,33 @@ export class DltConnectorClient {
    * transmit transaction via dlt-connector to iota
    * and update dltTransactionId of transaction in db with iota message id
    */
-  public async transmitTransaction(transaction: DbTransaction): Promise<string> {
-    const typeString = getTransactionTypeString(transaction.typeId)
-    const secondsSinceEpoch = Math.round(transaction.balanceDate.getTime() / 1000)
-    const amountString = transaction.amount.toString()
-    try {
-      const result: { transmitTransaction: { dltTransactionIdHex: string } } =
-        await this.client.request(mutation, {
+  public async transmitTransaction(transaction?: DbTransaction | null): Promise<string> {
+    console.log('transmitTransaction tx=', transaction)
+    if (transaction) {
+      const typeString = getTransactionTypeString(transaction.typeId)
+      const secondsSinceEpoch = Math.round(transaction.balanceDate.getTime() / 1000)
+      const amountString = transaction.amount.toString()
+      console.log('typeString=', typeString)
+      console.log('secondsSinceEpoch=', secondsSinceEpoch)
+      console.log('amountString=', amountString)
+      try {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+        const { data } = await this.client.rawRequest(sendTransaction, {
           input: {
             type: typeString,
             amount: amountString,
             createdAt: secondsSinceEpoch,
           },
         })
-      return result.transmitTransaction.dltTransactionIdHex
-    } catch (e) {
-      throw new LogError('Error send sending transaction to dlt-connector: %o', e)
+        console.log('result data=', data)
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return, @typescript-eslint/no-unsafe-member-access
+        return data.sendTransaction.dltTransactionIdHex
+      } catch (e) {
+        console.log('error return result ', e)
+        throw new LogError('Error send sending transaction to dlt-connector: ', e)
+      }
+    } else {
+      throw new LogError('parameter transaction not set...')
     }
   }
 }

backend/src/graphql/resolver/util/sendTransactionsToDltConnector.test.ts

@@ -0,0 +1,581 @@
+/* eslint-disable @typescript-eslint/no-unsafe-member-access */
+/* eslint-disable @typescript-eslint/unbound-method */
+/* eslint-disable @typescript-eslint/no-unsafe-assignment */
+/* eslint-disable @typescript-eslint/no-unsafe-call */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+
+import { Connection } from '@dbTools/typeorm'
+import { DltTransaction } from '@entity/DltTransaction'
+import { Transaction } from '@entity/Transaction'
+import { ApolloServerTestClient } from 'apollo-server-testing'
+import { Decimal } from 'decimal.js-light'
+// import { GraphQLClient } from 'graphql-request'
+// import { Response } from 'graphql-request/dist/types'
+import { GraphQLClient } from 'graphql-request'
+import { Response } from 'graphql-request/dist/types'
+
+import { testEnvironment, cleanDB } from '@test/helpers'
+import { logger, i18n as localization } from '@test/testSetup'
+
+import { CONFIG } from '@/config'
+import { TransactionTypeId } from '@/graphql/enum/TransactionTypeId'
+
+import { sendTransactionsToDltConnector } from './sendTransactionsToDltConnector'
+
+/*
+// Mock the GraphQLClient
+jest.mock('graphql-request', () => {
+  const originalModule = jest.requireActual('graphql-request')
+
+  let testCursor = 0
+
+  return {
+    __esModule: true,
+    ...originalModule,
+    GraphQLClient: jest.fn().mockImplementation((url: string) => {
+      if (url === 'invalid') {
+        throw new Error('invalid url')
+      }
+      return {
+        // why not using mockResolvedValueOnce or mockReturnValueOnce?
+        // I have tried, but it didn't work and return every time the first value
+        request: jest.fn().mockImplementation(() => {
+          testCursor++
+          if (testCursor === 4) {
+            return Promise.resolve(
+              // invalid, is 33 Bytes long as binary
+              {
+                transmitTransaction: {
+                  dltTransactionIdHex:
+                    '723e3fab62c5d3e2f62fd72ba4e622bcd53eff35262e3f3526327fe41bc516212A',
+                },
+              },
+            )
+          } else if (testCursor === 5) {
+            throw Error('Connection error')
+          } else {
+            return Promise.resolve(
+              // valid, is 32 Bytes long as binary
+              {
+                transmitTransaction: {
+                  dltTransactionIdHex:
+                    '723e3fab62c5d3e2f62fd72ba4e622bcd53eff35262e3f3526327fe41bc51621',
+                },
+              },
+            )
+          }
+        }),
+      }
+    }),
+  }
+})
+let mutate: ApolloServerTestClient['mutate'],
+  query: ApolloServerTestClient['query'],
+  con: Connection
+let testEnv: {
+  mutate: ApolloServerTestClient['mutate']
+  query: ApolloServerTestClient['query']
+  con: Connection
+}
+*/
+
+async function createTxCREATION1(): Promise<Transaction> {
+  const tx = Transaction.create()
+  tx.amount = new Decimal(1000)
+  tx.balance = new Decimal(100)
+  tx.balanceDate = new Date('01.01.2023 00:00:00')
+  tx.memo = 'txCREATION1'
+  tx.typeId = TransactionTypeId.CREATION
+  tx.userGradidoID = 'txCREATION1.userGradidoID'
+  tx.userId = 1
+  tx.userName = 'txCREATION 1'
+  return await Transaction.save(tx)
+}
+
+async function createTxCREATION2(): Promise<Transaction> {
+  const tx = Transaction.create()
+  tx.amount = new Decimal(1000)
+  tx.balance = new Decimal(200)
+  tx.balanceDate = new Date('02.01.2023 00:00:00')
+  tx.memo = 'txCREATION2'
+  tx.typeId = TransactionTypeId.CREATION
+  tx.userGradidoID = 'txCREATION2.userGradidoID'
+  tx.userId = 2
+  tx.userName = 'txCREATION 2'
+  return await Transaction.save(tx)
+}
+
+async function createTxCREATION3(): Promise<Transaction> {
+  const tx = Transaction.create()
+  tx.amount = new Decimal(1000)
+  tx.balance = new Decimal(300)
+  tx.balanceDate = new Date('03.01.2023 00:00:00')
+  tx.memo = 'txCREATION3'
+  tx.typeId = TransactionTypeId.CREATION
+  tx.userGradidoID = 'txCREATION3.userGradidoID'
+  tx.userId = 3
+  tx.userName = 'txCREATION 3'
+  return await Transaction.save(tx)
+}
+
+async function createTxSend1ToReceive2(): Promise<Transaction> {
+  const tx = Transaction.create()
+  tx.amount = new Decimal(100)
+  tx.balance = new Decimal(1000)
+  tx.balanceDate = new Date('11.01.2023 00:00:00')
+  tx.memo = 'txSEND1 to txRECEIVE2'
+  tx.typeId = TransactionTypeId.SEND
+  tx.userGradidoID = 'txSEND1.userGradidoID'
+  tx.userId = 1
+  tx.userName = 'txSEND 1'
+  tx.linkedUserGradidoID = 'txRECEIVE2.linkedUserGradidoID'
+  tx.linkedUserId = 2
+  tx.linkedUserName = 'txRECEIVE 2'
+  return await Transaction.save(tx)
+}
+
+async function createTxReceive2FromSend1(): Promise<Transaction> {
+  const tx = Transaction.create()
+  tx.amount = new Decimal(100)
+  tx.balance = new Decimal(1300)
+  tx.balanceDate = new Date('11.01.2023 00:00:00')
+  tx.memo = 'txSEND1 to txRECEIVE2'
+  tx.typeId = TransactionTypeId.RECEIVE
+  tx.userGradidoID = 'txRECEIVE2.linkedUserGradidoID'
+  tx.userId = 2
+  tx.userName = 'txRECEIVE 2'
+  tx.linkedUserGradidoID = 'txSEND1.userGradidoID'
+  tx.linkedUserId = 1
+  tx.linkedUserName = 'txSEND 1'
+  return await Transaction.save(tx)
+}
+
+async function createTxSend2ToReceive3(): Promise<Transaction> {
+  const tx = Transaction.create()
+  tx.amount = new Decimal(200)
+  tx.balance = new Decimal(1100)
+  tx.balanceDate = new Date('23.01.2023 00:00:00')
+  tx.memo = 'txSEND2 to txRECEIVE3'
+  tx.typeId = TransactionTypeId.SEND
+  tx.userGradidoID = 'txSEND2.userGradidoID'
+  tx.userId = 2
+  tx.userName = 'txSEND 2'
+  tx.linkedUserGradidoID = 'txRECEIVE3.linkedUserGradidoID'
+  tx.linkedUserId = 3
+  tx.linkedUserName = 'txRECEIVE 3'
+  return await Transaction.save(tx)
+}
+
+async function createTxReceive3FromSend2(): Promise<Transaction> {
+  const tx = Transaction.create()
+  tx.amount = new Decimal(200)
+  tx.balance = new Decimal(1500)
+  tx.balanceDate = new Date('23.01.2023 00:00:00')
+  tx.memo = 'txSEND2 to txRECEIVE3'
+  tx.typeId = TransactionTypeId.RECEIVE
+  tx.userGradidoID = 'txRECEIVE3.linkedUserGradidoID'
+  tx.userId = 3
+  tx.userName = 'txRECEIVE 3'
+  tx.linkedUserGradidoID = 'txSEND2.userGradidoID'
+  tx.linkedUserId = 2
+  tx.linkedUserName = 'txSEND 2'
+  return await Transaction.save(tx)
+}
+
+async function createTxSend3ToReceive1(): Promise<Transaction> {
+  const tx = Transaction.create()
+  tx.amount = new Decimal(300)
+  tx.balance = new Decimal(1200)
+  tx.balanceDate = new Date('31.01.2023 00:00:00')
+  tx.memo = 'txSEND3 to txRECEIVE1'
+  tx.typeId = TransactionTypeId.SEND
+  tx.userGradidoID = 'txSEND3.userGradidoID'
+  tx.userId = 3
+  tx.userName = 'txSEND 3'
+  tx.linkedUserGradidoID = 'txRECEIVE1.linkedUserGradidoID'
+  tx.linkedUserId = 1
+  tx.linkedUserName = 'txRECEIVE 1'
+  return await Transaction.save(tx)
+}
+
+async function createTxReceive1FromSend3(): Promise<Transaction> {
+  const tx = Transaction.create()
+  tx.amount = new Decimal(300)
+  tx.balance = new Decimal(1300)
+  tx.balanceDate = new Date('31.01.2023 00:00:00')
+  tx.memo = 'txSEND3 to txRECEIVE1'
+  tx.typeId = TransactionTypeId.RECEIVE
+  tx.userGradidoID = 'txRECEIVE1.linkedUserGradidoID'
+  tx.userId = 1
+  tx.userName = 'txRECEIVE 1'
+  tx.linkedUserGradidoID = 'txSEND3.userGradidoID'
+  tx.linkedUserId = 3
+  tx.linkedUserName = 'txSEND 3'
+  return await Transaction.save(tx)
+}
+
+let con: Connection
+let testEnv: {
+  mutate: ApolloServerTestClient['mutate']
+  query: ApolloServerTestClient['query']
+  con: Connection
+}
+
+beforeAll(async () => {
+  testEnv = await testEnvironment(logger, localization)
+  con = testEnv.con
+  await cleanDB()
+})
+
+afterAll(async () => {
+  await cleanDB()
+  await con.close()
+})
+
+describe('create and send Transactions to DltConnector', () => {
+  let txCREATION1: Transaction
+  let txCREATION2: Transaction
+  let txCREATION3: Transaction
+  let txSEND1to2: Transaction
+  let txRECEIVE2From1: Transaction
+  let txSEND2To3: Transaction
+  let txRECEIVE3From2: Transaction
+  let txSEND3To1: Transaction
+  let txRECEIVE1From3: Transaction
+
+  beforeEach(async () => {
+    jest.clearAllMocks()
+
+    txCREATION1 = await createTxCREATION1()
+    txCREATION2 = await createTxCREATION2()
+    txCREATION3 = await createTxCREATION3()
+  })
+
+  describe('with 3 creations but inactive dlt-connector', () => {
+    beforeEach(async () => {
+      jest.clearAllMocks()
+      CONFIG.DLT_CONNECTOR = false
+      await sendTransactionsToDltConnector()
+    })
+
+    it('found 3 dlt-transactions', async () => {
+      expect(logger.info).toBeCalledWith('sendTransactionsToDltConnector...')
+
+      // Find the previous created transactions of sendCoin mutation
+      const transactions = await Transaction.find({
+        // where: { memo: 'unrepeatable memo' },
+        order: { balanceDate: 'ASC', id: 'ASC' },
+      })
+
+      const dltTransactions = await DltTransaction.find({
+        // where: { transactionId: In([transaction[0].id, transaction[1].id]) },
+        // relations: ['transaction'],
+        order: { createdAt: 'ASC', id: 'ASC' },
+      })
+
+      expect(dltTransactions).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: expect.any(Number),
+            transactionId: transactions[0].id,
+            messageId: null,
+            verified: false,
+            createdAt: expect.any(Date),
+            verifiedAt: null,
+          }),
+          expect.objectContaining({
+            id: expect.any(Number),
+            transactionId: transactions[1].id,
+            messageId: null,
+            verified: false,
+            createdAt: expect.any(Date),
+            verifiedAt: null,
+          }),
+          expect.objectContaining({
+            id: expect.any(Number),
+            transactionId: transactions[2].id,
+            messageId: null,
+            verified: false,
+            createdAt: expect.any(Date),
+            verifiedAt: null,
+          }),
+        ]),
+      )
+
+      expect(logger.info).nthCalledWith(3, 'sending to DltConnector currently not configured...')
+    })
+  })
+
+  describe('with 3 creations and active dlt-connector', () => {
+    beforeEach(async () => {
+      jest.clearAllMocks()
+      CONFIG.DLT_CONNECTOR = true
+
+      // eslint-disable-next-line @typescript-eslint/require-await
+      jest.spyOn(GraphQLClient.prototype, 'rawRequest').mockImplementation(async () => {
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return {
+          data: {
+            sendTransaction: {
+              dltTransactionIdHex:
+                '723e3fab62c5d3e2f62fd72ba4e622bcd53eff35262e3f3526327fe41bc516212',
+            },
+          },
+        } as Response<unknown>
+      })
+
+      await sendTransactionsToDltConnector()
+    })
+
+    it('found 3 dlt-transactions', async () => {
+      expect(logger.info).toBeCalledWith('sendTransactionsToDltConnector...')
+
+      // Find the previous created transactions of sendCoin mutation
+      const transactions = await Transaction.find({
+        // where: { memo: 'unrepeatable memo' },
+        order: { balanceDate: 'ASC', id: 'ASC' },
+      })
+
+      const dltTransactions = await DltTransaction.find({
+        // where: { transactionId: In([transaction[0].id, transaction[1].id]) },
+        // relations: ['transaction'],
+        order: { createdAt: 'ASC', id: 'ASC' },
+      })
+
+      expect(dltTransactions).toEqual(
+        expect.arrayContaining([
+          expect.objectContaining({
+            id: expect.any(Number),
+            transactionId: transactions[0].id,
+            messageId: '723e3fab62c5d3e2f62fd72ba4e622bcd53eff35262e3f3526327fe41bc51621',
+            verified: false,
+            createdAt: expect.any(Date),
+            verifiedAt: null,
+          }),
+          expect.objectContaining({
+            id: expect.any(Number),
+            transactionId: transactions[1].id,
+            messageId: '723e3fab62c5d3e2f62fd72ba4e622bcd53eff35262e3f3526327fe41bc51621',
+            verified: false,
+            createdAt: expect.any(Date),
+            verifiedAt: null,
+          }),
+          expect.objectContaining({
+            id: expect.any(Number),
+            transactionId: transactions[2].id,
+            messageId: '723e3fab62c5d3e2f62fd72ba4e622bcd53eff35262e3f3526327fe41bc51621',
+            verified: false,
+            createdAt: expect.any(Date),
+            verifiedAt: null,
+          }),
+        ]),
+      )
+    })
+
+    /*
+    describe('with one Community of api 1_0 and not matching pubKey', () => {
+      beforeEach(async () => {
+        // eslint-disable-next-line @typescript-eslint/require-await
+        jest.spyOn(GraphQLClient.prototype, 'rawRequest').mockImplementation(async () => {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+          return {
+            data: {
+              getPublicKey: {
+                publicKey: 'somePubKey',
+              },
+            },
+          } as Response<unknown>
+        })
+        const variables1 = {
+          publicKey: Buffer.from('11111111111111111111111111111111'),
+          apiVersion: '1_0',
+          endPoint: 'http//localhost:5001/api/',
+          lastAnnouncedAt: new Date(),
+        }
+        await DbFederatedCommunity.createQueryBuilder()
+          .insert()
+          .into(DbFederatedCommunity)
+          .values(variables1)
+          .orUpdate({
+            // eslint-disable-next-line camelcase
+            conflict_target: ['id', 'publicKey', 'apiVersion'],
+            overwrite: ['end_point', 'last_announced_at'],
+          })
+          .execute()
+
+        jest.clearAllMocks()
+        // await validateCommunities()
+      })
+
+      it('logs one community found', () => {
+        expect(logger.debug).toBeCalledWith(`Federation: found 1 dbCommunities`)
+      })
+      it('logs requestGetPublicKey for community api 1_0 ', () => {
+        expect(logger.info).toBeCalledWith(
+          'Federation: getPublicKey from endpoint',
+          'http//localhost:5001/api/1_0/',
+        )
+      })
+      it('logs not matching publicKeys', () => {
+        expect(logger.warn).toBeCalledWith(
+          'Federation: received not matching publicKey:',
+          'somePubKey',
+          expect.stringMatching('11111111111111111111111111111111'),
+        )
+      })
+    })
+    describe('with one Community of api 1_0 and matching pubKey', () => {
+      beforeEach(async () => {
+        // eslint-disable-next-line @typescript-eslint/require-await
+        jest.spyOn(GraphQLClient.prototype, 'rawRequest').mockImplementation(async () => {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+          return {
+            data: {
+              getPublicKey: {
+                publicKey: '11111111111111111111111111111111',
+              },
+            },
+          } as Response<unknown>
+        })
+        const variables1 = {
+          publicKey: Buffer.from('11111111111111111111111111111111'),
+          apiVersion: '1_0',
+          endPoint: 'http//localhost:5001/api/',
+          lastAnnouncedAt: new Date(),
+        }
+        await DbFederatedCommunity.createQueryBuilder()
+          .insert()
+          .into(DbFederatedCommunity)
+          .values(variables1)
+          .orUpdate({
+            // eslint-disable-next-line camelcase
+            conflict_target: ['id', 'publicKey', 'apiVersion'],
+            overwrite: ['end_point', 'last_announced_at'],
+          })
+          .execute()
+        await DbFederatedCommunity.update({}, { verifiedAt: null })
+        jest.clearAllMocks()
+        // await validateCommunities()
+      })
+
+      it('logs one community found', () => {
+        expect(logger.debug).toBeCalledWith(`Federation: found 1 dbCommunities`)
+      })
+      it('logs requestGetPublicKey for community api 1_0 ', () => {
+        expect(logger.info).toBeCalledWith(
+          'Federation: getPublicKey from endpoint',
+          'http//localhost:5001/api/1_0/',
+        )
+      })
+      it('logs community pubKey verified', () => {
+        expect(logger.info).toHaveBeenNthCalledWith(
+          3,
+          'Federation: verified community with',
+          'http//localhost:5001/api/',
+        )
+      })
+    })
+    describe('with two Communities of api 1_0 and 1_1', () => {
+      beforeEach(async () => {
+        jest.clearAllMocks()
+        // eslint-disable-next-line @typescript-eslint/require-await
+        jest.spyOn(GraphQLClient.prototype, 'rawRequest').mockImplementation(async () => {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+          return {
+            data: {
+              getPublicKey: {
+                publicKey: '11111111111111111111111111111111',
+              },
+            },
+          } as Response<unknown>
+        })
+        const variables2 = {
+          publicKey: Buffer.from('11111111111111111111111111111111'),
+          apiVersion: '1_1',
+          endPoint: 'http//localhost:5001/api/',
+          lastAnnouncedAt: new Date(),
+        }
+        await DbFederatedCommunity.createQueryBuilder()
+          .insert()
+          .into(DbFederatedCommunity)
+          .values(variables2)
+          .orUpdate({
+            // eslint-disable-next-line camelcase
+            conflict_target: ['id', 'publicKey', 'apiVersion'],
+            overwrite: ['end_point', 'last_announced_at'],
+          })
+          .execute()
+
+        await DbFederatedCommunity.update({}, { verifiedAt: null })
+        jest.clearAllMocks()
+        // await validateCommunities()
+      })
+      it('logs two communities found', () => {
+        expect(logger.debug).toBeCalledWith(`Federation: found 2 dbCommunities`)
+      })
+      it('logs requestGetPublicKey for community api 1_0 ', () => {
+        expect(logger.info).toBeCalledWith(
+          'Federation: getPublicKey from endpoint',
+          'http//localhost:5001/api/1_0/',
+        )
+      })
+      it('logs requestGetPublicKey for community api 1_1 ', () => {
+        expect(logger.info).toBeCalledWith(
+          'Federation: getPublicKey from endpoint',
+          'http//localhost:5001/api/1_1/',
+        )
+      })
+    })
+    describe('with three Communities of api 1_0, 1_1 and 2_0', () => {
+      let dbCom: DbFederatedCommunity
+      beforeEach(async () => {
+        const variables3 = {
+          publicKey: Buffer.from('11111111111111111111111111111111'),
+          apiVersion: '2_0',
+          endPoint: 'http//localhost:5001/api/',
+          lastAnnouncedAt: new Date(),
+        }
+        await DbFederatedCommunity.createQueryBuilder()
+          .insert()
+          .into(DbFederatedCommunity)
+          .values(variables3)
+          .orUpdate({
+            // eslint-disable-next-line camelcase
+            conflict_target: ['id', 'publicKey', 'apiVersion'],
+            overwrite: ['end_point', 'last_announced_at'],
+          })
+          .execute()
+        dbCom = await DbFederatedCommunity.findOneOrFail({
+          where: { publicKey: variables3.publicKey, apiVersion: variables3.apiVersion },
+        })
+        await DbFederatedCommunity.update({}, { verifiedAt: null })
+        jest.clearAllMocks()
+        // await validateCommunities()
+      })
+      it('logs three community found', () => {
+        expect(logger.debug).toBeCalledWith(`Federation: found 3 dbCommunities`)
+      })
+      it('logs requestGetPublicKey for community api 1_0 ', () => {
+        expect(logger.info).toBeCalledWith(
+          'Federation: getPublicKey from endpoint',
+          'http//localhost:5001/api/1_0/',
+        )
+      })
+      it('logs requestGetPublicKey for community api 1_1 ', () => {
+        expect(logger.info).toBeCalledWith(
+          'Federation: getPublicKey from endpoint',
+          'http//localhost:5001/api/1_1/',
+        )
+      })
+      it('logs unsupported api for community with api 2_0 ', () => {
+        expect(logger.warn).toBeCalledWith(
+          'Federation: dbCom with unsupported apiVersion',
+          dbCom.endPoint,
+          '2_0',
+        )
+      })
+    })
+    */
+  })
+})

backend/src/graphql/resolver/util/sendTransactionsToDltConnector.ts

@@ -17,37 +17,41 @@ export async function sendTransactionsToDltConnector(): Promise<void> {
       await createDltTransactions()
       const dltConnector = DltConnectorClient.getInstance()
       if (dltConnector) {
+        console.log('aktiv dltConnector...')
+        logger.debug('with sending to DltConnector...')
         const dltTransactions = await DltTransaction.find({
           where: { messageId: IsNull() },
           relations: ['transaction'],
           order: { createdAt: 'ASC', id: 'ASC' },
         })
+        console.log('dltTransactions=', dltTransactions)
         for (const dltTx of dltTransactions) {
-          logger.debug('sending dltTx=', dltTx)
-          if (dltTx.transaction && (dltTx.transaction ?? false)) {
-            try {
-              const messageId = await dltConnector.transmitTransaction(dltTx.transaction)
-              logger.debug('received messageId=', messageId)
-              const dltMessageId = Buffer.from(messageId, 'hex')
-              logger.debug('dltMessageId as Buffer=', dltMessageId)
-              if (dltMessageId.length !== 32) {
-                logger.error(
-                  'Error dlt message id is invalid: %s, should by 32 Bytes long in binary after converting from hex',
-                  dltMessageId,
-                )
-                return
-              }
-              dltTx.messageId = dltMessageId.toString()
-              await DltTransaction.save(dltTx)
-              logger.info('store messageId=%s in dltTx=%d', dltTx.messageId, dltTx.id)
-            } catch (e) {
-              logger.error(
-                `error while sending to dlt-connector or writing messageId of dltTx=${dltTx.id}`,
-                e,
+          console.log('sending dltTx=', dltTx)
+          try {
+            const messageId = await dltConnector.transmitTransaction(dltTx.transaction)
+            console.log('received messageId=', messageId)
+            const dltMessageId = Buffer.from(messageId, 'hex')
+            console.log('dltMessageId as Buffer=', dltMessageId)
+            if (dltMessageId.length !== 32) {
+              console.log(
+                'Error dlt message id is invalid: %s, should by 32 Bytes long in binary after converting from hex',
+                dltMessageId,
               )
+              return
             }
+            dltTx.messageId = dltMessageId.toString('hex')
+            await DltTransaction.save(dltTx)
+            logger.info('store messageId=%s in dltTx=%d', dltTx.messageId, dltTx.id)
+          } catch (e) {
+            console.log('error ', e)
+            logger.error(
+              `error while sending to dlt-connector or writing messageId of dltTx=${dltTx.id}`,
+              e,
+            )
           }
         }
+      } else {
+        logger.info('sending to DltConnector currently not configured...')
       }
     } catch (e) {
       logger.error('error on sending transactions to dlt-connector.', e)