sekken 0.1.0

data/spec/integration/wasmuth_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe 'Integration with Wasmuth' do
+
+  subject(:client) { Sekken.new(wsdl_url, http_mock) }
+
+  let(:wsdl_url)  { 'http://www3.mediaservice-wasmuth.de/online-ws-2.0/OnlineSync?wsdl' }
+
+  before do
+    http_mock.fake_request(wsdl_url, 'wsdl/wasmuth/wasmuth.wsdl')
+
+    # 2 schemas to import.
+    schema_import_base = 'http://www3.mediaservice-wasmuth.de:80/online-ws-2.0/OnlineSync?xsd=%d'
+    http_mock.fake_request(schema_import_base % 1, "wsdl/wasmuth/wasmuth1.xsd")
+    http_mock.fake_request(schema_import_base % 2, "wsdl/wasmuth/wasmuth2.xsd")
+  end
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'OnlineSyncService' => {
+        :ports => {
+          'OnlineSyncPort' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'http://www3.mediaservice-wasmuth.de:80/online-ws-2.0/OnlineSync'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the operations' do
+    operation = client.operation('OnlineSyncService', 'OnlineSyncPort', 'getStTables')
+
+    expect(operation.soap_action).to eq('')
+    expect(operation.endpoint).to eq('http://www3.mediaservice-wasmuth.de:80/online-ws-2.0/OnlineSync')
+
+    namespace = 'http://ws.online.msw/'
+
+    expect(operation.body_parts).to eq([
+      [['getStTables'],             { namespace: namespace, form: 'qualified',   singular: true }],
+      [['getStTables', 'username'], { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['getStTables', 'password'], { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['getStTables', 'version'],  { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }]
+    ])
+  end
+
+end

data/spec/integration/xignite_spec.rb

@@ -0,0 +1,112 @@
+require 'spec_helper'
+
+describe 'Integration with Xignite' do
+
+  # reference: http://www.xignite.com/product/global-security-master-data/api/GetSecurities/
+  subject(:client) { Sekken.new fixture('wsdl/xignite') }
+
+  let(:service_name) { :XigniteGlobalMaster }
+  let(:port_name)    { :XigniteGlobalMasterSoap12 }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'XigniteGlobalMaster' => {
+        ports: {
+          'XigniteGlobalMasterSoap' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'http://globalmaster.xignite.com/xglobalmaster.asmx'
+          },
+          'XigniteGlobalMasterSoap12' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap12/',
+            location: 'http://globalmaster.xignite.com/xglobalmaster.asmx'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the operations' do
+    operation = client.operation(service_name, port_name, :GetSecurities)
+
+    expect(operation.soap_action).to eq('http://www.xignite.com/services/GetSecurities')
+    expect(operation.endpoint).to eq('http://globalmaster.xignite.com/xglobalmaster.asmx')
+
+    namespace = 'http://www.xignite.com/services/'
+
+    expect(operation.body_parts).to eq([
+      [['GetSecurities'],                   { namespace: namespace, form: 'qualified', singular: true }],
+      [['GetSecurities', 'Identifiers'],    { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['GetSecurities', 'IdentifierType'], { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['GetSecurities', 'AsOfDate'],       { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }]
+    ])
+  end
+
+  it 'creates an example header' do
+    operation = client.operation(service_name, port_name, :GetSecurities)
+
+    expect(operation.example_header).to eq(
+      Header: {
+        Username: 'string',
+        Password: 'string',
+        Tracer: 'string'
+      }
+    )
+  end
+
+  it 'creates an example body' do
+    operation = client.operation(service_name, port_name, :GetSecurities)
+
+    expect(operation.example_body).to eq(
+      GetSecurities: {
+        Identifiers: 'string',
+        IdentifierType: 'string',
+        AsOfDate: 'string'
+      }
+    )
+  end
+
+  it 'creates a request with a header' do
+    operation = client.operation(service_name, port_name, :GetSecurities)
+
+    operation.header = {
+      Header: {
+        Username: 'test',
+        Password: 'secret',
+        Tracer: 'i-dont-know'
+      }
+    }
+
+    operation.body = {
+      GetSecurities: {
+        Identifiers: 'NESN.XVTX,BMW.XETR',
+        IdentifierType: 'Symbol',
+        AsOfDate: '6/4/2013'
+      }
+    }
+
+    expected = Nokogiri.XML('
+      <env:Envelope
+          xmlns:lol0="http://www.xignite.com/services/"
+          xmlns:env="http://www.w3.org/2003/05/soap-envelope">
+        <env:Header>
+          <lol0:Header>
+            <lol0:Username>test</lol0:Username>
+            <lol0:Password>secret</lol0:Password>
+            <lol0:Tracer>i-dont-know</lol0:Tracer>
+          </lol0:Header>
+        </env:Header>
+        <env:Body>
+          <lol0:GetSecurities>
+            <lol0:Identifiers>NESN.XVTX,BMW.XETR</lol0:Identifiers>
+            <lol0:IdentifierType>Symbol</lol0:IdentifierType>
+            <lol0:AsOfDate>6/4/2013</lol0:AsOfDate>
+          </lol0:GetSecurities>
+        </env:Body>
+      </env:Envelope>
+    ')
+
+    expect(Nokogiri.XML operation.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+end

data/spec/integration/yahoo_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe 'Integration with Yahoo\'s AccountService' do
+
+  subject(:client) { Sekken.new fixture('wsdl/yahoo') }
+
+  let(:service_name) { :AccountServiceService }
+  let(:port_name)    { :AccountService }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'AccountServiceService' => {
+        ports: {
+          'AccountService' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+
+            # symbolic endpoint
+            location: 'https://USE_ADDRESS_RETURNED_BY_LOCATION_SERVICE/services/V10/AccountService'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the operations' do
+    operation = client.operation(service_name, port_name, :updateStatusForManagedPublisher)
+
+    expect(operation.soap_action).to eq('')
+    expect(operation.endpoint).to eq('https://USE_ADDRESS_RETURNED_BY_LOCATION_SERVICE/services/V10/AccountService')
+
+    namespace = 'http://apt.yahooapis.com/V10'
+
+    expect(operation.body_parts).to eq([
+      [['updateStatusForManagedPublisher'],                  { namespace: namespace, form: 'qualified', singular: true }],
+      [['updateStatusForManagedPublisher', 'accountID'],     { namespace: namespace, form: 'qualified', singular: true, type: 'xsd:string' }],
+      [['updateStatusForManagedPublisher', 'accountStatus'], { namespace: namespace, form: 'qualified', singular: true, type: 'xsd:string' }]
+    ])
+  end
+
+  # multiple implicit headers. reference: http://www.ibm.com/developerworks/library/ws-tip-headers/index.html
+  it 'creates an example header' do
+    operation = client.operation(service_name, port_name, :updateStatusForManagedPublisher)
+
+    expect(operation.example_header).to eq(
+      Security: {
+        UsernameToken: {
+          Username: 'string',
+          Password: 'string'
+        }
+      },
+      license: 'string',
+      accountID: 'string'
+    )
+  end
+
+  it 'creates an example body' do
+    operation = client.operation(service_name, port_name, :updateStatusForManagedPublisher)
+
+    expect(operation.example_body).to eq(
+      updateStatusForManagedPublisher: {
+        accountID: 'string',
+        accountStatus: 'string'
+      }
+    )
+  end
+
+  it 'creates a request with multiple headers' do
+    operation = client.operation(service_name, port_name, :updateStatusForManagedPublisher)
+
+    operation.header = {
+      Security: {
+        UsernameToken: {
+          Username: 'admin',
+          Password: 'secret'
+        }
+      },
+      license: 'abc-license',
+      accountID: '23'
+    }
+
+    operation.body = {
+      updateStatusForManagedPublisher: {
+        accountID: '23',
+        accountStatus: 'closed'
+      }
+    }
+
+    expected = Nokogiri.XML('
+      <env:Envelope
+          xmlns:lol0="http://schemas.xmlsoap.org/ws/2002/07/secext"
+          xmlns:lol1="http://apt.yahooapis.com/V10"
+          xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+        <env:Header>
+          <lol0:Security>
+            <UsernameToken>
+              <Username>admin</Username>
+              <Password>secret</Password>
+            </UsernameToken>
+          </lol0:Security>
+          <lol1:license>abc-license</lol1:license>
+          <lol1:accountID>23</lol1:accountID>
+        </env:Header>
+        <env:Body>
+          <lol1:updateStatusForManagedPublisher>
+            <lol1:accountID>23</lol1:accountID>
+            <lol1:accountStatus>closed</lol1:accountStatus>
+          </lol1:updateStatusForManagedPublisher>
+        </env:Body>
+      </env:Envelope>
+    ')
+
+    expect(Nokogiri.XML operation.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+end

data/spec/sekken/httpclient_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe Sekken::HTTPClient do
+
+  subject(:http) { Sekken::HTTPClient.new }
+
+  describe '#client' do
+    it 'returns the HTTPClient instance to configure' do
+      expect(http.client).to be_an_instance_of(HTTPClient)
+    end
+  end
+
+  describe '#get' do
+    it 'executes an HTTP GET request and returns the raw response' do
+      url = 'http://example.com'
+
+      response = mock(content: 'raw get!')
+      http.client.expects(:request).with(:get, url, nil, nil, {}).returns(response)
+
+      raw_response = http.get(url)
+
+      expect(raw_response).to eq('raw get!')
+    end
+  end
+
+  describe '#post' do
+    it 'executes an HTTP POST request and returns the raw response' do
+      url = 'http://example.com'
+      body = 'post request!'
+      headers = { 'Content-Length' => 5 }
+
+      response = mock(content: 'raw post!')
+      http.client.expects(:request).with(:post, url, nil, body, headers).returns(response)
+
+      raw_response = http.post(url, headers, body)
+
+      expect(raw_response).to eq('raw post!')
+    end
+  end
+
+end

data/spec/sekken/operation/build_spec.rb

@@ -0,0 +1,308 @@
+require 'spec_helper'
+
+describe Sekken::Operation do
+
+  let(:add_logins) {
+    client = Sekken.new fixture('wsdl/bronto')
+
+    service_name = :BrontoSoapApiImplService
+    port_name    = :BrontoSoapApiImplPort
+
+    client.operation(service_name, port_name, :addLogins)
+  }
+
+  let(:get_mu_bets_lite) {
+    client = Sekken.new fixture('wsdl/betfair')
+
+    service_name = port_name = :BFExchangeService
+    client.operation(service_name, port_name, :getMUBetsLite)
+  }
+
+  let(:vatAccount_update_from_data_array) {
+    client = Sekken.new fixture('wsdl/arrays_with_attributes')
+
+    service, port = "EconomicWebService", "EconomicWebServiceSoap"
+
+    client.operation(service, port, 'VatAccount_UpdateFromDataArray')
+  }
+
+  let(:zanox_export_service){ 
+    client = Sekken.new fixture('wsdl/zanox_export_service')
+
+    service, port = "ExportService", "ExportServiceSoap"
+
+    client.operation(service, port, 'GetPps')
+  }
+
+  describe '#build' do
+    it 'expects Arrays of complex types as Arrays of Hashes' do
+      add_logins.body = {
+        addLogins: {
+
+          # accounts in an array of complex types
+          # which can be represented by hashes.
+          accounts: [
+            {
+              username: 'first',
+              password: 'secret',
+              contactInformation: {
+                email: 'first@example.com',
+              }
+            },
+            {
+              username: 'second',
+              password: 'ubersecret',
+              contactInformation: {
+                email: 'second@example.com',
+              }
+            }
+          ]
+        }
+      }
+
+      expected = Nokogiri.XML('
+        <env:Envelope
+            xmlns:lol0="http://api.bronto.com/v4"
+            xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+          <env:Header>
+          </env:Header>
+          <env:Body>
+            <lol0:addLogins>
+              <accounts>
+                <username>first</username>
+                <password>secret</password>
+                <contactInformation>
+                  <email>first@example.com</email>
+                </contactInformation>
+              </accounts>
+              <accounts>
+                <username>second</username>
+                <password>ubersecret</password>
+                <contactInformation>
+                  <email>second@example.com</email>
+                </contactInformation>
+              </accounts>
+            </lol0:addLogins>
+          </env:Body>
+        </env:Envelope>
+      ')
+
+      expect(Nokogiri.XML add_logins.build).
+        to be_equivalent_to(expected).respecting_element_order
+    end
+
+    it 'raises if it did not receive a Hash for a singular complex type' do
+      add_logins.body = {
+        addLogins: [
+          {
+            accounts: {
+              username: 'test'
+            }
+          }
+        ]
+      }
+
+      expect { add_logins.build }.
+        to raise_error(ArgumentError, "Expected a Hash for the :addLogins complex type")
+    end
+
+    it 'raises if it did not receive an Array for an Array of complex types' do
+      add_logins.body = {
+        addLogins: {
+
+          # accounts is an array and we expect the value
+          # to be an array of hashes to reflect this.
+          accounts: {
+            username: 'test'
+          }
+        }
+      }
+
+      expect { add_logins.build }.
+        to raise_error(ArgumentError, "Expected an Array of Hashes for the :accounts complex type")
+    end
+
+    it 'raises if it received an Array for a singular simple type' do
+      add_logins.body = {
+        addLogins: {
+          accounts: [
+            {
+              username: ['multiple', 'tests']
+            }
+          ]
+        }
+      }
+
+      expect { add_logins.build }.
+        to raise_error(ArgumentError, "Unexpected Array for the :username simple type")
+    end
+
+    it 'expectes Arrays of simple types to be represented as Arrays of values' do
+      get_mu_bets_lite.body = {
+        getMUBetsLite: {
+          request: {
+            betIds: {
+              betId: [1, 2, 3]
+            }
+          }
+        }
+      }
+
+      expected = Nokogiri.XML(%{
+        <env:Envelope
+            xmlns:lol0="http://www.betfair.com/publicapi/v5/BFExchangeService/"
+            xmlns:lol1="http://www.betfair.com/publicapi/types/exchange/v5/"
+            xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+          <env:Header/>
+          <env:Body>
+            <lol0:getMUBetsLite>
+              <lol0:request>
+                <betIds>
+                  <lol1:betId>1</lol1:betId>
+                  <lol1:betId>2</lol1:betId>
+                  <lol1:betId>3</lol1:betId>
+                </betIds>
+              </lol0:request>
+            </lol0:getMUBetsLite>
+          </env:Body>
+        </env:Envelope>
+      })
+
+      expect(Nokogiri.XML get_mu_bets_lite.build).
+        to be_equivalent_to(expected).respecting_element_order
+    end
+
+    it 'raises if it did not receive an Array for an Array of simple types' do
+      get_mu_bets_lite.body = {
+        getMUBetsLite: {
+          request: {
+            betIds: {
+              betId: 1
+            }
+          }
+        }
+      }
+
+      expect { get_mu_bets_lite.build }.
+        to raise_error(ArgumentError, "Expected an Array of values for the :betId simple type")
+    end
+
+    it 'test' do
+      zanox_export_service.header = {
+        zanox: {
+          ticket: 'EFB745D691DBFF2DFA9F8B10A4D7A7B1AEA850CD'
+        }
+      }
+      zanox_export_service.body = {
+        :GetPps => {
+          programid: 5574,
+          ppsfilter: {
+              period: {
+                :_from => '2013-10-01T00:00:00+02:00', 
+                :_to   => '2013-11-12T00:00:00+02:00'
+              },
+              :reviewstate => {reviewstate: 0, :_negate => 1},
+              :categoryid => {}
+          }
+        }
+      }
+
+      expected = Nokogiri.XML(%{
+        <env:Envelope xmlns:lol0="http://services.zanox.com/erp" xmlns:lol1="http://services.zanox.com/erp/Export" xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+          <env:Header>
+            <lol0:zanox>
+              <lol0:ticket>EFB745D691DBFF2DFA9F8B10A4D7A7B1AEA850CD</lol0:ticket>
+            </lol0:zanox>
+          </env:Header>
+          <env:Body>
+            <lol0:GetPps>
+              <lol0:programid>5574</lol0:programid>
+              <lol1:ppsfilter>
+                <lol1:period from="2013-10-01T00:00:00+02:00" to="2013-11-12T00:00:00+02:00"/>
+                <lol1:reviewstate negate='1'>0</lol1:reviewstate>
+                <lol1:categoryid/>
+              </lol1:ppsfilter>
+            </lol0:GetPps>
+          </env:Body>
+        </env:Envelope>})
+
+      expect(Nokogiri.XML zanox_export_service.build).
+          to be_equivalent_to(expected).respecting_element_order      
+    end
+
+    it 'expects Array of Hashes with attributes to return Array of complex types with attributes' do
+      vatAccount_update_from_data_array.body = {
+          :VatAccount_UpdateFromDataArray => {
+              :dataArray => {
+                  :VatAccountData => [
+                      {
+                          :Handle => {:VatCode => "VAT123"},
+                          :VatCode => {:_attribute => 'test', :_foo => 11, :VatCode => "VAT123"},
+                          :Name => "ITS",
+                          :Type => "Ltd",
+                          :RateAsPercent => 17.5,
+                          :AccountHandle => {:Number => 123}, :ContraAccountHandle => {:Number => 456},
+                          :_Thaco => "Testing 1234"
+                      },
+                      {
+                          :Handle => {:VatCode => "VAT987"},
+                          :VatCode => "VAT987",
+                          :Name => "Banana",
+                          :Type => "PLC",
+                          :RateAsPercent => 21.12,
+                          :AccountHandle => {:Number => 876}, :ContraAccountHandle => {:Number => 8756},
+                          :_Thaco => "Testing 5678"
+                      }
+                  ]
+              }
+          }
+      }
+
+      expected = Nokogiri.XML(%{
+        <env:Envelope xmlns:lol0="http://e-conomic.com" xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+          <env:Header>
+          </env:Header>
+          <env:Body>
+            <lol0:VatAccount_UpdateFromDataArray>
+              <lol0:dataArray>
+                <lol0:VatAccountData Thaco="Testing 1234">
+                  <lol0:Handle>
+                    <lol0:VatCode>VAT123</lol0:VatCode>
+                  </lol0:Handle>
+                  <lol0:VatCode attribute='test' foo='11'>VAT123</lol0:VatCode>
+                  <lol0:Name>ITS</lol0:Name>
+                  <lol0:Type>Ltd</lol0:Type>
+                  <lol0:RateAsPercent>17.5</lol0:RateAsPercent>
+                  <lol0:AccountHandle>
+                    <lol0:Number>123</lol0:Number>
+                  </lol0:AccountHandle>
+                  <lol0:ContraAccountHandle>
+                    <lol0:Number>456</lol0:Number>
+                  </lol0:ContraAccountHandle>
+                </lol0:VatAccountData>
+                <lol0:VatAccountData Thaco="Testing 5678">
+                  <lol0:Handle>
+                    <lol0:VatCode>VAT987</lol0:VatCode>
+                  </lol0:Handle>
+                  <lol0:VatCode>VAT987</lol0:VatCode>
+                  <lol0:Name>Banana</lol0:Name>
+                  <lol0:Type>PLC</lol0:Type>
+                  <lol0:RateAsPercent>21.12</lol0:RateAsPercent>
+                  <lol0:AccountHandle>
+                    <lol0:Number>876</lol0:Number>
+                  </lol0:AccountHandle>
+                  <lol0:ContraAccountHandle>
+                    <lol0:Number>8756</lol0:Number>
+                  </lol0:ContraAccountHandle>
+                </lol0:VatAccountData>
+              </lol0:dataArray>
+            </lol0:VatAccount_UpdateFromDataArray>
+          </env:Body>
+        </env:Envelope>})
+
+      expect(Nokogiri.XML vatAccount_update_from_data_array.build).
+          to be_equivalent_to(expected).respecting_element_order
+    end
+  end
+
+end