tests up and working

backend/src/config/index.ts

@@ -10,7 +10,7 @@ Decimal.set({
 })
 
 const constants = {
-  DB_VERSION: '0049-add_user_contacts_table',
+  DB_VERSION: '0050-add_messageId_to_event_protocol',
   DECAY_START_TIME: new Date('2021-05-13 17:46:31-0000'), // GMT+0
   LOG4JS_CONFIG: 'log4js-config.json',
   // default log level on production should be info

backend/src/graphql/resolver/TransactionResolver.test.ts

@@ -1,5 +1,20 @@
-import { cleanDB, testEnvironment } from '@test/helpers'
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/explicit-module-boundary-types */
+
+import { userFactory } from '@/seeds/factory/user'
+import {
+  confirmContribution,
+  createContribution,
+  createUser,
+  sendCoins,
+} from '@/seeds/graphql/mutations'
+import { login } from '@/seeds/graphql/queries'
+import { bobBaumeister } from '@/seeds/users/bob-baumeister'
+import { peterLustig } from '@/seeds/users/peter-lustig'
+import { User } from '@entity/User'
+import { cleanDB, resetToken, testEnvironment } from '@test/helpers'
 import { logger } from '@test/testSetup'
+import { GraphQLError } from 'graphql'
 
 let mutate: any, query: any, con: any
 let testEnv: any
@@ -15,4 +30,269 @@ beforeAll(async () => {
 afterAll(async () => {
   await cleanDB()
   await con.close()
-})
+})
+
+let bobData: any
+let peterData: any
+let user: User[]
+
+describe('send coins', () => {
+  beforeAll(async () => {
+    await userFactory(testEnv, peterLustig)
+    await userFactory(testEnv, bobBaumeister)
+
+    bobData = {
+      email: 'bob@baumeister.de',
+      password: 'Aa12345_',
+      publisherId: 1234,
+    }
+
+    peterData = {
+      email: 'peter@lustig.de',
+      password: 'Aa12345_',
+      publisherId: 1234,
+    }
+
+    user = await User.find({ relations: ['emailContact'] })
+  })
+
+  afterAll(async () => {
+    await cleanDB()
+  })
+
+  describe('wrong recipient', () => {
+    it('unknown recipient', async () => {
+      await mutate({
+        query: login,
+        variables: bobData,
+      })
+      expect(
+        await mutate({
+          mutation: sendCoins,
+          variables: {
+            email: 'wrong@email.com',
+            amount: 100,
+            memo: 'test',
+          },
+        }),
+      ).toEqual(
+        expect.objectContaining({
+          errors: [new GraphQLError('No user with this credentials')],
+        }),
+      )
+    })
+
+    it('deleted recipient', async () => {
+      // delete bob
+      const bob = await User.findOneOrFail({ id: user[1].id })
+      bob.deletedAt = new Date()
+      await bob.save()
+
+      await mutate({
+        query: login,
+        variables: peterData,
+      })
+
+      expect(
+        await mutate({
+          mutation: sendCoins,
+          variables: {
+            email: 'bob@baumeister.de',
+            amount: 100,
+            memo: 'test',
+          },
+        }),
+      ).toEqual(
+        expect.objectContaining({
+          errors: [new GraphQLError('The recipient account was deleted')],
+        }),
+      )
+
+      // make bob active again
+      bob.deletedAt = null
+      await bob.save()
+    })
+
+    it('recipient account not activated', async () => {
+      resetToken()
+
+      await mutate({
+        mutation: createUser,
+        variables: {
+          email: 'testing@user.de',
+          firstName: 'testing',
+          lastName: 'user',
+          language: 'de',
+          publisherId: 1234,
+        },
+      })
+
+      await mutate({
+        query: login,
+        variables: peterData,
+      })
+
+      expect(
+        await mutate({
+          mutation: sendCoins,
+          variables: {
+            email: 'testing@user.de',
+            amount: 100,
+            memo: 'test',
+          },
+        }),
+      ).toEqual(
+        expect.objectContaining({
+          errors: [new GraphQLError('The recipient account is not activated')],
+        }),
+      )
+    })
+  })
+
+  describe('errors in the transaction itself', () => {
+    beforeAll(async () => {
+      await mutate({
+        query: login,
+        variables: bobData,
+      })
+    })
+
+    describe('sender and recipient are the same', () => {
+      it('throws an error', async () => {
+        expect(
+          await mutate({
+            mutation: sendCoins,
+            variables: {
+              email: 'bob@baumeister.de',
+              amount: 100,
+              memo: 'test',
+            },
+          }),
+        ).toEqual(
+          expect.objectContaining({
+            errors: [new GraphQLError('Sender and Recipient are the same.')],
+          }),
+        )
+      })
+
+      it('logs the error thrown', () => {
+        expect(logger.error).toBeCalledWith('Sender and Recipient are the same.')
+      })
+    })
+
+    describe('memo text is too long', () => {
+      it('throws an error', async () => {
+        expect(
+          await mutate({
+            mutation: sendCoins,
+            variables: {
+              email: 'peter@lustig.de',
+              amount: 100,
+              memo: 'test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test test t',
+            },
+          }),
+        ).toEqual(
+          expect.objectContaining({
+            errors: [new GraphQLError('memo text is too long (255 characters maximum)')],
+          }),
+        )
+      })
+
+      it('logs the error thrown', () => {
+        expect(logger.error).toBeCalledWith('memo text is too long: memo.length=256 > 255')
+      })
+    })
+
+    describe('memo text is too short', () => {
+      it('throws an error', async () => {
+        expect(
+          await mutate({
+            mutation: sendCoins,
+            variables: {
+              email: 'peter@lustig.de',
+              amount: 100,
+              memo: 'test',
+            },
+          }),
+        ).toEqual(
+          expect.objectContaining({
+            errors: [new GraphQLError('memo text is too short (5 characters minimum)')],
+          }),
+        )
+      })
+
+      it('logs the error thrown', () => {
+        expect(logger.error).toBeCalledWith('memo text is too short: memo.length=4 < 5')
+      })
+    })
+
+    describe('user has not enough GDD', () => {
+      it('throws an error', async () => {
+        expect(
+          await mutate({
+            mutation: sendCoins,
+            variables: {
+              email: 'peter@lustig.de',
+              amount: 100,
+              memo: 'testing',
+            },
+          }),
+        ).toEqual(
+          expect.objectContaining({
+            errors: [new GraphQLError(`user hasn't enough GDD or amount is < 0`)],
+          }),
+        )
+      })
+
+      it('logs the error thrown', () => {
+        expect(logger.error).toBeCalledWith(
+          `user hasn't enough GDD or amount is < 0 : balance=null`,
+        )
+      })
+    })
+  })
+
+  describe('transaction correct', () => {
+    it('sends the coins', async () => {
+      // make Peter Lustig Admin
+      const peter = await User.findOneOrFail({ id: user[0].id })
+      peter.isAdmin = new Date()
+      await peter.save()
+
+      // create contribution as user bob
+      const contribution = await mutate({
+        mutation: createContribution,
+        variables: { amount: 1000, memo: 'testing', creationDate: new Date().toISOString() },
+      })
+
+      // login as admin
+      await query({ query: login, variables: peterData })
+
+      // confirm the contribution
+      await mutate({
+        mutation: confirmContribution,
+        variables: { id: contribution.data.createContribution.id },
+      })
+
+      // login as bob again
+      await query({ query: login, variables: bobData })
+
+      expect(
+        await mutate({
+          mutation: sendCoins,
+          variables: {
+            email: 'peter@lustig.de',
+            amount: 100,
+            memo: 'testing',
+          },
+        }),
+      ).toEqual(
+        expect.objectContaining({
+          data: {
+            sendCoins: 'true',
+          },
+        }),
+      )
+    })
+  })
+})

backend/src/graphql/resolver/TransactionResolver.ts

@@ -55,12 +55,12 @@ export const executeTransaction = async (
   }
 
   if (memo.length > MEMO_MAX_CHARS) {
-    logger.error(`memo text is too long: memo.length=${memo.length} > (${MEMO_MAX_CHARS}`)
+    logger.error(`memo text is too long: memo.length=${memo.length} > ${MEMO_MAX_CHARS}`)
     throw new Error(`memo text is too long (${MEMO_MAX_CHARS} characters maximum)`)
   }
 
   if (memo.length < MEMO_MIN_CHARS) {
-    logger.error(`memo text is too short: memo.length=${memo.length} < (${MEMO_MIN_CHARS}`)
+    logger.error(`memo text is too short: memo.length=${memo.length} < ${MEMO_MIN_CHARS}`)
     throw new Error(`memo text is too short (${MEMO_MIN_CHARS} characters minimum)`)
   }
 
@@ -74,6 +74,7 @@ export const executeTransaction = async (
   )
   logger.debug(`calculated Balance=${sendBalance}`)
   if (!sendBalance) {
+    // josejgi: wrong messages from my point of view, at this point balance is always null, should log inside calculate balance or handle returns in a different way
     logger.error(`user hasn't enough GDD or amount is < 0 : balance=${sendBalance}`)
     throw new Error("user hasn't enough GDD or amount is < 0")
   }
@@ -316,6 +317,10 @@ export class TransactionResolver {
     }
     */
     // const recipientUser = await dbUser.findOne({ id: emailContact.userId })
+
+    /* Code inside this if statement is unreachable (useless by so), 
+    in findUserByEmail() an error is already thrown if the user is not found
+    */
     if (!recipientUser) {
       logger.error(`unknown recipient to UserContact: email=${email}`)
       throw new Error('unknown recipient')