spree_core 3.0.9 → 3.2.0

data/spec/models/spree/reimbursement_type/store_credit_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+module Spree
+  describe ReimbursementType::StoreCredit do
+    let(:reimbursement) { create(:reimbursement, return_items_count: 2) }
+    let(:return_item) { reimbursement.return_items.first }
+    let(:return_item2) { reimbursement.return_items.last }
+    let(:payment) { reimbursement.order.payments.first }
+    let(:simulate) { false }
+    let!(:default_refund_reason) do
+      Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON,
+                                             mutable: false)
+    end
+
+    let!(:primary_credit_type) { create(:primary_credit_type) }
+    let!(:created_by_user) { create(:user, email: Spree::StoreCredit::DEFAULT_CREATED_BY_EMAIL) }
+    let!(:default_reimbursement_category) { create(:store_credit_category) }
+
+    subject do
+      Spree::ReimbursementType::StoreCredit.reimburse(reimbursement, [return_item, return_item2],
+                                                      simulate)
+    end
+
+    before { reimbursement.update!(total: reimbursement.calculated_total) }
+
+    describe '.reimburse' do
+      context 'simulate is true' do
+        let(:simulate) { true }
+
+        context 'for store credits that the customer used' do
+          before do
+            allow(Spree::ReimbursementType::StoreCredit).to receive(:store_credit_payments).and_return([payment])
+          end
+
+          it 'creates readonly refunds for all store credit payments' do
+            expect(subject.map(&:class)).to eq [Spree::Refund]
+            expect(subject.map(&:readonly?)).to eq [true]
+          end
+
+          it 'does not save to the database' do
+            expect { subject }.to_not change { payment.refunds.count }
+          end
+        end
+
+        context 'for return items that were not paid for with store credit' do
+          before do
+            allow(Spree::ReimbursementType::StoreCredit).to receive(:store_credit_payments).and_return([])
+          end
+
+          context 'creates one readonly lump credit for all outstanding balance payable to the customer' do
+            it 'creates a credit that is read only' do
+              expect(subject.map(&:class)).to eq [Spree::Reimbursement::Credit]
+              expect(subject.map(&:readonly?)).to eq [true]
+            end
+
+            it 'creates a credit which amounts to the sum of the return items rounded down' do
+              allow(return_item).to receive(:total).and_return(10.0076)
+              allow(return_item2).to receive(:total).and_return(10.0023)
+              expect(subject.sum(&:amount)).to eq 20.0
+            end
+          end
+
+          it 'does not save to the database' do
+            expect { subject }.to_not change { Spree::Reimbursement::Credit.count }
+          end
+        end
+      end
+
+      context 'simulate is false' do
+        let(:simulate) { false }
+
+        context 'for store credits that the customer used' do
+          before do
+            allow(Spree::ReimbursementType::StoreCredit).to receive(:store_credit_payments).and_return([payment])
+          end
+
+          it 'performs refunds for all store credit payments' do
+            expect { subject }.to change { payment.refunds.count }.by(1)
+            expect(payment.refunds.sum(:amount)).to eq reimbursement.return_items.to_a.sum(&:total)
+          end
+        end
+
+        context 'for return items that were not paid for with store credit' do
+          before do
+            allow(Spree::ReimbursementType::StoreCredit).to receive(:store_credit_payments).and_return([])
+          end
+
+          it 'creates one lump credit for all outstanding balance payable to the customer' do
+            expect { subject }.to change { Spree::Reimbursement::Credit.count }.by(1)
+            expect(subject.sum(&:amount)).to eq reimbursement.return_items.to_a.sum(&:total)
+          end
+
+          it "creates a store credit with the same currency as the reimbursement's order" do
+            expect { subject }.to change { Spree::StoreCredit.count }.by(1)
+            expect(Spree::StoreCredit.last.currency).to eq reimbursement.order.currency
+          end
+        end
+      end
+    end
+  end
+end

data/spec/models/spree/return_authorization_reason_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Spree::ReturnAuthorizationReason do
+  describe 'Associations' do
+    it { is_expected.to have_many(:return_authorizations).dependent(:restrict_with_error) }
+  end
+end

data/spec/models/spree/return_authorization_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::ReturnAuthorization, :type => :model do
+describe Spree::ReturnAuthorization, type: :model do
   let(:order) { create(:shipped_order) }
   let(:stock_location) { create(:stock_location) }
   let(:rma_reason) { create(:return_authorization_reason) }
@@ -84,28 +84,8 @@ describe Spree::ReturnAuthorization, :type => :model do
     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
+  describe 'whitelisted_ransackable_attributes' do
+    it { expect(Spree::ReturnAuthorization.whitelisted_ransackable_attributes).to eq(%w(memo number state)) }
   end
 
   context "#currency" do

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::ReturnItem::EligibilityValidator::Default, :type => :model do
+describe Spree::ReturnItem::EligibilityValidator::Default, type: :model do
   let(:return_item) { create(:return_item) }
   let(:validator) { Spree::ReturnItem::EligibilityValidator::Default.new(return_item) }
 

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::ReturnItem::EligibilityValidator::RMARequired, :type => :model do
+describe Spree::ReturnItem::EligibilityValidator::RMARequired, type: :model do
   let(:return_item) { create(:return_item) }
   let(:validator) { Spree::ReturnItem::EligibilityValidator::RMARequired.new(return_item) }
 

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

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::ReturnItem::EligibilityValidator::TimeSincePurchase, :type => :model do
+describe Spree::ReturnItem::EligibilityValidator::TimeSincePurchase, type: :model do
   let(:inventory_unit) { create(:inventory_unit, order: create(:shipped_order)) }
   let(:return_item)    { create(:return_item, inventory_unit: inventory_unit) }
   let(:validator)      { Spree::ReturnItem::EligibilityValidator::TimeSincePurchase.new(return_item) }

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module ReturnItem::ExchangeVariantEligibility
-    describe SameOptionValue, :type => :model do
+    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") }

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

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module ReturnItem::ExchangeVariantEligibility
-    describe SameProduct, :type => :model do
+    describe SameProduct, type: :model do
       describe ".eligible_variants" do
 
         context "product has no variants" do

data/spec/models/spree/return_item_spec.rb

@@ -8,7 +8,7 @@ shared_examples "an invalid state transition" do |status, expected_status|
   end
 end
 
-describe Spree::ReturnItem, :type => :model do
+describe Spree::ReturnItem, type: :model do
 
   all_reception_statuses = Spree::ReturnItem.state_machines[:reception_status].states.map(&:name).map(&:to_s)
   all_acceptance_statuses = Spree::ReturnItem.state_machines[:acceptance_status].states.map(&:name).map(&:to_s)
@@ -18,7 +18,7 @@ describe Spree::ReturnItem, :type => :model do
   end
 
   describe '#receive!' do
-    let(:now)            { Time.now }
+    let(:now)            { Time.current }
     let(:inventory_unit) { create(:inventory_unit, state: 'shipped') }
     let(:return_item)    { create(:return_item, inventory_unit: inventory_unit) }
 
@@ -679,4 +679,53 @@ describe Spree::ReturnItem, :type => :model do
       expect(return_item.total).to eq 20
     end
   end
+
+  describe '#process_inventory_unit!' do
+    let(:inventory_unit) { create(:inventory_unit, state: 'shipped') }
+    let(:return_item) { create(:return_item, inventory_unit: inventory_unit, reception_status: 'awaiting') }
+    let!(:stock_item) { inventory_unit.find_stock_item }
+    before { return_item.update_attributes!(reception_status: 'awaiting') }
+
+    subject { return_item.send(:process_inventory_unit!) }
+
+    it { expect { subject }.to change { inventory_unit.state }.to('returned').from('shipped') }
+
+    context 'stock should restock' do
+      let(:stock_movement_attributes) do
+        {
+          stock_item_id: stock_item.id,
+          quantity: 1,
+          originator: return_item.return_authorization
+        }
+      end
+
+      it { expect(subject).to eq(Spree::StockMovement.find_by(stock_movement_attributes)) }
+    end
+
+    context 'stock should not restock' do
+      context 'return_item is not resellable' do
+        before { return_item.resellable = false }
+        it { expect(subject).to be_nil }
+        it { expect { subject }.to_not change { stock_item.reload.count_on_hand } }
+      end
+
+      context 'variant should not track inventory' do
+        before { return_item.variant.track_inventory = false }
+        it { expect(subject).to be_nil }
+        it { expect { subject }.to_not change { stock_item.reload.count_on_hand } }
+      end
+
+      context 'stock_item not present' do
+        before { stock_item.destroy }
+        it { expect(subject).to be_nil }
+        it { expect { subject }.to_not change { stock_item.reload.count_on_hand } }
+      end
+
+      context 'when restock inventory preference false' do
+        before { Spree::Config[:restock_inventory] = false }
+        it { expect(subject).to be_nil }
+        it { expect { subject }.to_not change { stock_item.reload.count_on_hand } }
+      end
+    end
+  end
 end

data/spec/models/spree/returns_calculator_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 module Spree
-  describe ReturnsCalculator, :type => :model do
+  describe ReturnsCalculator, type: :model do
     let(:return_item) { build(:return_item) }
     subject { ReturnsCalculator.new }
 
     it 'compute_shipment must be overridden' do
       expect {
         subject.compute(return_item)
-      }.to raise_error
+      }.to raise_error(NotImplementedError)
     end
   end
 end

data/spec/models/spree/role_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe Spree::Role, type: :model do
+  describe 'Associations' do
+    it { is_expected.to have_many(:role_users).class_name('Spree::RoleUser').dependent(:destroy) }
+  end
+end

data/spec/models/spree/shipment_spec.rb

@@ -1,14 +1,14 @@
 require 'spec_helper'
 require 'benchmark'
 
-describe Spree::Shipment, :type => :model do
+describe Spree::Shipment, type: :model do
   let(:order) { mock_model Spree::Order, backordered?: false,
                                          canceled?: false,
                                          can_ship?: true,
                                          currency: 'USD',
                                          number: 'S12345',
                                          paid?: false,
-                                         touch: true }
+                                         touch_later: false }
   let(:shipping_method) { create(:shipping_method, name: "UPS") }
   let(:shipment) do
     shipment = Spree::Shipment.new(cost: 1, state: 'pending', stock_location: create(:stock_location))
@@ -31,9 +31,11 @@ describe Spree::Shipment, :type => :model do
   end
 
   describe "precision of pre_tax_amount" do
-    let!(:line_item) { create :line_item, pre_tax_amount: 4.2051 }
+    let(:line_item) { create :line_item, pre_tax_amount: 4.2051 }
 
     it "keeps four digits of precision even when reloading" do
+      # prevent it from updating pre_tax_amount
+      allow_any_instance_of(Spree::LineItem).to receive(:update_tax_charge)
       expect(line_item.reload.pre_tax_amount).to eq(4.2051)
     end
   end
@@ -41,7 +43,7 @@ describe Spree::Shipment, :type => :model do
   # Regression test for #4063
   context "number generation" do
     before do
-      allow(order).to receive :update!
+      allow(order).to receive :update_with_updater!
     end
 
     it "generates a number containing a letter + 11 numbers" do
@@ -228,7 +230,7 @@ describe Spree::Shipment, :type => :model do
       end
 
       it "can't get rates without a shipping address" do
-        shipment.order(ship_address: nil)
+        shipment.order.ship_address = nil
         expect(shipment.refresh_rates).to eq([])
       end
 
@@ -394,7 +396,7 @@ describe Spree::Shipment, :type => :model do
 
   context "#cancel" do
     it 'cancels the shipment' do
-      allow(shipment.order).to receive(:update!)
+      allow(shipment.order).to receive(:update_with_updater!)
 
       shipment.state = 'pending'
       expect(shipment).to receive(:after_cancel)
@@ -439,33 +441,33 @@ describe Spree::Shipment, :type => :model do
   end
 
   context "#resume" do
-    it 'will determine new state based on order' do
-      allow(shipment.order).to receive(:update!)
+    it 'transitions state to ready if the order is ready' do
+      allow(shipment.order).to receive(:update_with_updater!)
 
       shipment.state = 'canceled'
-      expect(shipment).to receive(:determine_state).and_return(:ready)
+      expect(shipment).to receive(:determine_state).and_return('ready')
       expect(shipment).to receive(:after_resume)
       shipment.resume!
       expect(shipment.state).to eq 'ready'
     end
 
-    it 'unstocks them items' do
-      allow(shipment).to receive_message_chain(inventory_units: [mock_model(Spree::InventoryUnit, line_item: line_item, variant: variant)])
-      shipment.stock_location = mock_model(Spree::StockLocation)
-      expect(shipment.stock_location).to receive(:unstock).with(variant, 1, shipment)
-      shipment.after_resume
-    end
-
-    it 'will determine new state based on order' do
-      allow(shipment.order).to receive(:update!)
+    it 'transitions state to pending if the order is not ready' do
+      allow(shipment.order).to receive(:update_with_updater!)
 
       shipment.state = 'canceled'
-      expect(shipment).to receive(:determine_state).twice.and_return('ready')
+      expect(shipment).to receive(:determine_state).and_return('pending')
       expect(shipment).to receive(:after_resume)
       shipment.resume!
       # Shipment is pending because order is already paid
       expect(shipment.state).to eq 'pending'
     end
+
+    it 'unstocks them items' do
+      allow(shipment).to receive_message_chain(inventory_units: [mock_model(Spree::InventoryUnit, line_item: line_item, variant: variant)])
+      shipment.stock_location = mock_model(Spree::StockLocation)
+      expect(shipment.stock_location).to receive(:unstock).with(variant, 1, shipment)
+      shipment.after_resume
+    end
   end
 
   context "#ship" do
@@ -473,7 +475,7 @@ describe Spree::Shipment, :type => :model do
       let(:shipment_with_inventory_units) { create(:shipment, order: create(:order_with_line_items), state: 'canceled') }
       let(:subject) { shipment_with_inventory_units.ship! }
       before do
-        allow(order).to receive(:update!)
+        allow(order).to receive(:update_with_updater!)
         allow(shipment_with_inventory_units).to receive_messages(require_inventory: false, update_order: true)
       end
 
@@ -489,7 +491,7 @@ describe Spree::Shipment, :type => :model do
     ['ready', 'canceled'].each do |state|
       context "from #{state}" do
         before do
-          allow(order).to receive(:update!)
+          allow(order).to receive(:update_with_updater!)
           allow(shipment).to receive_messages(require_inventory: false, update_order: true, state: state)
         end
 
@@ -725,7 +727,7 @@ describe Spree::Shipment, :type => :model do
   context "state changes" do
     before do
       # Must be stubbed so transition can succeed
-      allow(order).to receive_messages :paid? => true
+      allow(order).to receive_messages paid?: true
     end
 
     it "are logged to the database" do

data/spec/models/spree/shipping_calculator_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
 module Spree
-  describe ShippingCalculator, :type => :model do
-    let(:variant1) { build(:variant, :price => 10) }
-    let(:variant2) { build(:variant, :price => 20) }
+  describe ShippingCalculator, type: :model do
+    let(:variant1) { build(:variant, price: 10) }
+    let(:variant2) { build(:variant, price: 20) }
 
     let(:package) do
       build(:stock_package, variants_contents: { variant1 => 2, variant2 => 1 })
@@ -25,13 +25,13 @@ module Spree
     it 'compute_shipment must be overridden' do
       expect {
         subject.compute_shipment(shipment)
-      }.to raise_error
+      }.to raise_error(NameError)
     end
 
     it 'compute_package must be overridden' do
       expect {
         subject.compute_package(package)
-      }.to raise_error
+      }.to raise_error(NotImplementedError)
     end
 
     it 'checks availability for a package' do

data/spec/models/spree/shipping_category_spec.rb

@@ -1,5 +1,19 @@
 require 'spec_helper'
 
-describe Spree::ShippingCategory, :type => :model do
+describe Spree::ShippingCategory, type: :model do
 
+  describe '#validations' do
+    it 'should have a valid factory' do
+      expect(FactoryGirl.build(:shipping_category)).to be_valid
+    end
+
+    it 'should require name' do
+      expect(FactoryGirl.build(:shipping_category, name: '')).not_to be_valid
+    end
+
+    it 'should validate uniqueness' do
+      FactoryGirl.create(:shipping_category, name: 'Test')
+      expect(FactoryGirl.build(:shipping_category, name: 'Test')).not_to be_valid
+    end
+  end
 end

data/spec/models/spree/shipping_method_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 class DummyShippingCalculator < Spree::ShippingCalculator
 end
 
-describe Spree::ShippingMethod, :type => :model do
+describe Spree::ShippingMethod, type: :model do
   let(:shipping_method){ create(:shipping_method) }
 
   context 'calculators' do
@@ -25,7 +25,7 @@ describe Spree::ShippingMethod, :type => :model do
     let!(:shipping_method) { create(:shipping_method) }
     let!(:shipment) do
       shipment = create(:shipment)
-      shipment.shipping_rates.create!(:shipping_method => shipping_method)
+      shipment.shipping_rates.create!(shipping_method: shipping_method)
       shipment
     end
 
@@ -42,8 +42,15 @@ describe Spree::ShippingMethod, :type => :model do
     end
 
     context "shipping category" do
-      it "validates presence of at least one" do
-        expect(subject.error_on(:base).size).to eq(1)
+      context "is required" do
+        it { expect(subject.error_on(:base).size).to eq(1) }
+        it 'adds error to base' do
+          expect(subject.error_on(:base)).to include(I18n.t(:required_shipping_category,
+                                                            scope: [
+                                                              :activerecord, :errors, :models,
+                                                              'spree/shipping_method', :attributes, :base
+                                                            ]))
+        end
       end
 
       context "one associated" do

data/spec/models/spree/shipping_rate_spec.rb

@@ -2,29 +2,32 @@
 
 require 'spec_helper'
 
-describe Spree::ShippingRate, :type => :model do
+describe Spree::ShippingRate, type: :model do
   let(:shipment) { create(:shipment) }
   let(:shipping_method) { create(:shipping_method) }
-  let(:shipping_rate) { Spree::ShippingRate.new(:shipment => shipment,
-                                                :shipping_method => shipping_method,
-                                                :cost => 10) }
+  let(:shipping_rate) do
+    Spree::ShippingRate.new shipment: shipment,
+                            shipping_method: shipping_method,
+                            cost: 10
+  end
 
   context "#display_price" do
     context "when tax included in price" do
+      let!(:default_zone) { create(:zone, default_tax: true) }
+      let(:default_tax_rate) do
+        create :tax_rate,
+               name: "VAT",
+               amount: 0.1,
+               included_in_price: true,
+               zone: default_zone
+      end
       context "when the tax rate is from the default zone" do
-        let!(:zone) { create(:zone, :default_tax => true) }
-        let(:tax_rate) do 
-          create(:tax_rate,
-            :name => "VAT",
-            :amount => 0.1,
-            :included_in_price => true,
-            :zone => zone)
-        end
 
-        before { shipping_rate.tax_rate = tax_rate }
+        before { shipping_rate.tax_rate = default_tax_rate }
 
         it "shows correct tax amount" do
-          expect(shipping_rate.display_price.to_s).to eq("$10.00 (incl. $0.91 #{tax_rate.name})")
+          expect(shipping_rate.display_price.to_s).
+            to eq("$10.00 (incl. $0.91 #{default_tax_rate.name})")
         end
 
         context "when cost is zero" do
@@ -38,20 +41,21 @@ describe Spree::ShippingRate, :type => :model do
         end
       end
 
-      context "when the tax rate is from a non-default zone" do
-        let!(:default_zone) { create(:zone, :default_tax => true) }
-        let!(:non_default_zone) { create(:zone, :default_tax => false) }
-        let(:tax_rate) do
-          create(:tax_rate,
-            :name => "VAT",
-            :amount => 0.1,
-            :included_in_price => true,
-            :zone => non_default_zone)
+      context "when the tax rate is from another zone" do
+        let!(:non_default_zone) { create(:zone, default_tax: false) }
+
+        let(:non_default_tax_rate) do
+          create :tax_rate,
+                 name: "VAT",
+                 amount: 0.2,
+                 included_in_price: true,
+                 zone: non_default_zone
         end
-        before { shipping_rate.tax_rate = tax_rate }
+        before { shipping_rate.tax_rate = non_default_tax_rate }
 
-        it "shows correct tax amount" do
-          expect(shipping_rate.display_price.to_s).to eq("$10.00 (excl. $0.91 #{tax_rate.name})")
+        it "deducts the other zone's VAT from the calculated shipping rate" do
+          expect(shipping_rate.display_price.to_s).
+            to eq("$10.00 (incl. $1.67 #{non_default_tax_rate.name})")
         end
 
         context "when cost is zero" do
@@ -67,11 +71,12 @@ describe Spree::ShippingRate, :type => :model do
     end
 
     context "when tax is additional to price" do
-      let(:tax_rate) { create(:tax_rate, :name => "Sales Tax", :amount => 0.1) }
+      let(:tax_rate) { create(:tax_rate, name: "Sales Tax", amount: 0.1) }
       before { shipping_rate.tax_rate = tax_rate }
 
       it "shows correct tax amount" do
-        expect(shipping_rate.display_price.to_s).to eq("$10.00 (+ $1.00 #{tax_rate.name})")
+        expect(shipping_rate.display_price.to_s).
+          to eq("$10.00 (+ $1.00 #{tax_rate.name})")
       end
 
       context "when cost is zero" do
@@ -86,9 +91,9 @@ describe Spree::ShippingRate, :type => :model do
     end
 
     context "when the currency is JPY" do
-      let(:shipping_rate) { shipping_rate = Spree::ShippingRate.new(:cost => 205)
-                            allow(shipping_rate).to receive_messages(:currency => "JPY")
-                            shipping_rate }
+      let(:shipping_rate) { Spree::ShippingRate.new(cost: 205) }
+
+      before { allow(shipping_rate).to receive_messages(currency: "JPY") }
 
       it "displays the price in yen" do
         expect(shipping_rate.display_price.to_s).to eq("¥205")
@@ -103,7 +108,7 @@ describe Spree::ShippingRate, :type => :model do
     end
 
     it "can be retrieved even when deleted" do
-      shipping_method.update_column(:deleted_at, Time.now)
+      shipping_method.update_column(:deleted_at, Time.current)
       shipping_rate.save
       shipping_rate.reload
       expect(shipping_rate.shipping_method).to eq(shipping_method)
@@ -122,20 +127,14 @@ describe Spree::ShippingRate, :type => :model do
     end
 
     it "can be retrieved even when deleted" do
-      tax_rate.update_column(:deleted_at, Time.now)
+      tax_rate.update_column(:deleted_at, Time.current)
       shipping_rate.save
       shipping_rate.reload
       expect(shipping_rate.tax_rate).to eq(tax_rate)
     end
   end
 
-  context "#shipping_method_code" do
-    before do
-      shipping_method.code = "THE_CODE"
-    end
-
-    it 'should be shipping_method.code' do
-      expect(shipping_rate.shipping_method_code).to eq("THE_CODE")
-    end
+  describe 'delegate' do
+    it { is_expected.to delegate_method(:code).to(:shipping_method).with_prefix(true) }
   end
 end