solidus_frontend 1.0.7 → 1.1.0.beta1

data/spec/controllers/spree/checkout_controller_with_views_spec.rb

@@ -1,36 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-# This spec is useful for when we just want to make sure a view is rendering correctly
-# Walking through the entire checkout process is rather tedious, don't you think?
-describe Spree::CheckoutController, type: :controller do
-  render_views
-  let(:token) { 'some_token' }
-  let(:user) { stub_model(Spree::LegacyUser) }
-
-  before do
-    allow(controller).to receive_messages try_spree_current_user: user
-  end
-
-  # Regression test for #3246
-  context "when using GBP" do
-    before do
-      Spree::Config[:currency] = "GBP"
-    end
-
-    context "when order is in delivery" do
-      before do
-        # Using a let block won't acknowledge the currency setting
-        # Therefore we just do it like this...
-        order = OrderWalkthrough.up_to(:address)
-        allow(controller).to receive_messages current_order: order
-      end
-
-      it "displays rate cost in correct currency" do
-        spree_get :edit
-        html = Nokogiri::HTML(response.body)
-        expect(html.css('.rate-cost').text).to eq "£10.00"
-      end
-    end
-  end
-end

data/spec/controllers/spree/content_controller_spec.rb

@@ -1,7 +0,0 @@
-require 'spec_helper'
-describe Spree::ContentController, :type => :controller do
-  it "should display CVV page" do
-    spree_get :cvv
-    expect(response.response_code).to eq(200)
-  end
-end

data/spec/controllers/spree/current_order_tracking_spec.rb

@@ -1,44 +0,0 @@
-require 'spec_helper'
-
-describe 'current order tracking', :type => :controller do
-  let(:user) { create(:user) }
-
-  controller(Spree::StoreController) do
-    def index
-      render :nothing => true
-    end
-  end
-
-  let(:order) { FactoryGirl.create(:order) }
-
-  it 'automatically tracks who the order was created by & IP address' do
-    allow(controller).to receive_messages(:try_spree_current_user => user)
-    get :index
-    expect(controller.current_order(create_order_if_necessary: true).created_by).to eq controller.try_spree_current_user
-    expect(controller.current_order.last_ip_address).to eq "0.0.0.0"
-  end
-
-  context "current order creation" do
-    before { allow(controller).to receive_messages(:try_spree_current_user => user) }
-
-    it "doesn't create a new order out of the blue" do
-      expect {
-        spree_get :index
-      }.not_to change { Spree::Order.count }
-    end
-  end
-end
-
-describe Spree::OrdersController, :type => :controller do
-  let(:user) { create(:user) }
-
-  before { allow(controller).to receive_messages(:try_spree_current_user => user) }
-
-  describe Spree::OrdersController do
-    it "doesn't create a new order out of the blue" do
-      expect {
-        spree_get :edit
-      }.not_to change { Spree::Order.count }
-    end
-  end
-end

data/spec/controllers/spree/home_controller_spec.rb

@@ -1,27 +0,0 @@
-require 'spec_helper'
-
-describe Spree::HomeController, :type => :controller do
-  it "provides current user to the searcher class" do
-    user = mock_model(Spree.user_class, :last_incomplete_spree_order => nil, :spree_api_key => 'fake')
-    allow(controller).to receive_messages :try_spree_current_user => user
-    expect_any_instance_of(Spree::Config.searcher_class).to receive(:current_user=).with(user)
-    spree_get :index
-    expect(response.status).to eq(200)
-  end
-
-  context "layout" do
-    it "renders default layout" do
-      spree_get :index
-      expect(response).to render_template(layout: 'spree/layouts/spree_application')
-    end
-
-    context "different layout specified in config" do
-      before { Spree::Config.layout = 'layouts/application' }
-
-      it "renders specified layout" do
-        spree_get :index
-        expect(response).to render_template(layout: 'layouts/application')
-      end
-    end
-  end
-end

data/spec/controllers/spree/orders_controller_ability_spec.rb

@@ -1,104 +0,0 @@
-require 'spec_helper'
-
-module Spree
-  describe OrdersController, :type => :controller do
-    ORDER_TOKEN = 'ORDER_TOKEN'
-
-    let(:user) { create(:user) }
-    let(:guest_user) { create(:user) }
-    let(:order) { Spree::Order.create }
-
-    it 'should understand order routes with token' do
-      expect(spree.token_order_path('R123456', 'ABCDEF')).to eq('/orders/R123456/token/ABCDEF')
-    end
-
-    context 'when an order exists in the cookies.signed' do
-      let(:token) { 'some_token' }
-      let(:specified_order) { create(:order) }
-
-      before do
-        allow(controller).to receive_messages :current_order => order
-        allow(controller).to receive_messages :spree_current_user => user
-      end
-
-      context '#populate' do
-        it 'should check if user is authorized for :edit' do
-          expect(controller).to receive(:authorize!).with(:edit, order, token)
-          spree_post :populate, :token => token
-        end
-        it "should check against the specified order" do
-          expect(controller).to receive(:authorize!).with(:edit, specified_order, token)
-          spree_post :populate, :id => specified_order.number, :token => token
-        end
-      end
-
-      context '#edit' do
-        it 'should check if user is authorized for :edit' do
-          expect(controller).to receive(:authorize!).with(:edit, order, token)
-          spree_get :edit, :token => token
-        end
-        it "should check against the specified order" do
-          expect(controller).to receive(:authorize!).with(:edit, specified_order, token)
-          spree_get :edit, :id => specified_order.number, :token => token
-        end
-      end
-
-      context '#update' do
-        it 'should check if user is authorized for :edit' do
-          allow(order).to receive :update_attributes
-          expect(controller).to receive(:authorize!).with(:edit, order, token)
-          spree_post :update, :order => { :email => "foo@bar.com" }, :token => token
-        end
-        it "should check against the specified order" do
-          allow(order).to receive :update_attributes
-          expect(controller).to receive(:authorize!).with(:edit, specified_order, token)
-          spree_post :update, :order => { :email => "foo@bar.com" }, :id => specified_order.number, :token => token
-        end
-      end
-
-      context '#empty' do
-        it 'should check if user is authorized for :edit' do
-          expect(controller).to receive(:authorize!).with(:edit, order, token)
-          spree_post :empty, :token => token
-        end
-        it "should check against the specified order" do
-          expect(controller).to receive(:authorize!).with(:edit, specified_order, token)
-          spree_post :empty, :id => specified_order.number, :token => token
-        end
-      end
-
-      context "#show" do
-        it "should check against the specified order" do
-          expect(controller).to receive(:authorize!).with(:edit, specified_order, token)
-          spree_get :show, :id => specified_order.number, :token => token
-        end
-      end
-    end
-
-    context 'when no authenticated user' do
-      let(:order) { create(:order, :number => 'R123') }
-
-      context '#show' do
-        context 'when token parameter present' do
-          it 'always ooverride existing token when passing a new one' do
-            cookies.signed[:guest_token] = "soo wrong"
-            spree_get :show, { :id => 'R123', :token => order.guest_token }
-            expect(cookies.signed[:guest_token]).to eq(order.guest_token)
-          end
-
-          it 'should store as guest_token in session' do
-            spree_get :show, {:id => 'R123', :token => order.guest_token }
-            expect(cookies.signed[:guest_token]).to eq(order.guest_token)
-          end
-        end
-
-        context 'when no token present' do
-          it 'should respond with 404' do
-            spree_get :show, {:id => 'R123'}
-            expect(response.code).to eq('404')
-          end
-        end
-      end
-    end
-  end
-end

data/spec/controllers/spree/orders_controller_spec.rb

@@ -1,134 +0,0 @@
-require 'spec_helper'
-
-describe Spree::OrdersController, :type => :controller do
-  let(:user) { create(:user) }
-
-  context "Order model mock" do
-    let(:order) do
-      Spree::Order.create!
-    end
-    let(:variant) { create(:variant) }
-
-    before do
-      allow(controller).to receive_messages(:try_spree_current_user => user)
-    end
-
-    context "#populate" do
-      it "should create a new order when none specified" do
-        spree_post :populate, {}, {}
-        expect(cookies.signed[:guest_token]).not_to be_blank
-        expect(Spree::Order.find_by_guest_token(cookies.signed[:guest_token])).to be_persisted
-      end
-
-      context "with Variant" do
-        it "should handle population" do
-          expect do
-            spree_post :populate, variant_id: variant.id, quantity: 5
-          end.to change { user.orders.count }.by(1)
-          order = user.orders.last
-          expect(response).to redirect_to spree.cart_path
-          expect(order.line_items.size).to eq(1)
-          line_item = order.line_items.first
-          expect(line_item.variant_id).to eq(variant.id)
-          expect(line_item.quantity).to eq(5)
-        end
-
-        it "shows an error when population fails" do
-          request.env["HTTP_REFERER"] = spree.root_path
-          allow_any_instance_of(Spree::LineItem).to(
-            receive(:valid?).and_return(false)
-          )
-          allow_any_instance_of(Spree::LineItem).to(
-            receive_message_chain(:errors, :full_messages).
-              and_return(["Order population failed"])
-          )
-
-          spree_post :populate, variant_id: variant.id, quantity: 5
-
-          expect(response).to redirect_to(spree.root_path)
-          expect(flash[:error]).to eq("Order population failed")
-        end
-
-        it "shows an error when quantity is invalid" do
-          request.env["HTTP_REFERER"] = spree.root_path
-
-          spree_post(
-            :populate,
-            variant_id: variant.id, quantity: -1
-          )
-
-          expect(response).to redirect_to(spree.root_path)
-          expect(flash[:error]).to eq(
-            Spree.t(:please_enter_reasonable_quantity)
-          )
-        end
-      end
-    end
-
-    context "#update" do
-      context "with authorization" do
-        before do
-          allow(controller).to receive :check_authorization
-          allow(controller).to receive_messages current_order: order
-        end
-
-        it "should render the edit view (on failure)" do
-          # email validation is only after address state
-          order.update_column(:state, "delivery")
-          spree_put :update, { :order => { :email => "" } }, { :order_id => order.id }
-          expect(response).to render_template :edit
-        end
-
-        it "should redirect to cart path (on success)" do
-          allow(order).to receive(:update_attributes).and_return true
-          spree_put :update, {}, {:order_id => 1}
-          expect(response).to redirect_to(spree.cart_path)
-        end
-      end
-    end
-
-    context "#empty" do
-      before do
-        allow(controller).to receive :check_authorization
-      end
-
-      it "should destroy line items in the current order" do
-        allow(controller).to receive(:current_order).and_return(order)
-        expect(order).to receive(:empty!)
-        spree_put :empty
-        expect(response).to redirect_to(spree.cart_path)
-      end
-    end
-
-    # Regression test for #2750
-    context "#update" do
-      before do
-        allow(user).to receive :last_incomplete_spree_order
-        allow(controller).to receive :set_current_order
-      end
-
-      it "cannot update a blank order" do
-        spree_put :update, :order => { :email => "foo" }
-        expect(flash[:error]).to eq(Spree.t(:order_not_found))
-        expect(response).to redirect_to(spree.root_path)
-      end
-    end
-  end
-
-  context "line items quantity is 0" do
-    let(:order) { Spree::Order.create }
-    let(:variant) { create(:variant) }
-    let!(:line_item) { order.contents.add(variant, 1) }
-
-    before do
-      allow(controller).to receive(:check_authorization)
-      allow(controller).to receive_messages(:current_order => order)
-    end
-
-    it "removes line items on update" do
-      expect(order.line_items.count).to eq 1
-      spree_put :update, :order => { line_items_attributes: { "0" => { id: line_item.id, quantity: 0 } } }
-      expect(order.reload.line_items.count).to eq 0
-    end
-  end
-end

data/spec/controllers/spree/orders_controller_transitions_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-Spree::Order.class_eval do
-  attr_accessor :did_transition
-end
-
-module Spree
-  describe OrdersController, :type => :controller do
-    # Regression test for #2004
-    context "with a transition callback on first state" do
-      let(:order) { Spree::Order.new }
-
-      before do
-        allow(controller).to receive_messages :current_order => order
-        expect(controller).to receive(:authorize!).at_least(:once).and_return(true)
-
-        first_state, _ = Spree::Order.checkout_steps.first
-        Spree::Order.state_machine.after_transition :to => first_state do |order|
-          order.did_transition = true
-        end
-      end
-
-      it "correctly calls the transition callback" do
-        expect(order.did_transition).to be_nil
-        order.line_items << FactoryGirl.create(:line_item)
-        spree_put :update, { :checkout => "checkout" }, { :order_id => 1}
-        expect(order.did_transition).to be true
-      end
-    end
-  end
-end

data/spec/controllers/spree/products_controller_spec.rb

@@ -1,36 +0,0 @@
-require 'spec_helper'
-
-describe Spree::ProductsController, :type => :controller do
-  let!(:product) { create(:product, :available_on => 1.year.from_now) }
-
-  # Regression test for #1390
-  it "allows admins to view non-active products" do
-    allow(controller).to receive_messages :spree_current_user => mock_model(Spree.user_class, :has_spree_role? => true, :last_incomplete_spree_order => nil, :spree_api_key => 'fake')
-    spree_get :show, :id => product.to_param
-    expect(response.status).to eq(200)
-  end
-
-  it "cannot view non-active products" do
-    spree_get :show, :id => product.to_param
-    expect(response.status).to eq(404)
-  end
-
-  it "should provide the current user to the searcher class" do
-    user = mock_model(Spree.user_class, :last_incomplete_spree_order => nil, :spree_api_key => 'fake')
-    allow(controller).to receive_messages :spree_current_user => user
-    expect_any_instance_of(Spree::Config.searcher_class).to receive(:current_user=).with(user)
-    spree_get :index
-    expect(response.status).to eq(200)
-  end
-
-  # Regression test for #2249
-  it "doesn't error when given an invalid referer" do
-    current_user = mock_model(Spree.user_class, :has_spree_role? => true, :last_incomplete_spree_order => nil, :generate_spree_api_key! => nil)
-    allow(controller).to receive_messages :spree_current_user => current_user
-    request.env['HTTP_REFERER'] = "not|a$url"
-
-    # Previously a URI::InvalidURIError exception was being thrown
-    expect { spree_get :show, :id => product.to_param }.not_to raise_error
-  end
-
-end

data/spec/controllers/spree/taxons_controller_spec.rb

@@ -1,12 +0,0 @@
-require 'spec_helper'
-
-describe Spree::TaxonsController, :type => :controller do
-  it "should provide the current user to the searcher class" do
-    taxon = create(:taxon, :permalink => "test")
-    user = mock_model(Spree.user_class, :last_incomplete_spree_order => nil, :spree_api_key => 'fake')
-    allow(controller).to receive_messages :spree_current_user => user
-    expect_any_instance_of(Spree::Config.searcher_class).to receive(:current_user=).with(user)
-    spree_get :show, :id => taxon.permalink
-    expect(response.status).to eq(200)
-  end
-end

data/spec/features/address_spec.rb

@@ -1,76 +0,0 @@
-require 'spec_helper'
-
-describe "Address", type: :feature, inaccessible: true do
-  let!(:product) { create(:product, :name => "RoR Mug") }
-  let!(:order) { create(:order_with_totals, :state => 'cart') }
-
-  stub_authorization!
-
-  before do
-    visit spree.root_path
-
-    click_link "RoR Mug"
-    click_button "add-to-cart-button"
-
-    address = "order_bill_address_attributes"
-    @country_css = "#{address}_country_id"
-    @state_select_css = "##{address}_state_id"
-    @state_name_css = "##{address}_state_name"
-  end
-
-  context "country requires state", :js => true, :focus => true do
-    let!(:canada) { create(:country, :name => "Canada", :states_required => true, :iso => "CA") }
-    let!(:uk) { create(:country, :name => "United Kingdom", :states_required => true, :iso => "UK") }
-
-    before { Spree::Config[:default_country_id] = uk.id }
-
-    context "but has no state" do
-      it "shows the state input field" do
-        click_button "Checkout"
-
-        select canada.name, :from => @country_css
-        expect(page).to have_no_css(@state_select_css)
-        expect(page).to have_css("#{@state_name_css}.required")
-      end
-    end
-
-    context "and has state" do
-      before { create(:state, :name => "Ontario", :country => canada) }
-
-      it "shows the state collection selection" do
-        click_button "Checkout"
-
-        select canada.name, :from => @country_css
-        expect(page).to have_no_css(@state_name_css)
-        expect(page).to have_css("#{@state_select_css}.required")
-      end
-    end
-
-    context "user changes to country without states required" do
-      let!(:france) { create(:country, :name => "France", :states_required => false, :iso => "FRA") }
-
-      it "clears the state name" do
-        click_button "Checkout"
-        select canada.name, :from => @country_css
-        page.find(@state_name_css).set("Toscana")
-
-        select france.name, :from => @country_css
-
-        expect(page).to have_no_css(@state_name_css)
-        expect(page).to have_no_css(@state_select_css)
-      end
-    end
-  end
-
-  context "country does not require state", :js => true do
-    let!(:france) { create(:country, :name => "France", :states_required => false, :iso => "FRA") }
-
-    it "shows a disabled state input field" do
-       click_button "Checkout"
-
-       select france.name, :from => @country_css
-       expect(page).to have_no_css(@state_name_css)
-       expect(page).to have_css("#{@state_select_css}[disabled]", visible: false)
-    end
-  end
-end