solidus_core_devise_token_auth 2.8.0.alpha.0

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

@@ -0,0 +1,484 @@
+# 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

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

@@ -0,0 +1,155 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::RoleConfiguration do
+  class DummyPermissionSet < Spree::PermissionSets::Base
+    def activate!
+      can :manage, :things
+    end
+  end
+  class OtherDummyPermissionSet < Spree::PermissionSets::Base; end
+
+  let(:instance) { Spree::RoleConfiguration.new }
+
+  describe ".configure" do
+    around(:each) do |example|
+      Spree::Deprecation.silence { example.run }
+    end
+
+    it "yields with the instance" do
+      expect { |b| described_class.configure(&b) }.to yield_with_args(described_class.instance)
+    end
+
+    it "only yields once" do
+      expect { |b| described_class.configure(&b) }.to yield_control.once
+    end
+  end
+
+  describe "#assign_permissions" do
+    let(:name) { "thing" }
+    subject { instance.assign_permissions name, [DummyPermissionSet] }
+
+    context "when a role for the name exists" do
+      before do
+        instance.roles[name] = described_class::Role.new(name, Set.new(existing_roles))
+      end
+
+      context "when adding duplicate permission sets" do
+        let(:existing_roles) { [DummyPermissionSet] }
+
+        it "does not add another role" do
+          expect{ subject }.to_not change{ instance.roles.count }
+        end
+
+        it "does not add duplicate permission sets" do
+          subject
+          role = instance.roles.values.detect { |r| r.name == name }
+          expect(role.permission_sets).to match_array([DummyPermissionSet])
+        end
+      end
+
+      context "when adding new permission sets to an existing role" do
+        let(:existing_roles) { [OtherDummyPermissionSet] }
+
+        it "does not add another role" do
+          expect{ subject }.to_not change{ instance.roles.count }
+        end
+
+        it "appends the permission set to the existing role" do
+          subject
+          role = instance.roles.values.detect { |r| r.name == name }
+          expect(role.permission_sets).to match_array([OtherDummyPermissionSet, DummyPermissionSet])
+        end
+      end
+    end
+
+    context "when a role for the name does not yet exist" do
+      it "creates a new role" do
+        expect{ subject }.to change{ instance.roles.count }.from(0).to(1)
+      end
+
+      it "sets the roles name accordingly" do
+        subject
+        expect(instance.roles.values.first.name).to eql(name)
+      end
+
+      it "sets the permission sets accordingly" do
+        subject
+        expect(instance.roles.values.first.permission_sets).to match_array([DummyPermissionSet])
+      end
+    end
+  end
+
+  describe "#activate_permissions!" do
+    let(:user) { build :user }
+    let(:role_name) { "testrole" }
+    let(:ability) { DummyAbility.new }
+
+    before do
+      user.spree_roles = user_roles.map do |role|
+        Spree::Role.create!(name: role)
+      end
+    end
+
+    subject { instance.activate_permissions! ability, user }
+
+    context "when the configuration has roles" do
+      before do
+        instance.roles[role_name] = described_class::Role.new(role_name, [DummyPermissionSet])
+      end
+
+      context "default_role" do
+        let(:role_name) { 'default' }
+
+        context "when the user has no roles" do
+          let(:user_roles) { [] }
+
+          it "activates the applicable permissions on the ability" do
+            expect{ subject }.to change{ ability.can? :manage, :things }.
+              from(false).
+              to(true)
+          end
+        end
+
+        context "when the user has a different role" do
+          let(:user_roles) { [] }
+
+          it "activates the applicable permissions on the ability" do
+            expect{ subject }.to change{ ability.can? :manage, :things }.
+              from(false).
+              to(true)
+          end
+        end
+      end
+
+      context "when the configuration has applicable roles" do
+        let(:user_roles) { [role_name, "someotherrandomrole"] }
+
+        it "activates the applicable permissions on the ability" do
+          expect{ subject }.to change{ ability.can? :manage, :things }.
+            from(false).
+            to(true)
+        end
+      end
+
+      context "when the configuration does not have applicable roles" do
+        let(:user_roles) { ["somerandomrole"] }
+
+        it "doesn't activate non matching roles" do
+          subject
+          expect(ability.can?(:manage, :things)).to be false
+        end
+      end
+    end
+
+    context "when the configuration does not have roles" do
+      let(:user_roles) { ["somerandomrole"] }
+
+      it "doesnt activate any new permissions" do
+        subject
+        expect(ability.can?(:manage, :things)).to be false
+      end
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Core::StockConfiguration do
+  describe '#coordinator_class' do
+    let(:stock_configuration) { described_class.new }
+    subject { stock_configuration.coordinator_class }
+
+    it "returns Spree::Stock::Coordinator" do
+      is_expected.to be ::Spree::Stock::SimpleCoordinator
+    end
+
+    context "with another constant name assiged" do
+      MyCoordinator = Class.new
+      before { stock_configuration.coordinator_class = MyCoordinator.to_s }
+
+      it "returns the constant" do
+        is_expected.to be MyCoordinator
+      end
+    end
+  end
+
+  describe '#estimator_class' do
+    let(:stock_configuration) { described_class.new }
+    subject { stock_configuration.estimator_class }
+
+    it "returns Spree::Stock::Estimator" do
+      is_expected.to be ::Spree::Stock::Estimator
+    end
+
+    context "with another constant name assiged" do
+      MyEstimator = Class.new
+      before { stock_configuration.estimator_class = MyEstimator.to_s }
+
+      it "returns the constant" do
+        is_expected.to be MyEstimator
+      end
+    end
+  end
+
+  describe '#location_sorter_class' do
+    let(:stock_configuration) { described_class.new }
+    subject { stock_configuration.location_sorter_class }
+
+    it "returns Spree::Stock::LocationSorter::Unsorted" do
+      is_expected.to be ::Spree::Stock::LocationSorter::Unsorted
+    end
+
+    context "with another constant name assiged" do
+      MySorter = Class.new
+      before { stock_configuration.location_sorter_class = MySorter.to_s }
+
+      it "returns the constant" do
+        is_expected.to be MySorter
+      end
+    end
+  end
+end