solidus_core_devise_token_auth 2.8.0.alpha.0

data/spec/models/spree/return_authorization_spec.rb

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

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

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

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

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

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

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

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

@@ -0,0 +1,43 @@
+# 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 { |v| v.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