solidus_core 2.10.5 → 3.0.8

data/spec/models/spree/distributed_amounts_handler_spec.rb

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

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

@@ -1,340 +0,0 @@
-# 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 stock location is the same of the target shipment" do
-    let(:current_shipment_inventory_unit_count) { 1 }
-    let(:quantity) { current_shipment_inventory_unit_count }
-
-    context "when the stock location is empty" do
-      before do
-        variant.stock_items.first.update_column(:count_on_hand, 0)
-      end
-
-      context "when the inventory unit is backordered" do
-        before do
-          current_shipment.inventory_units.first.update state: :backordered
-        end
-
-        it "creates a new backordered inventory unit" do
-          subject
-          expect(desired_shipment.inventory_units.first).to be_backordered
-        end
-      end
-
-      context "when the inventory unit is on hand" do
-        before do
-          current_shipment.inventory_units.first.update state: :on_hand
-        end
-
-        it "creates a new on hand inventory unit" do
-          subject
-          expect(desired_shipment.inventory_units.first).to be_on_hand
-        end
-      end
-    end
-  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

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

@@ -1,21 +0,0 @@
-# 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) { build_stubbed(:variant) }
-
-  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

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

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

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

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