solidus_core 1.0.7 → 1.1.0.beta1

data/spec/helpers/taxons_helper_spec.rb

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

@@ -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 RuntimeError
-
-    expect {
-      Spree.translate('.legacy_translation')
-    }.to raise_error RuntimeError
-  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(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

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

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

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

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