solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/models/spree/stock_location_spec.rb

@@ -0,0 +1,288 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  RSpec.describe StockLocation, type: :model do
+    subject { create(:stock_location_with_items, backorderable_default: true) }
+    let(:stock_item) { subject.stock_items.order(:id).first }
+    let(:variant) { stock_item.variant }
+
+    it 'creates stock_items for all variants' do
+      expect(subject.stock_items.count).to eq Variant.count
+    end
+
+    context "handling stock items" do
+      let!(:variant) { create(:variant) }
+
+      context "given a variant" do
+        subject { StockLocation.create(name: "testing", propagate_all_variants: false) }
+
+        context "set up" do
+          it "creates stock item" do
+            expect(subject).to receive(:propagate_variant)
+            subject.set_up_stock_item(variant)
+          end
+
+          context "stock item exists" do
+            let!(:stock_item) { subject.propagate_variant(variant) }
+
+            it "returns existing stock item" do
+              expect(subject.set_up_stock_item(variant)).to eq(stock_item)
+            end
+          end
+        end
+
+        context "propagate variants" do
+          let(:stock_item) { subject.propagate_variant(variant) }
+
+          it "creates a new stock item" do
+            expect {
+              subject.propagate_variant(variant)
+            }.to change{ StockItem.count }.by(1)
+          end
+
+          context "passes backorderable default config" do
+            context "true" do
+              before { subject.backorderable_default = true }
+              it { expect(stock_item.backorderable).to be true }
+            end
+
+            context "false" do
+              before { subject.backorderable_default = false }
+              it { expect(stock_item.backorderable).to be false }
+            end
+          end
+        end
+
+        context "propagate all variants" do
+          subject { StockLocation.new(name: "testing") }
+
+          context "true" do
+            before { subject.propagate_all_variants = true }
+
+            specify do
+              expect(subject).to receive(:propagate_variant).at_least(:once)
+              subject.save!
+            end
+          end
+
+          context "false" do
+            before { subject.propagate_all_variants = false }
+
+            specify do
+              expect(subject).not_to receive(:propagate_variant)
+              subject.save!
+            end
+          end
+        end
+      end
+    end
+
+    it 'finds a stock_item for a variant' do
+      stock_item = subject.stock_item(variant)
+      expect(stock_item.count_on_hand).to eq 10
+    end
+
+    it 'finds a stock_item for a variant by id' do
+      stock_item = subject.stock_item(variant.id)
+      expect(stock_item.variant).to eq variant
+    end
+
+    it 'returns nil when stock_item is not found for variant' do
+      stock_item = subject.stock_item(0)
+      expect(stock_item).to be_nil
+    end
+
+    describe '#stock_item_or_create' do
+      before do
+        variant = create(:variant)
+        variant.stock_items.each(&:really_destroy!)
+        variant.save
+      end
+
+      it 'creates a stock_item if not found for a variant' do
+        stock_item = subject.stock_item_or_create(variant)
+        expect(stock_item.variant).to eq variant
+      end
+
+      it 'creates a stock_item if not found for a variant_id' do
+        stock_item = subject.stock_item_or_create(variant.id)
+        expect(stock_item.variant).to eq variant
+      end
+    end
+
+    it 'finds a count_on_hand for a variant' do
+       expect(subject.count_on_hand(variant)).to eq 10
+    end
+
+    it 'finds determines if you a variant is backorderable' do
+      expect(subject.backorderable?(variant)).to be true
+    end
+
+    it 'restocks a variant with a positive stock movement' do
+      originator = double
+      expect(subject).to receive(:move).with(variant, 5, originator)
+      subject.restock(variant, 5, originator)
+    end
+
+    it 'unstocks a variant with a negative stock movement' do
+      originator = double
+      expect(subject).to receive(:move).with(variant, -5, originator)
+      subject.unstock(variant, 5, originator)
+    end
+
+    it 'it creates a stock_movement' do
+      expect {
+        subject.move variant, 5
+      }.to change { subject.stock_movements.where(stock_item_id: stock_item).count }.by(1)
+    end
+
+    it 'can be deactivated' do
+      create(:stock_location, active: true)
+      create(:stock_location, active: false)
+      expect(Spree::StockLocation.active.count).to eq 1
+    end
+
+    it 'ensures only one stock location is default at a time' do
+      first = create(:stock_location, active: true, default: true)
+      second = create(:stock_location, active: true, default: true)
+
+      expect(first.reload.default).to eq false
+      expect(second.reload.default).to eq true
+
+      first.default = true
+      first.save!
+
+      expect(first.reload.default).to eq true
+      expect(second.reload.default).to eq false
+    end
+
+    context 'fill_status' do
+      it 'all on_hand with no backordered' do
+        on_hand, backordered = subject.fill_status(variant, 5)
+        expect(on_hand).to eq 5
+        expect(backordered).to eq 0
+      end
+
+      it 'some on_hand with some backordered' do
+        on_hand, backordered = subject.fill_status(variant, 20)
+        expect(on_hand).to eq 10
+        expect(backordered).to eq 10
+      end
+
+      it 'zero on_hand with all backordered' do
+        stock_item.set_count_on_hand(0)
+
+        on_hand, backordered = subject.fill_status(variant, 20)
+        expect(on_hand).to eq 0
+        expect(backordered).to eq 20
+      end
+
+      context 'when backordering is not allowed' do
+        before do
+          stock_item.update!(backorderable: false)
+        end
+
+        it 'all on_hand' do
+          stock_item.set_count_on_hand(10)
+
+          on_hand, backordered = subject.fill_status(variant, 5)
+          expect(on_hand).to eq 5
+          expect(backordered).to eq 0
+        end
+
+        it 'some on_hand' do
+          stock_item.set_count_on_hand(10)
+
+          on_hand, backordered = subject.fill_status(variant, 20)
+          expect(on_hand).to eq 10
+          expect(backordered).to eq 0
+        end
+
+        it 'zero on_hand' do
+          stock_item.set_count_on_hand(0)
+
+          on_hand, backordered = subject.fill_status(variant, 20)
+          expect(on_hand).to eq 0
+          expect(backordered).to eq 0
+        end
+      end
+
+      context 'without stock_items' do
+        subject { create(:stock_location) }
+        let(:variant) { create(:base_variant) }
+
+        it 'zero on_hand and backordered' do
+          subject
+          variant.stock_items.each(&:really_destroy!)
+          on_hand, backordered = subject.fill_status(variant, 1)
+          expect(on_hand).to eq 0
+          expect(backordered).to eq 0
+        end
+      end
+
+      context 'with soft-deleted stock_items' do
+        subject { create(:stock_location) }
+        let(:variant) { create(:base_variant) }
+
+        it 'zero on_hand and backordered' do
+          subject
+          variant.stock_items.discard_all
+          on_hand, backordered = subject.fill_status(variant, 1)
+          expect(on_hand).to eq 0
+          expect(backordered).to eq 0
+        end
+      end
+    end
+
+    context '#state_text' do
+      context 'state is blank' do
+        subject { StockLocation.create(name: "testing", state: nil, state_name: 'virginia') }
+        specify { expect(subject.state_text).to eq('virginia') }
+      end
+
+      context 'both name and abbr is present' do
+        let(:state) { stub_model(Spree::State, name: 'virginia', abbr: 'va') }
+        subject { StockLocation.create(name: "testing", state: state, state_name: nil) }
+        specify { expect(subject.state_text).to eq('va') }
+      end
+
+      context 'only name is present' do
+        let(:state) { stub_model(Spree::State, name: 'virginia', abbr: nil) }
+        subject { StockLocation.create(name: "testing", state: state, state_name: nil) }
+        specify { expect(subject.state_text).to eq('virginia') }
+      end
+    end
+
+    describe "#move" do
+      let!(:variant) { create(:variant) }
+      def move
+        subject.move(variant, quantity)
+      end
+
+      context "no stock item exists" do
+        before { subject.stock_items.each(&:really_destroy!) }
+        context "positive movement" do
+          let(:quantity) { 1 }
+          it "creates a stock item" do
+            expect { move }.to change { subject.stock_items.count }.by 1
+          end
+        end
+
+        # We should not be creating stock items that do not exist
+        # for the sake of a negative movement.
+        context "negative movement" do
+          let(:quantity) { -1 }
+          it "raises an error" do
+            expect {
+              expect {
+                move
+              }.to raise_error StockLocation::InvalidMovementError
+            }.not_to change { subject.stock_items.count }
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/stock_movement_spec.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::StockMovement, type: :model do
+  let(:stock_location) { create(:stock_location_with_items) }
+  let(:stock_item) { stock_location.stock_items.order(:id).first }
+  subject { build(:stock_movement, stock_item: stock_item) }
+
+  it 'should belong to a stock item' do
+    expect(subject).to respond_to(:stock_item)
+  end
+
+  it 'is readonly unless new' do
+    subject.save
+    expect {
+      subject.save
+    }.to raise_error(ActiveRecord::ReadOnlyRecord)
+  end
+
+  it 'does not update count on hand when track inventory levels is false' do
+    Spree::Config[:track_inventory_levels] = false
+    subject.quantity = 1
+    subject.save
+    stock_item.reload
+    expect(stock_item.count_on_hand).to eq(10)
+  end
+
+  it 'does not update count on hand when variant inventory tracking is off' do
+    stock_item.variant.track_inventory = false
+    subject.quantity = 1
+    subject.save
+    stock_item.reload
+    expect(stock_item.count_on_hand).to eq(10)
+  end
+
+  context "when quantity is negative" do
+    context "after save" do
+      it "should decrement the stock item count on hand" do
+        subject.quantity = -1
+        subject.save
+        stock_item.reload
+        expect(stock_item.count_on_hand).to eq(9)
+      end
+    end
+  end
+
+  context "when quantity is positive" do
+    context "after save" do
+      it "should increment the stock item count on hand" do
+        subject.quantity = 1
+        subject.save
+        stock_item.reload
+        expect(stock_item.count_on_hand).to eq(11)
+      end
+    end
+  end
+end

data/spec/models/spree/stock_quantities_spec.rb

@@ -0,0 +1,249 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::StockQuantities, type: :model do
+  let(:variant1) { mock_model(Spree::Variant) }
+  let(:variant2) { mock_model(Spree::Variant) }
+
+  subject do
+    described_class.new(quantities)
+  end
+
+  describe "#each" do
+    def expect_each
+      expect { |b| subject.each(&b) }
+    end
+
+    context "with no items" do
+      let(:quantities) { {} }
+
+      it "doesn't yield" do
+        expect_each.not_to yield_control
+      end
+    end
+
+    context "with one item" do
+      let(:quantities) { { variant1 => 2 } }
+
+      it "yields values" do
+        expect_each.to yield_with_args([variant1, 2])
+      end
+    end
+
+    context "with two items" do
+      let(:quantities) { { variant1 => 2, variant2 => 3 } }
+
+      it "yields values" do
+        expect_each.to yield_successive_args([variant1, 2], [variant2, 3])
+      end
+    end
+  end
+
+  describe "#variants" do
+    context "with one item" do
+      let(:quantities) { { variant1 => 2 } }
+
+      it "returns variant" do
+        expect(subject.variants).to eq [variant1]
+      end
+    end
+
+    context "with two items" do
+      let(:quantities) { { variant1 => 2, variant2 => 3 } }
+
+      it "returns both variants" do
+        expect(subject.variants).to eq [variant1, variant2]
+      end
+    end
+  end
+
+  describe "#empty?" do
+    context "no variants" do
+      let(:quantities) { {} }
+      it { is_expected.to be_empty }
+    end
+
+    context "only quantity 0" do
+      let(:quantities) { { variant1 => 0 } }
+      it { is_expected.to be_empty }
+    end
+
+    context "positive quantity" do
+      let(:quantities) { { variant1 => 1 } }
+      it { is_expected.not_to be_empty }
+    end
+
+    context "one variant positive one zero" do
+      let(:quantities) { { variant1 => 1, variant2 => 0 } }
+      it { is_expected.not_to be_empty }
+    end
+
+    context "negative quantity" do
+      # empty? doesn't make a whole lot of sense in this case, but returning
+      # false is probably more accurate.
+      let(:quantities) { { variant1 => -1 } }
+      it { is_expected.not_to be_empty }
+    end
+  end
+
+  describe "==" do
+    subject do
+      described_class.new(quantity1) == described_class.new(quantity2)
+    end
+
+    context "when both empty" do
+      let(:quantity1) { {} }
+      let(:quantity2) { {} }
+      it { is_expected.to be true }
+    end
+
+    context "when both equal" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { { variant1 => 1 } }
+      it { is_expected.to be true }
+    end
+
+    context "with different order" do
+      let(:quantity1) { { variant1 => 1, variant2 => 2 } }
+      let(:quantity2) { { variant2 => 2, variant1 => 1 } }
+      it { is_expected.to be true }
+    end
+
+    context "with different variant" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { { variant2 => 1 } }
+      it { is_expected.to be false }
+    end
+
+    context "with different quantities" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { { variant1 => 2 } }
+      it { is_expected.to be false }
+    end
+
+    context "nil != 0" do
+      let(:quantity1) { { variant1 => 0 } }
+      let(:quantity2) { {} }
+      it { is_expected.to be false }
+    end
+  end
+
+  describe "+" do
+    subject do
+      described_class.new(quantity1) + described_class.new(quantity2)
+    end
+
+    context "same variant" do
+      let(:quantity1) { { variant1 => 20 } }
+      let(:quantity2) { { variant1 => 22 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 42 }) }
+    end
+
+    context "different variants" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { { variant2 => 2 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 1, variant2 => 2 }) }
+    end
+
+    context "0 quantities" do
+      let(:quantity1) { { variant1 => 0 } }
+      let(:quantity2) { { variant2 => 1 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 0, variant2 => 1 }) }
+    end
+
+    context "empty quantity" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { {} }
+
+      it { is_expected.to eq described_class.new({ variant1 => 1 }) }
+    end
+  end
+
+  describe "-" do
+    subject do
+      described_class.new(quantity1) - described_class.new(quantity2)
+    end
+
+    context "same variant" do
+      let(:quantity1) { { variant1 => 22 } }
+      let(:quantity2) { { variant1 => 20 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 2 }) }
+    end
+
+    context "different variants" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { { variant2 => 2 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 1, variant2 => -2 }) }
+    end
+
+    context "0 quantity" do
+      let(:quantity1) { { variant1 => 0 } }
+      let(:quantity2) { { variant1 => 1 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => -1 }) }
+    end
+
+    context "empty quantity RHS" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { {} }
+
+      it { is_expected.to eq described_class.new({ variant1 => 1 }) }
+    end
+
+    context "empty quantity LHS" do
+      let(:quantity1) { {} }
+      let(:quantity2) { { variant1 => 1 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => -1 }) }
+    end
+  end
+
+  # Common subset
+  describe "&" do
+    subject do
+      described_class.new(quantity1) & described_class.new(quantity2)
+    end
+
+    context "same variant" do
+      let(:quantity1) { { variant1 => 20 } }
+      let(:quantity2) { { variant1 => 22 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 20 }) }
+    end
+
+    context "multiple variants" do
+      let(:quantity1) { { variant1 => 10, variant2 => 20 } }
+      let(:quantity2) { { variant1 => 12, variant2 => 14 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 10, variant2 => 14 }) }
+    end
+
+    context "different variants" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { { variant2 => 2 } }
+
+      it { is_expected.to be_empty }
+      it { is_expected.to eq described_class.new({}) }
+    end
+
+    context "0 quantities" do
+      let(:quantity1) { { variant1 => 0 } }
+      let(:quantity2) { { variant1 => 1 } }
+
+      it { is_expected.to eq described_class.new({ variant1 => 0 }) }
+    end
+
+    context "empty quantity" do
+      let(:quantity1) { { variant1 => 1 } }
+      let(:quantity2) { {} }
+
+      it { is_expected.to eq described_class.new({}) }
+    end
+  end
+end

data/spec/models/spree/store_credit_category_spec.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::StoreCreditCategory, type: :model do
+  describe "#non_expiring?" do
+    let(:store_credit_category) { build(:store_credit_category, name: category_name) }
+
+    context "non-expiring type store credit" do
+      let(:category_name) { "Non-expiring" }
+      it { expect(store_credit_category).to be_non_expiring }
+    end
+
+    context "expiring type store credit" do
+      let(:category_name) { "Expiring" }
+      it { expect(store_credit_category).not_to be_non_expiring }
+    end
+  end
+end