solidus_core 1.2.3 → 1.3.0.beta1

data/spec/models/spree/reimbursement_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe Spree::Reimbursement, type: :model do
-
   describe ".before_create" do
     describe "#generate_number" do
       context "number is assigned" do
@@ -50,10 +49,10 @@ describe Spree::Reimbursement, type: :model do
     let!(:adjustments)            { [] } # placeholder to ensure it gets run prior the "before" at this level
 
     let!(:tax_rate)               { nil }
-    let!(:tax_zone)               { create :zone, default_tax: true }
+    let!(:tax_zone)               { create :zone, :with_country, default_tax: true }
     let(:shipping_method)         { create :shipping_method, zones: [tax_zone] }
     let(:variant)                 { create :variant }
-    let(:order)                   { create(:order_with_line_items, state: 'payment', line_items_attributes: [{variant: variant, price: line_items_price}], shipment_cost: 0, shipping_method: shipping_method) }
+    let(:order)                   { create(:order_with_line_items, state: 'payment', line_items_attributes: [{ variant: variant, price: line_items_price }], shipment_cost: 0, shipping_method: shipping_method) }
     let(:line_items_price)        { BigDecimal.new(10) }
     let(:line_item)               { order.line_items.first }
     let(:inventory_unit)          { line_item.inventory_units.first }
@@ -107,8 +106,8 @@ describe Spree::Reimbursement, type: :model do
         return_item.reload
         expect(return_item.additional_tax_total).to be > 0
         expect(return_item.additional_tax_total).to eq line_item.additional_tax_total
-        expect(reimbursement.total).to eq line_item.pre_tax_amount + line_item.additional_tax_total
-        expect(Spree::Refund.last.amount).to eq line_item.pre_tax_amount + line_item.additional_tax_total
+        expect(reimbursement.total).to eq line_item.amount + line_item.additional_tax_total
+        expect(Spree::Refund.last.amount).to eq line_item.amount + line_item.additional_tax_total
       end
     end
 
@@ -122,8 +121,8 @@ describe Spree::Reimbursement, type: :model do
         return_item.reload
         expect(return_item.included_tax_total).to be > 0
         expect(return_item.included_tax_total).to eq line_item.included_tax_total
-        expect(reimbursement.total).to eq (line_item.pre_tax_amount + line_item.included_tax_total).round(2, :down)
-        expect(Spree::Refund.last.amount).to eq (line_item.pre_tax_amount + line_item.included_tax_total).round(2, :down)
+        expect(reimbursement.total).to eq((line_item.pre_tax_amount + line_item.included_tax_total).round(2, :down))
+        expect(Spree::Refund.last.amount).to eq((line_item.pre_tax_amount + line_item.included_tax_total).round(2, :down))
       end
     end
 
@@ -148,12 +147,11 @@ describe Spree::Reimbursement, type: :model do
       expect(Spree::ReimbursementMailer).to receive(:reimbursement_email).with(reimbursement.id) { double(deliver_later: true) }
       subject
     end
-
   end
 
   describe "#return_items_requiring_exchange" do
     it "returns only the return items that require an exchange" do
-      return_items = [double(exchange_required?: true), double(exchange_required?: true),double(exchange_required?: false)]
+      return_items = [double(exchange_required?: true), double(exchange_required?: true), double(exchange_required?: false)]
       allow(subject).to receive(:return_items) { return_items }
       expect(subject.return_items_requiring_exchange).to eq return_items.take(2)
     end
@@ -194,8 +192,8 @@ describe Spree::Reimbursement, type: :model do
       subject { reimbursement.calculated_total }
 
       before do
-        reimbursement.return_items << Spree::ReturnItem.new(pre_tax_amount: 10.003)
-        reimbursement.return_items << Spree::ReturnItem.new(pre_tax_amount: 10.003)
+        reimbursement.return_items << Spree::ReturnItem.new(amount: 10.003)
+        reimbursement.return_items << Spree::ReturnItem.new(amount: 10.003)
       end
 
       it 'rounds down' do

data/spec/models/spree/reimbursement_tax_calculator_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
-describe Spree::ReimbursementTaxCalculator, :type => :model do
-
+describe Spree::ReimbursementTaxCalculator, type: :model do
   let!(:tax_rate) { nil }
 
   let(:reimbursement) { create(:reimbursement, return_items_count: 1) }
@@ -25,7 +24,7 @@ describe Spree::ReimbursementTaxCalculator, :type => :model do
 
   context 'with additional tax' do
     let!(:tax_rate) { create(:tax_rate, name: "Sales Tax", amount: 0.10, included_in_price: false, zone: tax_zone) }
-    let(:tax_zone) { create(:zone, default_tax: true) }
+    let(:tax_zone) { create(:zone, :with_country, default_tax: true) }
 
     it 'sets additional_tax_total on the return items' do
       subject
@@ -38,13 +37,13 @@ describe Spree::ReimbursementTaxCalculator, :type => :model do
 
   context 'with included tax' do
     let!(:tax_rate) { create(:tax_rate, name: "VAT Tax", amount: 0.1, included_in_price: true, zone: tax_zone) }
-    let(:tax_zone) { create(:zone, default_tax: true) }
+    let(:tax_zone) { create(:zone, :with_country, default_tax: true) }
 
     it 'sets included_tax_total on the return items' do
       subject
       return_item.reload
 
-      expect(return_item.included_tax_total).to be < 0
+      expect(return_item.included_tax_total).to be > 0
       expect(return_item.included_tax_total).to eq line_item.included_tax_total
     end
   end

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe ReimbursementType::Credit, :type => :model do
+  describe ReimbursementType::Credit, type: :model do
     let(:reimbursement)           { create(:reimbursement, return_items_count: 1) }
     let(:return_item)             { reimbursement.return_items.first }
     let(:payment)                 { reimbursement.order.payments.first }
@@ -14,7 +14,7 @@ module Spree
       self.table_name = 'spree_payments' # Your creditable class should not use this table
     end
 
-    subject { Spree::ReimbursementType::Credit.reimburse(reimbursement, [return_item], simulate)}
+    subject { Spree::ReimbursementType::Credit.reimburse(reimbursement, [return_item], simulate) }
 
     before do
       reimbursement.update!(total: reimbursement.calculated_total)

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

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 module Spree
-  describe ReimbursementType::Exchange, :type => :model do
+  describe ReimbursementType::Exchange, type: :model do
     describe '.reimburse' do
       let(:reimbursement) { create(:reimbursement, return_items_count: 1) }
       let(:return_items)  { reimbursement.return_items }
       let(:new_exchange)  { double("Exchange") }
       let(:simulate)      { true }
 
-      subject { Spree::ReimbursementType::Exchange.reimburse(reimbursement, return_items, simulate)}
+      subject { Spree::ReimbursementType::Exchange.reimburse(reimbursement, return_items, simulate) }
 
       context 'return items are supplied' do
         before do
@@ -16,7 +16,6 @@ module Spree
         end
 
         context "simulate is true" do
-
           it 'does not perform an exchange and returns the exchange object' do
             expect(new_exchange).not_to receive(:perform!)
             expect(subject).to eq [new_exchange]

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

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 module Spree
-  describe ReimbursementType::OriginalPayment, :type => :model do
+  describe ReimbursementType::OriginalPayment, type: :model do
     let(:reimbursement)           { create(:reimbursement, return_items_count: 1) }
     let(:return_item)             { reimbursement.return_items.first }
     let(:payment)                 { reimbursement.order.payments.first }
     let(:simulate)                { false }
     let!(:default_refund_reason)  { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
 
-    subject { Spree::ReimbursementType::OriginalPayment.reimburse(reimbursement, [return_item], simulate)}
+    subject { Spree::ReimbursementType::OriginalPayment.reimburse(reimbursement, [return_item], simulate) }
 
     before { reimbursement.update!(total: reimbursement.calculated_total) }
 
@@ -43,7 +43,7 @@ module Spree
 
       context 'when a payment is negative' do
         before do
-          expect_any_instance_of(Spree::Payment).to receive(:amount).and_return -100
+          expect_any_instance_of(Spree::Payment).to receive(:amount).and_return(-100)
         end
 
         it 'returns an empty array' do
@@ -61,7 +61,7 @@ module Spree
 
         before do
           reimbursement.order.payments.first.update_attributes!(amount: 5.0)
-          return_item.update_attributes!(pre_tax_amount: refund_amount)
+          return_item.update_attributes!(amount: refund_amount)
         end
 
         it "includes refunds all payment type" do

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

@@ -13,7 +13,7 @@ module Spree
     let!(:created_by_user)        { create(:user, email: Spree::StoreCredit::DEFAULT_CREATED_BY_EMAIL) }
     let!(:default_reimbursement_category) { create(:store_credit_category) }
 
-    subject { Spree::ReimbursementType::StoreCredit.reimburse(reimbursement, [return_item, return_item2], simulate)}
+    subject { Spree::ReimbursementType::StoreCredit.reimburse(reimbursement, [return_item, return_item2], simulate) }
 
     before do
       reimbursement.update!(total: reimbursement.calculated_total)

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_reason) }
@@ -52,13 +52,11 @@ describe Spree::ReturnAuthorization, :type => :model do
       subject                    { create(:return_authorization, order: order, return_items: [exchange_return_item, return_item]) }
 
       before do
-        @expediteted_exchanges_config = Spree::Config[:expedited_exchanges]
         Spree::Config[:expedited_exchanges] = true
         @pre_exchange_hooks = subject.class.pre_expedited_exchange_hooks
       end
 
       after do
-        Spree::Config[:expedited_exchanges] = @expediteted_exchanges_config
         subject.class.pre_expedited_exchange_hooks = @pre_exchange_hooks
       end
 
@@ -66,7 +64,7 @@ describe Spree::ReturnAuthorization, :type => :model do
         subject { create(:return_authorization, order: order) }
 
         it "does not create a reimbursement" do
-          expect{subject.save}.to_not change { Spree::Reimbursement.count }
+          expect{ subject.save }.to_not change { Spree::Reimbursement.count }
         end
       end
 
@@ -104,7 +102,6 @@ describe Spree::ReturnAuthorization, :type => :model do
           end
         end
       end
-
     end
   end
 
@@ -140,19 +137,19 @@ describe Spree::ReturnAuthorization, :type => :model do
   end
 
   describe "#pre_tax_total" do
-    let(:pre_tax_amount_1) { 15.0 }
-    let!(:return_item_1) { create(:return_item, return_authorization: return_authorization, pre_tax_amount: pre_tax_amount_1) }
+    let(:amount_1) { 15.0 }
+    let!(:return_item_1) { create(:return_item, return_authorization: return_authorization, amount: amount_1) }
 
-    let(:pre_tax_amount_2) { 50.0 }
-    let!(:return_item_2) { create(:return_item, return_authorization: return_authorization, pre_tax_amount: pre_tax_amount_2) }
+    let(:amount_2) { 50.0 }
+    let!(:return_item_2) { create(:return_item, return_authorization: return_authorization, amount: amount_2) }
 
-    let(:pre_tax_amount_3) { 5.0 }
-    let!(:return_item_3) { create(:return_item, return_authorization: return_authorization, pre_tax_amount: pre_tax_amount_3) }
+    let(:amount_3) { 5.0 }
+    let!(:return_item_3) { create(:return_item, return_authorization: return_authorization, amount: amount_3) }
 
-    subject { return_authorization.pre_tax_total }
+    subject { return_authorization.reload.pre_tax_total }
 
-    it "sums it's associated return_item's pre-tax amounts" do
-      expect(subject).to eq (pre_tax_amount_1 + pre_tax_amount_2 + pre_tax_amount_3)
+    it "sums it's associated return_item's amounts" do
+      expect(subject).to eq(amount_1 + amount_2 + amount_3)
     end
   end
 
@@ -169,38 +166,38 @@ describe Spree::ReturnAuthorization, :type => :model do
     end
 
     it "should allow_receive when inventory units assigned" do
-      allow(return_authorization).to receive_messages(:inventory_units => [1,2,3])
+      allow(return_authorization).to receive_messages(inventory_units: [1, 2, 3])
       expect(return_authorization.can_receive?).to be true
     end
 
     it "should not allow_receive with no inventory units" do
-      allow(return_authorization).to receive_messages(:inventory_units => [])
+      allow(return_authorization).to receive_messages(inventory_units: [])
       expect(return_authorization.can_receive?).to be false
     end
   end
 
   describe "#refundable_amount" do
-    let(:weighted_line_item_pre_tax_amount) { 5.0 }
-    let(:line_item_count)                   { return_authorization.order.line_items.count }
+    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(pre_tax_amount: weighted_line_item_pre_tax_amount)
+      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 (weighted_line_item_pre_tax_amount * line_item_count)
+        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 (weighted_line_item_pre_tax_amount * line_item_count) + promo_total
+        expect(subject).to eq((line_item_price * line_item_count) + promo_total)
       end
     end
   end

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) }
 
@@ -10,11 +10,11 @@ describe Spree::ReturnItem::EligibilityValidator::Default, :type => :model do
   let(:time_eligibility_instance) { double(errors: time_error) }
   let(:rma_eligibility_instance)  { double(errors: rma_error) }
 
-  let(:time_error) {{}}
-  let(:rma_error)  {{}}
+  let(:time_error) { {} }
+  let(:rma_error)  { {} }
 
   before do
-    validator.permitted_eligibility_validators = [ time_eligibility_class, rma_eligibility_class ]
+    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)
@@ -63,14 +63,14 @@ describe Spree::ReturnItem::EligibilityValidator::Default, :type => :model do
     end
 
     context "the validators have errors" do
-      let(:time_error) { { time: time_error_text }}
-      let(:rma_error)  { { rma: rma_error_text }}
+      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})
+        expect(subject).to eq({ time: time_error_text, rma: rma_error_text })
       end
     end
   end

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

@@ -53,6 +53,5 @@ describe Spree::ReturnItem::EligibilityValidator::InventoryShipped do
         expect(subject).to eq false
       end
     end
-
   end
 end

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

@@ -4,7 +4,6 @@ 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

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") }
@@ -62,4 +62,3 @@ module Spree
     end
   end
 end
-

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

@@ -2,9 +2,8 @@ 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
           it "returns the master variant for the same product" do
             product = create(:product)
@@ -16,7 +15,7 @@ module Spree
 
         context "product has variants" do
           it "returns all variants for the same product" do
-            product = create(:product, variants: 3.times.map { create(:variant) })
+            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
@@ -30,14 +29,13 @@ module Spree
         end
 
         it "only returns variants that are on hand" do
-          product = create(:product, variants: 2.times.map { create(:variant) })
+          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

data/spec/models/spree/return_item_spec.rb

@@ -8,8 +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)
 
@@ -19,10 +18,10 @@ describe Spree::ReturnItem, :type => :model do
 
   describe '#receive!' do
     let(:now)            { Time.current }
-    let(:order)          { create(:shipped_order)}
-    let(:inventory_unit) { create(:inventory_unit, order: order,state: 'shipped') }
+    let(:order)          { create(:shipped_order) }
+    let(:inventory_unit) { create(:inventory_unit, order: order, state: 'shipped') }
     let!(:customer_return) { create(:customer_return_without_return_items, return_items: [return_item], stock_location_id: inventory_unit.shipment.stock_location_id) }
-    let(:return_item)    { create(:return_item, inventory_unit: inventory_unit) }
+    let(:return_item) { create(:return_item, inventory_unit: inventory_unit) }
 
     before do
       inventory_unit.update_attributes!(state: 'shipped')
@@ -59,9 +58,9 @@ describe Spree::ReturnItem, :type => :model do
     end
 
     context 'when the received item is actually the exchange (aka customer changed mind about exchange)' do
-      let(:exchange_inventory_unit) { create(:inventory_unit, order: order,state: 'shipped') }
+      let(:exchange_inventory_unit) { create(:inventory_unit, order: order, state: 'shipped') }
       let!(:return_item_with_exchange) { create(:return_item, inventory_unit: inventory_unit, exchange_inventory_unit: exchange_inventory_unit) }
-      let!(:return_item_in_lieu) { create(:return_item, inventory_unit: exchange_inventory_unit)}
+      let!(:return_item_in_lieu) { create(:return_item, inventory_unit: exchange_inventory_unit) }
 
       it 'unexchanges original return item' do
         return_item_in_lieu.receive!
@@ -70,7 +69,7 @@ describe Spree::ReturnItem, :type => :model do
         return_item_in_lieu.reload
         expect(return_item_with_exchange.reception_status).to eq 'unexchanged'
         expect(return_item_in_lieu.reception_status).to eq 'received'
-        expect(return_item_in_lieu.pre_tax_amount).to eq 0
+        expect(return_item_in_lieu.amount).to eq 0
         expect(inventory_unit.reload.state).to eq 'shipped'
         expect(exchange_inventory_unit.reload.state).to eq 'returned'
       end
@@ -78,7 +77,7 @@ describe Spree::ReturnItem, :type => :model do
 
     context 'with a stock location' do
       let(:stock_location) { customer_return.stock_location }
-      let(:stock_item)      { stock_location.stock_item(inventory_unit.variant) }
+      let(:stock_item) { stock_location.stock_item(inventory_unit.variant) }
 
       before do
         inventory_unit.update_attributes!(state: 'shipped')
@@ -121,7 +120,6 @@ describe Spree::ReturnItem, :type => :model do
           expect(stock_item.variant).to eq inventory_unit.variant
           expect(stock_item.count_on_hand).to eq 1
         end
-
       end
 
       Spree::ReturnItem::INTERMEDIATE_RECEPTION_STATUSES.each do |status|
@@ -142,13 +140,13 @@ describe Spree::ReturnItem, :type => :model do
     end
   end
 
-
   describe "#display_pre_tax_amount" do
-    let(:pre_tax_amount) { 21.22 }
-    let(:return_item) { build(:return_item, pre_tax_amount: pre_tax_amount) }
+    let(:amount) { 21.22 }
+    let(:included_tax_total) { 1.22 }
+    let(:return_item) { build(:return_item, amount: amount, included_tax_total: included_tax_total) }
 
     it "returns a Spree::Money" do
-      expect(return_item.display_pre_tax_amount).to eq Spree::Money.new(pre_tax_amount)
+      expect(return_item.display_pre_tax_amount).to eq Spree::Money.new(amount - included_tax_total)
     end
   end
 
@@ -158,28 +156,28 @@ describe Spree::ReturnItem, :type => :model do
     end
   end
 
-  describe "pre_tax_amount calculations on create" do
+  describe "amount calculations on create" do
     let(:inventory_unit) { build(:inventory_unit) }
     before { subject.save! }
 
-    context "pre tax amount is not specified" do
+    context "amount is not specified" do
       subject { build(:return_item, inventory_unit: inventory_unit) }
 
       context "not an exchange" do
-        it { expect(subject.pre_tax_amount).to eq Spree::Calculator::Returns::DefaultRefundAmount.new.compute(subject) }
+        it { expect(subject.amount).to eq Spree::Calculator::Returns::DefaultRefundAmount.new.compute(subject) }
       end
 
       context "an exchange" do
         subject { build(:exchange_return_item) }
 
-        it { expect(subject.pre_tax_amount).to eq 0.0 }
+        it { expect(subject.amount).to eq 0.0 }
       end
     end
 
-    context "pre tax amount is specified" do
-      subject { build(:return_item, inventory_unit: inventory_unit, pre_tax_amount: 100) }
+    context "amount is specified" do
+      subject { build(:return_item, inventory_unit: inventory_unit, amount: 100) }
 
-      it { expect(subject.pre_tax_amount).to eq 100 }
+      it { expect(subject.amount).to eq 100 }
     end
   end
 
@@ -480,7 +478,7 @@ describe Spree::ReturnItem, :type => :model do
 
       it 'is valid' do
         expect(subject).to_not be_valid
-        expect(subject.errors.messages).to eq({reimbursement: [I18n.t(:cannot_be_associated_unless_accepted, scope: 'activerecord.errors.models.spree/return_item.attributes.reimbursement')]})
+        expect(subject.errors.messages).to eq({ reimbursement: [I18n.t(:cannot_be_associated_unless_accepted, scope: 'activerecord.errors.models.spree/return_item.attributes.reimbursement')] })
       end
     end
   end
@@ -570,17 +568,17 @@ describe Spree::ReturnItem, :type => :model do
       end
 
       it do
-        return_item.pre_tax_amount = 5.0
+        return_item.amount = 5.0
         return_item.save!
-        expect(return_item.reload.pre_tax_amount).to eq 0.0
+        expect(return_item.reload.amount).to eq 0.0
       end
     end
 
     context "the return item is not intended to be exchanged" do
       it do
-        return_item.pre_tax_amount = 5.0
+        return_item.amount = 5.0
         return_item.save!
-        expect(return_item.reload.pre_tax_amount).to eq 5.0
+        expect(return_item.reload.amount).to eq 5.0
       end
     end
   end
@@ -637,7 +635,7 @@ describe Spree::ReturnItem, :type => :model do
     subject do
       build(:return_item, {
         return_authorization: old_return_item.return_authorization,
-        inventory_unit: old_return_item.inventory_unit,
+        inventory_unit: old_return_item.inventory_unit
       })
     end
 
@@ -689,14 +687,14 @@ describe Spree::ReturnItem, :type => :model do
       create(
         :return_item,
         inventory_unit: inventory_unit,
-        included_tax_total: 10
+        included_tax_total: 5
       )
     end
 
     it 'includes included tax total' do
-      expect(return_item.pre_tax_amount).to eq 10
-      expect(return_item.included_tax_total).to eq 10
-      expect(return_item.total).to eq 20
+      expect(return_item.amount).to eq 10
+      expect(return_item.included_tax_total).to eq 5
+      expect(return_item.total).to eq 10
     end
   end
 

data/spec/models/spree/returns_calculator_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe ReturnsCalculator, :type => :model do
+  describe ReturnsCalculator, type: :model do
     let(:return_item) { build(:return_item) }
     subject { ReturnsCalculator.new }