workarea-paypal 2.0.12 → 3.0.0

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

data/test/models/workarea/payment/null_address_test.rb

@@ -0,0 +1,53 @@
+require 'test_helper'
+
+module Workarea
+  class Payment
+    class NullAddressTest < TestCase
+      def test_responding_as_address
+        address = NullAddress.new
+
+        assert(address.save)
+
+        address.street = '123 Street Rd.'
+        assert_nil(address.street)
+        assert(address.valid?)
+        assert_equal('123 Street Rd.', address.reference.street)
+
+        address.country = 'US'
+        assert_nil(address.country.alpha2)
+        assert_equal('US', address.reference.country.alpha2)
+
+        assert(address.save!)
+
+        assert(
+          address.update!(
+            first_name: 'Robert',
+            last_name: 'Clams',
+            street: '22 South 3rd St.',
+            city: 'Philadelphia',
+            region: 'PA',
+            postal_code: '19106'
+          )
+        )
+
+        refute(address.persisted?)
+        assert_nil(address.first_name)
+        assert_nil(address.last_name)
+        assert_nil(address.street)
+        assert_nil(address.city)
+        assert_nil(address.region)
+        assert_nil(address.postal_code)
+        assert(address.valid?)
+
+        refute(address.reference.persisted?)
+        assert_equal('Robert', address.reference.first_name)
+        assert_equal('Clams', address.reference.last_name)
+        assert_equal('22 South 3rd St.', address.reference.street)
+        assert_equal('Philadelphia', address.reference.city)
+        assert_equal('PA', address.reference.region)
+        assert_equal('19106', address.reference.postal_code)
+        assert(address.reference.valid?)
+      end
+    end
+  end
+end

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

@@ -4,64 +4,65 @@ module Workarea
   class Payment
     class Refund
       class PaypalTest < Workarea::TestCase
-        delegate :gateway, to: Workarea::Paypal
-
-        def authorization
-          @authorization ||= ActiveMerchant::Billing::BogusGateway::AUTHORIZATION
+        def payment
+          @payment ||= create_payment
         end
 
-        def payment
-          @payment ||=
+        def tender
+          @tender ||=
             begin
-              result = create_payment
-              result.set_paypal(token: '1234', payer_id: 'pid')
-              result
+              payment.build_paypal(paypal_id: '1234', payer_id: 'pid')
+              payment.paypal
             end
         end
 
-        def reference
-          @reference ||= Transaction.new(
+        def transaction
+          @transaction ||= tender.transactions.build(
+            action: 'authorize',
             amount: 5.to_m,
-            response: ActiveMerchant::Billing::Response.new(
-              true,
-              'Message',
-              'transaction_id' => authorization
+            reference: tender.build_transaction(
+              action: 'purchase',
+              amount: 5.to_m,
+              response: ActiveMerchant::Billing::Response.new(
+                true,
+                'PayPal capture succeeded',
+                id: 'CAPTURE_0001'
+              )
             )
           )
         end
 
-        def transaction
-          @transaction ||= payment.paypal.transactions.build(
-            amount: 5.to_m,
-            reference: reference
+        def stubbed_refund
+          @stubbed_refund ||= OpenStruct.new(
+            status_code: 201,
+            result: OpenStruct.new(
+              id: 'REFUND_0001',
+              status: 'COMPLETED',
+            )
           )
         end
 
-        def test_complete_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_refunds_on_the_credit_card_gateway
-          operation = Paypal.new(payment.paypal, transaction)
-
-          gateway
-            .expects(:refund)
-            .with(500, authorization, currency: 'USD')
+        def test_complete_success
+          PayPal::PayPalHttpClient.any_instance.expects(:execute).returns(stubbed_refund)
 
+          operation = Paypal.new(tender, transaction)
           operation.complete!
+
+          assert(transaction.response.success?)
+          assert(transaction.response.message.present?)
+          assert_equal('CAPTURE_0001', transaction.response.params['capture_id'])
         end
 
-        def test_complete_sets_the_response_on_the_transaction
-          operation = Paypal.new(payment.paypal, transaction)
+        def test_complete_failure
+          stubbed_refund.status_code = 500
+          PayPal::PayPalHttpClient.any_instance.expects(:execute).returns(stubbed_refund)
+
+          operation = Paypal.new(tender, transaction)
           operation.complete!
 
-          assert_instance_of(
-            ActiveMerchant::Billing::Response,
-            transaction.response
-          )
+          refute(transaction.response.success?)
+          assert(transaction.response.message.present?)
+          assert(transaction.response.params.present?)
         end
       end
     end

data/test/models/workarea/paypal_payment_test.rb

@@ -0,0 +1,65 @@
+require 'test_helper'
+
+module Workarea
+  class PaypalPaymentTest < TestCase
+    def payment
+      @payment ||= Payment.create!
+    end
+
+    def test_paypal?
+      refute(payment.paypal?)
+
+      payment.build_paypal
+      refute(payment.paypal?)
+
+      payment.paypal.approved = true
+      assert(payment.paypal?)
+    end
+
+    def test_set_paypal_creates_paypal_tender
+      payment.set_paypal(
+        paypal_id: '12345',
+        payer_id: 'payer_id',
+        details: { 'foo' => 'bar' }
+      )
+
+      assert_equal('12345', payment.paypal.paypal_id)
+      assert_equal('payer_id', payment.paypal.payer_id)
+      assert_equal({ 'foo' => 'bar' }, payment.paypal.details)
+    end
+
+    def test_set_credit_card_removes_paypal_tender
+      payment.set_paypal(
+        paypal_id: '12345',
+        payer_id: 'payer_id',
+        details: { 'foo' => 'bar' }
+      )
+
+      payment.set_credit_card({})
+      assert(payment.paypal.blank?)
+    end
+
+    def test_address
+      refute(payment.address.present?)
+
+      payment.build_paypal(approved: true)
+      assert(payment.address.present?)
+
+      assert(payment.address.valid?)
+      assert(payment.address.street.blank?)
+
+      payment.set_address(factory_defaults(:billing_address))
+      assert(payment.address.valid?)
+      assert(payment.address.street.present?)
+
+      payment.paypal = nil
+      assert(payment.address.valid?)
+
+      payment.address = nil
+      refute(payment.address.present?)
+
+      payment.build_address
+      refute(payment.address.valid?)
+    end
+  end
+end

data/test/models/workarea/search/paypal_order_text_test.rb

@@ -0,0 +1,14 @@
+require 'test_helper'
+
+module Workarea
+  module Search
+    class PaypalOrderTextTest < TestCase
+      def test_payment_text
+        order = create_order
+        payment = Workarea::Payment.create!(id: order.id, paypal: { approved: true })
+
+        assert_equal('PayPal', Search::OrderText.new(order).payment_text)
+      end
+    end
+  end
+end

data/test/services/workarea/paypal/approve_order_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+module Workarea
+  module Paypal
+    class ApproveOrderTest < TestCase
+      include PaypalSetup
+
+      setup :checkout
+
+      def test_perform
+        order_id = VCR.use_cassette('paypal_create_order') do
+          CreateOrder.new(checkout).perform.id
+        end
+
+        checkout.start_as(:guest)
+
+        VCR.use_cassette('paypal_approve_order') do
+          ApproveOrder.new(checkout, order_id).perform
+        end
+
+        assert(checkout.complete?)
+        assert(checkout.order.email.present?)
+        assert(checkout.shipping.shipping_service.valid?)
+        assert(checkout.shipping.address.valid?)
+        assert(checkout.payment.address.valid?)
+        assert(checkout.payment.paypal?)
+        assert(checkout.payment.paypal.paypal_id.present?)
+        assert(checkout.payment.paypal.payer_id.present?)
+        assert(checkout.payment.paypal.details.present?)
+        assert(checkout.payment.paypal.approved?)
+        assert_equal(checkout.order.total_price, checkout.payment.paypal.amount)
+      end
+    end
+  end
+end

data/test/services/workarea/paypal/create_order_test.rb

@@ -0,0 +1,127 @@
+require 'test_helper'
+
+module Workarea
+  module Paypal
+    class CreateOrderTest < TestCase
+      include PaypalSetup
+
+      setup :checkout
+
+      def test_perform
+        result = VCR.use_cassette('paypal_create_order') do
+          CreateOrder.new(checkout).perform
+        end
+
+        assert(result.id.present?)
+      end
+
+      def test_request_body
+        body = CreateOrder.new(checkout).request_body
+
+        context = body[:application_context]
+        assert_equal(Workarea.config.site_name, context[:brand_name])
+        assert_equal('SET_PROVIDED_ADDRESS', context[:shipping_preference])
+
+        payer = body[:payer]
+        assert(payer[:email_address].present?)
+        assert(payer[:name].present?)
+        assert(payer[:address].present?)
+
+        purchase_unit = body[:purchase_units].first
+        assert_equal(checkout.order.id, purchase_unit[:custom_id])
+        assert(purchase_unit[:amount].present?)
+        assert(purchase_unit[:items].present?)
+        assert(purchase_unit[:shipping].present?)
+      end
+
+      def test_payer
+        payer = CreateOrder.new(checkout).payer
+
+        assert_equal(checkout.order.email, payer[:email_address])
+        assert_equal(checkout.payment.address.first_name, payer[:name][:given_name])
+        assert_equal(checkout.payment.address.last_name, payer[:name][:surname])
+        assert_equal(checkout.payment.address.street, payer[:address][:address_line_1])
+        assert_equal(checkout.payment.address.street_2, payer[:address][:address_line_2])
+        assert_equal(checkout.payment.address.city, payer[:address][:admin_area_2])
+        assert_equal(checkout.payment.address.region, payer[:address][:admin_area_1])
+        assert_equal(checkout.payment.address.postal_code, payer[:address][:postal_code])
+        assert_equal(checkout.payment.address.country.alpha2, payer[:address][:country_code])
+
+        checkout.order.email = nil
+        payer = CreateOrder.new(checkout).payer
+        refute(payer.present?)
+
+        checkout.order.email = 'test@workarea.com'
+        checkout.payment.address = nil
+        payer = CreateOrder.new(checkout).payer
+
+        assert_equal(checkout.order.email, payer[:email_address])
+        assert_nil(payer[:name])
+        assert_nil(payer[:address])
+      end
+
+      def test_amount
+        amount = CreateOrder.new(checkout).amount
+
+        assert_equal('11.60', amount[:value])
+
+        breakdown = amount[:breakdown]
+        assert_equal('10.00', breakdown[:item_total][:value])
+        assert_equal('1.00', breakdown[:shipping][:value])
+        assert_equal('0.60', breakdown[:tax_total][:value])
+        assert_equal('0.00', breakdown[:discount][:value])
+
+        checkout.payment.build_store_credit(amount: 5.to_m)
+        amount = CreateOrder.new(checkout).amount
+
+        assert_equal('6.60', amount[:value])
+
+        breakdown = amount[:breakdown]
+        assert_equal('10.00', breakdown[:item_total][:value])
+        assert_equal('1.00', breakdown[:shipping][:value])
+        assert_equal('0.60', breakdown[:tax_total][:value])
+        assert_equal('5.00', breakdown[:discount][:value])
+      end
+
+      def test_items
+        item = CreateOrder.new(checkout).items.first
+        order_item = checkout.order.items.first
+
+        assert_equal(order_item.sku, item[:sku])
+        assert_equal('5.00', item[:unit_amount][:value])
+        assert_equal(2, item[:quantity])
+        assert_equal('PHYSICAL_GOODS', item[:category])
+
+        order_item.fulfillment = 'download'
+
+        item = CreateOrder.new(checkout).items.first
+        assert_equal('DIGITAL_GOODS', item[:category])
+      end
+
+      def test_shipping_info
+        shipping = CreateOrder.new(checkout).shipping_info
+
+        assert_equal('Ground', shipping[:method])
+        assert_equal('Ben Crouse', shipping[:name][:full_name])
+        assert_equal(checkout.shipping.address.street, shipping[:address][:address_line_1])
+        assert_equal(checkout.shipping.address.street_2, shipping[:address][:address_line_2])
+        assert_equal(checkout.shipping.address.city, shipping[:address][:admin_area_2])
+        assert_equal(checkout.shipping.address.region, shipping[:address][:admin_area_1])
+        assert_equal(checkout.shipping.address.postal_code, shipping[:address][:postal_code])
+        assert_equal(checkout.shipping.address.country.alpha2, shipping[:address][:country_code])
+
+        checkout.order.items.first.fulfillment = 'download'
+        assert(CreateOrder.new(checkout).shipping_info.blank?)
+
+        checkout.order.items.first.fulfillment = 'shipping'
+        checkout.shipping.address = nil
+        assert(CreateOrder.new(checkout).shipping_info.blank?)
+
+        create_shipping(order_id: checkout.order.id)
+        new_checkout = Checkout.new(checkout.order)
+        assert_equal(2, new_checkout.shippings.size)
+        assert(CreateOrder.new(new_checkout).shipping_info.blank?)
+      end
+    end
+  end
+end