solidus_frontend 1.1.0 → 1.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8ad1542e9b72fbbb94234f29a5152046547bde16
-  data.tar.gz: ea41c5e70d3b926c821a5c7f8ea8205be50fbf30
+  metadata.gz: 91e44cc077f8c0722c34d2e140538dfc7b93666f
+  data.tar.gz: 526ec8a133539279d5e019f4f5d615ca280df47f
 SHA512:
-  metadata.gz: cfaf5acb4bf0053d1c29b1cf059cae7c49a4c01b809b03ab7d2838ab82ded99de39ebd2847c297b98b25c594050cb4675724101e4c01d54f7e28cd2bdb27f551
-  data.tar.gz: 5b2859edac2ca908c938174d06251f442f9fd52338c78a67a42f0c67afef1243fb15f3eb5b9e333bc83fbf33d555c55820a0864ef696371ad3007a8245d36875
+  metadata.gz: 518839b6bcd447a9a06bd8d248021250d9c28d2f2a345d40dbe4e1f44a6cb166ad18acbd62e59c8fc6dccc7987ec19a50be17cff062a6fdbabe3dab05c93eccb
+  data.tar.gz: a6a22da41038fadfd08b04cf21537b730027623a2997ef49ba7394b52305c6de43d8cf0bdd09f99b6290182be72eb57567f6bb930995e33e7eef80665d4ca4a4

data/Gemfile

@@ -0,0 +1,6 @@
+eval(File.read(File.dirname(__FILE__) + '/../common_spree_dependencies.rb'))
+
+gem 'solidus_core', :path => '../core'
+gem 'solidus_api', :path => '../api'
+
+gemspec

data/Rakefile

@@ -0,0 +1,15 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+require 'rspec/core/rake_task'
+require 'spree/testing_support/common_rake'
+
+RSpec::Core::RakeTask.new
+
+task :default => :spec
+
+desc "Generates a dummy app for testing"
+task :test_app do
+  ENV['LIB_NAME'] = 'spree/frontend'
+  Rake::Task['common:test_app'].invoke
+end

data/script/rails

@@ -0,0 +1,9 @@
+#!/usr/bin/env ruby
+# This command will automatically be run when you run "rails" with Rails 3 gems installed from the root of your application.
+
+ENGINE_ROOT = File.expand_path('../..', __FILE__)
+ENGINE_PATH = File.expand_path('../../lib/spree/frontend/engine', __FILE__)
+
+require 'rails/all'
+require 'rails/engine/commands'
+

data/solidus_frontend.gemspec

@@ -0,0 +1,28 @@
+# encoding: UTF-8
+version = File.read(File.expand_path("../../SOLIDUS_VERSION", __FILE__)).strip
+
+Gem::Specification.new do |s|
+  s.platform    = Gem::Platform::RUBY
+  s.name        = 'solidus_frontend'
+  s.version     = version
+  s.summary     = 'Cart and storefront for the Solidus e-commerce project.'
+  s.description = s.summary
+
+  s.required_ruby_version = '>= 2.1.0'
+  s.author      = 'Solidus Team'
+  s.email       = 'contact@solidus.io'
+  s.homepage    = 'http://solidus.io/'
+  s.rubyforge_project = 'solidus_frontend'
+
+  s.files        = `git ls-files`.split("\n")
+  s.require_path = 'lib'
+  s.requirements << 'none'
+
+  s.add_dependency 'solidus_api', version
+  s.add_dependency 'solidus_core', version
+
+  s.add_dependency 'canonical-rails', '~> 0.0.4'
+  s.add_dependency 'jquery-rails'
+
+  s.add_development_dependency 'capybara-accessible'
+end

data/spec/controllers/controller_extension_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+# This test tests the functionality within
+# spree/core/controller_helpers/respond_with.rb
+# Rather than duck-punching the existing controllers, let's define a custom one:
+class Spree::CustomController < Spree::BaseController
+  def index
+    respond_with(Spree::Address.new) do |format|
+      format.html { render :text => "neutral" }
+    end
+  end
+
+  def create
+    # Just need a model with validations
+    # Address is good enough, so let's go with that
+    address = Spree::Address.new(params[:address])
+    respond_with(address)
+  end
+end
+
+describe Spree::CustomController, :type => :controller do
+  after do
+    Spree::CustomController.clear_overrides!
+  end
+
+  before do
+    @routes = ActionDispatch::Routing::RouteSet.new.tap do |r|
+      r.draw {
+        get 'index', to: 'spree/custom#index'
+        post 'create', to: 'spree/custom#create'
+      }
+    end
+  end
+
+  context "extension testing" do
+    context "index" do
+      context "specify symbol for handler instead of Proc" do
+        before do
+          Spree::CustomController.class_eval do
+            respond_override({:index => {:html => {:success => :success_method}}})
+
+            private
+
+            def success_method
+              render :text => 'success!!!'
+            end
+          end
+        end
+
+        describe "GET" do
+          it "has value success" do
+            spree_get :index
+            expect(response).to be_success
+            assert (response.body =~ /success!!!/)
+          end
+        end
+      end
+
+      context "render" do
+        before do
+          Spree::CustomController.instance_eval do
+            respond_override({:index => {:html => {:success => lambda { render(:text => 'success!!!') }}}})
+            respond_override({:index => {:html => {:failure => lambda { render(:text => 'failure!!!') }}}})
+          end
+        end
+
+        describe "GET" do
+          it "has value success" do
+            spree_get :index
+            expect(response).to be_success
+            assert (response.body =~ /success!!!/)
+          end
+        end
+      end
+
+      context "redirect" do
+        before do
+          Spree::CustomController.instance_eval do
+            respond_override({:index => {:html => {:success => lambda { redirect_to('/cart') }}}})
+            respond_override({:index => {:html => {:failure => lambda { render(:text => 'failure!!!') }}}})
+          end
+        end
+
+        describe "GET" do
+          it "has value success" do
+            spree_get :index
+            expect(response).to be_redirect
+          end
+        end
+      end
+
+      context "validation error" do
+        before do
+          Spree::CustomController.instance_eval do
+            respond_to :html
+            respond_override({:create => {:html => {:success => lambda { render(:text => 'success!!!') }}}})
+            respond_override({:create => {:html => {:failure => lambda { render(:text => 'failure!!!') }}}})
+          end
+        end
+
+        describe "POST" do
+          it "has value success" do
+            spree_post :create
+            expect(response).to be_success
+            assert (response.body =~ /success!/)
+          end
+        end
+      end
+
+      context 'A different controllers respond_override. Regression test for #1301' do
+        before do
+          Spree::CheckoutController.instance_eval do
+            respond_override({:index => {:html => {:success => lambda { render(:text => 'success!!!') }}}})
+          end
+        end
+
+        describe "POST" do
+          it "should not effect the wrong controller" do
+            spree_get :index
+            assert (response.body =~ /neutral/)
+          end
+        end
+      end
+    end
+  end
+end

data/spec/controllers/controller_helpers_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+# In this file, we want to test that the controller helpers function correctly
+# So we need to use one of the controllers inside Spree.
+# ProductsController is good.
+describe Spree::ProductsController, :type => :controller do
+
+  before do
+    I18n.enforce_available_locales = false
+    expect(I18n).to receive(:available_locales).and_return([:en, :de])
+    Spree::Frontend::Config[:locale] = :de
+  end
+
+  after do
+    Spree::Frontend::Config[:locale] = :en
+    I18n.locale = :en
+    I18n.enforce_available_locales = true
+  end
+
+  # Regression test for #1184
+  it "sets the default locale based off Spree::Frontend::Config[:locale]" do
+    expect(I18n.locale).to eq(:en)
+    spree_get :index
+    expect(I18n.locale).to eq(:de)
+  end
+end

data/spec/controllers/spree/checkout_controller_spec.rb

@@ -0,0 +1,400 @@
+require 'spec_helper'
+
+describe Spree::CheckoutController, :type => :controller do
+  let(:token) { 'some_token' }
+  let(:user) { stub_model(Spree::LegacyUser) }
+  let(:order) { FactoryGirl.create(:order_with_totals) }
+
+  let(:address_params) do
+    address = FactoryGirl.build(:address)
+    address.attributes.except("created_at", "updated_at")
+  end
+
+  before do
+    allow(controller).to receive_messages try_spree_current_user: user
+    allow(controller).to receive_messages spree_current_user: user
+    allow(controller).to receive_messages current_order: order
+  end
+
+  context "#edit" do
+    it 'should check if the user is authorized for :edit' do
+      expect(controller).to receive(:authorize!).with(:edit, order, token)
+      request.cookie_jar.signed[:guest_token] = token
+      spree_get :edit, { state: 'address' }
+    end
+
+    it "should redirect to the cart path unless checkout_allowed?" do
+      allow(order).to receive_messages :checkout_allowed? => false
+      spree_get :edit, { :state => "delivery" }
+      expect(response).to redirect_to(spree.cart_path)
+    end
+
+    it "should redirect to the cart path if current_order is nil" do
+      allow(controller).to receive(:current_order).and_return(nil)
+      spree_get :edit, { :state => "delivery" }
+      expect(response).to redirect_to(spree.cart_path)
+    end
+
+    it "should redirect to cart if order is completed" do
+      allow(order).to receive_messages(:completed? => true)
+      spree_get :edit, { :state => "address" }
+      expect(response).to redirect_to(spree.cart_path)
+    end
+
+    # Regression test for #2280
+    it "should redirect to current step trying to access a future step" do
+      order.update_column(:state, "address")
+      spree_get :edit, { :state => "delivery" }
+      expect(response).to redirect_to spree.checkout_state_path("address")
+    end
+
+    context "when entering the checkout" do
+      before do
+        # The first step for checkout controller is address
+        # Transitioning into this state first is required
+        order.update_column(:state, "address")
+      end
+
+      it "should associate the order with a user" do
+        order.update_column :user_id, nil
+        expect(order).to receive(:associate_user!).with(user)
+        spree_get :edit, {}, order_id: 1
+      end
+    end
+  end
+
+  context "#update" do
+    it 'should check if the user is authorized for :edit' do
+      expect(controller).to receive(:authorize!).with(:edit, order, token)
+      request.cookie_jar.signed[:guest_token] = token
+      spree_post :update, { state: 'address' }
+    end
+
+    context "save successful" do
+      def spree_post_address
+        spree_post :update, {
+          :state => "address",
+          :order => {
+            :bill_address_attributes => address_params,
+            :use_billing => true
+          }
+        }
+      end
+
+      before do
+        # Must have *a* shipping method and a payment method so updating from address works
+        allow(order).to receive_messages :available_shipping_methods => [stub_model(Spree::ShippingMethod)]
+        allow(order).to receive_messages :available_payment_methods => [stub_model(Spree::PaymentMethod)]
+        allow(order).to receive_messages :ensure_available_shipping_rates => true
+        order.line_items << FactoryGirl.create(:line_item)
+      end
+
+      context "with the order in the cart state" do
+        before do
+          order.update_column(:state, "cart")
+          allow(order).to receive_messages :user => user
+        end
+
+        it "should assign order" do
+          spree_post :update, {:state => "address"}
+          expect(assigns[:order]).not_to be_nil
+        end
+
+        it "should advance the state" do
+          spree_post_address
+          expect(order.reload.state).to eq("delivery")
+        end
+
+        it "should redirect the next state" do
+          spree_post_address
+          expect(response).to redirect_to spree.checkout_state_path("delivery")
+        end
+
+        context "current_user respond to save address method" do
+          it "calls persist order address on user" do
+            expect(user).to receive(:persist_order_address)
+            spree_post :update, {
+              :state => "address",
+              :order => {
+                :bill_address_attributes => address_params,
+                :use_billing => true
+              },
+              :save_user_address => "1"
+            }
+          end
+        end
+
+        context "current_user doesnt respond to persist_order_address" do
+          it "doesnt raise any error" do
+            expect {
+              spree_post :update, {
+                :state => "address",
+                :order => {
+                  :bill_address_attributes => address_params,
+                  :use_billing => true
+                },
+                :save_user_address => "1"
+              }
+            }.to_not raise_error
+          end
+        end
+      end
+
+      context "with the order in the address state" do
+        before do
+          order.update_columns(ship_address_id: create(:address).id, state: "address")
+          allow(order).to receive_messages user: user
+        end
+
+        context "with a billing and shipping address" do
+          before do
+            @expected_bill_address_id = order.bill_address.id
+            @expected_ship_address_id = order.ship_address.id
+
+            spree_post :update, {
+                :state => "address",
+                :order => {
+                    :bill_address_attributes => order.bill_address.attributes.except("created_at", "updated_at"),
+                    :ship_address_attributes => order.ship_address.attributes.except("created_at", "updated_at"),
+                    :use_billing => false
+                }
+            }
+
+            order.reload
+          end
+
+          it "unchanged address data does not change Address instances" do
+            expect(order.bill_address.id).to eq(@expected_bill_address_id)
+            expect(order.ship_address.id).to eq(@expected_ship_address_id)
+          end
+        end
+      end
+
+      context "when in the confirm state" do
+        before do
+          order.update_column(:state, "confirm")
+          allow(order).to receive_messages :user => user
+          # An order requires a payment to reach the complete state
+          # This is because payment_required? is true on the order
+          create(:payment, :amount => order.total, :order => order)
+          order.create_proposed_shipments
+          order.payments.reload
+        end
+
+        # This inadvertently is a regression test for #2694
+        it "should redirect to the order view" do
+          spree_post :update, {:state => "confirm"}
+          expect(response).to redirect_to spree.order_path(order)
+        end
+
+        it "should populate the flash message" do
+          spree_post :update, {:state => "confirm"}
+          expect(flash.notice).to eq(Spree.t(:order_processed_successfully))
+        end
+
+        it "should remove completed order from current_order" do
+          spree_post :update, {:state => "confirm"}, {:order_id => "foofah"}
+          expect(assigns(:current_order)).to be_nil
+          expect(assigns(:order)).to eql controller.current_order
+        end
+      end
+    end
+
+    context "save unsuccessful" do
+      before do
+        allow(order).to receive_messages :user => user
+        allow(order).to receive_messages :update_attributes => false
+      end
+
+      it "should not assign order" do
+        spree_post :update, {:state => "address"}
+        expect(assigns[:order]).not_to be_nil
+      end
+
+      it "should not change the order state" do
+        spree_post :update, { :state => 'address' }
+      end
+
+      it "should render the edit template" do
+        spree_post :update, { :state => 'address' }
+        expect(response).to render_template :edit
+      end
+    end
+
+    context "when current_order is nil" do
+      before { allow(controller).to receive_messages :current_order => nil }
+
+      it "should not change the state if order is completed" do
+        expect(order).not_to receive(:update_attribute)
+        spree_post :update, {:state => "confirm"}
+      end
+
+      it "should redirect to the cart_path" do
+        spree_post :update, {:state => "confirm"}
+        expect(response).to redirect_to spree.cart_path
+      end
+    end
+
+    context "Spree::Core::GatewayError" do
+      before do
+        allow(order).to receive_messages :user => user
+        allow(order).to receive(:update_attributes).and_raise(Spree::Core::GatewayError.new("Invalid something or other."))
+        spree_post :update, {:state => "address"}
+      end
+
+      it "should render the edit template and display exception message" do
+        expect(response).to render_template :edit
+        expect(flash.now[:error]).to eq(Spree.t(:spree_gateway_error_flash_for_checkout))
+        expect(assigns(:order).errors[:base]).to include("Invalid something or other.")
+      end
+    end
+
+    context "fails to transition from address" do
+      let(:order) do
+        FactoryGirl.create(:order_with_line_items).tap do |order|
+          order.next!
+          expect(order.state).to eq('address')
+        end
+      end
+
+      before do
+        allow(controller).to receive_messages :current_order => order
+        allow(controller).to receive_messages :check_authorization => true
+      end
+
+      context "when the order is invalid" do
+        before do
+          allow(order).to receive_messages :update_attributes => true, :next => nil
+          order.errors.add :base, 'Base error'
+          order.errors.add :adjustments, 'error'
+        end
+
+        it "due to the order having errors" do
+          spree_put :update, :state => order.state, :order => {}
+          expect(flash[:error]).to eq("Base error\nAdjustments error")
+          expect(response).to redirect_to(spree.checkout_state_path('address'))
+        end
+      end
+    end
+
+    context "fails to transition to complete from confirm" do
+      let(:order) do
+        FactoryGirl.create(:order_with_line_items).tap do |order|
+          order.next!
+        end
+      end
+
+      before do
+        allow(controller).to receive_messages :current_order => order
+        allow(controller).to receive_messages :check_authorization => true
+      end
+
+      context "when the country is not a shippable country" do
+        before do
+          order.ship_address.tap do |address|
+            # A different country which is not included in the list of shippable countries
+            australia = create(:country, name: "Australia")
+            # update_columns to get around readonly restriction when testing
+            address.update_columns(country_id: australia.id, state_name: 'Victoria')
+          end
+
+          payment_method = FactoryGirl.create(:simple_credit_card_payment_method)
+          payment = FactoryGirl.create(:payment, :payment_method => payment_method)
+          order.payments << payment
+        end
+
+        it "due to no available shipping rates for any of the shipments" do
+          expect(order.shipments.count).to eq(1)
+          order.shipments.first.shipping_rates.delete_all
+          order.update_attributes(state: 'confirm')
+          spree_put :update, state: order.state, :order => {}
+          expect(flash[:error]).to eq(Spree.t(:items_cannot_be_shipped))
+          expect(response).to redirect_to(spree.checkout_state_path('confirm'))
+        end
+      end
+    end
+
+    context "when GatewayError is raised" do
+      let(:order) do
+        FactoryGirl.create(:order_with_line_items).tap do |order|
+          until order.state == 'payment'
+            order.next!
+          end
+          # So that the confirmation step is skipped and we get straight to the action.
+          payment_method = FactoryGirl.create(:simple_credit_card_payment_method)
+          payment = FactoryGirl.create(:payment, payment_method: payment_method, amount: order.total)
+          order.payments << payment
+          order.next!
+        end
+      end
+
+      before do
+        allow(controller).to receive_messages :current_order => order
+        allow(controller).to receive_messages :check_authorization => true
+      end
+
+      it "fails to transition from payment to complete" do
+        allow_any_instance_of(Spree::Payment).to receive(:process!).and_raise(Spree::Core::GatewayError.new(Spree.t(:payment_processing_failed)))
+        spree_put :update, state: order.state, :order => {}
+        expect(flash[:error]).to eq(Spree.t(:payment_processing_failed))
+      end
+    end
+  end
+
+  context "When last inventory item has been purchased" do
+    let(:product) { mock_model(Spree::Product, :name => "Amazing Object") }
+    let(:variant) { mock_model(Spree::Variant) }
+    let(:line_item) { mock_model Spree::LineItem, :insufficient_stock? => true, :amount => 0 }
+    let(:order) { create(:order) }
+
+    before do
+      allow(order).to receive_messages(:line_items => [line_item], :state => "payment")
+
+      configure_spree_preferences do |config|
+        config.track_inventory_levels = true
+      end
+    end
+
+    context "and back orders are not allowed" do
+      before do
+        spree_post :update, { :state => "payment" }
+      end
+
+      it "should redirect to cart" do
+        expect(response).to redirect_to spree.cart_path
+      end
+
+      it "should set flash message for no inventory" do
+        expect(flash[:error]).to eq(Spree.t(:inventory_error_flash_for_insufficient_quantity , :names => "'#{product.name}'" ))
+      end
+    end
+  end
+
+  context "order doesn't have a delivery step" do
+    before do
+      allow(order).to receive_messages(:checkout_steps => ["cart", "address", "payment"])
+      allow(order).to receive_messages state: "address"
+      allow(controller).to receive_messages :check_authorization => true
+    end
+
+    it "doesn't set shipping address on the order" do
+      expect(order).to_not receive(:ship_address=)
+      spree_post :update, state: order.state
+    end
+
+    it "doesn't remove unshippable items before payment" do
+      expect {
+        spree_post :update, { :state => "payment" }
+      }.to_not change { order.line_items }
+    end
+  end
+
+  it "does remove unshippable items before payment" do
+    allow(order).to receive_messages :payment_required? => true
+    allow(controller).to receive_messages :check_authorization => true
+
+    expect {
+      spree_post :update, { :state => "payment" }
+    }.to change { order.line_items }
+  end
+end