backend unit test coverage to 80%

backend/tests/unit/utils/stripeErrors.test.js

@@ -4,6 +4,9 @@ const {
   DECLINE_MESSAGES,
 } = require('../../../utils/stripeErrors');
 
+// Access INVALID_REQUEST_MESSAGES for testing via module internals
+// We'll test it indirectly through parseStripeError since it's not exported
+
 describe('Stripe Errors Utility', () => {
   describe('DECLINE_MESSAGES', () => {
     const requiredProperties = [
@@ -252,4 +255,253 @@ describe('Stripe Errors Utility', () => {
       expect(json).not.toHaveProperty('_stripeCode');
     });
   });
+
+  describe('parseStripeError - StripeInvalidRequestError', () => {
+    const requiredProperties = [
+      'ownerMessage',
+      'renterMessage',
+      'canOwnerRetry',
+      'requiresNewPaymentMethod',
+    ];
+
+    test('should parse resource_missing error', () => {
+      const error = {
+        type: 'StripeInvalidRequestError',
+        code: 'resource_missing',
+        message: 'No such payment method',
+      };
+
+      const result = parseStripeError(error);
+
+      expect(result.code).toBe('resource_missing');
+      expect(result.ownerMessage).toBe("The renter's payment method is no longer valid.");
+      expect(result.requiresNewPaymentMethod).toBe(true);
+      expect(result.canOwnerRetry).toBe(false);
+    });
+
+    test('should parse payment_method_invalid error', () => {
+      const error = {
+        type: 'StripeInvalidRequestError',
+        code: 'payment_method_invalid',
+        message: 'Payment method is invalid',
+      };
+
+      const result = parseStripeError(error);
+
+      expect(result.code).toBe('payment_method_invalid');
+      expect(result.ownerMessage).toBe("The renter's payment method is invalid.");
+      expect(result.requiresNewPaymentMethod).toBe(true);
+    });
+
+    test('should parse payment_intent_unexpected_state error', () => {
+      const error = {
+        type: 'StripeInvalidRequestError',
+        code: 'payment_intent_unexpected_state',
+        message: 'Payment intent in unexpected state',
+      };
+
+      const result = parseStripeError(error);
+
+      expect(result.code).toBe('payment_intent_unexpected_state');
+      expect(result.ownerMessage).toBe('This payment is in an unexpected state.');
+      expect(result.canOwnerRetry).toBe(true);
+      expect(result.requiresNewPaymentMethod).toBe(false);
+    });
+
+    test('should parse customer_deleted error', () => {
+      const error = {
+        type: 'StripeInvalidRequestError',
+        code: 'customer_deleted',
+        message: 'Customer has been deleted',
+      };
+
+      const result = parseStripeError(error);
+
+      expect(result.code).toBe('customer_deleted');
+      expect(result.ownerMessage).toBe("The renter's payment profile has been deleted.");
+      expect(result.requiresNewPaymentMethod).toBe(true);
+    });
+
+    test('should handle StripeInvalidRequestError with decline_code', () => {
+      const error = {
+        type: 'StripeInvalidRequestError',
+        code: 'some_code',
+        decline_code: 'insufficient_funds',
+        message: 'Card declined due to insufficient funds',
+      };
+
+      const result = parseStripeError(error);
+
+      expect(result.code).toBe('insufficient_funds');
+      expect(result.ownerMessage).toBe("The renter's card has insufficient funds.");
+    });
+
+    test('should handle StripeInvalidRequestError with code matching DECLINE_MESSAGES', () => {
+      const error = {
+        type: 'StripeInvalidRequestError',
+        code: 'expired_card',
+        message: 'Card has expired',
+      };
+
+      const result = parseStripeError(error);
+
+      expect(result.code).toBe('expired_card');
+      expect(result.ownerMessage).toBe("The renter's card has expired.");
+      expect(result.requiresNewPaymentMethod).toBe(true);
+    });
+
+    test('should return default for unhandled StripeInvalidRequestError', () => {
+      const error = {
+        type: 'StripeInvalidRequestError',
+        code: 'unknown_invalid_request_code',
+        message: 'Some unknown error',
+      };
+
+      const result = parseStripeError(error);
+
+      expect(result.code).toBe('unknown_invalid_request_code');
+      expect(result.ownerMessage).toBe('There was a problem processing this payment.');
+      expect(result.renterMessage).toBe('There was a problem with your payment method.');
+      expect(result.requiresNewPaymentMethod).toBe(true);
+    });
+
+    // Verify INVALID_REQUEST_MESSAGES entries have all required properties
+    describe('INVALID_REQUEST_MESSAGES structure validation', () => {
+      const invalidRequestCodes = [
+        'resource_missing',
+        'payment_method_invalid',
+        'payment_intent_unexpected_state',
+        'customer_deleted',
+      ];
+
+      test.each(invalidRequestCodes)('%s error returns all required properties', (code) => {
+        const error = {
+          type: 'StripeInvalidRequestError',
+          code: code,
+          message: 'Test error',
+        };
+
+        const result = parseStripeError(error);
+
+        for (const prop of requiredProperties) {
+          expect(result).toHaveProperty(prop);
+        }
+        expect(result).toHaveProperty('_originalMessage');
+        expect(result).toHaveProperty('_stripeCode');
+      });
+    });
+  });
+
+  describe('parseStripeError - edge cases', () => {
+    test('should handle StripeConnectionError same as StripeAPIError', () => {
+      const error = {
+        type: 'StripeConnectionError',
+        message: 'Network connection failed',
+        code: 'connection_error',
+      };
+
+      const result = parseStripeError(error);
+
+      expect(result.code).toBe('api_error');
+      expect(result.canOwnerRetry).toBe(true);
+      expect(result.requiresNewPaymentMethod).toBe(false);
+      expect(result.ownerMessage).toBe('A temporary error occurred. Please try again.');
+    });
+
+    test('should return unknown_error for completely unknown error type', () => {
+      const error = {
+        type: 'UnknownStripeErrorType',
+        message: 'Something unexpected happened',
+        code: 'unknown_code',
+      };
+
+      const result = parseStripeError(error);
+
+      expect(result.code).toBe('unknown_error');
+      expect(result.ownerMessage).toBe('The payment could not be processed.');
+      expect(result.renterMessage).toBe('Your payment could not be processed. Please try a different payment method.');
+    });
+
+    test('should include _originalMessage and _stripeCode in all responses', () => {
+      // Test StripeCardError
+      const cardError = {
+        type: 'StripeCardError',
+        code: 'card_declined',
+        decline_code: 'generic_decline',
+        message: 'Card was declined',
+      };
+      const cardResult = parseStripeError(cardError);
+      expect(cardResult._originalMessage).toBe('Card was declined');
+      expect(cardResult._stripeCode).toBe('card_declined');
+
+      // Test StripeAPIError
+      const apiError = {
+        type: 'StripeAPIError',
+        message: 'API error occurred',
+        code: 'api_error',
+      };
+      const apiResult = parseStripeError(apiError);
+      expect(apiResult._originalMessage).toBe('API error occurred');
+      expect(apiResult._stripeCode).toBe('api_error');
+
+      // Test StripeRateLimitError
+      const rateLimitError = {
+        type: 'StripeRateLimitError',
+        message: 'Rate limit exceeded',
+        code: 'rate_limit',
+      };
+      const rateLimitResult = parseStripeError(rateLimitError);
+      expect(rateLimitResult._originalMessage).toBe('Rate limit exceeded');
+      expect(rateLimitResult._stripeCode).toBe('rate_limit');
+
+      // Test unknown error
+      const unknownError = {
+        type: 'UnknownType',
+        message: 'Unknown error',
+        code: 'unknown',
+      };
+      const unknownResult = parseStripeError(unknownError);
+      expect(unknownResult._originalMessage).toBe('Unknown error');
+      expect(unknownResult._stripeCode).toBe('unknown');
+    });
+
+    test('should handle error with no message', () => {
+      const error = {
+        type: 'StripeCardError',
+        code: 'card_declined',
+        decline_code: 'generic_decline',
+      };
+
+      const result = parseStripeError(error);
+
+      expect(result.code).toBe('generic_decline');
+      expect(result._originalMessage).toBeUndefined();
+    });
+
+    test('should handle error with null decline_code', () => {
+      const error = {
+        type: 'StripeCardError',
+        code: 'card_declined',
+        decline_code: null,
+        message: 'Card declined',
+      };
+
+      const result = parseStripeError(error);
+
+      expect(result.code).toBe('card_declined');
+    });
+
+    test('should handle StripeInvalidRequestError with null code', () => {
+      const error = {
+        type: 'StripeInvalidRequestError',
+        code: null,
+        message: 'Invalid request',
+      };
+
+      const result = parseStripeError(error);
+
+      expect(result.code).toBe('invalid_request');
+      expect(result.requiresNewPaymentMethod).toBe(true);
+    });
+  });
 });