spree_core 3.0.9 → 3.2.0

data/spec/models/spree/payment_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Spree::Payment, :type => :model do
+describe Spree::Payment, type: :model do
   let(:order) { Spree::Order.create }
   let(:refund_reason) { create(:refund_reason) }
 
   let(:gateway) do
-    gateway = Spree::Gateway::Bogus.create(active: true, name: 'Bogus')
+    gateway = Spree::Gateway::Bogus.new(active: true)
     allow(gateway).to receive_messages source_required: true
     gateway
   end
@@ -43,6 +43,41 @@ describe Spree::Payment, :type => :model do
     allow(payment.log_entries).to receive(:create!)
   end
 
+  describe 'delegate' do
+    it { is_expected.to delegate_method(:currency).to(:order) }
+  end
+
+  describe 'Constants' do
+    it { expect(Spree::Payment::INVALID_STATES).to eq(%w(failed invalid)) }
+  end
+
+  describe 'scopes' do
+    describe '.valid' do
+      let!(:invalid_payment) do
+        create(:payment, avs_response: 'Y', cvv_response_code: 'M', cvv_response_message: '', state: 'invalid')
+      end
+
+      let!(:failed_payment) do
+        create(:payment, avs_response: 'Y', cvv_response_code: 'M', cvv_response_message: '', state: 'failed')
+      end
+
+      let!(:checkout_payment) do
+        create(:payment, avs_response: 'A', cvv_response_code: 'M', cvv_response_message: '', state: 'checkout')
+      end
+
+      let!(:completed_payment) do
+        create(:payment, avs_response: 'Y', cvv_response_code: 'N', cvv_response_message: '', state: 'completed')
+      end
+
+      subject { Spree::Payment.valid }
+
+      it { is_expected.to_not include(invalid_payment) }
+      it { is_expected.to_not include(failed_payment) }
+      it { is_expected.to     include(checkout_payment) }
+      it { is_expected.to     include(completed_payment) }
+    end
+  end
+
   context '.risky' do
 
     let!(:payment_1) { create(:payment, avs_response: 'Y', cvv_response_code: 'M', cvv_response_message: 'Match') }
@@ -147,7 +182,7 @@ describe Spree::Payment, :type => :model do
 
       # Regression test for #4598
       it "should allow payments with a gateway_customer_profile_id" do
-        allow(payment.source).to receive_messages :gateway_customer_profile_id => "customer_1"
+        allow(payment.source).to receive_messages gateway_customer_profile_id: "customer_1"
         expect(payment.payment_method).to receive(:supports?).with(payment.source).and_return(false)
         expect(payment).to receive(:started_processing!)
         payment.process!
@@ -155,7 +190,7 @@ describe Spree::Payment, :type => :model do
 
       # Another regression test for #4598
       it "should allow payments with a gateway_payment_profile_id" do
-        allow(payment.source).to receive_messages :gateway_payment_profile_id => "customer_1"
+        allow(payment.source).to receive_messages gateway_payment_profile_id: "customer_1"
         expect(payment.payment_method).to receive(:supports?).with(payment.source).and_return(false)
         expect(payment).to receive(:started_processing!)
         payment.process!
@@ -171,10 +206,10 @@ describe Spree::Payment, :type => :model do
       end
 
       it "should call authorize on the gateway with the currency code" do
-        allow(payment).to receive_messages :currency => 'GBP'
+        allow(payment).to receive_messages currency: 'GBP'
         expect(payment.payment_method).to receive(:authorize).with(amount_in_cents,
                                                                card,
-                                                               hash_including({:currency => "GBP"})).and_return(success_response)
+                                                               hash_including({currency: "GBP"})).and_return(success_response)
         payment.authorize!
       end
 
@@ -334,7 +369,7 @@ describe Spree::Payment, :type => :model do
 
         context "if unsuccessful" do
           it "should not make payment complete" do
-            allow(gateway).to receive_messages :capture => failed_response
+            allow(gateway).to receive_messages capture: failed_response
             expect(payment).to receive(:failure)
             expect(payment).not_to receive(:complete)
             expect { payment.capture! }.to raise_error(Spree::Core::GatewayError)
@@ -365,7 +400,7 @@ describe Spree::Payment, :type => :model do
 
       context "when profiles are supported" do
         it "should call payment_gateway.void with the payment's response_code" do
-          allow(gateway).to receive_messages :payment_profiles_supported? => true
+          allow(gateway).to receive_messages payment_profiles_supported?: true
           expect(gateway).to receive(:void).with('123', card, anything).and_return(success_response)
           payment.void_transaction!
         end
@@ -373,14 +408,14 @@ describe Spree::Payment, :type => :model do
 
       context "when profiles are not supported" do
         it "should call payment_gateway.void with the payment's response_code" do
-          allow(gateway).to receive_messages :payment_profiles_supported? => false
+          allow(gateway).to receive_messages payment_profiles_supported?: false
           expect(gateway).to receive(:void).with('123', anything).and_return(success_response)
           payment.void_transaction!
         end
       end
 
       it "should log the response" do
-        expect(payment.log_entries).to receive(:create!).with(:details => anything)
+        expect(payment.log_entries).to receive(:create!).with(details: anything)
         payment.void_transaction!
       end
 
@@ -395,7 +430,7 @@ describe Spree::Payment, :type => :model do
 
       context "if unsuccessful" do
         it "should not void the payment" do
-          allow(gateway).to receive_messages :void => failed_response
+          allow(gateway).to receive_messages void: failed_response
           expect(payment).not_to receive(:void)
           expect { payment.void_transaction! }.to raise_error(Spree::Core::GatewayError)
         end
@@ -440,7 +475,7 @@ describe Spree::Payment, :type => :model do
     context "raises no error if source is not specified" do
       before do
         payment.source = nil
-        allow(payment.payment_method).to receive_messages(:source_required? => false)
+        allow(payment.payment_method).to receive_messages(source_required?: false)
       end
 
       specify do
@@ -483,7 +518,7 @@ describe Spree::Payment, :type => :model do
     context "not completed payments" do
       it "doesn't update order payment total" do
         expect {
-          Spree::Payment.create(:amount => 100, :order => order)
+          Spree::Payment.create(amount: 100, order: order)
         }.not_to change { order.payment_total }
       end
 
@@ -519,8 +554,8 @@ describe Spree::Payment, :type => :model do
 
     context "when profiles are supported" do
       before do
-        allow(gateway).to receive_messages :payment_profiles_supported? => true
-        allow(payment.source).to receive_messages :has_payment_profile? => false
+        allow(gateway).to receive_messages payment_profiles_supported?: true
+        allow(payment.source).to receive_messages has_payment_profile?: false
       end
 
       context "when there is an error connecting to the gateway" do
@@ -530,10 +565,10 @@ describe Spree::Payment, :type => :model do
           expect(gateway).to receive(:create_profile).and_raise(connection_error)
           expect do
             Spree::Payment.create(
-              :amount => 100,
-              :order => order,
-              :source => card,
-              :payment_method => gateway
+              amount: 100,
+              order: order,
+              source: card,
+              payment_method: gateway
             )
           end.to raise_error(Spree::Core::GatewayError)
         end
@@ -564,25 +599,25 @@ describe Spree::Payment, :type => :model do
         it "should create a payment profile" do
           expect(payment.payment_method).to receive :create_profile
           payment = Spree::Payment.create(
-            :amount => 100,
-            :order => order,
-            :source => card,
-            :payment_method => gateway
+            amount: 100,
+            order: order,
+            source: card,
+            payment_method: gateway
           )
         end
       end
     end
 
     context "when profiles are not supported" do
-      before { allow(gateway).to receive_messages :payment_profiles_supported? => false }
+      before { allow(gateway).to receive_messages payment_profiles_supported?: false }
 
       it "should not create a payment profile" do
         expect(gateway).not_to receive :create_profile
         payment = Spree::Payment.create(
-          :amount => 100,
-          :order => order,
-          :source => card,
-          :payment_method => gateway
+          amount: 100,
+          order: order,
+          source: card,
+          payment_method: gateway
         )
       end
     end
@@ -591,13 +626,13 @@ describe Spree::Payment, :type => :model do
   describe "#build_source" do
     let(:params) do
       {
-        :amount => 100,
-        :payment_method => gateway,
-        :source_attributes => {
-          :expiry =>"01 / 99",
-          :number => '1234567890123',
-          :verification_value => '123',
-          :name => 'Spree Commerce'
+        amount: 100,
+        payment_method: gateway,
+        source_attributes: {
+          expiry:"01 / 99",
+          number: '1234567890123',
+          verification_value: '123',
+          name: 'Spree Commerce'
         }
       }
     end
@@ -617,8 +652,8 @@ describe Spree::Payment, :type => :model do
     end
 
     it "errors when payment source not valid" do
-      params = { :amount => 100, :payment_method => gateway,
-        :source_attributes => {:expiry => "1 / 12" }}
+      params = { amount: 100, payment_method: gateway,
+        source_attributes: {expiry: "1 / 12" }}
 
       payment = Spree::Payment.new(params)
       expect(payment).not_to be_valid
@@ -649,7 +684,7 @@ describe Spree::Payment, :type => :model do
 
   # Regression test for #2216
   describe "#gateway_options" do
-    before { allow(order).to receive_messages(:last_ip_address => "192.168.1.1") }
+    before { allow(order).to receive_messages(last_ip_address: "192.168.1.1") }
 
     it "contains an IP" do
       expect(payment.gateway_options[:ip]).to eq(order.last_ip_address)
@@ -659,53 +694,11 @@ describe Spree::Payment, :type => :model do
       # Sets the payment's order to a different Ruby object entirely
       payment.order = Spree::Order.find(payment.order_id)
       email = 'foo@example.com'
-      order.update_attributes(:email => email)
+      order.update_attributes(email: email)
       expect(payment.gateway_options[:email]).to eq(email)
     end
   end
 
-  describe "#set_unique_number" do
-    # Regression test for #1998
-    it "sets a unique number on create" do
-      payment.generate_number
-      payment.save
-
-      expect(payment.number).to_not be_blank
-      expect(payment.number.length).to eq 8
-      expect(payment.number).to be_a(String)
-    end
-
-    # Regression test for #3733
-    it "does not regenerate the number on re-save" do
-      payment.run_callbacks(:create)
-      payment.save
-      old_number = payment.number
-      payment.save
-      expect(payment.number).to eq old_number
-    end
-
-    context "other payment exists" do
-      let(:other_payment) {
-        payment = Spree::Payment.new
-        payment.source = card
-        payment.order = order
-        payment.payment_method = gateway
-        payment
-      }
-
-      it "doesn't set duplicate number" do
-        other_payment.run_callbacks(:create)
-        other_payment.save!
-
-        payment.run_callbacks(:create)
-        payment.save!
-
-        expect(payment.number).to_not be_blank
-        expect(payment.number).to_not eq other_payment.number
-      end
-    end
-  end
-
   describe "#amount=" do
     before do
       subject.amount = amount
@@ -781,7 +774,7 @@ describe Spree::Payment, :type => :model do
 
     context "when the locale uses a coma as a decimal separator" do
       before(:each) do
-        I18n.backend.store_translations(:fr, { :number => { :currency => { :format => { :delimiter => ' ', :separator => ',' } } } })
+        I18n.backend.store_translations(:fr, { number: { currency: { format: { delimiter: ' ', separator: ',' } } } })
         I18n.locale = :fr
         subject.amount = amount
       end

data/spec/models/spree/preference_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Preference, :type => :model do
+describe Spree::Preference, type: :model do
 
   it "should require a key" do
     @preference = Spree::Preference.new

data/spec/models/spree/preferences/configuration_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe Spree::Preferences::Configuration, :type => :model do
+describe Spree::Preferences::Configuration, type: :model do
 
   before :all do
     class AppConfig < Spree::Preferences::Configuration
-      preference :color, :string, :default => :blue
+      preference :color, :string, default: :blue
     end
     @config = AppConfig.new
   end

data/spec/models/spree/preferences/preferable_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Preferences::Preferable, :type => :model do
+describe Spree::Preferences::Preferable, type: :model do
 
   before :all do
     class A
@@ -15,7 +15,7 @@ describe Spree::Preferences::Preferable, :type => :model do
         @preferences ||= default_preferences
       end
 
-      preference :color, :string, :default => 'green'
+      preference :color, :string, default: 'green'
     end
 
     class B < A
@@ -25,9 +25,9 @@ describe Spree::Preferences::Preferable, :type => :model do
 
   before :each do
     @a = A.new
-    allow(@a).to receive_messages(:persisted? => true)
+    allow(@a).to receive_messages(persisted?: true)
     @b = B.new
-    allow(@b).to receive_messages(:persisted? => true)
+    allow(@b).to receive_messages(persisted?: true)
 
     # ensure we're persisting as that is the default
     #
@@ -150,7 +150,7 @@ describe Spree::Preferences::Preferable, :type => :model do
 
     context "converts boolean preferences to boolean values" do
       before do
-        A.preference :is_boolean, :boolean, :default => true
+        A.preference :is_boolean, :boolean, default: true
       end
 
       it "with strings" do
@@ -216,12 +216,6 @@ describe Spree::Preferences::Preferable, :type => :model do
         expect(@a.preferences[:is_hash]).to eql({1 => 2, 3 => 4})
       end
 
-      it "with ancestor of a hash" do
-        ancestor_of_hash = ActionController::Parameters.new({ key: :value })
-        @a.set_preference(:is_hash, ancestor_of_hash)
-        expect(@a.preferences[:is_hash]).to eql({"key" => :value})
-      end
-
       it "with string" do
         @a.set_preference(:is_hash, "{\"0\"=>{\"answer\"=>\"1\", \"value\"=>\"No\"}}")
         expect(@a.preferences[:is_hash]).to be_is_a(Hash)
@@ -255,8 +249,8 @@ describe Spree::Preferences::Preferable, :type => :model do
 
     context "converts any preferences to any values" do
       before do
-        A.preference :product_ids, :any, :default => []
-        A.preference :product_attributes, :any, :default => {}
+        A.preference :product_ids, :any, default: []
+        A.preference :product_attributes, :any, default: {}
       end
 
       it "with array" do
@@ -267,8 +261,8 @@ describe Spree::Preferences::Preferable, :type => :model do
 
       it "with hash" do
         expect(@a.preferences[:product_attributes]).to eq({})
-        @a.set_preference(:product_attributes, {:id => 1, :name => 2})
-        expect(@a.preferences[:product_attributes]).to eq({:id => 1, :name => 2})
+        @a.set_preference(:product_attributes, {id: 1, name: 2})
+        expect(@a.preferences[:product_attributes]).to eq({id: 1, name: 2})
       end
     end
 
@@ -276,7 +270,7 @@ describe Spree::Preferences::Preferable, :type => :model do
 
   describe "persisted preferables" do
     before(:all) do
-      class CreatePrefTest < ActiveRecord::Migration
+      class CreatePrefTest < ActiveRecord::Migration[4.2]
         def self.up
           create_table :pref_tests do |t|
             t.string :col
@@ -294,8 +288,8 @@ describe Spree::Preferences::Preferable, :type => :model do
       CreatePrefTest.migrate(:up)
 
       class PrefTest < Spree::Base
-        preference :pref_test_pref, :string, :default => 'abc'
-        preference :pref_test_any, :any, :default => []
+        preference :pref_test_pref, :string, default: 'abc'
+        preference :pref_test_any, :any, default: []
       end
     end
 
@@ -305,6 +299,8 @@ describe Spree::Preferences::Preferable, :type => :model do
     end
 
     before(:each) do
+      # load PrefTest table
+      PrefTest.first
       @pt = PrefTest.create
     end
 
@@ -338,7 +334,7 @@ describe Spree::Preferences::Preferable, :type => :model do
       @pt.preferred_pref_test_pref = 'lmn'
       @pt.save!
       @pt.destroy
-      @pt1 = PrefTest.new(:col => 'aaaa')
+      @pt1 = PrefTest.new(col: 'aaaa')
       @pt1.id = @pt.id
       @pt1.save!
       expect(@pt1.get_preference(:pref_test_pref)).to eq('abc')

data/spec/models/spree/preferences/scoped_store_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Preferences::ScopedStore, :type => :model do
+describe Spree::Preferences::ScopedStore, type: :model do
   let(:scoped_store){ described_class.new(prefix, suffix) }
   subject{ scoped_store }
   let(:prefix){ nil }

data/spec/models/spree/preferences/store_spec.rb

@@ -1,6 +1,6 @@
 require 'spec_helper'
 
-describe Spree::Preferences::Store, :type => :model do
+describe Spree::Preferences::Store, type: :model do
   before :each do
     @store = Spree::Preferences::StoreInstance.new
   end
@@ -17,7 +17,7 @@ describe Spree::Preferences::Store, :type => :model do
   end
 
   it "will return db value when cache is emtpy and cache the db value" do
-    preference = Spree::Preference.where(:key => 'test').first_or_initialize
+    preference = Spree::Preference.where(key: 'test').first_or_initialize
     preference.value = '123'
     preference.save
 
@@ -34,7 +34,7 @@ describe Spree::Preferences::Store, :type => :model do
 
   it "should return but not cache fallback value when persistence is disabled" do
     Rails.cache.clear
-    allow(@store).to receive_messages(:should_persist? => false)
+    allow(@store).to receive_messages(should_persist?: false)
     expect(@store.get(:test){ true }).to be true
     expect(Rails.cache.exist?(:test)).to be false
   end

data/spec/models/spree/price_spec.rb

@@ -1,6 +1,34 @@
 require 'spec_helper'
 
-describe Spree::Price, :type => :model do
+describe Spree::Price, type: :model do
+  describe '#amount=' do
+    let(:price) { Spree::Price.new }
+    let(:amount) { '3,0A0' }
+
+    before do
+      price.amount = amount
+    end
+
+    it 'is expected to equal to localized number' do
+      expect(price.amount).to eq(Spree::LocalizedNumber.parse(amount))
+    end
+  end
+
+  describe '#price' do
+    let(:price) { Spree::Price.new }
+    let(:amount) { 3000.00 }
+
+    context 'when amount is changed' do
+      before do
+        price.amount = amount
+      end
+
+      it 'is expected to equal to price' do
+        expect(price.amount).to eq(price.price)
+      end
+    end
+  end
+
   describe 'validations' do
     let(:variant) { stub_model Spree::Variant }
     subject { Spree::Price.new variant: variant, amount: amount }
@@ -39,4 +67,62 @@ describe Spree::Price, :type => :model do
       it { is_expected.to be_valid }
     end
   end
+
+  describe '#price_including_vat_for(zone)' do
+    let(:variant) { stub_model Spree::Variant }
+    let(:default_zone) { Spree::Zone.new }
+    let(:zone) { Spree::Zone.new }
+    let(:amount) { 10 }
+    let(:tax_category) { Spree::TaxCategory.new }
+    let(:price) { Spree::Price.new variant: variant, amount: amount }
+    let(:price_options) { { tax_zone: zone } }
+
+    subject(:price_with_vat) { price.price_including_vat_for(price_options) }
+
+    context 'when called with a non-default zone' do
+      before do
+        allow(variant).to receive(:tax_category).and_return(tax_category)
+        expect(price).to receive(:default_zone).at_least(:once).and_return(default_zone)
+        allow(price).to receive(:apply_foreign_vat?).and_return(true)
+        allow(price).to receive(:included_tax_amount).with(tax_zone: default_zone, tax_category: tax_category) { 0.19 }
+        allow(price).to receive(:included_tax_amount).with(tax_zone: zone, tax_category: tax_category) { 0.25 }
+      end
+
+      it "returns the correct price including another VAT to two digits" do
+        expect(price_with_vat).to eq(10.50)
+      end
+    end
+
+    context 'when called from the default zone' do
+      before do
+        allow(variant).to receive(:tax_category).and_return(tax_category)
+        expect(price).to receive(:default_zone).at_least(:once).and_return(zone)
+      end
+
+      it "returns the correct price" do
+        expect(price).to receive(:price).and_call_original
+        expect(price_with_vat).to eq(10.00)
+      end
+    end
+
+    context 'when no default zone is set' do
+      before do
+        allow(variant).to receive(:tax_category).and_return(tax_category)
+        expect(price).to receive(:default_zone).at_least(:once).and_return(nil)
+      end
+
+      it "returns the correct price" do
+        expect(price).to receive(:price).and_call_original
+        expect(price.price_including_vat_for(tax_zone: zone)).to eq(10.00)
+      end
+    end
+  end
+
+  describe '#display_price_including_vat_for(zone)' do
+    subject { Spree::Price.new amount: 10 }
+    it 'calls #price_including_vat_for' do
+      expect(subject).to receive(:price_including_vat_for)
+      subject.display_price_including_vat_for(nil)
+    end
+  end
 end

data/spec/models/spree/product/scopes_spec.rb

@@ -1,15 +1,50 @@
 require 'spec_helper'
 
-describe "Product scopes", :type => :model do
+describe "Product scopes", type: :model do
   let!(:product) { create(:product) }
 
+  describe '#available' do
+    context 'when discontinued' do
+      let!(:discontinued_product) { create(:product, discontinue_on: Time.current - 1.day) }
+
+      it { expect(Spree::Product.available).not_to include(discontinued_product) }
+    end
+
+    context 'when not discontinued' do
+      let!(:product_2) { create(:product, discontinue_on: Time.current + 1.day) }
+
+      it { expect(Spree::Product.available).to include(product_2) }
+    end
+
+    context 'when available' do
+      let!(:product_2) { create(:product, available_on: Time.current - 1.day) }
+
+      it { expect(Spree::Product.available).to include(product_2) }
+    end
+
+    context 'when not available' do
+      let!(:unavailable_product) { create(:product, available_on: Time.current + 1.day) }
+
+      it { expect(Spree::Product.available).not_to include(unavailable_product) }
+    end
+
+    context 'when multiple prices present' do
+      let!(:price_1) { create(:price, currency: 'EUR', variant: product.master) }
+      let!(:price_2) { create(:price, currency: 'EUR', variant: product.master) }
+
+      it 'should not duplicate product' do
+        expect(Spree::Product.available).to eq([product])
+      end
+    end
+  end
+
   context "A product assigned to parent and child taxons" do
     before do
       @taxonomy = create(:taxonomy)
       @root_taxon = @taxonomy.root
 
-      @parent_taxon = create(:taxon, :name => 'Parent', :taxonomy_id => @taxonomy.id, :parent => @root_taxon)
-      @child_taxon = create(:taxon, :name =>'Child 1', :taxonomy_id => @taxonomy.id, :parent => @parent_taxon)
+      @parent_taxon = create(:taxon, name: 'Parent', taxonomy_id: @taxonomy.id, parent: @root_taxon)
+      @child_taxon = create(:taxon, name:'Child 1', taxonomy_id: @taxonomy.id, parent: @parent_taxon)
       @parent_taxon.reload # Need to reload for descendents to show up
 
       product.taxons << @parent_taxon
@@ -38,7 +73,7 @@ describe "Product scopes", :type => :model do
 
       it 'after ordering changed' do
         [@child_taxon, other_taxon].each do |taxon|
-          Spree::Classification.find_by(:taxon => taxon, :product => product).insert_at(2)
+          Spree::Classification.find_by(taxon: taxon, product: product).insert_at(2)
           expect(Spree::Product.in_taxon(taxon)).to eq([product_2, product])
         end
       end

data/spec/models/spree/product_duplicator_spec.rb

@@ -2,13 +2,13 @@ require 'spec_helper'
 
 module Spree
 
-  describe Spree::ProductDuplicator, :type => :model do
+  describe Spree::ProductDuplicator, type: :model do
 
     let(:product) { create(:product, properties: [create(:property, name: "MyProperty")])}
     let!(:duplicator) { Spree::ProductDuplicator.new(product)}
 
     let(:image) { File.open(File.expand_path('../../../fixtures/thinking-cat.jpg', __FILE__)) }
-    let(:params) { {:viewable_id => product.master.id, :viewable_type => 'Spree::Variant', :attachment => image, :alt => "position 1", :position => 1} }
+    let(:params) { {viewable_id: product.master.id, viewable_type: 'Spree::Variant', attachment: image, alt: "position 1", position: 1} }
 
     before do
       Spree::Image.create(params)

data/spec/models/spree/product_filter_spec.rb

@@ -1,12 +1,12 @@
 require 'spec_helper'
 require 'spree/core/product_filters'
 
-describe 'product filters', :type => :model do
+describe 'product filters', type: :model do
   # Regression test for #1709
   context 'finds products filtered by brand' do
     let(:product) { create(:product) }
     before do
-      property = Spree::Property.create!(:name => "brand", :presentation => "brand")
+      property = Spree::Property.create!(name: "brand", presentation: "brand")
       product.set_property("brand", "Nike")
     end