solidus_starter_frontend 0.1.0 → 0.2.0

data/spec/controllers/spree/orders_controller_ability_spec.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe OrdersController, type: :controller do
-    ORDER_TOKEN = 'ORDER_TOKEN'
-
-    let!(:store) { create(:store) }
-    let(:order) { Spree::Order.create }
-    let(:variant) { create(:variant) }
-
-    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' }
-
-      before do
-        allow(controller).to receive_messages current_order: order
-      end
-
-      context '#populate' do
-        it 'should check if user is authorized for :update' do
-          expect(controller).to receive(:authorize!).with(:update, order, token)
-          post :populate, params: { variant_id: variant.id, token: token }
-        end
-      end
-
-      context '#edit' do
-        it 'should check if user is authorized for :read' do
-          expect(controller).to receive(:authorize!).with(:read, order, token)
-          get :edit, params: { token: token }
-        end
-      end
-
-      context '#update' do
-        it 'should check if user is authorized for :update' do
-          allow(order).to receive :update
-          expect(controller).to receive(:authorize!).with(:update, order, token)
-          post :update, params: { order: { email: "foo@bar.com" }, token: token }
-        end
-      end
-
-      context '#empty' do
-        it 'should check if user is authorized for :update' do
-          expect(controller).to receive(:authorize!).with(:update, order, token)
-          post :empty, params: { token: token }
-        end
-      end
-
-      context "#show" do
-        let(:specified_order) { create(:order) }
-
-        it "should check against the specified order" do
-          expect(controller).to receive(:authorize!).with(:read, specified_order, token)
-          get :show, params: { 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"
-            get :show, params: { 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
-            get :show, params: { 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
-            expect {
-              get :show, params: { id: 'R123' }
-            }.to raise_error(ActiveRecord::RecordNotFound)
-          end
-        end
-      end
-    end
-  end
-end

data/spec/controllers/spree/orders_controller_spec.rb

@@ -1,241 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::OrdersController, type: :controller do
-  let!(:store) { create(:store) }
-  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
-        post :populate, params: { variant_id: variant.id }
-        expect(response).to be_redirect
-        expect(cookies.signed[:guest_token]).not_to be_blank
-
-        order_by_token = Spree::Order.find_by(guest_token: cookies.signed[:guest_token])
-        assigned_order = assigns[:order]
-
-        expect(assigned_order).to eq order_by_token
-        expect(assigned_order).to be_persisted
-      end
-
-      context "with Variant" do
-        it "should handle population" do
-          expect do
-            post :populate, params: { 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"])
-          )
-
-          post :populate, params: { 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
-
-          post(
-            :populate,
-            params: { variant_id: variant.id, quantity: -1 }
-          )
-
-          expect(response).to redirect_to(spree.root_path)
-          expect(flash[:error]).to eq(
-            I18n.t('spree.please_enter_reasonable_quantity')
-          )
-        end
-
-        context "when quantity is empty string" do
-          it "should populate order with 1 of given variant" do
-            expect do
-              post :populate, params: { variant_id: variant.id, quantity: '' }
-            end.to change { Spree::Order.count }.by(1)
-            order = Spree::Order.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(1)
-          end
-        end
-
-        context "when quantity is nil" do
-          it "should populate order with 1 of given variant" do
-            expect do
-              post :populate, params: { variant_id: variant.id, quantity: nil }
-            end.to change { Spree::Order.count }.by(1)
-            order = Spree::Order.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(1)
-          end
-        end
-      end
-    end
-
-    context '#edit' do
-      before do
-        allow(controller).to receive :authorize!
-        allow(controller).to receive_messages current_order: order
-      end
-
-      it 'should render cart' do
-        get :edit, params: { id: order.number }
-
-        expect(flash[:error]).to be_nil
-        expect(response).to be_ok
-      end
-
-      context 'with another order number than the current_order' do
-        let(:other_order) { create(:completed_order_with_totals) }
-
-        it 'should display error message' do
-          get :edit, params: { id: other_order.number }
-
-          expect(flash[:error]).to eq "You may only edit your current shopping cart."
-          expect(response).to redirect_to cart_path
-        end
-      end
-    end
-
-    context "#update" do
-      context "with authorization" do
-        before do
-          allow(controller).to receive :authorize!
-          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")
-          put :update, params: { order: { email: "" } }
-          expect(response).to render_template :edit
-        end
-
-        it "should redirect to cart path (on success)" do
-          allow(order).to receive(:update).and_return true
-          put :update
-          expect(response).to redirect_to(spree.cart_path)
-        end
-
-        it "should advance the order if :checkout button is pressed" do
-          allow(order).to receive(:update).and_return true
-          expect(order).to receive(:next)
-          put :update, params: { checkout: true }
-          expect(response).to redirect_to checkout_state_path('address')
-        end
-
-        context 'trying to apply a coupon code' do
-          let(:order) { create(:order_with_line_items, state: 'cart') }
-          let(:coupon_code) { "coupon_code" }
-
-          context "when coupon code is empty" do
-            let(:coupon_code) { "" }
-
-            it 'does not try to apply coupon code' do
-              expect(Spree::PromotionHandler::Coupon).not_to receive :new
-
-              put :update, params: { state: order.state, order: { coupon_code: coupon_code } }
-
-              expect(response).to redirect_to(spree.cart_path)
-            end
-          end
-        end
-      end
-    end
-
-    context "#empty" do
-      before do
-        allow(controller).to receive :authorize!
-      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!)
-        put :empty
-        expect(response).to redirect_to(spree.cart_path)
-      end
-    end
-
-    # Regression test for https://github.com/spree/spree/issues/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
-        put :update, params: { order: { email: "foo" } }
-        expect(flash[:error]).to eq(I18n.t('spree.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(store: store) }
-    let(:variant) { create(:variant) }
-    let!(:line_item) { order.contents.add(variant, 1) }
-
-    before do
-      allow(controller).to receive :authorize!
-      allow(controller).to receive_messages(current_order: order)
-    end
-
-    it "removes line items on update" do
-      expect(order.line_items.count).to eq 1
-      put :update, params: { order: { line_items_attributes: { "0" => { id: line_item.id, quantity: 0 } } } }
-      expect(order.reload.line_items.count).to eq 0
-    end
-  end
-
-  describe '#edit' do
-    subject { get :edit }
-    let(:user) { build :user }
-
-    it "builds a new valid order with complete meta-data" do
-      allow(controller).to receive_messages(try_spree_current_user: user)
-
-      subject
-
-      order = controller.instance_variable_get(:@order)
-
-      aggregate_failures do
-        expect(order).to be_valid
-        expect(order).not_to be_persisted
-        expect(order.store).to be_present
-        expect(order.user).to eq(user)
-        expect(order.created_by).to eq(user)
-      end
-    end
-  end
-end

data/spec/controllers/spree/orders_controller_transitions_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-Spree::Order.class_eval do
-  attr_accessor :did_transition
-end
-
-module Spree
-  describe OrdersController, type: :controller do
-    # Regression test for https://github.com/spree/spree/issues/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 << FactoryBot.create(:line_item)
-        put :update, params: { checkout: "checkout" }
-        expect(order.did_transition).to be true
-      end
-    end
-  end
-end

data/spec/controllers/spree/products_controller_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Spree::ProductsController, type: :controller do
-  let!(:product) { create(:product, available_on: 1.year.from_now) }
-
-  # Regression test for https://github.com/spree/spree/issues/1390
-  it "allows admins to view non-active products" do
-    allow(controller).to receive_messages try_spree_current_user: mock_model(Spree.user_class, has_spree_role?: true, last_incomplete_spree_order: nil, spree_api_key: 'fake')
-    get :show, params: { id: product.to_param }
-    expect(response.status).to eq(200)
-  end
-
-  it "cannot view non-active products" do
-    expect {
-      get :show, params: { id: product.to_param }
-    }.to raise_error(ActiveRecord::RecordNotFound)
-  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 try_spree_current_user: user
-    expect_any_instance_of(Spree::Config.searcher_class).to receive(:current_user=).with(user)
-    get :index
-    expect(response.status).to eq(200)
-  end
-
-  # Regression test for https://github.com/spree/spree/issues/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 try_spree_current_user: current_user
-    request.env['HTTP_REFERER'] = "not|a$url"
-
-    # Previously a URI::InvalidURIError exception was being thrown
-    get :show, params: { id: product.to_param }
-  end
-end

data/spec/controllers/spree/taxons_controller_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-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 try_spree_current_user: user
-    expect_any_instance_of(Spree::Config.searcher_class).to receive(:current_user=).with(user)
-    get :show, params: { id: taxon.permalink }
-    expect(response.status).to eq(200)
-  end
-end

data/spec/generators/solidus/views/override_generator_spec.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'generator_spec'
-require 'generators/solidus_starter_frontend/views/override_generator'
-
-RSpec.describe SolidusStarterFrontend::Views::OverrideGenerator, type: :generator do
-  destination Rails.root.join('app', 'views', 'spree')
-
-  before(:all) do
-    prepare_destination
-  end
-
-  subject! do
-    run_generator arguments
-  end
-
-  let(:src) do
-    ::SolidusStarterFrontend::Engine.root.join('app', 'views', 'spree')
-  end
-
-  let(:dest) do
-    Rails.root.join('app', 'views', 'spree')
-  end
-
-  context 'without any arguments' do
-    let(:arguments) { %w() }
-
-    it 'copies all views into the host app' do
-      expect(src.entries).to match_array(dest.entries)
-    end
-  end
-
-  context 'when "products" is passed as --only argument' do
-    let(:arguments) { %w(--only products) }
-
-    context 'as folder' do
-      it 'exclusively copies views whose name contains "products"' do
-        Dir.glob(dest.join("**", "*")).each do |file|
-          next if File.directory?(file)
-          expect(file.to_s).to match("products")
-        end
-      end
-    end
-  end
-
-  after do
-    FileUtils.rm_rf destination_root
-  end
-end

data/spec/helpers/base_helper_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe BaseHelper, type: :helper do
-    # Regression test for https://github.com/spree/spree/issues/2759
-    it "nested_taxons_path works with a Taxon object" do
-      taxon = create(:taxon, name: "iphone")
-      expect(spree.nested_taxons_path(taxon)).to eq("/t/iphone")
-    end
-  end
-end

data/spec/helpers/order_helper_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-module Spree
-  describe Spree::OrdersHelper, type: :helper do
-    # Regression test for https://github.com/spree/spree/issues/2518 and https://github.com/spree/spree/issues/2323
-    it "truncates HTML correctly in product description" do
-      product = double(description: "<strong>" + ("a" * 95) + "</strong> This content is invisible.")
-      expected = "<strong>" + ("a" * 95) + "</strong>..."
-      expect(truncated_product_description(product)).to eq(expected)
-    end
-  end
-end

data/spec/helpers/taxon_filters_helper_spec.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-RSpec.describe Spree::TaxonFiltersHelper, type: :helper do
-  let(:taxon) { nil }
-  subject { applicable_filters_for(taxon) }
-
-  it "returns the price/brand filters" do
-    expect(subject.map { |y| y[:name] }).to eq ['Brands', 'Price Range']
-  end
-end

data/spec/spec_helper.rb

@@ -1,64 +0,0 @@
-# frozen_string_literal: true
-
-# Configure Rails Environment
-ENV['RAILS_ENV'] = 'test'
-
-# Run Coverage report
-require 'solidus_dev_support/rspec/coverage'
-
-require File.expand_path('dummy/config/environment.rb', __dir__)
-
-require 'rails-controller-testing'
-require 'rspec/active_model/mocks'
-
-# Requires factories and other useful helpers defined in spree_core.
-require 'solidus_dev_support/rspec/feature_helper'
-require 'spree/testing_support/caching'
-require 'spree/testing_support/order_walkthrough'
-require 'spree/testing_support/translations' unless Spree.solidus_gem_version < Gem::Version.new('2.11')
-
-# Requires supporting ruby files with custom matchers and macros, etc,
-# in spec/support/ and its subdirectories.
-Dir[File.join(File.dirname(__FILE__), 'support/**/*.rb')].each { |f| require f }
-
-# Requires factories defined in lib/solidus_starter_frontend/factories.rb
-require 'solidus_starter_frontend/factories'
-
-RSpec.configure do |config|
-  config.infer_spec_type_from_file_location!
-  config.use_transactional_fixtures = false
-
-  if Spree.solidus_gem_version < Gem::Version.new('2.11')
-    config.extend Spree::TestingSupport::AuthorizationHelpers::Request, type: :system
-
-    config.after(:each, type: :system) do |example|
-      missing_translations = page.body.scan(/translation missing: #{I18n.locale}\.(.*?)[\s<\"&]/)
-      if missing_translations.any?
-        puts "Found missing translations: #{missing_translations.inspect}\n"
-        puts "In spec: #{example.location}"
-      end
-    end
-  end
-
-  if SolidusSupport.reset_spree_preferences_deprecated?
-    config.before :suite do
-      Spree::TestingSupport::Preferences.freeze_preferences(SolidusStarterFrontend::Config)
-    end
-  else
-    config.before do
-      SolidusStarterFrontend::Config.preference_store = SolidusStarterFrontend::Config.default_preferences
-    end
-  end
-
-  config.before do
-    Rails.cache.clear
-  end
-
-  config.before(:each, type: :system) do
-    driven_by((ENV['CAPYBARA_DRIVER'] || :rack_test).to_sym)
-  end
-
-  config.before(:each, type: :system, js: true) do
-    driven_by((ENV['CAPYBARA_JS_DRIVER'] || :apparition).to_sym)
-  end
-end

data/spec/support/shared_contexts/checkout_setup.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-shared_context 'checkout setup' do
-  let!(:store) { create(:store) }
-  let!(:country) { create(:country, states_required: true) }
-  let!(:state) { create(:state, country: country) }
-  let!(:shipping_method) { create(:shipping_method) }
-  let!(:stock_location) { create(:stock_location) }
-  let!(:mug) { create(:product, name: "RoR Mug") }
-  let!(:payment_method) { create(:check_payment_method) }
-  let!(:zone) { create(:zone) }
-end

data/spec/support/shared_contexts/custom_products.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-shared_context "custom products" do
-  before(:each) do
-    create(:store)
-    taxonomy = FactoryBot.create(:taxonomy, name: 'Categories')
-    root = taxonomy.root
-    clothing_taxon = FactoryBot.create(:taxon, name: 'Clothing', parent_id: root.id)
-    bags_taxon = FactoryBot.create(:taxon, name: 'Bags', parent_id: root.id)
-    mugs_taxon = FactoryBot.create(:taxon, name: 'Mugs', parent_id: root.id)
-
-    taxonomy = FactoryBot.create(:taxonomy, name: 'Brands')
-    root = taxonomy.root
-    apache_taxon = FactoryBot.create(:taxon, name: 'Apache', parent_id: root.id)
-    rails_taxon = FactoryBot.create(:taxon, name: 'Ruby on Rails', parent_id: root.id)
-    ruby_taxon = FactoryBot.create(:taxon, name: 'Ruby', parent_id: root.id)
-
-    FactoryBot.create(:custom_product, name: 'Ruby on Rails Ringer T-Shirt', price: '19.99', taxons: [rails_taxon, clothing_taxon])
-    FactoryBot.create(:custom_product, name: 'Ruby on Rails Mug', price: '15.99', taxons: [rails_taxon, mugs_taxon])
-    FactoryBot.create(:custom_product, name: 'Ruby on Rails Tote', price: '15.99', taxons: [rails_taxon, bags_taxon])
-    FactoryBot.create(:custom_product, name: 'Ruby on Rails Bag', price: '22.99', taxons: [rails_taxon, bags_taxon])
-    FactoryBot.create(:custom_product, name: 'Ruby on Rails Baseball Jersey', price: '19.99', taxons: [rails_taxon, clothing_taxon])
-    FactoryBot.create(:custom_product, name: 'Ruby on Rails Stein', price: '16.99', taxons: [rails_taxon, mugs_taxon])
-    FactoryBot.create(:custom_product, name: 'Ruby on Rails Jr. Spaghetti', price: '19.99', taxons: [rails_taxon, clothing_taxon])
-    FactoryBot.create(:custom_product, name: 'Ruby Baseball Jersey', price: '19.99', taxons: [ruby_taxon, clothing_taxon])
-    FactoryBot.create(:custom_product, name: 'Apache Baseball Jersey', price: '19.99', taxons: [apache_taxon, clothing_taxon])
-  end
-end

data/spec/support/shared_contexts/locales.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-shared_context 'fr locale' do
-  before do
-    I18n.backend.store_translations(:fr, spree: {
-      i18n: { this_file_language: "Français" },
-      cart: 'Panier',
-      shopping_cart: 'Panier'
-    })
-  end
-
-  after do
-    I18n.locale = :en # reset locale after each spec.
-    I18n.reload!
-  end
-end