workarea-afterpay 2.0.2

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

@@ -0,0 +1,242 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class AfterpayIntengrationTest < Workarea::IntegrationTest
+      setup do
+        create_tax_category(
+          name: 'Sales Tax',
+          code: '001',
+          rates: [{ percentage: 0.07, country: 'US', region: 'PA' }]
+        )
+
+        product = create_product(
+          variants: [{ sku: 'SKU1', regular: 6.to_m, tax_code: '001' }]
+        )
+
+        create_shipping_service(
+          carrier: 'UPS',
+          name: 'Ground',
+          service_code: '03',
+          tax_code: '001',
+          rates: [{ price: 7.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: 'bcrouse@workarea.com',
+            billing_address: {
+              first_name:   'Ben',
+              last_name:    'Crouse',
+              street:       '12 N. 3rd St.',
+              city:         'Philadelphia',
+              region:       'PA',
+              postal_code:  '19106',
+              country:      'US',
+              phone_number: '2159251800'
+            },
+            shipping_address: {
+              first_name:   'Ben',
+              last_name:    'Crouse',
+              street:       '22 S. 3rd St.',
+              city:         'Philadelphia',
+              region:       'PA',
+              postal_code:  '19106',
+              country:      'US',
+              phone_number: '2159251800'
+            }
+          }
+
+        patch storefront.checkout_shipping_path
+      end
+
+      def test_start_adds_a_token_to_payment
+        get storefront.start_afterpay_path
+
+        payment = Payment.find(order.id)
+        payment.reload
+
+        assert(payment.afterpay.present?)
+
+        order.reload
+
+        assert(order.afterpay_token.present?)
+      end
+
+      def test_start_clears_credit_card
+        payment = Payment.find(order.id)
+        payment.set_credit_card({
+          month: "01",
+          year: Time.now.year + 1,
+          number: 1,
+          cvv: "123"
+        })
+
+        payment.reload
+
+        get storefront.start_afterpay_path
+
+        payment.reload
+        order.reload
+
+        refute(payment.credit_card.present?)
+        assert(payment.afterpay.present?)
+        assert(order.afterpay_token.present?)
+      end
+
+      def test_cancel_removes_afterpay
+        payment = Payment.find(order.id)
+
+        payment.set_afterpay(token: '1234')
+
+        assert(payment.afterpay?)
+
+        get storefront.cancel_afterpay_path(token: '1234')
+        payment.reload
+
+        refute(payment.afterpay?)
+      end
+
+      def test_handling_afterpay_payment_error
+        payment = Payment.find(order.id)
+
+        payment.set_afterpay(token: '1234')
+
+        params = { token: '1234', status: 'ERROR' }
+        get storefront.complete_afterpay_path(params)
+
+        payment.reload
+        refute(payment.afterpay?)
+      end
+
+      def test_placing_order_from_afterpay
+        Workarea::Afterpay::BogusGateway.any_instance.stubs(:get_order).returns(get_order_response(order.total_price.to_s))
+
+        payment = Payment.find(order.id)
+
+        payment.set_afterpay(token: '1234')
+
+        params = { token: '1234', status: 'SUCCESS' }
+
+        get storefront.complete_afterpay_path(params)
+
+        payment.reload
+        order.reload
+
+        assert(order.placed?)
+
+        transactions = payment.tenders.first.transactions
+        assert_equal(1, transactions.size)
+        assert(transactions.first.success?)
+        assert_equal('purchase', transactions.first.action)
+      end
+
+
+      def test_placing_order_from_afterpay_with_invalid_order_total
+        Workarea::Afterpay::BogusGateway.any_instance.stubs(:get_order).returns(get_order_response("5.00"))
+
+        payment = Payment.find(order.id)
+
+        payment.set_afterpay(token: '1234')
+
+        params = { token: '1234', status: 'SUCCESS' }
+
+        get storefront.complete_afterpay_path(params)
+
+        payment.reload
+        order.reload
+
+        refute(order.placed?)
+      end
+
+      def test_placing_order_with_dual_payment
+        payment = Payment.find(order.id)
+        payment.profile = create_payment_profile(email: order.email)
+
+        payment.profile.update_attributes!(store_credit: 1.00)
+        payment.set_store_credit
+        payment.tenders.first.amount = 1.to_m
+        payment.save!
+
+        payment.set_afterpay(token: '1234')
+
+        params = { token: '1234', status: 'SUCCESS' }
+
+        ap_balance = order.total_price - 1.to_m
+        Workarea::Afterpay::BogusGateway.any_instance.stubs(:get_order).returns(get_order_response(ap_balance.to_s))
+
+        get storefront.complete_afterpay_path(params)
+
+        payment.reload
+        order.reload
+
+        assert(order.placed?)
+        transactions = payment.transactions
+        assert_equal(2, transactions.size)
+
+        ap_tender = payment.tenders.detect { |t| t.slug == :afterpay }
+        assert(ap_tender.transactions.first.success?)
+        assert_equal('purchase', ap_tender.transactions.first.action)
+
+        sc_tender = payment.tenders.detect { |t| t.slug == :store_credit }
+        assert(sc_tender.transactions.first.success?)
+
+        # Workarea v3.0.53, v3.1.40, v3.2.29, v3.3.21 and greater sets store credit to purchase by default.
+        assert_equal('purchase', sc_tender.transactions.first.action)
+      end
+
+      def test_failed_afterpay_capture
+        payment = Payment.find(order.id)
+
+        payment.set_afterpay(token: 'error_token')
+
+        params = { token: 'error_token', status: 'SUCCESS' }
+
+        get storefront.complete_afterpay_path(params)
+
+        payment.reload
+        order.reload
+
+        refute(order.placed?)
+      end
+
+      private
+
+      def order
+         @order ||= Order.first
+       end
+
+      def product
+        @product ||= create_product(
+          variants: [{ sku: 'SKU1', regular: 6.to_m, tax_code: '001' }]
+        )
+      end
+
+      def get_order_response(amount)
+        b = {
+              "totalAmount": {
+                "amount": "#{amount}",
+                "currency": "USD"
+            }
+          }
+          Workarea::Afterpay::Response.new(response(b))
+      end
+
+      def response(body, status = 200)
+        response = Faraday.new do |builder|
+          builder.adapter :test do |stub|
+            stub.get("/v1/bogus") { |env| [ status, {}, body.to_json ] }
+          end
+        end
+        response.get("/v1/bogus")
+      end
+    end
+  end
+end

data/test/models/workarea/afterpay_order_test.rb

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+module Workarea
+  class AfterpayOrderTest < Workarea::TestCase
+    def test_afterpay_location
+      order = create_order
+      assert_equal(:us, order.afterpay_location)
+    end
+  end
+end

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

@@ -0,0 +1,67 @@
+require 'test_helper'
+
+module Workarea
+  class AfterpayPaymentIntegrationTest < Workarea::TestCase
+
+    def test_capture
+      tender.amount = 5.to_m
+      transaction = tender.build_transaction(action: 'capture')
+      transaction.save!
+
+      operation = Payment::Capture::Afterpay.new(tender, transaction)
+      operation.complete!
+
+      assert(transaction.success?, 'expected transaction to be successful')
+    end
+
+    def test_auth
+      transaction = tender.build_transaction(action: 'authorize')
+      Payment::Authorize::Afterpay.new(tender, transaction).complete!
+      assert(transaction.success?, 'expected transaction to be successful')
+    end
+
+    def test_purchase
+      transaction = tender.build_transaction(action: 'purchase')
+      Payment::Purchase::Afterpay.new(tender, transaction).complete!
+      assert(transaction.success?)
+    end
+
+    private
+
+      def gateway
+        Workarea.Afterpay.gateay
+      end
+
+      def payment
+        @payment ||=
+          begin
+            profile = create_payment_profile
+            create_payment(
+              profile_id: profile.id,
+              address: {
+                first_name: 'Ben',
+                last_name: 'Crouse',
+                street: '22 s. 3rd st.',
+                city: 'Philadelphia',
+                region: 'PA',
+                postal_code: '19106',
+                country: Country['US']
+              }
+            )
+          end
+      end
+
+      def tender
+        @tender ||=
+          begin
+            payment.set_address(first_name: 'Ben', last_name: 'Crouse')
+
+            payment.build_afterpay(
+              token: '12345'
+            )
+
+            payment.afterpay
+          end
+      end
+  end
+end

data/test/services/workarea/afterpay/order_builder_test.rb

@@ -0,0 +1,88 @@
+require 'test_helper'
+
+module Workarea
+  module Afterpay
+    class OrderBuilderTest < Workarea::TestCase
+
+      def test_build
+        create_order_total_discount
+        order = create_order
+
+        # apply store credit
+        payment = Workarea::Payment.find(order.id)
+        payment.profile.update_attributes!(store_credit: 1.00)
+        payment.set_store_credit
+        payment.tenders.first.amount = 1.to_m
+        payment.save
+
+        order.reload
+        payment.reload
+        order_hash = Workarea::Afterpay::OrderBuilder.new(order).build
+
+        assert_equal(9.00, order_hash[:totalAmount][:amount].to_f)
+        assert_equal(1.00, order_hash[:shippingAmount][:amount].to_f)
+        assert_equal(0.00, order_hash[:taxAmount][:amount].to_f)
+        assert_equal(order.id, order_hash[:merchantReference])
+
+        assert_equal("bcrouse-new@workarea.com", order_hash[:consumer][:email])
+        assert_equal("Ben", order_hash[:consumer][:givenNames])
+        assert_equal("Crouse", order_hash[:consumer][:surname])
+
+        assert_equal(1, order_hash[:discounts].size)
+        assert_equal("Order Total Discount", order_hash[:discounts].first[:displayName])
+
+        assert_equal("Philadelphia", order_hash[:shipping][:suburb])
+        assert_equal("Wilmington", order_hash[:billing][:suburb])
+
+        assert_equal(1, order_hash[:items].size)
+        assert_equal("SKU", order_hash[:items].first[:sku])
+        assert_equal(2, order_hash[:items].first[:quantity])
+        assert_equal(5, order_hash[:items].first[:price][:amount].to_f)
+      end
+
+      private
+
+      def create_order(overrides = {})
+        attributes = {
+          id: '1234',
+          email: 'bcrouse-new@workarea.com',
+          placed_at: Time.current
+        }.merge(overrides)
+
+        shipping_service = create_shipping_service
+        product = create_product(variants: [{ sku: 'SKU', regular: 5.to_m }])
+
+        order = Workarea::Order.new(attributes)
+        order.add_item(product_id: product.id, sku: 'SKU', quantity: 2)
+
+        checkout = Checkout.new(order)
+        checkout.update(
+          shipping_address: {
+            first_name: 'Ben',
+            last_name: 'Crouse',
+            street: '22 S. 3rd St.',
+            street_2: 'Second Floor',
+            city: 'Philadelphia',
+            region: 'PA',
+            postal_code: '19106',
+            country: 'US'
+          },
+          billing_address: {
+            first_name: 'Bob',
+            last_name: 'Clams',
+            street: '12 N. 3rd St.',
+            street_2: 'Second Floor',
+            city: 'Wilmington',
+            region: 'DE',
+            postal_code: '18083',
+            country: 'US'
+          },
+          shipping_service: shipping_service.name,
+        )
+
+
+        order
+      end
+    end
+  end
+end

data/test/system/workarea/storefront/afterpay_product_test.rb

@@ -0,0 +1,51 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class AfterpayProductText < Workarea::SystemTest
+      include Storefront::SystemTest
+
+      def test_showing_a_products_afterpay_price
+        @product = create_product(
+          name: 'Integration Product',
+          variants: [{ sku: 'SKU1', regular: 100.to_m }]
+        )
+
+        visit storefront.product_path(@product)
+        assert(page.has_content?(t('workarea.storefront.products.afterpay', installment_price: '$25.00', installment_count: Workarea.config.afterpay[:installment_count])))
+      end
+
+      def test_eneligble_product_total
+        @product = create_product(
+          name: 'Integration Product',
+          variants: [{ sku: 'SKU1', regular: 1.to_m }]
+        )
+
+        visit storefront.product_path(@product)
+        refute(page.has_content?(t('workarea.storefront.products.afterpay', installment_price: '$0.25', installment_count: Workarea.config.afterpay[:installment_count])))
+      end
+
+      def test_global_display_settings
+        Workarea::Afterpay::Configuration.create(enabled: false)
+        @product = create_product(
+          name: 'Integration Product',
+          variants: [{ sku: 'SKU1', regular: 100.to_m }]
+        )
+
+        visit storefront.product_path(@product)
+        refute(page.has_content?(t('workarea.storefront.products.afterpay', installment_price: '$25.00', installment_count: Workarea.config.afterpay[:installment_count])))
+      end
+
+      def test_pdp_display_settings
+        Workarea::Afterpay::Configuration.create(display_on_pdp: false)
+        @product = create_product(
+          name: 'Integration Product',
+          variants: [{ sku: 'SKU1', regular: 100.to_m }]
+        )
+
+        visit storefront.product_path(@product)
+        refute(page.has_content?(t('workarea.storefront.products.afterpay', installment_price: '$25.00', installment_count: Workarea.config.afterpay[:installment_count])))
+      end
+    end
+  end
+end

data/test/system/workarea/storefront/cart_system_test.decorator

@@ -0,0 +1,83 @@
+require 'test_helper'
+
+module Workarea
+  decorate Storefront::CartSystemTest, with: :afterpay do
+    def test_afterpay_content
+      visit storefront.product_path(@product)
+      select @product.skus.first, from: 'sku'
+      click_button t('workarea.storefront.products.add_to_cart')
+      click_link t('workarea.storefront.carts.view_cart')
+
+      assert(page.has_content?(t('workarea.storefront.carts.afterpay', installment_price: '$1.25', installment_count: Workarea.config.afterpay[:installment_count])))
+    end
+
+    def test_afterpay_price_ineligibility
+      product = create_product(
+          name: 'Integration Product 2',
+          variants: [
+            { name: 'SKU3', sku: 'SKU3', regular: 1.to_m },
+            { name: 'SKU4', sku: 'SKU4', regular: 2.to_m }
+          ]
+        )
+
+      visit storefront.product_path(product)
+      select product.skus.first, from: 'sku'
+      click_button t('workarea.storefront.products.add_to_cart')
+      click_link t('workarea.storefront.carts.view_cart')
+
+      assert(page.has_content?(t('workarea.storefront.afterpay.ineligible_order_total', min: '$5.00', max: '$500.00')))
+    end
+
+    def test_afterpay_country_ineligibility
+      Workarea.with_config do |config|
+        config.afterpay.api_timeout = 5
+        config.afterpay.open_timeout = 2
+        config.afterpay.currency_country_map = {
+            "GBP": "GB"
+        }
+
+        config.afterpay.test = true
+        config.afterpay.enabled = {
+          au: true,
+          us: true
+        }
+
+        product = create_product(
+            name: 'Integration Product 2',
+            variants: [
+              { name: 'SKU3', sku: 'SKU3', regular: 1.to_m },
+              { name: 'SKU4', sku: 'SKU4', regular: 2.to_m }
+            ]
+          )
+
+        visit storefront.product_path(product)
+        select product.skus.first, from: 'sku'
+        click_button t('workarea.storefront.products.add_to_cart')
+        click_link t('workarea.storefront.carts.view_cart')
+
+        refute(page.has_content?(t('workarea.storefront.afterpay.ineligible_order_total', min: '$5.00', max: '$500.00')))
+      end
+    end
+
+    def test_global_display_settings
+      Workarea::Afterpay::Configuration.create(enabled: false)
+      visit storefront.product_path(@product)
+      select @product.skus.first, from: 'sku'
+      click_button t('workarea.storefront.products.add_to_cart')
+      click_link t('workarea.storefront.carts.view_cart')
+
+      refute(page.has_content?(t('workarea.storefront.carts.afterpay', installment_price: '$1.25', installment_count: Workarea.config.afterpay[:installment_count])))
+    end
+
+    def test_cart_display_settings
+      Workarea::Afterpay::Configuration.create(display_on_cart: false)
+      visit storefront.product_path(@product)
+      select @product.skus.first, from: 'sku'
+      click_button t('workarea.storefront.products.add_to_cart')
+      click_link t('workarea.storefront.carts.view_cart')
+
+      refute(page.has_content?(t('workarea.storefront.carts.afterpay', installment_price: '$1.25', installment_count: Workarea.config.afterpay[:installment_count])))
+    end
+  end
+end
+

data/test/system/workarea/storefront/logged_in_checkout_system_test.decorator

@@ -0,0 +1,10 @@
+require 'test_helper'
+
+module Workarea
+  decorate Storefront::LoggedInCheckoutSystemTest, with: :afterpay do
+    def test_afterpay_option_in_checkout
+      assert(page.has_content?(t('workarea.storefront.afterpay.on_continue')))
+      assert(page.has_content?(t('workarea.storefront.checkouts.afterpay', installment_price: '$3.21', installment_count: Workarea.config.afterpay[:installment_count])))
+    end
+  end
+end

data/test/teaspoon_env.rb

@@ -0,0 +1,6 @@
+require 'workarea/testing/teaspoon'
+
+Teaspoon.configure do |config|
+  config.root = Workarea::Afterpay::Engine.root
+  Workarea::Teaspoon.apply(config)
+end

data/test/test_helper.rb

@@ -0,0 +1,10 @@
+# Configure Rails Environment
+ENV['RAILS_ENV'] = 'test'
+
+require File.expand_path("../../test/dummy/config/environment.rb", __FILE__)
+require 'rails/test_help'
+require 'workarea/test_help'
+
+# Filter out Minitest backtrace while allowing backtrace from other libraries
+# to be shown.
+Minitest.backtrace_filter = Minitest::BacktraceFilter.new

data/test/view_models/workarea/storefront/afterpay_view_model_test.rb

@@ -0,0 +1,100 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class AfterpayViewModelTest < TestCase
+      setup :set_checkout
+
+      def set_checkout
+        @order = Order.new(email: 'bcrouse@workarea.com')
+        @user = User.new(email: 'bcrouse@workarea.com')
+      end
+
+      def test_order_total_in_range
+        @order.total_price = 25.00
+
+        checkout = Workarea::Checkout.new(@order, @user)
+        view_model = Workarea::Storefront::AfterpayViewModel.new(checkout, { afterpay_configuration: afterpay_options, order: @order })
+
+        assert(view_model.order_total_in_range?)
+
+        @order.total_price = 15.00
+        view_model = Workarea::Storefront::AfterpayViewModel.new(checkout, { afterpay_configuration: afterpay_options, order: @order })
+        refute(view_model.order_total_in_range?)
+      end
+
+      def test_show?
+        settings = Workarea::Afterpay::Configuration.create!
+
+        @order.total_price = 25.00
+        view_model = Workarea::Storefront::AfterpayViewModel.new(nil, { afterpay_configuration: afterpay_options, order: @order })
+        assert(view_model.show?)
+
+        settings.enabled = false
+        settings.save!
+        view_model = Workarea::Storefront::AfterpayViewModel.new(nil, { afterpay_configuration: afterpay_options, order: @order })
+        refute(view_model.show?)
+
+        @order.total_price = 25.00.to_m("EUR")
+        view_model = Workarea::Storefront::AfterpayViewModel.new(nil, { afterpay_configuration: afterpay_options, order: @order })
+        refute(view_model.show?)
+
+        Workarea::Order.any_instance.stubs(:currency).returns("EUR")
+        @order.total_price = 25.00
+        view_model = Workarea::Storefront::AfterpayViewModel.new(nil, { afterpay_configuration: afterpay_options, order: @order })
+        refute(view_model.show?)
+      end
+
+      def test_afterpay_country
+        checkout = Workarea::Checkout.new(@order, @user)
+
+        @order.total_price = 25.00
+        view_model = Workarea::Storefront::AfterpayViewModel.new(checkout, { afterpay_configuration: afterpay_options, order: @order })
+        assert_equal('US', view_model.afterpay_country)
+
+        @order.total_price = 25.00.to_m('AUD')
+        view_model = Workarea::Storefront::AfterpayViewModel.new(checkout, { afterpay_configuration: afterpay_options, order: @order })
+        assert_equal('AU', view_model.afterpay_country)
+
+        @order.total_price = 25.00.to_m('EUR')
+        view_model = Workarea::Storefront::AfterpayViewModel.new(checkout, { afterpay_configuration: afterpay_options, order: @order })
+        refute(view_model.afterpay_country.present?)
+      end
+
+      def test_display_options
+        @order.total_price = 25.00
+
+        checkout = Workarea::Checkout.new(@order, @user)
+        view_model = Workarea::Storefront::AfterpayViewModel.new(checkout, { afterpay_configuration: afterpay_options, order: @order })
+
+        assert_equal("PAY_BY_INSTALLMENT", view_model.display_option[:type])
+        assert_equal("Pay over time", view_model.display_option[:description])
+      end
+
+      def test_installment_price
+        @order.total_price = 100.00
+        view_model = Workarea::Storefront::AfterpayViewModel.new(nil, { afterpay_configuration: afterpay_options, order: @order })
+
+        assert_equal(25.00, view_model.installment_price.amount)
+      end
+
+      private
+        def afterpay_options
+          [
+            {
+              "type": "PAY_BY_INSTALLMENT",
+              "description": "Pay over time",
+              "minimumAmount": {
+                   "amount": "20.00",
+                   "currency": "USD"
+               },
+              "maximumAmount": {
+                  "amount": "30.00",
+                  "currency": "USD"
+              }
+            }
+          ]
+        end
+    end
+  end
+end