solidus_core 1.2.3 → 1.3.0.beta1

data/spec/models/spree/promotion/rules/user_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Promotion::Rules::User, :type => :model do
+describe Spree::Promotion::Rules::User, type: :model do
   let(:rule) { Spree::Promotion::Rules::User.new }
 
   context "#eligible?(order)" do
@@ -13,24 +13,24 @@ describe Spree::Promotion::Rules::User, :type => :model do
     it "should be eligible if users include user placing the order" do
       user = mock_model(Spree::LegacyUser)
       users = [user, mock_model(Spree::LegacyUser)]
-      allow(rule).to receive_messages(:users => users)
-      allow(order).to receive_messages(:user => user)
+      allow(rule).to receive_messages(users: users)
+      allow(order).to receive_messages(user: user)
 
       expect(rule).to be_eligible(order)
     end
 
     it "should not be eligible if user placing the order is not listed" do
-      allow(order).to receive_messages(:user => mock_model(Spree::LegacyUser))
+      allow(order).to receive_messages(user: mock_model(Spree::LegacyUser))
       users = [mock_model(Spree::LegacyUser), mock_model(Spree::LegacyUser)]
-      allow(rule).to receive_messages(:users => users)
+      allow(rule).to receive_messages(users: users)
 
       expect(rule).not_to be_eligible(order)
     end
 
     # Regression test for https://github.com/spree/spree/issues/3885
     it "can assign to user_ids" do
-      user1 = Spree::LegacyUser.create!(:email => "test1@example.com")
-      user2 = Spree::LegacyUser.create!(:email => "test2@example.com")
+      user1 = Spree::LegacyUser.create!(email: "test1@example.com")
+      user2 = Spree::LegacyUser.create!(email: "test2@example.com")
       rule.user_ids = "#{user1.id}, #{user2.id}"
     end
   end

data/spec/models/spree/promotion_builder_spec.rb

@@ -5,13 +5,15 @@ describe Spree::PromotionBuilder do
   let(:base_code) { 'abc' }
   let(:number_of_codes) { 1 }
   let(:promotion_attrs) { { name: 'some promo' } }
-  let(:builder) { Spree::PromotionBuilder.new(
-    {
-      base_code: base_code,
-      number_of_codes: number_of_codes
-    },
-    promotion_attrs,
-  ) }
+  let(:builder) {
+    Spree::PromotionBuilder.new(
+      {
+        base_code: base_code,
+        number_of_codes: number_of_codes
+      },
+    promotion_attrs
+  )
+  }
 
   describe '#initialize' do
     subject { builder }
@@ -25,7 +27,7 @@ describe Spree::PromotionBuilder do
   end
 
   describe '#valid?' do
-    subject {  builder.valid? }
+    subject { builder.valid? }
 
     it 'is true' do
       expect(subject).to be

data/spec/models/spree/promotion_category_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::PromotionCategory, :type => :model do
+describe Spree::PromotionCategory, type: :model do
   describe 'validation' do
     let(:name) { 'Nom' }
     subject { Spree::PromotionCategory.new name: name }

data/spec/models/spree/promotion_code/code_builder_spec.rb

@@ -39,7 +39,7 @@ describe Spree::PromotionCode::CodeBuilder do
 
       it "builds codes with the same base prefix" do
         subject
-        values = builder.promotion.codes.map &:value
+        values = builder.promotion.codes.map(&:value)
         expect(values.all? { |val| val.starts_with?("#{base_code}_") }).to be true
       end
 
@@ -72,8 +72,6 @@ describe Spree::PromotionCode::CodeBuilder do
           expect(builder.promotion.codes.map(&:value).uniq.size).to eq(num_codes)
         end
       end
-
     end
   end
-
 end

data/spec/models/spree/promotion_code_spec.rb

@@ -142,13 +142,14 @@ RSpec.describe Spree::PromotionCode do
         :promotion,
         :with_order_adjustment,
         code: "discount",
-        per_code_usage_limit: 1
+        per_code_usage_limit: 1,
+        weighted_order_adjustment_amount: 10
       )
     end
     let(:code) { promotion.codes.first }
     let(:order) do
-      FactoryGirl.create(:order_with_line_items).tap do |order|
-        FactoryGirl.create(:payment, amount: order.total, order: order)
+      FactoryGirl.create(:order_with_line_items, line_items_price: 40, shipment_cost: 0).tap do |order|
+        FactoryGirl.create(:payment, amount: 30, order: order)
         promotion.activate(order: order, promotion_code: code)
       end
     end
@@ -156,8 +157,8 @@ RSpec.describe Spree::PromotionCode do
     before do
       order.next! until order.confirm?
 
-      FactoryGirl.create(:order_with_line_items).tap do |order|
-        FactoryGirl.create(:payment, amount: order.total, order: order)
+      FactoryGirl.create(:order_with_line_items, line_items_price: 40, shipment_cost: 0).tap do |order|
+        FactoryGirl.create(:payment, amount: 30, order: order)
         promotion.activate(order: order, promotion_code: code)
         order.next! until order.confirm?
         order.complete!
@@ -173,10 +174,10 @@ RSpec.describe Spree::PromotionCode do
         order.complete
       }.to change(order, :promo_total).by(10)
     end
-    it "adjusts the total" do
+    it "increases the total to remove the promo" do
       expect{
         order.complete
-      }.to change(order, :total).by(10)
+      }.to change(order, :total).from(30).to(40)
     end
     it "resets the state of the order" do
       expect{

data/spec/models/spree/promotion_handler/cart_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module PromotionHandler
-    describe Cart, :type => :model do
+    describe Cart, type: :model do
       let(:line_item) { create(:line_item) }
       let(:order) { line_item.order }
       let(:promotion) { create(:promotion, apply_automatically: true) }

data/spec/models/spree/promotion_handler/coupon_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 module Spree
   module PromotionHandler
-    describe Coupon, :type => :model do
+    describe Coupon, type: :model do
       let(:order) { double("Order", coupon_code: "10off").as_null_object }
 
       subject { Coupon.new(order) }
@@ -17,7 +17,6 @@ module Spree
         expect(adjustable.adjustments.map(&:promotion_code)).to include(promotion_code)
       end
 
-
       it "returns self in apply" do
         expect(subject.apply).to be_a Coupon
       end
@@ -85,11 +84,11 @@ module Spree
         end
 
         context "with a per-item adjustment action" do
-          let(:order) { create(:order_with_line_items, :line_items_count => 3) }
+          let(:order) { create(:order_with_line_items, line_items_count: 3) }
 
           context "right coupon given" do
             context "with correct coupon code casing" do
-              before { allow(order).to receive_messages :coupon_code => "10off" }
+              before { allow(order).to receive_messages coupon_code: "10off" }
 
               it "successfully activates promo" do
                 expect(order.total).to eq(130)
@@ -113,7 +112,7 @@ module Spree
 
             # Regression test for https://github.com/spree/spree/issues/4211
             context "with incorrect coupon code casing" do
-              before { allow(order).to receive_messages :coupon_code => "10OFF" }
+              before { allow(order).to receive_messages coupon_code: "10OFF" }
               it "successfully activates promo" do
                 expect(order.total).to eq(130)
                 subject.apply
@@ -132,10 +131,10 @@ module Spree
             let!(:order) { Order.create }
 
             before do
-              allow(order).to receive_messages :coupon_code => "10off"
+              allow(order).to receive_messages coupon_code: "10off"
               calculator = Calculator::FlatRate.new(preferred_amount: 10)
               general_promo = create(:promotion, name: "General Promo")
-              general_action = Promotion::Actions::CreateItemAdjustments.create(promotion: general_promo, calculator: calculator)
+              Promotion::Actions::CreateItemAdjustments.create(promotion: general_promo, calculator: calculator)
 
               order.contents.add create(:variant)
             end
@@ -155,9 +154,9 @@ module Spree
         context "with a free-shipping adjustment action" do
           let!(:action) { Promotion::Actions::FreeShipping.create!(promotion: promotion) }
           context "right coupon code given" do
-            let(:order) { create(:order_with_line_items, :line_items_count => 3) }
+            let(:order) { create(:order_with_line_items, line_items_count: 3) }
 
-            before { allow(order).to receive_messages :coupon_code => "10off" }
+            before { allow(order).to receive_messages coupon_code: "10off" }
 
             it "successfully activates promo" do
               expect(order.total).to eq(130)
@@ -187,10 +186,10 @@ module Spree
 
             before do
               allow(order).to receive_messages({
-                :coupon_code => "10off",
+                coupon_code: "10off",
                 # These need to be here so that promotion adjustment "wins"
-                :item_total => 50,
-                :ship_total => 10
+                item_total: 50,
+                ship_total: 10
               })
             end
 
@@ -252,25 +251,26 @@ module Spree
         end
 
         context "for an order with taxable line items" do
+          let(:store) { create(:store) }
           before(:each) do
             @country = create(:country)
-            @zone = create(:zone, :name => "Country Zone", :default_tax => true, :zone_members => [])
-            @zone.zone_members.create(:zoneable => @country)
-            @category = Spree::TaxCategory.create :name => "Taxable Foo"
+            @zone = create(:zone, name: "Country Zone", default_tax: true, zone_members: [])
+            @zone.zone_members.create(zoneable: @country)
+            @category = Spree::TaxCategory.create name: "Taxable Foo"
             @rate1 = Spree::TaxRate.create(
-                :amount => 0.10,
-                :calculator => Spree::Calculator::DefaultTax.create,
-                :tax_category => @category,
-                :zone => @zone
+              amount: 0.10,
+              calculator: Spree::Calculator::DefaultTax.create,
+              tax_category: @category,
+              zone: @zone
             )
 
-            @order = Spree::Order.create!
-            allow(@order).to receive_messages :coupon_code => "10off"
+            @order = Spree::Order.create!(store: store)
+            allow(@order).to receive_messages coupon_code: "10off"
           end
           context "and the product price is less than promo discount" do
             before(:each) do
-              3.times do |i|
-                taxable = create(:product, :tax_category => @category, :price => 9.0)
+              3.times do |_i|
+                taxable = create(:product, tax_category: @category, price: 9.0)
                 @order.contents.add(taxable.master, 1)
               end
             end
@@ -287,8 +287,8 @@ module Spree
           end
           context "and the product price is greater than promo discount" do
             before(:each) do
-              3.times do |i|
-                taxable = create(:product, :tax_category => @category, :price => 11.0)
+              3.times do |_i|
+                taxable = create(:product, tax_category: @category, price: 11.0)
                 @order.contents.add(taxable.master, 2)
               end
             end
@@ -311,9 +311,9 @@ module Spree
                                                                calculator: twnty_off_calc)
 
               allow(@order).to receive(:coupon_code).and_call_original
-              allow(@order).to receive_messages :coupon_code => "20off"
-              3.times do |i|
-                taxable = create(:product, :tax_category => @category, :price => 10.0)
+              allow(@order).to receive_messages coupon_code: "20off"
+              3.times do |_i|
+                taxable = create(:product, tax_category: @category, price: 10.0)
                 @order.contents.add(taxable.master, 2)
               end
             end

data/spec/models/spree/promotion_handler/page_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 module Spree
   module PromotionHandler
-    describe Page, :type => :model do
-      let(:order) { create(:order_with_line_items, :line_items_count => 1) }
+    describe Page, type: :model do
+      let(:order) { create(:order_with_line_items, line_items_count: 1) }
 
-      let(:promotion) { Promotion.create(name: "10% off", :path => '10off') }
+      let(:promotion) { Promotion.create(name: "10% off", path: '10off') }
       before do
         calculator = Calculator::FlatPercentItemTotal.new(preferred_flat_percent: 10)
-        action = Promotion::Actions::CreateItemAdjustments.create(:calculator => calculator)
+        action = Promotion::Actions::CreateItemAdjustments.create(calculator: calculator)
         promotion.actions << action
       end
 
@@ -21,8 +21,8 @@ module Spree
       context "when promotion is expired" do
         before do
           promotion.update_columns(
-            :starts_at => 1.week.ago,
-            :expires_at => 1.day.ago
+            starts_at: 1.week.ago,
+            expires_at: 1.day.ago
           )
         end
 
@@ -41,4 +41,3 @@ module Spree
     end
   end
 end
-

data/spec/models/spree/promotion_rule_spec.rb

@@ -2,11 +2,10 @@ require 'spec_helper'
 
 module Spree
   describe Spree::PromotionRule, type: :model do
-
     class BadTestRule < Spree::PromotionRule; end
 
     class TestRule < Spree::PromotionRule
-      def eligible?(promotable, options = {})
+      def eligible?(_promotable, _options = {})
         true
       end
     end

data/spec/models/spree/promotion_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Spree::Promotion, :type => :model do
+describe Spree::Promotion, type: :model do
   let(:promotion) { Spree::Promotion.new }
 
   describe "validations" do
     before :each do
-      @valid_promotion = Spree::Promotion.new :name => "A promotion"
+      @valid_promotion = Spree::Promotion.new name: "A promotion"
     end
 
     it "valid_promotion is valid" do
@@ -38,7 +38,7 @@ describe Spree::Promotion, :type => :model do
 
   describe ".advertised" do
     let(:promotion) { create(:promotion) }
-    let(:advertised_promotion) { create(:promotion, :advertise => true) }
+    let(:advertised_promotion) { create(:promotion, advertise: true) }
 
     it "only shows advertised promotions" do
       advertised = Spree::Promotion.advertised
@@ -76,7 +76,7 @@ describe Spree::Promotion, :type => :model do
   end
 
   describe "#save" do
-    let(:promotion) { Spree::Promotion.create(:name => "delete me") }
+    let(:promotion) { Spree::Promotion.create(name: "delete me") }
 
     before(:each) do
       promotion.actions << Spree::Promotion::Actions::CreateAdjustment.new
@@ -105,7 +105,7 @@ describe Spree::Promotion, :type => :model do
 
       @user = create(:user)
       @order = create(:order, user: @user, created_at: DateTime.current)
-      @payload = { :order => @order, :user => @user }
+      @payload = { order: @order, user: @user }
     end
 
     it "should check path if present" do
@@ -163,7 +163,6 @@ describe Spree::Promotion, :type => :model do
           expect(promotion.orders.reload.to_a).to eql [@order]
         end
       end
-
     end
 
     context "when there is a code" do
@@ -370,13 +369,13 @@ describe Spree::Promotion, :type => :model do
       create(
         :promotion,
         name: "Foo",
-        code: "XXX",
+        code: "XXX"
       )
     end
 
     let!(:action) do
       calculator = Spree::Calculator::FlatRate.new
-      action_params = { :promotion => promotion, :calculator => calculator }
+      action_params = { promotion: promotion, calculator: calculator }
       action = Spree::Promotion::Actions::CreateAdjustment.create(action_params)
       promotion.actions << action
       action
@@ -538,7 +537,7 @@ describe Spree::Promotion, :type => :model do
     end
 
     it "true if there are no applicable rules" do
-      promotion.promotion_rules = [stub_model(Spree::PromotionRule, :eligible? => true, :applicable? => false)]
+      promotion.promotion_rules = [stub_model(Spree::PromotionRule, eligible?: true, applicable?: false)]
       allow(promotion.promotion_rules).to receive(:for).and_return([])
       expect(promotion.eligible_rules(promotable)).to eq []
     end
@@ -586,14 +585,14 @@ describe Spree::Promotion, :type => :model do
     end
 
     context "with 'any' match policy" do
-      let(:promotion) { Spree::Promotion.create(:name => "Promo", :match_policy => 'any') }
+      let(:promotion) { Spree::Promotion.create(name: "Promo", match_policy: 'any') }
       let(:promotable) { double('Promotable') }
 
       it "should have eligible rules if any of the rules are eligible" do
-        allow_any_instance_of(Spree::PromotionRule).to receive_messages(:applicable? => true)
-        true_rule = Spree::PromotionRule.create(:promotion => promotion)
-        allow(true_rule).to receive_messages(:eligible? => true)
-        allow(promotion).to receive_messages(:rules => [true_rule])
+        allow_any_instance_of(Spree::PromotionRule).to receive_messages(applicable?: true)
+        true_rule = Spree::PromotionRule.create(promotion: promotion)
+        allow(true_rule).to receive_messages(eligible?: true)
+        allow(promotion).to receive_messages(rules: [true_rule])
         allow(promotion).to receive_message_chain(:rules, :for).and_return([true_rule])
         expect(promotion.eligible_rules(promotable)).to eq [true_rule]
       end
@@ -620,7 +619,7 @@ describe Spree::Promotion, :type => :model do
 
   describe '#line_item_actionable?' do
     let(:order) { double Spree::Order }
-    let(:line_item) { double Spree::LineItem}
+    let(:line_item) { double Spree::LineItem }
     let(:true_rule) { double Spree::PromotionRule, eligible?: true, applicable?: true, actionable?: true }
     let(:false_rule) { double Spree::PromotionRule, eligible?: true, applicable?: true, actionable?: false }
     let(:rules) { [] }
@@ -643,12 +642,12 @@ describe Spree::Promotion, :type => :model do
 
           context 'when all rules allow action on the line item' do
             let(:rules) { [true_rule] }
-            it { is_expected.to be}
+            it { is_expected.to be }
           end
 
           context 'when at least one rule does not allow action on the line item' do
             let(:rules) { [true_rule, false_rule] }
-            it { is_expected.not_to be}
+            it { is_expected.not_to be }
           end
         end
 
@@ -662,7 +661,7 @@ describe Spree::Promotion, :type => :model do
 
           context 'when no rules allow action on the line item' do
             let(:rules) { [false_rule] }
-            it { is_expected.not_to be}
+            it { is_expected.not_to be }
           end
         end
       end
@@ -692,7 +691,7 @@ describe Spree::Promotion, :type => :model do
   # admin form posts the code and path as empty string
   describe "normalize blank values for path" do
     it "will save blank value as nil value instead" do
-      promotion = Spree::Promotion.create(:name => "A promotion", :path => "")
+      promotion = Spree::Promotion.create(name: "A promotion", path: "")
       expect(promotion.path).to be_nil
     end
   end
@@ -740,6 +739,11 @@ describe Spree::Promotion, :type => :model do
 
       context 'when the order is not complete' do
         let(:order) { create :order, user: user }
+
+        # The before clause above sets the completed at
+        # value for this order
+        before { order.update completed_at: nil }
+
         it { is_expected.to be false }
       end
     end
@@ -764,13 +768,13 @@ describe Spree::Promotion, :type => :model do
       order.update!
 
       expect(line_item.adjustments.size).to eq(1)
-      expect(order.adjustment_total).to eq -5
+      expect(order.adjustment_total).to eq(-5)
 
       other_line_item = order.contents.add(variant, 1, currency: order.currency)
 
       expect(other_line_item).not_to eq line_item
       expect(other_line_item.adjustments.size).to eq(1)
-      expect(order.adjustment_total).to eq -10
+      expect(order.adjustment_total).to eq(-10)
     end
   end
 end

data/spec/models/spree/refund_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Refund, :type => :model do
-
+describe Spree::Refund, type: :model do
   describe 'create' do
     let(:amount) { 100.0 }
     let(:amount_in_cents) { amount * 100 }
@@ -9,7 +8,7 @@ describe Spree::Refund, :type => :model do
     let(:authorization) { generate(:refund_transaction_id) }
 
     let(:payment) { create(:payment, amount: payment_amount, payment_method: payment_method) }
-    let(:payment_amount) { amount*2 }
+    let(:payment_amount) { amount * 2 }
     let(:payment_method) { create(:credit_card_payment_method) }
 
     let(:refund_reason) { create(:refund_reason) }
@@ -32,7 +31,7 @@ describe Spree::Refund, :type => :model do
     before do
       allow(payment.payment_method)
         .to receive(:credit)
-        .with(amount_in_cents, payment.source, payment.transaction_id, {originator: an_instance_of(Spree::Refund)})
+        .with(amount_in_cents, payment.source, payment.transaction_id, { originator: an_instance_of(Spree::Refund) })
         .and_return(gateway_response)
     end
 
@@ -60,7 +59,6 @@ describe Spree::Refund, :type => :model do
         expect(payment.payment_method).not_to receive(:credit)
         subject
       end
-
     end
 
     context "processing is successful" do
@@ -95,7 +93,6 @@ describe Spree::Refund, :type => :model do
         expect(payment.order.updater).to receive(:update)
         subject
       end
-
     end
 
     context "processing fails" do
@@ -117,7 +114,7 @@ describe Spree::Refund, :type => :model do
       it 'should not supply the payment source' do
         expect(payment.payment_method)
           .to receive(:credit)
-          .with(amount * 100, payment.transaction_id, {originator: an_instance_of(Spree::Refund)})
+          .with(amount * 100, payment.transaction_id, { originator: an_instance_of(Spree::Refund) })
           .and_return(gateway_response)
 
         subject
@@ -132,7 +129,7 @@ describe Spree::Refund, :type => :model do
       it 'should supply the payment source' do
         expect(payment.payment_method)
           .to receive(:credit)
-          .with(amount_in_cents, payment.source, payment.transaction_id, {originator: an_instance_of(Spree::Refund)})
+          .with(amount_in_cents, payment.source, payment.transaction_id, { originator: an_instance_of(Spree::Refund) })
           .and_return(gateway_response)
 
         subject
@@ -143,7 +140,7 @@ describe Spree::Refund, :type => :model do
       before do
         expect(payment.payment_method)
           .to receive(:credit)
-          .with(amount_in_cents, payment.source, payment.transaction_id, {originator: an_instance_of(Spree::Refund)})
+          .with(amount_in_cents, payment.source, payment.transaction_id, { originator: an_instance_of(Spree::Refund) })
           .and_raise(ActiveMerchant::ConnectionError.new("foo", nil))
       end
 
@@ -154,7 +151,7 @@ describe Spree::Refund, :type => :model do
 
     context 'with amount too large' do
       let(:payment_amount) { 10 }
-      let(:amount) { payment_amount*2 }
+      let(:amount) { payment_amount * 2 }
 
       it 'is invalid' do
         expect { subject }.to raise_error { |error|
@@ -166,7 +163,7 @@ describe Spree::Refund, :type => :model do
   end
 
   describe 'total_amount_reimbursed_for' do
-    let(:customer_return) { reimbursement.customer_return}
+    let(:customer_return) { reimbursement.customer_return }
     let(:reimbursement) { create(:reimbursement) }
     let!(:default_refund_reason) { Spree::RefundReason.find_or_create_by!(name: Spree::RefundReason::RETURN_PROCESSING_REASON, mutable: false) }
 

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

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Reimbursement::Credit, :type => :model do
+  describe Reimbursement::Credit, type: :model do
     context 'class methods' do
       describe '.total_amount_reimbursed_for' do
         subject { Spree::Reimbursement::Credit.total_amount_reimbursed_for(reimbursement) }
@@ -9,7 +9,7 @@ module Spree
         let(:reimbursement) { create(:reimbursement) }
         let(:credit_double) { double(amount: 99.99) }
 
-        before { allow(reimbursement).to receive(:credits).and_return([credit_double, credit_double])}
+        before { allow(reimbursement).to receive(:credits).and_return([credit_double, credit_double]) }
 
         it 'should sum the amounts of all of the reimbursements credits' do
           expect(subject).to eq BigDecimal.new('199.98')

data/spec/models/spree/reimbursement/reimbursement_type_engine_spec.rb

@@ -1,22 +1,24 @@
 require 'spec_helper'
 
 module Spree
-  describe Reimbursement::ReimbursementTypeEngine, :type => :model do
+  describe Reimbursement::ReimbursementTypeEngine, type: :model do
     describe '#calculate_reimbursement_types' do
       let(:return_item)   { create(:return_item) }
-      let(:return_items)  { [ return_item ] }
+      let(:return_items)  { [return_item] }
       let(:reimbursement_type_engine) { Spree::Reimbursement::ReimbursementTypeEngine.new(return_items) }
       let(:expired_reimbursement_type) { Spree::ReimbursementType::OriginalPayment }
       let(:override_reimbursement_type) { Spree::ReimbursementType::OriginalPayment.new }
       let(:preferred_reimbursement_type) { Spree::ReimbursementType::OriginalPayment.new }
       let(:calculated_reimbursement_types) { subject }
-      let(:all_reimbursement_types) {[
+      let(:all_reimbursement_types) {
+        [
                                         reimbursement_type_engine.default_reimbursement_type,
                                         reimbursement_type_engine.exchange_reimbursement_type,
                                         expired_reimbursement_type,
                                         override_reimbursement_type,
                                         preferred_reimbursement_type
-                                    ]}
+                                    ]
+      }
 
       subject { reimbursement_type_engine.calculate_reimbursement_types }
 

data/spec/models/spree/reimbursement/reimbursement_type_validator_spec.rb

@@ -1,7 +1,7 @@
 require 'spec_helper'
 
 module Spree
-  describe Reimbursement::ReimbursementTypeValidator, :type => :model do
+  describe Reimbursement::ReimbursementTypeValidator, type: :model do
     class DummyClass
       include Spree::Reimbursement::ReimbursementTypeValidator
 

data/spec/models/spree/reimbursement_performer_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe Spree::ReimbursementPerformer, :type => :model do
+describe Spree::ReimbursementPerformer, type: :model do
   let(:reimbursement)           { create(:reimbursement, return_items_count: 1) }
   let(:return_item)             { reimbursement.return_items.first }
   let(:reimbursement_type)      { double("ReimbursementType") }
-  let(:reimbursement_type_hash) { { reimbursement_type => [return_item]} }
+  let(:reimbursement_type_hash) { { reimbursement_type => [return_item] } }
 
   before do
     expect(Spree::ReimbursementPerformer).to receive(:calculate_reimbursement_types).and_return(reimbursement_type_hash)