rconomic 0.5.0 → 0.5.1

data/spec/economic/proxies/cash_book_proxy_spec.rb

@@ -8,7 +8,7 @@ describe Economic::CashBookProxy do
   describe ".new" do
 
     it "stores session" do
-      subject.session.should === session
+      expect(subject.session).to equal(session)
     end
 
   end
@@ -16,11 +16,11 @@ describe Economic::CashBookProxy do
   describe ".build" do
 
     it "instantiates a new CashBook" do
-      subject.build.should be_instance_of(Economic::CashBook)
+      expect(subject.build).to be_instance_of(Economic::CashBook)
     end
 
     it "assigns the session to the CashBook" do
-      subject.build.session.should === session
+      expect(subject.build.session).to equal(session)
     end
 
   end
@@ -28,52 +28,54 @@ describe Economic::CashBookProxy do
   describe ".all" do
 
     it "returns multiple cashbooks" do
-      savon.stubs('CashBook_GetAll').returns(:multiple)
-      savon.stubs('CashBook_GetDataArray').returns(:multiple)
+      stub_request('CashBook_GetAll', nil, :multiple)
+      stub_request('CashBook_GetDataArray', nil, :multiple)
 
       all = subject.all
-      all.size.should == 2
-      all.each { |cash_book| cash_book.should be_instance_of(Economic::CashBook) }
+      expect(all.size).to eq(2)
+      all.each { |cash_book| expect(cash_book).to be_instance_of(Economic::CashBook) }
     end
 
     it "properly fills out handles of cash books" do
       # Issue #12
-      savon.stubs('CashBook_GetAll').returns(:multiple)
-      savon.stubs('CashBook_GetData').returns(:success)
-      savon.stubs('CashBook_GetDataArray').returns(:multiple)
+      stub_request('CashBook_GetAll', nil, :multiple)
+      stub_request('CashBook_GetDataArray', nil, :multiple)
+      stub_request('CashBook_GetData', nil, :success)
+      stub_request('CashBook_GetAll', nil, :multiple)
+      stub_request('CashBook_GetDataArray', nil, :multiple)
 
       cash_book = subject.find(subject.all.first.handle)
-      subject.all.first.handle.should == cash_book.handle
+      expect(subject.all.first.handle).to eq(cash_book.handle)
     end
   end
 
   describe ".get_name" do
 
     it 'returns a cash book with a name' do
-      savon.expects('CashBook_GetName').with("cashBookHandle" => { "Number" => "52" }).returns(:success)
+      mock_request('CashBook_GetName', {"cashBookHandle" => { "Number" => "52" }}, :success)
       result = subject.get_name("52")
-      result.should be_instance_of(Economic::CashBook)
-      result.number.should == "52"
-      result.name.should be_a(String)
+      expect(result).to be_instance_of(Economic::CashBook)
+      expect(result.number).to eq("52")
+      expect(result.name).to be_a(String)
     end
 
   end
 
   describe "#last" do
     it "returns the last cash book" do
-      savon.stubs('CashBook_GetAll').returns(:multiple)
-      savon.stubs('CashBook_GetDataArray').returns(:multiple)
+      stub_request('CashBook_GetAll', nil, :multiple)
+      stub_request('CashBook_GetDataArray', nil, :multiple)
 
-      subject.all.last.name.should == "Another cash book"
+      expect(subject.all.last.name).to eq("Another cash book")
     end
   end
 
   describe "#[]" do
     it "returns the specific cash book" do
-      savon.stubs('CashBook_GetAll').returns(:multiple)
-      savon.stubs('CashBook_GetDataArray').returns(:multiple)
+      stub_request('CashBook_GetAll', nil, :multiple)
+      stub_request('CashBook_GetDataArray', nil, :multiple)
 
-      subject.all[1].name.should == "Another cash book"
+      expect(subject.all[1].name).to eq("Another cash book")
     end
   end
 end

data/spec/economic/proxies/creditor_contact_proxy_spec.rb

@@ -6,21 +6,21 @@ describe Economic::CreditorContactProxy do
 
   describe ".new" do
     it "stores session" do
-      subject.session.should === session
+      expect(subject.session).to equal(session)
     end
   end
 
   describe ".build" do
     it "instantiates a new CreditorContact" do
-      subject.build.should be_instance_of(Economic::CreditorContact)
+      expect(subject.build).to be_instance_of(Economic::CreditorContact)
     end
 
     it "assigns the session to the CreditorContact" do
-      subject.build.session.should === session
+      expect(subject.build.session).to equal(session)
     end
 
     it "should not build a partial CreditorContact" do
-      subject.build.should_not be_partial
+      expect(subject.build).to_not be_partial
     end
 
     context "when owner is a Creditor" do
@@ -28,38 +28,34 @@ describe Economic::CreditorContactProxy do
       subject { creditor.contacts }
 
       it "should use the Creditors session" do
-        subject.build.session.should == creditor.session
+        expect(subject.build.session).to eq(creditor.session)
       end
 
       it "should initialize with values from Creditor" do
         contact = subject.build
-        contact.creditor_handle.should == creditor.handle
+        expect(contact.creditor_handle).to eq(creditor.handle)
       end
     end
   end
 
   describe ".find" do
-    before :each do
-      savon.stubs('CreditorContact_GetData').returns(:success)
-    end
-
     it "gets contact data from API" do
-      savon.expects('CreditorContact_GetData').with('entityHandle' => {'Id' => 42}).returns(:success)
+      mock_request('CreditorContact_GetData', {'entityHandle' => {'Id' => 42}}, :success)
       subject.find(42)
     end
 
     it "returns CreditorContact object" do
-      subject.find(42).should be_instance_of(Economic::CreditorContact)
+      stub_request('CreditorContact_GetData', nil, :success)
+      expect(subject.find(42)).to be_instance_of(Economic::CreditorContact)
     end
   end
 
   describe "#find_by_name" do
     it "uses the FindByName command" do
-      Economic::Proxies::Actions::FindByName.expects(:new).
+      expect(Economic::Proxies::Actions::FindByName).to receive(:new).
         with(subject, "Bob").
-        returns(lambda { "Result" })
-      subject.find_by_name("Bob").should == "Result"
+        and_return(lambda { "Result" })
+      expect(subject.find_by_name("Bob")).to eq("Result")
     end
   end
 end
-

data/spec/economic/proxies/creditor_entry_proxy_spec.rb

@@ -6,44 +6,48 @@ describe Economic::CreditorEntryProxy do
 
   describe "new" do
     it "stores session" do
-      subject.session.should === session
+      expect(subject.session).to equal(session)
     end
   end
 
   describe "#find_by_invoice_number" do
     it 'should be able to find multiple creditor entries' do
-      savon.expects("CreditorEntry_FindByInvoiceNumber").with('invoiceNumber' => '123').returns(:many)
-      subject.find_by_invoice_number('123').should == [1, 2]
+      mock_request("CreditorEntry_FindByInvoiceNumber", {'invoiceNumber' => '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
-      savon.stubs("CreditorEntry_FindByInvoiceNumber").returns(:single)
-      subject.find_by_invoice_number('123').should == [1]
+      stub_request("CreditorEntry_FindByInvoiceNumber", nil, :single)
+      expect(subject.find_by_invoice_number('123')).to eq([1])
     end
   end
 
   describe "#find" do
     it 'should get a creditor entry by serial number' do
-      savon.expects("CreditorEntry_GetData").with('entityHandle' => { 'SerialNumber' => '123' }).returns(:success)
-      subject.find('123').should be_instance_of(Economic::CreditorEntry)
+      mock_request("CreditorEntry_GetData", {'entityHandle' => { 'SerialNumber' => '123' }}, :success)
+      expect(subject.find('123')).to be_instance_of(Economic::CreditorEntry)
     end
   end
 
   describe "#match" do
     it 'should match two creditor entries by serial numbers' do
-      savon.stubs("CreditorEntry_MatchEntries").with(
-        :entries => [
-          { :creditor_entry_handle => { :serial_number => 1 } },
-          { :credior_entry_handle => { :serial_number => 2 } }
-        ]
-      ).returns(:success)
+      stub_request(
+        "CreditorEntry_MatchEntries",
+        {:entries => {
+          "CreditorEntryHandle" => [
+            {"SerialNumber"=>1},
+            {"SerialNumber"=>2}
+          ]
+        }},
+        :success
+      )
       subject.match(1, 2)
     end
   end
 
   describe "#entity_class" do
     it "should return Economic::CreditorEntry" do
-      Economic::CreditorEntryProxy.entity_class.should == Economic::CreditorEntry
+      expect(Economic::CreditorEntryProxy.entity_class).to eq(Economic::CreditorEntry)
     end
   end
 end

data/spec/economic/proxies/creditor_proxy_spec.rb

@@ -6,40 +6,37 @@ describe Economic::CreditorProxy do
 
   describe "new" do
     it "stores session" do
-      subject.session.should === session
+      expect(subject.session).to equal(session)
     end
   end
 
   describe "find" do
-    before :each do
-      savon.stubs('Creditor_GetData').returns(:success)
-    end
-
     it "gets creditor data from API" do
-      savon.expects('Creditor_GetData').with('entityHandle' => {'Number' => 42}).returns(:success)
+      mock_request('Creditor_GetData', {'entityHandle' => {'Number' => 42}}, :success)
       subject.find(42)
     end
 
     it "returns Creditor object" do
-      subject.find(42).should be_instance_of(Economic::Creditor)
+      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
-      savon.expects('Creditor_FindByNumber').with('number' => '1').returns(:found)
+      mock_request('Creditor_FindByNumber', {'number' => '1'}, :found)
       result = subject.find_by_number('1')
-      result.should be_instance_of(Economic::Creditor)
-      result.number.should == 1
-      result.partial.should be_true
-      result.persisted.should be_true
-      result.handle.should == Economic::Entity::Handle.new({ :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 }))
     end
 
     it "returns nil when there is no creditor" do
-      savon.expects('Creditor_FindByNumber').with('number' => '1').returns(:not_found)
+      mock_request('Creditor_FindByNumber', {'number' => '1'}, :not_found)
       result = subject.find_by_number('1')
-      result.should be_nil
+      expect(result).to be_nil
     end
   end
 
@@ -47,35 +44,35 @@ describe Economic::CreditorProxy do
     subject { session.creditors.build }
 
     it "instantiates a new Creditor" do
-      subject.should be_instance_of(Economic::Creditor)
+      expect(subject).to be_instance_of(Economic::Creditor)
     end
 
     it "assigns the session to the Creditor" do
-      subject.session.should === session
+      expect(subject.session).to equal(session)
     end
   end
 
   describe "#entity_class" do
     it "should return Economic::Creditor" do
-      Economic::CreditorProxy.entity_class.should == Economic::Creditor
+      expect(Economic::CreditorProxy.entity_class).to eq(Economic::Creditor)
     end
   end
 
   describe ".all" do
     it "returns a single creditor" do
-      savon.expects('Creditor_GetAll').returns(:single)
-      savon.expects('Creditor_GetData').with('entityHandle' => {'Number' => 1}).returns(:success)
+      stub_request('Creditor_GetAll', nil, :single)
+      mock_request('Creditor_GetData', {'entityHandle' => {'Number' => 1}}, :success)
       all = subject.all
-      all.size.should == 1
-      all.first.should be_instance_of(Economic::Creditor)
+      expect(all.size).to eq(1)
+      expect(all.first).to be_instance_of(Economic::Creditor)
     end
 
     it "returns multiple creditors" do
-      savon.expects('Creditor_GetAll').returns(:multiple)
-      savon.expects('Creditor_GetDataArray').returns(:multiple)
+      mock_request('Creditor_GetAll', nil, :multiple)
+      stub_request('Creditor_GetDataArray', nil, :multiple)
       all = subject.all
-      all.size.should == 2
-      all.first.should be_instance_of(Economic::Creditor)
+      expect(all.size).to eq(2)
+      expect(all.first).to be_instance_of(Economic::Creditor)
     end
   end
 end

data/spec/economic/proxies/current_invoice_line_proxy_spec.rb

@@ -7,11 +7,11 @@ describe Economic::CurrentInvoiceLineProxy do
 
   describe "new" do
     it "stores owner" do
-      subject.owner.should == invoice
+      expect(subject.owner).to eq(invoice)
     end
 
     it "stores session" do
-      subject.session.should == invoice.session
+      expect(subject.session).to eq(invoice.session)
     end
   end
 
@@ -20,72 +20,69 @@ describe Economic::CurrentInvoiceLineProxy do
       line = Economic::CurrentInvoiceLine.new
       subject.append(line)
       subject.append(line)
-      subject.size.should == 1
+      expect(subject.size).to eq(1)
     end
   end
 
   describe ".build" do
     it "instantiates a new CurrentInvoiceLine" do
-      subject.build.should be_instance_of(Economic::CurrentInvoiceLine)
+      expect(subject.build).to be_instance_of(Economic::CurrentInvoiceLine)
     end
 
     it "assigns the session to the CurrentInvoiceLine" do
-      subject.build.session.should == session
+      expect(subject.build.session).to eq(session)
     end
 
     it "should not build a partial CurrentInvoiceLine" do
-      subject.build.should_not be_partial
+      expect(subject.build).to_not be_partial
     end
 
     it "adds the built line to proxy items" do
-      line = subject.build
-      subject.first.should == line
+      line = subject.build(:number => 5)
+      expect(subject.first).to eq(line)
     end
 
     context "when owner is a CurrentInvoice" do
       subject { invoice.lines }
 
       it "should use the Debtors session" do
-        subject.build.session.should == invoice.session
+        expect(subject.build.session).to eq(invoice.session)
       end
 
       it "should initialize with values from CurrentInvoice" do
         invoice_line = subject.build
-        invoice_line.invoice_handle.should == invoice.handle
+        expect(invoice_line.invoice_handle).to eq(invoice.handle)
       end
     end
   end
 
   describe ".find" do
-    before :each do
-      savon.stubs('CurrentInvoiceLine_GetData').returns(:success)
-    end
-
     it "gets invoice_line data from API" do
-      savon.expects('CurrentInvoiceLine_GetData').with('entityHandle' => {'Number' => 42}).returns(:success)
+      mock_request('CurrentInvoiceLine_GetData', {'entityHandle' => {'Number' => 42}}, :success)
       subject.find(42)
     end
 
     it "returns CurrentInvoiceLine object" do
-      subject.find(42).should be_instance_of(Economic::CurrentInvoiceLine)
+      stub_request('CurrentInvoiceLine_GetData', nil, :success)
+      expect(subject.find(42)).to be_instance_of(Economic::CurrentInvoiceLine)
     end
   end
 
   describe "enumerable" do
     it "can be empty" do
-      subject.should be_empty
+      expect(subject).to be_empty
     end
 
     it "can be appended to" do
-      line = Economic::CurrentInvoiceLine.new
+      line = Economic::CurrentInvoiceLine.new(:number => 5)
       subject << line
-      subject.last.should == line
+      expect(subject.last).to eq(line)
     end
 
     it "can be iterated over" do
       line = Economic::CurrentInvoiceLine.new
       subject << line
-      subject.all? { |l| l.is_a?(Economic::CurrentInvoiceLine) }.should be_true
+      expect(subject.all? { |l| l.is_a?(Economic::CurrentInvoiceLine) }).to be_true
     end
   end
 end

data/spec/economic/proxies/current_invoice_proxy_spec.rb

@@ -7,21 +7,21 @@ describe Economic::CurrentInvoiceProxy do
 
   describe ".new" do
     it "stores session" do
-      subject.session.should === session
+      expect(subject.session).to equal(session)
     end
   end
 
   describe ".build" do
     it "instantiates a new CurrentInvoice" do
-      subject.build.should be_instance_of(Economic::CurrentInvoice)
+      expect(subject.build).to be_instance_of(Economic::CurrentInvoice)
     end
 
     it "assigns the session to the CurrentInvoice" do
-      subject.build.session.should === session
+      expect(subject.build.session).to equal(session)
     end
 
     it "should not build a partial CurrentInvoice" do
-      subject.build.should_not be_partial
+      expect(subject.build).to_not be_partial
     end
 
     context "when owner is a Debtor" do
@@ -29,37 +29,34 @@ describe Economic::CurrentInvoiceProxy do
       subject { debtor.current_invoices }
 
       it "should use the Debtors session" do
-        subject.build.session.should == debtor.session
+        expect(subject.build.session).to eq(debtor.session)
       end
 
       it "should initialize with values from Debtor" do
         invoice = subject.build
 
-        invoice.debtor_name.should == debtor.name
-        invoice.debtor_address.should == debtor.address
-        invoice.debtor_postal_code.should == debtor.postal_code
-        invoice.debtor_city.should == debtor.city
+        expect(invoice.debtor_name).to eq(debtor.name)
+        expect(invoice.debtor_address).to eq(debtor.address)
+        expect(invoice.debtor_postal_code).to eq(debtor.postal_code)
+        expect(invoice.debtor_city).to eq(debtor.city)
 
-        invoice.debtor_handle.should == debtor.handle
-        invoice.term_of_payment_handle.should == debtor.term_of_payment_handle
-        invoice.layout_handle.should == debtor.layout_handle
-        invoice.currency_handle.should == debtor.currency_handle
+        expect(invoice.debtor_handle).to eq(debtor.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
     end
   end
 
   describe ".find" do
-    before :each do
-      savon.stubs('CurrentInvoice_GetData').returns(:success)
-    end
-
     it "gets invoice data from API" do
-      savon.expects('CurrentInvoice_GetData').with('entityHandle' => {'Id' => 42}).returns(:success)
+      mock_request('CurrentInvoice_GetData', {'entityHandle' => {'Id' => 42}}, :success)
       subject.find(42)
     end
 
     it "returns CurrentInvoice object" do
-      subject.find(42).should be_instance_of(Economic::CurrentInvoice)
+      stub_request('CurrentInvoice_GetData', nil, :success)
+      expect(subject.find(42)).to be_instance_of(Economic::CurrentInvoice)
     end
   end
 
@@ -68,25 +65,25 @@ describe Economic::CurrentInvoiceProxy do
     let(:unto) { Time.now }
 
     it "should be able to return a single current invoice" do
-      savon.expects('CurrentInvoice_FindByDateInterval').with('first' => from.iso8601, 'last' => unto.iso8601).returns(:single)
-      savon.expects('CurrentInvoice_GetDataArray').returns(: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)
-      results.size.should == 1
-      results.first.should be_instance_of(Economic::CurrentInvoice)
+      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
-      savon.expects('CurrentInvoice_FindByDateInterval').with('first' => from.iso8601, 'last' => unto.iso8601).returns(:many)
-      savon.expects('CurrentInvoice_GetDataArray').returns(: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)
-      results.size.should == 2
-      results.first.should be_instance_of(Economic::CurrentInvoice)
+      expect(results.size).to eq(2)
+      expect(results.first).to be_instance_of(Economic::CurrentInvoice)
     end
 
     it "should be able to return nothing" do
-      savon.expects('CurrentInvoice_FindByDateInterval').with('first' => from.iso8601, 'last' => unto.iso8601).returns(:none)
+      mock_request('CurrentInvoice_FindByDateInterval', {'first' => from.iso8601, 'last' => unto.iso8601}, :none)
       results = subject.find_by_date_interval(from, unto)
-      results.size.should == 0
+      expect(results.size).to eq(0)
     end
 
   end
@@ -94,29 +91,29 @@ describe Economic::CurrentInvoiceProxy do
   describe ".all" do
 
     it "returns an empty array when there are no current invoices" do
-      savon.expects('CurrentInvoice_GetAll').returns(:none)
-      subject.all.size.should == 0
+      stub_request('CurrentInvoice_GetAll', nil, :none)
+      expect(subject.all.size).to eq(0)
     end
 
     it "finds and adds a single current invoice" do
-      savon.expects('CurrentInvoice_GetAll').returns(:single)
-      savon.expects('CurrentInvoice_GetData').with('entityHandle' => {'Id' => 1}).returns(:success)
+      stub_request('CurrentInvoice_GetAll', nil, :single)
+      mock_request('CurrentInvoice_GetData', {'entityHandle' => {'Id' => 1}}, :success)
 
       current_invoices = subject.all
-      current_invoices.should be_instance_of(Economic::CurrentInvoiceProxy)
+      expect(current_invoices).to be_instance_of(Economic::CurrentInvoiceProxy)
 
-      current_invoices.size.should == 1
-      current_invoices.first.should be_instance_of(Economic::CurrentInvoice)
+      expect(current_invoices.size).to eq(1)
+      expect(current_invoices.first).to be_instance_of(Economic::CurrentInvoice)
     end
 
     it "adds multiple current invoices" do
-      savon.expects('CurrentInvoice_GetAll').returns(:multiple)
-      savon.expects('CurrentInvoice_GetDataArray').returns(:multiple)
+      stub_request('CurrentInvoice_GetAll', nil, :multiple)
+      stub_request('CurrentInvoice_GetDataArray', nil, :multiple)
 
       current_invoices = subject.all
-      current_invoices.size.should == 2
-      current_invoices.first.should be_instance_of(Economic::CurrentInvoice)
-      current_invoices.last.should be_instance_of(Economic::CurrentInvoice)
+      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