rconomic 0.5.0 → 0.5.1

data/lib/economic/session.rb

@@ -1,6 +1,9 @@
 module Economic
+  # The Economic::Session contains details and behaviors for a current
+  # connection to the API endpoint.
   class Session
     attr_accessor :agreement_number, :user_name, :password
+    attr_reader :authentication_token
 
     def initialize(agreement_number, user_name, password)
       self.agreement_number = agreement_number
@@ -10,16 +13,12 @@ module Economic
 
     # Authenticates with e-conomic
     def connect
-      client.http.headers.delete("Cookie")
-      response = client.request :economic, :connect do
-        soap.body = {
-          :agreementNumber => self.agreement_number,
-          :userName => self.user_name,
-          :password => self.password
-        }
+      endpoint.call(
+        :connect,
+        authentication_details
+      ) do |response|
+        store_authentication_token(response)
       end
-
-      @cookie = response.http.headers["Set-Cookie"]
     end
 
     # Provides access to the DebtorContacts
@@ -27,7 +26,8 @@ module Economic
       @contacts ||= DebtorContactProxy.new(self)
     end
 
-    # Provides access to the current invoices - ie invoices that haven't yet been booked
+    # Provides access to the current invoices - ie invoices that haven't yet
+    # been booked
     def current_invoices
       @current_invoices ||= CurrentInvoiceProxy.new(self)
     end
@@ -72,21 +72,8 @@ module Economic
     end
 
     # Requests an action from the API endpoint
-    def request(action, data = nil)
-      client.http.headers["Cookie"]  = @cookie
-
-      response = client.request(:economic, action) do
-        soap.body = data if data
-      end
-      response_hash = response.to_hash
-
-      response_key = "#{action}_response".intern
-      result_key = "#{action}_result".intern
-      if response_hash[response_key] && response_hash[response_key][result_key]
-        response_hash[response_key][result_key]
-      else
-        {}
-      end
+    def request(soap_action, data = nil)
+      endpoint.call(soap_action, data, authentication_token)
     end
 
     # Returns self - used by proxies to access the session of their owner
@@ -94,14 +81,23 @@ module Economic
       self
     end
 
+    # Returns the SOAP endpoint to connect to
+    def endpoint
+      @endpoint ||= Economic::Endpoint.new
+    end
+
     private
 
-    # Returns the Savon::Client used to connect to e-conomic
-    # Cached on class-level to avoid loading the big wsdl file more than once (can take several hunder megabytes of ram after a while...)
-    def client
-      @@client ||= Savon::Client.new do
-        wsdl.document = File.expand_path(File.join(File.dirname(__FILE__), "economic.wsdl"))
-      end
+    def authentication_details
+      {
+        :agreementNumber => self.agreement_number,
+        :userName => self.user_name,
+        :password => self.password
+      }
+    end
+
+    def store_authentication_token(response)
+      @authentication_token = response.http.cookies
     end
   end
 end

data/lib/rconomic/version.rb

@@ -1,3 +1,3 @@
 module Rconomic
-  VERSION = "0.5.0"
+  VERSION = "0.5.1"
 end

data/rconomic.gemspec

@@ -17,11 +17,7 @@ Gem::Specification.new do |s|
   s.version     = Rconomic::VERSION
   s.platform    = Gem::Platform::RUBY
 
-  # As long as we use Savon 0.9.5, we need to tie down the max version
-  # of gyoku as 0.4.5 is not backwards compatible. If we update Savon,
-  # we should remove the gyoku constraint.
-  s.add_runtime_dependency "savon", "0.9.5"
-  s.add_runtime_dependency "gyoku", "0.4.4"
+  s.add_runtime_dependency "savon", "~> 2.2"
 
   s.files         = `git ls-files`.split("\n").reject { |filename| ['.gitignore'].include?(filename) }
   s.test_files    = `git ls-files -- {spec}/*`.split("\n")

data/spec/economic/cash_book_entry_spec.rb

@@ -5,24 +5,46 @@ describe Economic::CashBookEntry do
   subject { Economic::CashBookEntry.new(:session => session) }
 
   it "inherits from Economic::Entity" do
-    Economic::CashBookEntry.ancestors.should include(Economic::Entity)
+    expect(Economic::CashBookEntry.ancestors).to include(Economic::Entity)
   end
 
   describe ".proxy" do
     it "should return a CashBookEntryProxy" do
-      subject.proxy.should be_instance_of(Economic::CashBookEntryProxy)
+      expect(subject.proxy).to be_instance_of(Economic::CashBookEntryProxy)
     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 "#save" do
     it 'should save it' do
-      savon.stubs('CashBookEntry_CreateFromData').returns(:success)
+      stub_request('CashBookEntry_CreateFromData', nil, :success)
       subject.save
     end
-  end
 
+    it "builds and sends data to API" do
+      time = Time.now
+      subject.date = subject.start_date = time
+      subject.account_handle = Economic::Entity::Handle.new(:number => 12)
+      mock_request(
+        :cash_book_entry_create_from_data, {
+          "data" => {
+            "AccountHandle" => {"Number" => 12},
+            "Date" => time,
+            "VoucherNumber" => 0,
+            "Text" => "",
+            "AmountDefaultCurrency" => 0,
+            "Amount" => 0,
+            "DueDate" => nil,
+            "StartDate" => time,
+            "EndDate" => nil
+          }
+        },
+        :success
+      )
+      subject.save
+    end
+  end
 end

data/spec/economic/cash_book_spec.rb

@@ -5,7 +5,7 @@ describe Economic::CashBook do
   subject { (i = Economic::CashBook.new( :id => 512, :number => 32 )).tap { i.session = session } }
 
   it "inherits from Economic::Entity" do
-    Economic::CashBook.superclass.should == Economic::Entity
+    expect(Economic::CashBook.superclass).to eq(Economic::Entity)
   end
 
   describe "class methods" do
@@ -13,22 +13,22 @@ describe Economic::CashBook do
 
     describe ".proxy" do
       it "should return CashBookProxy" do
-        subject.proxy.should == Economic::CashBookProxy
+        expect(subject.proxy).to eq(Economic::CashBookProxy)
       end
     end
   end
 
   describe "#entries" do
     it 'should return a cash book entry proxy' do
-      subject.entries.should be_a(Economic::CashBookEntryProxy)
-      subject.entries.owner.should == subject
+      expect(subject.entries).to be_a(Economic::CashBookEntryProxy)
+      expect(subject.entries.owner).to eq(subject)
     end
   end
 
   describe "#book" do
     it 'should book the cash book and return an invoice number' do
-      savon.expects("CashBook_Book").with('cashBookHandle' => { 'Number' => 32 }).returns(:success)
-      subject.book.should == 832
+      mock_request("CashBook_Book", {'cashBookHandle' => { 'Number' => 32 }}, :success)
+      expect(subject.book).to eq(832)
     end
   end
 end

data/spec/economic/creditor_contact_spec.rb

@@ -5,7 +5,7 @@ describe Economic::CreditorContact do
   subject { Economic::CreditorContact.new(:session => session) }
 
   it "inherits from Economic::Entity" do
-    Economic::CreditorContact.ancestors.should include(Economic::Entity)
+    expect(Economic::CreditorContact.ancestors).to include(Economic::Entity)
   end
 
   context "when saving" do
@@ -18,17 +18,26 @@ describe Economic::CreditorContact do
         end
 
         it "should send request and let e-conomic return an error" do
-          session.expects(:request)
+          expect(session).to receive(:request)
           subject.save
         end
       end
     end
+
+    it "builds and sends data to API" do
+      mock_request(
+        :creditor_contact_create_from_data,
+        {"data" => {"Handle" => {}, "Number" => nil}},
+        :success
+      )
+      subject.save
+    end
   end
 
   describe ".creditor" do
     context "when creditor_handle is not set" do
       it "returns nil" do
-        subject.creditor.should be_nil
+        expect(subject.creditor).to be_nil
       end
     end
 
@@ -40,13 +49,13 @@ describe Economic::CreditorContact do
       end
 
       it "returns a Creditor" do
-        session.creditors.expects(:find).with(42).returns(Economic::Creditor.new)
-        subject.creditor.should be_instance_of(Economic::Creditor)
+        expect(session.creditors).to receive(:find).with(42).and_return(Economic::Creditor.new)
+        expect(subject.creditor).to be_instance_of(Economic::Creditor)
       end
 
       it "only looks up the creditor the first time" do
-        session.creditors.expects(:find).with(42).returns(Economic::Creditor.new)
-        subject.creditor.should === subject.creditor
+        expect(session.creditors).to receive(:find).with(42).and_return(Economic::Creditor.new)
+        expect(subject.creditor).to equal(subject.creditor)
       end
     end
   end
@@ -55,7 +64,7 @@ describe Economic::CreditorContact do
     let(:creditor) { make_creditor }
     it "should set creditor_handle" do
       subject.creditor = creditor
-      subject.creditor_handle.should == creditor.handle
+      expect(subject.creditor_handle).to eq(creditor.handle)
     end
   end
 
@@ -65,7 +74,7 @@ describe Economic::CreditorContact do
 
     it "should set creditor_handle" do
       subject.creditor_handle = handle
-      subject.creditor_handle.should == handle
+      expect(subject.creditor_handle).to eq(handle)
     end
 
     context "when creditor handle is for a different Creditor" do
@@ -74,9 +83,9 @@ describe Economic::CreditorContact do
       end
 
       it "should clear cached creditor and fetch the new creditor from API" do
-        savon.stubs('Creditor_GetData').returns(:success)
+        stub_request('Creditor_GetData', nil, :success)
         subject.creditor_handle = Economic::Creditor::Handle.new({:number => 1234})
-        subject.creditor.should be_instance_of(Economic::Creditor)
+        expect(subject.creditor).to be_instance_of(Economic::Creditor)
       end
     end
 
@@ -86,20 +95,20 @@ describe Economic::CreditorContact do
       end
 
       it "should not clear cached creditor nor fetch the creditor from API" do
-        savon.stubs('Creditor_GetData').never
+        expect(session).to receive(:request).never
         subject.creditor_handle = handle
-        subject.creditor.should be_instance_of(Economic::Creditor)
+        expect(subject.creditor).to be_instance_of(Economic::Creditor)
       end
     end
   end
 
   describe ".proxy" do
     it "should return a CreditorContactProxy" do
-      subject.proxy.should be_instance_of(Economic::CreditorContactProxy)
+      expect(subject.proxy).to be_instance_of(Economic::CreditorContactProxy)
     end
 
     it "should return a proxy owned by session" do
-      subject.proxy.session.should == session
+      expect(subject.proxy.session).to eq(session)
     end
   end
 

data/spec/economic/creditor_spec.rb

@@ -5,7 +5,7 @@ describe Economic::Creditor do
   subject { Economic::Creditor.new(:session => session) }
 
   it "inherits from Economic::Entity" do
-    Economic::Creditor.ancestors.should include(Economic::Entity)
+    expect(Economic::Creditor.ancestors).to include(Economic::Entity)
   end
 
   describe "class methods" do
@@ -13,39 +13,39 @@ describe Economic::Creditor do
 
     describe ".proxy" do
       it "should return CreditorProxy" do
-        subject.proxy.should == Economic::CreditorProxy
+        expect(subject.proxy).to eq(Economic::CreditorProxy)
       end
     end
 
     describe ".key" do
       it "should == :creditor" do
-        Economic::Creditor.key.should == :creditor
+        expect(Economic::Creditor.key).to eq(:creditor)
       end
     end
   end
 
   describe ".contacts" do
     it "returns a CreditorContactProxy" do
-      subject.contacts.should be_instance_of(Economic::CreditorContactProxy)
+      expect(subject.contacts).to be_instance_of(Economic::CreditorContactProxy)
     end
 
     it "memoizes the proxy" do
-      subject.contacts.should === subject.contacts
+      expect(subject.contacts).to equal(subject.contacts)
     end
 
     it "should store the session" do
-      subject.session.should_not be_nil
-      subject.contacts.session.should == subject.session
+      expect(subject.session).to_not be_nil
+      expect(subject.contacts.session).to eq(subject.session)
     end
   end
 
   describe ".proxy" do
     it "should return a CreditorProxy" do
-      subject.proxy.should be_instance_of(Economic::CreditorProxy)
+      expect(subject.proxy).to be_instance_of(Economic::CreditorProxy)
     end
 
     it "should return a proxy owned by session" do
-      subject.proxy.session.should == session
+      expect(subject.proxy.session).to eq(session)
     end
   end
 

data/spec/economic/current_invoice_line_spec.rb

@@ -5,7 +5,7 @@ describe Economic::CurrentInvoiceLine do
   subject { (l = Economic::CurrentInvoiceLine.new).tap { l.session = session } }
 
   it "inherits from Economic::Entity" do
-    Economic::CurrentInvoiceLine.ancestors.should include(Economic::Entity)
+    expect(Economic::CurrentInvoiceLine.ancestors).to include(Economic::Entity)
   end
 
   describe "equality" do
@@ -13,14 +13,14 @@ describe Economic::CurrentInvoiceLine do
       line1 = Economic::CurrentInvoiceLine.new({})
       line2 = Economic::CurrentInvoiceLine.new({})
 
-      line1.should_not == line2
+      expect(line1).not_to eq(line2)
     end
 
     it "should not be equal when numbers are different" do
       line1 = Economic::CurrentInvoiceLine.new({:number => 1})
       line2 = Economic::CurrentInvoiceLine.new({:number => 2})
 
-      line1.should_not == line2
+      expect(line1).not_to eq(line2)
     end
   end
 
@@ -30,18 +30,18 @@ describe Economic::CurrentInvoiceLine do
 
       subject.invoice = invoice
 
-      subject.invoice.should == invoice
-      subject.invoice_handle.should == invoice.handle
+      expect(subject.invoice).to eq(invoice)
+      expect(subject.invoice_handle).to eq(invoice.handle)
     end
   end
 
   describe ".proxy" do
     it "should return a CurrentInvoiceLineProxy" do
-      subject.proxy.should be_instance_of(Economic::CurrentInvoiceLineProxy)
+      expect(subject.proxy).to be_instance_of(Economic::CurrentInvoiceLineProxy)
     end
 
     it "should return a proxy owned by session" do
-      subject.proxy.session.should == session
+      expect(subject.proxy.session).to eq(session)
     end
   end
 

data/spec/economic/current_invoice_spec.rb

@@ -5,67 +5,102 @@ describe Economic::CurrentInvoice do
   subject { (i = Economic::CurrentInvoice.new( :id => 512 )).tap { i.session = session } }
 
   it "inherits from Economic::Entity" do
-    Economic::CurrentInvoice.ancestors.should include(Economic::Entity)
+    expect(Economic::CurrentInvoice.ancestors).to include(Economic::Entity)
   end
 
   describe "new" do
     it "initializes lines as an empty proxy" do
-      subject.lines.should be_instance_of(Economic::CurrentInvoiceLineProxy)
-      subject.lines.should be_empty
+      expect(subject.lines).to be_instance_of(Economic::CurrentInvoiceLineProxy)
+      expect(subject.lines).to be_empty
     end
   end
 
   describe ".key" do
     it "should == :current_invoice" do
-      Economic::CurrentInvoice.key.should == :current_invoice
+      expect(Economic::CurrentInvoice.key).to eq(:current_invoice)
     end
   end
 
   describe ".proxy" do
     it "should return a CurrentInvoiceProxy" do
-      subject.proxy.should be_instance_of(Economic::CurrentInvoiceProxy)
+      expect(subject.proxy).to be_instance_of(Economic::CurrentInvoiceProxy)
     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 "save" do
     context "when successful" do
-      before :each do
-        savon.stubs('CurrentInvoice_CreateFromData').returns(:success)
+      it "builds and sends data to API" do
+        time = Time.now
+        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.layout_handle = Economic::Entity::Handle.new(:id => 314)
+
+        mock_request(
+          "CurrentInvoice_CreateFromData", {
+            "data" => {
+              "Id" => 512,
+              "DebtorName" => nil,
+              "AttentionHandle" => {"Id" => 42},
+              "Date" => time.iso8601,
+              "TermOfPaymentHandle" => {"Id" => 37},
+              "DueDate" => nil,
+              "CurrencyHandle" => {"Code" => "BTC"},
+              "ExchangeRate" => 100,
+              "IsVatIncluded" => nil,
+              "LayoutHandle" => {"Id" => 314},
+              "DeliveryDate" => nil,
+              "NetAmount" => 0,
+              "VatAmount" => 0,
+              "GrossAmount" => 0,
+              "Margin" => 0,
+              "MarginAsPercent" => 0
+            }
+          },
+          :success
+        )
+        subject.save
       end
 
       it "updates id with the created id" do
+        stub_request('CurrentInvoice_CreateFromData', nil, :success)
         subject.save
-        subject.id.should == 42
+        expect(subject.id).to eq(42)
       end
 
       it "updates handle with the created id" do
+        stub_request('CurrentInvoice_CreateFromData', nil, :success)
+
         invoice = Economic::CurrentInvoice.new({})
         invoice.session = session
 
         # This line memoizes the handle with the wrong/old id (0). This is what
         # we're testing changes
-        invoice.handle.id.should == 0
+        expect(invoice.handle.id).to eq(0)
 
         invoice.save
-        invoice.handle.should == Economic::Entity::Handle.new(:id => 42)
+        expect(invoice.handle).to eq(Economic::Entity::Handle.new(:id => 42))
       end
 
       context "when invoice has lines" do
         before :each do
+          stub_request('CurrentInvoice_CreateFromData', nil, :success)
+
           2.times do
             line = Economic::CurrentInvoiceLine.new
-            line.stubs(:save)
+            allow(line).to receive(:save)
             subject.lines << line
           end
         end
 
         it "adds the lines to the invoice" do
           subject.lines.each do |line|
-            line.expects(:invoice=).with(subject)
+            expect(line).to receive(:invoice=).with(subject)
           end
 
           subject.save
@@ -73,7 +108,7 @@ describe Economic::CurrentInvoice do
 
         it "assigns the invoice session to each line" do
           subject.lines.each do |line|
-            line.expects(:session=).with(subject.session)
+            expect(line).to receive(:session=).with(subject.session)
           end
 
           subject.save
@@ -81,7 +116,7 @@ describe Economic::CurrentInvoice do
 
         it "saves each line" do
           subject.lines.each do |line|
-            line.expects(:save)
+            expect(line).to receive(:save)
           end
 
           subject.save
@@ -91,32 +126,29 @@ describe Economic::CurrentInvoice do
   end
 
   describe "#book" do
-    before :each do
-      savon.stubs('CurrentInvoice_Book').returns(:success)
-      savon.stubs('Invoice_GetData').returns(:success)
-    end
-
     it 'should book the current invoice and return the created invoice object' do
-      savon.expects("Invoice_GetData").with('entityHandle' => { 'Number' => 328 }).returns(:success)
-      subject.book.should be_instance_of(Economic::Invoice)
+      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
-      savon.expects("CurrentInvoice_Book").with('currentInvoiceHandle' => { 'Id' => 512 }).returns(:success)
+      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
-      savon.stubs('CurrentInvoice_BookWithNumber').returns(:success)
-      savon.expects("Invoice_GetData").with('entityHandle' => { 'Number' => 123 }).returns(:success)
-      subject.book_with_number(123).should be_instance_of(Economic::Invoice)
+      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
-      savon.stubs('Invoice_GetData').returns(:success)
-      savon.expects("CurrentInvoice_BookWithNumber").with('currentInvoiceHandle' => { 'Id' => 512 }, 'number' => 123).returns(:success)
+      mock_request("CurrentInvoice_BookWithNumber", {'currentInvoiceHandle' => { 'Id' => 512 }, 'number' => 123}, :success)
+      stub_request('Invoice_GetData', nil, :success)
       subject.book_with_number(123)
     end
   end
@@ -132,18 +164,35 @@ describe Economic::CurrentInvoice do
 
     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