rconomic 0.5.2 → 0.6.0

data/spec/economic/current_invoice_spec.rb

@@ -1,8 +1,8 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::CurrentInvoice do
   let(:session) { make_session }
-  subject { (i = Economic::CurrentInvoice.new( :id => 512 )).tap { i.session = session } }
+  subject { (i = Economic::CurrentInvoice.new(:id => 512)).tap { i.session = session } }
 
   it "inherits from Economic::Entity" do
     expect(Economic::CurrentInvoice.ancestors).to include(Economic::Entity)
@@ -38,7 +38,7 @@ describe Economic::CurrentInvoice do
         subject.date = time
         subject.attention_handle = Economic::Entity::Handle.new(:id => 42)
         subject.term_of_payment_handle = Economic::Entity::Handle.new(:id => 37)
-        subject.currency_handle = Economic::Entity::Handle.new({:code => "BTC"})
+        subject.currency_handle = Economic::Entity::Handle.new(:code => "BTC")
         subject.layout_handle = Economic::Entity::Handle.new(:id => 314)
 
         mock_request(
@@ -68,13 +68,13 @@ describe Economic::CurrentInvoice do
       end
 
       it "updates id with the created id" do
-        stub_request('CurrentInvoice_CreateFromData', nil, :success)
+        stub_request("CurrentInvoice_CreateFromData", nil, :success)
         subject.save
         expect(subject.id).to eq(42)
       end
 
       it "updates handle with the created id" do
-        stub_request('CurrentInvoice_CreateFromData', nil, :success)
+        stub_request("CurrentInvoice_CreateFromData", nil, :success)
 
         invoice = Economic::CurrentInvoice.new({})
         invoice.session = session
@@ -89,7 +89,7 @@ describe Economic::CurrentInvoice do
 
       context "when invoice has lines" do
         before :each do
-          stub_request('CurrentInvoice_CreateFromData', nil, :success)
+          stub_request("CurrentInvoice_CreateFromData", nil, :success)
 
           2.times do
             line = Economic::CurrentInvoiceLine.new
@@ -126,29 +126,29 @@ describe Economic::CurrentInvoice do
   end
 
   describe "#book" do
-    it 'should book the current invoice and return the created invoice object' do
-      stub_request('CurrentInvoice_Book', nil, :success)
-      mock_request("Invoice_GetData", {'entityHandle' => { 'Number' => 328 }}, :success)
+    it "should book the current invoice and return the created invoice object" do
+      stub_request("CurrentInvoice_Book", nil, :success)
+      mock_request("Invoice_GetData", {"entityHandle" => {"Number" => "328"}}, :success)
       expect(subject.book).to be_instance_of(Economic::Invoice)
     end
 
-    it 'should request with the right key for handle' do
-      mock_request("CurrentInvoice_Book", {'currentInvoiceHandle' => { 'Id' => 512 }}, :success)
-      stub_request('Invoice_GetData', nil, :success)
+    it "should request with the right key for handle" do
+      mock_request("CurrentInvoice_Book", {"currentInvoiceHandle" => {"Id" => 512}}, :success)
+      stub_request("Invoice_GetData", nil, :success)
       subject.book
     end
   end
 
   describe "#book_with_number" do
-    it 'should book the current invoice with the given number and return the created invoice object' do
-      stub_request('CurrentInvoice_BookWithNumber', nil, :success)
-      mock_request("Invoice_GetData", {'entityHandle' => { 'Number' => 123 }}, :success)
+    it "should book the current invoice with the given number and return the created invoice object" do
+      stub_request("CurrentInvoice_BookWithNumber", nil, :success)
+      mock_request("Invoice_GetData", {"entityHandle" => {"Number" => "123"}}, :success)
       expect(subject.book_with_number(123)).to be_instance_of(Economic::Invoice)
     end
 
-    it 'should request with the right key for handle' do
-      mock_request("CurrentInvoice_BookWithNumber", {'currentInvoiceHandle' => { 'Id' => 512 }, 'number' => 123}, :success)
-      stub_request('Invoice_GetData', nil, :success)
+    it "should request with the right key for handle" do
+      mock_request("CurrentInvoice_BookWithNumber", {"currentInvoiceHandle" => {"Id" => 512}, "number" => 123}, :success)
+      stub_request("Invoice_GetData", nil, :success)
       subject.book_with_number(123)
     end
   end
@@ -156,7 +156,7 @@ describe Economic::CurrentInvoice do
   describe "#attention" do
     let(:contact) {
       c = Economic::DebtorContact.new(
-        :handle => Economic::Entity::Handle.new({:id => 12, :number => 34})
+        :handle => Economic::Entity::Handle.new(:id => 12, :number => 34)
       )
       c.session = session
       c

data/spec/economic/debtor_contact_spec.rb

@@ -1,4 +1,4 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::DebtorContact do
   let(:session) { make_session }
@@ -43,7 +43,7 @@ describe Economic::DebtorContact do
     end
 
     context "when debtor_handle is set" do
-      let(:handle) { Economic::DebtorContact::Handle.new({:number => 42}) }
+      let(:handle) { Economic::DebtorContact::Handle.new(:number => 42) }
 
       before :each do
         subject.debtor_handle = handle
@@ -84,8 +84,8 @@ describe Economic::DebtorContact do
       end
 
       it "should clear cached debtor and fetch the new debtor from API" do
-        stub_request('Debtor_GetData', nil, :success)
-        subject.debtor_handle = Economic::Debtor::Handle.new({:number => 1234})
+        stub_request("Debtor_GetData", nil, :success)
+        subject.debtor_handle = Economic::Debtor::Handle.new(:number => 1234)
         expect(subject.debtor).to be_instance_of(Economic::Debtor)
       end
     end
@@ -112,5 +112,4 @@ describe Economic::DebtorContact do
       expect(subject.proxy.session).to eq(session)
     end
   end
-
 end

data/spec/economic/debtor_entry_spec.rb

@@ -1,4 +1,4 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::DebtorEntry do
   let(:session) { make_session }

data/spec/economic/debtor_spec.rb

@@ -1,4 +1,4 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::Debtor do
   let(:session) { make_session }
@@ -61,8 +61,8 @@ describe Economic::Debtor do
       expect(subject.invoices).to be_empty
     end
     it "returns invoices if there is a handle" do
-      mock_request('Debtor_GetInvoices', {"debtorHandle"=>{"Number"=>1}}, :success)
-      subject.handle = Economic::Entity::Handle.new({:number => "1"})
+      mock_request("Debtor_GetInvoices", {"debtorHandle" => {"Number" => "1"}}, :success)
+      subject.handle = Economic::Entity::Handle.new(:number => "1")
       subject.invoices.each do |i|
         expect(i).to be_instance_of(Economic::Invoice)
       end
@@ -74,8 +74,8 @@ describe Economic::Debtor do
       expect(subject.orders).to be_empty
     end
     it "returns invoices if there is a handle" do
-      mock_request('Debtor_GetOrders', {"debtorHandle"=>{"Number"=>1}}, :success)
-      subject.handle = Economic::Entity::Handle.new({:number => "1"})
+      mock_request("Debtor_GetOrders", {"debtorHandle" => {"Number" => "1"}}, :success)
+      subject.handle = Economic::Entity::Handle.new(:number => "1")
       subject.orders.each do |i|
         expect(i).to be_instance_of(Economic::Order)
       end
@@ -88,8 +88,8 @@ describe Economic::Debtor do
     end
 
     it "returns debtor contacts if there is a handle" do
-      mock_request('Debtor_GetDebtorContacts', {"debtorHandle"=>{"Number"=>1}}, :multiple)
-      subject.handle = Economic::Entity::Handle.new({:number => "1"})
+      mock_request("Debtor_GetDebtorContacts", {"debtorHandle" => {"Number" => "1"}}, :multiple)
+      subject.handle = Economic::Entity::Handle.new(:number => "1")
       subject.contacts.each do |contact|
         expect(contact).to be_instance_of(Economic::DebtorContact)
       end
@@ -119,8 +119,8 @@ describe Economic::Debtor do
   end
 
   describe "#save" do
-    it 'should save it' do
-      stub_request('Debtor_CreateFromData', nil, :success)
+    it "should save it" do
+      stub_request("Debtor_CreateFromData", nil, :success)
       subject.save
     end
 
@@ -143,10 +143,10 @@ describe Economic::Debtor do
         :success
       )
 
-      subject.debtor_group_handle = Economic::Entity::Handle.new({:number => 42})
-      subject.currency_handle = Economic::Entity::Handle.new({:code => 'BTC'})
-      subject.price_group_handle = Economic::Entity::Handle.new({:number => 37})
-      subject.term_of_payment_handle = Economic::Entity::Handle.new({:id => 314})
+      subject.debtor_group_handle = Economic::Entity::Handle.new(:number => 42)
+      subject.currency_handle = Economic::Entity::Handle.new(:code => "BTC")
+      subject.price_group_handle = Economic::Entity::Handle.new(:number => 37)
+      subject.term_of_payment_handle = Economic::Entity::Handle.new(:id => 314)
       subject.layout_handle = Economic::Entity::Handle.new({:id => 21})
 
       subject.save

data/spec/economic/endpoint_spec.rb

@@ -1,4 +1,4 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::Endpoint do
   subject { Economic::Endpoint.new }
@@ -11,28 +11,28 @@ describe Economic::Endpoint do
     it "uses the SOAP client to invoke a SOAP action on the API" do
       expect(client).to receive(:call).with(
         :foo_bar,
-        :message => {:baz => 'qux'}
+        :message => {:baz => "qux"}
       ).and_return({})
-      subject.call(:foo_bar, {:baz => 'qux'})
+      subject.call(:foo_bar, :baz => "qux")
     end
 
     it "sends an actual request" do
-      mock_request('Connect', nil, :success)
+      mock_request("Connect", nil, :success)
       subject.call(:connect)
     end
 
     it "returns a hash with data" do
-      stub_request('CurrentInvoice_GetAll', nil, :single)
-      expect(subject.call(:current_invoice_get_all)).to eq({:current_invoice_handle => {:id => "1"}})
+      stub_request("CurrentInvoice_GetAll", nil, :single)
+      expect(subject.call(:current_invoice_get_all)).to eq(:current_invoice_handle => {:id => "1"})
     end
 
     it "returns an empty hash if no data returned" do
-      stub_request('CurrentInvoice_GetAll', nil, :none)
+      stub_request("CurrentInvoice_GetAll", nil, :none)
       expect(subject.call(:current_invoice_get_all)).to be_empty
     end
 
     it "yields a Savon response" do
-      stub_request('CurrentInvoice_GetAll', nil, :single)
+      stub_request("CurrentInvoice_GetAll", nil, :single)
       @yielded_value = nil
       subject.call(:current_invoice_get_all) do |response|
         @yielded_value = response
@@ -71,19 +71,35 @@ describe Economic::Endpoint do
 
   describe "savon globals configuration" do
     it "sets the log_level option of the endpoint" do
-      subject.client.globals.should_receive(:log_level).with(:fatal)
+      expect(subject.client.globals).to receive(:log_level).with(:fatal)
       subject.log_level = :fatal
     end
 
     it "sets the log option of the endpoint" do
-      subject.client.globals.should_receive(:log).with(true)
+      expect(subject.client.globals).to receive(:log).with(true)
       subject.log = true
     end
 
     it "sets the logger option of the boolean" do
       logger = double("MyLogger")
-      subject.client.globals.should_receive(:logger).with(logger)
+      expect(subject.client.globals).to receive(:logger).with(logger)
       subject.logger = logger
     end
   end
+
+  describe "app identifier configuration" do
+    let(:app_id) { "my awesome app v.4.0.9-beta-rc1" }
+
+    subject {
+      described_class.new(app_id)
+    }
+
+    it "adds the app identifier HTTP headers" do
+      client = subject.client(:force_new_instance => true)
+      globals = client.globals
+      expect(
+        globals[:headers]["X-EconomicAppIdentifier"]
+      ).to eq(app_id)
+    end
+  end
 end

data/spec/economic/entity/handle_spec.rb

@@ -1,4 +1,4 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::Entity::Handle do
   describe "equality" do
@@ -56,17 +56,6 @@ describe Economic::Entity::Handle do
       end).to raise_error(ArgumentError)
     end
 
-    it "should assume :id if argument is numeric" do
-      handle = Economic::Entity::Handle.new(12)
-      expect(handle.id).to eq(12)
-      expect(handle.number).to be_nil
-    end
-
-    it "should use to_i on numeric argument" do
-      handle = Economic::Entity::Handle.new("42")
-      expect(handle.id).to eq(42)
-    end
-
     it "should raise error if argument is nil" do
       expect(lambda do
         Economic::Entity::Handle.new(nil)
@@ -95,7 +84,7 @@ describe Economic::Entity::Handle do
       expect(handle.number).to eq(42)
     end
 
-    it 'should set id1 and id2' do
+    it "should set id1 and id2" do
       handle = Economic::Entity::Handle.new(:id1 => 37, :id2 => 42)
       expect(handle.id1).to eq(37)
       expect(handle.id2).to eq(42)
@@ -104,7 +93,6 @@ describe Economic::Entity::Handle do
     it "should to_i values" do
       handle = Economic::Entity::Handle.new(:id => "37", :number => "42")
       expect(handle.id).to eq(37)
-      expect(handle.number).to eq(42)
     end
 
     it "should not to_i nil values" do
@@ -114,7 +102,7 @@ describe Economic::Entity::Handle do
     end
 
     it "should accept a Hash with capitalized keys" do
-      handle = Economic::Entity::Handle.new({"Id" => 37, "Number" => 42})
+      handle = Economic::Entity::Handle.new("Id" => 37, "Number" => 42)
       expect(handle.id).to eq(37)
       expect(handle.number).to eq(42)
     end
@@ -138,11 +126,11 @@ describe Economic::Entity::Handle do
     end
 
     it "returns nil when hash has no values" do
-      expect(Economic::Entity::Handle.build({:id => nil, :number => nil})).to be_empty
+      expect(Economic::Entity::Handle.build(:id => nil, :number => nil)).to be_empty
     end
 
     it "returns handle when hash has values" do
-      expect(Economic::Entity::Handle.build({:id2 => 42})).to eq(Economic::Entity::Handle.new({:id2 => 42}))
+      expect(Economic::Entity::Handle.build(:id2 => 42)).to eq(Economic::Entity::Handle.new(:id2 => 42))
     end
 
     it "returns a given handle" do
@@ -157,24 +145,23 @@ describe Economic::Entity::Handle do
     end
 
     it "returns false when handle has a value" do
-      expect(Economic::Entity::Handle.new({:serial_number => 12})).to_not be_empty
+      expect(Economic::Entity::Handle.new(:serial_number => 12)).to_not be_empty
     end
   end
 
   describe ".to_hash" do
-    subject { Economic::Entity::Handle.new({:id => 42, :number => 37, :serial_number => 7, :code => "USD", :name => "Bob", :vat_code => 1}) }
+    subject { Economic::Entity::Handle.new(:id => 42, :number => 37, :serial_number => 7, :code => "USD", :name => "Bob", :vat_code => 1) }
 
     it "should return a handle for putting into the body of a SOAP request" do
-      expect(subject.to_hash).to eq({'Id' => 42, 'Number' => 37, 'SerialNumber' => 7, 'Code' => 'USD', 'Name' => 'Bob', 'VatCode' => 1})
+      expect(subject.to_hash).to eq("Id" => 42, "Number" => 37, "SerialNumber" => 7, "Code" => "USD", "Name" => "Bob", "VatCode" => 1)
     end
 
     it "includes only the named value in the hash" do
-      expect(subject.to_hash(:id)).to eq({'Id' => 42})
+      expect(subject.to_hash(:id)).to eq("Id" => 42)
     end
 
     it "includes only the named values in the hash" do
-      expect(subject.to_hash([:id, :serial_number])).to eq({'Id' => 42, 'SerialNumber' => 7})
+      expect(subject.to_hash([:id, :serial_number])).to eq("Id" => 42, "SerialNumber" => 7)
     end
   end
 end
-

data/spec/economic/entity/mapper_spec.rb

@@ -1,20 +1,20 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::Entity::Mapper do
-  let(:entity) { double("Entity", {
-    :handle => Economic::Entity::Handle.new(:id => 42),
-    :creditor_handle => Economic::Entity::Handle.new(:number => 37),
-    :name => "David Brent",
-    :is_to_receive_email_copy_of_order => true
-  }) }
+  let(:entity) {
+    double("Entity", :handle => Economic::Entity::Handle.new(:id => 42),
+                     :creditor_handle => Economic::Entity::Handle.new(:number => 37),
+                     :name => "David Brent",
+                     :is_to_receive_email_copy_of_order => true)
+  }
 
   let(:fields) {
     [
-      ["Handle", :handle, Proc.new { |v| v.to_hash }, :required],
-      ["CreditorHandle", :creditor_handle, Proc.new { |v| {"Number" => v[:number] }}],
-      ["Id", :handle, Proc.new { |v| v.id }, :required],
+      ["Handle", :handle, proc { |v| v.to_hash }, :required],
+      ["CreditorHandle", :creditor_handle, proc { |v| {"Number" => v[:number]} }],
+      ["Id", :handle, proc { |v| v.id }, :required],
       ["Name", :name],
-      ["IsToReceiveEmailCopyOfOrder", :is_to_receive_email_copy_of_order, Proc.new { |v| v || false }, :required],
+      ["IsToReceiveEmailCopyOfOrder", :is_to_receive_email_copy_of_order, proc { |v| v || false }, :required]
     ]
   }
 
@@ -22,33 +22,29 @@ describe Economic::Entity::Mapper do
 
   describe "#to_hash" do
     it "returns a Hash with fields as per the field descriptions" do
-      subject.to_hash.should == {
-        "Handle" => {"Id" => 42},
-        "CreditorHandle" => {"Number" => 37},
-        "Id" => 42,
-        "Name" => "David Brent",
-        "IsToReceiveEmailCopyOfOrder" => true
-      }
+      expect(subject.to_hash).to eq("Handle" => {"Id" => 42},
+                                    "CreditorHandle" => {"Number" => 37},
+                                    "Id" => 42,
+                                    "Name" => "David Brent",
+                                    "IsToReceiveEmailCopyOfOrder" => true)
     end
   end
 
   describe "when entity has no values" do
-    let(:entity) { double("Entity", {
-      :handle => Economic::Entity::Handle.new({}),
-      :creditor_handle => nil,
-      :name => nil,
-      :number => nil,
-      :is_to_receive_email_copy_of_order => nil
-    }) }
+    let(:entity) {
+      double("Entity", :handle => Economic::Entity::Handle.new({}),
+                       :creditor_handle => nil,
+                       :name => nil,
+                       :number => nil,
+                       :is_to_receive_email_copy_of_order => nil)
+    }
 
     subject { Economic::Entity::Mapper.new(entity, fields) }
 
     it "returns the minimal set of required fields" do
-      subject.to_hash.should == {
-        "Handle" => {},
-        "Id" => nil,
-        "IsToReceiveEmailCopyOfOrder" => false
-      }
+      expect(subject.to_hash).to eq("Handle" => {},
+                                    "Id" => nil,
+                                    "IsToReceiveEmailCopyOfOrder" => false)
     end
   end
 end

data/spec/economic/entity_spec.rb

@@ -1,12 +1,17 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 class Account < Economic::Entity
   has_properties :id, :foo, :baz, :bar_handle
 
-  def build_soap_data; {:foo => "bar"}; end
+  def build_soap_data
+    {:foo => "bar"}
+  end
+
   def existing_method; end
 
-  def proxy; Economic::AccountProxy.new(session); end
+  def proxy
+    Economic::AccountProxy.new(session)
+  end
 end
 
 class Economic::AccountProxy < Economic::EntityProxy; end
@@ -33,9 +38,9 @@ describe Economic::Entity do
       end
 
       it "initializes the entity with values from the given hash" do
-        entity = Account.new(:foo => 'bar', :baz => 'qux')
-        expect(entity.foo).to eq('bar')
-        expect(entity.baz).to eq('qux')
+        entity = Account.new(:foo => "bar", :baz => "qux")
+        expect(entity.foo).to eq("bar")
+        expect(entity.baz).to eq("qux")
       end
     end
 
@@ -47,8 +52,8 @@ describe Economic::Entity do
 
     describe "has_properties" do
       it "creates getter for all properties" do
-        expect(subject).to receive(:define_method).with('name')
-        expect(subject).to receive(:define_method).with('age')
+        expect(subject).to receive(:define_method).with("name")
+        expect(subject).to receive(:define_method).with("age")
         subject.has_properties :name, :age
       end
 
@@ -73,14 +78,14 @@ describe Economic::Entity do
       end
 
       it "does not create setter or getter for id'ish properties" do
-        expect(subject).to receive(:define_method).with('id').never
-        expect(subject).to receive(:define_method).with('number').never
-        expect(subject).to receive(:define_method).with('handle').never
+        expect(subject).to receive(:define_method).with("id").never
+        expect(subject).to receive(:define_method).with("number").never
+        expect(subject).to receive(:define_method).with("handle").never
         subject.has_properties :id, :number, :handle
       end
 
       it "does clobber existing methods" do
-        expect(subject).to receive(:define_method).with('existing_method')
+        expect(subject).to receive(:define_method).with("existing_method")
         subject.has_properties :existing_method
       end
 
@@ -90,20 +95,20 @@ describe Economic::Entity do
   end
 
   describe "get_data" do
-    subject { (e = Account.new).tap { |e| e.session = session } }
+    subject { Account.new.tap { |e| e.session = session } }
 
     before :each do
     end
 
     it "fetches data from API" do
-      subject.instance_variable_set('@number', 42)
-      mock_request(:account_get_data, {'entityHandle' => {'Number' => 42}}, :success)
+      subject.instance_variable_set("@number", 42)
+      mock_request(:account_get_data, {"entityHandle" => {"Number" => 42}}, :success)
       subject.get_data
     end
 
     it "updates the entity with the response" do
       stub_request(:account_get_data, nil, :success)
-      expect(subject).to receive(:update_properties).with({:foo => 'bar', :baz => 'qux'})
+      expect(subject).to receive(:update_properties).with(:foo => "bar", :baz => "qux")
       subject.get_data
     end
 
@@ -121,7 +126,7 @@ describe Economic::Entity do
   end
 
   describe "save" do
-    subject { (e = Account.new).tap { |e| e.session = session } }
+    subject { Account.new.tap { |e| e.session = session } }
 
     context "entity has not been persisted" do
       before :each do
@@ -147,7 +152,7 @@ describe Economic::Entity do
   end
 
   describe "create" do
-    subject { (e = Account.new).tap { |e| e.persisted = false; e.session = session } }
+    subject { Account.new.tap { |e| e.persisted = false; e.session = session } }
 
     it "sends data to the API" do
       mock_request(:account_create_from_data, {"data" => {:foo => "bar"}}, :success)
@@ -157,12 +162,12 @@ describe Economic::Entity do
     it "updates handle with the number returned from API" do
       stub_request(:account_create_from_data, :any, :success)
       subject.save
-      expect(subject.number).to eq('42')
+      expect(subject.number).to eq("42")
     end
   end
 
   describe ".proxy" do
-    subject { (e = Account.new).tap { |e| e.session = session } }
+    subject { Account.new.tap { |e| e.session = session } }
 
     it "should return AccountProxy" do
       expect(subject.proxy).to be_instance_of(Economic::AccountProxy)
@@ -170,7 +175,7 @@ describe Economic::Entity do
   end
 
   describe "update" do
-    subject { (e = Account.new).tap { |e| e.persisted = true; e.session = session } }
+    subject { Account.new.tap { |e| e.persisted = true; e.session = session } }
 
     it "sends data to the API" do
       mock_request(:account_update_from_data, {"data" => {:foo => "bar"}}, :success)
@@ -179,7 +184,7 @@ describe Economic::Entity do
   end
 
   describe "destroy" do
-    subject { (e = Account.new).tap { |e| e.id = 42; e.persisted = true; e.partial = false; e.session = session } }
+    subject { Account.new.tap { |e| e.id = 42; e.persisted = true; e.partial = false; e.session = session } }
 
     it "sends data to the API" do
       mock_request(:account_delete, :any, :success)
@@ -187,7 +192,7 @@ describe Economic::Entity do
     end
 
     it "should request with the correct model and id" do
-      mock_request(:account_delete, {'accountHandle' => {'Id' => 42}}, :success)
+      mock_request(:account_delete, {"accountHandle" => {"Id" => 42}}, :success)
       subject.destroy
     end
 
@@ -199,8 +204,8 @@ describe Economic::Entity do
     end
 
     it "should return the response" do
-      expect(session).to receive(:request).and_return({ :response => true })
-      expect(subject.destroy).to eq({ :response => true })
+      expect(session).to receive(:request).and_return(:response => true)
+      expect(subject.destroy).to eq(:response => true)
     end
   end
 
@@ -209,15 +214,15 @@ describe Economic::Entity do
 
     it "sets the properties to the given values" do
       subject.class.has_properties :foo, :baz
-      expect(subject).to receive(:foo=).with('bar')
-      expect(subject).to receive(:baz=).with('qux')
-      subject.update_properties(:foo => 'bar', 'baz' => 'qux')
+      expect(subject).to receive(:foo=).with("bar")
+      expect(subject).to receive(:baz=).with("qux")
+      subject.update_properties(:foo => "bar", "baz" => "qux")
     end
 
     it "only sets known properties" do
       subject.class.has_properties :foo, :bar
-      expect(subject).to receive(:foo=).with('bar')
-      subject.update_properties(:foo => 'bar', 'baz' => 'qux')
+      expect(subject).to receive(:foo=).with("bar")
+      subject.update_properties(:foo => "bar", "baz" => "qux")
     end
   end
 
@@ -226,7 +231,7 @@ describe Economic::Entity do
     let(:other) { Account.new }
 
     context "when other is nil do" do
-      it { should_not == nil }
+      it { is_expected.not_to eq(nil) }
     end
 
     context "when both handles are empty" do

data/spec/economic/entry_spec.rb

@@ -1,4 +1,4 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::Entry do
   let(:session) { make_session }