spree_core 3.2.1 → 3.2.2

data/spec/helpers/products_helper_spec.rb

@@ -1,289 +0,0 @@
-# encoding: utf-8
-
-require "spec_helper"
-
-module Spree
-  describe ProductsHelper, type: :helper do
-    include ProductsHelper
-
-    let(:product) { create(:product) }
-    let(:currency) { 'USD' }
-
-    before do
-      allow(helper).to receive(:current_currency) { currency }
-    end
-
-    context "#variant_price_diff" do
-      let(:product_price) { 10 }
-      let(:variant_price) { 10 }
-
-      before do
-        @variant = create(:variant, product: product)
-        product.price = 15
-        @variant.price = 10
-        allow(product).to receive(:amount_in) { product_price }
-        allow(@variant).to receive(:amount_in) { variant_price }
-      end
-
-      subject { helper.variant_price(@variant) }
-
-      context "when variant is same as master" do
-        it { is_expected.to be_nil }
-      end
-
-      context "when the master has no price" do
-        let(:product_price) { nil }
-
-        it { is_expected.to be_nil }
-      end
-
-      context "when currency is default" do
-        context "when variant is more than master" do
-          let(:variant_price) { 15 }
-
-          it { is_expected.to eq("(Add: $5.00)") }
-          # Regression test for #2737
-          it { is_expected.to be_html_safe }
-        end
-
-        context "when variant is less than master" do
-          let(:product_price) { 15 }
-
-          it { is_expected.to eq("(Subtract: $5.00)") }
-        end
-      end
-
-      context "when currency is JPY" do
-        let(:variant_price) { 100 }
-        let(:product_price) { 100 }
-        let(:currency) { 'JPY' }
-
-        context "when variant is more than master" do
-          let(:variant_price) { 150 }
-
-          it { is_expected.to eq("(Add: ¥50)") }
-        end
-
-        context "when variant is less than master" do
-          let(:product_price) { 150 }
-
-          it { is_expected.to eq("(Subtract: ¥50)") }
-        end
-      end
-    end
-
-    context "#variant_price_full" do
-      before do
-        Spree::Config[:show_variant_full_price] = true
-        @variant1 = create(:variant, product: product)
-        @variant2 = create(:variant, product: product)
-      end
-
-      context "when currency is default" do
-        it "should return the variant price if the price is different than master" do
-          product.price = 10
-          @variant1.price = 15
-          @variant2.price = 20
-          expect(helper.variant_price(@variant1)).to eq("$15.00")
-          expect(helper.variant_price(@variant2)).to eq("$20.00")
-        end
-      end
-
-      context "when currency is JPY" do
-        let(:currency) { 'JPY' }
-
-        before do
-          product.variants.active.each do |variant|
-            variant.prices.each do |price|
-              price.currency = currency
-              price.save!
-            end
-          end
-        end
-
-        it "should return the variant price if the price is different than master" do
-          product.price = 100
-          @variant1.price = 150
-          expect(helper.variant_price(@variant1)).to eq("¥150")
-        end
-      end
-
-      it "should be nil when all variant prices are equal" do
-        product.price = 10
-        @variant1.default_price.update_column(:amount, 10)
-        @variant2.default_price.update_column(:amount, 10)
-        expect(helper.variant_price(@variant1)).to be_nil
-        expect(helper.variant_price(@variant2)).to be_nil
-      end
-    end
-
-
-    context "#product_description" do
-      # Regression test for #1607
-      it "renders a product description without excessive paragraph breaks" do
-        product.description = %Q{
-<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. Vivamus a ligula leo. Proin eu arcu at ipsum dapibus ullamcorper. Pellentesque egestas orci nec magna condimentum luctus. Cum sociis natoque penatibus et magnis dis parturient montes, nascetur ridiculus mus. Ut ac ante et mauris bibendum ultricies non sed massa. Fusce facilisis dui eget lacus scelerisque eget aliquam urna ultricies. Duis et rhoncus quam. Praesent tellus nisi, ultrices sed iaculis quis, euismod interdum ipsum.</p>
-<ul>
-<li>Lorem ipsum dolor sit amet</li>
-<li>Lorem ipsum dolor sit amet</li>
-</ul>
-        }
-        description = product_description(product)
-        expect(description.strip).to eq(product.description.strip)
-      end
-
-      it "renders a product description with automatic paragraph breaks" do
-        product.description = %Q{
-THIS IS THE BEST PRODUCT EVER!
-
-"IT CHANGED MY LIFE" - Sue, MD}
-
-        description = product_description(product)
-        expect(description.strip).to eq(%Q{<p>\nTHIS IS THE BEST PRODUCT EVER!</p>"IT CHANGED MY LIFE" - Sue, MD})
-      end
-
-      it "renders a product description without any formatting based on configuration" do
-        initialDescription = %Q{
-            <p>hello world</p>
-
-            <p>tihs is completely awesome and it works</p>
-
-            <p>why so many spaces in the code. and why some more formatting afterwards?</p>
-        }
-
-        product.description = initialDescription
-
-        Spree::Config[:show_raw_product_description] = true
-        description = product_description(product)
-        expect(description).to eq(initialDescription)
-      end
-
-      context "renders a product description default description incase description is blank" do
-        before { product.description = '' }
-        it { expect(product_description(product)).to eq(Spree.t(:product_has_no_description)) }
-      end
-    end
-
-    shared_examples_for "line item descriptions" do
-      context 'variant has a blank description' do
-        let(:description) { nil }
-        it { is_expected.to eq(Spree.t(:product_has_no_description)) }
-      end
-      context 'variant has a description' do
-        let(:description) { 'test_desc' }
-        it { is_expected.to eq(description) }
-      end
-      context 'description has nonbreaking spaces' do
-        let(:description) { 'test&nbsp;desc' }
-        it { is_expected.to eq('test desc') }
-      end
-      context 'description has line endings' do
-        let(:description) { "test\n\r\ndesc" }
-        it { is_expected.to eq('test desc') }
-      end
-    end
-
-    context '#line_item_description_text' do
-      subject { line_item_description_text description }
-
-      it_should_behave_like "line item descriptions"
-    end
-
-    context '#cache_key_for_products' do
-      let(:zone) { Spree::Zone.new }
-      let(:price_options) { { tax_zone: zone } }
-
-      subject { helper.cache_key_for_products }
-      before(:each) do
-        @products = double('products collection')
-        allow(helper).to receive(:params) { {page: 10} }
-        allow(helper).to receive(:current_price_options) { price_options }
-      end
-
-      context 'when there is a maximum updated date' do
-        let(:updated_at) { Date.new(2011, 12, 13) }
-        before :each do
-          allow(@products).to receive(:count) { 5 }
-          allow(@products).to receive(:maximum).with(:updated_at) { updated_at }
-        end
-
-        it { is_expected.to eq("en/USD/spree/zones/new/spree/products/all-10-20111213-5") }
-      end
-
-      context 'when there is no considered maximum updated date' do
-        let(:today) { Date.new(2013, 12, 11) }
-        before :each do
-          allow(@products).to receive(:count) { 1234567 }
-          allow(@products).to receive(:maximum).with(:updated_at) { nil }
-          allow(Date).to receive(:today) { today }
-        end
-
-        it { is_expected.to eq("en/USD/spree/zones/new/spree/products/all-10-20131211-1234567") }
-      end
-    end
-
-    context "#cache_key_for_product" do
-      let(:product) { Spree::Product.new }
-      let(:price_options) { { tax_zone: zone } }
-
-      subject(:cache_key) { helper.cache_key_for_product(product) }
-
-      before do
-        allow(helper).to receive(:current_price_options) { price_options }
-      end
-
-      context "when there is a current tax zone" do
-        let(:zone) { Spree::Zone.new }
-
-        it "includes the current_tax_zone" do
-          is_expected.to eq("en/USD/spree/zones/new/spree/products/new/")
-        end
-      end
-
-      context "when there is no current tax zone" do
-        let(:zone) { nil }
-
-        it { is_expected.to eq("en/USD/spree/products/new/") }
-      end
-
-      context "when current_price_options includes nil values" do
-        let(:price_options) do
-          {
-            a: nil,
-            b: Spree::Zone.new
-          }
-        end
-
-        it "does not include nil values" do
-          expect(cache_key).to eq("en/USD/spree/zones/new/spree/products/new/")
-        end
-      end
-
-      context "when current_price_options includes values that do not implement cache_key" do
-        let(:price_options) do
-          {
-            a: true,
-            b: Spree::Zone.new
-          }
-        end
-
-        it "includes string representations of these values" do
-          expect(cache_key).to eq("en/USD/true/spree/zones/new/spree/products/new/")
-        end
-      end
-
-      context "when keys in the options hash are inserted in non-alphabetical order" do
-        let(:price_options) do
-          {
-            b: Spree::Zone.new,
-            a: true
-          }
-        end
-
-        it "the values are nevertheless returned in alphabetical order of their keys" do
-          expect(cache_key).to eq("en/USD/true/spree/zones/new/spree/products/new/")
-        end
-      end
-    end
-  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(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(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