solidus_core 2.0.3 → 2.1.0.beta1

data/spec/models/spree/permission_sets/user_management_spec.rb

@@ -20,8 +20,15 @@ describe Spree::PermissionSets::UserManagement do
     it { is_expected.to be_able_to(:orders, Spree.user_class) }
     it { is_expected.to be_able_to(:items, Spree.user_class) }
 
-    it { is_expected.to be_able_to(:update_email, Spree.user_class.new(spree_roles: [])) }
-    it { is_expected.not_to be_able_to(:update_email, Spree.user_class.new(spree_roles: [create(:role)])) }
+    context 'when the user does not have a role' do
+      let(:user) { create(:user) }
+      it { is_expected.to be_able_to(:update_email, user) }
+    end
+
+    context 'when the user has a role' do
+      let(:user) { create(:user, spree_roles: [create(:role)]) }
+      it { is_expected.not_to be_able_to(:update_email, user) }
+    end
 
     it { is_expected.not_to be_able_to(:delete, Spree.user_class) }
     it { is_expected.not_to be_able_to(:destroy, Spree.user_class) }

data/spec/models/spree/price_spec.rb

@@ -55,6 +55,12 @@ describe Spree::Price, type: :model do
         it { is_expected.to be_valid }
       end
 
+      context 'when country iso is an empty string' do
+        let(:country_iso) { "" }
+
+        it { is_expected.to be_valid }
+      end
+
       context 'when country iso is a country code' do
         let!(:country) { create(:country, iso: "DE") }
         let(:country_iso) { "DE" }
@@ -69,9 +75,18 @@ describe Spree::Price, type: :model do
       end
     end
 
+    describe "country_iso=" do
+      let(:price) { Spree::Price.new(country_iso: "de") }
+
+      it "assigns nil if passed nil" do
+        price.country_iso = nil
+        expect(price.country_iso).to be_nil
+      end
+    end
+
     describe '#country' do
       let!(:country) { create(:country, iso: "DE") }
-      let(:price) { create(:price, country_iso: "DE", is_default: false) }
+      let(:price) { create(:price, country_iso: "DE") }
 
       it 'returns the country object' do
         expect(price.country).to eq(country)

data/spec/models/spree/product_spec.rb

@@ -429,81 +429,6 @@ describe Spree::Product, type: :model do
     end
   end
 
-  context '#create' do
-    let!(:prototype) { create(:prototype) }
-    let!(:product) { Spree::Product.new(name: "Foo", price: 1.99, shipping_category_id: create(:shipping_category).id) }
-
-    before { product.prototype_id = prototype.id }
-
-    context "when prototype is supplied" do
-      it "should create properties based on the prototype" do
-        product.save
-        expect(product.properties.count).to eq(1)
-      end
-    end
-
-    context "when prototype with option types is supplied" do
-      def build_option_type_with_values(name, values)
-        ot = create(:option_type, name: name)
-        values.each do |val|
-          ot.option_values.create(name: val.downcase, presentation: val)
-        end
-        ot
-      end
-
-      let(:prototype) do
-        size = build_option_type_with_values("size", %w(Small Medium Large))
-        create(:prototype, name: "Size", option_types: [size])
-      end
-
-      let(:option_values_hash) do
-        hash = {}
-        prototype.option_types.each do |i|
-          hash[i.id.to_s] = i.option_value_ids
-        end
-        hash
-      end
-
-      it "should create option types based on the prototype" do
-        product.save
-        expect(product.option_type_ids.length).to eq(1)
-        expect(product.option_type_ids).to eq(prototype.option_type_ids)
-      end
-
-      it "should create product option types based on the prototype" do
-        product.save
-        expect(product.product_option_types.pluck(:option_type_id)).to eq(prototype.option_type_ids)
-      end
-
-      it "should create variants from an option values hash with one option type" do
-        product.option_values_hash = option_values_hash
-        product.save
-        expect(product.variants.length).to eq(3)
-      end
-
-      it "should still create variants when option_values_hash is given but prototype id is nil" do
-        product.option_values_hash = option_values_hash
-        product.prototype_id = nil
-        product.save
-        expect(product.option_type_ids.length).to eq(1)
-        expect(product.option_type_ids).to eq(prototype.option_type_ids)
-        expect(product.variants.length).to eq(3)
-      end
-
-      it "should create variants from an option values hash with multiple option types" do
-        color = build_option_type_with_values("color", %w(Red Green Blue))
-        logo  = build_option_type_with_values("logo", %w(Ruby Rails Nginx))
-        option_values_hash[color.id.to_s] = color.option_value_ids
-        option_values_hash[logo.id.to_s] = logo.option_value_ids
-        product.option_values_hash = option_values_hash
-        product.save
-        product.reload
-        expect(product.option_type_ids.length).to eq(3)
-        expect(product.variants.length).to eq(27)
-      end
-    end
-  end
-
   context "#images" do
     let(:product) { create(:product) }
     let(:image) { File.open(File.expand_path('../../../fixtures/thinking-cat.jpg', __FILE__)) }

data/spec/models/spree/promotion/actions/create_adjustment_spec.rb

@@ -58,6 +58,26 @@ describe Spree::Promotion::Actions::CreateAdjustment, type: :model do
     end
   end
 
+  describe '#remove_from' do
+    let(:action) { promotion.actions.first! }
+    let(:promotion) { create(:promotion, :with_order_adjustment) }
+
+    let!(:unrelated_adjustment) { create(:adjustment, order: order, source: nil) }
+
+    before do
+      action.perform(payload)
+      @action_adjustment = order.adjustments.where(source: action).first!
+    end
+
+    it 'removes the action adjustment' do
+      expect(order.adjustments).to match_array([unrelated_adjustment, @action_adjustment])
+
+      action.remove_from(order)
+
+      expect(order.adjustments).to eq([unrelated_adjustment])
+    end
+  end
+
   context "#destroy" do
     before(:each) do
       action.calculator = Spree::Calculator::FlatRate.new(preferred_amount: 10)

data/spec/models/spree/promotion/actions/create_item_adjustments_spec.rb

@@ -4,11 +4,11 @@ module Spree
   class Promotion
     module Actions
       describe CreateItemAdjustments, type: :model do
-        let(:order) { create(:order) }
+        let(:order) { create(:order_with_line_items, line_items_count: 1) }
         let(:promotion) { create(:promotion, :with_line_item_adjustment, adjustment_rate: adjustment_amount) }
         let(:adjustment_amount) { 10 }
         let(:action) { promotion.actions.first! }
-        let!(:line_item) { create(:line_item, order: order) }
+        let(:line_item) { order.line_items.to_a.first }
         let(:payload) { { order: order, promotion: promotion } }
 
         before do
@@ -122,32 +122,56 @@ module Spree
           end
         end
 
+        describe '#remove_from' do
+          # this adjustment should not get removed
+          let!(:other_adjustment) { create(:adjustment, adjustable: line_item, order: order, source: nil) }
+
+          before do
+            action.perform(payload)
+            @action_adjustment = line_item.adjustments.where(source: action).first!
+          end
+
+          it 'removes the action adjustment' do
+            expect(line_item.adjustments).to match_array([other_adjustment, @action_adjustment])
+
+            action.remove_from(order)
+
+            expect(line_item.adjustments).to eq([other_adjustment])
+          end
+        end
+
         context "#destroy" do
           let!(:action) { promotion.actions.first }
           let(:other_action) { other_promotion.actions.first }
           let(:promotion) { create(:promotion, :with_line_item_adjustment) }
           let(:other_promotion) { create(:promotion, :with_line_item_adjustment) }
 
-          it "destroys adjustments for incompleted orders" do
-            order = Order.create
-            action.adjustments.create!(label: "Check", amount: 0, order: order, adjustable: order)
+          context 'with incomplete orders' do
+            let(:order) { create(:order) }
 
-            expect {
-              action.destroy
-            }.to change { Adjustment.count }.by(-1)
+            it 'destroys adjustments' do
+              order.adjustments.create!(label: 'Check', amount: 0, order: order, source: action)
+
+              expect {
+                action.destroy
+              }.to change { Adjustment.count }.by(-1)
+            end
           end
 
-          it "nullifies adjustments for completed orders" do
-            order = Order.create(completed_at: Time.current)
-            adjustment = action.adjustments.create!(label: "Check", amount: 0, order: order, adjustable: order)
+          context 'with complete orders' do
+            let(:order) { create(:completed_order_with_totals) }
 
-            expect {
-              action.destroy
-            }.to change { adjustment.reload.source_id }.from(action.id).to nil
+            it 'nullifies adjustments for completed orders' do
+              adjustment = order.adjustments.create!(label: 'Check', amount: 0, order: order, source: action)
+
+              expect {
+                action.destroy
+              }.to change { adjustment.reload.source_id }.from(action.id).to nil
+            end
           end
 
           it "doesnt mess with unrelated adjustments" do
-            other_action.adjustments.create!(label: "Check", amount: 0, order: order, adjustable: order)
+            order.adjustments.create!(label: "Check", amount: 0, order: order, source: action)
 
             expect {
               action.destroy

data/spec/models/spree/promotion/actions/create_quantity_adjustments_spec.rb

@@ -4,36 +4,53 @@ module Spree::Promotion::Actions
   RSpec.describe CreateQuantityAdjustments do
     let(:action) { CreateQuantityAdjustments.create!(calculator: calculator, promotion: promotion) }
 
-    let(:order) { FactoryGirl.create :order }
+    let(:order) do
+      create(
+        :order_with_line_items,
+        line_items_attributes: line_items_attributes
+      )
+    end
+
+    let(:line_items_attributes) do
+      [
+        { price: 10, quantity: quantity }
+      ]
+    end
+
+    let(:quantity) { 1 }
     let(:promotion) { FactoryGirl.create :promotion }
 
     describe "#compute_amount" do
       subject { action.compute_amount(line_item) }
 
-      let!(:item_a) { FactoryGirl.create :line_item, order: order, quantity: quantity, price: 10 }
-
       context "with a flat rate adjustment" do
         let(:calculator) { FactoryGirl.create :flat_rate_calculator, preferred_amount: 5 }
 
         context "with a quantity group of 2" do
-          let(:line_item) { item_a }
+          let(:line_item) { order.line_items.first }
+
           before { action.preferred_group_size = 2 }
+
           context "and an item with a quantity of 0" do
             let(:quantity) { 0 }
             it { is_expected.to eq 0 }
           end
+
           context "and an item with a quantity of 1" do
             let(:quantity) { 1 }
             it { is_expected.to eq 0 }
           end
+
           context "and an item with a quantity of 2" do
             let(:quantity) { 2 }
             it { is_expected.to eq(-10) }
           end
+
           context "and an item with a quantity of 3" do
             let(:quantity) { 3 }
             it { is_expected.to eq(-10) }
           end
+
           context "and an item with a quantity of 4" do
             let(:quantity) { 4 }
             it { is_expected.to eq(-20) }
@@ -41,36 +58,51 @@ module Spree::Promotion::Actions
         end
 
         context "with a quantity group of 3" do
-          let(:quantity) { 2 }
-          let!(:item_b) { FactoryGirl.create :line_item, order: order, quantity: 1 }
-          let!(:item_c) { FactoryGirl.create :line_item, order: order, quantity: 1 }
           before { action.preferred_group_size = 3 }
+
           context "and 2x item A, 1x item B and 1x item C" do
+            let(:line_items_attributes) do
+              [
+                { price: 10, quantity: 2 },
+                { price: 10, quantity: 1 },
+                { price: 10, quantity: 1 },
+              ]
+            end
+
             before { action.perform({ order: order, promotion: promotion }) }
+
             describe "the adjustment for the first item" do
-              let(:line_item) { item_a }
+              let(:line_item) { order.line_items.first }
               it { is_expected.to eq(-10) }
             end
             describe "the adjustment for the second item" do
-              let(:line_item) { item_b }
+              let(:line_item) { order.line_items.second }
               it { is_expected.to eq(-5) }
             end
             describe "the adjustment for the third item" do
-              let(:line_item) { item_c }
+              let(:line_item) { order.line_items.third }
               it { is_expected.to eq 0 }
             end
           end
         end
 
         context "with multiple orders using the same action" do
-          let(:quantity) { 2 }
-          let(:line_item) { item_a }
+          let(:other_order) do
+            create(
+              :order_with_line_items,
+              line_items_attributes: [
+                { quantity: 3 }
+            ]
+            )
+          end
+
+          let(:line_item) { other_order.line_items.first }
+
           before do
             action.preferred_group_size = 2
-            other_order = FactoryGirl.create :order
-            FactoryGirl.create :line_item, order: other_order, quantity: 3
             action.perform({ order: other_order, promotion: promotion })
           end
+
           it { is_expected.to eq(-10) }
         end
       end
@@ -78,38 +110,187 @@ module Spree::Promotion::Actions
       context "with a percentage based adjustment" do
         let(:calculator) { FactoryGirl.create :percent_on_item_calculator, preferred_percent: 10 }
 
+        let(:line_items_attributes) do
+          [
+            { price: 10, quantity: 1 }.merge(line_one_options),
+            { price: 10, quantity: 1 }.merge(line_two_options),
+          ]
+        end
+
+        let(:line_one_options) { {} }
+        let(:line_two_options) { {} }
+
         context "with a quantity group of 3" do
           before do
             action.preferred_group_size = 3
             action.perform({ order: order, promotion: promotion })
           end
+
           context "and 2x item A and 1x item B" do
-            let(:quantity) { 2 }
-            let!(:item_b) { FactoryGirl.create :line_item, order: order, quantity: 1, price: 10 }
+            let(:line_one_options) { { quantity: 2 } }
+
             describe "the adjustment for the first item" do
-              let(:line_item) { item_a }
+              let(:line_item) { order.line_items.first }
               it { is_expected.to eq(-2) }
             end
             describe "the adjustment for the second item" do
-              let(:line_item) { item_b }
+              let(:line_item) { order.line_items.second }
               it { is_expected.to eq(-1) }
             end
           end
 
           context "and the items cost different amounts" do
-            let(:quantity) { 3 }
-            let!(:item_b) { FactoryGirl.create :line_item, order: order, quantity: 1, price: 20 }
+            let(:line_one_options) { { quantity: 3 } }
+            let(:line_two_options) { { price: 20 } }
+
             describe "the adjustment for the first item" do
-              let(:line_item) { item_a }
+              let(:line_item) { order.line_items.first }
               it { is_expected.to eq(-3) }
             end
             describe "the adjustment for the second item" do
-              let(:line_item) { item_b }
+              let(:line_item) { order.line_items.second }
               it { is_expected.to eq 0 }
             end
           end
         end
       end
+
+      context "with a tiered percentage based adjustment" do
+        let(:tiers) do
+          {
+            20 => 20,
+            40 => 30
+          }
+        end
+
+        let(:calculator) do
+          Spree::Calculator::TieredPercent.create(preferred_base_percent: 10, preferred_tiers: tiers)
+        end
+        let(:line_items_attributes) do
+          [
+            { price: 10, quantity: 1 }.merge(line_one_options),
+            { price: 10, quantity: 1 }.merge(line_two_options),
+          ]
+        end
+
+        let(:line_one_options) { {} }
+        let(:line_two_options) { {} }
+
+        context "with a quantity group of 3" do
+          before do
+            action.preferred_group_size = 3
+            action.perform({ order: order, promotion: promotion })
+          end
+
+          context "and 2x item A and 1x item B" do
+            let(:line_one_options) { { quantity: 2 } }
+
+            context "when amount falls within the first tier" do
+              describe "the adjustment for the first item" do
+                let(:line_item) { order.line_items.first }
+                it { is_expected.to eq(-4) }
+              end
+              describe "the adjustment for the second item" do
+                let(:line_item) { order.line_items.second }
+                it { is_expected.to eq(-2) }
+              end
+            end
+
+            context "when amount falls within the second tier" do
+              let(:line_two_options) { { price: 20 } }
+
+              describe "the adjustment for the first item" do
+                let(:line_item) { order.line_items.first }
+                it { is_expected.to eq(-6) }
+              end
+
+              describe "the adjustment for the second item" do
+                let(:line_item) { order.line_items.second }
+                it { is_expected.to eq(-6) }
+              end
+            end
+          end
+        end
+      end
+    end
+
+    # Regression test for https://github.com/solidusio/solidus/pull/1591
+    context "with unsaved line_item changes" do
+      let(:calculator) { FactoryGirl.create :flat_rate_calculator }
+      let(:line_item) { order.line_items.first }
+
+      before do
+        order.line_items.first.promo_total = -11
+        action.compute_amount(line_item)
+      end
+
+      it "doesn't reload the line_items association" do
+        expect(order.line_items.first.promo_total).to eq -11
+      end
+    end
+
+    # Regression test for https://github.com/solidusio/solidus/pull/1591
+    context "applied to the order" do
+      let(:calculator) { FactoryGirl.create :flat_rate_calculator }
+
+      before do
+        action.perform(order: order, promotion: promotion)
+        order.update!
+      end
+
+      it 'updates the order totals' do
+        expect(order).to have_attributes(
+          total: 100,
+          adjustment_total: -10
+        )
+      end
+
+      context "after updating item quantity" do
+        before do
+          order.line_items.first.update!(quantity: 2, price: 30)
+          order.update!
+        end
+
+        it 'updates the order totals' do
+          expect(order).to have_attributes(
+            total: 140,
+            adjustment_total: -20
+          )
+        end
+      end
+
+      context "after updating promotion amount" do
+        before do
+          calculator.update!(preferred_amount: 5)
+          order.update!
+        end
+
+        it 'updates the order totals' do
+          expect(order).to have_attributes(
+            total: 105,
+            adjustment_total: -5
+          )
+        end
+      end
+    end
+
+    describe Spree::Promotion::Actions::CreateQuantityAdjustments::PartialLineItem do
+      let!(:item) { FactoryGirl.create :line_item, order: order, quantity: quantity, price: 10 }
+      let(:quantity) { 5 }
+
+      subject { described_class.new(item) }
+
+      it "has a reference to the parent order" do
+        expect(subject.order.id).to eq order.id
+      end
+
+      it "uses the `line_item.price` as a `line_item.amount`" do
+        expect(subject.amount).to eq item.price
+      end
+
+      it "has a currency" do
+        expect(subject.currency).to eq item.currency
+      end
     end
   end
 end