solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/models/spree/distributed_amounts_handler_spec.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require "rails_helper"
+
+RSpec.describe Spree::DistributedAmountsHandler, type: :model do
+  let(:order) do
+    FactoryBot.create(
+      :order_with_line_items,
+      line_items_attributes: line_items_attributes
+    )
+  end
+
+  let(:handler) {
+    described_class.new(order.line_items, total_amount)
+  }
+
+  describe "#amount" do
+    let(:total_amount) { 15 }
+
+    context "when there is only one line item" do
+      let(:line_items_attributes) { [{ price: 100 }] }
+      let(:line_item) { order.line_items.first }
+
+      it "applies the entire amount to the line item" do
+        expect(handler.amount(line_item)).to eq(15)
+      end
+    end
+
+    context "when there are multiple line items" do
+      let(:line_items_attributes) do
+        [{ price: 50 }, { price: 50 }, { price: 50 }]
+      end
+
+      context "and the line items are equally priced" do
+        it "evenly distributes the total amount" do
+          expect(
+            [
+              handler.amount(order.line_items[0]),
+              handler.amount(order.line_items[1]),
+              handler.amount(order.line_items[2])
+            ]
+          ).to eq(
+            [5, 5, 5]
+          )
+        end
+
+        context "and the total amount cannot be equally distributed" do
+          let(:total_amount) { 10 }
+
+          it "applies the remainder of the total amount to the last item" do
+            expect(
+              [
+                handler.amount(order.line_items[0]),
+                handler.amount(order.line_items[1]),
+                handler.amount(order.line_items[2])
+              ]
+            ).to match_array(
+              [3.33, 3.33, 3.34]
+            )
+          end
+        end
+      end
+
+      context "and the line items do not have equal subtotal amounts" do
+        let(:line_items_attributes) do
+          [{ price: 50, quantity: 3 }, { price: 50, quantity: 1 }, { price: 50, quantity: 2 }]
+        end
+
+        it "distributes the total amount relative to the item's price" do
+          expect(
+            [
+              handler.amount(order.line_items[0]),
+              handler.amount(order.line_items[1]),
+              handler.amount(order.line_items[2])
+            ]
+          ).to eq(
+            [7.5, 2.5, 5]
+          )
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/exchange_spec.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+module Spree
+  RSpec.describe Exchange, type: :model do
+    let(:order) { Spree::Order.new }
+
+    let(:return_item_1) { build(:exchange_return_item) }
+    let(:return_item_2) { build(:exchange_return_item) }
+    let(:return_items) { [return_item_1, return_item_2] }
+    let(:exchange) { Exchange.new(order, return_items) }
+
+    describe "#description" do
+      before do
+        allow(return_item_1).to receive(:variant) { double(options_text: "foo") }
+        allow(return_item_1).to receive(:exchange_variant) { double(options_text: "bar") }
+        allow(return_item_2).to receive(:variant) { double(options_text: "baz") }
+        allow(return_item_2).to receive(:exchange_variant) { double(options_text: "qux") }
+      end
+
+      it "describes the return items' change in options" do
+        expect(exchange.description).to match /foo => bar/
+        expect(exchange.description).to match /baz => qux/
+      end
+    end
+
+    describe "#display_amount" do
+      it "is the total amount of all return items" do
+        expect(exchange.display_amount).to eq Spree::Money.new(0.0)
+      end
+    end
+
+    describe "#perform!" do
+      let(:return_item) { create(:exchange_return_item, inventory_unit: inventory_unit) }
+      let(:return_items) { [return_item] }
+
+      let(:inventory_unit) { create(:inventory_unit, order: order, line_item: line_item) }
+      let(:order) { create(:shipped_order, line_items_count: 1) }
+      let(:line_item) { order.line_items.first }
+
+      subject { exchange.perform! }
+      before { return_item.exchange_variant.stock_items.first.adjust_count_on_hand(20) }
+
+      it "creates shipments for the order with the return items exchange inventory units" do
+        expect { subject }.to change { order.shipments.count }.by(1)
+        new_shipment = order.shipments.last
+        expect(new_shipment).to be_ready
+        new_inventory_units = new_shipment.inventory_units
+        expect(new_inventory_units.count).to eq 1
+        expect(new_inventory_units.first.original_return_item).to eq return_item
+        expect(new_inventory_units.first.line_item).to eq return_item.inventory_unit.line_item
+      end
+
+      context "when it cannot create shipments for all items" do
+        before do
+          StockItem.where(variant_id: return_item.exchange_variant_id).each(&:really_destroy!)
+        end
+
+        it 'raises an UnableToCreateShipments error' do
+          expect {
+            subject
+          }.to raise_error(Spree::Exchange::UnableToCreateShipments)
+        end
+      end
+    end
+
+    describe "#to_key" do # for dom_id
+      it { expect(Exchange.new(nil, nil).to_key).to be_nil }
+    end
+
+    describe ".param_key" do # for dom_id
+      it { expect(Exchange.param_key).to eq "spree_exchange" }
+    end
+  end
+end

data/spec/models/spree/fulfilment_changer_spec.rb

@@ -0,0 +1,307 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::FulfilmentChanger do
+  let(:variant) { create(:variant) }
+
+  let(:order) do
+    create(
+      :completed_order_with_totals,
+      line_items_attributes: [
+        {
+          quantity: current_shipment_inventory_unit_count,
+          variant: variant
+        }
+      ]
+    )
+  end
+
+  let(:current_shipment) { order.shipments.first }
+  let(:desired_shipment) { order.shipments.create!(stock_location: desired_stock_location) }
+  let(:desired_stock_location) { current_shipment.stock_location }
+
+  let(:shipment_splitter) do
+    described_class.new(
+      current_shipment: current_shipment,
+      desired_shipment: desired_shipment,
+      variant: variant,
+      quantity: quantity
+    )
+  end
+
+  subject { shipment_splitter.run! }
+
+  before do
+    order && desired_shipment
+    variant.stock_items.first.update_column(:count_on_hand, 100)
+  end
+
+  context "when the current shipment has enough inventory units" do
+    let(:current_shipment_inventory_unit_count) { 2 }
+    let(:quantity) { 1 }
+
+    it "adds the desired inventory units to the desired shipment" do
+      expect { subject }.to change { desired_shipment.inventory_units.length }.by(quantity)
+    end
+
+    it "removes the desired inventory units from the current shipment" do
+      expect { subject }.to change { current_shipment.inventory_units.length }.by(-quantity)
+    end
+
+    it "recalculates shipping costs for the current shipment" do
+      expect(current_shipment).to receive(:refresh_rates)
+      subject
+    end
+
+    it "recalculates shipping costs for the new shipment" do
+      expect(desired_shipment).to receive(:refresh_rates)
+      subject
+    end
+
+    it 'updates order totals' do
+      original_total = order.total
+      original_shipment_total = order.shipment_total
+
+      expect { subject }.
+        to change { order.total }.from(original_total).to(original_total + original_shipment_total).
+        and change { order.shipment_total }.by(original_shipment_total)
+    end
+
+    context "when transferring to another stock location" do
+      let(:desired_stock_location) { create(:stock_location) }
+      let!(:stock_item) do
+        variant.stock_items.find_or_create_by!(
+          stock_location: desired_stock_location,
+          variant: variant,
+        )
+      end
+
+      before do
+        stock_item.set_count_on_hand(desired_count_on_hand)
+        stock_item.update(backorderable: false)
+      end
+
+      context "when the other stock location has enough stock" do
+        let(:desired_count_on_hand) { 2 }
+
+        it "is marked as a successful transfer" do
+          expect(subject).to be true
+        end
+
+        it "stocks the current stock location back up" do
+          expect { subject }.to change { current_shipment.stock_location.count_on_hand(variant) }.by(quantity)
+        end
+
+        it "unstocks the desired stock location" do
+          expect { subject }.to change { desired_shipment.stock_location.count_on_hand(variant) }.by(-quantity)
+        end
+
+        context "when the order is not completed" do
+          before do
+            allow(order).to receive(:completed?).and_return(false)
+          end
+
+          it "does not stock the current stock location back up" do
+            expect { subject }.not_to change { current_shipment.stock_location.count_on_hand(variant) }
+          end
+
+          it "does not unstock the desired location" do
+            expect { subject }.not_to change { stock_item.count_on_hand }
+          end
+        end
+      end
+
+      context "when the desired stock location can only partially fulfil the quantity" do
+        let(:current_shipment_inventory_unit_count) { 10 }
+        let(:quantity) { 7 }
+        let(:desired_count_on_hand) { 5 }
+
+        before do
+          stock_item.update(backorderable: true)
+        end
+
+        it "restocks seven at the original stock location" do
+          expect { subject }.to change { current_shipment.stock_location.count_on_hand(variant) }.by(7)
+        end
+
+        it "unstocks seven at the desired stock location" do
+          expect { subject }.to change { desired_shipment.stock_location.count_on_hand(variant) }.by(-7)
+        end
+
+        it "creates a shipment with the correct number of on hand and backordered units" do
+          subject
+          expect(desired_shipment.inventory_units.on_hand.count).to eq(5)
+          expect(desired_shipment.inventory_units.backordered.count).to eq(2)
+        end
+
+        context "when the desired stock location already has a backordered units" do
+          let(:desired_count_on_hand) { -1 }
+
+          it "restocks seven at the original stock location" do
+            expect { subject }.to change { current_shipment.stock_location.count_on_hand(variant) }.by(7)
+          end
+
+          it "unstocks seven at the desired stock location" do
+            expect { subject }.to change { desired_shipment.stock_location.count_on_hand(variant) }.by(-7)
+          end
+
+          it "creates a shipment with the correct number of on hand and backordered units" do
+            subject
+            expect(desired_shipment.inventory_units.on_hand.count).to eq(0)
+            expect(desired_shipment.inventory_units.backordered.count).to eq(7)
+          end
+        end
+
+        context "when the original shipment has on hand and backordered units" do
+          before do
+            current_shipment.inventory_units.limit(6).update_all(state: :backordered)
+          end
+
+          it "removes the backordered items first" do
+            subject
+            expect(current_shipment.inventory_units.backordered.count).to eq(0)
+            expect(current_shipment.inventory_units.on_hand.count).to eq(3)
+          end
+        end
+
+        context "when the original shipment had some backordered units" do
+          let(:current_stock_item) { current_shipment.stock_location.stock_items.find_by(variant: variant) }
+          let(:desired_stock_item) { desired_shipment.stock_location.stock_items.find_by(variant: variant) }
+          let(:backordered_units)  { 6 }
+
+          before do
+            current_shipment.inventory_units.limit(backordered_units).update_all(state: :backordered)
+            current_stock_item.set_count_on_hand(-backordered_units)
+          end
+
+          it "restocks four at the original stock location" do
+            expect { subject }.to change { current_stock_item.reload.count_on_hand }.from(-backordered_units).to(1)
+          end
+
+          it "unstocks five at the desired stock location" do
+            expect { subject }.to change { desired_stock_item.reload.count_on_hand }.from(5).to(-2)
+          end
+
+          it "creates a shipment with the correct number of on hand and backordered units" do
+            subject
+            expect(desired_shipment.inventory_units.on_hand.count).to eq(5)
+            expect(desired_shipment.inventory_units.backordered.count).to eq(2)
+          end
+        end
+      end
+
+      context "when the other stock location does not have enough stock" do
+        let(:desired_count_on_hand) { 0 }
+
+        it "is not successful" do
+          expect(subject).to be false
+        end
+
+        it "has an activemodel error hash" do
+          subject
+          expect(shipment_splitter.errors.messages).to eq(desired_shipment: ["not enough stock in desired stock location"])
+        end
+      end
+    end
+
+    context "when the quantity to transfer is not positive" do
+      let(:quantity) { 0 }
+
+      it "is not successful" do
+        expect(subject).to be false
+      end
+
+      it "has an activemodel error hash" do
+        subject
+        expect(shipment_splitter.errors.messages).to eq(quantity: ["must be greater than 0"])
+      end
+    end
+
+    context "when the desired shipment is identical to the current shipment" do
+      let(:desired_shipment) { current_shipment }
+
+      it "is not successful" do
+        expect(subject).to be false
+      end
+
+      it "has an activemodel error hash" do
+        subject
+        expect(shipment_splitter.errors.messages).to eq(desired_shipment: ["can not be same as current shipment"])
+      end
+    end
+
+    context "when the desired shipment has no stock location" do
+      let(:desired_stock_location) { nil }
+
+      it "is not successful" do
+        expect(subject).to be false
+      end
+
+      it "has an activemodel error hash" do
+        subject
+        expect(shipment_splitter.errors.messages).to eq(desired_stock_location: ["can't be blank"])
+      end
+    end
+
+    context "when the current shipment has been shipped already" do
+      let(:order) do
+        create(
+          :shipped_order,
+          line_items_attributes: [
+            {
+              quantity: current_shipment_inventory_unit_count,
+              variant: variant
+            }
+          ]
+        )
+      end
+
+      it "is not successful" do
+        expect(subject).to be false
+      end
+
+      it "has an activemodel error hash" do
+        subject
+        expect(shipment_splitter.errors.messages).to eq(current_shipment: ["has already been shipped"])
+      end
+    end
+  end
+
+  context "when the current shipment is emptied out by the transfer" do
+    let(:current_shipment_inventory_unit_count) { 30 }
+    let(:quantity) { 30 }
+
+    it "adds the desired inventory units to the desired shipment" do
+      expect { subject }.to change { desired_shipment.inventory_units.length }.by(quantity)
+    end
+
+    it "removes the current shipment" do
+      expect { subject }.to change { Spree::Shipment.count }.by(-1)
+    end
+  end
+
+  context "when the desired shipment is not yet persisted" do
+    let(:current_shipment_inventory_unit_count) { 2 }
+    let(:quantity) { 1 }
+
+    let(:desired_shipment) { order.shipments.build(stock_location: current_shipment.stock_location) }
+
+    it "adds the desired inventory units to the desired shipment" do
+      expect { subject }.to change { Spree::Shipment.count }.by(1)
+    end
+
+    context "if the desired shipment is invalid" do
+      let(:desired_shipment) { order.shipments.build(stock_location_id: 99_999_999) }
+
+      it "is not successful" do
+        expect(subject).to be false
+      end
+
+      it "has an activemodel error hash" do
+        subject
+        expect(shipment_splitter.errors.messages).to eq(desired_stock_location: ["can't be blank"])
+      end
+    end
+  end
+end

data/spec/models/spree/gallery/product_gallery_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+require 'spree/testing_support/shared_examples/gallery'
+
+RSpec.describe Spree::Gallery::ProductGallery do
+  let(:gallery) { described_class.new(product) }
+  let(:product) { create(:product) }
+
+  shared_context 'has multiple images' do
+    let(:first_image) { build(:image) }
+    let(:second_image) { build(:image) }
+
+    before do
+      product.images << first_image
+      product.images << second_image
+    end
+  end
+
+  it_behaves_like 'a gallery'
+end

data/spec/models/spree/gallery/variant_gallery_spec.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+require 'spree/testing_support/shared_examples/gallery'
+
+RSpec.describe Spree::Gallery::VariantGallery do
+  let(:gallery) { described_class.new(variant) }
+  let(:variant) { Spree::Variant.new }
+
+  shared_context 'has multiple images' do
+    let(:first_image) { build(:image) }
+    let(:second_image) { build(:image) }
+
+    before do
+      variant.images << first_image
+      variant.images << second_image
+    end
+  end
+
+  it_behaves_like 'a gallery'
+end

data/spec/models/spree/gateway/bogus_simple.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Gateway::BogusSimple do
+  it 'is deprecated' do
+    expect(Spree::Deprecation).to receive(:warn)
+    described_class.new
+  end
+
+  it 'has Spree::PaymentMethod::SimpleBogusCreditCard as superclass' do
+    expect(described_class.ancestors).to include(Spree::PaymentMethod::SimpleBogusCreditCard)
+  end
+end

data/spec/models/spree/gateway/bogus_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Gateway::Bogus do
+  it 'is deprecated' do
+    expect(Spree::Deprecation).to receive(:warn)
+    described_class.new
+  end
+
+  it 'has Spree::PaymentMethod::BogusCreditCard as superclass' do
+    expect(described_class.ancestors).to include(Spree::PaymentMethod::BogusCreditCard)
+  end
+end

data/spec/models/spree/gateway_spec.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Gateway do
+  it 'is deprecated' do
+    expect(Spree::Deprecation).to receive(:warn)
+    described_class.new
+  end
+
+  it 'has Spree::PaymentMethod::CreditCard as superclass' do
+    expect(described_class.ancestors).to include(Spree::PaymentMethod::CreditCard)
+  end
+end

data/spec/models/spree/image_spec.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+require 'rails_helper'
+
+RSpec.describe Spree::Image, type: :model do
+  context '#save' do
+    context 'invalid attachment' do
+      let(:invalid_image) { File.open(__FILE__) }
+      subject { described_class.new(attachment: invalid_image) }
+
+      it 'returns false' do
+        expect(subject.save).to be false
+      end
+    end
+
+    context 'valid attachment' do
+      let(:valid_image) { File.open(File.join('spec', 'fixtures', 'thinking-cat.jpg')) }
+      subject { described_class.new(attachment: valid_image) }
+
+      it 'returns true' do
+        expect(subject.save).to be true
+      end
+    end
+  end
+end