workarea-flow_io 1.2.1

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

@@ -0,0 +1,54 @@
+require 'test_helper'
+
+module Workarea
+  module Storefront
+    class FlowWebhookRackAttackIntegrationTest < Workarea::IntegrationTest
+      include Workarea::FlowIo::WebhookIntegrationTest
+
+      class AddEnvMiddleware
+        def initialize(app)
+          @app = app
+        end
+
+        def call(env)
+          env.merge!(Rails.application.env_config)
+          @app.call(env)
+        end
+      end
+
+      def test_safelist_webhook_requests
+        post_signed "/", params: { faked: "request" }.to_json
+        assert_equal("allow flow webhooks", @rack_attack_rules["rack.attack.matched"])
+        assert_equal(:safelist, @rack_attack_rules["rack.attack.match_type"])
+      end
+
+      def test_doesnt_safelist_with_bad_auth
+        post "/", params: {}
+        assert_nil(@rack_attack_rules["rack.attack.matched"])
+        assert_nil(@rack_attack_rules["rack.attack.match_type"])
+      end
+
+      private
+
+      def app
+        @app ||=
+          begin
+            endpoint = ->(env) do
+              @rack_attack_rules = env.slice(
+                "rack.attack.matched",
+                "rack.attack.match_type"
+              )
+              [200, {}, []]
+            end
+
+            Rack::Builder.new do
+              use AddEnvMiddleware
+              use Rack::Attack
+              use ActionDispatch::Cookies
+              run endpoint
+            end
+          end
+      end
+    end
+  end
+end

data/test/integration/workarea/storefront/search_integration_test.decorator

@@ -0,0 +1,51 @@
+module Workarea
+  decorate Storefront::SearchIntegrationTest, with: :flow_io do
+    def test_localized_price_filters
+      create_pricing_sku_with_flow(
+        id: 'SKU1',
+        flow_io_local_items: [
+          build_flow_io_local_item(regular: 5.to_m("CAD"))
+        ]
+      )
+
+      create_pricing_sku_with_flow(
+        id: 'SKU2',
+        flow_io_local_items: [
+          build_flow_io_local_item(regular: 70.to_m("CAD"))
+        ]
+      )
+
+      Catalog::Product.create!(
+        name: "Cheap Shirt",
+        variants: [ sku: "SKU1" ]
+      )
+
+      Catalog::Product.create!(
+        name: "Expensive Shirt",
+        variants: [ sku: "SKU2" ]
+      )
+
+      Workarea::Search::Settings.current.update_attributes!(
+        currency_localized_facets: {
+          "CAD" => [
+            { "to" => 19.99 },
+            { "from" => 20.0, "to" => 39.99 },
+            { "from" => 40.0 }
+          ]
+        }
+      )
+
+      cookies['_f60_session'] = 2
+      get storefront.searches_path(q: "shirt", format: :json)
+      assert response.ok?
+
+      get storefront.search_path(q: "shirt")
+      assert_match("Cheap Shirt", response.body)
+      assert_match("Expensive Shirt", response.body)
+
+      get storefront.search_path(price_canada: ["*-19.99"], q: "shirt", locale: "can")
+      assert_match("Cheap Shirt", response.body)
+      refute_match("Expensive Shirt", response.body)
+    end
+  end
+end

data/test/javascripts/flow_spec.js

@@ -0,0 +1,39 @@
+//= require workarea/storefront/flow_io/flow_country_picker
+
+(function () {
+    'use strict';
+
+    describe('WORKAREA.flowCountryPicker', function () {
+        describe('urlLocale', function () {
+            it('parses iso_3166_3 in url', function () {
+                var url = 'https://example.com/deu/products/small-iron-bag';
+                expect(WORKAREA.flowCountryPicker.urlLocale(url)).to.eq("deu");
+            });
+
+            it('handles url without iso_3166_3', function () {
+                var url = 'https://example.com/products/small-iron-bag';
+                expect(_.isUndefined(WORKAREA.flowCountryPicker.urlLocale(url))).to.eq(true);
+            });
+        });
+
+        describe('redirectUrl', function () {
+            it('replaces the country in the url', function () {
+                var url = 'https://example.com/products/small-iron-bag';
+                expect(WORKAREA.flowCountryPicker.redirectUrl(url, "gbr")).to.eq("https://example.com/gbr/products/small-iron-bag");
+            });
+
+            it('injects the country into the url', function () {
+                var url = 'https://example.com/deu/products/small-iron-bag';
+                expect(WORKAREA.flowCountryPicker.redirectUrl(url, "gbr")).to.eq("https://example.com/gbr/products/small-iron-bag");
+            });
+
+            it('works without path', function () {
+                var url = 'https://example.com/';
+                expect(WORKAREA.flowCountryPicker.redirectUrl(url, "gbr")).to.eq("https://example.com/gbr/");
+
+                url = 'https://example.com';
+                expect(WORKAREA.flowCountryPicker.redirectUrl(url, "gbr")).to.eq("https://example.com/gbr");
+            });
+        });
+    });
+}());

data/test/javascripts/spec_helper.js

@@ -0,0 +1,3 @@
+//= require workarea/core/spec_helper
+//= require workarea/storefront/spec_helper
+//= require workarea/storefront/application

data/test/models/workarea/address_test.decorator

@@ -0,0 +1,20 @@
+module Workarea
+  decorate AddressTest, with: :flow_io do
+    def test_flow_region
+      address = Address.new(
+        first_name: 'Jeff',
+        last_name: 'Yuci ',
+        street: '22 S. 3rd St.',
+        street_2: 'Second Floor',
+        city: 'Cologn',
+        region: nil,
+        postal_code: '19106',
+        country: 'DE',
+        phone_number: '2159251800',
+        flow: true
+      )
+
+      assert(address.valid?)
+    end
+  end
+end

data/test/models/workarea/checkout_test.decorator

@@ -0,0 +1,20 @@
+module Workarea
+  decorate CheckoutTest, with: :flow_io do
+    def test_shippable
+      checkout = Checkout.new(Order.new)
+      assert(checkout.shippable?)
+
+      checkout = Checkout.new(@order)
+      Checkout::ShippingOptions.any_instance.expects(:valid?).returns(false)
+      refute(checkout.shippable?)
+
+      checkout = Checkout.new(@order)
+      Checkout::ShippingOptions.any_instance.expects(:valid?).returns(true)
+      assert(checkout.shippable?)
+
+      flow_order = create_order(flow: true, items: [{ product_id: @product.id, sku: 'SKU' }])
+      checkout = Checkout.new(flow_order)
+      assert(checkout.shippable?)
+    end
+  end
+end

data/test/models/workarea/flow_io/imported_item_test.rb

@@ -0,0 +1,50 @@
+require 'test_helper'
+
+module Workarea
+  module FlowIo
+    class ImportedItemTest < TestCase
+      def test_import_from_params
+        assert_difference -> { Pricing::Sku.count } do
+          imported = ImportedItem.process(
+            {
+              'experience[key]' => 'canada',
+              'item[number]' => '607508142-9',
+              'prices[item][amount]' => '20.0',
+              'prices[item][base][amount]' => '14.6',
+              'prices[item][base][currency]' => 'USD',
+              'prices[item][base][label]' => 'US$14.60',
+              'prices[item][currency]' => 'CAD',
+              'prices[item][includes][key]' => 'none',
+              'prices[item][includes][label]' => 'HST and duty not included',
+              'prices[item][label]' => 'CA$20.00',
+              'prices[price_attributes][msrp][amount]' => '30.0',
+              'prices[price_attributes][msrp][base][amount]' => '21.9',
+              'prices[price_attributes][msrp][base][currency]' => 'USD',
+              'prices[price_attributes][msrp][base][label]' => 'US$21.90',
+              'prices[price_attributes][msrp][currency]' => 'CAD',
+              'prices[price_attributes][msrp][label]' => 'CA$30.00',
+              'prices[price_attributes][regular_price][amount]' => '20.0',
+              'prices[price_attributes][regular_price][base][amount]' => '14.6',
+              'prices[price_attributes][regular_price][base][currency]' => 'USD',
+              'prices[price_attributes][regular_price][base][label]' => 'US$14.60',
+              'prices[price_attributes][regular_price][currency]' => 'CAD',
+              'prices[price_attributes][regular_price][label]' => 'CA$20.00',
+              'prices[price_attributes][sale_price][amount]' => '10.0',
+              'prices[price_attributes][sale_price][base][amount]' => '7.3',
+              'prices[price_attributes][sale_price][base][currency]' => 'USD',
+              'prices[price_attributes][sale_price][base][label]' => 'US$7.30',
+              'prices[price_attributes][sale_price][currency]' => 'CAD',
+              'prices[price_attributes][sale_price][label]' => 'CA$10.00',
+            },
+            FlowIo.client.experiences.get(FlowIo.organization_id)
+          )
+          sku = Pricing::Sku.find('607508142-9')
+          local_item = sku.flow_io_local_items.last
+          regular = local_item.prices.first.regular
+
+          assert_equal(20.to_m('CAD'), regular.price)
+        end
+      end
+    end
+  end
+end

data/test/models/workarea/fulfillment_test.decorator

@@ -0,0 +1,12 @@
+module Workarea
+  decorate FulfillmentTest, with: :flow_io do
+    decorated { setup :stub_flow_workers }
+
+    private
+
+      def stub_flow_workers
+        Workarea::FlowIo::ShippingNotifications.any_instance.stubs(:perform).returns(stub_everything)
+        Workarea::FlowIo::FulfillmentCancellation.any_instance.stubs(:perform).returns(stub_everything)
+      end
+  end
+end

data/test/models/workarea/oms_fulfillment_test.decorator

@@ -0,0 +1,14 @@
+module Workarea
+  if Plugin.installed?(:oms)
+    decorate OmsFulfillmentTest, with: :flow_io do
+      decorated { setup :stub_flow_workers }
+
+      private
+
+        def stub_flow_workers
+          Workarea::FlowIo::ShippingNotifications.any_instance.stubs(:perform).returns(stub_everything)
+          Workarea::FlowIo::FulfillmentCancellation.any_instance.stubs(:perform).returns(stub_everything)
+        end
+    end
+  end
+end

data/test/models/workarea/order/item_test.decorator

@@ -0,0 +1,46 @@
+module Workarea
+  decorate Order::ItemTest, with: :flow_io do
+    decorated { include Workarea::FlowIo::FlowFixtures } 
+
+    def test_current_flow_unit_price_with_no_price_adjustments
+      order = Order.new(
+        experience: canada_experience_geo,
+        items: [
+          {
+            product_id: "1234",
+            sku: "1234",
+            quantity: 1
+          }
+        ] 
+      )
+
+      item = order.items.first
+
+      assert_equal(0.to_m("CAD"), item.current_flow_unit_price)
+    end
+
+    def test_current_flow_unit_price
+      order = Order.new(
+        experience: canada_experience_geo,
+        items: [
+          {
+            product_id: "1234",
+            sku: "1234",
+            quantity: 1,
+            flow_price_adjustments: [
+              {
+                price: "item",
+                quantity: 2,
+                amount: 10.to_m("CAD")
+              }
+            ]
+          }
+        ] 
+      )
+
+      item = order.items.first
+
+      assert_equal(5.to_m("CAD"), item.current_flow_unit_price)
+    end
+  end
+end

data/test/models/workarea/order_test.decorator

@@ -0,0 +1,16 @@
+module Workarea
+  decorate OrderTest, with: :flow_io do
+    decorated { include Workarea::FlowIo::FlowFixtures }
+
+    def test_currency_without_experience
+      order = Order.new
+
+      assert_equal(Money.default_currency.iso_code, order.currency)
+    end
+
+    def test_currency_with_experience
+      order = Order.new(experience: europe_experience_geo)
+      assert_equal("EUR", order.currency)
+    end
+  end
+end

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

@@ -0,0 +1,163 @@
+require 'test_helper'
+
+module Workarea
+  class Payment
+    class FlowCreditCardIntegrationTest < Workarea::TestCase
+      include FlowIoVCRConfig
+
+      def test_store_auth
+        VCR.use_cassette 'payment/flow/store_auth' do
+          transaction = tender.build_transaction(action: 'authorize')
+          Payment::Authorize::FlowPayment.new(tender, transaction).complete!
+          assert(transaction.success?, 'expected transaction to be successful')
+
+          assert(tender.token.present?)
+        end
+      end
+
+      def test_store_purchase
+        VCR.use_cassette 'payment/flow/store_purchase' do
+          transaction = tender.build_transaction(action: 'purchase')
+          Payment::Purchase::FlowPayment.new(tender, transaction).complete!
+          assert(transaction.success?)
+
+          assert(tender.token.present?)
+        end
+      end
+
+      def test_auth_capture
+        VCR.use_cassette 'payment/flow/auth_capture' do
+          transaction = tender.build_transaction(action: 'authorize')
+          Payment::Authorize::FlowPayment.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?)
+          assert(capture_transaction.success?)
+        end
+      end
+
+      def test_auth_void
+        VCR.use_cassette 'payment/flow/auth_void' do
+          transaction = tender.build_transaction(action: 'authorize')
+          operation = Payment::Authorize::FlowPayment.new(tender, transaction)
+          operation.complete!
+          assert(transaction.success?, 'expected transaction to be successful')
+          transaction.save!
+
+          assert(tender.token.present?)
+
+          operation.cancel!
+          void = transaction.cancellation
+
+          assert(void.success?)
+        end
+      end
+
+      def test_auth_capture_refund
+        pass && return unless Workarea.config.run_credit_card_refund_tests
+
+        VCR.use_cassette 'payment/flow/auth_capture_refund' do
+          transaction = tender.build_transaction(action: 'authorize')
+          Payment::Authorize::FlowPayment.new(tender, transaction).complete!
+          assert(transaction.success?, 'expected transaction to be successful')
+          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?)
+
+          refund = Payment::Refund.new(payment: payment)
+          refund.allocate_amounts!(total: 5.to_m)
+
+          assert(refund.valid?)
+          refund.complete!
+
+          refund_transaction = payment.credit_card.transactions.refunds.first
+          assert(refund_transaction.valid?)
+        end
+      end
+
+      def test_purchase_refund
+        pass && return unless Workarea.config.run_credit_card_refund_tests
+
+        VCR.use_cassette 'payment/flow/purchase_refund' do
+          transaction = tender.build_transaction(action: 'purchase')
+          Payment::Purchase::FlowPayment.new(tender, transaction).complete!
+          assert(transaction.success?)
+          transaction.save!
+
+          assert(tender.token.present?)
+
+          refund = Payment::Refund.new(payment: payment)
+          refund.allocate_amounts!(total: 5.to_m)
+
+          assert(refund.valid?)
+          refund.complete!
+
+          refund_transaction = payment.credit_card.transactions.refunds.first
+          assert(refund_transaction.valid?)
+        end
+      end
+
+      private
+
+      def gateway
+        Workarea::FlowIo.gateway
+      end
+
+      def payment
+        @payment ||=
+          begin
+            profile = create_payment_profile
+            order = create_order(flow_total_price: 5.to_m('CAD'))
+            create_payment(
+              operation_tender_type: 'FlowPayment',
+              id: order.id,
+              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_credit_card(
+              number: 4012888888881881,
+              month: 1,
+              year: Time.current.year + 1,
+              cvv: '999',
+              amount: 5.to_m
+            )
+
+            payment.credit_card
+          end
+      end
+    end
+  end
+end