workarea-core 3.4.45 → 3.5.0.beta.1

data/test/models/workarea/metrics/user_test.rb

@@ -39,91 +39,174 @@ module Workarea
         assert_equal(-2, user.discounts)
       end
 
-      def test_update_calculated_fields!
-        freeze_time
-        User.save_order(email: 'bcrouse1@workarea.com', revenue: 1.to_m, at: 1.day.ago)
-        User.save_order(email: 'bcrouse2@workarea.com', revenue: 10.to_m, at: 2.days.ago)
-        User.save_order(email: 'bcrouse2@workarea.com', revenue: 20.to_m, at: 3.days.ago)
-        User.update_calculated_fields!
-
-        one = User.find('bcrouse1@workarea.com')
-        assert_equal(1, one.average_order_value)
-        assert_in_delta(1.46e-08, one.frequency)
-
-        two = User.find('bcrouse2@workarea.com')
-        assert_equal(15, two.average_order_value)
-        assert_in_delta(1.29e-08, two.frequency)
+      def test_save_cancellation
+        first = Time.zone.local(2018, 11, 14)
+
+        User.save_order(
+          email: 'bcrouse@workarea.com',
+          revenue: 50.to_m,
+          at: first
+        )
+
+        User.save_cancellation(
+          email: 'bcrouse@workarea.com',
+          refund: -5.to_m,
+          at: first
+        )
+
+        assert_equal(1, User.count)
+
+        user = User.first
+        assert_equal(1, user.cancellations)
+        assert_equal(-5, user.refund)
+        assert_equal(45, user.revenue)
+
+        last = Time.zone.local(2018, 11, 15)
+
+        User.save_cancellation(
+          email: 'bcrouse@workarea.com',
+          refund: -3.to_m,
+          at: last
+        )
+
+        assert_equal(1, User.count)
+
+        user.reload
+        assert_equal(2, user.cancellations)
+        assert_equal(-8, user.refund)
+        assert_equal(42, user.revenue)
+      end
+
+      def test_save_affinity
+        2.times do
+          User.save_affinity(
+            id: 'bcrouse@workarea.com',
+            action: 'viewed',
+            product_ids: %w(foo bar),
+            category_ids: 'baz',
+            search_ids: %(qoo)
+          )
+        end
+
+        assert_equal(1, User.count)
+        user = User.first
+        assert_equal('bcrouse@workarea.com', user.id)
+        assert_equal(%w(foo bar foo bar), user.viewed.product_ids)
+        assert_equal(%w(baz baz), user.viewed.category_ids)
+        assert_equal(%w(qoo qoo), user.viewed.search_ids)
+
+        assert_changes -> { user.reload.updated_at } do
+          User.save_affinity(
+            id: 'bcrouse@workarea.com',
+            action: 'purchased',
+            product_ids: %w(foo bar)
+          )
+        end
+
+        assert_equal(1, User.count)
+        user.reload
+        assert_equal('bcrouse@workarea.com', user.id)
+        assert_equal(%w(foo bar foo bar), user.viewed.product_ids)
+        assert_equal(%w(baz baz), user.viewed.category_ids)
+        assert_equal(%w(qoo qoo), user.viewed.search_ids)
+        assert_equal(%w(foo bar), user.purchased.product_ids)
       end
 
-      def test_update_percentiles!
-        User.save_order(email: 'bcrouse1@workarea.com', revenue: 100.to_m, at: 30.days.ago)
-        User.save_order(email: 'bcrouse2@workarea.com', revenue: 1.to_m, at: 2.days.ago)
-        User.save_order(email: 'bcrouse2@workarea.com', revenue: 2.to_m, at: 3.days.ago)
-        User.update_calculated_fields!
-        User.update_percentiles!
-
-        one = User.find('bcrouse1@workarea.com')
-        assert_equal(50, one.orders_percentile)
-        assert_equal(50, one.frequency_percentile)
-        assert_equal(100, one.revenue_percentile)
-        assert_equal(100, one.average_order_value_percentile)
-
-        two = User.find('bcrouse2@workarea.com')
-        assert_equal(100, two.orders_percentile)
-        assert_equal(100, two.frequency_percentile)
-        assert_equal(50, two.revenue_percentile)
-        assert_equal(50, two.average_order_value_percentile)
+      def test_save_affinity_limits_storage
+        Workarea.config.max_affinity_items = 3
+
+        4.times do
+          User.save_affinity(
+            id: 'bcrouse@workarea.com',
+            action: 'viewed',
+            product_ids: %w(foo bar),
+            category_ids: 'baz',
+            search_ids: %(qoo)
+          )
+        end
+
+        user = User.first
+        assert_equal(%w(foo bar foo), user.viewed.product_ids)
+        assert_equal(%w(baz baz baz), user.viewed.category_ids)
+        assert_equal(%w(qoo qoo qoo), user.viewed.search_ids)
       end
 
       def test_merging_metrics
         freeze_time
 
-        first = User.create!(
+        metrics = User.create!(
           first_order_at: 2.weeks.ago,
           last_order_at: 1.day.ago,
           orders: 2,
           revenue: 100,
           discounts: -10,
           average_order_value: 50,
+          cancellations: 1,
+          refund: -20,
+          viewed: { product_ids: ['foo'], category_ids: ['bar'], search_ids: ['baz'] },
+          purchased: { product_ids: ['qoo'], category_ids: ['quo'], search_ids: ['qux'] }
         )
 
-        first.merge!(User.new)
-        first.reload
-        assert_equal(1, Metrics::User.count)
-        assert_equal(2.weeks.ago, first.first_order_at)
-        assert_equal(1.day.ago, first.last_order_at)
-        assert_equal(2, first.orders)
-        assert_equal(100, first.revenue)
-        assert_equal(-10, first.discounts)
-        assert_equal(50, first.average_order_value)
-
-        second = User.create!(id: 'foo').tap { |u| u.merge!(first) }
-        second.reload
-        assert_equal(1, Metrics::User.count)
-        assert_equal(2.weeks.ago, second.first_order_at)
-        assert_equal(1.day.ago, second.last_order_at)
-        assert_equal(2, second.orders)
-        assert_equal(100, second.revenue)
-        assert_equal(-10, second.discounts)
-        assert_equal(50, second.average_order_value)
-
-        third = User.create!(
+        metrics.merge!(User.new)
+        metrics.reload
+        assert_equal(2.weeks.ago, metrics.first_order_at)
+        assert_equal(1.day.ago, metrics.last_order_at)
+        assert_equal(2, metrics.orders)
+        assert_equal(100, metrics.revenue)
+        assert_equal(-10, metrics.discounts)
+        assert_equal(50, metrics.average_order_value)
+        assert_equal(1, metrics.cancellations)
+        assert_equal(-20, metrics.refund)
+        assert_equal(['foo'], metrics.viewed.product_ids)
+        assert_equal(['bar'], metrics.viewed.category_ids)
+        assert_equal(['baz'], metrics.viewed.search_ids)
+        assert_equal(['qoo'], metrics.purchased.product_ids)
+        assert_equal(['quo'], metrics.purchased.category_ids)
+        assert_equal(['qux'], metrics.purchased.search_ids)
+
+        blank = User.create!(id: 'foo').tap { |u| u.merge!(metrics) }
+        blank.reload
+        assert_equal(2.weeks.ago, blank.first_order_at)
+        assert_equal(1.day.ago, blank.last_order_at)
+        assert_equal(2, blank.orders)
+        assert_equal(100, blank.revenue)
+        assert_equal(-10, blank.discounts)
+        assert_equal(50, blank.average_order_value)
+        assert_equal(1, blank.cancellations)
+        assert_equal(-20, blank.refund)
+        assert_equal(['foo'], blank.viewed.product_ids)
+        assert_equal(['bar'], blank.viewed.category_ids)
+        assert_equal(['baz'], blank.viewed.search_ids)
+        assert_equal(['qoo'], blank.purchased.product_ids)
+        assert_equal(['quo'], blank.purchased.category_ids)
+        assert_equal(['qux'], blank.purchased.search_ids)
+
+        existing = User.create!(
           first_order_at: 3.weeks.ago,
           last_order_at: 3.weeks.ago,
           orders: 2,
           revenue: 120,
           average_order_value: 60,
+          viewed: { product_ids: ['one'], category_ids: ['two'], search_ids: ['three'] },
+          purchased: { product_ids: ['four'], category_ids: ['five'], search_ids: ['six'] }
         )
 
-        third.merge!(second)
-        third.reload
-        assert_equal(1, Metrics::User.count)
-        assert_equal(3.weeks.ago, third.first_order_at)
-        assert_equal(1.day.ago, third.last_order_at)
-        assert_equal(4, third.orders)
-        assert_equal(220, third.revenue)
-        assert_equal(-10, third.discounts)
-        assert_equal(55, third.average_order_value)
+        existing.merge!(metrics)
+        existing.reload
+        assert_equal(3.weeks.ago, existing.first_order_at)
+        assert_equal(1.day.ago, existing.last_order_at)
+        assert_equal(4, existing.orders)
+        assert_equal(220, existing.revenue)
+        assert_equal(-10, existing.discounts)
+        assert_equal(55, existing.average_order_value)
+        assert_equal(1, existing.cancellations)
+        assert_equal(-20, existing.refund)
+        assert_equal(%w(one foo), existing.viewed.product_ids)
+        assert_equal(%w(two bar), existing.viewed.category_ids)
+        assert_equal(%w(three baz), existing.viewed.search_ids)
+        assert_equal(%w(four qoo), existing.purchased.product_ids)
+        assert_equal(%w(five quo), existing.purchased.category_ids)
+        assert_equal(%w(six qux), existing.purchased.search_ids)
       end
     end
   end

data/test/models/workarea/navigation/breadcrumbs_test.rb

@@ -23,10 +23,20 @@ module Workarea
       end
 
       def test_last
-        breadcrumbs = Breadcrumbs.new(@navigable, last: 'Test Taxon')
+        model = create_product
+        breadcrumbs = Breadcrumbs.new(@navigable, last: model)
+
+        assert(breadcrumbs.last.is_a?(Navigation::Taxon))
+        assert_equal(4, breadcrumbs.length) # including home
+        assert_equal(model, breadcrumbs.last.navigable)
+        assert_equal(model.name, breadcrumbs.last.name)
+
+        model = create_inventory
+        breadcrumbs = Breadcrumbs.new(@navigable, last: model.id)
+
         assert(breadcrumbs.last.is_a?(Navigation::Taxon))
         assert_equal(4, breadcrumbs.length) # including home
-        assert_equal('Test Taxon', breadcrumbs.last.name)
+        assert_equal(model.id, breadcrumbs.last.name)
       end
 
       def test_selected

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

@@ -118,6 +118,7 @@ module Workarea
       def test_need_reminding
         placed = Order.create!(placed_at: 1.hour.ago)
         reminded = Order.create!(reminded_at: 1.hour.ago)
+        fraud = Order.create!(fraud_suspected_at: 1.hour.ago)
         not_abandoned = Order.create!(email: email)
         abandoned = Order.create!(email: email, checkout_started_at: 2.hours.ago, items: [{ product_id: '1', sku: 2 }])
         empty = Order.create!(email: email, checkout_started_at: 2.hours.ago, items: [])
@@ -126,6 +127,7 @@ module Workarea
 
         refute_includes(results, placed)
         refute_includes(results, reminded)
+        refute_includes(results, fraud)
         refute_includes(results, no_info)
         refute_includes(results, not_abandoned)
         refute_includes(results, empty)

data/test/models/workarea/order_test.rb

@@ -56,6 +56,9 @@ module Workarea
       order.checkout_started_at = Time.current
       assert_equal(:checkout, order.status)
 
+      order.fraud_suspected_at = Time.current
+      assert_equal(:suspected_fraud, order.status)
+
       order.place
       assert_equal(:placed, order.status)
 
@@ -150,5 +153,46 @@ module Workarea
       order = Order.new
       assert_equal("Order #{order.id}", order.name)
     end
+
+    def test_fraud_suspected?
+      order = Order.new
+      order.fraud_decision = create_fraud_decision
+
+      refute(order.fraud_suspected?)
+
+      order.fraud_decision = create_fraud_decision(decision: :declined)
+      order.fraud_suspected_at = Time.current
+      assert(order.fraud_suspected?)
+    end
+
+    def test_set_fraud_decision
+      order = Order.new
+      order.set_fraud_decision!(create_fraud_decision)
+
+      refute(order.fraud_suspected_at.present?)
+      assert(order.fraud_decided_at.present?)
+
+      order.set_fraud_decision!(create_fraud_decision(decision: :declined))
+      assert(order.fraud_suspected_at.present?)
+    end
+
+    def test_item_count_limit
+      Workarea.config.item_count_limit = 2
+
+      order = Order.new(email: 'test@workarea.com')
+
+      order.items.build(sku: 'SKU1', product_id: 'PROD')
+      assert(order.valid?)
+
+      order.items.build(sku: 'SKU2', product_id: 'PROD', quantity: 2)
+      assert(order.valid?)
+
+      order.items.build(sku: 'SKU3', product_id: 'PROD')
+      refute(order.valid?)
+      assert_equal(
+        t('workarea.order.errors.count_limit', size: 2),
+        order.errors.full_messages.first
+      )
+    end
   end
 end

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

@@ -4,117 +4,115 @@ module Workarea
   class Payment
     class AddressTest < TestCase
       def test_po_box_addresses
-        Workarea.with_config do |config|
-          address = Payment::Address.new(
-            first_name: 'Ben',
-            last_name: 'Crouse',
-            street: '22 S. 3rd St.',
-            street_2: 'Second Floor',
-            city: 'Philadelphia',
-            region: 'PA',
-            postal_code: '19106',
-            country: 'US'
-          )
-
-          config.allow_payment_address_po_box = false
-
-          po_boxes = [
-            'PO Box 123',
-            'P O box 123',
-            'P. O. Box 123',
-            'P.O.Box 123',
-            'post box 123',
-            'post office box 123',
-            'post office 123',
-            'P.O.B 123',
-            'P.O.B. 123',
-            'Post Office Bin 123',
-            'Postal Code 123',
-            'Post Box #123',
-            'Postal Box 123',
-            'P.O. Box 123',
-            'PO. Box 123',
-            'P.o box 123',
-            'Pobox 123',
-            'pob 123',
-            'pob123',
-            'pobox123',
-            'p.o. Box123',
-            'po-box123',
-            'p.o.-box 123',
-            'PO-Box 123',
-            'p-o-box 123',
-            'p-o box 123',
-            'box 123',
-            'Box123',
-            'Box-123'
-          ]
-
-          non_po_boxes = [
-            '123 Box Turtle Circle',
-            '123 Boxing Pass',
-            '123 Poblano Lane',
-            '123 P O Davis Drive',
-            '123 Postal Circle'
-          ]
-
-          po_boxes.each do |po_box|
-            address.street = po_box
-            refute(address.valid?)
-            refute(address.errors[:street].empty?)
-          end
-
-          address.street = '22 S. 3rd St'
-          po_boxes.each do |po_box|
-            address.street_2 = po_box
-            refute(address.valid?)
-            refute(address.errors[:street_2].empty?)
-          end
-
-          config.allow_payment_address_po_box = true
-          address.street_2 = 'Second Floor'
-
-          po_boxes.each do |po_box|
-            address.street = po_box
-            assert(address.valid?)
-            refute(address.errors[:street].present?)
-          end
-
-          address.street = '22 S. 3rd St'
-          po_boxes.each do |po_box|
-            address.street_2 = po_box
-            assert(address.valid?)
-            refute(address.errors[:street_2].present?)
-          end
-
-          non_po_boxes.each do |non_po_box|
-            address.street = non_po_box
-            assert(address.valid?)
-            assert(address.errors[:street].empty?)
-          end
-
-          address.street = '22 S. 3rd St'
-          non_po_boxes.each do |non_po_box|
-            address.street_2 = non_po_box
-            assert(address.valid?)
-            assert(address.errors[:street_2].empty?)
-          end
-
-          config.allow_payment_address_po_box = true
-          address.street_2 = 'Second Floor'
-
-          non_po_boxes.each do |non_po_box|
-            address.street = non_po_box
-            assert(address.valid?)
-            refute(address.errors[:street].present?)
-          end
-
-          address.street = '22 S. 3rd St'
-          non_po_boxes.each do |non_po_box|
-            address.street_2 = non_po_box
-            assert(address.valid?)
-            refute(address.errors[:street_2].present?)
-          end
+        address = Payment::Address.new(
+          first_name: 'Ben',
+          last_name: 'Crouse',
+          street: '22 S. 3rd St.',
+          street_2: 'Second Floor',
+          city: 'Philadelphia',
+          region: 'PA',
+          postal_code: '19106',
+          country: 'US'
+        )
+
+        Workarea.config.allow_payment_address_po_box = false
+
+        po_boxes = [
+          'PO Box 123',
+          'P O box 123',
+          'P. O. Box 123',
+          'P.O.Box 123',
+          'post box 123',
+          'post office box 123',
+          'post office 123',
+          'P.O.B 123',
+          'P.O.B. 123',
+          'Post Office Bin 123',
+          'Postal Code 123',
+          'Post Box #123',
+          'Postal Box 123',
+          'P.O. Box 123',
+          'PO. Box 123',
+          'P.o box 123',
+          'Pobox 123',
+          'pob 123',
+          'pob123',
+          'pobox123',
+          'p.o. Box123',
+          'po-box123',
+          'p.o.-box 123',
+          'PO-Box 123',
+          'p-o-box 123',
+          'p-o box 123',
+          'box 123',
+          'Box123',
+          'Box-123'
+        ]
+
+        non_po_boxes = [
+          '123 Box Turtle Circle',
+          '123 Boxing Pass',
+          '123 Poblano Lane',
+          '123 P O Davis Drive',
+          '123 Postal Circle'
+        ]
+
+        po_boxes.each do |po_box|
+          address.street = po_box
+          refute(address.valid?)
+          refute(address.errors[:street].empty?)
+        end
+
+        address.street = '22 S. 3rd St'
+        po_boxes.each do |po_box|
+          address.street_2 = po_box
+          refute(address.valid?)
+          refute(address.errors[:street_2].empty?)
+        end
+
+        Workarea.config.allow_payment_address_po_box = true
+        address.street_2 = 'Second Floor'
+
+        po_boxes.each do |po_box|
+          address.street = po_box
+          assert(address.valid?)
+          refute(address.errors[:street].present?)
+        end
+
+        address.street = '22 S. 3rd St'
+        po_boxes.each do |po_box|
+          address.street_2 = po_box
+          assert(address.valid?)
+          refute(address.errors[:street_2].present?)
+        end
+
+        non_po_boxes.each do |non_po_box|
+          address.street = non_po_box
+          assert(address.valid?)
+          assert(address.errors[:street].empty?)
+        end
+
+        address.street = '22 S. 3rd St'
+        non_po_boxes.each do |non_po_box|
+          address.street_2 = non_po_box
+          assert(address.valid?)
+          assert(address.errors[:street_2].empty?)
+        end
+
+        Workarea.config.allow_payment_address_po_box = true
+        address.street_2 = 'Second Floor'
+
+        non_po_boxes.each do |non_po_box|
+          address.street = non_po_box
+          assert(address.valid?)
+          refute(address.errors[:street].present?)
+        end
+
+        address.street = '22 S. 3rd St'
+        non_po_boxes.each do |non_po_box|
+          address.street_2 = non_po_box
+          assert(address.valid?)
+          refute(address.errors[:street_2].present?)
         end
       end
 

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

@@ -76,58 +76,6 @@ module Workarea
         end
       end
 
-      def test_auth_capture_refund
-        pass && return unless Workarea.config.run_credit_card_refund_tests
-
-        VCR.use_cassette 'credit_card/auth_capture_refund' do
-          transaction = tender.build_transaction(action: 'authorize')
-          Payment::Authorize::CreditCard.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 'credit_card/purchase_refund' do
-          transaction = tender.build_transaction(action: 'purchase')
-          Payment::Purchase::CreditCard.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

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

@@ -52,6 +52,11 @@ module Workarea
         credit_card.valid?
         assert(credit_card.display_number.present?)
         assert(credit_card.issuer.present?)
+
+        Workarea.config.credit_card_issuers.delete('american_express')
+        credit_card.number = 378282246310005 # amex test number
+        refute(credit_card.valid?, 'valid')
+        assert(credit_card.errors[:base].present?, 'no errors')
       end
 
       def test_number=

data/test/models/workarea/pricing/cache_key_test.rb

@@ -10,12 +10,14 @@ module Workarea
             :setup_order_item,
             :setup_shipping,
             :setup_pricing,
+            :setup_payment,
             :setup_cache_key
 
       def test_parts
         parts = @cache_key.parts.flatten
 
         assert_includes(parts, @pricing.cache_key)
+        assert_includes(parts, @payment.cache_key)
         assert_includes(parts, @discount.reload.cache_key)
         assert_includes(parts, @order.cache_key)
         assert_includes(parts, @shipping.cache_key)
@@ -59,8 +61,12 @@ module Workarea
         @request = Request.new(@order, @shipping)
       end
 
+      def setup_payment
+        @payment = create_payment(id: @order.id)
+      end
+
       def setup_cache_key
-        @cache_key = CacheKey.new(@order, [@shipping], @request)
+        @cache_key = CacheKey.new(@order, [@shipping], @payment, @request)
       end
     end
   end