solidus_core 2.10.5 → 3.0.8

data/spec/models/spree/return_authorization_spec.rb

@@ -1,226 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::ReturnAuthorization, type: :model do
-  let(:order) { create(:shipped_order) }
-  let(:stock_location) { create(:stock_location) }
-  let(:rma_reason) { create(:return_reason) }
-  let(:inventory_unit_1) { order.inventory_units.first }
-
-  let(:variant) { order.variants.first }
-  let(:return_authorization) do
-    Spree::ReturnAuthorization.new(order: order,
-      stock_location_id: stock_location.id,
-      return_reason_id: rma_reason.id)
-  end
-
-  context "save" do
-    let(:order) { Spree::Order.create }
-
-    it "should be invalid when order has no inventory units" do
-      order.inventory_units.each(&:delete)
-      return_authorization.save
-      expect(return_authorization.errors[:order]).to eq(["has no shipped units"])
-    end
-
-    context "an inventory unit is already being exchanged" do
-      let(:order)                           { create(:shipped_order, line_items_count: 2) }
-      let!(:previous_exchange_return_item)  { create(:exchange_return_item, inventory_unit: order.inventory_units.last) }
-      let(:return_item)                     { create(:return_item, inventory_unit: order.inventory_units.last) }
-      let(:return_authorization)            { build(:return_authorization, order: order, return_items: [return_item]) }
-
-      it "should be invalid" do
-        return_authorization.save
-        expect(return_authorization.errors['base']).to include('Return items cannot be created for inventory units that are already awaiting exchange.')
-      end
-    end
-
-    context "an inventory unit is not being exchanged" do
-      let(:order)                           { create(:shipped_order, line_items_count: 2) }
-      let(:return_item)                     { create(:return_item, inventory_unit: order.inventory_units.last) }
-      let(:return_authorization)            { build(:return_authorization, order: order, return_items: [return_item]) }
-
-      it "is valid" do
-        return_authorization.save
-        expect(return_authorization.errors['base'].size).to eq 0
-      end
-    end
-  end
-
-  describe ".before_create" do
-    describe "#generate_number" do
-      context "number is assigned" do
-        let(:return_authorization) { Spree::ReturnAuthorization.new(number: '123') }
-
-        it "should return the assigned number" do
-          return_authorization.save
-          expect(return_authorization.number).to eq('123')
-        end
-      end
-
-      context "number is not assigned" do
-        let(:return_authorization) { Spree::ReturnAuthorization.new(number: nil) }
-
-        before { allow(return_authorization).to receive_messages valid?: true }
-
-        it "should assign number with random RA number" do
-          return_authorization.save
-          expect(return_authorization.number).to match(/RA\d{9}/)
-        end
-      end
-    end
-  end
-
-  context "#currency" do
-    before { allow(order).to receive(:currency) { "ABC" } }
-    it "returns the order currency" do
-      expect(return_authorization.currency).to eq("ABC")
-    end
-  end
-
-  describe "#total_excluding_vat" do
-    let(:amount_1) { 15.0 }
-    let!(:return_item_1) { create(:return_item, return_authorization: return_authorization, amount: amount_1) }
-
-    let(:amount_2) { 50.0 }
-    let!(:return_item_2) { create(:return_item, return_authorization: return_authorization, amount: amount_2) }
-
-    let(:amount_3) { 5.0 }
-    let!(:return_item_3) { create(:return_item, return_authorization: return_authorization, amount: amount_3) }
-
-    subject { return_authorization.reload.total_excluding_vat }
-
-    it "sums it's associated return_item's amounts" do
-      expect(subject).to eq(amount_1 + amount_2 + amount_3)
-    end
-  end
-
-  describe "#display_total_excluding_vat" do
-    it "returns a Spree::Money" do
-      allow(return_authorization).to receive_messages(total_excluding_vat: 21.22)
-      expect(return_authorization.display_total_excluding_vat).to eq(Spree::Money.new(21.22))
-    end
-  end
-
-  describe "#amount" do
-    let(:return_item1) { create(:return_item, amount: 10) }
-    let(:return_item2) { create(:return_item, amount: 5) }
-    let(:return_authorization) { create(:return_authorization, return_items: [return_item1, return_item2]) }
-
-    subject { return_authorization.amount }
-
-    it "sums the return items' amounts" do
-      expect(subject).to eq(15)
-    end
-  end
-
-  describe "#refundable_amount" do
-    let(:line_item_price) { 5.0 }
-    let(:line_item_count) { return_authorization.order.line_items.count }
-
-    subject { return_authorization.refundable_amount }
-
-    before do
-      return_authorization.order.line_items.update_all(price: line_item_price)
-      return_authorization.order.update_attribute(:promo_total, promo_total)
-    end
-
-    context "no promotions" do
-      let(:promo_total) { 0.0 }
-      it "returns the pre-tax line item total" do
-        expect(subject).to eq(line_item_price * line_item_count)
-      end
-    end
-
-    context "promotions" do
-      let(:promo_total) { -10.0 }
-      it "returns the pre-tax line item total minus the order level promotion value" do
-        expect(subject).to eq((line_item_price * line_item_count) + promo_total)
-      end
-    end
-  end
-
-  describe "#customer_returned_items?" do
-    before do
-      allow_any_instance_of(Spree::Order).to receive_messages(return!: true)
-    end
-
-    subject { return_authorization.customer_returned_items? }
-
-    context "has associated customer returns" do
-      let(:customer_return) { create(:customer_return) }
-      let(:return_authorization) { customer_return.return_authorizations.first }
-
-      it "returns true" do
-        expect(subject).to eq true
-      end
-    end
-
-    context "does not have associated customer returns" do
-      let(:return_authorization) { create(:return_authorization) }
-
-      it "returns false" do
-        expect(subject).to eq false
-      end
-    end
-  end
-
-  describe 'cancel_return_items' do
-    let(:return_authorization) { create(:return_authorization, return_items: return_items) }
-    let(:return_items) { [return_item] }
-    let(:return_item) { create(:return_item) }
-
-    subject {
-      return_authorization.cancel!
-    }
-
-    it 'cancels the associated return items' do
-      subject
-      expect(return_item.reception_status).to eq 'cancelled'
-    end
-
-    context 'some return items cannot be cancelled' do
-      let(:return_items) { [return_item, return_item_2] }
-      let(:return_item_2) { create(:return_item, reception_status: 'received') }
-
-      it 'cancels those that can be cancelled' do
-        subject
-        expect(return_item.reception_status).to eq 'cancelled'
-        expect(return_item_2.reception_status).to eq 'received'
-      end
-    end
-  end
-
-  describe '#can_cancel?' do
-    subject { create(:return_authorization, return_items: return_items).can_cancel? }
-    let(:return_items) { [return_item_1, return_item_2] }
-    let(:return_item_1) { create(:return_item) }
-    let(:return_item_2) { create(:return_item) }
-
-    context 'all items can be cancelled' do
-      it 'returns true' do
-        expect(subject).to eq true
-      end
-    end
-
-    context 'at least one return item can be cancelled' do
-      let(:return_item_2) { create(:return_item, reception_status: 'received') }
-
-      it { is_expected.to eq true }
-    end
-
-    context 'no items can be cancelled' do
-      let(:return_item_1) { create(:return_item, reception_status: 'received') }
-      let(:return_item_2) { create(:return_item, reception_status: 'received') }
-
-      it { is_expected.to eq false }
-    end
-
-    context 'when return_authorization has no return_items' do
-      let(:return_items) { [] }
-
-      it { is_expected.to eq true }
-    end
-  end
-end

data/spec/models/spree/return_item/eligibility_validator/default_spec.rb

@@ -1,79 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::ReturnItem::EligibilityValidator::Default, type: :model do
-  let(:return_item) { create(:return_item) }
-  let(:validator) { Spree::ReturnItem::EligibilityValidator::Default.new(return_item) }
-
-  let(:time_eligibility_class) { double("TimeEligibilityValidatorClass") }
-  let(:rma_eligibility_class)  { double("RMAEligibilityValidatorClass") }
-
-  let(:time_eligibility_instance) { double(errors: time_error) }
-  let(:rma_eligibility_instance)  { double(errors: rma_error) }
-
-  let(:time_error) { {} }
-  let(:rma_error)  { {} }
-
-  before do
-    validator.permitted_eligibility_validators = [time_eligibility_class, rma_eligibility_class]
-
-    expect(time_eligibility_class).to receive(:new).and_return(time_eligibility_instance)
-    expect(rma_eligibility_class).to receive(:new).and_return(rma_eligibility_instance)
-  end
-
-  describe "#eligible_for_return?" do
-    subject { validator.eligible_for_return? }
-
-    it "checks that all permitted eligibility validators are eligible for return" do
-      expect(time_eligibility_instance).to receive(:eligible_for_return?).and_return(true)
-      expect(rma_eligibility_instance).to receive(:eligible_for_return?).and_return(true)
-
-      expect(subject).to be true
-    end
-  end
-
-  describe "#requires_manual_intervention?" do
-    subject { validator.requires_manual_intervention? }
-
-    context "any of the permitted eligibility validators require manual intervention" do
-      it "returns true" do
-        expect(time_eligibility_instance).to receive(:requires_manual_intervention?).and_return(false)
-        expect(rma_eligibility_instance).to receive(:requires_manual_intervention?).and_return(true)
-
-        expect(subject).to be true
-      end
-    end
-
-    context "no permitted eligibility validators require manual intervention" do
-      it "returns false" do
-        expect(time_eligibility_instance).to receive(:requires_manual_intervention?).and_return(false)
-        expect(rma_eligibility_instance).to receive(:requires_manual_intervention?).and_return(false)
-
-        expect(subject).to be false
-      end
-    end
-  end
-
-  describe "#errors" do
-    subject { validator.errors }
-
-    context "the validator errors are empty" do
-      it "returns an empty hash" do
-        expect(subject).to eq({})
-      end
-    end
-
-    context "the validators have errors" do
-      let(:time_error) { { time: time_error_text } }
-      let(:rma_error)  { { rma: rma_error_text } }
-
-      let(:time_error_text) { "Time eligibility error" }
-      let(:rma_error_text)  { "RMA eligibility error" }
-
-      it "gathers all errors from permitted eligibility validators into a single errors hash" do
-        expect(subject).to eq({ time: time_error_text, rma: rma_error_text })
-      end
-    end
-  end
-end

data/spec/models/spree/return_item/eligibility_validator/inventory_shipped_spec.rb

@@ -1,59 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::ReturnItem::EligibilityValidator::InventoryShipped do
-  let(:return_item) { create(:return_item) }
-  let(:validator)   { Spree::ReturnItem::EligibilityValidator::InventoryShipped.new(return_item) }
-
-  describe "#eligible_for_return?" do
-    before { allow(return_item.inventory_unit).to receive(:shipped?).and_return(true) }
-
-    subject { validator.eligible_for_return? }
-
-    context "the associated inventory unit is shipped" do
-      it "returns true" do
-        expect(subject).to eq true
-      end
-    end
-
-    context "the associated inventory unit is not shipped" do
-      before { allow(return_item.inventory_unit).to receive(:shipped?).and_return(false) }
-
-      it "returns false" do
-        expect(subject).to eq false
-      end
-
-      it "sets an error" do
-        subject
-        expect(validator.errors[:inventory_unit_shipped]).to eq I18n.t('spree.return_item_inventory_unit_ineligible')
-      end
-    end
-  end
-
-  describe "#requires_manual_intervention?" do
-    subject { validator.requires_manual_intervention? }
-
-    context "not eligible for return" do
-      before do
-        allow(return_item.inventory_unit).to receive(:shipped?).and_return(false)
-        validator.eligible_for_return?
-      end
-
-      it 'returns true if errors were added' do
-        expect(subject).to eq true
-      end
-    end
-
-    context "eligible for return" do
-      before do
-        allow(return_item.inventory_unit).to receive(:shipped?).and_return(true)
-        validator.eligible_for_return?
-      end
-
-      it 'returns false if no errors were added' do
-        expect(subject).to eq false
-      end
-    end
-  end
-end

data/spec/models/spree/return_item/eligibility_validator/no_reimbursements_spec.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::ReturnItem::EligibilityValidator::NoReimbursements do
-  let(:validator) { Spree::ReturnItem::EligibilityValidator::NoReimbursements.new(return_item) }
-
-  describe "#eligible_for_return?" do
-    subject { validator.eligible_for_return? }
-
-    context "inventory unit has already been reimbursed" do
-      let(:reimbursement) { create(:reimbursement) }
-      let(:return_item)   { reimbursement.return_items.last }
-
-      it "returns false" do
-        expect(subject).to eq false
-      end
-
-      it "sets an error" do
-        subject
-        expect(validator.errors[:inventory_unit_reimbursed]).to eq I18n.t('spree.return_item_inventory_unit_reimbursed')
-      end
-
-      context "but the return item has been expired" do
-        before { return_item.expired }
-
-        it "returns true" do
-          expect(subject).to eq true
-        end
-      end
-
-      context "but the return item has been canceled" do
-        before { return_item.cancel }
-
-        it "returns true" do
-          expect(subject).to eq true
-        end
-      end
-
-      context "but the return item has been unexchanged" do
-        before { return_item.unexchange }
-
-        it "returns true" do
-          expect(subject).to eq true
-        end
-      end
-    end
-
-    context "inventory unit has not been reimbursed" do
-      let(:return_item) { create(:return_item) }
-
-      it "returns true" do
-        expect(subject).to eq true
-      end
-    end
-  end
-
-  describe "#requires_manual_intervention?" do
-    subject { validator.requires_manual_intervention? }
-
-    context "not eligible for return" do
-      let(:reimbursement) { create(:reimbursement) }
-      let(:return_item)   { reimbursement.return_items.last }
-
-      before do
-        validator.eligible_for_return?
-      end
-
-      it 'returns true if errors were added' do
-        expect(subject).to eq true
-      end
-    end
-
-    context "eligible for return" do
-      let(:return_item) { create(:return_item) }
-
-      before do
-        validator.eligible_for_return?
-      end
-
-      it 'returns false if no errors were added' do
-        expect(subject).to eq false
-      end
-    end
-  end
-end

data/spec/models/spree/return_item/eligibility_validator/order_completed_spec.rb

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::ReturnItem::EligibilityValidator::OrderCompleted do
-  let(:shipment)       { create(:shipment, order: order) }
-  let(:inventory_unit) { create(:inventory_unit, shipment: shipment) }
-  let(:return_item)    { create(:return_item, inventory_unit: inventory_unit) }
-  let(:validator)      { Spree::ReturnItem::EligibilityValidator::OrderCompleted.new(return_item) }
-
-  describe "#eligible_for_return?" do
-    subject { validator.eligible_for_return? }
-
-    context "the order was completed" do
-      let(:order) { create(:completed_order_with_totals) }
-
-      it "returns true" do
-        expect(subject).to be true
-      end
-    end
-
-    context "the order is not completed" do
-      let(:order) { create(:order) }
-
-      it "returns false" do
-        expect(subject).to be false
-      end
-
-      it "sets an error" do
-        subject
-        expect(validator.errors[:order_not_completed]).to eq I18n.t('spree.return_item_order_not_completed')
-      end
-    end
-  end
-end

data/spec/models/spree/return_item/eligibility_validator/rma_required_spec.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::ReturnItem::EligibilityValidator::RMARequired, type: :model do
-  let(:return_item) { create(:return_item) }
-  let(:validator) { Spree::ReturnItem::EligibilityValidator::RMARequired.new(return_item) }
-
-  describe "#eligible_for_return?" do
-    subject { validator.eligible_for_return? }
-
-    context "there is an rma on the return item" do
-      it "returns true" do
-        expect(subject).to be true
-      end
-    end
-
-    context "there is no rma on the return item" do
-      before { allow(return_item).to receive(:return_authorization).and_return(nil) }
-
-      it "returns false" do
-        expect(subject).to be false
-      end
-
-      it "sets an error" do
-        subject
-        expect(validator.errors[:rma_required]).to eq I18n.t('spree.return_item_rma_ineligible')
-      end
-    end
-  end
-end

data/spec/models/spree/return_item/eligibility_validator/time_since_purchase_spec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-RSpec.describe Spree::ReturnItem::EligibilityValidator::TimeSincePurchase, type: :model do
-  include ActiveSupport::Testing::TimeHelpers
-
-  let(:return_item) { instance_double(Spree::ReturnItem) }
-  let(:validator) { described_class.new(return_item) }
-
-  describe "#eligible_for_return?" do
-    subject { validator.eligible_for_return? }
-
-    let(:interval) { Spree::Config[:return_eligibility_number_of_days] }
-
-    before do
-      allow(return_item).
-        to receive_message_chain('inventory_unit.order.completed_at').
-        and_return(completed_at)
-    end
-
-    around(:each) do |e|
-      travel_to(Time.current) { e.run }
-    end
-
-    context "it is within the return timeframe" do
-      let(:completed_at) { 1.day.ago }
-      it { is_expected.to be_truthy }
-    end
-
-    context "it is past the return timeframe" do
-      let(:completed_at) { interval.day.ago }
-
-      it { is_expected.to be_falsy }
-
-      it "sets an error" do
-        subject
-        expect(validator.errors[:number_of_days]).to eq I18n.t('spree.return_item_time_period_ineligible')
-      end
-    end
-  end
-end

data/spec/models/spree/return_item/exchange_variant_eligibility/same_option_value_spec.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module ReturnItem::ExchangeVariantEligibility
-    RSpec.describe SameOptionValue, type: :model do
-      describe ".eligible_variants" do
-        let(:color_option_type) { create(:option_type, name: "color") }
-        let(:waist_option_type) { create(:option_type, name: "waist") }
-        let(:inseam_option_type) { create(:option_type, name: "inseam") }
-
-        let(:blue_option_value) { create(:option_value, name: "blue", option_type: color_option_type) }
-        let(:red_option_value) { create(:option_value, name: "red", option_type: color_option_type) }
-
-        let(:three_two_waist_option_value) { create(:option_value, name: 32, option_type: waist_option_type) }
-        let(:three_four_waist_option_value) { create(:option_value, name: 34, option_type: waist_option_type) }
-
-        let(:three_zero_inseam_option_value) { create(:option_value, name: 30, option_type: inseam_option_type) }
-        let(:three_one_inseam_option_value) { create(:option_value, name: 31, option_type: inseam_option_type) }
-
-        let(:product) { create(:product, option_types: [color_option_type, waist_option_type, inseam_option_type]) }
-
-        let!(:variant) { create(:variant, product: product, option_values: [blue_option_value, three_two_waist_option_value, three_zero_inseam_option_value]) }
-        let!(:same_option_values_variant) { create(:variant, product: product, option_values: [blue_option_value, three_two_waist_option_value, three_one_inseam_option_value]) }
-        let!(:different_color_option_value_variant) { create(:variant, product: product, option_values: [red_option_value, three_two_waist_option_value, three_one_inseam_option_value]) }
-        let!(:different_waist_option_value_variant) { create(:variant, product: product, option_values: [blue_option_value, three_four_waist_option_value, three_one_inseam_option_value]) }
-
-        before do
-          @original_option_type_restrictions = SameOptionValue.option_type_restrictions
-          SameOptionValue.option_type_restrictions = ["color", "waist"]
-        end
-
-        after { SameOptionValue.option_type_restrictions = @original_option_type_restrictions }
-
-        subject { SameOptionValue.eligible_variants(variant.reload) }
-
-        it "returns all other variants for the same product with the same option value for the specified option type" do
-          Spree::StockItem.update_all(count_on_hand: 10)
-
-          expect(subject.sort).to eq [variant, same_option_values_variant].sort
-        end
-
-        it "does not return variants for another product" do
-          other_product_variant = create(:variant)
-          expect(subject).not_to include other_product_variant
-        end
-
-        context "no option value restrictions are specified" do
-          before do
-            @original_option_type_restrictions = SameOptionValue.option_type_restrictions
-            SameOptionValue.option_type_restrictions = []
-          end
-
-          after { SameOptionValue.option_type_restrictions = @original_option_type_restrictions }
-
-          it "returns all variants for the product" do
-            Spree::StockItem.update_all(count_on_hand: 10)
-
-            expect(subject.sort).to eq [variant, same_option_values_variant, different_waist_option_value_variant, different_color_option_value_variant].sort
-          end
-        end
-      end
-    end
-  end
-end

data/spec/models/spree/return_item/exchange_variant_eligibility/same_product_spec.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'rails_helper'
-
-module Spree
-  module ReturnItem::ExchangeVariantEligibility
-    RSpec.describe SameProduct, type: :model do
-      describe ".eligible_variants" do
-        context "product has no variants" do
-          it "returns the master variant for the same product" do
-            product = create(:product)
-            product.master.stock_items.first.update_column(:count_on_hand, 10)
-
-            expect(SameProduct.eligible_variants(product.master)).to eq [product.master]
-          end
-        end
-
-        context "product has variants" do
-          it "returns all variants for the same product" do
-            product = create(:product, variants: Array.new(3) { create(:variant) })
-            product.variants.map { |value| value.stock_items.first.update_column(:count_on_hand, 10) }
-
-            expect(SameProduct.eligible_variants(product.variants.first).sort).to eq product.variants.sort
-          end
-        end
-
-        it "does not return variants for another product" do
-          variant = create(:variant)
-          other_product_variant = create(:variant)
-          expect(SameProduct.eligible_variants(variant)).not_to include other_product_variant
-        end
-
-        it "only returns variants that are on hand" do
-          product = create(:product, variants: Array.new(2) { create(:variant) })
-          in_stock_variant = product.variants.first
-
-          in_stock_variant.stock_items.first.update_column(:count_on_hand, 10)
-          expect(SameProduct.eligible_variants(in_stock_variant)).to eq [in_stock_variant]
-        end
-      end
-    end
-  end
-end