rconomic 0.5.2 → 0.6.0

data/spec/economic/proxies/creditor_proxy_spec.rb

@@ -1,4 +1,4 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::CreditorProxy do
   let(:session) { make_session }
@@ -12,30 +12,30 @@ describe Economic::CreditorProxy do
 
   describe "find" do
     it "gets creditor data from API" do
-      mock_request('Creditor_GetData', {'entityHandle' => {'Number' => 42}}, :success)
+      mock_request("Creditor_GetData", {"entityHandle" => {"Number" => 42}}, :success)
       subject.find(42)
     end
 
     it "returns Creditor object" do
-      stub_request('Creditor_GetData', nil, :success)
+      stub_request("Creditor_GetData", nil, :success)
       expect(subject.find(42)).to be_instance_of(Economic::Creditor)
     end
   end
 
   describe "find_by_number" do
     it "can find a creditor" do
-      mock_request('Creditor_FindByNumber', {'number' => '1'}, :found)
-      result = subject.find_by_number('1')
+      mock_request("Creditor_FindByNumber", {"number" => "1"}, :found)
+      result = subject.find_by_number("1")
       expect(result).to be_instance_of(Economic::Creditor)
-      expect(result.number).to eq(1)
-      expect(result.partial).to be_true
-      expect(result.persisted).to be_true
-      expect(result.handle).to eq(Economic::Entity::Handle.new({ :number => 1 }))
+      expect(result.partial).to be_truthy
+      expect(result.persisted).to be_truthy
+      expect(result.number).to eq("1")
+      expect(result.handle).to eq(Economic::Entity::Handle.new(:number => "1"))
     end
 
     it "returns nil when there is no creditor" do
-      mock_request('Creditor_FindByNumber', {'number' => '1'}, :not_found)
-      result = subject.find_by_number('1')
+      mock_request("Creditor_FindByNumber", {"number" => "1"}, :not_found)
+      result = subject.find_by_number("1")
       expect(result).to be_nil
     end
   end
@@ -60,16 +60,16 @@ describe Economic::CreditorProxy do
 
   describe ".all" do
     it "returns a single creditor" do
-      stub_request('Creditor_GetAll', nil, :single)
-      mock_request('Creditor_GetData', {'entityHandle' => {'Number' => 1}}, :success)
+      stub_request("Creditor_GetAll", nil, :single)
+      mock_request("Creditor_GetData", {"entityHandle" => {"Number" => "1"}}, :success)
       all = subject.all
       expect(all.size).to eq(1)
       expect(all.first).to be_instance_of(Economic::Creditor)
     end
 
     it "returns multiple creditors" do
-      mock_request('Creditor_GetAll', nil, :multiple)
-      stub_request('Creditor_GetDataArray', nil, :multiple)
+      mock_request("Creditor_GetAll", nil, :multiple)
+      stub_request("Creditor_GetDataArray", nil, :multiple)
       all = subject.all
       expect(all.size).to eq(2)
       expect(all.first).to be_instance_of(Economic::Creditor)

data/spec/economic/proxies/current_invoice_line_proxy_spec.rb

@@ -1,4 +1,4 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::CurrentInvoiceLineProxy do
   let(:session) { make_session }
@@ -58,12 +58,16 @@ describe Economic::CurrentInvoiceLineProxy do
 
   describe ".find" do
     it "gets invoice_line data from API" do
-      mock_request('CurrentInvoiceLine_GetData', {'entityHandle' => {'Number' => 42}}, :success)
+      mock_request(
+        "CurrentInvoiceLine_GetData",
+        {"entityHandle" => {"Number" => 42}},
+        :success
+      )
       subject.find(42)
     end
 
     it "returns CurrentInvoiceLine object" do
-      stub_request('CurrentInvoiceLine_GetData', nil, :success)
+      stub_request("CurrentInvoiceLine_GetData", nil, :success)
       expect(subject.find(42)).to be_instance_of(Economic::CurrentInvoiceLine)
     end
   end
@@ -82,7 +86,9 @@ describe Economic::CurrentInvoiceLineProxy do
     it "can be iterated over" do
       line = Economic::CurrentInvoiceLine.new
       subject << line
-      expect(subject.all? { |l| l.is_a?(Economic::CurrentInvoiceLine) }).to be_true
+      expect(subject.all? { |l|
+        l.is_a?(Economic::CurrentInvoiceLine)
+      }).to be_truthy
     end
   end
 end

data/spec/economic/proxies/current_invoice_proxy_spec.rb

@@ -1,7 +1,6 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::CurrentInvoiceProxy do
-
   let(:session) { make_session }
   subject { Economic::CurrentInvoiceProxy.new(session) }
 
@@ -41,7 +40,9 @@ describe Economic::CurrentInvoiceProxy do
         expect(invoice.debtor_city).to eq(debtor.city)
 
         expect(invoice.debtor_handle).to eq(debtor.handle)
-        expect(invoice.term_of_payment_handle).to eq(debtor.term_of_payment_handle)
+        expect(invoice.term_of_payment_handle).to eq(
+          debtor.term_of_payment_handle
+        )
         expect(invoice.layout_handle).to eq(debtor.layout_handle)
         expect(invoice.currency_handle).to eq(debtor.currency_handle)
       end
@@ -50,12 +51,16 @@ describe Economic::CurrentInvoiceProxy do
 
   describe ".find" do
     it "gets invoice data from API" do
-      mock_request('CurrentInvoice_GetData', {'entityHandle' => {'Id' => 42}}, :success)
+      mock_request(
+        "CurrentInvoice_GetData",
+        {"entityHandle" => {"Id" => 42}},
+        :success
+      )
       subject.find(42)
     end
 
     it "returns CurrentInvoice object" do
-      stub_request('CurrentInvoice_GetData', nil, :success)
+      stub_request("CurrentInvoice_GetData", nil, :success)
       expect(subject.find(42)).to be_instance_of(Economic::CurrentInvoice)
     end
   end
@@ -65,39 +70,53 @@ describe Economic::CurrentInvoiceProxy do
     let(:unto) { Time.now }
 
     it "should be able to return a single current invoice" do
-      mock_request('CurrentInvoice_FindByDateInterval', {'first' => from.iso8601, 'last' => unto.iso8601}, :single)
-      stub_request('CurrentInvoice_GetDataArray', nil, :single)
+      mock_request(
+        "CurrentInvoice_FindByDateInterval",
+        {"first" => from.iso8601, "last" => unto.iso8601},
+        :single
+      )
+      stub_request("CurrentInvoice_GetDataArray", nil, :single)
       results = subject.find_by_date_interval(from, unto)
       expect(results.size).to eq(1)
       expect(results.first).to be_instance_of(Economic::CurrentInvoice)
     end
 
     it "should be able to return multiple invoices" do
-      mock_request('CurrentInvoice_FindByDateInterval', {'first' => from.iso8601, 'last' => unto.iso8601}, :many)
-      stub_request('CurrentInvoice_GetDataArray', nil, :multiple)
+      mock_request(
+        "CurrentInvoice_FindByDateInterval",
+        {"first" => from.iso8601, "last" => unto.iso8601},
+        :many
+      )
+      stub_request("CurrentInvoice_GetDataArray", nil, :multiple)
       results = subject.find_by_date_interval(from, unto)
       expect(results.size).to eq(2)
       expect(results.first).to be_instance_of(Economic::CurrentInvoice)
     end
 
     it "should be able to return nothing" do
-      mock_request('CurrentInvoice_FindByDateInterval', {'first' => from.iso8601, 'last' => unto.iso8601}, :none)
+      mock_request(
+        "CurrentInvoice_FindByDateInterval",
+        {"first" => from.iso8601, "last" => unto.iso8601},
+        :none
+      )
       results = subject.find_by_date_interval(from, unto)
       expect(results.size).to eq(0)
     end
-
   end
-  
-  describe ".all" do
 
+  describe ".all" do
     it "returns an empty array when there are no current invoices" do
-      stub_request('CurrentInvoice_GetAll', nil, :none)
+      stub_request("CurrentInvoice_GetAll", nil, :none)
       expect(subject.all.size).to eq(0)
     end
 
     it "finds and adds a single current invoice" do
-      stub_request('CurrentInvoice_GetAll', nil, :single)
-      mock_request('CurrentInvoice_GetData', {'entityHandle' => {'Id' => 1}}, :success)
+      stub_request("CurrentInvoice_GetAll", nil, :single)
+      mock_request(
+        "CurrentInvoice_GetData",
+        {"entityHandle" => {"Id" => 1}},
+        :success
+      )
 
       current_invoices = subject.all
       expect(current_invoices).to be_instance_of(Economic::CurrentInvoiceProxy)
@@ -107,14 +126,13 @@ describe Economic::CurrentInvoiceProxy do
     end
 
     it "adds multiple current invoices" do
-      stub_request('CurrentInvoice_GetAll', nil, :multiple)
-      stub_request('CurrentInvoice_GetDataArray', nil, :multiple)
+      stub_request("CurrentInvoice_GetAll", nil, :multiple)
+      stub_request("CurrentInvoice_GetDataArray", nil, :multiple)
 
       current_invoices = subject.all
       expect(current_invoices.size).to eq(2)
       expect(current_invoices.first).to be_instance_of(Economic::CurrentInvoice)
       expect(current_invoices.last).to be_instance_of(Economic::CurrentInvoice)
     end
-
   end
 end

data/spec/economic/proxies/debtor_contact_proxy_spec.rb

@@ -1,4 +1,4 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::DebtorContactProxy do
   let(:session) { make_session }
@@ -40,12 +40,16 @@ describe Economic::DebtorContactProxy do
 
   describe ".find" do
     it "gets contact data from API" do
-      mock_request('DebtorContact_GetData', {'entityHandle' => {'Id' => 42}}, :success)
+      mock_request(
+        "DebtorContact_GetData",
+        {"entityHandle" => {"Id" => 42}},
+        :success
+      )
       subject.find(42)
     end
 
     it "returns DebtorContact object" do
-      stub_request('DebtorContact_GetData', nil, :success)
+      stub_request("DebtorContact_GetData", nil, :success)
       expect(subject.find(42)).to be_instance_of(Economic::DebtorContact)
     end
   end
@@ -54,7 +58,7 @@ describe Economic::DebtorContactProxy do
     it "uses the FindByName command" do
       expect(Economic::Proxies::Actions::FindByName).to receive(:new).
         with(subject, "Bob").
-        and_return(lambda { "Result" })
+        and_return(-> { "Result" })
       expect(subject.find_by_name("Bob")).to eq("Result")
     end
   end

data/spec/economic/proxies/debtor_entry_proxy_spec.rb

@@ -1,4 +1,4 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::DebtorEntryProxy do
   let(:session) { make_session }
@@ -11,24 +11,32 @@ describe Economic::DebtorEntryProxy do
   end
 
   describe "#find_by_invoice_number" do
-    it 'should be able to find multiple debtor entries' do
-      mock_request("DebtorEntry_FindByInvoiceNumber", {'from' => '123', 'to' => '456'}, :many)
-      expect(subject.find_by_invoice_number('123', '456')).to eq([1, 2])
+    it "should be able to find multiple debtor entries" do
+      mock_request(
+        "DebtorEntry_FindByInvoiceNumber",
+        {"from" => "123", "to" => "456"},
+        :many
+      )
+      expect(subject.find_by_invoice_number("123", "456")).to eq([1, 2])
     end
 
-    it 'should be able to find debtor entries with one invoice id' do
-      mock_request("DebtorEntry_FindByInvoiceNumber", {'from' => '123', 'to' => '123'}, :many)
-      expect(subject.find_by_invoice_number('123')).to eq([1, 2])
+    it "should be able to find debtor entries with one invoice id" do
+      mock_request(
+        "DebtorEntry_FindByInvoiceNumber",
+        {"from" => "123", "to" => "123"},
+        :many
+      )
+      expect(subject.find_by_invoice_number("123")).to eq([1, 2])
     end
 
-    it 'should handle a single serial number in the response' do
+    it "should handle a single serial number in the response" do
       stub_request("DebtorEntry_FindByInvoiceNumber", nil, :single)
-      expect(subject.find_by_invoice_number('123')).to eq([1])
+      expect(subject.find_by_invoice_number("123")).to eq([1])
     end
   end
 
   describe "#match" do
-    it 'should match two debtor entries by serial numbers' do
+    it "should match two debtor entries by serial numbers" do
       stub_request(
         "DebtorEntry_MatchEntries",
         {:entries => {
@@ -45,7 +53,9 @@ describe Economic::DebtorEntryProxy do
 
   describe "#entity_class" do
     it "should return Economic::DebtorEntry" do
-      expect(Economic::DebtorEntryProxy.entity_class).to eq(Economic::DebtorEntry)
+      expect(
+        Economic::DebtorEntryProxy.entity_class
+      ).to eq(Economic::DebtorEntry)
     end
   end
 end

data/spec/economic/proxies/debtor_proxy_spec.rb

@@ -1,4 +1,4 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::DebtorProxy do
   let(:session) { make_session }
@@ -12,32 +12,42 @@ describe Economic::DebtorProxy do
 
   describe "find" do
     it "gets debtor data from API" do
-      mock_request('Debtor_GetData', {'entityHandle' => {'Number' => 42}}, :success)
+      mock_request(
+        "Debtor_GetData",
+        {"entityHandle" => {"Number" => 42}},
+        :success
+      )
       subject.find(42)
     end
 
     it "returns Debtor object" do
-      stub_request('Debtor_GetData', nil, :success)
+      stub_request("Debtor_GetData", nil, :success)
       expect(subject.find(42)).to be_instance_of(Economic::Debtor)
     end
   end
 
   describe "find_by_ci_number" do
     it "uses FindByCINumber on API" do
-      mock_request('Debtor_FindByCINumber', {'ciNumber' => '12345678'}, :many)
-      subject.find_by_ci_number('12345678')
+      mock_request(
+        "Debtor_FindByCINumber",
+        {"ciNumber" => "12345678"},
+        :many
+      )
+      subject.find_by_ci_number("12345678")
     end
 
     context "when many debtors exist" do
       before :each do
-        stub_request('Debtor_FindByCINumber', nil, :many)
+        stub_request("Debtor_FindByCINumber", nil, :many)
       end
 
-      let(:results) { subject.find_by_ci_number('12345678') }
+      let(:results) { subject.find_by_ci_number("12345678") }
 
       it "returns a Debtor object for each result" do
         expect(results.size).to eq(2)
-        results.all? { |result| expect(result).to be_instance_of(Economic::Debtor) }
+        results.all? { |result|
+          expect(result).to be_instance_of(Economic::Debtor)
+        }
       end
 
       it "returns partial Debtor objects" do
@@ -52,43 +62,51 @@ describe Economic::DebtorProxy do
 
   describe "find_by_number" do
     it "can find a debtor" do
-      mock_request('Debtor_FindByNumber', {'number' => '1'}, :found)
-      result = subject.find_by_number('1')
+      mock_request("Debtor_FindByNumber", {"number" => "1"}, :found)
+      result = subject.find_by_number("1")
       expect(result).to be_instance_of(Economic::Debtor)
-      expect(result.number).to eq(1)
-      expect(result.partial).to be_true
-      expect(result.persisted).to be_true
-      expect(result.handle).to eq(Economic::Entity::Handle.new({:number => 1}))
+      expect(result.partial).to be_truthy
+      expect(result.persisted).to be_truthy
+      expect(result.number).to eq("1")
+      expect(result.handle).to eq(Economic::Entity::Handle.new(:number => "1"))
     end
 
     it "returns nil when there is no debtor" do
-      mock_request('Debtor_FindByNumber', {'number' => '1'}, :not_found)
-      result = subject.find_by_number('1')
+      mock_request("Debtor_FindByNumber", {"number" => "1"}, :not_found)
+      result = subject.find_by_number("1")
       expect(result).to be_nil
     end
   end
 
   describe "find_by_telephone_and_fax_number" do
     it "can find a debtor" do
-      mock_request('Debtor_FindByTelephoneAndFaxNumber', {'telephoneAndFaxNumber' => '22334455'}, :found)
-      result = subject.find_by_telephone_and_fax_number('22334455')
+      mock_request(
+        "Debtor_FindByTelephoneAndFaxNumber",
+        {"telephoneAndFaxNumber" => "22334455"},
+        :found
+      )
+      result = subject.find_by_telephone_and_fax_number("22334455")
       expect(result).to be_instance_of(Economic::Debtor)
       expect(result.number).to eq(1)
-      expect(result.partial).to be_true
-      expect(result.persisted).to be_true
+      expect(result.partial).to be_truthy
+      expect(result.persisted).to be_truthy
     end
 
     it "returns nil when there is no debtor" do
-      mock_request('Debtor_FindByTelephoneAndFaxNumber', {'telephoneAndFaxNumber' => '22334455'}, :not_found)
-      result = subject.find_by_telephone_and_fax_number('22334455')
+      mock_request(
+        "Debtor_FindByTelephoneAndFaxNumber",
+        {"telephoneAndFaxNumber" => "22334455"},
+        :not_found
+      )
+      result = subject.find_by_telephone_and_fax_number("22334455")
       expect(result).to be_nil
     end
   end
 
   describe "next_available_number" do
     it "gets the next available debtor number from API" do
-      mock_request('Debtor_GetNextAvailableNumber', nil, :success)
-      expect(subject.next_available_number).to eq('105')
+      mock_request("Debtor_GetNextAvailableNumber", nil, :success)
+      expect(subject.next_available_number).to eq("105")
     end
   end
 
@@ -110,20 +128,24 @@ describe Economic::DebtorProxy do
     end
   end
 
-  # Complete specs in current_invoice, no point in duplicating them here, just ensuring that
-  # it handles debtors "Number" id.
+  # Complete specs in current_invoice, no point in duplicating them here, just
+  # ensuring that it handles debtors "Number" id.
   describe ".all" do
     it "returns a single debtor" do
-      mock_request('Debtor_GetAll', nil, :single)
-      mock_request('Debtor_GetData', {'entityHandle' => {'Number' => 1}}, :success)
+      mock_request("Debtor_GetAll", nil, :single)
+      mock_request(
+        "Debtor_GetData",
+        {"entityHandle" => {"Number" => "1"}},
+        :success
+      )
       all = subject.all
       expect(all.size).to eq(1)
       expect(all.first).to be_instance_of(Economic::Debtor)
     end
 
     it "returns multiple debtors" do
-      mock_request('Debtor_GetAll', nil, :multiple)
-      mock_request('Debtor_GetDataArray', :any, :multiple)
+      mock_request("Debtor_GetAll", nil, :multiple)
+      mock_request("Debtor_GetDataArray", :any, :multiple)
       all = subject.all
       expect(all.size).to eq(2)
       expect(all.first).to be_instance_of(Economic::Debtor)
@@ -131,14 +153,18 @@ describe Economic::DebtorProxy do
   end
 
   describe ".get_debtor_contacts" do
-    let(:handle) { Economic::Entity::Handle.new({:number => 1}) }
+    let(:handle) { Economic::Entity::Handle.new(:number => 1) }
     it "gets debtor contact data from API" do
-      mock_request('Debtor_GetDebtorContacts', {"debtorHandle"=>{"Number"=>1}}, :multiple)
+      mock_request(
+        "Debtor_GetDebtorContacts",
+        {"debtorHandle" => {"Number" => 1}},
+        :multiple
+      )
       subject.get_debtor_contacts(handle)
     end
 
     it "returns DebtorContact objects" do
-      stub_request('Debtor_GetDebtorContacts', nil, :multiple)
+      stub_request("Debtor_GetDebtorContacts", nil, :multiple)
       subject.get_debtor_contacts(handle).each do |d|
         expect(d).to be_instance_of(Economic::DebtorContact)
       end
@@ -146,14 +172,18 @@ describe Economic::DebtorProxy do
   end
 
   describe ".get_invoices" do
-    let(:handle) { Economic::Entity::Handle.new({:number => 1}) }
+    let(:handle) { Economic::Entity::Handle.new(:number => 1) }
     it "gets invoice data from API" do
-      mock_request('Debtor_GetInvoices', {"debtorHandle"=>{"Number"=>1}}, :success)
+      mock_request(
+        "Debtor_GetInvoices",
+        {"debtorHandle" => {"Number" => 1}},
+        :success
+      )
       subject.get_invoices(handle)
     end
 
     it "returns Invoice object" do
-      stub_request('Debtor_GetInvoices', nil, :success)
+      stub_request("Debtor_GetInvoices", nil, :success)
       subject.get_invoices(handle).each do |i|
         expect(i).to be_instance_of(Economic::Invoice)
       end
@@ -161,24 +191,35 @@ describe Economic::DebtorProxy do
   end
 
   describe ".get_order" do
-    let(:handle) { Economic::Entity::Handle.new({:number => 1}) }
+    let(:handle) { Economic::Entity::Handle.new(:number => 1) }
     it "gets invoice data from API" do
-      mock_request('Debtor_GetOrders', {"debtorHandle"=>{"Number"=>1}}, :success)
+      mock_request(
+        "Debtor_GetOrders",
+        {"debtorHandle" => {"Number" => 1}},
+        :success
+      )
       subject.get_orders(handle)
     end
 
     it "returns Order object" do
-      stub_request('Debtor_GetOrders', nil, :success)
+      stub_request("Debtor_GetOrders", nil, :success)
       subject.get_orders(handle).each do |i|
         expect(i).to be_instance_of(Economic::Order)
       end
     end
 
     it "sets the number" do
-      stub_request('Debtor_GetOrders', nil, :success)
+      stub_request("Debtor_GetOrders", nil, :success)
       subject.get_orders(handle).each do |i|
         expect(i.number).to eq(1)
       end
     end
+
+    it "returns nil if no orders are found" do
+      stub_request("Debtor_GetOrders", nil, :none)
+      expect(
+        subject.get_orders(handle)
+      ).to be_nil
+    end
   end
 end

data/spec/economic/proxies/entry_proxy_spec.rb

@@ -1,4 +1,4 @@
-require './spec/spec_helper'
+require "./spec/spec_helper"
 
 describe Economic::EntryProxy do
   let(:session) { make_session }
@@ -11,60 +11,64 @@ describe Economic::EntryProxy do
   end
 
   describe "#find_by_date_interval" do
-    it 'should be able to find multiple entries' do
+    it "should be able to find multiple entries" do
       from_date = Date.new
       to_date = Date.new
       mock_request(
         "Entry_FindByDateInterval",
-        {'fromDate' => from_date, 'toDate' => to_date},
+        {"fromDate" => from_date, "toDate" => to_date},
         :many
       )
       expect(subject.find_by_date_interval(from_date, to_date)).to eq([1, 2])
     end
 
-    it 'should handle a single serial number in the response' do
+    it "should handle a single serial number in the response" do
       stub_request("Entry_FindByDateInterval", nil, :single)
       expect(subject.find_by_date_interval(Date.new, Date.new)).to eq([1])
     end
 
-    it 'should handle an empty response' do
+    it "should handle an empty response" do
       stub_request("Entry_FindByDateInterval", nil, :none)
       expect(subject.find_by_date_interval(Date.new, Date.new)).to eq([])
     end
   end
 
   describe "#find_by_serial_number_interval" do
-    it 'should be able to find multiple entries' do
+    it "should be able to find multiple entries" do
       mock_request(
         "Entry_FindBySerialNumberInterval",
-        {'minNumber' => 123, 'maxNumber' => 456},
+        {"minNumber" => 123, "maxNumber" => 456},
         :many
       )
       expect(subject.find_by_serial_number_interval(123, 456)).to eq([1, 2])
     end
 
-    it 'should handle a single serial number in the response' do
+    it "should handle a single serial number in the response" do
       stub_request("Entry_FindBySerialNumberInterval", nil, :single)
       expect(subject.find_by_serial_number_interval(123, 456)).to eq([1])
     end
 
-    it 'should handle an empty response' do
+    it "should handle an empty response" do
       stub_request("Entry_FindBySerialNumberInterval", nil, :none)
       expect(subject.find_by_serial_number_interval(123, 456)).to eq([])
     end
   end
 
   describe "#get_last_used_serial_number" do
-    it 'returns the number' do
+    it "returns the number" do
       mock_request("Entry_GetLastUsedSerialNumber", nil, :success)
       expect(subject.get_last_used_serial_number).to eq(123)
     end
   end
 
   describe "#find" do
-    it 'should get a entry by serial number' do
-      mock_request("Entry_GetData", {'entityHandle' => { 'SerialNumber' => '123' }}, :success)
-      expect(subject.find('123')).to be_instance_of(Economic::Entry)
+    it "should get a entry by serial number" do
+      mock_request(
+        "Entry_GetData",
+        {"entityHandle" => {"SerialNumber" => "123"}},
+        :success
+      )
+      expect(subject.find("123")).to be_instance_of(Economic::Entry)
     end
   end
 
@@ -74,4 +78,3 @@ describe Economic::EntryProxy do
     end
   end
 end
-