workarea-core 3.4.44 → 3.5.0.beta.1

data/test/models/workarea/pricing/discount/collection_test.rb

@@ -5,38 +5,36 @@ module Workarea
     class Discount
       class CollectionTest < TestCase
         def test_all
-          Workarea.with_config do |config|
-            config.discount_application_order = %w(
-              Workarea::Pricing::Discount::Product
-              Workarea::Pricing::Discount::ProductAttribute
-              Workarea::Pricing::Discount::Category
-              Workarea::Pricing::Discount::BuySomeGetSome
-              Workarea::Pricing::Discount::QuantityFixedPrice
-              Workarea::Pricing::Discount::FreeGift
-              Workarea::Pricing::Discount::Shipping
-              Workarea::Pricing::Discount::OrderTotal
-            )
+          Workarea.config.discount_application_order = %w(
+            Workarea::Pricing::Discount::Product
+            Workarea::Pricing::Discount::ProductAttribute
+            Workarea::Pricing::Discount::Category
+            Workarea::Pricing::Discount::BuySomeGetSome
+            Workarea::Pricing::Discount::QuantityFixedPrice
+            Workarea::Pricing::Discount::FreeGift
+            Workarea::Pricing::Discount::Shipping
+            Workarea::Pricing::Discount::OrderTotal
+          )
 
-            buy_some_get_some = create_buy_some_get_some_discount
-            category = create_category_discount
-            free_gift = create_free_gift_discount
-            order_total = create_order_total_discount
-            product_attribute = create_product_attribute_discount
-            product = create_product_discount
-            fixed_price = create_quantity_fixed_price_discount
-            shipping = create_shipping_discount
+          buy_some_get_some = create_buy_some_get_some_discount
+          category = create_category_discount
+          free_gift = create_free_gift_discount
+          order_total = create_order_total_discount
+          product_attribute = create_product_attribute_discount
+          product = create_product_discount
+          fixed_price = create_quantity_fixed_price_discount
+          shipping = create_shipping_discount
 
-            collection = Collection.new
+          collection = Collection.new
 
-            assert_equal(product, collection.all[0])
-            assert_equal(product_attribute, collection.all[1])
-            assert_equal(category, collection.all[2])
-            assert_equal(buy_some_get_some, collection.all[3])
-            assert_equal(fixed_price, collection.all[4])
-            assert_equal(free_gift, collection.all[5])
-            assert_equal(shipping, collection.all[6])
-            assert_equal(order_total, collection.all[7])
-          end
+          assert_equal(product, collection.all[0])
+          assert_equal(product_attribute, collection.all[1])
+          assert_equal(category, collection.all[2])
+          assert_equal(buy_some_get_some, collection.all[3])
+          assert_equal(fixed_price, collection.all[4])
+          assert_equal(free_gift, collection.all[5])
+          assert_equal(shipping, collection.all[6])
+          assert_equal(order_total, collection.all[7])
         end
       end
     end

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

@@ -35,30 +35,28 @@ module Workarea
       end
 
       def test_comparison_operator # <==>
-        Workarea.with_config do |config|
-          config.discount_application_order = %w(
-              Workarea::Pricing::Discount::Product
-              Workarea::Pricing::Discount::ProductAttribute
-              Workarea::Pricing::Discount::Category
-              Workarea::Pricing::Discount::BuySomeGetSome
-              Workarea::Pricing::Discount::QuantityFixedPrice
-              Workarea::Pricing::Discount::FreeGift
-              Workarea::Pricing::Discount::Shipping
-              Workarea::Pricing::Discount::OrderTotal
-          )
-
-          product = create_product_discount
-          product_attribute = create_product_attribute_discount
-
-          assert_equal(-1, product <=> product_attribute)
-          assert_equal(1, product_attribute <=> product)
-          assert_equal(0, product <=> product)
-
-          product_1 = create_product_discount(id: 1)
-          product_2 = create_product_discount(id: 2)
-
-          assert_equal(-1, product_1 <=> product_2)
-        end
+        Workarea.config.discount_application_order = %w(
+            Workarea::Pricing::Discount::Product
+            Workarea::Pricing::Discount::ProductAttribute
+            Workarea::Pricing::Discount::Category
+            Workarea::Pricing::Discount::BuySomeGetSome
+            Workarea::Pricing::Discount::QuantityFixedPrice
+            Workarea::Pricing::Discount::FreeGift
+            Workarea::Pricing::Discount::Shipping
+            Workarea::Pricing::Discount::OrderTotal
+        )
+
+        product = create_product_discount
+        product_attribute = create_product_attribute_discount
+
+        assert_equal(-1, product <=> product_attribute)
+        assert_equal(1, product_attribute <=> product)
+        assert_equal(0, product <=> product)
+
+        product_1 = create_product_discount(id: 1)
+        product_2 = create_product_discount(id: 2)
+
+        assert_equal(-1, product_1 <=> product_2)
       end
 
       def test_qualifies?

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

@@ -0,0 +1,83 @@
+require 'test_helper'
+
+module Workarea
+  module Pricing
+    class ItemTaxApplierTest < TestCase
+      setup :set_models
+
+      def set_models
+        @item = Order::Item.new
+        @address = Workarea::Address.new(factory_defaults_config.billing_address)
+
+        @adjustments_to_tax = PriceAdjustmentSet.new(
+          [
+            @item.price_adjustments.build(
+              price: 'item',
+              amount: 5.to_m,
+              data: { 'tax_code' => 101 }
+            )
+          ]
+        )
+      end
+
+      def test_adds_a_tax_price_adjustment_to_an_item
+        create_tax_category(code: '101')
+
+        applier = ItemTaxApplier.new(@address, @adjustments_to_tax)
+        applier.apply
+
+        price_adjustment = @item.price_adjustments.last
+        assert_equal('tax', price_adjustment.price)
+        assert_equal(0.3.to_m, price_adjustment.amount)
+      end
+
+      def test_guards_against_negative_tax_amounts
+        create_tax_category(
+          code: '101',
+          rates: [{ percentage: -0.06, country: 'US', region: 'PA' }]
+        )
+
+        applier = ItemTaxApplier.new(@address, @adjustments_to_tax)
+        applier.apply
+
+        assert_equal(1, @item.price_adjustments.size)
+      end
+
+      def test_with_multiple_tax_codes_and_discount
+        create_tax_category(
+          code: '101',
+          rates: [{ percentage: 0.07, country: 'US', region: 'PA' }]
+        )
+
+        create_tax_category(
+          code: '102',
+          rates: [{ percentage: 0.05, country: 'US', region: 'PA' }]
+        )
+
+        item_2 = Order::Item.new
+        @adjustments_to_tax.concat([
+          @item.price_adjustments.build(
+            price: 'item',
+            amount: -1.to_m,
+            data: { 'discount_value' => 1.to_m }
+          ),
+          item_2.price_adjustments.build(
+            price: 'item',
+            amount: 10.to_m,
+            data: { 'tax_code' => 102 }
+          )
+        ])
+
+        applier = ItemTaxApplier.new(@address, @adjustments_to_tax)
+        applier.apply
+
+
+        assert_equal(3, @item.price_adjustments.size)
+        assert_equal(0.28.to_m, @item.price_adjustments.last.amount)
+
+        assert_equal(2, item_2.price_adjustments.size)
+        assert_equal(0.50.to_m, item_2.price_adjustments.last.amount)
+      end
+    end
+  end
+end

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

@@ -53,6 +53,15 @@ module Workarea
         price.on_sale = false
         refute(price.on_sale?)
       end
+
+      def test_unsupported_segmentation
+        price = Price.new(active_segment_ids: %w(foo bar))
+        refute(price.valid?)
+        assert_includes(
+          price.errors[:active_segment_ids],
+          t('workarea.errors.messages.unsupported_segmentation')
+        )
+      end
     end
   end
 end

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

@@ -18,6 +18,11 @@ module Workarea
         @order.add_item(product_id: 'PRODUCT', sku: 'SKU', quantity: 2)
         @order.save!
 
+        @payment = create_payment(
+          id: @order.id,
+          address: factory_defaults_config.billing_address
+        )
+
         @discount = create_product_discount(promo_codes: ['promo-code'])
 
         @shipping = Shipping.create!(shipping_service: { name: 'Ground' })
@@ -81,6 +86,14 @@ module Workarea
 
         assert @request.stale?
       end
+
+      def test_payment_breaks_cache
+        @payment.address.street = '225 Arch St.'
+        @payment.save!
+
+        @request = Request.new(@order, @shipping)
+        assert @request.stale?
+      end
     end
   end
 end

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

@@ -32,6 +32,15 @@ module Workarea
         end
       end
 
+      def test_unsupported_segmentation
+        sku = Sku.new(active_segment_ids: %w(foo bar))
+        refute(sku.valid?)
+        assert_includes(
+          sku.errors[:active_segment_ids],
+          t('workarea.errors.messages.unsupported_segmentation')
+        )
+      end
+
       private
 
       def configure_locales

data/test/models/workarea/releasable_active_test.rb

@@ -0,0 +1,113 @@
+require 'test_helper'
+
+module Workarea
+  class ReleasableActiveTest < TestCase
+    class Foo
+      include Mongoid::Document
+      include Mongoid::Timestamps
+      include Releasable
+      field :name, type: String
+      field :blank_field, type: String
+      field :slug, type: String
+      validates :name, presence: true
+
+      embeds_many :bars
+      embeds_one :baz
+    end
+
+    class Bar
+      include Mongoid::Document
+      include Releasable
+      field :name, type: String
+      embedded_in :foo
+    end
+
+    class Baz
+      include Mongoid::Document
+      include Releasable
+      field :name, type: String
+      embedded_in :foo
+    end
+
+    setup :set_release
+
+    def set_release
+      @release = create_release
+    end
+
+    def test_save_can_schedule_activation
+      model = Foo.create!(
+        name: 'Test',
+        active: true,
+        activate_with: @release.id
+      )
+
+      model.reload
+
+      refute(model.active)
+      assert_equal(1, model.changesets.length)
+      assert_equal(@release.id, model.changesets.first.release_id)
+      assert_equal(1, model.changesets.first.changeset.size)
+      assert(model.changesets.first.changeset['active'][I18n.locale.to_s])
+      assert_equal(1, model.changesets.first.original.size)
+      refute(model.changesets.first.original['active'][I18n.locale.to_s])
+    end
+
+    def test_save_can_schedule_activation_for_an_embedded_document
+      model = Foo.create!(name: 'Test')
+
+      embedded_1 = model.bars.create!(
+        name: 'Bar',
+        active: true,
+        activate_with: @release.id
+      )
+
+      embedded_2 = model.bars.create!(
+        name: 'Baz',
+        active: true,
+        activate_with: @release.id
+      )
+
+      model.reload
+
+      refute(embedded_1.active)
+      assert_equal(1, embedded_1.changesets.length)
+      assert_equal(@release.id, embedded_1.changesets.first.release_id)
+      assert_equal(1, embedded_1.changesets.first.changeset.size)
+      assert(embedded_1.changesets.first.changeset['active'][I18n.locale.to_s])
+      assert_equal(1, embedded_1.changesets.first.original.size)
+      refute(embedded_1.changesets.first.original['active'][I18n.locale.to_s])
+
+      refute(embedded_2.active)
+      assert_equal(1, embedded_2.changesets.length)
+      assert_equal(@release.id, embedded_2.changesets.first.release_id)
+      assert_equal(1, embedded_2.changesets.first.changeset.size)
+      assert(embedded_2.changesets.first.changeset['active'][I18n.locale.to_s])
+      assert_equal(1, embedded_2.changesets.first.original.size)
+      refute(embedded_2.changesets.first.original['active'][I18n.locale.to_s])
+    end
+
+    def test_creating_and_activating_embedded
+      model = Foo.create!(name: 'Foo')
+
+      embedded = Release.with_current(@release.id) do
+        model.bars.create!(
+          name: 'Test',
+          active: true,
+          activate_with: @release.id
+        )
+      end
+
+      model.reload
+
+      refute(embedded.active)
+      assert_equal(1, embedded.changesets.length)
+      assert_equal(@release.id, embedded.changesets.first.release_id)
+      assert_equal(1, embedded.changesets.first.changeset.size)
+      assert(embedded.changesets.first.changeset['active'][I18n.locale.to_s])
+      assert_equal(1, embedded.changesets.first.original.size)
+      refute(embedded.changesets.first.original['active'][I18n.locale.to_s])
+      assert(embedded.changesets.first.document_path.present?)
+    end
+  end
+end

data/test/models/workarea/releasable_test.rb

@@ -113,44 +113,19 @@ module Workarea
       assert_equal(1, model.changesets.length)
       assert_equal(@release.id, model.changesets.first.release_id)
       assert_equal('Changed', model.changesets.first.changeset['name'])
+      assert_equal('Test', model.changesets.first.original['name'])
 
       assert_equal('Bar', model.bars.first.name)
       assert_equal(1, model.bars.first.changesets.length)
       assert_equal(@release.id, model.bars.first.changesets.first.release_id)
       assert_equal('Bar Changed', model.bars.first.changesets.first.changeset['name'])
+      assert_equal('Bar', model.bars.first.changesets.first.original['name'])
 
       assert_equal('Baz', model.baz.name)
       assert_equal(1, model.baz.changesets.length)
       assert_equal(@release.id, model.baz.changesets.first.release_id)
       assert_equal('Baz Changed', model.baz.changesets.first.changeset['name'])
-    end
-
-    def test_save_does_not_log_undone_changes
-      model = Foo.create!(
-        name: 'Test',
-        blank_field: 'test'
-      )
-
-      Release.with_current(@release.id) do
-        model.name = 'Changed'
-        model.blank_field = 'changed'
-        model.save!
-
-        model.name = 'Test'
-        model.blank_field = 'changed'
-        model.save!
-      end
-
-      assert(model.changesets.first.present?)
-      assert_equal('changed', model.changesets.first.changeset['blank_field'])
-      assert_nil(model.changesets.first.changeset['name'])
-
-      Release.with_current(@release.id) do
-        model.blank_field = 'test'
-        model.save!
-      end
-
-      assert(model.changesets.empty?)
+      assert_equal('Baz', model.baz.changesets.first.original['name'])
     end
 
     def test_save_does_not_log_release_changes_if_invalid
@@ -215,16 +190,19 @@ module Workarea
       assert_equal(1, model.changesets.length)
       assert_equal(@release.id, model.changesets.first.release_id)
       assert_equal('Changed', model.changesets.first.changeset['name'])
+      assert_equal('Test', model.changesets.first.original['name'])
 
       assert_equal('Bar', model.bars.first.name)
       assert_equal(1, model.bars.first.changesets.length)
       assert_equal(@release.id, model.bars.first.changesets.first.release_id)
       assert_equal('Bar Changed', model.bars.first.changesets.first.changeset['name'])
+      assert_equal('Bar', model.bars.first.changesets.first.original['name'])
 
       assert_equal('Baz', model.baz.name)
       assert_equal(1, model.baz.changesets.length)
       assert_equal(@release.id, model.baz.changesets.first.release_id)
       assert_equal('Baz Changed', model.baz.changesets.first.changeset['name'])
+      assert_equal('Baz', model.baz.changesets.first.original['name'])
     end
 
     def test_save_does_not_save_timestamp_changes
@@ -236,6 +214,9 @@ module Workarea
 
       fields_in_change = model.changesets.first.changeset.keys
       refute_includes(fields_in_change, 'updated_at')
+
+      fields_in_original = model.changesets.first.original.keys
+      refute_includes(fields_in_original, 'updated_at')
     end
 
     def test_save_does_not_save_slug_changes
@@ -261,21 +242,9 @@ module Workarea
 
       fields_in_change = model.changesets.first.changeset.keys
       refute_includes(fields_in_change, 'blank_field')
-    end
-
-    def test_save_can_schedule_activation
-      model = Foo.create!(
-        name: 'Test',
-        active: true,
-        activate_with: @release.id
-      )
-
-      model.reload
 
-      refute(model.active)
-      assert_equal(1, model.changesets.length)
-      assert_equal(@release.id, model.changesets.first.release_id)
-      assert(model.changesets.first.changeset['active'])
+      fields_in_original = model.changesets.first.original.keys
+      refute_includes(fields_in_original, 'blank_field')
     end
 
     def test_save_ignores_illegal_values
@@ -291,34 +260,6 @@ module Workarea
       assert_equal(0, model.changesets.length)
     end
 
-    def test_save_can_schedule_activation_for_an_embedded_document
-      model = Foo.create!(name: 'Test')
-
-      embedded_1 = model.bars.create!(
-        name: 'Bar',
-        active: true,
-        activate_with: @release.id
-      )
-
-      embedded_2 = model.bars.create!(
-        name: 'Baz',
-        active: true,
-        activate_with: @release.id
-      )
-
-      model.reload
-
-      refute(embedded_1.active)
-      assert_equal(1, embedded_1.changesets.length)
-      assert_equal(@release.id, embedded_1.changesets.first.release_id)
-      assert(embedded_1.changesets.first.changeset['active'])
-
-      refute(embedded_2.active)
-      assert_equal(1, embedded_2.changesets.length)
-      assert_equal(@release.id, embedded_2.changesets.first.release_id)
-      assert(embedded_2.changesets.first.changeset['active'])
-    end
-
     def test_destroys_related_changesets
       model = Foo.create!(
         name: 'Test',
@@ -361,6 +302,7 @@ module Workarea
       assert_equal(1, model.changesets.length)
       assert_equal(@release.id, model.changesets.first.release_id)
       assert_equal('Changed', model.changesets.first.changeset['name'])
+      assert_equal('Test', model.changesets.first.original['name'])
     end
 
     def test_destroys_a_changeset_where_it_is_the_only_change_if_embedded
@@ -407,73 +349,80 @@ module Workarea
       assert_equal('Baz Changed', model.baz.name)
     end
 
-    def test_undo
-      model = Foo.create!(
-        name: 'Test',
-        bars: [{ name: 'Bar' }],
-        baz: { name: 'Baz' }
-      )
+    def test_deleting_embedded
+      model = Foo.create!(name: 'Foo', bars: [{ name: 'Test' }])
+      @release.as_current { model.bars.first.destroy }
 
-      Release.with_current(@release.id) do
-        model.name = 'Changed'
-        model.save!
-
-        model.bars.first.name = 'Bar Changed'
-        model.bars.first.save!
+      model.reload
+      assert(model.bars.first.active?)
 
-        model.baz.name = 'Baz Changed'
-        model.baz.save!
+      @release.as_current do
+        model.reload
+        refute(model.bars.first.active?)
       end
+    end
 
-      @release.changesets.each(&:publish!)
-      model.reload
-
-      assert_equal('Changed', model.name)
-      assert_equal('Bar Changed', model.bars.first.name)
-      assert_equal('Baz Changed', model.baz.name)
+    def test_in_release
+      model = Foo.create!(name: 'Foo')
+      @release.as_current { model.update!(name: 'Bar') }
 
-      @release.changesets.each(&:undo!)
       model.reload
-
-      assert_equal('Test', model.name)
-      assert_equal('Bar', model.bars.first.name)
-      assert_equal('Baz', model.baz.name)
+      in_release = model.in_release(@release)
+      assert_equal('Bar', in_release.name)
+      refute_equal(in_release.object_id, model.object_id)
+
+      @release.as_current { model.reload }
+      in_release = model.in_release(nil)
+      assert_equal('Foo', in_release.name)
+      refute_equal(in_release.object_id, model.object_id)
     end
 
-    def test_activates_with_current_release
-      model = Foo.create!(name: 'Test', active: false)
-      refute(model.activates_with_current_release?)
+    def test_skip_changeset
+      model = Foo.create!(name: 'Foo')
 
-      Release.with_current(@release.id) do
-        model.active = true
-        model.save!
+      @release.as_current do
+        model.skip_changeset { model.update!(name: 'Bar') }
+      end
 
-        model.reload
-        assert(model.activates_with_current_release?)
+      assert_equal('Bar', model.reload.name)
+      assert_equal(0, model.changesets.count)
+
+      assert_raises do
+        @release.as_current do
+          model.skip_changeset do
+            model.update!(name: 'Baz')
+            raise 'test'
+          end
+        end
       end
 
-      model.reload
-      refute(model.activates_with_current_release?)
+      @release.as_current { model.update!(name: 'Qoo') }
+      assert_equal('Baz', model.reload.name)
+      assert_equal(1, model.changesets.count)
     end
 
-    def test_creating_and_activating_embedded
-      model = Foo.create!(name: 'Foo')
+    def test_changesets_with_children
+      model = Foo.create!(
+        name: 'Test',
+        bars: [{ name: 'Bar' }],
+        baz: { name: 'Baz' }
+      )
 
-      embedded = Release.with_current(@release.id) do
-        model.bars.create!(
-          name: 'Test',
-          active: true,
-          activate_with: @release.id
-        )
-      end
+      assert_empty(model.changesets_with_children)
 
-      model.reload
+      @release.as_current { model.update!(name: 'Test 2') }
+      assert_equal(model.changesets, model.changesets_with_children)
+
+      @release.as_current { model.bars.first.update!(name: 'Bar 2') }
+      assert_equal(2, model.changesets_with_children.size)
+      assert_includes(model.changesets_with_children, model.changesets.first)
+      assert_includes(model.changesets_with_children, model.bars.first.changesets.first)
 
-      refute(embedded.active)
-      assert_equal(1, embedded.changesets.length)
-      assert_equal(@release.id, embedded.changesets.first.release_id)
-      assert(embedded.changesets.first.changeset['active'])
-      assert(embedded.changesets.first.document_path.present?)
+      @release.as_current { model.baz.update!(name: 'Baz 2') }
+      assert_equal(3, model.changesets_with_children.size)
+      assert_includes(model.changesets_with_children, model.changesets.first)
+      assert_includes(model.changesets_with_children, model.bars.first.changesets.first)
+      assert_includes(model.changesets_with_children, model.baz.changesets.first)
     end
   end
 end