spree_core 3.2.9 → 3.3.0.rc1

data/spec/lib/calculated_adjustments_spec.rb

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,123 @@
+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

@@ -0,0 +1,86 @@
+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(ActionController::Parameters.new(params))
+    expect(searcher.retrieve_products.count).to eq(2)
+
+    params.merge! page: "2"
+    searcher = Spree::Core::Search::Base.new(ActionController::Parameters.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(ActionController::Parameters.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(ActionController::Parameters.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(ActionController::Parameters.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

@@ -0,0 +1,103 @@
+require 'spec_helper'
+require 'spree/testing_support/url_helpers'
+
+class FakesController < ApplicationController
+  include Spree::Core::ControllerHelpers::Auth
+  def index; render plain: '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 plain: '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

@@ -0,0 +1,110 @@
+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

@@ -0,0 +1,17 @@
+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