sekken 0.1.0

data/spec/integration/bronto_spec.rb

@@ -0,0 +1,178 @@
+require 'spec_helper'
+
+describe 'Integration with Bronto' do
+
+  subject(:client) { Sekken.new fixture('wsdl/bronto') }
+
+  let(:service_name) { :BrontoSoapApiImplService }
+  let(:port_name)    { :BrontoSoapApiImplPort }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'BrontoSoapApiImplService' => {
+        ports: {
+          'BrontoSoapApiImplPort' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'https://api.bronto.com/v4'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the operations' do
+    operation = client.operation(service_name, port_name, :addLogins)
+
+    expect(operation.soap_action).to eq('')
+    expect(operation.endpoint).to eq('https://api.bronto.com/v4')
+
+    namespace = 'http://api.bronto.com/v4'
+
+    expect(operation.body_parts).to eq([
+      [['addLogins'],                                                   { namespace: namespace, form: 'qualified',   singular: true }],
+      [['addLogins', 'accounts'],                                       { namespace: namespace, form: 'unqualified', singular: false }],
+      [['addLogins', 'accounts', 'username'],                           { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'password'],                           { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'contactInformation'],                 { namespace: namespace, form: 'unqualified', singular: true }],
+      [['addLogins', 'accounts', 'contactInformation', 'organization'], { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'contactInformation', 'firstName'],    { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'contactInformation', 'lastName'],     { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'contactInformation', 'email'],        { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'contactInformation', 'phone'],        { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'contactInformation', 'address'],      { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'contactInformation', 'address2'],     { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'contactInformation', 'city'],         { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'contactInformation', 'state'],        { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'contactInformation', 'zip'],          { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'contactInformation', 'country'],      { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'contactInformation', 'notes'],        { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:string' }],
+      [['addLogins', 'accounts', 'permissionAgencyAdmin'],              { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionAdmin'],                    { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionApi'],                      { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionUpgrade'],                  { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionFatigueOverride'],          { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionMessageCompose'],           { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionMessageApprove'],           { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionMessageDelete'],            { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionAutomatorCompose'],         { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionListCreateSend'],           { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionListCreate'],               { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionSegmentCreate'],            { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionFieldCreate'],              { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionFieldReorder'],             { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionSubscriberCreate'],         { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }],
+      [['addLogins', 'accounts', 'permissionSubscriberView'],           { namespace: namespace, form: 'unqualified', singular: true, type: 'xs:boolean' }]
+    ])
+  end
+
+  # explicit 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, :addLogins)
+
+    expect(operation.example_header).to eq(
+      sessionHeader: {
+        sessionId: 'string'
+      }
+    )
+  end
+
+  it 'creates an example body' do
+    operation = client.operation(service_name, port_name, :addLogins)
+
+    expect(operation.example_body).to eq(
+      addLogins: {
+        accounts: [
+          {
+            username: 'string',
+            password: 'string',
+            contactInformation: {
+              organization: 'string',
+              firstName: 'string',
+              lastName: 'string',
+              email: 'string',
+              phone: 'string',
+              address: 'string',
+              address2: 'string',
+              city: 'string',
+              state: 'string',
+              zip: 'string',
+              country: 'string',
+              notes: 'string'
+            },
+            permissionAgencyAdmin: 'boolean',
+            permissionAdmin: 'boolean',
+            permissionApi: 'boolean',
+            permissionUpgrade: 'boolean',
+            permissionFatigueOverride: 'boolean',
+            permissionMessageCompose: 'boolean',
+            permissionMessageApprove: 'boolean',
+            permissionMessageDelete: 'boolean',
+            permissionAutomatorCompose: 'boolean',
+            permissionListCreateSend: 'boolean',
+            permissionListCreate: 'boolean',
+            permissionSegmentCreate: 'boolean',
+            permissionFieldCreate: 'boolean',
+            permissionFieldReorder: 'boolean',
+            permissionSubscriberCreate: 'boolean',
+            permissionSubscriberView: 'boolean'
+          }
+        ]
+      }
+    )
+  end
+
+  it 'creates a request with a header' do
+    operation = client.operation(service_name, port_name, :addLogins)
+
+    operation.header = {
+      sessionHeader: {
+        sessionId: '23'
+      }
+    }
+
+    operation.body = {
+      addLogins: {
+        accounts: [
+          {
+            username: 'admin',
+            password: 'secert',
+            contactInformation: {
+              firstName: 'brew',
+              email: 'brew@example.com',
+            },
+            permissionApi: true,
+          }
+        ]
+      }
+    }
+
+    expected = Nokogiri.XML('
+      <env:Envelope
+          xmlns:lol0="http://api.bronto.com/v4"
+          xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+        <env:Header>
+          <lol0:sessionHeader>
+            <sessionId>23</sessionId>
+          </lol0:sessionHeader>
+        </env:Header>
+        <env:Body>
+          <lol0:addLogins>
+            <accounts>
+              <username>admin</username>
+              <password>secert</password>
+              <contactInformation>
+                <firstName>brew</firstName>
+                <email>brew@example.com</email>
+              </contactInformation>
+              <permissionApi>true</permissionApi>
+            </accounts>
+          </lol0:addLogins>
+        </env:Body>
+      </env:Envelope>
+    ')
+
+    expect(Nokogiri.XML operation.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+end

data/spec/integration/bydexchange_spec.rb

@@ -0,0 +1,40 @@
+require 'spec_helper'
+
+describe 'Integration with BYDExchange' do
+
+  subject(:client) { Sekken.new(wsdl_url, http_mock) }
+
+  let(:wsdl_url)  { 'http://bydexchange.nbs-us.com/BYDExchangeServer.svc?wsdl' }
+  let(:wsdl2_url) { 'http://bydexchange.nbs-us.com/BYDExchangeServer.svc?wsdl=wsdl0' }
+
+  before do
+    http_mock.fake_request(wsdl_url, 'wsdl/bydexchange/bydexchange.wsdl')
+    http_mock.fake_request(wsdl2_url, 'wsdl/bydexchange/bydexchange2.wsdl')
+
+    # 8 schemas to import
+    schema_import_base = 'http://bydexchange.nbs-us.com/BYDExchangeServer.svc?xsd=xsd%d'
+    (0..8).each do |i|
+      url = schema_import_base % i
+      http_mock.fake_request(url, "wsdl/bydexchange/bydexchange#{i}.xsd")
+    end
+  end
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'BYDExchangeServer' => {
+        :ports => {
+          'BasicHttpBinding_IBYDExchangeServer' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'http://bydexchange.nbs-us.com/BYDExchangeServer.svc'
+          }
+        }
+      }
+    )
+  end
+
+  it 'resolves WSDL imports to get the operations' do
+    operations = client.operations('BYDExchangeServer', 'BasicHttpBinding_IBYDExchangeServer')
+    expect(operations).to include('GetCustomer')
+  end
+
+end

data/spec/integration/crowd_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe 'Integration with Atlassian Crowd' do
+
+  subject(:client) { Sekken.new fixture('wsdl/crowd') }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'SecurityServer' => {
+        :ports => {
+          'SecurityServerHttpPort' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'http://magnesium:8095/crowd/services/SecurityServer'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the operations' do
+    service, port = 'SecurityServer', 'SecurityServerHttpPort'
+    operation = client.operation(service, port, 'addAttributeToGroup')
+
+    expect(operation.soap_action).to eq('')
+    expect(operation.endpoint).to eq('http://magnesium:8095/crowd/services/SecurityServer')
+
+    ns1 = 'urn:SecurityServer'
+    ns2 = 'http://authentication.integration.crowd.atlassian.com'
+    ns3 = 'http://soap.integration.crowd.atlassian.com'
+
+    expect(operation.body_parts).to eq([
+      [['addAttributeToGroup'],                            { namespace: ns1, form: 'qualified', singular: true }],
+      [['addAttributeToGroup', 'in0'],                     { namespace: ns1, form: 'qualified', singular: true }],
+      [['addAttributeToGroup', 'in0', 'name'],             { namespace: ns2, form: 'qualified', singular: true, type: 'xsd:string' }],
+      [['addAttributeToGroup', 'in0', 'token'],            { namespace: ns2, form: 'qualified', singular: true, type: 'xsd:string' }],
+      [['addAttributeToGroup', 'in1'],                     { namespace: ns1, form: 'qualified', singular: true, type: 'xsd:string' }],
+      [['addAttributeToGroup', 'in2'],                     { namespace: ns1, form: 'qualified', singular: true }],
+      [['addAttributeToGroup', 'in2', 'name'],             { namespace: ns3, form: 'qualified', singular: true, type: 'xsd:string' }],
+      [['addAttributeToGroup', 'in2', 'values'],           { namespace: ns3, form: 'qualified', singular: true }],
+      [['addAttributeToGroup', 'in2', 'values', 'string'], { namespace: ns1, form: 'qualified', singular: false, type: 'xsd:string' }]
+    ])
+  end
+
+end

data/spec/integration/data_exchange_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+
+describe 'Integration with DataExchange' do
+
+  subject(:client) { Sekken.new fixture('wsdl/data_exchange') }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'DataExchange'       => {
+        :ports        => {
+          'DataExchange'  => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'http://my.yfu.org/cgi-bin/WebObjects/WebService.woa/ws/DataExchange'
+          }
+        }
+      }
+    )
+  end
+
+  it 'raises an error because RPC/encoded operations are not ' do
+    service = port = 'DataExchange'
+
+    expect { client.operation(service, port, 'submit') }.
+      to raise_error(Sekken::UnsupportedStyleError, /"submit" is an "rpc\/encoded" style operation/)
+  end
+
+end

data/spec/integration/document_literal_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+describe 'Integration with a Document/Literal example' do
+
+  subject(:client) { Sekken.new fixture('wsdl/document_literal_wrapped') }
+
+  let(:service_name) { :SampleService }
+  let(:port_name)    { :Sample }
+
+  it 'works with op1' do
+    op1 = client.operation(service_name, port_name, :op1)
+
+    expect(op1.example_body).to eq(
+      op1: {
+        in: {
+          data1: 'int',
+          data2: 'int'
+        }
+      }
+    )
+
+    op1.body = {
+      op1: {
+        in: {
+          data1: 24,
+          data2: 36
+        }
+      }
+    }
+
+    # The expected request.
+    expected = Nokogiri.XML('
+      <env:Envelope
+          xmlns:lol0="http://apiNamespace.com"
+          xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+        <env:Header/>
+        <env:Body>
+          <lol0:op1>
+            <in>
+              <data1>24</data1>
+              <data2>36</data2>
+            </in>
+          </lol0:op1>
+        </env:Body>
+      </env:Envelope>
+    ')
+
+    expect(Nokogiri.XML op1.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+  it 'works with op3' do
+    op3 = client.operation(service_name, port_name, :op3)
+
+    expect(op3.example_body).to eq(
+      op3: {
+        DataElem: {
+          data1: 'int',
+          data2: 'int'
+        },
+        in2: {
+          RefDataElem: 'int'
+        }
+      }
+    )
+
+    op3.body = {
+      op3: {
+        DataElem: {
+          data1: 64,
+          data2: 128
+        },
+        in2: {
+          RefDataElem: 3
+        }
+      }
+    }
+
+    expected = Nokogiri.XML('
+      <env:Envelope
+          xmlns:lol0="http://apiNamespace.com"
+          xmlns:lol1="http://dataNamespace.com"
+          xmlns:lol2="http://refNamespace.com"
+          xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+        <env:Header/>
+        <env:Body>
+          <lol0:op3>
+            <lol1:DataElem>
+              <data1>64</data1>
+              <data2>128</data2>
+            </lol1:DataElem>
+            <in2>
+              <lol2:RefDataElem>3</lol2:RefDataElem>
+            </in2>
+          </lol0:op3>
+        </env:Body>
+      </env:Envelope>
+    ')
+
+    expect(Nokogiri.XML op3.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+end

data/spec/integration/economic_spec.rb

@@ -0,0 +1,64 @@
+require 'spec_helper'
+require 'benchmark'
+
+describe 'Integration with Economic' do
+
+  before :all do
+    @client = Sekken.new fixture('wsdl/economic')
+  end
+
+  it 'returns a map of services and ports' do
+    expect(@client.services).to eq(
+      'EconomicWebService' => {
+        :ports => {
+          'EconomicWebServiceSoap'   => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'https://api.e-conomic.com/secure/api1/EconomicWebservice.asmx'
+          },
+          'EconomicWebServiceSoap12' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap12/',
+            :location => 'https://api.e-conomic.com/secure/api1/EconomicWebservice.asmx'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows operations with Arrays' do
+    service, port = 'EconomicWebService', 'EconomicWebServiceSoap'
+    operation = @client.operation(service, port, 'Account_GetDataArray')
+
+    expect(operation.soap_action).to eq('http://e-conomic.com/Account_GetDataArray')
+    expect(operation.endpoint).to eq('https://api.e-conomic.com/secure/api1/EconomicWebservice.asmx')
+
+    namespace = 'http://e-conomic.com'
+
+    expect(operation.body_parts).to eq([
+      [['Account_GetDataArray'], { namespace: namespace, form: 'qualified', singular: true }],
+      [['Account_GetDataArray', 'entityHandles'], { namespace: namespace, form: 'qualified', singular: true }],
+      [['Account_GetDataArray', 'entityHandles', 'AccountHandle'], { namespace: namespace, form: 'qualified', singular: false }],
+      [['Account_GetDataArray', 'entityHandles', 'AccountHandle', 'Number'], { namespace: namespace, form: 'qualified', type: 's:int', singular: true }]
+    ])
+  end
+
+  it 'has an ok parse-time for huge wsdl files' do
+    if RUBY_ENGINE =~ /rbx/
+      parse_time = Benchmark.realtime {
+        @client.operations('EconomicWebService', 'EconomicWebServiceSoap')
+      }
+
+      pending 'This currently takes %.2f sec on Rubinius. Investigate why!' % parse_time
+    else
+      #profiler = MethodProfiler.observe(Wasabi::Parser)
+      parse_time = Benchmark.realtime {
+        @client.operations('EconomicWebService', 'EconomicWebServiceSoap')
+      }
+      #puts profiler.report
+
+      # this probably needs to be increased for travis or other rubies,
+      # but it should prevent major performance problems.
+      expect(parse_time).to be < 1.0
+    end
+  end
+
+end