spree_core 3.3.0.rc1 → 3.3.0.rc2

data/spec/models/spree/promotion/rules/taxon_spec.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Promotion::Rules::Taxon, type: :model do
-  let(:rule){ subject }
-
-  context '#elegible?(order)' do
-    let(:taxon){ create :taxon, name: 'first' }
-    let(:taxon2){ create :taxon, name: 'second'}
-    let(:order){ create :order_with_line_items }
-
-    before do
-      rule.save
-    end
-
-    context 'with any match policy' do
-      before do
-        rule.preferred_match_policy = 'any'
-      end
-
-      it 'is eligible if order does has any prefered taxon' do
-        order.products.first.taxons << taxon
-        rule.taxons << taxon
-        expect(rule).to be_eligible(order)
-      end
-
-      context 'when order contains items from different taxons' do
-        before do
-          order.products.first.taxons << taxon
-          rule.taxons << taxon
-        end
-
-        it 'should act on a product within the eligible taxon' do
-          expect(rule).to be_actionable(order.line_items.last)
-        end
-
-        it 'should not act on a product in another taxon' do
-          order.line_items << create(:line_item, product: create(:product, taxons: [taxon2]))
-          expect(rule).not_to be_actionable(order.line_items.last)
-        end
-      end
-
-      context "when order does not have any prefered taxon" do
-        before { rule.taxons << taxon2 }
-        it { expect(rule).not_to be_eligible(order) }
-        it "sets an error message" do
-          rule.eligible?(order)
-          expect(rule.eligibility_errors.full_messages.first).
-            to eq "You need to add a product from an applicable category before applying this coupon code."
-        end
-      end
-
-      context 'when a product has a taxon child of a taxon rule' do
-        before do
-          taxon.children << taxon2
-          order.products.first.taxons << taxon2
-          rule.taxons << taxon2
-        end
-
-        it{ expect(rule).to be_eligible(order) }
-      end
-    end
-
-    context 'with all match policy' do
-      before do
-        rule.preferred_match_policy = 'all'
-      end
-
-      it 'is eligible order has all prefered taxons' do
-        order.products.first.taxons << taxon2
-        order.products.last.taxons << taxon
-
-        rule.taxons = [taxon, taxon2]
-
-        expect(rule).to be_eligible(order)
-      end
-
-      context "when order does not have all prefered taxons" do
-        before { rule.taxons << taxon  }
-        it { expect(rule).not_to be_eligible(order) }
-        it "sets an error message" do
-          rule.eligible?(order)
-          expect(rule.eligibility_errors.full_messages.first).
-            to eq "You need to add a product from all applicable categories before applying this coupon code."
-        end
-      end
-
-      context 'when a product has a taxon child of a taxon rule' do
-        let(:taxon3){ create :taxon }
-
-        before do
-          taxon.children << taxon2
-          order.products.first.taxons << taxon2
-          order.products.last.taxons << taxon3
-          rule.taxons << taxon2
-          rule.taxons << taxon3
-        end
-
-        it{ expect(rule).to be_eligible(order) }
-      end
-    end
-  end
-end

data/spec/models/spree/promotion/rules/user_logged_in_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Promotion::Rules::UserLoggedIn, type: :model do
-  let(:rule) { Spree::Promotion::Rules::UserLoggedIn.new }
-
-  context "#eligible?(order)" do
-    let(:order) { Spree::Order.new }
-
-    it "should be eligible if order has an associated user" do
-      user = double('User')
-      allow(order).to receive_messages(user: user)
-
-      expect(rule).to be_eligible(order)
-    end
-
-    context "when user is not logged in" do
-      before { allow(order).to receive_messages(user: nil) } # better to be explicit here
-      it { expect(rule).not_to be_eligible(order) }
-      it "sets an error message" do
-        rule.eligible?(order)
-        expect(rule.eligibility_errors.full_messages.first).
-          to eq "You need to login before applying this coupon code."
-      end
-    end
-  end
-end
-

data/spec/models/spree/promotion/rules/user_spec.rb

@@ -1,45 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Promotion::Rules::User, type: :model do
-  let(:rule) { Spree::Promotion::Rules::User.new }
-  let(:test_user) { create :user }
-
-  describe 'Associations' do
-    it 'should have many promotion_rule_users' do
-      is_expected.to have_many(:promotion_rule_users).with_foreign_key(:promotion_rule_id).
-        class_name('Spree::PromotionRuleUser').dependent(:destroy)
-    end
-  end
-
-  context "#eligible?(order)" do
-    let(:order) { Spree::Order.new }
-
-    it "should not be eligible if users are not provided" do
-      expect(rule).not_to be_eligible(order)
-    end
-
-    it "should be eligible if users include user placing the order" do
-      user = mock_model(Spree::LegacyUser)
-      users = [user, mock_model(Spree::LegacyUser)]
-      allow(rule).to receive_messages(users: users)
-      allow(order).to receive_messages(user: user)
-
-      expect(rule).to be_eligible(order)
-    end
-
-    it "should not be eligible if user placing the order is not listed" do
-      allow(order).to receive_messages(user: mock_model(Spree::LegacyUser))
-      users = [mock_model(Spree::LegacyUser), mock_model(Spree::LegacyUser)]
-      allow(rule).to receive_messages(users: users)
-
-      expect(rule).not_to be_eligible(order)
-    end
-
-    # Regression test for #3885
-    it "can assign to user_ids" do
-      user1 = Spree::LegacyUser.create!(email: "test1@example.com")
-      user2 = Spree::LegacyUser.create!(email: "test2@example.com")
-      expect { rule.user_ids = "#{user1.id}, #{user2.id}" }.not_to raise_error
-    end
-  end
-end

data/spec/models/spree/promotion_action_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-describe Spree::PromotionAction, type: :model do
-
-  it "should force developer to implement 'perform' method" do
-    expect { MyAction.new.perform }.to raise_error(NameError)
-  end
-
-end
-

data/spec/models/spree/promotion_category_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-describe Spree::PromotionCategory, type: :model do
-  describe 'validation' do
-    let(:name) { 'Nom' }
-    subject { Spree::PromotionCategory.new name: name }
-
-    context 'when all required attributes are specified' do
-      it { is_expected.to be_valid }
-    end
-
-    context 'when name is missing' do
-      let(:name) { nil }
-      it { is_expected.not_to be_valid }
-    end
-  end
-end

data/spec/models/spree/promotion_handler/cart_spec.rb

@@ -1,102 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module PromotionHandler
-    describe Cart, type: :model do
-      let(:line_item) { create(:line_item) }
-      let(:order) { line_item.order }
-
-      let(:promotion) { Promotion.create(name: "At line items") }
-      let(:calculator) { Calculator::FlatPercentItemTotal.new(preferred_flat_percent: 10) }
-
-      subject { Cart.new(order, line_item) }
-
-      context "activates in LineItem level" do
-        let!(:action) { Promotion::Actions::CreateItemAdjustments.create(promotion: promotion, calculator: calculator) }
-        let(:adjustable) { line_item }
-
-        shared_context "creates the adjustment" do
-          it "creates the adjustment" do
-            expect {
-              subject.activate
-            }.to change { adjustable.adjustments.count }.by(1)
-          end
-        end
-
-        context "promotion with no rules" do
-          include_context "creates the adjustment"
-        end
-
-        context "promotion includes item involved" do
-          let!(:rule) { Promotion::Rules::Product.create(products: [line_item.product], promotion: promotion) }
-
-          include_context "creates the adjustment"
-        end
-
-        context "promotion has item total rule" do
-          let(:shirt) { create(:product) }
-          let!(:rule) { Promotion::Rules::ItemTotal.create(preferred_operator_min: 'gt', preferred_amount_min: 50, preferred_operator_max: 'lt', preferred_amount_max: 150, promotion: promotion) }
-
-          before do
-            # Makes the order eligible for this promotion
-            order.item_total = 100
-            order.save
-          end
-
-          include_context "creates the adjustment"
-        end
-      end
-
-      context "activates in Order level" do
-        let!(:action) { Promotion::Actions::CreateAdjustment.create(promotion: promotion, calculator: calculator) }
-        let(:adjustable) { order }
-
-        shared_context "creates the adjustment" do
-          it "creates the adjustment" do
-            expect {
-              subject.activate
-            }.to change { adjustable.adjustments.count }.by(1)
-          end
-        end
-
-        context "promotion with no rules" do
-          before do
-            # Gives the calculator something to discount
-            order.item_total = 10
-            order.save
-          end
-
-          include_context "creates the adjustment"
-        end
-
-        context "promotion has item total rule" do
-          let(:shirt) { create(:product) }
-          let!(:rule) { Promotion::Rules::ItemTotal.create(preferred_operator_min: 'gt', preferred_amount_min: 50, preferred_operator_max: 'lt', preferred_amount_max: 150, promotion: promotion) }
-
-          before do
-            # Makes the order eligible for this promotion
-            order.item_total = 100
-            order.save
-          end
-
-          include_context "creates the adjustment"
-        end
-      end
-
-      context "activates promotions associated with the order" do
-        let(:promo) { create :promotion_with_item_adjustment, adjustment_rate: 5, code: 'promo' }
-        let(:adjustable) { line_item }
-
-        before do
-          order.promotions << promo
-        end
-
-        it "creates the adjustment" do
-          expect {
-            subject.activate
-          }.to change { adjustable.adjustments.count }.by(1)
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/promotion_handler/coupon_spec.rb

@@ -1,323 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  module PromotionHandler
-    describe Coupon, type: :model do
-      let(:order) { double("Order", coupon_code: "10off").as_null_object }
-
-      subject { Coupon.new(order) }
-
-      it "returns self in apply" do
-        expect(subject.apply).to be_a Coupon
-      end
-
-      context 'status messages' do
-        let(:coupon) { Coupon.new(order) }
-
-        describe "#set_success_code" do
-          let(:status) { :coupon_code_applied }
-          subject { coupon.set_success_code status }
-
-          it 'should have status_code' do
-            subject
-            expect(coupon.status_code).to eq(status)
-          end
-
-          it 'should have success message' do
-            subject
-            expect(coupon.success).to eq(Spree.t(status))
-          end
-        end
-
-        describe "#set_error_code" do
-          let(:status) { :coupon_code_not_found }
-
-          subject { coupon.set_error_code status }
-
-          it 'should have status_code' do
-            subject
-            expect(coupon.status_code).to eq(status)
-          end
-
-          it 'should have error message' do
-            subject
-            expect(coupon.error).to eq(Spree.t(status))
-          end
-        end
-      end
-
-      context "coupon code promotion doesnt exist" do
-        before { Promotion.create name: "promo", code: nil }
-
-        it "doesnt fetch any promotion" do
-          expect(subject.promotion).to be_blank
-        end
-
-        context "with no actions defined" do
-          before { Promotion.create name: "promo", code: "10off" }
-
-          it "populates error message" do
-            subject.apply
-            expect(subject.error).to eq Spree.t(:coupon_code_not_found)
-          end
-        end
-      end
-
-      context "existing coupon code promotion" do
-        let!(:promotion) { Promotion.create name: "promo", code: "10off"  }
-        let!(:action) { Promotion::Actions::CreateItemAdjustments.create(promotion: promotion, calculator: calculator) }
-        let(:calculator) { Calculator::FlatRate.new(preferred_amount: 10) }
-
-        it "fetches with given code" do
-          expect(subject.promotion).to eq promotion
-        end
-
-        context "with a per-item adjustment action" do
-          let(:order) { create(:order_with_line_items, line_items_count: 3) }
-
-          context "right coupon given" do
-            context "with correct coupon code casing" do
-              before { allow(order).to receive_messages coupon_code: "10off" }
-
-              it "successfully activates promo" do
-                expect(order.total).to eq(130)
-                subject.apply
-                expect(subject.success).to be_present
-                order.line_items.each do |line_item|
-                  expect(line_item.adjustments.count).to eq(1)
-                end
-                # Ensure that applying the adjustment actually affects the order's total!
-                expect(order.reload.total).to eq(100)
-              end
-
-              it "coupon already applied to the order" do
-                subject.apply
-                expect(subject.success).to be_present
-                subject.apply
-                expect(subject.error).to eq Spree.t(:coupon_code_already_applied)
-              end
-            end
-
-            # Regression test for #4211
-            context "with incorrect coupon code casing" do
-              before { allow(order).to receive_messages coupon_code: "10OFF" }
-              it "successfully activates promo" do
-                expect(order.total).to eq(130)
-                subject.apply
-                expect(subject.success).to be_present
-                order.line_items.each do |line_item|
-                  expect(line_item.adjustments.count).to eq(1)
-                end
-                # Ensure that applying the adjustment actually affects the order's total!
-                expect(order.reload.total).to eq(100)
-              end
-            end
-          end
-
-          context "coexists with a non coupon code promo" do
-            let!(:order) { Order.create }
-
-            before do
-              allow(order).to receive_messages coupon_code: "10off"
-              calculator = Calculator::FlatRate.new(preferred_amount: 10)
-              general_promo = Promotion.create name: "General Promo"
-              general_action = Promotion::Actions::CreateItemAdjustments.create(promotion: general_promo, calculator: calculator)
-
-              order.contents.add create(:variant)
-            end
-
-            # regression spec for #4515
-            it "successfully activates promo" do
-              subject.apply
-              expect(subject).to be_successful
-            end
-          end
-        end
-
-        context "with a free-shipping adjustment action" do
-          let!(:action) { Promotion::Actions::FreeShipping.create(promotion: promotion) }
-          context "right coupon code given" do
-            let(:order) { create(:order_with_line_items, line_items_count: 3) }
-
-            before { allow(order).to receive_messages coupon_code: "10off" }
-
-            it "successfully activates promo" do
-              expect(order.total).to eq(130)
-              subject.apply
-              expect(subject.success).to be_present
-
-              expect(order.shipment_adjustments.count).to eq(1)
-            end
-
-            it "coupon already applied to the order" do
-              subject.apply
-              expect(subject.success).to be_present
-              subject.apply
-              expect(subject.error).to eq Spree.t(:coupon_code_already_applied)
-            end
-          end
-        end
-
-        context "with a whole-order adjustment action" do
-          let!(:action) { Promotion::Actions::CreateAdjustment.create(promotion: promotion, calculator: calculator) }
-          context "right coupon given" do
-            let(:order) { create(:order) }
-            let(:calculator) { Calculator::FlatRate.new(preferred_amount: 10) }
-
-            before do
-              allow(order).to receive_messages({
-                coupon_code: "10off",
-                # These need to be here so that promotion adjustment "wins"
-                item_total: 50,
-                ship_total: 10
-              })
-            end
-
-            it "successfully activates promo" do
-              subject.apply
-              expect(subject.success).to be_present
-              expect(order.adjustments.count).to eq(1)
-            end
-
-            it "coupon already applied to the order" do
-              subject.apply
-              expect(subject.success).to be_present
-              subject.apply
-              expect(subject.error).to eq Spree.t(:coupon_code_already_applied)
-            end
-
-            it "coupon fails to activate" do
-              allow_any_instance_of(Spree::Promotion).to receive(:activate).and_return false
-              subject.apply
-              expect(subject.error).to eq Spree.t(:coupon_code_unknown_error)
-            end
-
-
-            it "coupon code hit max usage" do
-              promotion.update_column(:usage_limit, 1)
-              coupon = Coupon.new(order)
-              coupon.apply
-              expect(coupon.successful?).to be true
-
-              order_2 = create(:order)
-              allow(order_2).to receive_messages coupon_code: "10off"
-              coupon = Coupon.new(order_2)
-              coupon.apply
-              expect(coupon.successful?).to be false
-              expect(coupon.error).to eq Spree.t(:coupon_code_max_usage)
-            end
-
-            context "when the a new coupon is less good" do
-              let!(:action_5) { Promotion::Actions::CreateAdjustment.create(promotion: promotion_5, calculator: calculator_5) }
-              let(:calculator_5) { Calculator::FlatRate.new(preferred_amount: 5) }
-              let!(:promotion_5) { Promotion.create name: "promo", code: "5off"  }
-
-              it 'notifies of better deal' do
-                subject.apply
-                allow(order).to receive_messages( { coupon_code: '5off' } )
-                coupon = Coupon.new(order).apply
-                expect(coupon.error).to eq Spree.t(:coupon_code_better_exists)
-              end
-            end
-          end
-        end
-
-        context "for an order with taxable line items" do
-          before(:each) do
-            @country = create(:country)
-            @zone = create(:zone, name: "Country Zone", default_tax: true, zone_members: [])
-            @zone.zone_members.create(zoneable: @country)
-            @category = Spree::TaxCategory.create name: "Taxable Foo"
-            @rate1 = Spree::TaxRate.create(
-                amount: 0.10,
-                calculator: Spree::Calculator::DefaultTax.create,
-                tax_category: @category,
-                zone: @zone
-            )
-
-            @order = Spree::Order.create!
-            allow(@order).to receive_messages coupon_code: "10off"
-          end
-          context "and the product price is less than promo discount" do
-            before(:each) do
-              3.times do |i|
-                taxable = create(:product, tax_category: @category, price: 9.0)
-                @order.contents.add(taxable.master, 1)
-              end
-            end
-            it "successfully applies the promo" do
-              # 3 * (9 + 0.9)
-              expect(@order.total).to eq(29.7)
-              coupon = Coupon.new(@order)
-              coupon.apply
-              expect(coupon.success).to be_present
-              # 3 * ((9 - [9,10].min) + 0)
-              expect(@order.reload.total).to eq(0)
-              expect(@order.additional_tax_total).to eq(0)
-            end
-          end
-          context "and the product price is greater than promo discount" do
-            before(:each) do
-              3.times do |i|
-                taxable = create(:product, tax_category: @category, price: 11.0)
-                @order.contents.add(taxable.master, 2)
-              end
-            end
-            it "successfully applies the promo" do
-              # 3 * (22 + 2.2)
-              expect(@order.total.to_f).to eq(72.6)
-              coupon = Coupon.new(@order)
-              coupon.apply
-              expect(coupon.success).to be_present
-              # 3 * ( (22 - 10) + 1.2)
-              expect(@order.reload.total).to eq(39.6)
-              expect(@order.additional_tax_total).to eq(3.6)
-            end
-          end
-          context "and multiple quantity per line item" do
-            before(:each) do
-              twnty_off = Promotion.create name: "promo", code: "20off"
-              twnty_off_calc = Calculator::FlatRate.new(preferred_amount: 20)
-              Promotion::Actions::CreateItemAdjustments.create(promotion: twnty_off,
-                                                               calculator: twnty_off_calc)
-
-              allow(@order).to receive(:coupon_code).and_call_original
-              allow(@order).to receive_messages coupon_code: "20off"
-              3.times do |i|
-                taxable = create(:product, tax_category: @category, price: 10.0)
-                @order.contents.add(taxable.master, 2)
-              end
-            end
-            it "successfully applies the promo" do
-              # 3 * ((2 * 10) + 2.0)
-              expect(@order.total.to_f).to eq(66)
-              coupon = Coupon.new(@order)
-              coupon.apply
-              expect(coupon.success).to be_present
-              # 0
-              expect(@order.reload.total).to eq(0)
-              expect(@order.additional_tax_total).to eq(0)
-            end
-          end
-        end
-
-        context "with a CreateLineItems action" do
-          let!(:variant) { create(:variant) }
-          let!(:action) { Promotion::Actions::CreateLineItems.create(promotion: promotion, promotion_action_line_items_attributes: { :'0' => { variant_id: variant.id }}) }
-          let(:order) { create(:order) }
-
-          before do
-            allow(order).to receive_messages(coupon_code: "10off")
-          end
-
-          it "successfully activates promo" do
-            subject.apply
-            expect(subject.success).to be_present
-            expect(order.line_items.pluck(:variant_id)).to include(variant.id)
-          end
-        end
-
-      end
-    end
-  end
-end