spree_core 3.2.9 → 3.3.0.rc1

data/lib/tasks/exchanges.rake

@@ -2,23 +2,21 @@ namespace :exchanges do
   desc %q{Takes unreturned exchanged items and creates a new order to charge
   the customer for not returning them}
   task charge_unreturned_items: :environment do
-
-    unreturned_return_items =  Spree::ReturnItem.awaiting_return.exchange_processed.joins(:exchange_inventory_unit).where([
+    unreturned_return_items_scope = Spree::ReturnItem.awaiting_return.exchange_processed
+    unreturned_return_items = unreturned_return_items_scope.joins(:exchange_inventory_units).where([
       "spree_inventory_units.created_at < :days_ago AND spree_inventory_units.state = :iu_state",
       days_ago: Spree::Config[:expedited_exchanges_days_window].days.ago, iu_state: "shipped"
-    ]).to_a
+    ]).distinct.to_a
 
     # Determine that a return item has already been deemed unreturned and therefore charged
     # by the fact that its exchange inventory unit has popped off to a different order
-    unreturned_return_items.select! { |ri| ri.inventory_unit.order_id == ri.exchange_inventory_unit.order_id }
+    unreturned_return_items.select! { |ri| ri.exchange_inventory_units.exists?(order_id: ri.inventory_unit.order_id) }
 
     failed_orders = []
 
-    unreturned_return_items.group_by(&:exchange_shipment).each do |shipment, return_items|
+    unreturned_return_items.group_by(&:exchange_shipments).each do |shipments, return_items|
       begin
-        inventory_units = return_items.map(&:exchange_inventory_unit)
-
-        original_order = shipment.order
+        original_order = shipments.first.order
         order_attributes = {
           bill_address: original_order.bill_address,
           ship_address: original_order.ship_address,
@@ -30,7 +28,7 @@ namespace :exchanges do
         order.associate_user!(original_order.user) if original_order.user
 
         return_items.group_by(&:exchange_variant).map do |variant, variant_return_items|
-          variant_inventory_units = variant_return_items.map(&:exchange_inventory_unit)
+          variant_inventory_units = variant_return_items.map(&:exchange_inventory_units).flatten
           line_item = Spree::LineItem.create!(variant: variant, quantity: variant_return_items.count, order: order)
           variant_inventory_units.each { |i| i.update_attributes!(line_item_id: line_item.id, order_id: order.id) }
         end
@@ -50,7 +48,7 @@ namespace :exchanges do
         # the order builds a shipment on its own on transition to delivery, but we want
         # the original exchange shipment, not the built one
         order.shipments.destroy_all
-        shipment.update_attributes!(order_id: order.id)
+        shipments.each { |shipment| shipment.update_attributes!(order_id: order.id) }
         order.update_attributes!(state: "confirm")
 
         order.reload.next!

data/spec/helpers/base_helper_spec.rb

@@ -0,0 +1,200 @@
+require 'spec_helper'
+
+describe Spree::BaseHelper, type: :helper do
+  include Spree::BaseHelper
+
+  let(:current_store){ create :store }
+
+  context "available_countries" do
+    let(:country) { create(:country) }
+
+    before do
+      3.times { create(:country) }
+    end
+
+    context "with no checkout zone defined" do
+      before do
+        Spree::Config[:checkout_zone] = nil
+      end
+
+      it "return complete list of countries" do
+        expect(available_countries.count).to eq(Spree::Country.count)
+      end
+    end
+
+    context "with a checkout zone defined" do
+      context "checkout zone is of type country" do
+        before do
+          @country_zone = create(:zone, name: "CountryZone")
+          @country_zone.members.create(zoneable: country)
+          Spree::Config[:checkout_zone] = @country_zone.name
+        end
+
+        it "return only the countries defined by the checkout zone" do
+          expect(available_countries).to eq([country])
+        end
+      end
+
+      context "checkout zone is of type state" do
+        before do
+          state_zone = create(:zone, name: "StateZone")
+          state = create(:state, country: country)
+          state_zone.members.create(zoneable: state)
+          Spree::Config[:checkout_zone] = state_zone.name
+        end
+
+        it "return complete list of countries" do
+          expect(available_countries.count).to eq(Spree::Country.count)
+        end
+      end
+    end
+  end
+
+  # Regression test for #1436
+  context "defining custom image helpers" do
+    let(:product) { mock_model(Spree::Product, images: [], variant_images: []) }
+    before do
+      Spree::Image.class_eval do
+        attachment_definitions[:attachment][:styles].merge!({very_strange: '1x1'})
+      end
+    end
+
+    it "should not raise errors when style exists" do
+      expect { very_strange_image(product) }.not_to raise_error
+    end
+
+    it "should raise NoMethodError when style is not exists" do
+      expect { another_strange_image(product) }.to raise_error(NoMethodError)
+    end
+  end
+
+  context "link_to_tracking" do
+    it "returns tracking link if available" do
+      a = link_to_tracking_html(shipping_method: true, tracking: '123', tracking_url: 'http://g.c/?t=123').css('a')
+
+      expect(a.text).to eq '123'
+      expect(a.attr('href').value).to eq 'http://g.c/?t=123'
+    end
+
+    it "returns tracking without link if link unavailable" do
+      html = link_to_tracking_html(shipping_method: true, tracking: '123', tracking_url: nil)
+      expect(html.css('span').text).to eq '123'
+    end
+
+    it "returns nothing when no shipping method" do
+      html = link_to_tracking_html(shipping_method: nil, tracking: '123')
+      expect(html.css('span').text).to eq ''
+    end
+
+    it "returns nothing when no tracking" do
+      html = link_to_tracking_html(tracking: nil)
+      expect(html.css('span').text).to eq ''
+    end
+
+    def link_to_tracking_html(options = {})
+      node = link_to_tracking(double(:shipment, options))
+      Nokogiri::HTML(node.to_s)
+    end
+  end
+
+  # Regression test for #2396
+  context "meta_data_tags" do
+    it "truncates a product description to 160 characters" do
+      # Because the controller_name method returns "test"
+      # controller_name is used by this method to infer what it is supposed
+      # to be generating meta_data_tags for
+      text = FFaker::Lorem.paragraphs(2).join(" ")
+      @test = Spree::Product.new(description: text)
+      tags = Nokogiri::HTML.parse(meta_data_tags)
+      content = tags.css("meta[name=description]").first["content"]
+      assert content.length <= 160, "content length is not truncated to 160 characters"
+    end
+  end
+
+  # Regression test for #5384
+  context "custom image helpers conflict with inproper statements" do
+    let(:product) { mock_model(Spree::Product, images: [], variant_images: []) }
+    before do
+      Spree::Image.class_eval do
+        attachment_definitions[:attachment][:styles].merge!({foobar: '1x1'})
+      end
+    end
+
+    it "should not raise errors when helper method called" do
+      expect { foobar_image(product) }.not_to raise_error
+    end
+
+    it "should raise NoMethodError when statement with name equal to style name called" do
+      expect { foobar(product) }.to raise_error(NoMethodError)
+    end
+  end
+
+  context "pretty_time" do
+    it "prints in a format" do
+      expect(pretty_time(DateTime.new(2012, 5, 6, 13, 33))).to eq "May 06, 2012  1:33 PM"
+    end
+  end
+
+  describe "#display_price" do
+    let!(:product) { create(:product) }
+    let(:current_currency) { "USD" }
+    let(:current_price_options) { { tax_zone: current_tax_zone } }
+
+    context "when there is no current order" do
+      let (:current_tax_zone) { nil }
+
+      it "returns the price including default vat" do
+        expect(display_price(product)).to eq("$19.99")
+      end
+
+      context "with a default VAT" do
+        let(:current_tax_zone) { create(:zone_with_country, default_tax: true) }
+        let!(:tax_rate) do
+          create :tax_rate,
+                 included_in_price: true,
+                 zone: current_tax_zone,
+                 tax_category: product.tax_category,
+                 amount: 0.2
+        end
+
+        it "returns the price adding the VAT" do
+          expect(display_price(product)).to eq("$19.99")
+        end
+      end
+    end
+
+    context "with an order that has a tax zone" do
+      let(:current_tax_zone) { create(:zone_with_country) }
+      let(:current_order) { Spree::Order.new }
+      let(:default_zone) { create(:zone_with_country, default_tax: true) }
+
+      let!(:default_vat) do
+        create :tax_rate,
+               included_in_price: true,
+               zone: default_zone,
+               tax_category: product.tax_category,
+               amount: 0.2
+      end
+
+      context "that matches no VAT" do
+        it "returns the price excluding VAT" do
+          expect(display_price(product)).to eq("$16.66")
+        end
+      end
+
+      context "that matches a VAT" do
+        let!(:other_vat) do
+          create :tax_rate,
+                 included_in_price: true,
+                 zone: current_tax_zone,
+                 tax_category: product.tax_category,
+                 amount: 0.4
+        end
+
+        it "returns the price adding the VAT" do
+          expect(display_price(product)).to eq("$23.32")
+        end
+      end
+    end
+  end
+end

data/spec/helpers/products_helper_spec.rb

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