workarea-paypal 2.0.10 → 3.0.4

data/test/integration/workarea/storefront/paypal_place_order_integration_test.rb

@@ -0,0 +1,42 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class PaypalPlaceOrderIntegrationTest < Workarea::IntegrationTest
+      def test_place_order_with_paypal
+        product = create_product(variants: [{ sku: 'SKU1', regular: 5.to_m }])
+
+        post storefront.cart_items_path, params: {
+          product_id: product.id,
+          sku: product.skus.first,
+          quantity: 2
+        }
+
+        patch storefront.checkout_addresses_path,
+          params: {
+            email: 'test@workarea.com',
+            billing_address: factory_defaults(:billing_address),
+            shipping_address: factory_defaults(:shipping_address)
+          }
+
+        patch storefront.checkout_place_order_path, params: { payment: 'paypal' }
+        assert_redirected_to(storefront.checkout_payment_path)
+        assert_equal(t('workarea.storefront.paypal.errors.place_order'), flash[:info])
+
+        Paypal::UpdateOrder.any_instance.expects(:perform).returns(true)
+        Workarea::Checkout.any_instance.stubs(:place_order).returns(true)
+
+        jar = ActionDispatch::Cookies::CookieJar.build(request, cookies.to_hash)
+        payment = Workarea::Payment.find_or_create_by(id: jar.signed[:order_id])
+        payment.set_paypal(
+          paypal_id: '123',
+          payer_id: 'abc',
+          approved: true
+        )
+
+        patch storefront.checkout_place_order_path, params: { payment: 'paypal' }
+        assert_redirected_to(storefront.checkout_confirmation_path)
+      end
+    end
+  end
+end

data/test/lib/workarea/paypal/gateway_test.rb

@@ -0,0 +1,236 @@
+require 'test_helper'
+
+module Workarea
+  module Paypal
+    class GatewayTest < TestCase
+      include PaypalSetup
+
+      def gateway
+        Paypal::Gateway.new
+      end
+
+      def body
+        {
+          intent: 'CAPTURE',
+          purchase_units: [{
+            amount: {
+              currency_code: 'USD',
+              value: '100.00'
+            }
+          }]
+        }
+      end
+
+      def order_id
+        VCR.use_cassette('paypal_gateway_create_order') do
+          gateway.create_order(body: body).id
+        end
+      end
+
+      def test_generate_token
+        response = VCR.use_cassette('paypal_gateway_generate_token') do
+          gateway.generate_token
+        end
+
+        assert(response.result.client_token.present?)
+      end
+
+      def test_get_order
+        response = VCR.use_cassette('paypal_gateway_get_order') do
+          gateway.get_order(order_id)
+        end
+
+        assert_equal(200, response.status_code)
+        assert_equal(order_id, response.result.id)
+        assert(response.result.purchase_units.first.present?)
+      end
+
+      def test_create_order
+        response = VCR.use_cassette('paypal_gateway_create_order') do
+          gateway.create_order(body: body)
+        end
+
+        assert_equal('CREATED', response.status)
+        assert(response.id.present?)
+      end
+
+      def test_update_order
+        body = [
+          {
+            op: 'replace',
+            path: "/purchase_units/@reference_id=='default'/amount",
+            value: {
+              currency_code: 'USD',
+              value: '125.00'
+            }
+          }
+        ]
+
+        VCR.use_cassette('paypal_gateway_update_order') do
+          response = gateway.update_order(order_id, body: body)
+
+          response = gateway.get_order(order_id)
+          assert_equal(200, response.status_code)
+          assert_equal('125.00', response.result.purchase_units.first.amount.value)
+        end
+      end
+
+
+      def test_capture
+        stubbed_response = OpenStruct.new(
+          status_code: 201,
+          result: PayPalHttp::HttpClient.new(nil)._parse_values(
+            purchase_units: [
+              {
+                payments: {
+                  captures: [{ id: 'CAPTURE_0001', status: 'COMPLETED' }]
+                }
+              }
+            ]
+          )
+        )
+
+        PayPal::PayPalHttpClient.any_instance.expects(:execute).returns(stubbed_response)
+
+        result = gateway.capture('1234')
+        assert(result.success?)
+        assert_equal('PayPal capture succeeded', result.message)
+        assert_equal({ 'id' => 'CAPTURE_0001', 'status' => 'COMPLETED' }, result.params)
+
+        stubbed_response.result.purchase_units.first.payments.captures.first.status = 'DECLINED'
+        PayPal::PayPalHttpClient.any_instance.unstub
+        PayPal::PayPalHttpClient.any_instance.expects(:execute).returns(stubbed_response)
+
+        result = gateway.capture('1234')
+        refute(result.success?)
+        assert_equal('PayPal capture failed', result.message)
+
+        stubbed_response.status_code = 422
+        stubbed_response.result.purchase_units.first.payments.captures.first.status = 'COMPLETED'
+        PayPal::PayPalHttpClient.any_instance.unstub
+        PayPal::PayPalHttpClient.any_instance.expects(:execute).returns(stubbed_response)
+
+        result = gateway.capture('1234')
+        refute(result.success?)
+        assert_equal('PayPal capture failed', result.message)
+        assert_equal(
+          { 'purchase_units' => [
+              { payments: { captures: [{ id: "CAPTURE_0001", status: 'COMPLETED' }] } }
+            ]
+          },
+          result.params
+        )
+
+        PayPal::PayPalHttpClient.any_instance.unstub
+        PayPal::PayPalHttpClient.any_instance.expects(:execute).raises(
+          PayPalHttp::HttpError.new(422, {}, { 'paypal-debug-id' => '123' })
+        )
+
+        result = gateway.capture('1234')
+        refute(result.success?)
+        assert_equal({ 'status_code' => 422, 'debug_id' => '123' }, result.params)
+
+        PayPal::PayPalHttpClient.any_instance.unstub
+        PayPal::PayPalHttpClient.any_instance.expects(:execute).raises(
+          StandardError.new('failed')
+        )
+
+        result = gateway.capture('1234')
+        refute(result.success?)
+        assert_equal('failed', result.message)
+        assert(result.params.blank?)
+      end
+
+
+      def test_refund
+        stubbed_response = OpenStruct.new(
+          status_code: 201,
+          result: OpenStruct.new(
+            id: 'REFUND_0001',
+            status: 'COMPLETED',
+            status_details: { reason: 'test test' }
+          )
+        )
+
+        PayPal::PayPalHttpClient
+          .any_instance
+          .expects(:execute)
+          .returns(stubbed_response)
+
+        result = gateway.refund('1234')
+        assert(result.success?)
+        assert_equal('PayPal refund succeeded', result.message)
+        assert_equal(
+          {
+            'id' => 'REFUND_0001',
+            'status' => 'COMPLETED',
+            'status_details' => { reason: 'test test' },
+            'capture_id' => '1234',
+            'amount' => ''
+          },
+          result.params
+        )
+
+        PayPal::PayPalHttpClient.any_instance.unstub
+        PayPal::PayPalHttpClient
+          .any_instance
+          .expects(:execute)
+          .with { |req| assert_equal('50.00', req.body[:amount][:value]) }
+          .returns(stubbed_response)
+
+        result = gateway.refund('1234', amount: 50.to_m)
+        assert(result.success?)
+        assert_equal('PayPal refund succeeded', result.message)
+        assert_equal(
+          {
+            'id' => 'REFUND_0001',
+            'status' => 'COMPLETED',
+            'status_details' => { reason: 'test test' },
+            'capture_id' => '1234',
+            'amount' => '50.00'
+          },
+          result.params
+        )
+      end
+
+      def test_webhooks
+        VCR.use_cassette('paypal_gateway_webhooks') do
+          webhook = gateway.create_webhook(
+            url: 'https://example.com/my-webhooks',
+            event_types: %w(
+              PAYMENT.CAPTURE.COMPLETED
+              PAYMENT.CAPTURE.DENIED
+            )
+          ).result
+
+          assert(webhook.id.present?)
+          assert_equal('https://example.com/my-webhooks', webhook.url)
+
+          list = gateway.list_webhooks.result.webhooks
+
+          assert_equal(1, list.length)
+          assert_equal(webhook.id, list.first.id)
+
+          gateway.delete_webhook(webhook.id)
+
+          list = gateway.list_webhooks.result.webhooks
+          assert_equal(0, list.length)
+        end
+      end
+
+      def test_client_id
+        ENV['WORKAREA_PAYPAL_CLIENT_ID'] = nil
+
+        if Rails.application.credentials.paypal.present?
+          assert(Rails.application.credentials.paypal[:client_id], gateway.client_id)
+        elsif Workarea.config.paypal.try(:[], :client_id).present?
+          assert(Workarea.config.paypal[:client_id], gateway.client_id)
+        end
+
+        ENV['WORKAREA_PAYPAL_CLIENT_ID'] = 'abc123'
+
+        assert('abc123', gateway.client_id)
+      end
+    end
+  end
+end

data/test/models/workarea/payment/authorize/paypal_test.rb

@@ -4,21 +4,14 @@ module Workarea
   class Payment
     module Authorize
       class PaypalTest < Workarea::TestCase
-        delegate :gateway, to: Workarea::Paypal
-
         def payment
           @payment ||= create_payment
         end
 
-        def authorization
-          @authorization ||= ActiveMerchant::Billing::BogusGateway::AUTHORIZATION
-        end
-
         def tender
           @tender ||=
             begin
-              payment.set_address(first_name: 'Ben', last_name: 'Crouse')
-              payment.build_paypal(token: '1234', payer_id: 'pid')
+              payment.build_paypal(paypal_id: '1234', payer_id: 'pid')
               payment.paypal
             end
         end
@@ -30,63 +23,81 @@ module Workarea
           )
         end
 
-        def test_complete_authorizes_on_the_paypal_gateway
-          operation = Paypal.new(tender, transaction)
-
-          gateway.expects(:authorize)
+        def stubbed_capture
+          @stubbed_capture ||= OpenStruct.new(
+            status_code: 201,
+            result: PayPalHttp::HttpClient.new(nil)._parse_values(
+              purchase_units: [
+                {
+                  payments: {
+                    captures: [{ id: 'CAPTURE_0001', status: 'COMPLETED' }]
+                  }
+                }
+              ]
+            )
+          )
+        end
 
-          operation.complete!
+        def stubbed_refund
+          @stubbed_refund ||= OpenStruct.new(
+            status_code: 201,
+            result: OpenStruct.new(
+              id: 'REFUND_0001',
+              status: 'COMPLETED',
+            )
+          )
         end
 
-        def test_complete_sets_the_response_on_the_transaction
+        def test_complete_success
+          PayPal::PayPalHttpClient.any_instance.expects(:execute).returns(stubbed_capture)
+
           operation = Paypal.new(tender, transaction)
           operation.complete!
 
-          assert_instance_of(
-            ActiveMerchant::Billing::Response,
-            transaction.response
-          )
-        end
+          assert_equal('purchase', transaction.action)
+          assert(transaction.response.success?)
+          assert(transaction.response.message.present?)
+          assert(transaction.response.params.present?)
 
-        def test_cancel_does_nothing_if_the_transaction_was_a_failure
-          transaction.success = false
-          operation = Paypal.new(tender, transaction)
+          PayPal::PayPalHttpClient.any_instance.unstub
+          PayPal::PayPalHttpClient.any_instance.expects(:execute).returns(stubbed_refund)
 
-          operation.gateway.expects(:void).never
           operation.cancel!
+          assert(transaction.cancellation.success?)
+          assert(transaction.cancellation.message.present?)
+          assert_equal('CAPTURE_0001', transaction.cancellation.params['capture_id'])
         end
 
-        def test_cancel_voids_with_the_authorization_from_the_transaction
-          transaction.response = ActiveMerchant::Billing::Response.new(
-            true,
-            'Message',
-            'transaction_id' => authorization
-          )
+        def test_complete_success_but_pending
+          stubbed_capture.result.purchase_units.first.payments.captures.first.status = 'PENDING'
+          PayPal::PayPalHttpClient.any_instance.expects(:execute).returns(stubbed_capture)
 
           operation = Paypal.new(tender, transaction)
+          operation.complete!
 
-          operation
-            .gateway
-            .expects(:void)
-            .with(authorization)
-
-          operation.cancel!
+          assert_equal('authorize', transaction.action)
+          assert(transaction.response.success?)
+          assert(transaction.response.message.present?)
+          assert(transaction.response.params.present?)
         end
 
-        def test_cancel_sets_cancellation_params_on_the_transaction
-          transaction.response = ActiveMerchant::Billing::Response.new(
-            true,
-            'Message',
-            'transaction_id' => authorization
-          )
+        def test_complete_failure
+          stubbed_capture.status_code = 500
+          PayPal::PayPalHttpClient.any_instance.expects(:execute).returns(stubbed_capture)
 
           operation = Paypal.new(tender, transaction)
-          operation.cancel!
+          operation.complete!
 
-          assert_instance_of(
-            ActiveMerchant::Billing::Response,
-            transaction.cancellation
-          )
+          assert_equal('purchase', transaction.action)
+          refute(transaction.response.success?)
+          assert(transaction.response.message.present?)
+          assert(transaction.response.params.present?)
+
+          PayPal::PayPalHttpClient.any_instance.unstub
+          PayPal::PayPalHttpClient.any_instance.expects(:execute).never
+
+          operation.cancel!
+          assert_nil(transaction.cancellation)
         end
       end
     end

data/test/models/workarea/payment/capture/paypal_test.rb

@@ -4,63 +4,21 @@ module Workarea
   class Payment
     class Capture
       class PaypalTest < Workarea::TestCase
-        delegate :gateway, to: Workarea::Paypal
-
-        def authorization
-          @authorization ||= ActiveMerchant::Billing::BogusGateway::AUTHORIZATION
-        end
-
         def payment
-          @payment ||=
-            begin
-              result = create_payment
-              result.set_paypal(token: '1234', payer_id: 'pid')
-              result
-            end
-        end
-
-        def reference
-          @reference ||= Transaction.new(
-            amount: 5.to_m,
-            response: ActiveMerchant::Billing::Response.new(
-              true,
-              'Message',
-              'transaction_id' => authorization
-            )
-          )
-        end
-
-        def transaction
-          @transaction ||= payment.paypal.transactions.build(
-            amount: 5.to_m,
-            reference: reference
+          @payment ||= create_payment(
+            paypal: { paypal_id: '123', approved: true }
           )
         end
 
-        def test_complate_raises_if_the_reference_transaction_is_blank
-          transaction.reference = nil
-          operation = Paypal.new(payment.paypal, transaction)
-
-          assert_raises(Payment::MissingReference) { operation.complete! }
-        end
-
-        def test_complete_captures_on_the_credit_card_gateway
-          operation = Paypal.new(payment.paypal, transaction)
-
-          gateway
-            .expects(:capture)
-            .with(500, authorization, currency: 'USD')
-
-          operation.complete!
-        end
+        def test_complete!
+          transaction = payment.paypal.build_transaction(action: 'capture')
 
-        def test_complete_sets_the_response_on_the_transaction
-          operation = Paypal.new(payment.paypal, transaction)
-          operation.complete!
+          Paypal.new(payment.paypal, transaction).complete!
 
-          assert_instance_of(
-            ActiveMerchant::Billing::Response,
-            transaction.response
+          refute(transaction.success?)
+          assert_includes(
+            transaction.message,
+            I18n.t('workarea.payment.paypal_capture')
           )
         end
       end