spree_core 3.1.14 → 3.2.0.rc1

data/spec/models/spree/zone_member_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Spree::ZoneMember, type: :model do
+  let(:country) { create(:country) }
+  let(:state) { create(:state) }
+  let(:zone) { create(:zone, kind: 'country') }
+  let(:zone_member) { create(:zone_member, zone: zone, zoneable: country) }
+
+  describe 'associations' do
+    it { is_expected.to belong_to(:zoneable) }
+    it { is_expected.to belong_to(:zone).counter_cache(true).inverse_of(:zone_members) }
+  end
+
+  describe 'validations' do
+    it { is_expected.to validate_presence_of(:zone) }
+    it { is_expected.to validate_presence_of(:zoneable) }
+  end
+
+  describe 'scopes' do
+    describe '.defunct_without_kind' do
+      let(:defunct_without_kind) { Spree::ZoneMember.defunct_without_kind('country') }
+
+      context 'zoneable is present and is of defunct kind' do
+        it { expect(defunct_without_kind).to_not include(zone_member) }
+      end
+
+      context 'zoneable is not of defunct kind' do
+        before { zone_member.update(zoneable: state) }
+        it { expect(defunct_without_kind).to include(zone_member) }
+      end
+
+      context 'zoneable is absent' do
+        before { zone_member.update_column(:zoneable_id, nil) }
+        it { expect(defunct_without_kind).to include(zone_member) }
+      end
+    end
+  end
+end

data/spec/models/spree/zone_spec.rb

@@ -0,0 +1,472 @@
+require 'spec_helper'
+
+describe Spree::Zone, type: :model do
+  context "#match" do
+    let(:country_zone) { create(:zone, kind: 'country') }
+
+    let(:country) do
+      create(:country)
+    end
+
+    let(:state) do
+      create(:state, country: country)
+    end
+
+    it { is_expected.to have_many(:shipping_methods).through(:shipping_method_zones).class_name('Spree::ShippingMethod') }
+
+    before { country_zone.members.create(zoneable: country) }
+
+    describe 'scopes' do
+      describe '.remove_previous_default' do
+        let(:zone_with_default_tax) { create(:zone, kind: 'country', default_tax: true) }
+        let(:zone_not_with_default_tax) { create(:zone, kind: 'country', default_tax: false) }
+
+        subject { Spree::Zone.with_default_tax }
+
+        it 'is expected to include zone with default tax' do
+          is_expected.to include(zone_with_default_tax)
+        end
+
+        it 'is expected to not include zone with default tax' do
+          is_expected.to_not include(zone_not_with_default_tax)
+        end
+      end
+    end
+
+    describe 'callbacks' do
+      it { is_expected.to callback(:remove_previous_default).after(:save).if(:default_tax?).if(:default_tax_changed?) }
+
+      describe '#remove_previous_default' do
+        let!(:zone_with_default_tax) { create(:zone, kind: 'country', default_tax: true) }
+        let!(:zone_not_with_default_tax) { create(:zone, kind: 'country', default_tax: false) }
+
+        it 'is expected to make previous default tax zones to non default tax zones' do
+          expect(zone_with_default_tax).to be_default_tax
+          zone_not_with_default_tax.update(default_tax: true)
+          expect(zone_with_default_tax.reload).to_not be_default_tax
+        end
+      end
+    end
+
+    context "when there is only one qualifying zone" do
+      let(:address) { create(:address, country: country, state: state) }
+
+      it "should return the qualifying zone" do
+        expect(Spree::Zone.match(address)).to eq(country_zone)
+      end
+    end
+
+    context "when there are two qualified zones with same member type" do
+      let(:address) { create(:address, country: country, state: state) }
+      let(:second_zone) { create(:zone, name: 'SecondZone') }
+
+      before { second_zone.members.create(zoneable: country) }
+
+      context "when both zones have the same number of members" do
+        it "should return the zone that was created first" do
+          Timecop.scale(100) do
+            expect(Spree::Zone.match(address)).to eq(country_zone)
+          end
+        end
+      end
+
+      context "when one of the zones has fewer members" do
+        let(:country2) { create(:country) }
+
+        before { country_zone.members.create(zoneable: country2) }
+
+        it "should return the zone with fewer members" do
+          expect(Spree::Zone.match(address)).to eq(second_zone)
+        end
+      end
+    end
+
+    context "when there are two qualified zones with different member types" do
+      let(:state_zone) { create(:zone, kind: 'state') }
+      let(:address) { create(:address, country: country, state: state) }
+
+      before { state_zone.members.create!(zoneable: state) }
+
+      it "should return the zone with the more specific member type" do
+        expect(Spree::Zone.match(address)).to eq(state_zone)
+      end
+    end
+
+    context "when there are no qualifying zones" do
+      it "should return nil" do
+        expect(Spree::Zone.match(Spree::Address.new)).to be_nil
+      end
+    end
+  end
+
+  context "#country_list" do
+    let(:state) { create(:state) }
+    let(:country) { state.country }
+
+    context "when zone consists of countries" do
+      let(:country_zone) { create(:zone, kind: 'country') }
+
+      before { country_zone.members.create(zoneable: country) }
+
+      it 'should return a list of countries' do
+        expect(country_zone.country_list).to eq([country])
+      end
+    end
+
+    context "when zone consists of states" do
+      let(:state_zone) { create(:zone, kind: 'state') }
+
+      before { state_zone.members.create(zoneable: state) }
+
+      it 'should return a list of countries' do
+        expect(state_zone.country_list).to eq([state.country])
+      end
+    end
+  end
+
+  context "#include?" do
+    let(:state) { create(:state) }
+    let(:country) { state.country }
+    let(:address) { create(:address, state: state) }
+
+    context "when zone is country type" do
+      let(:country_zone) { create(:zone, kind: 'country') }
+      before { country_zone.members.create(zoneable: country) }
+
+      it "should be true" do
+        expect(country_zone.include?(address)).to be true
+      end
+    end
+
+    context "when zone is state type" do
+      let(:state_zone) { create(:zone, kind: 'state') }
+      before { state_zone.members.create(zoneable: state) }
+
+      it "should be true" do
+        expect(state_zone.include?(address)).to be true
+      end
+    end
+  end
+
+  context ".default_tax" do
+    context "when there is a default tax zone specified" do
+      before { @foo_zone = create(:zone, name: 'whatever', default_tax: true) }
+
+      it "should be the correct zone" do
+        foo_zone = create(:zone, name: 'foo')
+        expect(Spree::Zone.default_tax).to eq(@foo_zone)
+      end
+    end
+
+    context "when there is no default tax zone specified" do
+      it "should be nil" do
+        expect(Spree::Zone.default_tax).to be_nil
+      end
+    end
+  end
+
+  context "#contains?" do
+    let(:country1) { create(:country) }
+    let(:country2) { create(:country) }
+    let(:country3) { create(:country) }
+
+    let(:state1) { create(:state) }
+    let(:state2) { create(:state) }
+    let(:state3) { create(:state) }
+
+    before do
+      @source = create(:zone, name: 'source', zone_members: [])
+      @target = create(:zone, name: 'target', zone_members: [])
+    end
+
+    context "when the target has no members" do
+      before { @source.members.create(zoneable: country1) }
+
+      it "should be false" do
+        expect(@source.contains?(@target)).to be false
+      end
+    end
+
+    context "when the source has no members" do
+      before { @target.members.create(zoneable: country1) }
+
+      it "should be false" do
+        expect(@source.contains?(@target)).to be false
+      end
+    end
+
+    context "when both zones are the same zone" do
+      before do
+        @source.members.create(zoneable: country1)
+        @target = @source
+      end
+
+      it "should be true" do
+        expect(@source.contains?(@target)).to be true
+      end
+    end
+
+    context "when checking countries against countries" do
+      before do
+        @source.members.create(zoneable: country1)
+        @source.members.create(zoneable: country2)
+      end
+
+      context "when all members are included in the zone we check against" do
+        before do
+          @target.members.create(zoneable: country1)
+          @target.members.create(zoneable: country2)
+        end
+
+        it "should be true" do
+          expect(@source.contains?(@target)).to be true
+        end
+      end
+
+      context "when some members are included in the zone we check against" do
+        before do
+          @target.members.create(zoneable: country1)
+          @target.members.create(zoneable: country2)
+          @target.members.create(zoneable: create(:country))
+        end
+
+        it "should be false" do
+          expect(@source.contains?(@target)).to be false
+        end
+      end
+
+      context "when none of the members are included in the zone we check against" do
+        before do
+          @target.members.create(zoneable: create(:country))
+          @target.members.create(zoneable: create(:country))
+        end
+
+        it "should be false" do
+          expect(@source.contains?(@target)).to be false
+        end
+      end
+    end
+
+
+    context "when checking states against states" do
+      before do
+        @source.members.create(zoneable: state1)
+        @source.members.create(zoneable: state2)
+      end
+
+      context "when all members are included in the zone we check against" do
+        before do
+          @target.members.create(zoneable: state1)
+          @target.members.create(zoneable: state2)
+        end
+
+        it "should be true" do
+          expect(@source.contains?(@target)).to be true
+        end
+      end
+
+      context "when some members are included in the zone we check against" do
+        before do
+          @target.members.create(zoneable: state1)
+          @target.members.create(zoneable: state2)
+          @target.members.create(zoneable: create(:state))
+        end
+
+        it "should be false" do
+          expect(@source.contains?(@target)).to be false
+        end
+      end
+
+      context "when none of the members are included in the zone we check against" do
+        before do
+          @target.members.create(zoneable: create(:state))
+          @target.members.create(zoneable: create(:state))
+        end
+
+        it "should be false" do
+          expect(@source.contains?(@target)).to be false
+        end
+      end
+    end
+
+    context "when checking country against state" do
+      before do
+        @source.members.create(zoneable: create(:state))
+        @target.members.create(zoneable: country1)
+      end
+
+      it "should be false" do
+        expect(@source.contains?(@target)).to be false
+      end
+    end
+
+    context "when checking state against country" do
+      before { @source.members.create(zoneable: country1) }
+
+      context "when all states contained in one of the countries we check against" do
+
+        before do
+          state1 = create(:state, country: country1)
+          @target.members.create(zoneable: state1)
+        end
+
+        it "should be true" do
+          expect(@source.contains?(@target)).to be true
+        end
+      end
+
+      context "when some states contained in one of the countries we check against" do
+        before do
+          state1 = create(:state, country: country1)
+          @target.members.create(zoneable: state1)
+          @target.members.create(zoneable: create(:state, country: country2))
+        end
+
+        it "should be false" do
+          expect(@source.contains?(@target)).to be false
+        end
+      end
+
+      context "when none of the states contained in any of the countries we check against" do
+        before do
+          @target.members.create(zoneable: create(:state, country: country2))
+          @target.members.create(zoneable: create(:state, country: country2))
+        end
+
+        it "should be false" do
+          expect(@source.contains?(@target)).to be false
+        end
+      end
+    end
+  end
+
+  context "#save" do
+    context "when default_tax is true" do
+      it "should clear previous default tax zone" do
+        zone1 = create(:zone, name: 'foo', default_tax: true)
+        zone = create(:zone, name: 'bar', default_tax: true)
+        expect(zone1.reload.default_tax).to be false
+      end
+    end
+
+    context "when a zone member country is added to an existing zone consisting of state members" do
+      it "should remove existing state members" do
+        zone = create(:zone, name: 'foo', zone_members: [])
+        state = create(:state)
+        country = create(:country)
+        zone.members.create(zoneable: state)
+        country_member = zone.members.create(zoneable: country)
+        zone.save
+        expect(zone.reload.members).to eq([country_member])
+      end
+    end
+  end
+
+  context "#kind" do
+    it "returns whatever value you set" do
+      zone = Spree::Zone.new kind: 'city'
+      expect(zone.kind).to eq 'city'
+    end
+
+    context "when the zone consists of country zone members" do
+      before do
+        @zone = create(:zone, name: 'country', zone_members: [])
+        @zone.members.create(zoneable: create(:country))
+      end
+
+      it "should return the kind of zone member" do
+        expect(@zone.kind).to eq("country")
+      end
+    end
+  end
+
+  context "#potential_matching_zones" do
+    let!(:country)  { create(:country) }
+    let!(:country2) { create(:country, name: 'OtherCountry') }
+    let!(:country3) { create(:country, name: 'TaxCountry') }
+    let!(:default_tax_zone) do
+      create(:zone, default_tax: true).tap { |z| z.members.create(zoneable: country3) }
+    end
+
+    context "finding potential matches for a country zone" do
+      let!(:zone) do
+        create(:zone).tap do |z|
+          z.members.create(zoneable: country)
+          z.members.create(zoneable: country2)
+          z.save!
+        end
+      end
+      let!(:zone2) do
+        create(:zone).tap { |z| z.members.create(zoneable: country) && z.save! }
+      end
+
+      before { @result = Spree::Zone.potential_matching_zones(zone) }
+
+      it "will find all zones with countries covered by the passed in zone" do
+        expect(@result).to include(zone, zone2)
+      end
+
+      it "only returns each zone once" do
+        expect(@result.select { |z| z == zone }.size).to be 1
+      end
+    end
+
+    context "finding potential matches for a state zone" do
+      let!(:state)  { create(:state, country: country) }
+      let!(:state2) { create(:state, country: country2, name: 'OtherState') }
+      let!(:state3) { create(:state, country: country2, name: 'State') }
+      let!(:zone) do
+        create(:zone).tap do |z|
+          z.members.create(zoneable: state)
+          z.members.create(zoneable: state2)
+          z.save!
+        end
+      end
+      let!(:zone2) do
+        create(:zone).tap { |z| z.members.create(zoneable: state) && z.save! }
+      end
+      let!(:zone3) do
+        create(:zone).tap { |z| z.members.create(zoneable: state2) && z.save! }
+      end
+
+      before { @result = Spree::Zone.potential_matching_zones(zone) }
+
+      it "will find all zones which share states covered by passed in zone" do
+        expect(@result).to include(zone, zone2)
+      end
+
+      it "will find zones that share countries with any states of the passed in zone" do
+        expect(@result).to include(zone3)
+      end
+
+      it "only returns each zone once" do
+        expect(@result.select { |z| z == zone }.size).to be 1
+      end
+    end
+  end
+
+  context "state and country associations" do
+    let!(:country)  { create(:country) }
+
+    context "has countries associated" do
+      let!(:zone) do
+        create(:zone, countries: [country])
+      end
+
+      it "can access associated countries" do
+        expect(zone.countries).to include(country)
+      end
+    end
+
+    context "has states associated" do
+      let!(:state)  { create(:state, country: country) }
+      let!(:zone) do
+        create(:zone, states: [state])
+      end
+
+      it "can access associated states" do
+        expect(zone.states).to include(state)
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,79 @@
+if ENV["COVERAGE"]
+  # Run Coverage report
+  require 'simplecov'
+  SimpleCov.start do
+    add_group 'Controllers', 'app/controllers'
+    add_group 'Helpers', 'app/helpers'
+    add_group 'Mailers', 'app/mailers'
+    add_group 'Models', 'app/models'
+    add_group 'Views', 'app/views'
+    add_group 'Jobs', 'app/jobs'
+    add_group 'Libraries', 'lib'
+  end
+end
+
+# This file is copied to ~/spec when you run 'ruby script/generate rspec'
+# from the project root directory.
+ENV["RAILS_ENV"] ||= 'test'
+
+begin
+  require File.expand_path("../dummy/config/environment", __FILE__)
+rescue LoadError
+  puts "Could not load dummy application. Please ensure you have run `bundle exec rake test_app`"
+end
+
+require 'rspec/rails'
+require 'database_cleaner'
+require 'ffaker'
+
+Dir["./spec/support/**/*.rb"].sort.each { |f| require f }
+
+if ENV["CHECK_TRANSLATIONS"]
+  require "spree/testing_support/i18n"
+end
+
+require 'spree/testing_support/factories'
+require 'spree/testing_support/preferences'
+require 'spree/testing_support/shoulda_matcher_configuration'
+require 'spree/testing_support/url_helpers'
+require 'spree/testing_support/kernel'
+
+RSpec.configure do |config|
+  config.color = true
+  config.fail_fast = ENV['FAIL_FAST'] || false
+  config.fixture_path = File.join(File.expand_path(File.dirname(__FILE__)), "fixtures")
+  config.infer_spec_type_from_file_location!
+  config.mock_with :rspec
+  config.raise_errors_for_deprecations!
+
+  # If you're not using ActiveRecord, or you'd prefer not to run each of your
+  # examples within a transaction, comment the following line or assign false
+  # instead of true.
+  config.use_transactional_fixtures = true
+
+  config.before :each do
+    Rails.cache.clear
+    reset_spree_preferences
+  end
+
+  config.extend WithModel
+
+  config.include FactoryGirl::Syntax::Methods
+  config.include Spree::TestingSupport::Preferences
+  config.include Spree::TestingSupport::Kernel
+
+  # Clean out the database state before the tests run
+  config.before(:suite) do
+    DatabaseCleaner.clean_with(:truncation)
+    DatabaseCleaner.strategy = :transaction
+  end
+
+  # Wrap all db isolated tests in a transaction
+  config.around(db: :isolate) do |example|
+    DatabaseCleaner.cleaning(&example)
+  end
+
+  config.around do |example|
+    Timeout.timeout(30, &example)
+  end
+end

data/spec/support/big_decimal.rb

@@ -0,0 +1,5 @@
+class BigDecimal
+  def inspect
+    "#<BigDecimal: #{to_s}>"
+  end
+end

data/spec/support/concerns/adjustment_source.rb

@@ -0,0 +1,23 @@
+shared_examples_for "an adjustment source" do
+  subject(:source) { described_class.create }
+
+  before do
+    allow(Spree::Adjustable::AdjustmentsUpdater).to receive(:update)
+    order.adjustments.create(order: order, amount: 10, label: 'Adjustment', source: source)
+  end
+
+  describe '#destroy' do
+    before { source.destroy }
+
+    context 'when order incomplete' do
+      let(:order) { create(:order_with_line_items) }
+      it { expect(order.adjustments.count).to eq(0) }
+    end
+
+    context 'when order is complete' do
+      let(:order) { create(:completed_order_with_totals) }
+      it { expect(order.adjustments.count).to eq(1) }
+      it { expect(order.adjustments.reload.first.source).to be_nil }
+    end
+  end
+end

data/spec/support/concerns/default_price.rb

@@ -0,0 +1,37 @@
+shared_examples_for "default_price" do
+  let(:model)        { described_class }
+  subject(:instance) { FactoryGirl.build(model.name.demodulize.downcase.to_sym) }
+
+  describe '.has_one :default_price' do
+    let(:default_price_association) { model.reflect_on_association(:default_price) }
+
+    it 'should be a has one association' do
+      expect(default_price_association.macro).to eql :has_one
+    end
+
+    it 'should have a dependent destroy' do
+      expect(default_price_association.options[:dependent]).to eql :destroy
+    end
+
+    it 'should have the class name of Spree::Price' do
+      expect(default_price_association.options[:class_name]).to eql 'Spree::Price'
+    end
+  end
+
+  describe '#default_price' do
+    subject { instance.default_price }
+
+    its(:class) { should eql Spree::Price }
+    it 'delegates price' do
+      expect(instance.default_price). to receive(:price)
+      instance.price
+    end
+
+    it 'delegates price_including_vat_for' do
+      expect(instance.default_price). to receive(:price_including_vat_for)
+      instance.price_including_vat_for
+    end
+  end
+
+  its(:has_default_price?) { should be_truthy }
+end

data/spec/support/rake.rb

@@ -0,0 +1,13 @@
+require "rake"
+
+shared_context "rake" do
+  let(:task_name) { self.class.top_level_description }
+  let(:task_path) { "lib/tasks/#{task_name.split(":").first}" }
+  subject         { Rake::Task[task_name] }
+
+  before do
+    Rake::Task.define_task(:environment)
+    load File.expand_path(Rails.root + "../../#{task_path}.rake")
+    subject.reenable
+  end
+end

data/spec/support/test_gateway.rb

@@ -0,0 +1,2 @@
+class Spree::Gateway::Test < Spree::Gateway
+end