spree_frontend 3.1.5 → 3.1.6

data/spec/features/checkout_unshippable_spec.rb

@@ -1,34 +0,0 @@
-require 'spec_helper'
-
-describe "checkout with unshippable items", type: :feature, inaccessible: true do
-  let!(:stock_location) { create(:stock_location) }
-  let(:order) { OrderWalkthrough.up_to(:delivery) }
-
-  before do
-    OrderWalkthrough.add_line_item!(order)
-    line_item = order.line_items.last
-    stock_item = stock_location.stock_item(line_item.variant)
-    stock_item.adjust_count_on_hand -999
-    stock_item.backorderable = false
-    stock_item.save!
-
-    user = create(:user)
-    order.user = user
-    order.update_with_updater!
-
-    allow_any_instance_of(Spree::CheckoutController).to receive_messages(:current_order => order)
-    allow_any_instance_of(Spree::CheckoutController).to receive_messages(:try_spree_current_user => user)
-    allow_any_instance_of(Spree::CheckoutController).to receive_messages(:skip_state_validation? => true)
-    allow_any_instance_of(Spree::CheckoutController).to receive_messages(:ensure_sufficient_stock_lines => true)
-  end
-
-  it 'displays and removes' do
-    visit spree.checkout_state_path(:delivery)
-    expect(page).to have_content('Unshippable Items')
-
-    click_button "Save and Continue"
-
-    order.reload
-    expect(order.line_items.count).to eq 1
-  end
-end

data/spec/features/coupon_code_spec.rb

@@ -1,88 +0,0 @@
-require 'spec_helper'
-
-describe "Coupon code promotions", type: :feature, js: true do
-  let!(:country) { create(:country, name: "United States of America", states_required: true) }
-  let!(:state) { create(:state, name: "Alabama", country: country) }
-  let!(:zone) { create(:zone) }
-  let!(:shipping_method) { create(:shipping_method) }
-  let!(:payment_method) { create(:check_payment_method) }
-  let!(:product) { create(:product, name: "RoR Mug", price: 20) }
-  let!(:store) { create(:store) }
-
-  context "visitor makes checkout as guest without registration" do
-    def create_basic_coupon_promotion(code)
-      promotion = Spree::Promotion.create!(name:       code.titleize,
-                                           code:       code,
-                                           starts_at:  1.day.ago,
-                                           expires_at: 1.day.from_now)
-
-      calculator = Spree::Calculator::FlatRate.new
-      calculator.preferred_amount = 10
-
-      action = Spree::Promotion::Actions::CreateItemAdjustments.new
-      action.calculator = calculator
-      action.promotion = promotion
-      action.save
-
-      promotion.reload # so that promotion.actions is available
-    end
-
-    let!(:promotion) { create_basic_coupon_promotion("onetwo") }
-
-    # OrdersController
-    context "on the payment page" do
-      before do
-        visit spree.root_path
-        click_link "RoR Mug"
-        click_button "add-to-cart-button"
-        click_button "Checkout"
-        fill_in "order_email", with: "spree@example.com"
-        fill_in "First Name", with: "John"
-        fill_in "Last Name", with: "Smith"
-        fill_in "Street Address", with: "1 John Street"
-        fill_in "City", with: "City of John"
-        fill_in "Zip", with: "01337"
-        select country.name, from: "Country"
-        select state.name, from: "order[bill_address_attributes][state_id]"
-        fill_in "Phone", with: "555-555-5555"
-
-        # To shipping method screen
-        click_button "Save and Continue"
-        # To payment screen
-        click_button "Save and Continue"
-      end
-
-      it "informs about an invalid coupon code" do
-        fill_in "order_coupon_code", with: "coupon_codes_rule_man"
-        click_button "Save and Continue"
-        expect(page).to have_content(Spree.t(:coupon_code_not_found))
-      end
-
-      it "informs the user about a coupon code which has exceeded its usage" do
-        promotion.update_column(:usage_limit, 5)
-        allow_any_instance_of(promotion.class).to receive_messages(credits_count: 10)
-
-        fill_in "order_coupon_code", with: "onetwo"
-        click_button "Save and Continue"
-        expect(page).to have_content(Spree.t(:coupon_code_max_usage))
-      end
-
-      it "can enter an invalid coupon code, then a real one" do
-        fill_in "order_coupon_code", with: "coupon_codes_rule_man"
-        click_button "Save and Continue"
-        expect(page).to have_content(Spree.t(:coupon_code_not_found))
-        fill_in "order_coupon_code", with: "onetwo"
-        click_button "Save and Continue"
-        expect(page).to have_content("Promotion (Onetwo)   -$10.00")
-      end
-
-      context "with a promotion" do
-        it "applies a promotion to an order" do
-          fill_in "order_coupon_code", with: "onetwo"
-          click_button "Save and Continue"
-          expect(page).to have_content("Promotion (Onetwo)   -$10.00")
-        end
-      end
-    end
-  end
-end

data/spec/features/currency_spec.rb

@@ -1,18 +0,0 @@
-require 'spec_helper'
-
-describe "Switching currencies in backend", :type => :feature do
-  before do
-    create(:base_product, :name => "RoR Mug")
-  end
-
-  # Regression test for #2340
-  it "does not cause current_order to become nil", inaccessible: true do
-    visit spree.root_path
-    click_link "RoR Mug"
-    click_button "Add To Cart"
-    # Now that we have an order...
-    Spree::Config[:currency] = "AUD"
-    expect { visit spree.root_path }.not_to raise_error
-  end
-
-end

data/spec/features/free_shipping_promotions_spec.rb

@@ -1,59 +0,0 @@
-require 'spec_helper'
-
-describe "Free shipping promotions", :type => :feature, :js => true do
-  let!(:country) { create(:country, :name => "United States of America", :states_required => true) }
-  let!(:state) { create(:state, :name => "Alabama", :country => country) }
-  let!(:zone) { create(:zone) }
-  let!(:shipping_method) do
-    sm = create(:shipping_method)
-    sm.calculator.preferred_amount = 10
-    sm.calculator.save
-    sm
-  end
-
-  let!(:payment_method) { create(:check_payment_method) }
-  let!(:product) { create(:product, :name => "RoR Mug", :price => 20) }
-  let!(:promotion) do
-    promotion = Spree::Promotion.create!(:name       => "Free Shipping",
-                                         :starts_at  => 1.day.ago,
-                                         :expires_at => 1.day.from_now)
-
-    action = Spree::Promotion::Actions::FreeShipping.new
-    action.promotion = promotion
-    action.save
-
-    promotion.reload # so that promotion.actions is available
-  end
-
-  context "free shipping promotion automatically applied" do
-    before do
-
-      visit spree.root_path
-      click_link "RoR Mug"
-      click_button "add-to-cart-button"
-      click_button "Checkout"
-      fill_in "order_email", :with => "spree@example.com"
-      fill_in "First Name", :with => "John"
-      fill_in "Last Name", :with => "Smith"
-      fill_in "Street Address", :with => "1 John Street"
-      fill_in "City", :with => "City of John"
-      fill_in "Zip", :with => "01337"
-      select country.name, :from => "Country"
-      select state.name, :from => "order[bill_address_attributes][state_id]"
-      fill_in "Phone", :with => "555-555-5555"
-
-      # To shipping method screen
-      click_button "Save and Continue"
-      # To payment screen
-      click_button "Save and Continue"
-    end
-
-    # Regression test for #4428
-    it "applies the free shipping promotion" do
-      within("#checkout-summary") do
-        expect(page).to have_content("Shipping total:  $10.00")
-        expect(page).to have_content("Promotion (Free Shipping): -$10.00")
-      end
-    end
-  end
-end

data/spec/features/locale_spec.rb

@@ -1,60 +0,0 @@
-require 'spec_helper'
-
-describe 'setting locale', type: :feature do
-  def with_locale(locale)
-    I18n.locale = locale
-    Spree::Frontend::Config[:locale] = locale
-    yield
-    I18n.locale = 'en'
-    Spree::Frontend::Config[:locale] = 'en'
-  end
-
-  context 'shopping cart link and page' do
-    before do
-      I18n.backend.store_translations(:fr,
-       spree: {
-         cart: 'Panier',
-         shopping_cart: 'Panier'
-      })
-    end
-
-    it 'should be in french' do
-      with_locale('fr') do
-        visit spree.root_path
-        click_link 'Panier'
-        expect(page).to have_content('Panier')
-      end
-    end
-  end
-
-  context 'checkout form validation messages' do
-    include_context 'checkout setup'
-
-    let(:error_messages) do
-      {
-        'en' => 'This field is required.',
-        'fr' => 'Ce champ est obligatoire.',
-        'de' => 'Dieses Feld ist ein Pflichtfeld.',
-      }
-    end
-
-    def check_error_text(text)
-      %w(firstname lastname address1 city).each do |attr|
-        expect(find("#b#{attr} label.error").text).to eq(text)
-      end
-    end
-
-    it 'shows translated jquery.validate error messages', js: true do
-      visit spree.root_path
-      click_link mug.name
-      click_button 'add-to-cart-button'
-      error_messages.each do |locale, message|
-        with_locale(locale) do
-          visit '/checkout/address'
-          find('.form-buttons input[type=submit]').click
-          check_error_text message
-        end
-      end
-    end
-  end
-end

data/spec/features/order_spec.rb

@@ -1,74 +0,0 @@
-require 'spec_helper'
-
-describe 'orders', :type => :feature do
-  let(:order) { OrderWalkthrough.up_to(:complete) }
-  let(:user) { create(:user) }
-
-  before do
-    order.update_attribute(:user_id, user.id)
-    order.shipments.destroy_all
-    allow_any_instance_of(Spree::OrdersController).to receive_messages(:try_spree_current_user => user)
-  end
-
-  it "can visit an order" do
-    # Regression test for current_user call on orders/show
-    expect { visit spree.order_path(order) }.not_to raise_error
-  end
-
-  it "should display line item price" do
-    # Regression test for #2772
-    line_item = order.line_items.first
-    line_item.target_shipment = create(:shipment)
-    line_item.price = 19.00
-    line_item.save!
-
-    visit spree.order_path(order)
-
-    # Tests view spree/shared/_order_details
-    within 'td.price' do
-      expect(page).to have_content "19.00"
-    end
-  end
-
-  it "should have credit card info if paid with credit card" do
-    create(:payment, :order => order)
-    visit spree.order_path(order)
-    within '.payment-info' do
-      expect(page).to have_content "Ending in 1111"
-    end
-  end
-
-  it "should have payment method name visible if not paid with credit card" do
-    create(:check_payment, :order => order)
-    visit spree.order_path(order)
-    within '.payment-info' do
-      expect(page).to have_content "Check"
-    end
-  end
-
-  # Regression test for #2282
-  context "can support a credit card with blank information" do
-    before do
-      credit_card = create(:credit_card)
-      credit_card.update_column(:cc_type, '')
-      payment = order.payments.first
-      payment.source = credit_card
-      payment.save!
-    end
-
-    specify do
-      visit spree.order_path(order)
-      within '.payment-info' do
-        expect { find("img") }.to raise_error(Capybara::ElementNotFound)
-      end
-    end
-  end
-
-  it "should return the correct title when displaying a completed order" do
-    visit spree.order_path(order)
-
-    within '#order_summary' do
-      expect(page).to have_content("#{Spree.t(:order)} #{order.number}")
-    end
-  end
-end

data/spec/features/page_promotions_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe 'page promotions', :type => :feature do
-  let!(:product) { create(:product, :name => "RoR Mug", :price => 20) }
-  before do
-    promotion = Spree::Promotion.create!(:name       => "$10 off",
-                                         :path       => 'test',
-                                         :starts_at  => 1.day.ago,
-                                         :expires_at => 1.day.from_now)
-
-   calculator = Spree::Calculator::FlatRate.new
-   calculator.preferred_amount = 10
-
-   action = Spree::Promotion::Actions::CreateItemAdjustments.create(:calculator => calculator)
-   promotion.actions << action
-
-   visit spree.root_path
-   click_link "RoR Mug"
-   click_button "add-to-cart-button"
-  end
-
-  it "automatically applies a page promotion upon visiting" do
-    expect(page).not_to have_content("Promotion ($10 off) -$10.00")
-    visit '/content/test'
-    visit '/cart'
-    expect(page).to have_content("Promotion ($10 off) -$10.00")
-    expect(page).to have_content("Subtotal (1 item) $20.00")
-  end
-
-  it "does not activate an adjustment for a path that doesn't have a promotion" do
-    expect(page).not_to have_content("Promotion ($10 off) -$10.00")
-    visit '/content/cvv'
-    visit '/cart'
-    expect(page).not_to have_content("Promotion ($10 off) -$10.00")
-  end
-end

data/spec/features/products_spec.rb

@@ -1,334 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe "Visiting Products", type: :feature, inaccessible: true do
-  include_context "custom products"
-
-  let(:store_name) do
-    ((first_store = Spree::Store.first) && first_store.name).to_s
-  end
-
-  before(:each) do
-    visit spree.root_path
-  end
-
-  it "should be able to show the shopping cart after adding a product to it" do
-    click_link "Ruby on Rails Ringer T-Shirt"
-    expect(page).to have_content("$19.99")
-
-    click_button 'add-to-cart-button'
-    expect(page).to have_content("Shopping Cart")
-  end
-
-  describe "correct displaying of microdata" do
-    let(:products) { Spree::TestingSupport::Microdata::Document.new(page.body).extract_items }
-    let(:ringer) { products.keep_if { |product| product.properties["name"].first.match("Ringer") }.first }
-
-    it "correctly displays the product name via microdata" do
-      expect(ringer.properties["name"]).to eq ["Ruby on Rails Ringer T-Shirt"]
-    end
-
-    it "correctly displays the product image via microdata" do
-      expect(ringer.properties['image'].first).to include '/assets/noimage/small'
-    end
-
-    it "correctly displays the product url via microdata" do
-      expect(ringer.properties["url"]).to eq ["/products/ruby-on-rails-ringer-t-shirt"]
-    end
-  end
-
-  describe 'meta tags and title' do
-    let(:jersey) { Spree::Product.find_by_name('Ruby on Rails Baseball Jersey') }
-    let(:metas) { { meta_description: 'Brand new Ruby on Rails Jersey', meta_title: 'Ruby on Rails Baseball Jersey Buy High Quality Geek Apparel', meta_keywords: 'ror, jersey, ruby' } }
-
-    it 'should return the correct title when displaying a single product' do
-      click_link jersey.name
-      expect(page).to have_title('Ruby on Rails Baseball Jersey - ' + store_name)
-      within('div#product-description') do
-        within('h1.product-title') do
-          expect(page).to have_content('Ruby on Rails Baseball Jersey')
-        end
-      end
-    end
-
-    it 'displays metas' do
-      jersey.update_attributes metas
-      click_link jersey.name
-      expect(page).to have_meta(:description, 'Brand new Ruby on Rails Jersey')
-      expect(page).to have_meta(:keywords, 'ror, jersey, ruby')
-    end
-
-    it 'displays title if set' do
-      jersey.update_attributes metas
-      click_link jersey.name
-      expect(page).to have_title('Ruby on Rails Baseball Jersey Buy High Quality Geek Apparel')
-    end
-
-    it "doesn't use meta_title as heading on page" do
-      jersey.update_attributes metas
-      click_link jersey.name
-      within("h1") do
-        expect(page).to have_content(jersey.name)
-        expect(page).not_to have_content(jersey.meta_title)
-      end
-    end
-
-    it 'uses product name in title when meta_title set to empty string' do
-      jersey.update_attributes meta_title: ''
-      click_link jersey.name
-      expect(page).to have_title('Ruby on Rails Baseball Jersey - ' + store_name)
-    end
-  end
-
-  context "using Russian Rubles as a currency" do
-    before do
-      Spree::Config[:currency] = "RUB"
-    end
-
-    let!(:product) do
-      product = Spree::Product.find_by_name("Ruby on Rails Ringer T-Shirt")
-      product.price = 19.99
-      product.tap(&:save)
-    end
-
-    # Regression tests for #2737
-    context "uses руб as the currency symbol" do
-      it "on products page" do
-        visit spree.root_path
-        within("#product_#{product.id}") do
-          within(".price") do
-            expect(page).to have_content("19.99 ₽")
-          end
-        end
-      end
-
-      it "on product page" do
-        visit spree.product_path(product)
-        within(".price") do
-          expect(page).to have_content("19.99 ₽")
-        end
-      end
-
-      it "when adding a product to the cart", js: true do
-        visit spree.product_path(product)
-        click_button "Add To Cart"
-        click_link "Home"
-        within(".cart-info") do
-          expect(page).to have_content("19.99 ₽")
-        end
-      end
-
-      it "when on the 'address' state of the cart", js: true do
-        visit spree.product_path(product)
-        click_button "Add To Cart"
-        click_button "Checkout"
-        fill_in "order_email", with: "test@example.com"
-        click_button 'Continue'
-        within("tr[data-hook=item_total]") do
-          expect(page).to have_content("19.99 ₽")
-        end
-      end
-    end
-  end
-
-  it "should be able to search for a product" do
-    fill_in "keywords", with: "shirt"
-    click_button "Search"
-
-    expect(page.all('#products .product-list-item').size).to eq(1)
-  end
-
-  context "a product with variants" do
-    let(:product) { Spree::Product.find_by_name("Ruby on Rails Baseball Jersey") }
-    let(:option_value) { create(:option_value) }
-    let!(:variant) { build(:variant, price: 5.59, product: product, option_values: []) }
-
-    before do
-      # Need to have two images to trigger the error
-      image = File.open(File.expand_path('../../fixtures/thinking-cat.jpg', __FILE__))
-      product.images.create!(:attachment => image)
-      product.images.create!(:attachment => image)
-
-      product.option_types << option_value.option_type
-      variant.option_values << option_value
-      variant.save!
-    end
-
-    it "should be displayed" do
-      expect { click_link product.name }.to_not raise_error
-    end
-
-    it "displays price of first variant listed", js: true do
-      click_link product.name
-      within("#product-price") do
-        expect(page).to have_content variant.price
-        expect(page).not_to have_content Spree.t(:out_of_stock)
-      end
-    end
-
-    it "doesn't display out of stock for master product" do
-      product.master.stock_items.update_all count_on_hand: 0, backorderable: false
-
-      click_link product.name
-      within("#product-price") do
-        expect(page).not_to have_content Spree.t(:out_of_stock)
-      end
-    end
-
-    it "doesn't display cart form if all variants (including master) are out of stock" do
-      product.variants_including_master.each { |v| v.stock_items.update_all count_on_hand: 0, backorderable: false }
-
-      click_link product.name
-      within("[data-hook=product_price]") do
-        expect(page).not_to have_content Spree.t(:add_to_cart)
-      end
-    end
-  end
-
-  context "a product with variants, images only for the variants" do
-    let(:product) { Spree::Product.find_by_name("Ruby on Rails Baseball Jersey") }
-    let(:variant1) { create(:variant, product: product, price: 9.99) }
-    let(:variant2) { create(:variant, product: product, price: 10.99) }
-
-    before do
-      image = File.open(File.expand_path('../../fixtures/thinking-cat.jpg', __FILE__))
-      variant1.images.create!(attachment: image)
-      variant2.images.create!(attachment: image)
-    end
-
-    it "should not display no image available" do
-      visit spree.root_path
-      expect(page).to have_xpath("//img[contains(@src,'thinking-cat')]")
-    end
-  end
-
-  context "an out of stock product without variants" do
-    let(:product) { Spree::Product.find_by_name("Ruby on Rails Tote") }
-
-    before do
-      product.master.stock_items.update_all count_on_hand: 0, backorderable: false
-    end
-
-    it "does display out of stock for master product" do
-      click_link product.name
-      within("#product-price") do
-        expect(page).to have_content Spree.t(:out_of_stock)
-      end
-    end
-
-    it "doesn't display cart form if master is out of stock" do
-      click_link product.name
-      within("[data-hook=product_price]") do
-        expect(page).not_to have_content Spree.t(:add_to_cart)
-      end
-    end
-  end
-
-  context 'product with taxons' do
-    let(:product) { Spree::Product.find_by_name("Ruby on Rails Tote") }
-    let(:taxon) { product.taxons.first }
-
-    it 'displays breadcrumbs for the default taxon when none selected' do
-      click_link product.name
-      within("#breadcrumbs") do
-        expect(page).to have_content taxon.name
-      end
-    end
-
-    it 'displays selected taxon in breadcrumbs' do
-      taxon = Spree::Taxon.last
-      product.taxons << taxon
-      product.save!
-      visit '/t/' + taxon.to_param
-      click_link product.name
-      within("#breadcrumbs") do
-        expect(page).to have_content taxon.name
-      end
-    end
-  end
-
-  it "should be able to hide products without price" do
-    expect(page.all('#products .product-list-item').size).to eq(9)
-    Spree::Config.show_products_without_price = false
-    Spree::Config.currency = "CAN"
-    visit spree.root_path
-    expect(page.all('#products .product-list-item').size).to eq(0)
-  end
-
-
-  it "should be able to display products priced under 10 dollars" do
-    within(:css, '#taxonomies') { click_link "Ruby on Rails" }
-    check "Price_Range_Under_$10.00"
-    within(:css, '#sidebar_products_search') { click_button "Search" }
-    expect(page).to have_content("No products found")
-  end
-
-  it "should be able to display products priced between 15 and 18 dollars" do
-    within(:css, '#taxonomies') { click_link "Ruby on Rails" }
-    check "Price_Range_$15.00_-_$18.00"
-    within(:css, '#sidebar_products_search') { click_button "Search" }
-
-    expect(page.all('#products .product-list-item').size).to eq(3)
-    tmp = page.all('#products .product-list-item a').map(&:text).flatten.compact
-    tmp.delete("")
-    expect(tmp.sort!).to eq(["Ruby on Rails Mug", "Ruby on Rails Stein", "Ruby on Rails Tote"])
-  end
-
-  it "should be able to display products priced between 15 and 18 dollars across multiple pages" do
-    Spree::Config.products_per_page = 2
-    within(:css, '#taxonomies') { click_link "Ruby on Rails" }
-    check "Price_Range_$15.00_-_$18.00"
-    within(:css, '#sidebar_products_search') { click_button "Search" }
-
-    expect(page.all('#products .product-list-item').size).to eq(2)
-    products = page.all('#products .product-list-item span[itemprop=name]')
-    expect(products.count).to eq(2)
-
-    find('.pagination .next a').click
-    products = page.all('#products .product-list-item span[itemprop=name]')
-    expect(products.count).to eq(1)
-  end
-
-  it "should be able to display products priced 18 dollars and above" do
-    within(:css, '#taxonomies') { click_link "Ruby on Rails" }
-    check "Price_Range_$18.00_-_$20.00"
-    check "Price_Range_$20.00_or_over"
-    within(:css, '#sidebar_products_search') { click_button "Search" }
-
-    expect(page.all('#products .product-list-item').size).to eq(4)
-    tmp = page.all('#products .product-list-item a').map(&:text).flatten.compact
-    tmp.delete("")
-    expect(tmp.sort!).to eq(["Ruby on Rails Bag",
-                         "Ruby on Rails Baseball Jersey",
-                         "Ruby on Rails Jr. Spaghetti",
-                         "Ruby on Rails Ringer T-Shirt"])
-  end
-
-  it "should be able to put a product without a description in the cart" do
-    product = FactoryGirl.create(:base_product, :description => nil, :name => 'Sample', :price => '19.99')
-    visit spree.product_path(product)
-    expect(page).to have_content "This product has no description"
-    click_button 'add-to-cart-button'
-    expect(page).to have_content "This product has no description"
-  end
-
-  it "shouldn't be able to put a product without a current price in the cart" do
-    product = FactoryGirl.create(:base_product, :description => nil, :name => 'Sample', :price => '19.99')
-    Spree::Config.currency = "CAN"
-    Spree::Config.show_products_without_price = true
-    visit spree.product_path(product)
-    expect(page).to have_content "This product is not available in the selected currency."
-    expect(page).not_to have_content "add-to-cart-button"
-  end
-
-  it "should return the correct title when displaying a single product" do
-    product = Spree::Product.find_by_name("Ruby on Rails Baseball Jersey")
-    click_link product.name
-
-    within("div#product-description") do
-      within("h1.product-title") do
-        expect(page).to have_content("Ruby on Rails Baseball Jersey")
-      end
-    end
-  end
-end