rconomic 0.5.0 → 0.5.1

data/spec/economic/proxies/debtor_contact_proxy_spec.rb

@@ -6,21 +6,21 @@ describe Economic::DebtorContactProxy 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 DebtorContact" do
-      subject.build.should be_instance_of(Economic::DebtorContact)
+      expect(subject.build).to be_instance_of(Economic::DebtorContact)
     end
 
     it "assigns the session to the DebtorContact" do
-      subject.build.session.should === session
+      expect(subject.build.session).to equal(session)
     end
 
     it "should not build a partial DebtorContact" do
-      subject.build.should_not be_partial
+      expect(subject.build).to_not be_partial
     end
 
     context "when owner is a Debtor" do
@@ -28,37 +28,34 @@ describe Economic::DebtorContactProxy do
       subject { debtor.contacts }
 
       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
         contact = subject.build
-        contact.debtor_handle.should == debtor.handle
+        expect(contact.debtor_handle).to eq(debtor.handle)
       end
     end
   end
 
   describe ".find" do
-    before :each do
-      savon.stubs('DebtorContact_GetData').returns(:success)
-    end
-
     it "gets contact data from API" do
-      savon.expects('DebtorContact_GetData').with('entityHandle' => {'Id' => 42}).returns(:success)
+      mock_request('DebtorContact_GetData', {'entityHandle' => {'Id' => 42}}, :success)
       subject.find(42)
     end
 
     it "returns DebtorContact object" do
-      subject.find(42).should be_instance_of(Economic::DebtorContact)
+      stub_request('DebtorContact_GetData', nil, :success)
+      expect(subject.find(42)).to be_instance_of(Economic::DebtorContact)
     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/debtor_entry_proxy_spec.rb

@@ -6,42 +6,46 @@ describe Economic::DebtorEntryProxy 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 debtor entries' do
-      savon.expects("DebtorEntry_FindByInvoiceNumber").with('from' => '123', 'to' => '456').returns(:many)
-      subject.find_by_invoice_number('123', '456').should == [1, 2]
+      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
-      savon.expects("DebtorEntry_FindByInvoiceNumber").with('from' => '123', 'to' => '123').returns(:many)
-      subject.find_by_invoice_number('123').should == [1, 2]
+      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
-      savon.stubs("DebtorEntry_FindByInvoiceNumber").returns(:single)
-      subject.find_by_invoice_number('123').should == [1]
+      stub_request("DebtorEntry_FindByInvoiceNumber", nil, :single)
+      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
-      savon.stubs("DebtorEntry_MatchEntries").with(
-        :entries => [
-          { :debtor_entry_handle => { :serial_number => 1 } },
-          { :debtor_entry_handle => { :serial_number => 2 } }
-        ]
-      ).returns(:success)
+      stub_request(
+        "DebtorEntry_MatchEntries",
+        {:entries => {
+          "DebtorEntryHandle" => [
+            {"SerialNumber" => 1},
+            {"SerialNumber" => 2}
+          ]
+        }},
+        :success
+      )
       subject.match(1, 2)
     end
   end
 
   describe "#entity_class" do
     it "should return Economic::DebtorEntry" do
-      Economic::DebtorEntryProxy.entity_class.should == Economic::DebtorEntry
+      expect(Economic::DebtorEntryProxy.entity_class).to eq(Economic::DebtorEntry)
     end
   end
 end

data/spec/economic/proxies/debtor_proxy_spec.rb

@@ -6,75 +6,72 @@ describe Economic::DebtorProxy 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('Debtor_GetData').returns(:success)
-    end
-
     it "gets debtor data from API" do
-      savon.expects('Debtor_GetData').with('entityHandle' => {'Number' => 42}).returns(:success)
+      mock_request('Debtor_GetData', {'entityHandle' => {'Number' => 42}}, :success)
       subject.find(42)
     end
 
     it "returns Debtor object" do
-      subject.find(42).should be_instance_of(Economic::Debtor)
+      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
-      savon.expects('Debtor_FindByCINumber').with('ciNumber' => '12345678').returns(:many)
+      mock_request('Debtor_FindByCINumber', {'ciNumber' => '12345678'}, :many)
       subject.find_by_ci_number('12345678')
     end
 
     context "when many debtors exist" do
       before :each do
-        savon.stubs('Debtor_FindByCINumber').returns(:many)
+        stub_request('Debtor_FindByCINumber', nil, :many)
       end
 
       let(:results) { subject.find_by_ci_number('12345678') }
 
       it "returns a Debtor object for each result" do
-        results.size.should == 2
-        results.all? { |result| result.should be_instance_of(Economic::Debtor) }
+        expect(results.size).to eq(2)
+        results.all? { |result| expect(result).to be_instance_of(Economic::Debtor) }
       end
 
       it "returns partial Debtor objects" do
-        results.all? { |result| result.should be_partial }
+        results.all? { |result| expect(result).to be_partial }
       end
 
       it "returns persisted Debtor objects" do
-        results.all? { |result| result.should be_persisted }
+        results.all? { |result| expect(result).to be_persisted }
       end
     end
   end
 
   describe "find_by_number" do
     it "can find a debtor" do
-      savon.expects('Debtor_FindByNumber').with('number' => '1').returns(:found)
+      mock_request('Debtor_FindByNumber', {'number' => '1'}, :found)
       result = subject.find_by_number('1')
-      result.should be_instance_of(Economic::Debtor)
-      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::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}))
     end
 
     it "returns nil when there is no debtor" do
-      savon.expects('Debtor_FindByNumber').with('number' => '1').returns(:not_found)
+      mock_request('Debtor_FindByNumber', {'number' => '1'}, :not_found)
       result = subject.find_by_number('1')
-      result.should be_nil
+      expect(result).to be_nil
     end
   end
 
   describe "next_available_number" do
     it "gets the next available debtor number from API" do
-      savon.expects('Debtor_GetNextAvailableNumber').returns(:success)
-      subject.next_available_number.should == '105'
+      mock_request('Debtor_GetNextAvailableNumber', nil, :success)
+      expect(subject.next_available_number).to eq('105')
     end
   end
 
@@ -82,17 +79,17 @@ describe Economic::DebtorProxy do
     subject { session.debtors.build }
 
     it "instantiates a new Debtor" do
-      subject.should be_instance_of(Economic::Debtor)
+      expect(subject).to be_instance_of(Economic::Debtor)
     end
 
     it "assigns the session to the Debtor" do
-      subject.session.should === session
+      expect(subject.session).to equal(session)
     end
   end
 
   describe "#entity_class" do
     it "should return Economic::Debtor" do
-      Economic::DebtorProxy.entity_class.should == Economic::Debtor
+      expect(Economic::DebtorProxy.entity_class).to eq(Economic::Debtor)
     end
   end
 
@@ -100,19 +97,19 @@ describe Economic::DebtorProxy do
   # it handles debtors "Number" id.
   describe ".all" do
     it "returns a single debtor" do
-      savon.expects('Debtor_GetAll').returns(:single)
-      savon.expects('Debtor_GetData').with('entityHandle' => {'Number' => 1}).returns(:success)
+      mock_request('Debtor_GetAll', nil, :single)
+      mock_request('Debtor_GetData', {'entityHandle' => {'Number' => 1}}, :success)
       all = subject.all
-      all.size.should == 1
-      all.first.should be_instance_of(Economic::Debtor)
+      expect(all.size).to eq(1)
+      expect(all.first).to be_instance_of(Economic::Debtor)
     end
 
     it "returns multiple debtors" do
-      savon.expects('Debtor_GetAll').returns(:multiple)
-      savon.expects('Debtor_GetDataArray').returns(:multiple)
+      mock_request('Debtor_GetAll', nil, :multiple)
+      mock_request('Debtor_GetDataArray', :any, :multiple)
       all = subject.all
-      all.size.should == 2
-      all.first.should be_instance_of(Economic::Debtor)
+      expect(all.size).to eq(2)
+      expect(all.first).to be_instance_of(Economic::Debtor)
     end
   end
 end

data/spec/economic/proxies/entry_proxy_spec.rb

@@ -6,7 +6,7 @@ describe Economic::EntryProxy do
 
   describe "new" do
     it "stores session" do
-      subject.session.should === session
+      expect(subject.session).to equal(session)
     end
   end
 
@@ -14,59 +14,63 @@ describe Economic::EntryProxy do
     it 'should be able to find multiple entries' do
       from_date = Date.new
       to_date = Date.new
-      savon.expects("Entry_FindByDateInterval").
-        with('fromDate' => from_date, 'toDate' => to_date).
-        returns(:many)
-      subject.find_by_date_interval(from_date, to_date).should == [1, 2]
+      mock_request(
+        "Entry_FindByDateInterval",
+        {'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
-      savon.stubs("Entry_FindByDateInterval").returns(:single)
-      subject.find_by_date_interval(Date.new, Date.new).should == [1]
+      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
-      savon.stubs("Entry_FindByDateInterval").returns(:none)
-      subject.find_by_date_interval(Date.new, Date.new).should == []
+      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
-      savon.expects("Entry_FindBySerialNumberInterval").
-        with('minNumber' => 123, 'maxNumber' => 456).
-        returns(:many)
-      subject.find_by_serial_number_interval(123, 456).should == [1, 2]
+      mock_request(
+        "Entry_FindBySerialNumberInterval",
+        {'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
-      savon.stubs("Entry_FindBySerialNumberInterval").returns(:single)
-      subject.find_by_serial_number_interval(123, 456).should == [1]
+      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
-      savon.stubs("Entry_FindBySerialNumberInterval").returns(:none)
-      subject.find_by_serial_number_interval(123, 456).should == []
+      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
-      savon.expects("Entry_GetLastUsedSerialNumber").returns(:success)
-      subject.get_last_used_serial_number.should == 123
+      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
-      savon.expects("Entry_GetData").with('entityHandle' => { 'SerialNumber' => '123' }).returns(:success)
-      subject.find('123').should be_instance_of(Economic::Entry)
+      mock_request("Entry_GetData", {'entityHandle' => { 'SerialNumber' => '123' }}, :success)
+      expect(subject.find('123')).to be_instance_of(Economic::Entry)
     end
   end
 
   describe "#entity_class" do
     it "should return Economic::Entry" do
-      Economic::EntryProxy.entity_class.should == Economic::Entry
+      expect(Economic::EntryProxy.entity_class).to eq(Economic::Entry)
     end
   end
 end

data/spec/economic/proxies/invoice_proxy_spec.rb

@@ -7,63 +7,60 @@ describe Economic::InvoiceProxy 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 Invoice" do
-      subject.build.should be_instance_of(Economic::Invoice)
+      expect(subject.build).to be_instance_of(Economic::Invoice)
     end
 
     it "assigns the session to the Invoice" do
-      subject.build.session.should === session
+      expect(subject.build.session).to equal(session)
     end
 
     it "should not build a partial Invoice" do
-      subject.build.should_not be_partial
+      expect(subject.build).to_not be_partial
     end
   end
 
   describe ".find" do
-    before :each do
-      savon.stubs('Invoice_GetData').returns(:success)
-    end
-
     it "gets invoice data from API" do
-      savon.expects('Invoice_GetData').with('entityHandle' => {'Number' => 42}).returns(:success)
+      mock_request('Invoice_GetData', {'entityHandle' => {'Number' => 42}}, :success)
       subject.find(42)
     end
 
     it "returns Invoice object" do
-      subject.find(42).should be_instance_of(Economic::Invoice)
+      stub_request('Invoice_GetData', nil, :success)
+      expect(subject.find(42)).to be_instance_of(Economic::Invoice)
     end
-  end  
+  end
 
   describe ".find_by_date_interval" do
     let(:from) { Time.now - 60 }
     let(:unto) { Time.now }
 
     it "should be able to return a single current invoice" do
-      savon.expects('Invoice_FindByDateInterval').with('first' => from.iso8601, 'last' => unto.iso8601).returns(:single)
-      savon.expects('Invoice_GetDataArray').returns(:single)
+      mock_request('Invoice_FindByDateInterval', {'first' => from.iso8601, 'last' => unto.iso8601}, :single)
+      mock_request('Invoice_GetDataArray', :any, :single)
       results = subject.find_by_date_interval(from, unto)
-      results.size.should == 1
-      results.first.should be_instance_of(Economic::Invoice)
+      expect(results.size).to eq(1)
+      expect(results.first).to be_instance_of(Economic::Invoice)
     end
 
     it "should be able to return multiple invoices" do
-      savon.expects('Invoice_FindByDateInterval').with('first' => from.iso8601, 'last' => unto.iso8601).returns(:many)
-      savon.expects('Invoice_GetDataArray').returns(:multiple)
+      mock_request('Invoice_FindByDateInterval', {'first' => from.iso8601, 'last' => unto.iso8601}, :many)
+      mock_request('Invoice_GetDataArray', :any, :multiple)
       results = subject.find_by_date_interval(from, unto)
-      results.size.should == 2
-      results.first.should be_instance_of(Economic::Invoice)
+      expect(results.size).to eq(2)
+      expect(results.first).to be_instance_of(Economic::Invoice)
     end
 
     it "should be able to return nothing" do
-      savon.expects('Invoice_FindByDateInterval').with('first' => from.iso8601, 'last' => unto.iso8601).returns(:none)
+      mock_request('Invoice_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

data/spec/economic/session_spec.rb

@@ -1,124 +1,137 @@
 require './spec/spec_helper'
 
 describe Economic::Session do
-  let(:client) { subject.send(:client) }
-
   subject { Economic::Session.new(123456, 'api', 'passw0rd') }
 
+  let(:endpoint) { subject.endpoint }
+
   describe "new" do
     it "should store authentication details" do
-      subject.agreement_number.should == 123456
-      subject.user_name.should == 'api'
-      subject.password.should == 'passw0rd'
-    end
-  end
-
-  describe "client" do
-    subject { Economic::Session.new(123456, 'api', 'passw0rd') }
-
-    it "returns a Savon::Client" do
-      client.should be_instance_of(::Savon::Client)
+      expect(subject.agreement_number).to eq(123456)
+      expect(subject.user_name).to eq('api')
+      expect(subject.password).to eq('passw0rd')
     end
   end
 
   describe "connect" do
+    let(:authentication_details) { {:agreementNumber => 123456, :userName => 'api', :password => 'passw0rd'} }
+
     it "connects to e-conomic with authentication details" do
-      savon.expects('Connect').with(has_entries(:agreementNumber => 123456, :userName => 'api', :password => 'passw0rd')).returns(:success)
+      mock_request(:connect, authentication_details, :success)
       subject.connect
     end
 
-    it "stores the cookie for later requests" do
-      savon.expects('Connect').returns({:headers => {'Set-Cookie' => 'cookie'}})
+    it "stores the authentication token for later requests" do
+      response = {
+        :headers => {'Set-Cookie' => 'cookie value from e-conomic'},
+        :body => fixture(:connect, :success)
+      }
+      stub_request('Connect', authentication_details, response)
+
       subject.connect
-      client.stubs(:request).returns({})
-      subject.request(:foo) { }
-      client.http.headers['Cookie'].should == 'cookie'
+
+      expect(subject.authentication_token.collect { |cookie|
+        cookie.name_and_value.split("=").last
+      }).to eq(["cookie value from e-conomic"])
     end
 
-    it "updates the cookie for new sessions" do
-      savon.expects('Connect').returns({:headers => {'Set-Cookie' => 'cookie'}})
+    it "updates the authentication token for new sessions" do
+      stub_request("Connect", nil, {:headers => {"Set-Cookie" => "authentication token"}})
       subject.connect
+
+      stub_request('Connect', nil, {:headers => {"Set-Cookie" => "another token"}})
       other_session = Economic::Session.new(123456, 'api', 'passw0rd')
-      savon.expects('Connect').returns({:headers => {'Set-Cookie' => 'other-cookie'}})
       other_session.connect
 
-      client.stubs(:request).returns({})
-      subject.request(:foo) { }
-      client.http.headers['Cookie'].should == 'cookie'
+      expect(subject.authentication_token.collect { |cookie|
+        cookie.name_and_value.split("=").last
+      }).to eq(["authentication token"])
+      expect(other_session.authentication_token.collect { |cookie|
+        cookie.name_and_value.split("=").last
+      }).to eq(["another token"])
     end
 
-    it "removes existing cookie header before connecting" do
-      client.http.headers.expects(:delete).with('Cookie')
-      savon.stubs('Connect').returns({:headers => {'Set-Cookie' => 'cookie'}})
+    it "doesn't use existing authentication details when connecting" do
+      expect(endpoint).to receive(:call).with(:connect, instance_of(Hash))
       subject.connect
     end
   end
 
+  describe ".endpoint" do
+    it "returns Economic::Endpoint" do
+      expect(subject.endpoint).to be_instance_of(Economic::Endpoint)
+    end
+  end
+
   describe ".session" do
     it "returns self" do
-      subject.session.should === subject
+      expect(subject.session).to equal(subject)
     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
   end
 
   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
   end
 
   describe "invoices" do
     it "returns an InvoiceProxy" do
-      subject.invoices.should be_instance_of(Economic::InvoiceProxy)
+      expect(subject.invoices).to be_instance_of(Economic::InvoiceProxy)
     end
 
     it "memoizes the proxy" do
-      subject.invoices.should === subject.invoices
+      expect(subject.invoices).to equal(subject.invoices)
     end
   end
 
   describe "debtors" do
     it "returns a DebtorProxy" do
-      subject.debtors.should be_instance_of(Economic::DebtorProxy)
+      expect(subject.debtors).to be_instance_of(Economic::DebtorProxy)
     end
 
     it "memoizes the proxy" do
-      subject.debtors.should === subject.debtors
+      expect(subject.debtors).to equal(subject.debtors)
     end
   end
 
   describe "request" do
     it "sends a request to API" do
-      client.expects(:request).with(:economic, :foo).returns({})
-      subject.request(:foo, {})
+      expect(endpoint).to receive(:call).with(
+        :invoice_get_all,
+        {},
+        nil
+      ).and_return({})
+      subject.request(:invoice_get_all, {})
     end
 
     it "sends data if given" do
-      savon.expects('CurrentInvoice_GetAll').with(:bar => :baz).returns(:none)
+      mock_request(:current_invoice_get_all, {:bar => :baz}, :none)
       subject.request(:current_invoice_get_all, {:bar => :baz})
     end
 
     it "returns a hash with data" do
-      savon.stubs('CurrentInvoice_GetAll').returns(:single)
-      subject.request(:current_invoice_get_all).should == {:current_invoice_handle => {:id => "1"}}
+      stub_request(:current_invoice_get_all, nil, :single)
+      expect(subject.request(:current_invoice_get_all)).to eq({:current_invoice_handle => {:id => "1"}})
     end
 
     it "returns an empty hash if no data returned" do
-      savon.stubs('CurrentInvoice_GetAll').returns(:none)
-      subject.request(:current_invoice_get_all).should be_empty
+      stub_request(:current_invoice_get_all, nil, :none)
+      expect(subject.request(:current_invoice_get_all)).to be_empty
     end
   end
 

data/spec/fixtures/{spec_entity_create_from_data → account_create_from_data}/success.xml

@@ -1,10 +1,10 @@
 <?xml version="1.0" encoding="utf-8"?>
 <soap:Envelope xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/">
   <soap:Body>
-    <SpecEntity_CreateFromDataResponse xmlns="http://e-conomic.com">
-      <SpecEntity_CreateFromDataResult>
+    <Account_CreateFromDataResponse xmlns="http://e-conomic.com">
+      <Account_CreateFromDataResult>
         <Number>42</Number>
-      </SpecEntity_CreateFromDataResult>
-    </SpecEntity_CreateFromDataResponse>
+      </Account_CreateFromDataResult>
+    </Account_CreateFromDataResponse>
   </soap:Body>
-</soap:Envelope>
+</soap:Envelope>