sekken 0.1.0

data/spec/integration/amazon_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe 'Integration with Amazon' do
+
+  subject(:client) { Sekken.new fixture('wsdl/amazon') }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'AmazonFPS' => {
+        :ports => {
+          'AmazonFPSPort' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'https://fps.amazonaws.com'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the operations' do
+    service, port = 'AmazonFPS', 'AmazonFPSPort'
+    operation = client.operation(service, port, 'Pay')
+
+    expect(operation.soap_action).to eq('Pay')
+    expect(operation.endpoint).to eq('https://fps.amazonaws.com')
+
+    namespace = 'http://fps.amazonaws.com/doc/2008-09-17/'
+
+    expect(operation.body_parts).to eq([
+      [['Pay'],                                           { namespace: namespace, form: 'qualified', singular: true }],
+      [['Pay', 'SenderTokenId'],                          { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['Pay', 'RecipientTokenId'],                       { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['Pay', 'TransactionAmount'],                      { namespace: namespace, form: 'qualified', singular: true }],
+      [['Pay', 'TransactionAmount', 'CurrencyCode'],      { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['Pay', 'TransactionAmount', 'Value'],             { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['Pay', 'ChargeFeeTo'],                            { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['Pay', 'CallerReference'],                        { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['Pay', 'CallerDescription'],                      { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['Pay', 'SenderDescription'],                      { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['Pay', 'DescriptorPolicy'],                       { namespace: namespace, form: 'qualified', singular: true }],
+      [['Pay', 'DescriptorPolicy', 'SoftDescriptorType'], { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['Pay', 'DescriptorPolicy', 'CSOwner'],            { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['Pay', 'TransactionTimeoutInMins'],               { namespace: namespace, form: 'qualified', singular: true, type: 'xs:integer' }],
+      [['Pay', 'MarketplaceFixedFee'],                    { namespace: namespace, form: 'qualified', singular: true }],
+      [['Pay', 'MarketplaceFixedFee', 'CurrencyCode'],    { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['Pay', 'MarketplaceFixedFee', 'Value'],           { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['Pay', 'MarketplaceVariableFee'],                 { namespace: namespace, form: 'qualified', singular: true, type: 'xs:decimal' }]
+    ])
+  end
+
+end

data/spec/integration/authentication_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe 'Integration with Authentication service' do
+
+  subject(:client) { Sekken.new fixture('wsdl/authentication') }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'AuthenticationWebServiceImplService' => {
+        :ports => {
+          'AuthenticationWebServiceImplPort' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'http://example.com/validation/1.0/AuthenticationService'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the operations' do
+    service = 'AuthenticationWebServiceImplService'
+    port = 'AuthenticationWebServiceImplPort'
+
+    operation = client.operation(service, port, 'authenticate')
+
+    expect(operation.soap_action).to eq('')
+    expect(operation.endpoint).to eq('http://example.com/validation/1.0/AuthenticationService')
+
+    namespace = 'http://v1_0.ws.auth.order.example.com/'
+
+    expect(operation.body_parts).to eq([
+      [['authenticate'],             { namespace: namespace, form: 'qualified', singular: true }],
+      [['authenticate', 'user'],     { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['authenticate', 'password'], { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }]
+    ])
+  end
+
+end

data/spec/integration/awse_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe 'Integration with AWSE' do
+
+subject(:client) { Sekken.new fixture('wsdl/awse') }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'AWSECommerceService' => {
+        ports: {
+          'AWSECommerceServicePort' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'https://webservices.amazon.com/onca/soap?Service=AWSECommerceService'
+          },
+          'AWSECommerceServicePortCA' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'https://webservices.amazon.ca/onca/soap?Service=AWSECommerceService'
+          },
+          'AWSECommerceServicePortCN' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'https://webservices.amazon.cn/onca/soap?Service=AWSECommerceService'
+          },
+          'AWSECommerceServicePortDE' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'https://webservices.amazon.de/onca/soap?Service=AWSECommerceService'
+          },
+          'AWSECommerceServicePortFR' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'https://webservices.amazon.fr/onca/soap?Service=AWSECommerceService'
+          },
+          'AWSECommerceServicePortIT' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'https://webservices.amazon.it/onca/soap?Service=AWSECommerceService'
+          },
+          'AWSECommerceServicePortJP' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'https://webservices.amazon.co.jp/onca/soap?Service=AWSECommerceService'
+          },
+          'AWSECommerceServicePortUK' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'https://webservices.amazon.co.uk/onca/soap?Service=AWSECommerceService'
+          },
+          'AWSECommerceServicePortUS' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'https://webservices.amazon.com/onca/soap?Service=AWSECommerceService'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the operations' do
+    service, port = 'AWSECommerceService', 'AWSECommerceServicePort'
+    operation = client.operation(service, port, 'CartAdd')
+
+    expect(operation.soap_action).to eq('http://soap.amazon.com/CartAdd')
+    expect(operation.endpoint).to eq('https://webservices.amazon.com/onca/soap?Service=AWSECommerceService')
+
+    namespace = 'http://webservices.amazon.com/AWSECommerceService/2011-08-01'
+
+    expect(operation.body_parts).to eq([
+      [['CartAdd'],                                               { namespace: namespace, form: 'qualified', singular: true }],
+      [['CartAdd', 'MarketplaceDomain'],                          { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'AWSAccessKeyId'],                             { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'AssociateTag'],                               { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Validate'],                                   { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'XMLEscaping'],                                { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Shared'],                                     { namespace: namespace, form: 'qualified', singular: true }],
+      [['CartAdd', 'Shared', 'CartId'],                           { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Shared', 'HMAC'],                             { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Shared', 'MergeCart'],                        { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Shared', 'Items'],                            { namespace: namespace, form: 'qualified', singular: true }],
+      [['CartAdd', 'Shared', 'Items', 'Item'],                    { namespace: namespace, form: 'qualified', singular: false }],
+      [['CartAdd', 'Shared', 'Items', 'Item', 'ASIN'],            { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Shared', 'Items', 'Item', 'OfferListingId'],  { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Shared', 'Items', 'Item', 'Quantity'],        { namespace: namespace, form: 'qualified', singular: true, type: 'xs:positiveInteger' }],
+      [['CartAdd', 'Shared', 'Items', 'Item', 'AssociateTag'],    { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Shared', 'Items', 'Item', 'ListItemId'],      { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Shared', 'ResponseGroup'],                    { namespace: namespace, form: 'qualified', singular: false, type: 'xs:string' }],
+      [['CartAdd', 'Request'],                                    { namespace: namespace, form: 'qualified', singular: false }],
+      [['CartAdd', 'Request', 'CartId'],                          { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Request', 'HMAC'],                            { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Request', 'MergeCart'],                       { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Request', 'Items'],                           { namespace: namespace, form: 'qualified', singular: true }],
+      [['CartAdd', 'Request', 'Items', 'Item'],                   { namespace: namespace, form: 'qualified', singular: false }],
+      [['CartAdd', 'Request', 'Items', 'Item', 'ASIN'],           { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Request', 'Items', 'Item', 'OfferListingId'], { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Request', 'Items', 'Item', 'Quantity'],       { namespace: namespace, form: 'qualified', singular: true, type: 'xs:positiveInteger' }],
+      [['CartAdd', 'Request', 'Items', 'Item', 'AssociateTag'],   { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Request', 'Items', 'Item', 'ListItemId'],     { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }],
+      [['CartAdd', 'Request', 'ResponseGroup'],                   { namespace: namespace, form: 'qualified', singular: false, type: 'xs:string' }]
+    ])
+  end
+
+end

data/spec/integration/betfair_spec.rb

@@ -0,0 +1,179 @@
+require 'spec_helper'
+
+describe 'Integration with Betfair' do
+
+  subject(:client) { Sekken.new fixture('wsdl/betfair') }
+
+  let(:service_name) { :BFExchangeService }
+  let(:port_name)    { :BFExchangeService }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'BFExchangeService' => {
+        :ports => {
+          'BFExchangeService' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'https://api.betfair.com/exchange/v5/BFExchangeService'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows operations with extensions and Arrays' do
+    service = port = 'BFExchangeService'
+    operation = client.operation(service, port, 'getMUBetsLite')
+
+    expect(operation.soap_action).to eq('getMUBetsLite')
+    expect(operation.endpoint).to eq('https://api.betfair.com/exchange/v5/BFExchangeService')
+
+    ns = 'http://www.betfair.com/publicapi/v5/BFExchangeService/'
+    ns2 = 'http://www.betfair.com/publicapi/types/exchange/v5/'
+
+    expect(operation.body_parts).to eq([
+      [['getMUBetsLite'],
+        { namespace: ns, form: 'qualified',   singular: true }],
+
+      [['getMUBetsLite', 'request'],
+        { namespace: ns, form: 'qualified',   singular: true }],
+
+      # extension elements
+
+      [['getMUBetsLite', 'request', 'header'],
+         { namespace: ns2, form: 'unqualified', singular: true }],
+
+      [['getMUBetsLite', 'request', 'header', 'clientStamp'],
+         { namespace: ns2, form: 'unqualified', singular: true, type: 'xsd:long' }],
+
+      [['getMUBetsLite', 'request', 'header', 'sessionToken'],
+         { namespace: ns2, form: 'unqualified', singular: true, type: 'xsd:string' }],
+
+      # ---
+
+      [['getMUBetsLite', 'request', 'betStatus'],
+        { namespace: ns2, form: 'unqualified', singular: true,  type: 'xsd:string' }],
+
+      [['getMUBetsLite', 'request', 'marketId'],
+        { namespace: ns2, form: 'unqualified', singular: true,  type: 'xsd:int' }],
+
+      [['getMUBetsLite', 'request', 'betIds'],
+        { namespace: ns2, form: 'unqualified', singular: true }],
+
+      [['getMUBetsLite', 'request', 'betIds', 'betId'],
+        { namespace: ns2, form: 'qualified',   singular: false, type: 'xsd:long' }],
+
+      [['getMUBetsLite', 'request', 'orderBy'],
+        { namespace: ns2, form: 'unqualified', singular: true,  type: 'xsd:string' }],
+
+      [['getMUBetsLite', 'request', 'sortOrder'],
+        { namespace: ns2, form: 'unqualified', singular: true,  type: 'xsd:string' }],
+
+      [['getMUBetsLite', 'request', 'recordCount'],
+        { namespace: ns2, form: 'unqualified', singular: true,  type: 'xsd:int' }],
+
+      [['getMUBetsLite', 'request', 'startRecord'],
+        { namespace: ns2, form: 'unqualified', singular: true,  type: 'xsd:int' }],
+
+      [['getMUBetsLite', 'request', 'matchedSince'],
+        { namespace: ns2, form: 'unqualified', singular: true,  type: 'xsd:dateTime' }],
+
+      [['getMUBetsLite', 'request', 'excludeLastSecond'],
+        { namespace: ns2, form: 'unqualified', singular: true,  type: 'xsd:boolean' }]
+    ])
+  end
+
+  it 'creates a proper example request for messages with Arrays' do
+    operation = client.operation(service_name, port_name, :getMUBetsLite)
+
+    expect(operation.example_body).to eq(
+      getMUBetsLite: {
+        request: {
+
+          # This is an extension
+          header: {
+            clientStamp: 'long',
+            sessionToken: 'string'
+          },
+
+          betStatus: 'string',
+          marketId: 'int',
+          betIds: {
+
+            # This is an Array of simpleTypes
+            betId: ['long']
+
+          },
+          orderBy: 'string',
+          sortOrder: 'string',
+          recordCount: 'int',
+          startRecord: 'int',
+          matchedSince: 'dateTime',
+          excludeLastSecond: 'boolean'
+        }
+      }
+    )
+  end
+
+  it 'builds a request for extensions and Arrays' do
+    operation = client.operation(service_name, port_name, :getMUBetsLite)
+    datetime_value = (Time.now - 365).xmlschema
+
+    operation.body = {
+      getMUBetsLite: {
+        request: {
+          header: {
+            clientStamp: 'test',
+            sessionToken: 'token'
+          },
+          betStatus: 'U',
+          marketId: 1,
+          betIds: {
+            betId: [1, 2, 3]
+          },
+          orderBy: 'NONE',
+          sortOrder: 'DESC',
+          recordCount: 10,
+          startRecord: 1,
+          matchedSince: datetime_value,
+          excludeLastSecond: true
+        }
+      }
+    }
+
+    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>
+              <header>
+                <clientStamp>test</clientStamp>
+                <sessionToken>token</sessionToken>
+              </header>
+              <betStatus>U</betStatus>
+              <marketId>1</marketId>
+              <betIds>
+                <lol1:betId>1</lol1:betId>
+                <lol1:betId>2</lol1:betId>
+                <lol1:betId>3</lol1:betId>
+              </betIds>
+              <orderBy>NONE</orderBy>
+              <sortOrder>DESC</sortOrder>
+              <recordCount>10</recordCount>
+              <startRecord>1</startRecord>
+              <matchedSince>#{datetime_value}</matchedSince>
+              <excludeLastSecond>true</excludeLastSecond>
+            </lol0:request>
+          </lol0:getMUBetsLite>
+        </env:Body>
+      </env:Envelope>
+    })
+
+    expect(Nokogiri.XML operation.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+end

data/spec/integration/blz_service_spec.rb

@@ -0,0 +1,46 @@
+ require 'spec_helper'
+
+describe 'Integration with BLZService' do
+
+  subject(:client) { Sekken.new fixture('wsdl/blz_service') }
+
+  let(:service_name) { :BLZService }
+  let(:port_name)    { :BLZServiceSOAP11port_http }
+
+  it 'creates an example request' do
+    operation = client.operation(service_name, port_name, :getBank)
+
+    expect(operation.example_body).to eq(
+      getBank: {
+        blz: 'string'
+      }
+    )
+  end
+
+  it 'builds a request' do
+    operation = client.operation(service_name, port_name, :getBank)
+
+    operation.body = {
+      getBank: {
+        blz: 70070010
+      }
+    }
+
+    expected = Nokogiri.XML(%{
+      <env:Envelope
+          xmlns:lol0="http://thomas-bayer.com/blz/"
+          xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+        <env:Header/>
+        <env:Body>
+          <lol0:getBank>
+            <lol0:blz>70070010</lol0:blz>
+          </lol0:getBank>
+        </env:Body>
+      </env:Envelope>
+    })
+
+    expect(Nokogiri.XML operation.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+end

data/spec/integration/bookt_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe 'Integration with Bookt' do
+
+  subject(:client) { Sekken.new(wsdl_url, http_mock) }
+
+  let(:wsdl_url)  { 'http://connect.bookt.com/svc/connect.svc?wsdl' }
+  let(:wsdl2_url) { 'http://connect.bookt.com/svc/connect.svc?wsdl=wsdl1' }
+  let(:wsdl3_url) { 'http://connect.bookt.com/svc/connect.svc?wsdl=wsdl0' }
+
+  before do
+    http_mock.fake_request(wsdl_url,  'wsdl/bookt/bookt.wsdl')
+    http_mock.fake_request(wsdl2_url, 'wsdl/bookt/bookt2.wsdl')
+    http_mock.fake_request(wsdl3_url, 'wsdl/bookt/bookt3.wsdl')
+
+    # 16 schemas to import
+    schema_import_base = 'http://connect.bookt.com/svc/connect.svc?xsd=xsd%d'
+    (0..15).each do |i|
+      url = schema_import_base % i
+      http_mock.fake_request(url, "wsdl/bookt/bookt#{i}.xsd")
+    end
+  end
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'Connect'       => {
+        :ports        => {
+          'IConnect'  => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'http://connect.bookt.com/svc/connect.svc'
+          }
+        }
+      }
+    )
+  end
+
+  it 'resolves WSDL imports to get the operations' do
+    operations = client.operations('Connect', 'IConnect')
+
+    expect(operations).to be_an(Array)
+    expect(operations.count).to eq(26)
+
+    expect(operations).to include('GetBooking')
+  end
+
+  it 'resolves XML Schema imports to get all elements' do
+    get_booking = client.operation('Connect', 'IConnect', 'GetBooking')
+
+    namespace = 'https://connect.bookt.com/connect'
+
+    expect(get_booking.body_parts).to eq([
+      [['GetBooking'],                  { namespace: namespace, form: 'qualified', singular: true }],
+      [['GetBooking', 'apiKey'],        { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string'  }],
+      [['GetBooking', 'bookingID'],     { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string'  }],
+      [['GetBooking', 'useInternalID'], { namespace: namespace, form: 'qualified', singular: true, type: 'xs:boolean' }]
+    ])
+  end
+
+end