Merge branch 'master' into feat/async-and-improved-initialization

chedieck · chedieck · commit 4e4db8c91022 · 2025-08-29T05:55:13.000-03:00
diff --git a/.github/coding-instructions.md b/.github/coding-instructions.md
@@ -9,6 +9,7 @@ When writing tests, follow these guidelines to ensure consistency and maintainab
  - **Make tests resilient to refactoring**: Tests should pass even if internal implementation changes, as long as the behavior remains the same.
  - Never make up new functions just to make tests pass. Always build tests based on the functions that already exist. If a function needs to be updated/revised/refactored, that is also OK.
  - Do not just add a 'markTestSkipped' on tests that look difficult to write. Instead, explain the problem and ask for some additional context before trying again.
+ - Make sure new tests added into the "integration-tests" directory are actually integration tests.
 
 General guidlines:
 - Never edit files that are git ignored.
diff --git a/tests/unittests/triggerService.test.ts b/tests/unittests/triggerService.test.ts
@@ -0,0 +1,238 @@
+import { prismaMock } from '../../prisma-local/mockedClient'
+import prisma from '../../prisma-local/clientInstance'
+import axios from 'axios'
+
+import { parseTriggerPostData } from '../../utils/validators'
+
+jest.mock('axios')
+const mockedAxios = axios as jest.Mocked<typeof axios>
+
+jest.mock('../../utils/validators', () => {
+  const originalModule = jest.requireActual('../../utils/validators')
+  return {
+    ...originalModule,
+    parseTriggerPostData: jest.fn()
+  }
+})
+const mockedParseTriggerPostData = parseTriggerPostData as jest.MockedFunction<typeof parseTriggerPostData>
+
+describe('Trigger JSON Validation Unit Tests', () => {
+  describe('Trigger Creation with JSON Validation', () => {
+    it('should reject trigger creation with invalid JSON during validation', async () => {
+      const invalidPostData = '{"amount": <amount>, "currency": <currency>'
+
+      mockedParseTriggerPostData.mockImplementation(() => {
+        throw new SyntaxError('Unexpected end of JSON input')
+      })
+
+      expect(() => {
+        parseTriggerPostData({
+          userId: 'test-user',
+          postData: invalidPostData,
+          postDataParameters: {} as any
+        })
+      }).toThrow('Unexpected end of JSON input')
+
+      expect(mockedParseTriggerPostData).toHaveBeenCalled()
+    })
+
+    it('should allow trigger creation with valid JSON', async () => {
+      const validPostData = '{"amount": <amount>, "currency": <currency>}'
+      const expectedParsedData = { amount: 100, currency: 'XEC' }
+
+      mockedParseTriggerPostData.mockReturnValue(expectedParsedData)
+
+      const result = parseTriggerPostData({
+        userId: 'test-user',
+        postData: validPostData,
+        postDataParameters: {} as any
+      })
+
+      expect(result).toEqual(expectedParsedData)
+      expect(mockedParseTriggerPostData).toHaveBeenCalled()
+    })
+  })
+
+  describe('Trigger Execution Scenarios', () => {
+    beforeEach(() => {
+      jest.clearAllMocks()
+
+      prismaMock.triggerLog.create.mockResolvedValue({
+        id: 1,
+        triggerId: 'test-trigger',
+        isError: false,
+        actionType: 'PostData',
+        data: '{}',
+        createdAt: new Date(),
+        updatedAt: new Date()
+      })
+      prisma.triggerLog.create = prismaMock.triggerLog.create
+    })
+
+    it('should demonstrate JSON validation flow differences', async () => {
+      console.log('=== Test Case 1: Valid JSON ===')
+
+      mockedParseTriggerPostData.mockReturnValue({ amount: 100, currency: 'XEC' })
+      mockedAxios.post.mockResolvedValue({ data: { success: true } })
+
+      try {
+        const result = parseTriggerPostData({
+          userId: 'user-123',
+          postData: '{"amount": <amount>, "currency": <currency>}',
+          postDataParameters: {} as any
+        })
+        console.log('✅ JSON parsing succeeded:', result)
+        console.log('✅ Network request would be made')
+      } catch (error) {
+        console.log('❌ Unexpected error:', error)
+      }
+
+      console.log('\n=== Test Case 2: Invalid JSON ===')
+
+      mockedParseTriggerPostData.mockImplementation(() => {
+        throw new SyntaxError('Unexpected end of JSON input')
+      })
+
+      try {
+        parseTriggerPostData({
+          userId: 'user-123',
+          postData: '{"amount": <amount>, "currency": <currency>',
+          postDataParameters: {} as any
+        })
+        console.log('❌ Should not reach here')
+      } catch (error) {
+        console.log('✅ JSON parsing failed as expected:', (error as Error).message)
+        console.log('✅ Network request would NOT be made')
+      }
+
+      expect(mockedParseTriggerPostData).toHaveBeenCalledTimes(2)
+    })
+
+    it('should log JSON validation errors with proper details', async () => {
+      const testCases = [
+        {
+          name: 'Missing closing brace',
+          postData: '{"amount": <amount>, "currency": <currency>',
+          expectedError: 'Unexpected end of JSON input'
+        },
+        {
+          name: 'Invalid property syntax',
+          postData: '{amount: <amount>, "currency": <currency>}',
+          expectedError: 'Expected property name'
+        },
+        {
+          name: 'Extra comma',
+          postData: '{"amount": <amount>,, "currency": <currency>}',
+          expectedError: 'Unexpected token'
+        }
+      ]
+
+      testCases.forEach(({ name, postData, expectedError }) => {
+        console.log(`\n=== Testing: ${name} ===`)
+
+        mockedParseTriggerPostData.mockImplementation(() => {
+          const error = new SyntaxError(expectedError)
+          error.name = 'SyntaxError'
+          throw error
+        })
+
+        try {
+          parseTriggerPostData({
+            userId: 'user-123',
+            postData,
+            postDataParameters: {} as any
+          })
+          console.log('❌ Should have failed')
+        } catch (error) {
+          const err = error as Error
+          console.log('✅ Failed as expected:', err.message)
+          expect(err.name).toBe('SyntaxError')
+          expect(err.message).toContain(expectedError)
+        }
+      })
+    })
+
+    it('should handle edge cases gracefully', async () => {
+      const edgeCases = [
+        {
+          name: 'Empty post data',
+          postData: '',
+          mockError: new Error('No data to parse')
+        },
+        {
+          name: 'Null-like post data',
+          postData: 'null',
+          mockError: new Error('Invalid null data')
+        },
+        {
+          name: 'Non-object JSON',
+          postData: '"just a string"',
+          mockError: new Error('Expected object')
+        }
+      ]
+
+      edgeCases.forEach(({ name, postData, mockError }) => {
+        console.log(`\n=== Testing edge case: ${name} ===`)
+
+        mockedParseTriggerPostData.mockImplementation(() => {
+          throw mockError
+        })
+
+        try {
+          parseTriggerPostData({
+            userId: 'user-123',
+            postData,
+            postDataParameters: {} as any
+          })
+          console.log('❌ Should have failed')
+        } catch (error) {
+          console.log('✅ Handled gracefully:', (error as Error).message)
+        }
+      })
+    })
+  })
+
+  describe('Performance and Efficiency Benefits', () => {
+    it('should demonstrate network request avoidance', async () => {
+      let networkRequestCount = 0
+
+      mockedAxios.post.mockImplementation(async () => {
+        networkRequestCount++
+        return { data: { success: true } }
+      })
+
+      console.log('\n=== Performance Test: Valid vs Invalid JSON ===')
+
+      mockedParseTriggerPostData.mockReturnValue({ amount: 100 })
+
+      try {
+        parseTriggerPostData({
+          userId: 'user-123',
+          postData: '{"amount": <amount>}',
+          postDataParameters: {} as any
+        })
+        await mockedAxios.post('https://example.com', { amount: 100 })
+        console.log('✅ Valid JSON: Network request made')
+      } catch (error) {
+        console.log('❌ Unexpected error with valid JSON')
+      }
+
+      mockedParseTriggerPostData.mockImplementation(() => {
+        throw new SyntaxError('Invalid JSON')
+      })
+
+      try {
+        parseTriggerPostData({
+          userId: 'user-123',
+          postData: '{"amount": <amount>',
+          postDataParameters: {} as any
+        })
+      } catch (error) {
+        console.log('✅ Invalid JSON: No network request made')
+      }
+
+      console.log(`Network requests made: ${networkRequestCount}`)
+      expect(networkRequestCount).toBe(1)
+    })
+  })
+})
diff --git a/utils/validators.ts b/utils/validators.ts
@@ -231,7 +231,7 @@ interface TriggerSignature {
 
 function getSignaturePayload (postData: string, postDataParameters: PostDataParameters): string {
   const includedVariables = TRIGGER_POST_VARIABLES.filter(v => postData.includes(v)).sort()
-  return includedVariables.map(varString => {
+  const result = includedVariables.map(varString => {
     const key = varString.replace('<', '').replace('>', '') as keyof PostDataParameters
     let valueString = ''
     if (key === 'opReturn') {
@@ -241,7 +241,8 @@ function getSignaturePayload (postData: string, postDataParameters: PostDataPara
       valueString = postDataParameters[key] as string
     }
     return valueString
-  }).join('+')
+  }).filter(value => value !== undefined && value !== null && value !== '')
+  return result.join('+')
 }
 
 export function signPostData ({ userId, postData, postDataParameters }: PaybuttonTriggerParseParameters): TriggerSignature {
