solidus_core 2.10.5 → 2.11.0

data/spec/lib/spree/core/controller_helpers/pricing_spec.rb

@@ -1,94 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Pricing
-end
-
-RSpec.describe Spree::Core::ControllerHelpers::Pricing, type: :controller do
-  controller(FakesController) {}
-
-  before do
-    allow(controller).to receive(:current_store).and_return(store)
-  end
-
-  describe '#current_currency' do
-    subject { controller.current_currency }
-
-    context "when store default_currency is nil" do
-      let(:store) { nil }
-      it { Spree::Deprecation.silence { is_expected.to eq('USD') } }
-    end
-
-    context "when the current store default_currency empty" do
-      let(:store) { FactoryBot.create :store, default_currency: '' }
-
-      it { Spree::Deprecation.silence { is_expected.to eq('USD') } }
-    end
-
-    context "when the current store default_currency is a currency" do
-      let(:store) { FactoryBot.create :store, default_currency: 'EUR' }
-
-      it { Spree::Deprecation.silence { is_expected.to eq('EUR') } }
-    end
-  end
-
-  describe '#current_pricing_options' do
-    subject { controller.current_pricing_options }
-
-    let(:store) { FactoryBot.create(:store, default_currency: nil) }
-
-    it { is_expected.to be_a(Spree::Config.pricing_options_class) }
-
-    context "currency" do
-      subject { controller.current_pricing_options.currency }
-
-      context "when store default_currency is nil" do
-        let(:store) { nil }
-        it { is_expected.to eq('USD') }
-      end
-
-      context "when the current store default_currency empty" do
-        let(:store) { FactoryBot.create :store, default_currency: '' }
-
-        it { is_expected.to eq('USD') }
-      end
-
-      context "when the current store default_currency is a currency" do
-        let(:store) { FactoryBot.create :store, default_currency: 'EUR' }
-
-        it { is_expected.to eq('EUR') }
-      end
-    end
-
-    context "country_iso" do
-      subject { controller.current_pricing_options.country_iso }
-
-      let(:store) { FactoryBot.create(:store, cart_tax_country_iso: cart_tax_country_iso) }
-
-      context "when the store has a cart tax country set" do
-        let(:cart_tax_country_iso) { "DE" }
-        it { is_expected.to eq("DE") }
-      end
-
-      context "when the store has no cart tax country set" do
-        let(:cart_tax_country_iso) { nil }
-        it { is_expected.to be_nil }
-      end
-    end
-
-    context "from context" do
-      subject { controller.current_pricing_options }
-
-      let(:store) { FactoryBot.create :store, default_currency: 'USD' }
-
-      context "when the whole context is passed" do
-        it "receives the right object " do
-          expect(Spree::Config.pricing_options_class).to receive(:from_context).with(controller)
-          is_expected.to be_nil
-        end
-      end
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/search_spec.rb

@@ -1,21 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Search
-end
-
-RSpec.describe Spree::Core::ControllerHelpers::Search, type: :controller do
-  controller(FakesController) {}
-
-  describe '#build_searcher' do
-    it 'returns Spree::Core::Search::Base instance' do
-      allow(controller).to receive_messages(
-        try_spree_current_user: create(:user),
-        current_pricing_options: Spree::Config.pricing_options_class.new(currency: 'USD')
-      )
-      expect(controller.build_searcher({}).class).to eq Spree::Core::Search::Base
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/store_spec.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::Store
-end
-
-RSpec.describe Spree::Core::ControllerHelpers::Store, type: :controller do
-  controller(FakesController) {}
-
-  describe '#current_store' do
-    let!(:store) { create :store, default: true }
-    it 'returns current store' do
-      expect(controller.current_store).to eq store
-    end
-  end
-end

data/spec/lib/spree/core/controller_helpers/strong_parameters_spec.rb

@@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-class FakesController < ApplicationController
-  include Spree::Core::ControllerHelpers::StrongParameters
-end
-
-RSpec.describe Spree::Core::ControllerHelpers::StrongParameters, type: :controller do
-  controller(FakesController) {}
-
-  describe '#permitted_attributes' do
-    it 'returns Spree::PermittedAttributes module' do
-      expect(controller.permitted_attributes).to eq Spree::PermittedAttributes
-    end
-  end
-
-  describe '#permitted_payment_attributes' do
-    it 'returns Array class' do
-      expect(controller.permitted_payment_attributes.class).to eq Array
-    end
-  end
-
-  describe '#permitted_checkout_attributes' do
-    it 'returns Array class' do
-      Spree::Deprecation.silence do
-        expect(controller.permitted_checkout_attributes.class).to eq Spree::CheckoutAdditionalAttributes
-      end
-    end
-
-    it 'is deprecated' do
-      expect(Spree::Deprecation).to receive(:warn)
-      controller.permitted_checkout_attributes
-    end
-  end
-
-  describe '#permitted_order_attributes' do
-    it 'returns Array class' do
-      expect(controller.permitted_order_attributes.class).to eq Array
-    end
-  end
-
-  describe '#permitted_product_attributes' do
-    it 'returns Array class' do
-      expect(controller.permitted_product_attributes.class).to eq Array
-    end
-  end
-end

data/spec/lib/spree/core/current_store_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::Core::CurrentStore do
-  describe "#store" do
-    subject { Spree::Deprecation.silence { Spree::Core::CurrentStore.new(request).store } }
-
-    context "with a default" do
-      let(:request) { double(headers: {}, env: {}) }
-      let!(:store_1) { create :store, default: true }
-
-      it "returns the default store" do
-        expect(subject).to eq(store_1)
-      end
-
-      context "with a domain match" do
-        let(:request) { double(headers: {}, env: { "SERVER_NAME" => url } ) }
-        let(:url) { "server-name.org" }
-        let!(:store_2) { create :store, default: false, url: url }
-
-        it "returns the store with the matching domain" do
-          expect(subject).to eq(store_2)
-        end
-      end
-    end
-
-    it 'is deprecated' do
-      expect(Spree::Deprecation).to(receive(:warn))
-      Spree::Core::CurrentStore.new(double)
-    end
-  end
-end

data/spec/lib/spree/core/environment_extension_spec.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-require 'spree/core/environment_extension'
-
-RSpec.describe Spree::Core::EnvironmentExtension do
-  let(:base) { Class.new { def self.to_s; 'ExampleClass'; end } }
-  subject! { base.include(described_class).new }
-
-  describe '.add_class_set' do
-    context 'with a class set named "foo"' do
-      before { base.add_class_set('foo') }
-
-      let(:class_one) { String }
-      let(:class_two) { Array }
-      let(:class_three) { Hash }
-
-      describe '#foo' do
-        it { respond_to?(:foo) }
-        it { expect(subject.foo).to be_empty }
-        it { expect(subject.foo).to be_kind_of Spree::Core::ClassConstantizer::Set }
-      end
-
-      describe '#foo=' do
-        it { respond_to?(:foo=) }
-
-        before { subject.foo = [class_one, class_two] }
-
-        it { expect(subject.foo).to include(class_one) }
-        it { expect(subject.foo).to include(class_two) }
-        it { expect(subject.foo).not_to include(class_three) }
-      end
-    end
-  end
-
-  describe '#add_class' do
-    it 'is deprecated' do
-      expect(Spree::Deprecation).to receive(:warn) do |message, _caller|
-        expect(message).to include('ExampleClass.add_class_set(:foo)')
-      end
-      expect(base).to receive(:add_class_set).with(:foo)
-
-      base.new.add_class(:foo)
-    end
-  end
-end

data/spec/lib/spree/core/importer/order_spec.rb

@@ -1,484 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module Core
-    RSpec.describe Importer::Order do
-      let!(:store) { create(:store) }
-      let!(:country) { create(:country) }
-      let!(:state) { country.states.first || create(:state, country: country) }
-      let!(:stock_location) { create(:stock_location, admin_name: 'Admin Name') }
-
-      let(:user) { stub_model(LegacyUser, email: 'fox@mudler.com') }
-      let(:shipping_method) { create(:shipping_method) }
-      let(:payment_method) { create(:check_payment_method) }
-
-      let(:product) {
-        product = Spree::Product.create(name: 'Test',
-                                             sku: 'TEST-1',
-                                             price: 33.22)
-        product.shipping_category = create(:shipping_category)
-        product.save
-        product
-      }
-
-      let(:variant) {
-        variant = product.master
-        variant.stock_items.each { |si| si.set_count_on_hand(10) }
-        variant
-      }
-
-      let(:sku) { variant.sku }
-      let(:variant_id) { variant.id }
-
-      let(:line_items) { { "0" => { variant_id: variant.id, quantity: 5 } } }
-      let(:ship_address) {
-        {
-         address1: '123 Testable Way',
-         firstname: 'Fox',
-         lastname: 'Mulder',
-         city: 'Washington',
-         country_id: country.id,
-         state_id: state.id,
-         zipcode: '66666',
-         phone: '666-666-6666'
-      }}
-
-      it 'can import an order number' do
-        params = { number: '123-456-789' }
-        order = Importer::Order.import(user, params)
-        expect(order.number).to eq '123-456-789'
-      end
-
-      it 'optionally add completed at' do
-        params = { email: 'test@test.com',
-                   completed_at: Time.current,
-                   line_items_attributes: line_items }
-        order = Importer::Order.import(user, params)
-        expect(order).to be_completed
-        expect(order.state).to eq 'complete'
-      end
-
-      it "assigns order[email] over user email to order" do
-        params = { email: 'wooowww@test.com' }
-        order = Importer::Order.import(user, params)
-        expect(order.email).to eq params[:email]
-      end
-
-      context "assigning a user to an order" do
-        let(:other_user) { stub_model(LegacyUser, email: 'dana@scully.com') }
-
-        context "as an admin" do
-          before { allow(user).to receive_messages has_spree_role?: true }
-
-          context "a user's id is not provided" do
-            context "nil user id is provided" do
-              it "unassociates the admin user from the order" do
-                params = { user_id: nil }
-                order = Importer::Order.import(user, params)
-                expect(order.user_id).to be_nil
-              end
-            end
-
-            context "another user's id is provided" do
-              it "permits the user to be assigned" do
-                params = { user_id: other_user.id }
-                order = Importer::Order.import(user, params)
-                expect(order.user_id).to eq(other_user.id)
-              end
-            end
-          end
-
-          context "a user's id is not provided" do
-            it "doesn't unassociate the admin from the order" do
-              params = {}
-              order = Importer::Order.import(user, params)
-              expect(order.user_id).to eq(user.id)
-            end
-          end
-        end
-
-        context "as a user" do
-          before { allow(user).to receive_messages has_spree_role?: false }
-          it "does not assign the order to the other user" do
-            params = { user_id: other_user.id }
-            order = Importer::Order.import(user, params)
-            expect(order.user_id).to eq(user.id)
-          end
-        end
-      end
-
-      it 'can build an order from API with just line items' do
-        params = { line_items_attributes: line_items }
-
-        expect(Importer::Order).to receive(:ensure_variant_id_from_params).and_return({ variant_id: variant.id, quantity: 5 })
-        order = Importer::Order.import(user, params)
-        expect(order.user).to eq(nil)
-        line_item = order.line_items.first
-        expect(line_item.quantity).to eq(5)
-        expect(line_item.variant_id).to eq(variant_id)
-      end
-
-      it 'handles line_item updating exceptions' do
-        line_items['0'][:price] = 'an invalid price'
-        params = { line_items_attributes: line_items }
-
-        expect {
-          Importer::Order.import(user, params)
-        }.to raise_exception ActiveRecord::RecordInvalid
-      end
-
-      it 'can build an order from API with variant sku' do
-        params = {
-          line_items_attributes: {
-            "0" => { sku: sku, quantity: 5 }
-          }
-        }
-
-        order = Importer::Order.import(user, params)
-
-        line_item = order.line_items.first
-        expect(line_item.variant_id).to eq(variant_id)
-        expect(line_item.quantity).to eq(5)
-      end
-
-      it 'can build an order from API shipping address' do
-        params = { ship_address_attributes: ship_address,
-                   line_items_attributes: line_items }
-
-        order = Importer::Order.import(user, params)
-        expect(order.ship_address.address1).to eq '123 Testable Way'
-      end
-
-      it 'can build an order from API with country attributes' do
-        ship_address.delete(:country_id)
-        ship_address[:country] = { 'iso' => 'US' }
-        params = { ship_address_attributes: ship_address,
-                   line_items_attributes: line_items }
-
-        order = Importer::Order.import(user, params)
-        expect(order.ship_address.country.iso).to eq 'US'
-      end
-
-      it 'can build an order from API with state attributes' do
-        ship_address.delete(:state_id)
-        ship_address[:state] = { 'name' => state.name }
-        params = { ship_address_attributes: ship_address,
-                   line_items_attributes: line_items }
-
-        order = Importer::Order.import(user, params)
-        expect(order.ship_address.state.name).to eq 'Alabama'
-      end
-
-      context "with a different currency" do
-        let(:params) { { currency: "GBP" } }
-
-        it "sets the order currency" do
-          order = Importer::Order.import(user, params)
-          expect(order.currency).to eq "GBP"
-        end
-
-        context "when a line item price is specified" do
-          let(:params) { { currency: "GBP", line_items_attributes: line_items } }
-
-          before { line_items["0"][:price] = 1.99 }
-
-          context "and price is present in the order currency" do
-            before { variant.prices.create(currency: "GBP", amount: 18.99) }
-
-            it "assigns a price correctly" do
-              order = Importer::Order.import(user, params)
-
-              expect(order.currency).to eq "GBP"
-              expect(order.line_items.first.price).to eq 1.99
-              expect(order.line_items.first.currency).to eq "GBP"
-            end
-          end
-
-          context "and no price is present in the order currency" do
-            it "raises an exception" do
-              expect {
-                Importer::Order.import(user, params)
-              }.to raise_exception ActiveRecord::RecordInvalid
-            end
-          end
-        end
-      end
-
-      context "state passed is not associated with country" do
-        let(:params) do
-          {
-            ship_address_attributes: ship_address,
-            line_items_attributes: line_items
-          }
-        end
-
-        let(:other_state) { create(:state, name: "Uhuhuh", country: create(:country)) }
-
-        before do
-          ship_address.delete(:state_id)
-          ship_address[:state] = { 'name' => other_state.name }
-        end
-
-        it 'sets states name instead of state id' do
-          order = Importer::Order.import(user, params)
-          expect(order.ship_address.state_name).to eq other_state.name
-        end
-      end
-
-      it 'sets state name if state record not found' do
-        ship_address.delete(:state_id)
-        ship_address[:state] = { 'name' => 'XXX' }
-        params = { ship_address_attributes: ship_address,
-                   line_items_attributes: line_items }
-
-        order = Importer::Order.import(user, params)
-        expect(order.ship_address.state_name).to eq 'XXX'
-      end
-
-      context 'variant not deleted' do
-        it 'ensures variant id from api' do
-          hash = { sku: variant.sku }
-          Importer::Order.ensure_variant_id_from_params(hash)
-          expect(hash[:variant_id]).to eq variant.id
-        end
-      end
-
-      context 'variant was soft-deleted' do
-        it 'raise error as variant shouldnt be found' do
-          variant.product.discard
-          hash = { sku: variant.sku }
-          expect {
-            Importer::Order.ensure_variant_id_from_params(hash)
-          }.to raise_error ActiveRecord::RecordNotFound
-        end
-      end
-
-      it 'ensures_country_id for country fields' do
-        [:name, :iso, :iso_name, :iso3].each do |field|
-          address = { country: { field => country.send(field) } }
-          Importer::Order.ensure_country_id_from_params(address)
-          expect(address[:country_id]).to eq country.id
-        end
-      end
-
-      it "raises with proper message when cant find country" do
-        address = { country: { "name" => "NoNoCountry" } }
-        expect {
-          Importer::Order.ensure_country_id_from_params(address)
-        }.to raise_error ActiveRecord::RecordNotFound
-      end
-
-      it 'ensures_state_id for state fields' do
-        [:name, :abbr].each do |field|
-          address = { country_id: country.id, state: { field => state.send(field) } }
-          Importer::Order.ensure_state_id_from_params(address)
-          expect(address[:state_id]).to eq state.id
-        end
-      end
-
-      context "shipments" do
-        let(:params) do
-          {
-            shipments_attributes: [
-              {
-                tracking: '123456789',
-                cost: '14.99',
-                shipping_method: shipping_method.name,
-                stock_location: stock_location.name,
-                inventory_units: [{ sku: sku }]
-              }
-            ]
-          }
-        end
-
-        it 'ensures variant exists and is not deleted' do
-          expect(Importer::Order).to receive(:ensure_variant_id_from_params).and_call_original
-          Importer::Order.import(user, params)
-        end
-
-        it 'builds them properly' do
-          order = Importer::Order.import(user, params)
-          shipment = order.shipments.first
-
-          expect(shipment.cost.to_f).to eq 14.99
-          expect(shipment.inventory_units.first.variant_id).to eq product.master.id
-          expect(shipment.tracking).to eq '123456789'
-          expect(shipment.shipping_rates.first.cost).to eq 14.99
-          expect(shipment.selected_shipping_rate).to eq(shipment.shipping_rates.first)
-          expect(shipment.stock_location).to eq stock_location
-          expect(order.shipment_total.to_f).to eq 14.99
-        end
-
-        it "accepts admin name for stock location" do
-          params[:shipments_attributes][0][:stock_location] = stock_location.admin_name
-          order = Importer::Order.import(user, params)
-          shipment = order.shipments.first
-
-          expect(shipment.stock_location).to eq stock_location
-        end
-
-        it "raises if cant find stock location" do
-          params[:shipments_attributes][0][:stock_location] = "doesnt exist"
-          expect {
-            Importer::Order.import(user, params)
-          }.to raise_error ActiveRecord::RecordNotFound
-        end
-
-        context 'when completed_at and shipped_at present' do
-          let(:params) do
-            {
-              completed_at: 2.days.ago,
-              shipments_attributes: [
-                {
-                  tracking: '123456789',
-                  cost: '4.99',
-                  shipped_at: 1.day.ago,
-                  shipping_method: shipping_method.name,
-                  stock_location: stock_location.name,
-                  inventory_units: [{ sku: sku }]
-                }
-              ]
-            }
-          end
-
-          it 'builds them properly' do
-            order = Importer::Order.import(user, params)
-            shipment = order.shipments.first
-
-            expect(shipment.cost.to_f).to eq 4.99
-            expect(shipment.inventory_units.first.variant_id).to eq product.master.id
-            expect(shipment.tracking).to eq '123456789'
-            expect(shipment.shipped_at).to be_present
-            expect(shipment.shipping_rates.first.cost).to eq 4.99
-            expect(shipment.selected_shipping_rate).to eq(shipment.shipping_rates.first)
-            expect(shipment.stock_location).to eq stock_location
-            expect(shipment.state).to eq('shipped')
-            expect(shipment.inventory_units.all?(&:shipped?)).to be true
-            expect(order.shipment_state).to eq('shipped')
-            expect(order.shipment_total.to_f).to eq 4.99
-          end
-        end
-
-        context "when line items and shipments are present" do
-          let(:params) do
-            {
-              completed_at: 2.days.ago,
-              line_items_attributes: line_items,
-              shipments_attributes: [
-                {
-                  tracking: '123456789',
-                  cost: '4.99',
-                  shipped_at: 1.day.ago,
-                  shipping_method: shipping_method.name,
-                  stock_location: stock_location.name,
-                  inventory_units: [{ sku: sku }]
-                }
-              ]
-            }
-          end
-
-          it 'builds quantities properly' do
-            order = Importer::Order.import(user, params)
-            line_item = order.line_items.first
-            expect(line_item.quantity).to eq(5)
-          end
-        end
-      end
-
-      it 'adds adjustments' do
-        params = {
-          adjustments_attributes: [
-            { label: 'Shipping Discount', amount: -4.99 },
-            { label: 'Promotion Discount', amount: -3.00 }
-          ]
-        }
-
-        order = Importer::Order.import(user, params)
-        expect(order.adjustments.all?(&:finalized?)).to be true
-        expect(order.adjustments.first.label).to eq 'Shipping Discount'
-        expect(order.adjustments.first.amount).to eq(-4.99)
-      end
-
-      it "calculates final order total correctly" do
-        params = {
-          adjustments_attributes: [
-            { label: 'Promotion Discount', amount: -3.00 }
-          ],
-          line_items_attributes: {
-            "0" => {
-              variant_id: variant.id,
-              quantity: 5
-            }
-          }
-        }
-
-        order = Importer::Order.import(user, params)
-        expect(order.item_total).to eq(166.1)
-        expect(order.total).to eq(163.1) # = item_total (166.1) - adjustment_total (3.00)
-      end
-
-      it 'builds a payment using state' do
-        params = { payments_attributes: [{ amount: '4.99',
-                                              payment_method: payment_method.name,
-                                              state: 'completed' }] }
-        order = Importer::Order.import(user, params)
-        expect(order.payments.first.amount).to eq 4.99
-      end
-
-      it 'builds a payment using status as fallback' do
-        params = { payments_attributes: [{ amount: '4.99',
-                                              payment_method: payment_method.name,
-                                              status: 'completed' }] }
-        order = Importer::Order.import(user, params)
-        expect(order.payments.first.amount).to eq 4.99
-      end
-
-      it 'build a source payment using years and month' do
-        params = { payments_attributes: [{
-                                              amount: '4.99',
-                                              payment_method: payment_method.name,
-                                              status: 'completed',
-                                              source: {
-                                                name: 'Fox',
-                                                last_digits: "7424",
-                                                cc_type: "visa",
-                                                year: '2022',
-                                                month: "5"
-                                              }
-                                            }] }
-
-        order = Importer::Order.import(user, params)
-        expect(order.payments.first.source.last_digits).to eq '7424'
-      end
-
-      it 'handles source building exceptions when do not have years and month' do
-        params = { payments_attributes: [{
-                                              amount: '4.99',
-                                              payment_method: payment_method.name,
-                                              status: 'completed',
-                                              source: {
-                                                name: 'Fox',
-                                                last_digits: "7424",
-                                                cc_type: "visa"
-                                              }
-                                            }] }
-
-        expect {
-          Importer::Order.import(user, params)
-        }.to raise_error /Validation failed: Credit card Month is not a number, Credit card Year is not a number/
-      end
-
-      context "raises error" do
-        it "clears out order from db" do
-          params = { payments_attributes: [{ payment_method: "XXX" }] }
-          count = Order.count
-
-          expect { Importer::Order.import(user, params) }.to raise_error ActiveRecord::RecordNotFound
-          expect(Order.count).to eq count
-        end
-      end
-    end
-  end
-end