sekken 0.1.0

data/spec/integration/rio2_spec.rb

@@ -0,0 +1,56 @@
+require 'spec_helper'
+
+describe 'Integration with Rio II' do
+
+  before :all do
+    wsdl_url  = 'http://193.155.1.72/MyCentral-RioII-Services/SecurityService.svc?wsdl'
+    wsdl0_url = 'http://193.155.1.72/MyCentral-RioII-Services/SecurityService.svc?wsdl=wsdl0'
+
+    # mock wsdl imports
+    http_mock.fake_request(wsdl_url,  'wsdl/rio2/rio2.wsdl')
+    http_mock.fake_request(wsdl0_url, 'wsdl/rio2/rio2_0.wsdl')
+
+    # mock schema imports
+    schema_import_base = 'http://193.155.1.72/MyCentral-RioII-Services/SecurityService.svc?xsd=xsd%d'
+    (0..3).each do |i|
+      url = schema_import_base % i
+      http_mock.fake_request(url, "wsdl/rio2/rio2_#{i}.xsd")
+    end
+
+    @client = Sekken.new(wsdl_url)
+  end
+
+  it 'only downloads WSDL and XML Schema imports once per location' do
+    expect(@client.services).to eq(
+      'SecurityService' => {
+        ports: {
+          'BasicHttpBinding_ISecurityService' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'http://193.155.1.72/MyCentral-RioII-Services/SecurityService.svc/soap'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the GetSessionState operation' do
+    service, port = :SecurityService, :BasicHttpBinding_ISecurityService
+    operation = @client.operation(service, port, :GetSessionState)
+
+    expect(operation.input_style).to eq('document/literal')
+
+    expect(operation.example_body).to eq(
+      GetSessionState: {
+        session: {
+          ApplicationId: 'string',
+          CultureCode: 'string',
+          SessionId: 'string'
+        },
+        request: {
+          Context: 'string'
+        }
+      }
+    )
+  end
+
+end

data/spec/integration/rpc_literal_spec.rb

@@ -0,0 +1,101 @@
+require 'spec_helper'
+
+describe 'Integration with an RPC/Literal example' do
+
+  subject(:client) { Sekken.new fixture('wsdl/rpc_literal') }
+
+  let(:service_name) { :SampleService }
+  let(:port_name)    { :Sample }
+
+  it 'works with op1' do
+    op1 = client.operation(service_name, port_name, :op1)
+
+    # Check the example request.
+    expect(op1.example_body).to eq(
+      in: {
+        data1: 'int',
+        data2: 'int'
+      }
+    )
+
+    # Build the request. It returns a Hash without the RPC wrapper element,
+    # because users just don't need to care about it.
+    op1.body = {
+      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)
+
+    # Check the example request.
+    expect(op3.example_body).to eq(
+      DataElem: {
+        data1: 'int',
+        data2: 'int'
+      },
+      in2: {
+        RefDataElem: 'int'
+      }
+    )
+
+    op3.body = {
+      DataElem: {
+        data1: 64,
+        data2: 128
+      },
+      in2: {
+        RefDataElem: 3
+      }
+    }
+
+    # The expected request. Notice how the RPC wrapper element 'op3' is not
+    # namespaced because the WSDL does not define a namespace for it.
+    expected = Nokogiri.XML('
+      <env:Envelope
+          xmlns:lol0="http://dataNamespace.com"
+          xmlns:lol1="http://refNamespace.com"
+          xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+        <env:Header/>
+        <env:Body>
+          <op3>
+            <lol0:DataElem>
+              <data1>64</data1>
+              <data2>128</data2>
+            </lol0:DataElem>
+            <in2>
+              <lol1:RefDataElem>3</lol1:RefDataElem>
+            </in2>
+          </op3>
+        </env:Body>
+      </env:Envelope>
+    ')
+
+    expect(Nokogiri.XML op3.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+end

data/spec/integration/spyne_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe 'Integration with a Spyne.io service' do
+
+  subject(:client) { Sekken.new fixture('wsdl/spyne') }
+
+  let(:service_name) { :HelloWorldService }
+  let(:port_name)    { :Application }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'HelloWorldService' => {
+        ports: {
+          'Application' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'http://localhost:8000/'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows operations with attributes and attribute groups' do
+    operation = client.operation(service_name, port_name, 'say_hello')
+
+    expect(operation.soap_action).to eq('say_hello')
+    expect(operation.endpoint).to eq('http://localhost:8000/')
+
+    expect(operation.body_parts).to eq([
+      [['say_hello'], { namespace: 'spyne.examples.hello', form: 'qualified', singular: true }]
+    ])
+  end
+
+  it 'creates an example body with attributes' do
+    operation = client.operation(service_name, port_name, :say_hello)
+    expect(operation.example_body).to eq(say_hello: {})
+  end
+
+  it 'creates a request with attributes' do
+    operation = client.operation(service_name, port_name, :say_hello)
+
+    operation.body = { say_hello: {} }
+
+    expected = Nokogiri.XML('
+      <env:Envelope
+          xmlns:lol0="spyne.examples.hello"
+          xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+        <env:Header>
+        </env:Header>
+        <env:Body>
+          <lol0:say_hello/>
+        </env:Body>
+      </env:Envelope>
+    ')
+
+    expect(Nokogiri.XML operation.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+end

data/spec/integration/stockquote_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe 'Integration with Stockquote service' do
+
+  subject(:client) { Sekken.new fixture('wsdl/stockquote') }
+
+  let(:service_name) { :StockQuote }
+  let(:port_name)    { :StockQuoteSoap }
+
+  it 'creates an example request' do
+    operation = client.operation(service_name, port_name, :GetQuote)
+
+    expect(operation.example_body).to eq(
+      GetQuote: {
+        symbol: 'string'
+      }
+    )
+  end
+
+  it 'builds a request' do
+    operation = client.operation(service_name, port_name, :GetQuote)
+
+    operation.body = {
+      GetQuote: {
+        symbol: 'AAPL'
+      }
+    }
+
+    expected = Nokogiri.XML(%{
+      <env:Envelope
+          xmlns:lol0="http://www.webserviceX.NET/"
+          xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+        <env:Header/>
+        <env:Body>
+          <lol0:GetQuote>
+            <lol0:symbol>AAPL</lol0:symbol>
+          </lol0:GetQuote>
+        </env:Body>
+      </env:Envelope>
+    })
+
+    expect(Nokogiri.XML operation.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+end

data/spec/integration/taxcloud_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe 'Integration with Taxcloud' do
+
+  subject(:client) { Sekken.new fixture('wsdl/taxcloud') }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'TaxCloud' => {
+        :ports => {
+          'TaxCloudSoap' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'https://api.taxcloud.net/1.0/TaxCloud.asmx'
+          },
+          'TaxCloudSoap12' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap12/',
+            :location => 'https://api.taxcloud.net/1.0/TaxCloud.asmx'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the operations' do
+    service, port = 'TaxCloud', 'TaxCloudSoap'
+    operation = client.operation(service, port, 'VerifyAddress')
+
+    expect(operation.soap_action).to eq('http://taxcloud.net/VerifyAddress')
+    expect(operation.endpoint).to eq('https://api.taxcloud.net/1.0/TaxCloud.asmx')
+
+    namespace = 'http://taxcloud.net'
+
+    expect(operation.body_parts).to eq([
+      [['VerifyAddress'],               { namespace: namespace, form: 'qualified', singular: true }],
+      [['VerifyAddress', 'uspsUserID'], { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['VerifyAddress', 'address1'],   { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['VerifyAddress', 'address2'],   { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['VerifyAddress', 'city'],       { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['VerifyAddress', 'state'],      { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['VerifyAddress', 'zip5'],       { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['VerifyAddress', 'zip4'],       { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }]
+    ])
+  end
+
+end

data/spec/integration/team_software_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe 'Integration with TeamSoftware' do
+
+  subject(:client) { Sekken.new(wsdl_url, http_mock) }
+
+  let(:wsdl_url)  { 'http://bydexchange.nbs-us.com/BYDExchangeServer.svc?wsdl' }
+
+  before do
+    http_mock.fake_request(wsdl_url, 'wsdl/team_software/team_software.wsdl')
+
+    # 4 schemas to import.
+    #
+    # XXX: actually some of the imported schemas import some of the other schemas,
+    #      but it seems like we're not following those?!
+    schema_import_base = 'https://winteamservicestest.myteamsoftware.com/Services.svc?xsd=xsd%d'
+    (0..3).each do |i|
+      url = schema_import_base % i
+      http_mock.fake_request(url, "wsdl/team_software/team_software#{i}.xsd")
+    end
+  end
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'ServiceManager' => {
+        :ports => {
+          'BasicHttpBinding_IWinTeamServiceManager' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'https://winteamservicestest.myteamsoftware.com/Services.svc'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the operations' do
+    service, port = 'ServiceManager', 'BasicHttpBinding_IWinTeamServiceManager'
+    operation = client.operation(service, port, 'Login')
+
+    expect(operation.soap_action).to eq('http://tempuri.org/IWinTeamServiceManager/Login')
+    expect(operation.endpoint).to eq('https://winteamservicestest.myteamsoftware.com/Services.svc')
+
+    namespace = 'http://tempuri.org/'
+
+    expect(operation.body_parts).to eq([
+      [['Login'],               { namespace: namespace, form: 'qualified', singular: true }],
+      [['Login', 'MappingKey'], { namespace: namespace, form: 'qualified', singular: true, type: 'xs:string' }]
+    ])
+  end
+
+end

data/spec/integration/telefonkatalogen_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+describe 'Integration with Telefonkatalogen' do
+
+  # reference: savon#295
+  subject(:client) { Sekken.new fixture('wsdl/telefonkatalogen') }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'SendSms' => {
+        :ports => {
+          'SendSmsPort' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'http://bedrift.telefonkatalogen.no/tk/websvcsendsms.php'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the operations' do
+    operation = client.operation('SendSms', 'SendSmsPort', 'sendsms')
+
+    expect(operation.soap_action).to eq('sendsms')
+
+    # notice how this contains 9 parts with one element each.
+    # it does not include the rpc wrapper.
+
+    expect(operation.body_parts).to eq([
+      [['sender'],      { namespace: nil, form: 'unqualified', singular: true, type: 'xsd:string' }],
+      [['cellular'],    { namespace: nil, form: 'unqualified', singular: true, type: 'xsd:string' }],
+      [['msg'],         { namespace: nil, form: 'unqualified', singular: true, type: 'xsd:string' }],
+      [['smsnumgroup'], { namespace: nil, form: 'unqualified', singular: true, type: 'xsd:string' }],
+      [['emailaddr'],   { namespace: nil, form: 'unqualified', singular: true, type: 'xsd:string' }],
+      [['udh'],         { namespace: nil, form: 'unqualified', singular: true, type: 'xsd:string' }],
+      [['datetime'],    { namespace: nil, form: 'unqualified', singular: true, type: 'xsd:string' }],
+      [['format'],      { namespace: nil, form: 'unqualified', singular: true, type: 'xsd:string' }],
+      [['dlrurl'],      { namespace: nil, form: 'unqualified', singular: true, type: 'xsd:string' }]
+    ])
+  end
+
+end

data/spec/integration/temperature_spec.rb

@@ -0,0 +1,71 @@
+ require 'spec_helper'
+
+describe 'Integration with Temperature service' do
+
+  subject(:client) { Sekken.new fixture('wsdl/temperature') }
+
+  let(:service_name) { :ConvertTemperature }
+  let(:port_name)    { :ConvertTemperatureSoap12 }
+
+  it 'returns an empty Hash if there are no header parts' do
+    operation = client.operation(service_name, port_name, :ConvertTemp)
+    expect(operation.example_header).to eq({})
+  end
+
+  it 'creates an example body' do
+    operation = client.operation(service_name, port_name, :ConvertTemp)
+
+    expect(operation.example_body).to eq(
+      ConvertTemp: {
+        Temperature: 'double',
+        FromUnit: 'string',
+        ToUnit: 'string'
+      }
+    )
+  end
+
+  it 'builds a request' do
+    operation = client.operation(service_name, port_name, :ConvertTemp)
+
+    # For the corrent values to pass for :from_unit and :to_unit, I searched the WSDL for
+    # the 'FromUnit' type which is a 'TemperatureUnit' enumeration that looks like this:
+    #
+    # <s:simpleType name='TemperatureUnit'>
+    #   <s:restriction base='s:string'>
+    #     <s:enumeration value='degreeCelsius'/>
+    #     <s:enumeration value='degreeFahrenheit'/>
+    #     <s:enumeration value='degreeRankine'/>
+    #     <s:enumeration value='degreeReaumur'/>
+    #     <s:enumeration value='kelvin'/>
+    #   </s:restriction>
+    # </s:simpleType>
+    #
+    # TODO: somehow expose the enumeration options through the example request.
+    operation.body = {
+      ConvertTemp: {
+        Temperature: 30,
+        FromUnit: 'degreeCelsius',
+        ToUnit: 'degreeFahrenheit'
+      }
+    }
+
+    expected = Nokogiri.XML(%{
+      <env:Envelope
+          xmlns:lol0="http://www.webserviceX.NET/"
+          xmlns:env="http://www.w3.org/2003/05/soap-envelope">
+        <env:Header/>
+        <env:Body>
+          <lol0:ConvertTemp>
+            <lol0:Temperature>30</lol0:Temperature>
+            <lol0:FromUnit>degreeCelsius</lol0:FromUnit>
+            <lol0:ToUnit>degreeFahrenheit</lol0:ToUnit>
+          </lol0:ConvertTemp>
+        </env:Body>
+      </env:Envelope>
+    })
+
+    expect(Nokogiri.XML operation.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+end