solidus_core 1.1.0 → 1.1.1

data/spec/helpers/taxons_helper_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Spree::TaxonsHelper, :type => :helper do
+  # Regression test for #4382
+  it "#taxon_preview" do
+    taxon = create(:taxon)
+    child_taxon = create(:taxon, parent: taxon)
+    product_1 = create(:product)
+    product_2 = create(:product)
+    product_3 = create(:product)
+    taxon.products << product_1
+    taxon.products << product_2
+    child_taxon.products << product_3
+
+    expect(taxon_preview(taxon.reload)).to eql([product_1, product_2, product_3])
+  end
+end

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,106 @@
+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 "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(attachment_file_name: "Test", position: 2)
+      @product1.master.images.create(attachment_file_name: "Test1", 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/search/variant_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+module Spree
+  describe Core::Search::Variant do
+    def assert_found(query_string, variant)
+      expect(described_class.new(query_string).results).to include variant
+    end
+
+    def refute_found(query_string, variant)
+      expect(described_class.new(query_string).results).not_to include variant
+    end
+
+    let(:product) { FactoryGirl.create(:product, name: "My Special Product", slug: "my-special-product") }
+    let!(:variant) { FactoryGirl.create(:variant, product: product, sku: "abc-123") }
+
+    context "blank string" do
+      it { assert_found(nil, variant) }
+      it { assert_found("", variant) }
+    end
+
+    context "by sku" do
+      it { assert_found("abc-123", variant) }
+      it { assert_found("abc-1", variant) }
+      it { assert_found("aBc-12", variant) }
+      it { refute_found("bca", variant) }
+    end
+
+    context "by product" do
+      it { assert_found("My Special Product", variant) }
+      it { assert_found("My Spec", variant) }
+      it { assert_found("my spec", variant) }
+      it { assert_found("my-special-product", variant) }
+      it { assert_found("my-spec", variant) }
+      it { assert_found("mY-sPec", variant) }
+      it { assert_found("My Product", variant) }
+      it { refute_found("My House", variant) }
+      it { refute_found("my-product", variant) }
+    end
+
+    context "by product + options" do
+      before do
+        variant.option_values << create(:option_value, presentation: "Robin's egg", name: "blue")
+        variant.option_values << create(:option_value, presentation: 'Slim')
+        variant.option_values << create(:option_value, presentation: '30')
+      end
+      it { assert_found("My Spec blue", variant) }
+      it { assert_found("My Spec robin egg Slim", variant) }
+      it { assert_found("My Spec 30 slim", variant) }
+      it { refute_found("My Spec red slim", variant) }
+      it { refute_found("foo product blue slim", variant) }
+    end
+
+    context "custom scope" do
+      it "takes into account a passed in scope" do
+        variant.stock_items.first.set_count_on_hand(10)
+        expect(
+          described_class.new(variant.sku, scope: Spree::Variant.in_stock).results
+        ).to include variant
+
+        variant.stock_items.each { |si| si.set_count_on_hand(0) }
+        expect(
+          described_class.new(variant.sku, scope: Spree::Variant.in_stock).results
+        ).not_to include variant
+      end
+    end
+
+    context "custom search configuration" do
+      context "removing a search query" do
+        around do |example|
+          search_terms = described_class.search_terms
+          described_class.search_terms -= [:sku_cont]
+          example.run
+          described_class.search_terms = search_terms
+        end
+
+        it { refute_found("abc-123", variant) }
+      end
+
+      context "adding a search query" do
+        around do |example|
+          search_terms = described_class.search_terms
+          described_class.search_terms += [:weight_eq]
+          example.run
+          described_class.search_terms = search_terms
+        end
+        before { variant.update_attributes!(weight: 5000) }
+
+        it { assert_found("5000", variant) }
+      end
+    end
+
+    describe '#search_terms' do
+      # Only search by SKU if the search word is a number
+      class NumericSkuSearcher < Core::Search::Variant
+        protected
+        def search_terms(word)
+          if word =~ /\A\d+\z/
+            super
+          else
+            super - [:sku_cont]
+          end
+        end
+      end
+
+      let!(:numeric_sku_variant) { FactoryGirl.create(:variant, product: product, sku: "123") }
+      let!(:non_numeric_sku_variant) { FactoryGirl.create(:variant, product: product, sku: "abc") }
+
+      it { expect(NumericSkuSearcher.new('123').results).to include numeric_sku_variant }
+      it { expect(NumericSkuSearcher.new('abc').results).not_to include non_numeric_sku_variant }
+    end
+  end
+end

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

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+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) {}
+
+  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 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
+end

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

@@ -0,0 +1,92 @@
+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, store: store) }
+  let(:store) { create(:store) }
+
+  before do
+    allow(controller).to receive_messages(current_store: store)
+    allow(controller).to receive_messages(try_spree_current_user: user)
+  end
+
+  describe '#simple_current_order' do
+    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
+    context 'create_order_if_necessary option is false' do
+      let!(:order) { create :order, user: user, store: store }
+      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
+  end
+
+  describe '#associate_user' do
+    before { allow(controller).to receive_messages(current_order: order) }
+    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) }
+
+    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