spree_core 3.1.5 → 3.1.6

data/spec/models/spree/address_spec.rb

@@ -1,291 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Address, :type => :model do
-
-  subject { Spree::Address }
-
-  describe "clone" do
-    it "creates a copy of the address with the exception of the id, updated_at and created_at attributes" do
-      state = create(:state)
-      original = create(:address,
-                         :address1 => 'address1',
-                         :address2 => 'address2',
-                         :alternative_phone => 'alternative_phone',
-                         :city => 'city',
-                         :country => Spree::Country.first,
-                         :firstname => 'firstname',
-                         :lastname => 'lastname',
-                         :company => 'company',
-                         :phone => 'phone',
-                         :state_id => state.id,
-                         :state_name => state.name,
-                         :zipcode => '10001')
-
-      cloned = original.clone
-
-      expect(cloned.address1).to eq(original.address1)
-      expect(cloned.address2).to eq(original.address2)
-      expect(cloned.alternative_phone).to eq(original.alternative_phone)
-      expect(cloned.city).to eq(original.city)
-      expect(cloned.country_id).to eq(original.country_id)
-      expect(cloned.firstname).to eq(original.firstname)
-      expect(cloned.lastname).to eq(original.lastname)
-      expect(cloned.company).to eq(original.company)
-      expect(cloned.phone).to eq(original.phone)
-      expect(cloned.state_id).to eq(original.state_id)
-      expect(cloned.state_name).to eq(original.state_name)
-      expect(cloned.zipcode).to eq(original.zipcode)
-
-      expect(cloned.id).not_to eq(original.id)
-      expect(cloned.created_at).not_to eq(original.created_at)
-      expect(cloned.updated_at).not_to eq(original.updated_at)
-    end
-  end
-
-  context "aliased attributes" do
-    let(:address) { Spree::Address.new }
-
-    it "first_name" do
-      address.firstname = "Ryan"
-      expect(address.first_name).to eq("Ryan")
-    end
-
-    it "last_name" do
-      address.lastname = "Bigg"
-      expect(address.last_name).to eq("Bigg")
-    end
-  end
-
-  context "validation" do
-    before do
-      configure_spree_preferences do |config|
-        config.address_requires_state = true
-      end
-    end
-
-    let(:country) { mock_model(Spree::Country, :states => [state], :states_required => true) }
-    let(:state) { stub_model(Spree::State, :name => 'maryland', :abbr => 'md') }
-    let(:address) { build(:address, :country => country) }
-
-    before do
-      allow(country.states).to receive_messages :find_all_by_name_or_abbr => [state]
-    end
-
-    it "state_name is not nil and country does not have any states" do
-      address.state = nil
-      address.state_name = 'alabama'
-      expect(address).to be_valid
-    end
-
-    it "errors when state_name is nil" do
-      address.state_name = nil
-      address.state = nil
-      expect(address).not_to be_valid
-    end
-
-    it "full state name is in state_name and country does contain that state" do
-      address.state_name = 'alabama'
-      # called by state_validate to set up state_id.
-      # Perhaps this should be a before_validation instead?
-      expect(address).to be_valid
-      expect(address.state).not_to be_nil
-      expect(address.state_name).to be_nil
-    end
-
-    it "state abbr is in state_name and country does contain that state" do
-      address.state_name = state.abbr
-      expect(address).to be_valid
-      expect(address.state_id).not_to be_nil
-      expect(address.state_name).to be_nil
-    end
-
-    it "state is entered but country does not contain that state" do
-      address.state = state
-      address.country = stub_model(Spree::Country, :states_required => true)
-      address.valid?
-      expect(address.errors["state"]).to eq(['is invalid'])
-    end
-
-    it "both state and state_name are entered but country does not contain the state" do
-      address.state = state
-      address.state_name = 'maryland'
-      address.country = stub_model(Spree::Country, :states_required => true)
-      expect(address).to be_valid
-      expect(address.state_id).to be_nil
-    end
-
-    it "both state and state_name are entered and country does contain the state" do
-      address.state = state
-      address.state_name = 'maryland'
-      expect(address).to be_valid
-      expect(address.state_name).to be_nil
-    end
-
-    it "address_requires_state preference is false" do
-      Spree::Config.set :address_requires_state => false
-      address.state = nil
-      address.state_name = nil
-      expect(address).to be_valid
-    end
-
-    it "requires phone" do
-      address.phone = ""
-      address.valid?
-      expect(address.errors["phone"]).to eq(["can't be blank"])
-    end
-
-    it "requires zipcode" do
-      address.zipcode = ""
-      address.valid?
-      expect(address.errors['zipcode']).to include("can't be blank")
-    end
-
-    context "zipcode validation" do
-      it "validates the zipcode" do
-        allow(address.country).to receive(:iso).and_return('US')
-        address.zipcode = 'abc'
-        address.valid?
-        expect(address.errors['zipcode']).to include('is invalid')
-      end
-
-      it "accepts a zip code with surrounding white space" do
-        allow(address.country).to receive(:iso).and_return('US')
-        address.zipcode = ' 12345 '
-        address.valid?
-        expect(address.errors['zipcode']).not_to include('is invalid')
-      end
-
-      context 'does not validate' do
-        it 'does not have a country' do
-          address.country = nil
-          address.valid?
-          expect(address.errors['zipcode']).not_to include('is invalid')
-        end
-
-        it 'does not have an iso' do
-          allow(address.country).to receive(:iso).and_return(nil)
-          address.valid?
-          expect(address.errors['zipcode']).not_to include('is invalid')
-        end
-
-        it 'does not have a zipcode' do
-          address.zipcode = ""
-          address.valid?
-          expect(address.errors['zipcode']).not_to include('is invalid')
-        end
-
-        it 'does not have a supported country iso' do
-          allow(address.country).to receive(:iso).and_return('BO')
-          address.valid?
-          expect(address.errors['zipcode']).not_to include('is invalid')
-        end
-      end
-    end
-
-    context "phone not required" do
-      before { allow(address).to receive_messages require_phone?: false }
-
-      it "shows no errors when phone is blank" do
-        address.phone = ""
-        address.valid?
-        expect(address.errors[:phone].size).to eq 0
-      end
-    end
-
-    context "zipcode not required" do
-      before { allow(address).to receive_messages require_zipcode?: false }
-
-      it "shows no errors when phone is blank" do
-        address.zipcode = ""
-        address.valid?
-        expect(address.errors[:zipcode].size).to eq 0
-      end
-    end
-  end
-
-  context ".default" do
-    context "no user given" do
-      before do
-        @default_country_id = Spree::Config[:default_country_id]
-        new_country = create(:country)
-        Spree::Config[:default_country_id] = new_country.id
-      end
-
-      after do
-        Spree::Config[:default_country_id] = @default_country_id
-      end
-
-      it "sets up a new record with Spree::Config[:default_country_id]" do
-        expect(Spree::Address.default.country).to eq(Spree::Country.find(Spree::Config[:default_country_id]))
-      end
-
-      # Regression test for #1142
-      it "uses the first available country if :default_country_id is set to an invalid value" do
-        Spree::Config[:default_country_id] = "0"
-        expect(Spree::Address.default.country).to eq(Spree::Country.first)
-      end
-    end
-
-    context "user given" do
-      let(:bill_address) { Spree::Address.new(phone: Time.current.to_i) }
-      let(:ship_address) { double("ShipAddress") }
-      let(:user) { double("User", bill_address: bill_address, ship_address: ship_address) }
-
-      it "returns a copy of that user bill address" do
-        expect(subject.default(user).phone).to eq bill_address.phone
-      end
-
-      it "falls back to build default when user has no address" do
-        allow(user).to receive_messages(bill_address: nil)
-        expect(subject.default(user)).to eq subject.build_default
-      end
-    end
-  end
-
-  context '#full_name' do
-    context 'both first and last names are present' do
-      let(:address) { stub_model(Spree::Address, :firstname => 'Michael', :lastname => 'Jackson') }
-      specify { expect(address.full_name).to eq('Michael Jackson') }
-    end
-
-    context 'first name is blank' do
-      let(:address) { stub_model(Spree::Address, :firstname => nil, :lastname => 'Jackson') }
-      specify { expect(address.full_name).to eq('Jackson') }
-    end
-
-    context 'last name is blank' do
-      let(:address) { stub_model(Spree::Address, :firstname => 'Michael', :lastname => nil) }
-      specify { expect(address.full_name).to eq('Michael') }
-    end
-
-    context 'both first and last names are blank' do
-      let(:address) { stub_model(Spree::Address, :firstname => nil, :lastname => nil) }
-      specify { expect(address.full_name).to eq('') }
-    end
-
-  end
-
-  context '#state_text' do
-    context 'state is blank' do
-      let(:address) { stub_model(Spree::Address, :state => nil, :state_name => 'virginia') }
-      specify { expect(address.state_text).to eq('virginia') }
-    end
-
-    context 'both name and abbr is present' do
-      let(:state) { stub_model(Spree::State, :name => 'virginia', :abbr => 'va') }
-      let(:address) { stub_model(Spree::Address, :state => state) }
-      specify { expect(address.state_text).to eq('va') }
-    end
-
-    context 'only name is present' do
-      let(:state) { stub_model(Spree::State, :name => 'virginia', :abbr => nil) }
-      let(:address) { stub_model(Spree::Address, :state => state) }
-      specify { expect(address.state_text).to eq('virginia') }
-    end
-  end
-
-  context "defines require_phone? helper method" do
-    let(:address) { stub_model(Spree::Address) }
-    specify { expect(address.instance_eval{ require_phone? }).to be true}
-  end
-end

data/spec/models/spree/adjustable/adjuster/base_spec.rb

@@ -1,10 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Adjustable::Adjuster::Base, type: :model do
-  let(:line_item) { create(:line_item) }
-  let(:subject) { Spree::Adjustable::Adjuster::Base }
-
-  it "raises missing update method" do
-    expect { subject.adjust(line_item, {}) }.to raise_error(NotImplementedError)
-  end
-end

data/spec/models/spree/adjustable/adjuster/promotion_spec.rb

@@ -1,211 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Adjustable::Adjuster::Promotion, type: :model do
-  let(:order) { create :order_with_line_items, line_items_count: 1 }
-  let(:line_item) { order.line_items.first }
-  let(:subject) { Spree::Adjustable::AdjustmentsUpdater.new(line_item) }
-  let(:order_subject) { Spree::Adjustable::AdjustmentsUpdater.new(order) }
-
-  context "best promotion is always applied" do
-    let(:calculator) { Spree::Calculator::FlatRate.new(preferred_amount: 10) }
-    let(:source) { Spree::Promotion::Actions::CreateItemAdjustments.create calculator: calculator }
-
-    def create_adjustment(label, amount)
-      create(:adjustment,
-             order: order,
-             adjustable: line_item,
-             source: source,
-             amount: amount,
-             state: "closed",
-             label: label,
-             mandatory: false)
-    end
-
-    describe "competing promos" do
-      before { Spree::Adjustment.competing_promos_source_types = ['Spree::PromotionAction', 'Custom'] }
-
-      it "do not update promo_total" do
-        create(:adjustment,
-               order: order,
-               adjustable: line_item,
-               source_type: 'Custom',
-               source_id: nil,
-               amount: -3.50,
-               label: "Other",
-               mandatory: false)
-        create_adjustment("Promotion A", -2.50)
-
-        subject.update
-        expect(line_item.promo_total).to eql 0.0
-      end
-    end
-
-    it "should use only the most valuable promotion" do
-      create_adjustment("Promotion A", -100)
-      create_adjustment("Promotion B", -200)
-      create_adjustment("Promotion C", -300)
-      create(:adjustment,
-             order: order,
-             adjustable: line_item,
-             source: nil,
-             amount: -500,
-             state: "closed",
-             label: "Some other credit")
-      line_item.adjustments.each { |a| a.update_column(:eligible, true) }
-
-      subject.update
-
-      expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-      expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion C')
-    end
-
-    it "should choose the most recent promotion adjustment when amounts are equal" do
-      # Using Timecop is a regression test
-      Timecop.freeze do
-        create_adjustment("Promotion A", -200)
-        create_adjustment("Promotion B", -200)
-      end
-      line_item.adjustments.each { |a| a.update_column(:eligible, true) }
-
-      subject.update
-
-      expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-      expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion B')
-    end
-
-    context "when previously ineligible promotions become available" do
-      let(:order_promo1) do
-        create(:promotion,
-               :with_order_adjustment,
-               :with_item_total_rule,
-               weighted_order_adjustment_amount: 5,
-               item_total_threshold_amount: 10)
-      end
-
-      let(:order_promo2) do
-        create(:promotion,
-               :with_order_adjustment,
-               :with_item_total_rule,
-               weighted_order_adjustment_amount: 10,
-               item_total_threshold_amount: 20)
-      end
-
-      let(:order_promos) { [order_promo1, order_promo2] }
-
-      let(:line_item_promo1) do
-        create(:promotion,
-               :with_line_item_adjustment,
-               :with_item_total_rule,
-               adjustment_rate: 2.5,
-               item_total_threshold_amount: 10)
-      end
-
-      let(:line_item_promo2) do
-        create(:promotion,
-               :with_line_item_adjustment,
-               :with_item_total_rule,
-               adjustment_rate: 5,
-               item_total_threshold_amount: 20)
-      end
-
-      let(:line_item_promos) { [line_item_promo1, line_item_promo2] }
-      let(:order) { create(:order_with_line_items, line_items_count: 1) }
-
-      # Apply promotions in different sequences. Results should be the same.
-      promo_sequences = [[0, 1], [1, 0]]
-
-      promo_sequences.each do |promo_sequence|
-        it "should pick the best order-level promo according to current eligibility" do
-          # apply both promos to the order, even though only promo1 is eligible
-          order_promos[promo_sequence[0]].activate order: order
-          order_promos[promo_sequence[1]].activate order: order
-
-          order.reload
-          msg = "Expected two adjustments (using sequence #{promo_sequence})"
-          expect(order.all_adjustments.count).to eq(2), msg
-
-          msg = "Expected one elegible adjustment (using sequence #{promo_sequence})"
-          expect(order.all_adjustments.eligible.count).to eq(1), msg
-
-          msg = "Expected promo1 to be used (using sequence #{promo_sequence})"
-          expect(order.all_adjustments.eligible.first.source.promotion).to eq(order_promo1), msg
-
-          order.contents.add create(:variant, price: 10), 1
-          order.save
-
-          order.reload
-          msg = "Expected two adjustments (using sequence #{promo_sequence})"
-          expect(order.all_adjustments.count).to eq(2), msg
-
-          msg = "Expected one elegible adjustment (using sequence #{promo_sequence})"
-          expect(order.all_adjustments.eligible.count).to eq(1), msg
-
-          msg = "Expected promo2 to be used (using sequence #{promo_sequence})"
-          expect(order.all_adjustments.eligible.first.source.promotion).to eq(order_promo2), msg
-        end
-      end
-
-      promo_sequences.each do |promo_sequence|
-        it "should pick the best line-item-level promo according to current eligibility" do
-          # apply both promos to the order, even though only promo1 is eligible
-          line_item_promos[promo_sequence[0]].activate order: order
-          line_item_promos[promo_sequence[1]].activate order: order
-
-          order.reload
-          msg = "Expected one adjustment (using sequence #{promo_sequence})"
-          expect(order.all_adjustments.count).to eq(1), msg
-
-          msg = "Expected one elegible adjustment (using sequence #{promo_sequence})"
-          expect(order.all_adjustments.eligible.count).to eq(1), msg
-
-          # line_item_promo1 is the only one that has thus far met the order total threshold,
-          # it is the only promo which should be applied.
-          msg = "Expected line_item_promo1 to be used (using sequence #{promo_sequence})"
-          expect(order.all_adjustments.first.source.promotion).to eq(line_item_promo1), msg
-
-          order.contents.add create(:variant, price: 10), 1
-          order.save
-
-          order.reload
-          msg = "Expected four adjustments (using sequence #{promo_sequence})"
-          expect(order.all_adjustments.count).to eq(4), msg
-
-          msg = "Expected two elegible adjustments (using sequence #{promo_sequence})"
-          expect(order.all_adjustments.eligible.count).to eq(2), msg
-
-          order.all_adjustments.eligible.each do |adjustment|
-            msg = "Expected line_item_promo2 to be used (using sequence #{promo_sequence})"
-            expect(adjustment.source.promotion).to eq(line_item_promo2), msg
-          end
-        end
-      end
-    end
-
-    context "multiple adjustments and the best one is not eligible" do
-      let!(:promo_a) { create_adjustment("Promotion A", -100) }
-      let!(:promo_c) { create_adjustment("Promotion C", -300) }
-
-      before do
-        promo_a.update_column(:eligible, true)
-        promo_c.update_column(:eligible, false)
-      end
-
-      # regression for #3274
-      it "still makes the previous best eligible adjustment valid" do
-        subject.update
-        expect(line_item.adjustments.promotion.eligible.first.label).to eq('Promotion A')
-      end
-    end
-
-    it "should only leave one adjustment even if 2 have the same amount" do
-      create_adjustment("Promotion A", -100)
-      create_adjustment("Promotion B", -200)
-      create_adjustment("Promotion C", -200)
-
-      subject.update
-
-      expect(line_item.adjustments.promotion.eligible.count).to eq(1)
-      expect(line_item.adjustments.promotion.eligible.first.amount.to_i).to eq(-200)
-    end
-  end
-end