workarea-zipco 1.0.0

data/test/dummy/config/routes.rb

@@ -0,0 +1,5 @@
+Rails.application.routes.draw do
+  mount Workarea::Core::Engine => '/'
+  mount Workarea::Admin::Engine => '/admin', as: 'admin'
+  mount Workarea::Storefront::Engine => '/', as: 'storefront'
+end

data/test/dummy/config/spring.rb

@@ -0,0 +1,6 @@
+%w[
+  .ruby-version
+  .rbenv-vars
+  tmp/restart.txt
+  tmp/caching-dev.txt
+].each { |path| Spring.watch(path) }

data/test/dummy/db/seeds.rb

@@ -0,0 +1,2 @@
+require 'workarea/seeds'
+Workarea::Seeds.run

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

@@ -0,0 +1,250 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class ZipcoIntengrationTest < Workarea::IntegrationTest
+      setup :set_order_data
+
+      def set_order_data
+        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_zipco_path
+
+        payment = Payment.find(order.id)
+        payment.reload
+
+        assert(payment.zipco.present?)
+
+        order.reload
+
+        assert(order.zipco_order_id.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_zipco_path
+
+        payment.reload
+        order.reload
+
+        refute(payment.credit_card.present?)
+        assert(payment.zipco.present?)
+        assert(order.zipco_order_id.present?)
+      end
+
+      def test_cancel_removes_zipco
+        payment = Payment.find(order.id)
+
+        order.update_attributes(zipco_order_id: '1234')
+
+        payment.set_zipco(token: '1234')
+
+        assert(payment.zipco?)
+
+        get storefront.complete_zipco_path(checkoutId: '1234', result: "cancelled")
+        payment.reload
+        order.reload
+
+        refute(payment.zipco?)
+        refute(order.zipco_order_id.present?)
+      end
+
+      def test_decline_removes_zipco
+        payment = Payment.find(order.id)
+
+        order.update_attributes(zipco_order_id: '1234')
+
+        payment.set_zipco(token: '1234')
+
+        assert(payment.zipco?)
+
+        get storefront.complete_zipco_path(checkoutId: '1234', result: "declined")
+        payment.reload
+        order.reload
+
+        refute(payment.zipco?)
+        refute(order.zipco_order_id.present?)
+      end
+
+      def test_placing_order_from_zipco
+        payment = Payment.find(order.id)
+
+        get storefront.start_zipco_path
+
+        params = { checkoutId: 'co_P9GOgSVE9qMnL0VA6Jy8z6', result: 'approved' }
+
+        get storefront.complete_zipco_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('authorize', transactions.first.action)
+      end
+
+      def test_referred_then_approved_order_from_zipco
+        payment = Payment.find(order.id)
+
+        get storefront.start_zipco_path
+
+        params = { checkoutId: 'co_P9GOgSVE9qMnL0VA6Jy8z6', result: 'referred' }
+
+        get storefront.complete_zipco_path(params)
+
+        payment.reload
+        order.reload
+
+        assert(order.zipco_order_id.present?)
+        assert(:zipco_referred, order.status)
+        refute(order.placed?)
+
+        transactions = payment.tenders.first.transactions
+        assert_equal(0, transactions.size)
+        assert(order.zipco_referred?)
+        assert_equal(:pending, payment.status)
+
+        assert_redirected_to(storefront.checkout_confirmation_path)
+
+        params = { checkoutId: 'co_P9GOgSVE9qMnL0VA6Jy8z6', result: 'approved' }
+
+        get storefront.complete_zipco_path(params)
+
+        payment.reload
+        order.reload
+        transactions = payment.tenders.first.transactions
+
+        assert_equal(1, transactions.size)
+        assert(order.zipco_order_id.present?)
+        assert(order.placed?)
+        assert(:authorized, payment.status)
+        refute(order.zipco_referred?)
+        assert_redirected_to(storefront.checkout_confirmation_path)
+      end
+
+      def test_referred_then_cancelled_order_from_zipco
+        payment = Payment.find(order.id)
+
+        get storefront.start_zipco_path
+
+        params = { checkoutId: 'co_P9GOgSVE9qMnL0VA6Jy8z6', result: 'referred' }
+
+        get storefront.complete_zipco_path(params)
+
+        order.reload
+        payment.reload
+
+        assert(order.zipco_order_id.present?)
+        refute(order.placed?)
+
+        assert(order.zipco_referred?)
+        assert_equal(:pending, payment.status)
+
+        params = { checkoutId: 'co_P9GOgSVE9qMnL0VA6Jy8z6', result: 'declined' }
+
+        get storefront.complete_zipco_path(params)
+
+        payment.reload
+        order.reload
+
+        assert_equal(:canceled, order.status)
+
+        transactions = payment.tenders.first.transactions
+        assert(:pending, payment.status)
+        assert_equal(0, transactions.size)
+        assert_redirected_to(storefront.cart_path)
+      end
+
+      def test_failed_zipco_capture
+        payment = Payment.find(order.id)
+
+        payment.set_zipco(token: 'error_token')
+
+        params = { token: 'error_token', status: 'SUCCESS' }
+
+        get storefront.complete_zipco_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
+    end
+  end
+end

data/test/models/workarea/order/zipco_queries_test.rb

@@ -0,0 +1,35 @@
+require 'test_helper'
+
+module Workarea
+  module Zipco
+    class ZipcoQueriesTest < Workarea::TestCase
+      attr_reader :email, :user
+
+      setup :setup_user
+
+      def setup_user
+        @email = 'bcrouse@workarea.com'
+        @user = create_user(email: email)
+      end
+
+      def test_referred_orders_do_not_need_reminding
+        referred_order = Workarea::Order.create!(email: email, checkout_started_at: 2.hours.ago, items: [{ product_id: '1', sku: 2 }], zipco_referred_at: Time.now)
+        results = Workarea::Order.need_reminding.to_a
+
+        refute_includes(results, referred_order)
+      end
+
+      def test_find_current_by_id_excludes_orders_under_review
+        order = create_order(zipco_referred_at: Time.now)
+
+        result = Workarea::Order.find_current(id: order.id)
+        refute result.persisted?
+      end
+
+      def test_find_current_by_user_id_excludes_orders_under_review
+        result = Workarea::Order.find_current(user_id: 'foo')
+        refute result.persisted?
+      end
+    end
+  end
+end

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

@@ -0,0 +1,89 @@
+require 'test_helper'
+
+module Workarea
+  class ZipcoPaymentIntegrationTest < Workarea::TestCase
+    def test_auth_capture
+      transaction = tender.build_transaction(action: 'authorize')
+      Payment::Purchase::Zipco.new(tender, transaction).complete!
+
+      assert(transaction.success?)
+      transaction.save!
+
+      assert(tender.token.present?)
+
+      capture = Payment::Capture.new(payment: payment)
+      capture.allocate_amounts!(total: 5.to_m)
+      assert(capture.valid?)
+      capture.complete!
+
+      capture_transaction = payment.transactions.detect(&:captures)
+      assert(capture_transaction.valid?)
+    end
+
+    def test_auth
+      transaction = tender.build_transaction(action: 'authorize')
+      Payment::Authorize::Zipco.new(tender, transaction).complete!
+      assert(transaction.success?, 'expected transaction to be successful')
+    end
+
+    def test_purchase
+      transaction = tender.build_transaction(action: 'purchase')
+      Payment::Purchase::Zipco.new(tender, transaction).complete!
+      assert(transaction.success?)
+    end
+
+    def test_timeout_auth
+      transaction = timeout_tender.build_transaction(action: 'authorize')
+      operation = Payment::Authorize::Zipco.new(timeout_tender, transaction)
+      operation.complete!
+      refute(transaction.success?, 'expected transaction to be a failure')
+    end
+
+    private
+
+      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_zipco(
+              token: '12345'
+            )
+
+            payment.zipco
+          end
+      end
+
+      def timeout_tender
+        @tender ||=
+          begin
+            payment.set_address(first_name: 'Ben', last_name: 'Crouse')
+
+            payment.build_zipco(
+              token: 'timeout_token'
+            )
+
+            payment.zipco
+          end
+      end
+  end
+end

data/test/services/workarea/zipco/checkout_test.rb

@@ -0,0 +1,43 @@
+require 'test_helper'
+
+module Workarea
+  module Zipco
+    class CheckoutTest < Workarea::TestCase
+      setup :set_models
+
+      def set_models
+        @user = create_user
+        @product = create_product(variants: [{ sku: 'SKU', regular: 5.to_m }])
+        @order = create_order(zipco_order_id: "1234", items: [{ product_id: @product.id, sku: 'SKU' }])
+        @checkout = Workarea::Checkout.new(@order, @user)
+      end
+
+      def test_complete_approved
+        @checkout.payment.set_zipco(token: "1234")
+
+        @checkout.steps.each do |step|
+          step.any_instance.expects(:complete?).returns(true).at_least_once
+        end
+        Workarea::Checkout::ShippingOptions.any_instance.expects(:valid?).returns(true)
+
+        zipco_checkout = Zipco::Checkout.new(@checkout, @user, { result: "approved", checkoutId: "1234" })
+        complete = zipco_checkout.complete
+
+        assert(complete)
+      end
+
+      def test_complete_referred
+        @checkout.payment.set_zipco(token: "1234")
+
+        @checkout.steps.each do |step|
+          step.any_instance.expects(:complete?).returns(true).at_least_once
+        end
+        Workarea::Checkout::ShippingOptions.any_instance.expects(:valid?).returns(true)
+
+        zipco_checkout = Zipco::Checkout.new(@checkout, @user, { result: "referred", checkoutId: "1234" })
+        complete = zipco_checkout.complete
+        assert(complete)
+      end
+    end
+  end
+end

data/test/services/workarea/zipco/order_test.rb

@@ -0,0 +1,102 @@
+require 'test_helper'
+
+module Workarea
+  module Zipco
+    class OrderTest < Workarea::TestCase
+      def test_to_h
+        create_order_total_discount
+        order = create_placed_order
+        payment = Workarea::Payment.find(order.id)
+
+        payment = Workarea::Payment.find(order.id)
+        payment.profile.update_attributes!(store_credit: 2.00)
+        payment.set_store_credit
+        payment.tenders.first.amount = 2.to_m
+        payment.save
+
+        order.reload
+        payment.reload
+
+        order_hash = Workarea::Zipco::Order.new(order).to_h
+        items = order_hash[:order][:items]
+        assert_equal(5, items.size)
+
+        assert_equal(8.00, order_hash[:order][:amount].to_f)
+
+        discount_items = items.select { |i| i[:type] == "discount" }
+
+        assert_equal(2, discount_items.size)
+        discount_prices = discount_items.map { |d| d[:amount] }
+        assert(discount_prices.include? -1.0) # order total discount
+        assert(discount_prices.include? -2.0) # store credit
+
+        zipco_order = order_hash[:order]
+        assert_equal(order.id, zipco_order[:reference])
+        assert_equal("USD", zipco_order[:currency])
+
+        zipco_shipping = zipco_order[:shipping]
+        assert(zipco_shipping.present?)
+        assert(zipco_shipping[:address].present?)
+
+        item = order.items.first
+        item.adjust_pricing(
+          price: 'item',
+          quantity: 1,
+          description: "Gift Wrapping",
+          calculator: "Workarea::Pricing::Calculators::GiftWrappingCalculator",
+          amount: 5.to_m,
+          data: {}
+          )
+
+        order_hash = Workarea::Zipco::Order.new(order).to_h
+
+        gift_wrap_item = order_hash[:order][:items].detect { |i| i[:name] == "Gift Wrapping" }
+        assert(gift_wrap_item.present?)
+        assert_equal(5.0, gift_wrap_item[:amount])
+      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