solidus_core 1.0.7 → 1.1.0.beta1

data/spec/models/spree/zone_spec.rb

@@ -1,305 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Zone, :type => :model do
-  context "#match" do
-    let(:country_zone) { create(:zone, name: 'CountryZone') }
-    let(:country) do
-      country = create(:country)
-      # Create at least one state for this country
-      state = create(:state, country: country)
-      country
-    end
-
-    before { country_zone.members.create(zoneable: country) }
-
-    context "when there is only one qualifying zone" do
-      let(:address) { create(:address, country: country, state: country.states.first) }
-
-      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: country.states.first) }
-      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
-          expect(Spree::Zone.match(address)).to eq(country_zone)
-        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, name: 'StateZone') }
-      let(:address) { create(:address, country: country, state: country.states.first) }
-
-      before { state_zone.members.create(zoneable: country.states.first) }
-
-      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, name: 'CountryZone') }
-
-      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, name: 'StateZone') }
-
-      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, name: 'CountryZone') }
-      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, name: 'StateZone') }
-      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) }
-
-    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 both zones are of the same type" 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 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
-    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
-
-    context "when the zone consists of state zone members" do
-      before do
-        @zone = create(:zone, name: 'state', zone_members: [])
-        @zone.members.create(zoneable: create(:state))
-      end
-      it "should return the kind of zone member" do
-        expect(@zone.kind).to eq("state")
-      end
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,78 +0,0 @@
-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
-  $stderr.puts "Could not load dummy application. Please ensure you have run `bundle exec rake test_app`"
-  exit 1
-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/mail'
-require 'cancan/matchers'
-
-RSpec.configure do |config|
-  config.color = true
-  config.infer_spec_type_from_file_location!
-  config.mock_with :rspec
-
-  config.fixture_path = File.join(File.expand_path(File.dirname(__FILE__)), "fixtures")
-
-  # 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 :suite do
-    DatabaseCleaner.clean_with :truncation
-  end
-
-  config.before :each do
-    Rails.cache.clear
-    reset_spree_preferences
-  end
-
-  config.include FactoryGirl::Syntax::Methods
-  config.include Spree::TestingSupport::Preferences
-  config.include Spree::TestingSupport::Mail
-  config.extend WithModel
-
-  config.fail_fast = ENV['FAIL_FAST'] || false
-
-  config.extend WithModel
-  config.filter_run focus: true
-  config.run_all_when_everything_filtered = true
-
-  config.example_status_persistence_file_path = "./spec/examples.txt"
-
-  config.order = :random
-
-  Kernel.srand config.seed
-end

data/spec/support/big_decimal.rb

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

data/spec/support/concerns/default_price.rb

@@ -1,34 +0,0 @@
-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 }
-
-    describe '#class' do
-      subject { super().class }
-      it { is_expected.to eql Spree::Price }
-    end
-  end
-
-  describe '#has_default_price?' do
-    subject { super().has_default_price? }
-    it { is_expected.to be_truthy }
-  end
-end

data/spec/support/dummy_ability.rb

@@ -1,4 +0,0 @@
-class DummyAbility
-  include CanCan::Ability
-end
-

data/spec/support/test_gateway.rb

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