rconomic 0.5.0 → 0.5.1

data/spec/economic/debtor_contact_spec.rb

@@ -5,7 +5,7 @@ describe Economic::DebtorContact do
   subject { Economic::DebtorContact.new(:session => session) }
 
   it "inherits from Economic::Entity" do
-    Economic::DebtorContact.ancestors.should include(Economic::Entity)
+    expect(Economic::DebtorContact.ancestors).to include(Economic::Entity)
   end
 
   context "when saving" do
@@ -18,17 +18,27 @@ describe Economic::DebtorContact 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(
+        :debtor_contact_create_from_data,
+        {"data" => {"Handle" => {}, "Id" => nil, "Name" => nil, "Number" => 42, "IsToReceiveEmailCopyOfOrder" => false, "IsToReceiveEmailCopyOfInvoice" => false}},
+        :success
+      )
+      subject.number = 42
+      subject.save
+    end
   end
 
   describe ".debtor" do
     context "when debtor_handle is not set" do
       it "returns nil" do
-        subject.debtor.should be_nil
+        expect(subject.debtor).to be_nil
       end
     end
 
@@ -40,13 +50,13 @@ describe Economic::DebtorContact do
       end
 
       it "returns a Debtor" do
-        session.debtors.expects(:find).with(42).returns(Economic::Debtor.new)
-        subject.debtor.should be_instance_of(Economic::Debtor)
+        expect(session.debtors).to receive(:find).with(42).and_return(Economic::Debtor.new)
+        expect(subject.debtor).to be_instance_of(Economic::Debtor)
       end
 
       it "only looks up the debtor the first time" do
-        session.debtors.expects(:find).with(42).returns(Economic::Debtor.new)
-        subject.debtor.should === subject.debtor
+        expect(session.debtors).to receive(:find).with(42).and_return(Economic::Debtor.new)
+        expect(subject.debtor).to equal(subject.debtor)
       end
     end
   end
@@ -55,7 +65,7 @@ describe Economic::DebtorContact do
     let(:debtor) { make_debtor }
     it "should set debtor_handle" do
       subject.debtor = debtor
-      subject.debtor_handle.should == debtor.handle
+      expect(subject.debtor_handle).to eq(debtor.handle)
     end
   end
 
@@ -65,7 +75,7 @@ describe Economic::DebtorContact do
 
     it "should set debtor_handle" do
       subject.debtor_handle = handle
-      subject.debtor_handle.should == handle
+      expect(subject.debtor_handle).to eq(handle)
     end
 
     context "when debtor handle is for a different Debtor" do
@@ -74,9 +84,9 @@ describe Economic::DebtorContact do
       end
 
       it "should clear cached debtor and fetch the new debtor from API" do
-        savon.stubs('Debtor_GetData').returns(:success)
+        stub_request('Debtor_GetData', nil, :success)
         subject.debtor_handle = Economic::Debtor::Handle.new({:number => 1234})
-        subject.debtor.should be_instance_of(Economic::Debtor)
+        expect(subject.debtor).to be_instance_of(Economic::Debtor)
       end
     end
 
@@ -86,20 +96,20 @@ describe Economic::DebtorContact do
       end
 
       it "should not clear cached debtor nor fetch the debtor from API" do
-        savon.stubs('Debtor_GetData').never
+        expect(session).to receive(:request).never
         subject.debtor_handle = handle
-        subject.debtor.should be_instance_of(Economic::Debtor)
+        expect(subject.debtor).to be_instance_of(Economic::Debtor)
       end
     end
   end
 
   describe ".proxy" do
     it "should return a DebtorContactProxy" do
-      subject.proxy.should be_instance_of(Economic::DebtorContactProxy)
+      expect(subject.proxy).to be_instance_of(Economic::DebtorContactProxy)
     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/debtor_entry_spec.rb

@@ -5,16 +5,16 @@ describe Economic::DebtorEntry do
   subject { Economic::DebtorEntry.new(:session => session) }
 
   it "inherits from Economic::Entity" do
-    Economic::DebtorEntry.ancestors.should include(Economic::Entity)
+    expect(Economic::DebtorEntry.ancestors).to include(Economic::Entity)
   end
 
   describe ".proxy" do
     it "should return a DebtorEntryProxy" do
-      subject.proxy.should be_instance_of(Economic::DebtorEntryProxy)
+      expect(subject.proxy).to be_instance_of(Economic::DebtorEntryProxy)
     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/debtor_spec.rb

@@ -5,7 +5,7 @@ describe Economic::Debtor do
   subject { Economic::Debtor.new(:session => session) }
 
   it "inherits from Economic::Entity" do
-    Economic::Debtor.ancestors.should include(Economic::Entity)
+    expect(Economic::Debtor.ancestors).to include(Economic::Entity)
   end
 
   describe "class methods" do
@@ -13,13 +13,13 @@ describe Economic::Debtor do
 
     describe ".proxy" do
       it "should return DebtorProxy" do
-        subject.proxy.should == Economic::DebtorProxy
+        expect(subject.proxy).to eq(Economic::DebtorProxy)
       end
     end
 
     describe ".key" do
       it "should == :debtor" do
-        Economic::Debtor.key.should == :debtor
+        expect(Economic::Debtor.key).to eq(:debtor)
       end
     end
   end
@@ -34,7 +34,7 @@ describe Economic::Debtor 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
@@ -43,41 +43,41 @@ describe Economic::Debtor do
 
   describe ".current_invoices" do
     it "returns an CurrentInvoiceProxy" do
-      subject.current_invoices.should be_instance_of(Economic::CurrentInvoiceProxy)
+      expect(subject.current_invoices).to be_instance_of(Economic::CurrentInvoiceProxy)
     end
 
     it "memoizes the proxy" do
-      subject.current_invoices.should === subject.current_invoices
+      expect(subject.current_invoices).to equal(subject.current_invoices)
     end
 
     it "should store the session" do
-      subject.session.should_not be_nil
-      subject.current_invoices.session.should == subject.session
+      expect(subject.session).to_not be_nil
+      expect(subject.current_invoices.session).to eq(subject.session)
     end
   end
 
   describe ".contacts" do
     it "returns a DebtorContactProxy" do
-      subject.contacts.should be_instance_of(Economic::DebtorContactProxy)
+      expect(subject.contacts).to be_instance_of(Economic::DebtorContactProxy)
     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 DebtorProxy" do
-      subject.proxy.should be_instance_of(Economic::DebtorProxy)
+      expect(subject.proxy).to be_instance_of(Economic::DebtorProxy)
     end
 
     it "should return a proxy owned by session" do
-      subject.proxy.session.should == session
+      expect(subject.proxy.session).to eq(session)
     end
   end
 
@@ -87,10 +87,44 @@ describe Economic::Debtor do
         let(:other) { Economic::Invoice.new(:session => session, :handle => subject.handle) }
 
         it "should return false" do
-          subject.should_not == other
+          expect(subject).not_to eq(other)
         end
       end
     end
   end
 
+  describe "#save" do
+    it 'should save it' do
+      stub_request('Debtor_CreateFromData', nil, :success)
+      subject.save
+    end
+
+    it "builds and sends data to API" do
+      mock_request(
+        :debtor_create_from_data, {
+          "data" => {
+            "Handle" => {},
+            "Number" => nil,
+            "DebtorGroupHandle" => {"Number" => 42},
+            "Name" => nil,
+            "VatZone" => nil,
+            "CurrencyHandle" => {"Code" => "BTC"},
+            "PriceGroupHandle" => {"Number" => 37},
+            "IsAccessible" => nil,
+            "TermOfPaymentHandle" => {"Id" => 314},
+            "LayoutHandle" => {"Id" => 21}
+          }
+        },
+        :success
+      )
+
+      subject.debtor_group_handle = Economic::Entity::Handle.new({:number => 42})
+      subject.currency_handle = Economic::Entity::Handle.new({:code => 'BTC'})
+      subject.price_group_handle = Economic::Entity::Handle.new({:number => 37})
+      subject.term_of_payment_handle = Economic::Entity::Handle.new({:id => 314})
+      subject.layout_handle = Economic::Entity::Handle.new({:id => 21})
+
+      subject.save
+    end
+  end
 end

data/spec/economic/endpoint_spec.rb

@@ -0,0 +1,71 @@
+require './spec/spec_helper'
+
+describe Economic::Endpoint do
+  subject { Economic::Endpoint.new }
+
+  describe "call" do
+    let(:client) {
+      subject.client
+    }
+
+    it "uses the SOAP client to invoke a SOAP action on the API" do
+      expect(client).to receive(:call).with(
+        :foo_bar,
+        :message => {:baz => 'qux'}
+      ).and_return({})
+      subject.call(:foo_bar, {:baz => 'qux'})
+    end
+
+    it "sends an actual request" do
+      mock_request('Connect', nil, :success)
+      subject.call(:connect)
+    end
+
+    it "returns a hash with data" do
+      stub_request('CurrentInvoice_GetAll', nil, :single)
+      expect(subject.call(:current_invoice_get_all)).to eq({:current_invoice_handle => {:id => "1"}})
+    end
+
+    it "returns an empty hash if no data returned" do
+      stub_request('CurrentInvoice_GetAll', nil, :none)
+      expect(subject.call(:current_invoice_get_all)).to be_empty
+    end
+
+    it "yields a Savon response" do
+      stub_request('CurrentInvoice_GetAll', nil, :single)
+      @yielded_value = nil
+      subject.call(:current_invoice_get_all) do |response|
+        @yielded_value = response
+      end
+      expect(@yielded_value).to be_instance_of(Savon::Response)
+    end
+
+    it "adds a cookie header" do
+      expect(client).to receive(:call).with(
+        :current_invoice_get_all,
+        :cookies => "omnomnom"
+      ).and_return({})
+      subject.call(:current_invoice_get_all, {}, "omnomnom")
+    end
+  end
+
+  describe "#client" do
+    it "returns a Savon::Client" do
+      expect(subject.client).to be_instance_of(::Savon::Client)
+    end
+
+    it "returns the same Savon::Client" do
+      expect(subject.client).to equal(subject.client)
+    end
+  end
+
+  describe "soap_action_name" do
+    it "returns full action name for the given class and soap action" do
+      expect(subject.soap_action_name(Economic::Debtor, :get_data)).to eq(:debtor_get_data)
+    end
+
+    it "returns full action name for a class given as strings" do
+      expect(subject.soap_action_name("FooBar", "Stuff")).to eq(:foo_bar_stuff)
+    end
+  end
+end

data/spec/economic/entity/handle_spec.rb

@@ -8,24 +8,24 @@ describe Economic::Entity::Handle do
     let(:handle_d) { Economic::Entity::Handle.new(:id => 1, :number => 3) }
 
     it "should be equal when both id and number are equal" do
-      handle_a.should == handle_b
+      expect(handle_a).to eq(handle_b)
     end
 
     it "should not be equal when id or number is missing" do
-      handle_a.should_not == handle_c
+      expect(handle_a).not_to eq(handle_c)
     end
 
     it "should not be equal when id or number is equal and the other isn't" do
-      handle_a.should_not == handle_d
+      expect(handle_a).not_to eq(handle_d)
     end
 
     it "should not equal if both are empty" do
-      Economic::Entity::Handle.new({}).should_not == Economic::Entity::Handle.new({})
+      expect(Economic::Entity::Handle.new({})).not_to eq(Economic::Entity::Handle.new({}))
     end
 
     it "should be equal if both are the same object" do
       handle = Economic::Entity::Handle.new({})
-      handle.should == handle
+      expect(handle).to eq(handle)
     end
 
     describe "CashBookEntry handles" do
@@ -35,7 +35,7 @@ describe Economic::Entity::Handle do
         let(:handle_b) { Economic::Entity::Handle.new(:id1 => 1, :id2 => 2) }
 
         it "should be equal" do
-          handle_a.should == handle_b
+          expect(handle_a).to eq(handle_b)
         end
       end
 
@@ -43,7 +43,7 @@ describe Economic::Entity::Handle do
         let(:handle_b) { Economic::Entity::Handle.new(:id1 => 11, :id2 => 12) }
 
         it "should_not be equal" do
-          handle_a.should_not == handle_b
+          expect(handle_a).not_to eq(handle_b)
         end
       end
     end
@@ -51,137 +51,130 @@ describe Economic::Entity::Handle do
 
   describe ".new" do
     it "should raise error if argument isn't supported" do
-      lambda do
+      expect(lambda do
         Economic::Entity::Handle.new(true)
-      end.should raise_error(ArgumentError)
+      end).to raise_error(ArgumentError)
     end
 
     it "should assume :id if argument is numeric" do
       handle = Economic::Entity::Handle.new(12)
-      handle.id.should == 12
-      handle.number.should be_nil
+      expect(handle.id).to eq(12)
+      expect(handle.number).to be_nil
     end
 
     it "should use to_i on numeric argument" do
       handle = Economic::Entity::Handle.new("42")
-      handle.id.should == 42
+      expect(handle.id).to eq(42)
     end
 
     it "should raise error if argument is nil" do
-      lambda do
+      expect(lambda do
         Economic::Entity::Handle.new(nil)
-      end.should raise_error(ArgumentError)
+      end).to raise_error(ArgumentError)
     end
 
     it "should raise error if argument contains invalid key" do
-      lambda do
+      expect(lambda do
         Economic::Entity::Handle.new(:Numeric => 12)
-      end.should raise_error(ArgumentError)
-    end
-
-    it "should raise error if argument contains invalid values" do
-      lambda do
-        Economic::Entity::Handle.new(:number => {:number => 12})
-      end.should raise_error(ArgumentError)
+      end).to raise_error(ArgumentError)
     end
 
     it "should set id" do
       handle = Economic::Entity::Handle.new(:id => 12)
-      handle.id.should == 12
+      expect(handle.id).to eq(12)
     end
 
     it "should set number" do
       handle = Economic::Entity::Handle.new(:number => 12)
-      handle.number.should == 12
+      expect(handle.number).to eq(12)
     end
 
     it "should set both id and number" do
       handle = Economic::Entity::Handle.new(:id => 37, :number => 42)
-      handle.id.should == 37
-      handle.number.should == 42
+      expect(handle.id).to eq(37)
+      expect(handle.number).to eq(42)
     end
 
     it 'should set id1 and id2' do
       handle = Economic::Entity::Handle.new(:id1 => 37, :id2 => 42)
-      handle.id1.should == 37
-      handle.id2.should == 42
+      expect(handle.id1).to eq(37)
+      expect(handle.id2).to eq(42)
     end
 
     it "should to_i values" do
       handle = Economic::Entity::Handle.new(:id => "37", :number => "42")
-      handle.id.should == 37
-      handle.number.should == 42
+      expect(handle.id).to eq(37)
+      expect(handle.number).to eq(42)
     end
 
     it "should not to_i nil values" do
       handle = Economic::Entity::Handle.new(:id => "37")
-      handle.id.should == 37
-      handle.number.should be_nil
+      expect(handle.id).to eq(37)
+      expect(handle.number).to be_nil
     end
 
     it "should accept a Hash with capitalized keys" do
       handle = Economic::Entity::Handle.new({"Id" => 37, "Number" => 42})
-      handle.id.should == 37
-      handle.number.should == 42
+      expect(handle.id).to eq(37)
+      expect(handle.number).to eq(42)
     end
 
     it "should accept another Handle" do
       original_handle = Economic::Entity::Handle.new(:id => 37)
       handle = Economic::Entity::Handle.new(original_handle)
-      handle.id.should == 37
-      handle.number.should be_nil
-      handle.should == original_handle
+      expect(handle.id).to eq(37)
+      expect(handle.number).to be_nil
+      expect(handle).to eq(original_handle)
     end
   end
 
   describe ".build" do
     it "returns nil when given nil" do
-      Economic::Entity::Handle.build(nil).should be_nil
+      expect(Economic::Entity::Handle.build(nil)).to be_nil
     end
 
     it "returns empty handle when hash is empty" do
-      Economic::Entity::Handle.build({}).should be_empty
+      expect(Economic::Entity::Handle.build({})).to be_empty
     end
 
     it "returns nil when hash has no values" do
-      Economic::Entity::Handle.build({:id => nil, :number => nil}).should be_empty
+      expect(Economic::Entity::Handle.build({:id => nil, :number => nil})).to be_empty
     end
 
     it "returns handle when hash has values" do
-      Economic::Entity::Handle.build({:id2 => 42}).should == Economic::Entity::Handle.new({:id2 => 42})
+      expect(Economic::Entity::Handle.build({:id2 => 42})).to eq(Economic::Entity::Handle.new({:id2 => 42}))
     end
 
     it "returns a given handle" do
       handle = Economic::Entity::Handle.new({})
-      Economic::Entity::Handle.build(handle).should === handle
+      expect(Economic::Entity::Handle.build(handle)).to equal(handle)
     end
   end
 
   describe "#empty?" do
     it "returns true when handle has no values" do
-      Economic::Entity::Handle.new({}).should be_empty
+      expect(Economic::Entity::Handle.new({})).to be_empty
     end
 
     it "returns false when handle has a value" do
-      Economic::Entity::Handle.new({:serial_number => 12}).should_not be_empty
+      expect(Economic::Entity::Handle.new({:serial_number => 12})).to_not be_empty
     end
   end
 
   describe ".to_hash" do
-    subject { Economic::Entity::Handle.new({:id => 42, :number => 37, :serial_number => 7}) }
+    subject { Economic::Entity::Handle.new({:id => 42, :number => 37, :serial_number => 7, :code => "USD", :vat_code => 1}) }
 
     it "should return a handle for putting into the body of a SOAP request" do
-      subject.to_hash.should == {'Id' => 42, 'Number' => 37, 'SerialNumber' => 7}
+      expect(subject.to_hash).to eq({'Id' => 42, 'Number' => 37, 'SerialNumber' => 7, 'Code' => 'USD', 'VatCode' => 1})
     end
 
     it "includes only the named value in the hash" do
-      subject.to_hash(:id).should == {'Id' => 42}
+      expect(subject.to_hash(:id)).to eq({'Id' => 42})
     end
 
     it "includes only the named values in the hash" do
-      subject.to_hash([:id, :serial_number]).should == {'Id' => 42, 'SerialNumber' => 7}
+      expect(subject.to_hash([:id, :serial_number])).to eq({'Id' => 42, 'SerialNumber' => 7})
     end
   end
-
 end
 

data/spec/economic/entity/mapper_spec.rb

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