workarea-paypal 2.0.12 → 3.0.0

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

@@ -3,346 +3,156 @@ require 'test_helper'
 module Workarea
   module Storefront
     class PaypalIntengrationTest < Workarea::IntegrationTest
-      delegate :gateway, to: Workarea::Paypal
+      def assert_paypal_create_order
+        Paypal::CreateOrder.any_instance.expects(:perform)
+          .returns(OpenStruct.new(id: 'test123'))
+      end
+
+      def assert_paypal_approve_order
+        Paypal::ApproveOrder.any_instance.expects(:perform).returns(true)
+      end
+
+      def product
+        @product ||= create_product(
+          variants: [{ sku: 'SKU1', regular: 6.to_m, tax_code: '001' }]
+        )
+      end
 
-      setup :stub_paypal_setup_redirect_url
+      def add_item_to_cart
+        post storefront.cart_items_path, params: {
+          product_id: product.id,
+          sku: product.skus.first,
+          quantity: 2
+        }
+      end
 
-      def test_start_starts_checkout_when_guest
+      def test_create_starts_checkout_when_guest
         add_item_to_cart
         Workarea::Checkout.any_instance.expects(:start_as).with(:guest)
-        get storefront.start_paypal_path
+        assert_paypal_create_order
+
+        post storefront.paypal_path, xhr: true
       end
 
-      def test_start_starts_checkout_when_logged_in
+      def test_create_starts_checkout_when_logged_in
         add_item_to_cart
-        user = User.new
 
-        Workarea::Storefront::PaypalController
-          .any_instance
-          .stubs(:current_user)
-          .returns(user)
+        user = create_user(email: 'test@workarea.com')
+        set_current_user(user)
 
         Workarea::Checkout.any_instance.expects(:start_as).with(user)
-        get storefront.start_paypal_path
+        assert_paypal_create_order
+
+        post storefront.paypal_path, xhr: true
       end
 
-      def test_start_does_not_start_checkout_from_checkout
+      def test_create_does_not_start_checkout_from_checkout
         add_item_to_cart
+        Workarea::Order.last.touch_checkout!
+
         Workarea::Checkout.any_instance.expects(:start_as).never
+        assert_paypal_create_order
 
-        get storefront.start_paypal_path, params: { from_checkout: 'from_checkout' }
+        post storefront.paypal_path, xhr: true
       end
 
-      def test_start_prices_the_order
+      def test_create_success
         add_item_to_cart
-        Workarea::Pricing.expects(:perform)
 
-        get storefront.start_paypal_path
-      end
+        assert_paypal_create_order
 
-      def test_start_uses_setup_to_redirect
-        add_item_to_cart
-        get storefront.start_paypal_path
-        assert_redirected_to('http://paypal.com')
-      end
+        post storefront.paypal_path, xhr: true
 
-      def test_start_redirects_to_cart_if_empty
-        get storefront.start_paypal_path
-        assert_redirected_to(storefront.cart_path)
+        json = JSON.parse(response.body)
+        assert(json['id'].present?)
       end
 
-      def test_start_rdirects_to_cart_if_inventory_is_not_available
-        product = create_product(variants: [{ sku: 'SKU', regular: 5 }])
+      def test_create_on_existing_paypal_order
+        add_item_to_cart
 
-        post storefront.cart_items_path, params: {
-          product_id: product.id,
-          sku: product.skus.first,
-          quantity: 1
-        }
+        order = Order.carts.last
+        order.touch_checkout!
 
-        create_inventory(
-          id: product.skus.first,
-          policy: 'standard',
-          available: 0
-        )
+        payment = Payment.find_or_initialize_by(id: order.id)
+        payment.build_paypal(paypal_id: '0987', approved: true)
+        payment.save!
 
-        get storefront.start_paypal_path
-        assert_redirected_to(storefront.cart_path)
-      end
+        Paypal::CreateOrder.any_instance.expects(:perform).never
 
-      def test_complete_sets_the_current_order
-        add_item_to_cart
-        stub_paypal_update_apply
-        Workarea::Storefront::PaypalController
-          .any_instance
-          .expects(:current_order=)
-        get storefront.complete_paypal_path(order_id: order.id)
-      end
+        post storefront.paypal_path, xhr: true
 
-      def test_complete_applies_a_paupal_update
-        add_item_to_cart
-        Workarea::Paypal::Update
-          .any_instance
-          .expects(:apply)
-
-        get storefront.complete_paypal_path(order_id: order.id)
+        json = JSON.parse(response.body)
+        assert_equal('0987', json['id'])
+        refute(payment.reload.paypal.approved?)
       end
 
-      def test_complete_redirects_to_checkout_path
+      def test_create_failure
         add_item_to_cart
-        stub_paypal_update_apply
-        Workarea::Checkout
-          .any_instance
-          .stubs(:complete?)
-          .returns(true)
-        get storefront.complete_paypal_path(order_id: order.id)
-        assert_redirected_to(storefront.checkout_payment_path)
-      end
 
-      def test_complete_redirects_to_payment_as_purchasable
-        shipping_method = create_shipping_service
-        product = create_product(variants: [{ sku: 'SKU', regular: 49.to_m }])
+        Paypal::CreateOrder.any_instance.expects(:perform).raises(
+          Paypal::Gateway::RequestError.new('failed')
+        )
 
-        post storefront.cart_items_path, params: {
-          product_id: product.id,
-          sku: product.skus.first,
-          quantity: 2
-        }
+        post storefront.paypal_path, xhr: true
 
-        order = Workarea::Order.last
-
-        Workarea::Shipping.find_or_create_by(id: order.id)
-        Workarea::Payment.find_or_create_by(id: order.id)
-
-        checkout = Workarea::Checkout.new(order)
-        checkout.update(
-          shipping_address: {
-            first_name: 'Test',
-            last_name: 'User',
-            street: '1 Main St',
-            street_2: nil,
-            city: 'San Jose',
-            region: 'CA',
-            postal_code: '95131',
-            country: 'US'
-          },
-          billing_address: {
-            first_name: 'Test',
-            last_name: 'User',
-            street: '1 Main St',
-            street_2: nil,
-            city: 'San Jose',
-            region: 'CA',
-            postal_code: '95131',
-            country: 'US'
-          },
-          shipping_method_id: shipping_method.id,
-          payment: 'paypal'
-        )
+        assert_equal(500, response.status)
+        assert(flash[:error].present?)
+      end
 
-        gateway.expects(:details_for).returns(details)
+      def test_update_success
+        add_item_to_cart
 
-        get storefront.complete_paypal_path(order_id: order.id)
+        PaypalController.any_instance.expects(:check_inventory).returns(true)
+        Paypal::ApproveOrder.any_instance.expects(:perform).returns(true)
+        Workarea::Checkout.any_instance.expects(:complete?).returns(true)
 
-        assert_redirected_to(storefront.checkout_payment_path)
-      end
+        put storefront.paypal_approved_path('1234'), xhr: true
 
-      def test_complete_redirects_to_address_if_paypal_address_invalid
-        Workarea.with_config do |config|
-          config.allow_shipping_address_po_box = false
-
-          details.params['PaymentDetails']['ShipToAddress'] = {
-            'Name' => 'Test User',
-            'Street1' => 'PO Box 123',
-            'Street2' => nil,
-            'CityName' => 'San Jose',
-            'StateOrProvince' => 'CA',
-            'Country' => 'US',
-            'CountryName' => 'United States',
-            'Phone' => '610-867-5309',
-            'PostalCode' => '95131',
-            'AddressID' => nil,
-            'AddressOwner' => 'PayPal',
-            'ExternalAddressID' => nil,
-            'AddressStatus' => 'Confirmed'
-          }
-
-          gateway.expects(:details_for).returns(details)
-
-          product = create_product(variants: [{ sku: 'SKU', regular: 5 }])
-
-          post storefront.cart_items_path, params: {
-            product_id: product.id,
-            sku: product.skus.first,
-            quantity: 1
-          }
-
-          order = Order.first
-
-          get storefront.complete_paypal_path(order_id: order.id)
-          assert_redirected_to(storefront.checkout_addresses_path)
-        end
+        json = JSON.parse(response.body)
+        assert(json['success'])
+        assert_equal(storefront.checkout_payment_path, json['redirect_url'])
       end
 
-      private
+      def test_update_failure
+        add_item_to_cart
 
-      def order
-        @order ||= create_order
-      end
+        PaypalController.any_instance.expects(:check_inventory).returns(true)
+        Paypal::ApproveOrder.any_instance.expects(:perform).returns(true)
+        Workarea::Checkout.any_instance.expects(:complete?).returns(false)
+
+        put storefront.paypal_approved_path('1234'), xhr: true
+
+        json = JSON.parse(response.body)
+        refute(json['success'])
+        assert(flash[:error].present?)
+      end
+
+      def test_events
+        payment = create_payment(paypal: { paypal_id: '123', approved: true }).tap do |p|
+          p.paypal.build_transaction(
+            action: 'authorize',
+            amount: 5.to_m,
+            response: ActiveMerchant::Billing::Response.new(
+              true,
+              'PayPal capture succeeded',
+              id: 'CAPTURE001',
+              status: 'PENDING'
+            )
+          ).save!
+        end
 
-      def product
-        @product ||= create_product(
-          variants: [{ sku: 'SKU1', regular: 6.to_m, tax_code: '001' }]
-        )
-      end
+        post storefront.paypal_event_path,
+             params: webhook_capture_completed_payload
 
-      def details
-        @details ||= stub(
-          email: 'bcrouse@workarea.com',
-          token: 'EC-3LX76108SH791964A',
-          payer_id: 'MDJZZYJ9SZJ52',
-          params: {
-            'timestamp' => '2012-02-16T15:22:17Z',
-            'ack' => 'Success',
-            'correlation_id' => 'e5e29daee048a',
-            'version' => '62.0',
-            'build' => '2571254',
-            'token' => 'EC-3LX76108SH791964A',
-            'payer' => 'bcrouse@workarea.com',
-            'payer_id' => 'MDJZZYJ9SZJ52',
-            'payer_status' => 'verified',
-            'salutation' => nil,
-            'first_name' => 'Test',
-            'middle_name' => nil,
-            'last_name' => 'User',
-            'suffix' => nil,
-            'payer_country' => 'US',
-            'payer_business' => nil,
-            'name' => 'Test Product 866',
-            'street1' => '1 Main St',
-            'street2' => nil,
-            'city_name' => 'San Jose',
-            'state_or_province' => 'CA',
-            'country' => 'US',
-            'country_name' => 'United States',
-            'postal_code' => '95131',
-            'address_owner' => 'PayPal',
-            'address_status' => 'Confirmed',
-            'order_total' => '98.00',
-            'order_total_currency_id' => 'USD',
-            'item_total' => '98.00',
-            'item_total_currency_id' => 'USD',
-            'shipping_total' => '0.00',
-            'shipping_total_currency_id' => 'USD',
-            'handling_total' => '0.00',
-            'handling_total_currency_id' => 'USD',
-            'tax_total' => '0.00',
-            'tax_total_currency_id' => 'USD',
-            'phone' => nil,
-            'address_id' => nil,
-            'external_address_id' => nil,
-            'quantity' => '2',
-            'tax' => '0.00',
-            'tax_currency_id' => 'USD',
-            'amount' => '49.00',
-            'amount_currency_id' => 'USD',
-            'ebay_item_payment_details_item' => nil,
-            'insurance_total' => '0.00',
-            'insurance_total_currency_id' => 'USD',
-            'shipping_discount' => '0.00',
-            'shipping_discount_currency_id' => 'USD',
-            'insurance_option_offered' => 'false',
-            'seller_details' => nil,
-            'payment_request_id' => nil,
-            'order_url' => nil,
-            'soft_descriptor' => nil,
-            'checkout_status' => 'PaymentActionNotInitiated',
-            'Token' => 'EC-3LX76108SH791964A',
-            'PayerInfo' => {
-              'Payer' => 'bcrouse@workarea.com',
-              'PayerID' => 'MDJZZYJ9SZJ52',
-              'PayerStatus' => 'verified',
-              'PayerName' => {
-                'Salutation' => nil,
-                'FirstName' => 'Test',
-                'MiddleName' => nil,
-                'LastName' => 'User',
-                'Suffix' => nil
-              },
-              'PayerCountry' => 'US',
-              'PayerBusiness' => nil,
-              'Address' => {
-                'Name' => 'Test User',
-                'Street1' => '1 Main St',
-                'Street2' => nil,
-                'CityName' => 'San Jose',
-                'StateOrProvince' => 'CA',
-                'Country' => 'US',
-                'CountryName' => 'United States',
-                'PostalCode' => '95131',
-                'AddressOwner' => 'PayPal',
-                'AddressStatus' => 'Confirmed'
-              }
-            },
-            'PaymentDetails' => {
-              'OrderTotal' => '98.00',
-              'ItemTotal' => '98.00',
-              'ShippingTotal' => '0.00',
-              'HandlingTotal' => '0.00',
-              'TaxTotal' => '0.00',
-              'ShipToAddress' => {
-                'Name' => 'Test User',
-                'Street1' => '1 Main St',
-                'Street2' => nil,
-                'CityName' => 'San Jose',
-                'StateOrProvince' => 'CA',
-                'Country' => 'US',
-                'CountryName' => 'United States',
-                'PostalCode' => '95131',
-                'AddressID' => nil,
-                'AddressOwner' => 'PayPal',
-                'ExternalAddressID' => nil,
-                'AddressStatus' => 'Confirmed'
-              },
-              'PaymentDetailsItem' => {
-                'Name' => 'Test Product 866',
-                'Quantity' => '2',
-                'Tax' => '0.00',
-                'Amount' => '49.00',
-                'EbayItemPaymentDetailsItem' => nil
-              },
-              'InsuranceTotal' => '0.00',
-              'ShippingDiscount' => '0.00',
-              'InsuranceOptionOffered' => 'false',
-              'SellerDetails' => nil,
-              'PaymentRequestID' => nil,
-              'OrderURL' => nil,
-              'SoftDescriptor' => nil
-            },
-            'CheckoutStatus' => 'PaymentActionNotInitiated'
-          }
-        )
-      end
+        assert(response.ok?)
 
-      def add_item_to_cart
-        post storefront.cart_items_path, params: {
-          product_id: product.id,
-          sku: product.skus.first,
-          quantity: 2
-        }
-      end
+        payment.reload
 
-      def stub_paypal_setup_redirect_url
-        Workarea::Paypal::Setup
-          .any_instance
-          .stubs(:redirect_url)
-          .returns('http://paypal.com')
-      end
+        assert_equal(2, payment.paypal.transactions.count)
 
-      def stub_paypal_update_apply
-        Workarea::Paypal::Update
-          .any_instance
-          .stubs(:apply)
+        txn = payment.paypal.transactions.captures.first
+        assert(txn.success?)
+        assert_equal(5.to_m, txn.amount)
       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