rconomic 0.5.0 → 0.5.1

data/spec/economic/entity_spec.rb

@@ -1,223 +1,229 @@
 require './spec/spec_helper'
 
-class SpecEntity < Economic::Entity
-  has_properties :id, :foo, :baz
+class Account < Economic::Entity
+  has_properties :id, :foo, :baz, :bar_handle
 
-  def build_soap_data; {}; end
+  def build_soap_data; {:foo => "bar"}; end
   def existing_method; end
 
-  def proxy; Economic::SpecEntityProxy.new(session); end
+  def proxy; Economic::AccountProxy.new(session); end
 end
 
-class Economic::SpecEntityProxy < Economic::EntityProxy; end
+class Economic::AccountProxy < Economic::EntityProxy; end
 
 describe Economic::Entity do
   let(:session) { make_session }
 
   describe "class methods" do
-    subject { SpecEntity }
+    subject { Account }
 
     describe "new" do
       subject { Economic::Entity.new }
 
       it "creates a new instance" do
-        subject.should be_instance_of(Economic::Entity)
+        expect(subject).to be_instance_of(Economic::Entity)
       end
 
       it "sets persisted to false" do
-        subject.should_not be_persisted
+        expect(subject).to_not be_persisted
       end
 
       it "sets partial to true" do
-        subject.should be_partial
+        expect(subject).to be_partial
       end
 
       it "initializes the entity with values from the given hash" do
-        entity = SpecEntity.new(:foo => 'bar', :baz => 'qux')
-        entity.foo.should == 'bar'
-        entity.baz.should == 'qux'
+        entity = Account.new(:foo => 'bar', :baz => 'qux')
+        expect(entity.foo).to eq('bar')
+        expect(entity.baz).to eq('qux')
       end
     end
 
     describe "properties_not_triggering_full_load" do
       it "returns names of special id'ish properties" do
-        subject.properties_not_triggering_full_load.should == [:id, :number, :handle]
+        expect(subject.properties_not_triggering_full_load).to eq([:id, :number, :handle])
       end
     end
 
     describe "has_properties" do
       it "creates getter for all properties" do
-        subject.expects(:define_method).with('name')
-        subject.expects(: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
 
       it "creates setter for all properties" do
-        subject.expects(:attr_writer).with(:name)
-        subject.expects(:attr_writer).with(:age)
+        expect(subject).to receive(:attr_writer).with(:name)
+        expect(subject).to receive(:attr_writer).with(:age)
         subject.has_properties :name, :age
       end
 
+      describe "setter for handles" do
+        subject { Account.new }
+
+        it "accepts a Handle" do
+          subject.bar_handle = Economic::Entity::Handle.new(:id => 2)
+          expect(subject.bar_handle.id).to eq(2)
+        end
+
+        it "converts Hash input to Handle" do
+          subject.bar_handle = {:id => 1}
+          expect(subject.bar_handle).to eq(Economic::Entity::Handle.new(:id => 1))
+        end
+      end
+
       it "does not create setter or getter for id'ish properties" do
-        subject.expects(:define_method).with('id').never
-        subject.expects(:define_method).with('number').never
-        subject.expects(: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
-        subject.expects(:define_method).with('existing_method')
+        expect(subject).to receive(:define_method).with('existing_method')
         subject.has_properties :existing_method
       end
 
       describe "properties created with has_properties" do
       end
     end
-
-    describe "soap_action" do
-      it "returns the name for the given soap action on this class" do
-        subject.soap_action_name(:get_data).should == :spec_entity_get_data
-
-        class Car < Economic::Entity; end
-        Car.soap_action_name(:start_engine).should == :car_start_engine
-        Car.soap_action_name('StartEngine').should == :car_start_engine
-      end
-    end
   end
 
   describe "get_data" do
-    subject { (e = SpecEntity.new).tap { |e| e.session = session } }
+    subject { (e = Account.new).tap { |e| e.session = session } }
 
     before :each do
-      savon.stubs(:spec_entity_get_data).returns(:success)
     end
 
     it "fetches data from API" do
       subject.instance_variable_set('@number', 42)
-      savon.expects(:spec_entity_get_data).with('entityHandle' => {'Number' => 42}).returns(:success)
+      mock_request(:account_get_data, {'entityHandle' => {'Number' => 42}}, :success)
       subject.get_data
     end
 
     it "updates the entity with the response" do
-      subject.expects(:update_properties).with({:foo => 'bar', :baz => 'qux'})
+      stub_request(:account_get_data, nil, :success)
+      expect(subject).to receive(:update_properties).with({:foo => 'bar', :baz => 'qux'})
       subject.get_data
     end
 
     it "sets partial to false" do
+      stub_request(:account_get_data, nil, :success)
       subject.get_data
-      subject.should_not be_partial
+      expect(subject).to_not be_partial
     end
 
     it "sets persisted to true" do
+      stub_request(:account_get_data, nil, :success)
       subject.get_data
-      subject.should be_persisted
+      expect(subject).to be_persisted
     end
   end
 
   describe "save" do
-    subject { (e = SpecEntity.new).tap { |e| e.session = session } }
+    subject { (e = Account.new).tap { |e| e.session = session } }
 
     context "entity has not been persisted" do
       before :each do
-        subject.stubs(:persisted?).returns(false)
+        allow(subject).to receive(:persisted?).and_return(false)
       end
 
       it "creates the entity" do
-        subject.expects(:create)
+        expect(subject).to receive(:create)
         subject.save
       end
     end
 
     context "entity has already been persisted" do
       before :each do
-        subject.stubs(:persisted?).returns(true)
+        allow(subject).to receive(:persisted?).and_return(true)
       end
 
       it "updates the entity" do
-        subject.expects(:update)
+        expect(subject).to receive(:update)
         subject.save
       end
     end
   end
 
   describe "create" do
-    subject { (e = SpecEntity.new).tap { |e| e.persisted = false; e.session = session } }
+    subject { (e = Account.new).tap { |e| e.persisted = false; e.session = session } }
 
     it "sends data to the API" do
-      savon.expects(:spec_entity_create_from_data).returns(:success)
+      mock_request(:account_create_from_data, {"data" => {:foo => "bar"}}, :success)
       subject.save
     end
 
     it "updates handle with the number returned from API" do
-      savon.expects(:spec_entity_create_from_data).returns(:success)
+      stub_request(:account_create_from_data, :any, :success)
       subject.save
-      subject.number.should == '42'
+      expect(subject.number).to eq('42')
     end
   end
 
   describe ".proxy" do
-    subject { (e = SpecEntity.new).tap { |e| e.session = session } }
+    subject { (e = Account.new).tap { |e| e.session = session } }
 
-    it "should return SpecEntityProxy" do
-      subject.proxy.should be_instance_of(Economic::SpecEntityProxy)
+    it "should return AccountProxy" do
+      expect(subject.proxy).to be_instance_of(Economic::AccountProxy)
     end
   end
 
   describe "update" do
-    subject { (e = SpecEntity.new).tap { |e| e.persisted = true; e.session = session } }
+    subject { (e = Account.new).tap { |e| e.persisted = true; e.session = session } }
 
     it "sends data to the API" do
-      savon.expects(:spec_entity_update_from_data).returns(:success)
+      mock_request(:account_update_from_data, {"data" => {:foo => "bar"}}, :success)
       subject.save
     end
   end
 
   describe "destroy" do
-    subject { (e = SpecEntity.new).tap { |e| e.id = 42; e.persisted = true; e.partial = false; e.session = session } }
+    subject { (e = Account.new).tap { |e| e.id = 42; e.persisted = true; e.partial = false; e.session = session } }
 
     it "sends data to the API" do
-      savon.expects(:spec_entity_delete).returns(:success)
+      mock_request(:account_delete, :any, :success)
       subject.destroy
     end
 
     it "should request with the correct model and id" do
-      savon.expects(:spec_entity_delete).with('specEntityHandle' => {'Id' => 42}).returns(:success)
+      mock_request(:account_delete, {'accountHandle' => {'Id' => 42}}, :success)
       subject.destroy
     end
 
     it "should mark the entity as not persisted and partial" do
-      savon.expects(:spec_entity_delete).returns(:success)
+      mock_request(:account_delete, :any, :success)
       subject.destroy
-      subject.should_not be_persisted
-      subject.should be_partial
+      expect(subject).to_not be_persisted
+      expect(subject).to be_partial
     end
 
     it "should return the response" do
-      session.expects(:request).returns({ :response => true })
-      subject.destroy.should == { :response => true }
+      expect(session).to receive(:request).and_return({ :response => true })
+      expect(subject.destroy).to eq({ :response => true })
     end
   end
 
   describe "update_properties" do
-    subject { SpecEntity.new }
+    subject { Account.new }
 
     it "sets the properties to the given values" do
       subject.class.has_properties :foo, :baz
-      subject.expects(:foo=).with('bar')
-      subject.expects(:baz=).with('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
-      subject.expects(:foo=).with('bar')
+      expect(subject).to receive(:foo=).with('bar')
       subject.update_properties(:foo => 'bar', 'baz' => 'qux')
     end
   end
 
   describe "equality" do
-    subject { SpecEntity.new }
-    let(:other) { SpecEntity.new }
+    subject { Account.new }
+    let(:other) { Account.new }
 
     context "when other is nil do" do
       it { should_not == nil }
@@ -228,21 +234,21 @@ describe Economic::Entity do
         subject.handle = Economic::Entity::Handle.new({})
         other.handle = Economic::Entity::Handle.new({})
 
-        subject.should_not == other
+        expect(subject).not_to eq(other)
       end
     end
 
     context "when self handle isn't present" do
       it "returns false" do
         subject.handle = nil
-        subject.should_not == other
+        expect(subject).not_to eq(other)
       end
     end
 
     context "when other handle isn't present" do
       it "returns false" do
         other.handle = nil
-        subject.should_not == other
+        expect(subject).not_to eq(other)
       end
     end
 
@@ -253,22 +259,22 @@ describe Economic::Entity do
       context "when other is another class" do
         it "should return false" do
           other = Economic::CashBook.new(:handle => handle)
-          subject.should_not == other
+          expect(subject).not_to eq(other)
         end
       end
 
       context "when other is same class" do
         it "should return true" do
           other = Economic::Debtor.new(:handle => handle)
-          subject.should == other
+          expect(subject).to eq(other)
         end
       end
 
       context "when other is child class" do
         it "should return true" do
           one = Economic::Entity.new(:handle => handle)
-          other = SpecEntity.new(:handle => handle)
-          one.should == other
+          other = Account.new(:handle => handle)
+          expect(one).to eq(other)
         end
       end
     end

data/spec/economic/entry_spec.rb

@@ -5,16 +5,16 @@ describe Economic::Entry do
   subject { Economic::Entry.new(:session => session) }
 
   it "inherits from Economic::Entity" do
-    Economic::Entry.ancestors.should include(Economic::Entity)
+    expect(Economic::Entry.ancestors).to include(Economic::Entity)
   end
 
   describe ".proxy" do
     it "should return a EntryProxy" do
-      subject.proxy.should be_instance_of(Economic::EntryProxy)
+      expect(subject.proxy).to be_instance_of(Economic::EntryProxy)
     end
 
     it "should return a proxy owned by session" do
-      subject.proxy.session.should == session
+      expect(subject.proxy.session).to eq(session)
     end
   end
 end

data/spec/economic/invoice_spec.rb

@@ -5,64 +5,83 @@ describe Economic::Invoice do
   subject { Economic::Invoice.new(:session => session, :number => 512) }
 
   it "inherits from Economic::Entity" do
-    Economic::Invoice.ancestors.should include(Economic::Entity)
+    expect(Economic::Invoice.ancestors).to include(Economic::Entity)
   end
 
   describe '#remainder' do
     it 'should get the remainder' do
-      savon.expects('Invoice_GetRemainder').with("invoiceHandle" => { "Number" => 512 }).returns(:success)
-      subject.remainder.should == "512.32"
+      mock_request('Invoice_GetRemainder', {"invoiceHandle" => { "Number" => 512 }}, :success)
+      expect(subject.remainder).to eq("512.32")
     end
   end
 
   describe ".proxy" do
     it "should return a InvoiceProxy" do
-      subject.proxy.should be_instance_of(Economic::InvoiceProxy)
+      expect(subject.proxy).to be_instance_of(Economic::InvoiceProxy)
     end
 
     it "should return a proxy owned by session" do
-      subject.proxy.session.should == session
+      expect(subject.proxy.session).to eq(session)
     end
   end
 
   describe ".key" do
     it "should == :invoice" do
-      Economic::Invoice.key.should == :invoice
+      expect(Economic::Invoice.key).to eq(:invoice)
     end
   end
 
   describe "#pdf" do
-    before :each do
-      savon.stubs('Invoice_GetPdf').returns(:success)
-    end
-
     it "gets PDF data from API" do
-      savon.expects('Invoice_GetPdf').with('invoiceHandle' => {'Number' => 512}).returns(:success)
+      mock_request('Invoice_GetPdf', {'invoiceHandle' => {'Number' => 512}}, :success)
       subject.pdf
     end
 
     it "decodes the base64Binary encoded data" do
-      subject.pdf.should == 'This is not really PDF data'
+      stub_request('Invoice_GetPdf', nil, :success)
+      expect(subject.pdf).to eq('This is not really PDF data')
     end
   end
 
   describe "#attention" do
-    let(:contact) { (c = Economic::DebtorContact.new).tap { c.session = session }}
+    let(:contact) {
+      Economic::DebtorContact.new.tap do |c|
+        c.session = session
+        c.id = 5
+      end
+    }
 
     it "should be set- and gettable" do
       subject.attention = contact
-      subject.attention_handle.should == contact.handle
-      subject.attention.should == contact
+      expect(subject.attention).to eq(contact)
+    end
+
+    it "updates the handle" do
+      handle = Economic::Entity::Handle.new(:number => 42)
+      contact.handle = handle
+      subject.attention = contact
+      expect(subject.attention_handle).to eq(handle)
     end
   end
 
   describe "#debtor" do
-    let(:debtor) { (c = Economic::Debtor.new).tap { c.session = session }}
+    let(:debtor) {
+      Economic::Debtor.new.tap do |c|
+        c.session = session
+        c.number = 5
+      end
+    }
 
     it "should be set- and gettable" do
       subject.debtor = debtor
-      subject.debtor_handle.should == debtor.handle
-      subject.debtor.should == debtor
+      expect(subject.debtor).to eq(debtor)
+    end
+
+    it "updates the handle" do
+      handle = Economic::Entity::Handle.new(:number => 42)
+      debtor.handle = handle
+      subject.debtor = debtor
+      expect(subject.debtor_handle).to eq(handle)
     end
   end
 end

data/spec/economic/proxies/actions/find_by_name_spec.rb

@@ -9,38 +9,41 @@ describe Economic::Proxies::Actions::FindByName do
   }
 
   describe "#call" do
-    before :each do
-      savon.stubs('CreditorContact_FindByName').returns(:multiple)
-    end
-
     it "gets contact data from the API" do
-      savon.expects('CreditorContact_FindByName').with('name' => 'Bob').returns(:multiple)
+      mock_request('CreditorContact_FindByName', {'name' => 'Bob'}, :multiple)
       subject.call
     end
 
     it "returns creditor contacts" do
-      subject.call.first.should be_instance_of(Economic::CreditorContact)
+      stub_request('CreditorContact_FindByName', nil, :multiple)
+      expect(subject.call.first).to be_instance_of(Economic::CreditorContact)
     end
 
     it "returns empty when nothing is found" do
-      savon.stubs('CreditorContact_FindByName').returns(:none)
-      subject.call.should be_empty
+      stub_request('CreditorContact_FindByName', nil, :none)
+      expect(subject.call).to be_empty
     end
 
     context "when calling proxy is owned by session" do
       it "returns all creditor contacts" do
-        subject.call.size.should == 2
+        stub_request('CreditorContact_FindByName', nil, :multiple)
+        expect(subject.call.size).to eq(2)
       end
     end
 
     context "when calling proxy is owned by a creditor" do
       it "returns only contacts for creditor" do
-        savon.stubs("CreditorContact_GetData").returns(:success)
-        savon.stubs("Creditor_GetData").returns(:success)
+        # Note the order of these stubs actually matters. They need to match
+        # the order they are called in in the implementation
+        stub_request('CreditorContact_FindByName', nil, :multiple)
+        stub_request("CreditorContact_GetData", nil, :success)
+        stub_request("Creditor_GetData", nil, :success)
+        stub_request("CreditorContact_GetData", nil, :success)
+        stub_request("Creditor_GetData", nil, :success)
         creditor = session.creditors.build
         proxy = Economic::CreditorContactProxy.new(creditor)
         action = Economic::Proxies::Actions::FindByName.new(proxy, "Bob")
-        action.call.each { |contact| contact.creditor.should == creditor }
+        action.call.each { |contact| expect(contact.creditor).to eq(creditor) }
       end
     end
   end

data/spec/economic/proxies/cash_book_entry_proxy_spec.rb

@@ -8,79 +8,81 @@ describe Economic::CashBookEntryProxy do
 
   describe ".new" do
     it "stores owner" do
-      subject.owner.should == cash_book
+      subject.owner.number = 2
+      expect(subject.owner).to eq(cash_book)
     end
 
     it "stores session" do
-      subject.session.should === session
+      expect(subject.session).to equal(session)
     end
   end
 
   describe ".build" do
     it "instantiates a new CashBookEntry" do
-      subject.build.should be_instance_of(Economic::CashBookEntry)
+      expect(subject.build).to be_instance_of(Economic::CashBookEntry)
     end
 
     it "assigns the session to the CashBookEntry" do
-      subject.build.session.should === session
+      expect(subject.build.session).to equal(session)
     end
   end
 
   describe "#create_finance_voucher" do
     it 'should create a finance voucher and return the created cash book entry' do
-      savon.stubs('CashBookEntry_CreateFinanceVoucher').returns(:success)
-      savon.stubs('CashBookEntry_GetData').with(:id1 => 15, :id2 => 16).returns(:success)
+      stub_request('CashBookEntry_CreateFinanceVoucher', nil, :success)
+      stub_request('CashBookEntry_GetData', {"entityHandle" => {"Id1" => 15, "Id2" => 16}}, :success)
       cash_book_entry = subject.create_finance_voucher(:account_handle => { :number => 2 }, :contra_account_handle => { :number => 3 })
-      cash_book_entry.should be_instance_of(Economic::CashBookEntry)
+      expect(cash_book_entry).to be_instance_of(Economic::CashBookEntry)
     end
   end
 
   describe "#create_debtor_payment" do
     it 'should create a debtor payment and then return the created cash book entry' do
-      savon.stubs('CashBookEntry_CreateDebtorPayment').returns(:success)
-      savon.stubs('CashBookEntry_GetData').with(:id1 => 13, :id2 => 14).returns(:success)
+      stub_request('CashBookEntry_CreateDebtorPayment', nil, :success)
+      stub_request('CashBookEntry_GetData', {"entityHandle" => {"Id1" => 13, "Id2" => 14}}, :success)
       cash_book_entry = subject.create_debtor_payment(:debtor_handle => { :number => 2 }, :contra_account_handle => { :number => 3 })
-      cash_book_entry.should be_instance_of(Economic::CashBookEntry)
+      expect(cash_book_entry).to be_instance_of(Economic::CashBookEntry)
     end
   end
 
   describe "#create_creditor_invoice" do
     it 'should create a creditor invoice and then return the created cash book entry' do
-      savon.stubs('CashBookEntry_CreateCreditorInvoice').returns(:success)
-      savon.stubs('CashBookEntry_GetData').with(:id1 => 13, :id2 => 14).returns(:success)
+      stub_request('CashBookEntry_CreateCreditorInvoice', nil, :success)
+      stub_request('CashBookEntry_GetData', {"entityHandle" => {"Id1" => 13, "Id2" => 14}}, :success)
       cash_book_entry = subject.create_creditor_invoice(:creditor_handle => { :number => 2 }, :contra_account_handle => { :number => 3 })
-      cash_book_entry.should be_instance_of(Economic::CashBookEntry)
+      expect(cash_book_entry).to be_instance_of(Economic::CashBookEntry)
     end
 
     it 'should not send handles that were not given' do
-      savon.stubs('CashBookEntry_CreateCreditorInvoice').with(:cashBookHandle => { 'Number' => 13 }).returns(:success)
-      savon.stubs('CashBookEntry_GetData').with(:id1 => 13, :id2 => 14).returns(:success)
-      cash_book_entry = subject.create_creditor_invoice({})
-      cash_book_entry.should be_instance_of(Economic::CashBookEntry)
+      stub_request('CashBookEntry_CreateCreditorInvoice', {"cashBookHandle" => { 'Number' => 42 }}, :success)
+      stub_request('CashBookEntry_GetData', {"entityHandle" => {"Id1" => 13, "Id2" => 14}}, :success)
+      cash_book.number = 42
+      cash_book_entry = subject.create_creditor_invoice({:number => 13})
+      expect(cash_book_entry).to be_instance_of(Economic::CashBookEntry)
     end
   end
 
   describe "#create_creditor_payment" do
     it 'should create a creditor payment and then return the created cash book entry' do
-      savon.stubs('CashBookEntry_CreateCreditorPayment').returns(:success)
-      savon.stubs('CashBookEntry_GetData').with(:id1 => 13, :id2 => 14).returns(:success)
+      stub_request('CashBookEntry_CreateCreditorPayment', nil, :success)
+      stub_request('CashBookEntry_GetData', {"entityHandle" => {"Id1" => 13, "Id2" => 14}}, :success)
       cash_book_entry = subject.create_creditor_payment(:creditor_handle => { :number => 2 }, :contra_account_handle => { :number => 3 })
-      cash_book_entry.should be_instance_of(Economic::CashBookEntry)
+      expect(cash_book_entry).to be_instance_of(Economic::CashBookEntry)
     end
   end
 
   describe "#set_due_date" do
     it 'should set due date' do
-      savon.expects('CashBookEntry_SetDueDate').with("cashBookEntryHandle" => { "Id1" => subject.owner.id, "Id2" => 234 }, :value => Date.new(2012, 12, 21)).returns(:success)
+      mock_request('CashBookEntry_SetDueDate', {"cashBookEntryHandle" => { "Id1" => subject.owner.id, "Id2" => 234 }, :value => Date.new(2012, 12, 21)}, :success)
       subject.set_due_date(234, Date.new(2012, 12, 21))
     end
   end
 
   describe "#all" do
     it 'should get the cash book entries' do
-      savon.stubs('CashBook_GetEntries').returns(:success)
-      subject.expects(:find).in_sequence.with({:id1 => '1', :id2 => '2'})
-      subject.expects(:find).in_sequence.with({:id1 => '11', :id2 => '12'})
+      stub_request('CashBook_GetEntries', nil, :success)
+      expect(subject).to receive(:find).with({:id1 => '1', :id2 => '2'})
+      expect(subject).to receive(:find).with({:id1 => '11', :id2 => '12'})
       subject.all
     end
   end