spree_core 3.1.5 → 3.1.6

data/spec/lib/calculated_adjustments_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-
-describe Spree::CalculatedAdjustments do
-  it "should add has_one :calculator relationship" do
-    assert Spree::ShippingMethod.reflect_on_all_associations(:has_one).map(&:name).include?(:calculator)
-  end
-end

data/spec/lib/i18n_spec.rb

@@ -1,123 +0,0 @@
-require 'rspec/expectations'
-require 'spree/i18n'
-require 'spree/testing_support/i18n'
-
-describe "i18n" do
-  before do
-    I18n.backend.store_translations(:en,
-    {
-      :spree => {
-        :foo => "bar",
-        :bar => {
-          :foo => "bar within bar scope",
-          :invalid => nil,
-          :legacy_translation => "back in the day..."
-        },
-        :invalid => nil,
-        :legacy_translation => "back in the day..."
-      }
-    })
-  end
-
-  it "translates within the spree scope" do
-    expect(Spree.normal_t(:foo)).to eql("bar")
-    expect(Spree.translate(:foo)).to eql("bar")
-  end
-
-  it "translates within the spree scope using a path" do
-    allow(Spree).to receive(:virtual_path).and_return('bar')
-
-    expect(Spree.normal_t('.legacy_translation')).to eql("back in the day...")
-    expect(Spree.translate('.legacy_translation')).to eql("back in the day...")
-  end
-
-  it "raise error without any context when using a path" do
-    expect {
-      Spree.normal_t('.legacy_translation')
-    }.to raise_error(StandardError)
-
-    expect {
-      Spree.translate('.legacy_translation')
-    }.to raise_error(StandardError)
-  end
-
-  it "prepends a string scope" do
-    expect(Spree.normal_t(:foo, :scope => "bar")).to eql("bar within bar scope")
-  end
-
-  it "prepends to an array scope" do
-    expect(Spree.normal_t(:foo, :scope => ["bar"])).to eql("bar within bar scope")
-  end
-
-  it "returns two translations" do
-    expect(Spree.normal_t([:foo, 'bar.foo'])).to eql(["bar", "bar within bar scope"])
-  end
-
-  it "returns reasonable string for missing translations" do
-    expect(Spree.t(:missing_entry)).to include("<span")
-  end
-
-  context "missed + unused translations" do
-    def key_with_locale(key)
-      "#{key} (#{I18n.locale})"
-    end
-
-    before do
-      Spree.used_translations = []
-    end
-
-    context "missed translations" do
-      def assert_missing_translation(key)
-        key = key_with_locale(key)
-        message = Spree.missing_translation_messages.detect { |m| m == key }
-        expect(message).not_to(be_nil, "expected '#{key}' to be missing, but it wasn't.")
-      end
-
-      it "logs missing translations" do
-        Spree.t(:missing, :scope => [:else, :where])
-        Spree.check_missing_translations
-        assert_missing_translation("else")
-        assert_missing_translation("else.where")
-        assert_missing_translation("else.where.missing")
-      end
-
-      it "does not log present translations" do
-        Spree.t(:foo)
-        Spree.check_missing_translations
-        expect(Spree.missing_translation_messages).to be_empty
-      end
-
-      it "does not break when asked for multiple translations" do
-        Spree.t [:foo, 'bar.foo']
-        Spree.check_missing_translations
-        expect(Spree.missing_translation_messages).to be_empty
-      end
-    end
-
-    context "unused translations" do
-      def assert_unused_translation(key)
-        key = key_with_locale(key)
-        message = Spree.unused_translation_messages.detect { |m| m == key }
-        expect(message).not_to(be_nil, "expected '#{key}' to be unused, but it was used.")
-      end
-
-      def assert_used_translation(key)
-        key = key_with_locale(key)
-        message = Spree.unused_translation_messages.detect { |m| m == key }
-        expect(message).to(be_nil, "expected '#{key}' to be used, but it wasn't.")
-      end
-
-      it "logs translations that aren't used" do
-        Spree.check_unused_translations
-        assert_unused_translation("bar.legacy_translation")
-        assert_unused_translation("legacy_translation")
-      end
-
-      it "does not log used translations" do
-        Spree.t(:foo)
-        Spree.check_unused_translations
-        assert_used_translation("foo")
-      end
-    end
-  end
-end

data/spec/lib/search/base_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe Spree::Core::Search::Base do
-
-  before do
-    include Spree::Core::ProductFilters
-    @taxon = create(:taxon, name: "Ruby on Rails")
-
-    @product1 = create(:product, name: "RoR Mug", price: 9.00)
-    @product1.taxons << @taxon
-    @product2 = create(:product, name: "RoR Shirt", price: 11.00)
-  end
-
-  it "returns all products by default" do
-    params = { :per_page => "" }
-    searcher = Spree::Core::Search::Base.new(params)
-    expect(searcher.retrieve_products.count).to eq(2)
-  end
-
-  context "when include_images is included in the initalization params" do
-    let(:params) { { include_images: true, keyword: @product1.name, taxon: @taxon.id } }
-    subject { described_class.new(params).retrieve_products }
-
-    before do
-      @product1.master.images << create(:image, position: 2)
-      @product1.master.images << create(:image, position: 1)
-      @product1.reload
-    end
-
-    it "returns images in correct order" do
-      expect(subject.first).to eq @product1
-      expect(subject.first.images).to eq @product1.master.images
-    end
-  end
-
-  it "switches to next page according to the page parameter" do
-    @product3 = create(:product, :name => "RoR Pants", :price => 14.00)
-
-    params = { :per_page => "2" }
-    searcher = Spree::Core::Search::Base.new(params)
-    expect(searcher.retrieve_products.count).to eq(2)
-
-    params.merge! :page => "2"
-    searcher = Spree::Core::Search::Base.new(params)
-    expect(searcher.retrieve_products.count).to eq(1)
-  end
-
-  it "maps search params to named scopes" do
-    params = { :per_page => "",
-               :search => { "price_range_any" => ["Under $10.00"] }}
-    searcher = Spree::Core::Search::Base.new(params)
-    expect(searcher.send(:get_base_scope).to_sql).to match /<= 10/
-    expect(searcher.retrieve_products.count).to eq(1)
-  end
-
-  it "maps multiple price_range_any filters" do
-    params = { :per_page => "",
-               :search => { "price_range_any" => ["Under $10.00", "$10.00 - $15.00"] }}
-    searcher = Spree::Core::Search::Base.new(params)
-    expect(searcher.send(:get_base_scope).to_sql).to match /<= 10/
-    expect(searcher.send(:get_base_scope).to_sql).to match /between 10 and 15/i
-    expect(searcher.retrieve_products.count).to eq(2)
-  end
-
-  it "uses ransack if scope not found" do
-    params = { :per_page => "",
-               :search => { "name_not_cont" => "Shirt" }}
-    searcher = Spree::Core::Search::Base.new(params)
-    expect(searcher.retrieve_products.count).to eq(1)
-  end
-
-  it "accepts a current user" do
-    user = double
-    searcher = Spree::Core::Search::Base.new({})
-    searcher.current_user = user
-    expect(searcher.current_user).to eql(user)
-  end
-
-  it "finds products in alternate currencies" do
-    price = create(:price, :currency => 'EUR', :variant => @product1.master)
-    searcher = Spree::Core::Search::Base.new({})
-    searcher.current_currency = 'EUR'
-    expect(searcher.retrieve_products).to eq([@product1])
-  end
-
-end

data/spec/lib/spree/core/controller_helpers/auth_spec.rb

@@ -1,103 +0,0 @@
-require 'spec_helper'
-require 'spree/testing_support/url_helpers'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Auth
-  def index; render text: 'index'; end
-end
-
-describe Spree::Core::ControllerHelpers::Auth, type: :controller do
-  controller(FakesController) {}
-  include Spree::TestingSupport::UrlHelpers
-
-  describe '#current_ability' do
-    it 'returns Spree::Ability instance' do
-      expect(controller.current_ability.class).to eq Spree::Ability
-    end
-  end
-
-  describe '#redirect_back_or_default' do
-    controller(FakesController) do
-      def index; redirect_back_or_default('/'); end
-    end
-    it 'redirects to session url' do
-      session[:spree_user_return_to] = '/redirect'
-      get :index
-      expect(response).to redirect_to('/redirect')
-    end
-    it 'redirects to HTTP_REFERER' do
-      request.env["HTTP_REFERER"] = '/dummy_redirect'
-      get :index
-      expect(response).to redirect_to('/dummy_redirect')
-    end
-    it 'redirects to default page' do
-      get :index
-      expect(response).to redirect_to('/')
-    end
-  end
-
-  describe '#set_guest_token' do
-    controller(FakesController) do
-      def index
-        set_guest_token
-        render text: 'index'
-      end
-    end
-    it 'sends cookie header' do
-      get :index
-      expect(response.cookies['guest_token']).not_to be_nil
-    end
-  end
-
-  describe '#store_location' do
-    it 'sets session return url' do
-      allow(controller).to receive_messages(request: double(fullpath: '/redirect'))
-      controller.store_location
-      expect(session[:spree_user_return_to]).to eq '/redirect'
-    end
-  end
-
-  describe '#try_spree_current_user' do
-    it 'calls spree_current_user when define spree_current_user method' do
-      expect(controller).to receive(:spree_current_user)
-      controller.try_spree_current_user
-    end
-    it 'calls current_spree_user when define current_spree_user method' do
-      expect(controller).to receive(:current_spree_user)
-      controller.try_spree_current_user
-    end
-    it 'returns nil' do
-      expect(controller.try_spree_current_user).to eq nil
-    end
-  end
-
-  describe '#redirect_unauthorized_access' do
-    controller(FakesController) do
-      def index; redirect_unauthorized_access; end
-    end
-    context 'when logged in' do
-      before do
-        allow(controller).to receive_messages(try_spree_current_user: double('User', id: 1, last_incomplete_spree_order: nil))
-      end
-      it 'redirects forbidden path' do
-        get :index
-        expect(response).to redirect_to(spree.forbidden_path)
-      end
-    end
-    context 'when guest user' do
-      before do
-        allow(controller).to receive_messages(try_spree_current_user: nil)
-      end
-      it 'redirects login path' do
-        allow(controller).to receive_messages(spree_login_path: '/login')
-        get :index
-        expect(response).to redirect_to('/login')
-      end
-      it 'redirects root path' do
-        allow(controller).to receive_message_chain(:spree, :root_path).and_return('/root_path')
-        get :index
-        expect(response).to redirect_to('/root_path')
-      end
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/order_spec.rb

@@ -1,110 +0,0 @@
-require 'spec_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Order
-end
-
-describe Spree::Core::ControllerHelpers::Order, type: :controller do
-  controller(FakesController) {}
-
-  let(:user) { create(:user) }
-  let(:order) { create(:order, user: user) }
-  let(:store) { create(:store) }
-
-  describe '#simple_current_order' do
-    before { allow(controller).to receive_messages(try_spree_current_user: user) }
-    it "returns an empty order" do
-      expect(controller.simple_current_order.item_count).to eq 0
-    end
-    it 'returns Spree::Order instance' do
-      allow(controller).to receive_messages(cookies: double(signed: { guest_token: order.guest_token }))
-      expect(controller.simple_current_order).to eq order
-    end
-  end
-
-  describe '#current_order' do
-    before {
-      allow(controller).to receive_messages(current_store: store)
-      allow(controller).to receive_messages(try_spree_current_user: user)
-    }
-    context 'create_order_if_necessary option is false' do
-      let!(:order) { create :order, user: user }
-      it 'returns current order' do
-        expect(controller.current_order).to eq order
-      end
-    end
-    context 'create_order_if_necessary option is true' do
-      it 'creates new order' do
-        expect {
-          controller.current_order(create_order_if_necessary: true)
-        }.to change(Spree::Order, :count).to(1)
-      end
-
-      it 'assigns the current_store id' do
-        controller.current_order(create_order_if_necessary: true)
-        expect(Spree::Order.last.store_id).to eq store.id
-      end
-    end
-
-    context 'gets using the guest_token' do
-      let!(:order) { create :order, user: user }
-      let!(:guest_order) { create :order, user: nil, email: nil, guest_token: 'token' }
-
-      before do
-        expect(controller).to receive(:current_order_params).and_return(
-          currency: Spree::Config[:currency], guest_token: 'token', store_id: guest_order.store_id, user_id: user.id,
-        )
-      end
-
-      specify 'without the guest token being bound to any user yet' do
-        expect(controller.current_order).to eq guest_order
-      end
-    end
-  end
-
-  describe '#associate_user' do
-    before do
-      allow(controller).to receive_messages(current_order: order, try_spree_current_user: user)
-    end
-    context "user's email is blank" do
-      let(:user) { create(:user, email: '') }
-      it 'calls Spree::Order#associate_user! method' do
-        expect_any_instance_of(Spree::Order).to receive(:associate_user!)
-        controller.associate_user
-      end
-    end
-    context "user isn't blank" do
-      it 'does not calls Spree::Order#associate_user! method' do
-        expect_any_instance_of(Spree::Order).not_to receive(:associate_user!)
-        controller.associate_user
-      end
-    end
-  end
-
-  describe '#set_current_order' do
-    let(:incomplete_order) { create(:order, user: user) }
-    before { allow(controller).to receive_messages(try_spree_current_user: user) }
-
-    context 'when current order not equal to users incomplete orders' do
-      before { allow(controller).to receive_messages(current_order: order, last_incomplete_order: incomplete_order, cookies: double(signed: { guest_token: 'guest_token' })) }
-
-      it 'calls Spree::Order#merge! method' do
-        expect(order).to receive(:merge!).with(incomplete_order, user)
-        controller.set_current_order
-      end
-    end
-  end
-
-  describe '#current_currency' do
-    it 'returns current currency' do
-      Spree::Config[:currency] = 'USD'
-      expect(controller.current_currency).to eq 'USD'
-    end
-  end
-
-  describe '#ip_address' do
-    it 'returns remote ip' do
-      expect(controller.ip_address).to eq request.remote_ip
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/search_spec.rb

@@ -1,17 +0,0 @@
-require 'spec_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Search
-end
-
-describe Spree::Core::ControllerHelpers::Search, type: :controller do
-  controller(FakesController) {}
-
-  describe '#build_searcher' do
-    it 'returns Spree::Core::Search::Base instance' do
-      allow(controller).to receive_messages(try_spree_current_user: create(:user),
-                      current_currency: 'USD')
-      expect(controller.build_searcher({}).class).to eq Spree::Core::Search::Base
-    end
-  end
-end