sekken 0.1.0

data/spec/sekken/operation/document_literal_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+
+describe Sekken::Operation do
+
+  # namespace reference:
+  #   http://www.ibm.com/developerworks/webservices/library/ws-tip-namespace/index.html
+  context 'with a document/literal wrapped document' do
+    it 'works for op1' do
+      client = Sekken.new fixture('wsdl/document_literal_wrapped')
+
+      op1 = client.operation('SampleService', 'Sample', 'op1')
+      expect(op1.input_style).to eq('document/literal')
+
+      expect(op1.body_parts).to eq([
+        [ ['op1'],                { namespace: 'http://apiNamespace.com',  form: 'qualified',   singular: true } ],
+        [ ['op1', 'in'],          { namespace: 'http://apiNamespace.com',  form: 'unqualified', singular: true } ],
+        [ ['op1', 'in', 'data1'], { namespace: 'http://dataNamespace.com', form: 'unqualified', singular: true, type: 'int' } ],
+        [ ['op1', 'in', 'data2'], { namespace: 'http://dataNamespace.com', form: 'unqualified', singular: true, type: 'int' } ]
+      ])
+    end
+
+    it 'works for op2' do
+      client = Sekken.new fixture('wsdl/document_literal_wrapped')
+
+      op2 = client.operation('SampleService', 'Sample', 'op2')
+      expect(op2.input_style).to eq('document/literal')
+
+      expect(op2.body_parts).to eq([
+        [ ['op2'],                { namespace: 'http://apiNamespace.com',  form: 'qualified',   singular: true } ],
+        [ ['op2', 'in'],          { namespace: 'http://apiNamespace.com',  form: 'unqualified', singular: true } ],
+        [ ['op2', 'in', 'data1'], { namespace: 'http://dataNamespace.com', form: 'unqualified', singular: true, type: 'int' } ],
+        [ ['op2', 'in', 'data2'], { namespace: 'http://dataNamespace.com', form: 'unqualified', singular: true, type: 'int' } ]
+      ])
+    end
+
+    it 'works for op3' do
+      client = Sekken.new fixture('wsdl/document_literal_wrapped')
+
+      op3 = client.operation('SampleService', 'Sample', 'op3')
+      expect(op3.input_style).to eq('document/literal')
+
+      expect(op3.body_parts).to eq([
+        [ ['op3'],                       { namespace: 'http://apiNamespace.com',  form: 'qualified',   singular: true } ],
+        [ ['op3', 'DataElem'],           { namespace: 'http://dataNamespace.com', form: 'qualified',   singular: true } ],
+        [ ['op3', 'DataElem', 'data1'],  { namespace: 'http://dataNamespace.com', form: 'unqualified', singular: true, type: 'int' } ],
+        [ ['op3', 'DataElem', 'data2'],  { namespace: 'http://dataNamespace.com', form: 'unqualified', singular: true, type: 'int' } ],
+        [ ['op3', 'in2'],                { namespace: 'http://apiNamespace.com',  form: 'unqualified', singular: true } ],
+        [ ['op3', 'in2', 'RefDataElem'], { namespace: 'http://refNamespace.com',  form: 'qualified',   singular: true, type: 'int' } ],
+      ])
+    end
+  end
+
+end

data/spec/sekken/operation/example_body_spec.rb

@@ -0,0 +1,95 @@
+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)
+  }
+
+  describe '#example_body' do
+    it 'returns an Array with a single Hash for Arrays of complex types' do
+      expect(add_logins.example_body).to eq(
+        addLogins: {
+
+          # array of complex types
+          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 'returns an Array with a single simple type for Arrays of simple types' do
+      expect(get_mu_bets_lite.example_body).to eq(
+        getMUBetsLite: {
+          request: {
+            header: {
+              clientStamp: 'long',
+              sessionToken: 'string'
+            },
+            betStatus: 'string',
+            marketId: 'int',
+            betIds: {
+
+              # array of simple types
+              betId: ['long']
+
+            },
+            orderBy: 'string',
+            sortOrder: 'string',
+            recordCount: 'int',
+            startRecord: 'int',
+            matchedSince: 'dateTime',
+            excludeLastSecond: 'boolean'
+          }
+        }
+      )
+    end
+  end
+
+end

data/spec/sekken/operation/rpc_literal_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe Sekken::Operation do
+
+  # namespace reference:
+  #   http://www.ibm.com/developerworks/webservices/library/ws-tip-namespace/index.html
+  context 'with an rpc/literal document' do
+    it 'qualifies the RPC wrapper with the soap:body namespace' do
+      client = Sekken.new fixture('wsdl/rpc_literal')
+
+      op1 = client.operation('SampleService', 'Sample', 'op1')
+      expect(op1.input_style).to eq('rpc/literal')
+
+      expect(op1.body_parts).to eq([
+        [ ['in'],          { namespace: nil,                        form: 'unqualified', singular: true } ],
+        [ ['in', 'data1'], { namespace: 'http://dataNamespace.com', form: 'unqualified', singular: true, type: 'int' } ],
+        [ ['in', 'data2'], { namespace: 'http://dataNamespace.com', form: 'unqualified', singular: true, type: 'int' } ]
+      ])
+    end
+
+    it 'qualifies the RPC wrapper with the soap:body namespace (which differs from the tns)' do
+      client = Sekken.new fixture('wsdl/rpc_literal')
+
+      op2 = client.operation('SampleService', 'Sample', 'op2')
+      expect(op2.input_style).to eq('rpc/literal')
+
+      expect(op2.body_parts).to eq([
+        [ ['in'],          { namespace: nil,                        form: 'unqualified', singular: true } ],
+        [ ['in', 'data1'], { namespace: 'http://dataNamespace.com', form: 'unqualified', singular: true, type: 'int' } ],
+        [ ['in', 'data2'], { namespace: 'http://dataNamespace.com', form: 'unqualified', singular: true, type: 'int' } ]
+      ])
+    end
+
+    it 'does not qualify the RPC wrapper without a soap:body namespace and follows element refs' do
+      client = Sekken.new fixture('wsdl/rpc_literal')
+
+      op3 = client.operation('SampleService', 'Sample', 'op3')
+      expect(op3.input_style).to eq('rpc/literal')
+
+      expect(op3.body_parts).to eq([
+        [ ['DataElem'],           { namespace: 'http://dataNamespace.com', form: 'qualified',   singular: true } ],
+        [ ['DataElem', 'data1'],  { namespace: 'http://dataNamespace.com', form: 'unqualified', singular: true, type: 'int' } ],
+        [ ['DataElem', 'data2'],  { namespace: 'http://dataNamespace.com', form: 'unqualified', singular: true, type: 'int' } ],
+        [ ['in2'],                { namespace: nil,                        form: 'unqualified', singular: true } ],
+        [ ['in2', 'RefDataElem'], { namespace: 'http://refNamespace.com',  form: 'qualified',   singular: true, type: 'int' } ],
+      ])
+    end
+  end
+
+end

data/spec/sekken/operation_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe Sekken::Operation do
+
+  subject(:operation)  { Sekken::Operation.new(wsdl_operation, wsdl, http_mock) }
+
+  let(:wsdl)           { Sekken::WSDL.new fixture('wsdl/temperature'), http_mock }
+  let(:wsdl_operation) { wsdl.operation('ConvertTemperature', 'ConvertTemperatureSoap12', 'ConvertTemp') }
+
+  describe '#endpoint' do
+    it 'returns the SOAP endpoint' do
+      expect(operation.endpoint).to eq('http://www.webservicex.net/ConvertTemperature.asmx')
+    end
+
+    it 'can be overwritten' do
+      operation.endpoint = 'http://example.com'
+      expect(operation.endpoint).to eq('http://example.com')
+    end
+  end
+
+  describe '#soap_version' do
+    it 'returns the SOAP version determined by the service and port' do
+      expect(operation.soap_version).to eq('1.2')
+    end
+
+    it 'can be overwritten' do
+      operation.soap_version = '1.1'
+      expect(operation.soap_version).to eq('1.1')
+    end
+  end
+
+  describe '#soap_action' do
+    it 'returns the SOAP action for the operation' do
+      expect(operation.soap_action).to eq('http://www.webserviceX.NET/ConvertTemp')
+    end
+
+    it 'can be overwritten' do
+      operation.soap_action = 'ConvertSomething'
+      expect(operation.soap_action).to eq('ConvertSomething')
+    end
+  end
+
+  describe '#encoding' do
+    it 'defaults to UTF-8' do
+      expect(operation.encoding).to eq('UTF-8')
+    end
+
+    it 'can be overwritten' do
+      operation.encoding = 'US-ASCII'
+      expect(operation.encoding).to eq('US-ASCII')
+    end
+  end
+
+  describe '#http_headers' do
+    it 'returns a Hash of HTTP headers for a SOAP 1.2 operation' do
+      expect(operation.http_headers).to eq(
+        'SOAPAction'   => '"http://www.webserviceX.NET/ConvertTemp"',
+        'Content-Type' => 'application/soap+xml;charset=UTF-8'
+      )
+    end
+
+    it 'returns a Hash of HTTP headers for a SOAP 1.1 operation' do
+      wsdl_operation = wsdl.operation('ConvertTemperature', 'ConvertTemperatureSoap', 'ConvertTemp')
+      operation = Sekken::Operation.new(wsdl_operation, wsdl, http_mock)
+
+      expect(operation.http_headers).to eq(
+        'SOAPAction'   => '"http://www.webserviceX.NET/ConvertTemp"',
+        'Content-Type' => 'text/xml;charset=UTF-8'
+      )
+    end
+
+    it 'can be overwritten' do
+      headers = { 'SecretToken' => 'abc'}
+      operation.http_headers = headers
+
+      expect(operation.http_headers).to eq(headers)
+    end
+  end
+
+  describe '#example_request' do
+    it 'returns an example request Hash following Sekken\'s conventions' do
+      expect(operation.example_body).to eq(
+        ConvertTemp: {
+          Temperature: 'double',
+          FromUnit: 'string',
+          ToUnit: 'string'
+        }
+      )
+    end
+  end
+
+  describe '#build' do
+    it 'returns an example request Hash following Sekken\'s conventions' do
+      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(operation.build).
+        to be_equivalent_to(expected).respecting_element_order
+    end
+  end
+
+  describe '#xml_envelope' do
+    let(:xml) do
+      '<?xml version="1.0" encoding="UTF-8"?>
+    <Envelope>
+      <Body>
+        <VerifySignature>
+          <UrlEndPoint></UrlEndPoint>
+          <HttpParameters></HttpParameters>
+        </VerifySignature>
+      </Body>
+    </Envelope>'
+    end
+
+    it 'returns the xml request' do
+      http_mock.fake_request('http://www.webservicex.net/ConvertTemperature.asmx')
+      operation.xml_envelope = xml
+
+      expect(operation.xml_envelope).to eq(xml)
+    end
+
+    it 'returns a Sekken response object' do
+      http_mock.fake_request('http://www.webservicex.net/ConvertTemperature.asmx')
+      operation.xml_envelope = xml
+
+      response = operation.call
+      expect(response).to be_a(Sekken::Response)
+    end
+  end
+
+  describe '#call' do
+    it 'calls the operation with a Hash of options and returns a Response' do
+      http_mock.fake_request('http://www.webservicex.net/ConvertTemperature.asmx')
+
+      operation.body = {
+        ConvertTemp: {
+          Temperature: 30,
+          FromUnit: 'degreeCelsius',
+          ToUnit: 'degreeFahrenheit'
+        }
+      }
+
+      response = operation.call
+
+      expect(response).to be_a(Sekken::Response)
+    end
+  end
+
+end

data/spec/sekken/resolver_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Sekken::Resolver do
+
+  subject(:resolver) { Sekken::Resolver.new(http_test_client) }
+
+  let(:http_test_client) {
+    Class.new {
+
+      def get(url)
+        "raw_response for #{url}"
+      end
+
+    }.new
+  }
+
+  it 'resolves remote files using a simple HTTP client interface' do
+    url = 'http://example.com?wsdl'
+
+    xml = resolver.resolve(url)
+    expect(xml).to eq("raw_response for #{url}")
+  end
+
+  it 'resolves local files' do
+    fixture = fixture('wsdl/authentication')
+
+    xml = resolver.resolve(fixture)
+    expect(xml).to eq(File.read(fixture))
+  end
+
+  it 'simply returns any raw input' do
+    string = '<xml/>'
+
+    xml = resolver.resolve(string)
+    expect(xml).to eq(string)
+  end
+
+end

data/spec/sekken/response_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Sekken::Response do
+  subject(:response) do
+    response = Sekken::Response.new(nil)
+    response.send(:instance_variable_set, :@hash, {
+      :envelope => {:header => 'the-spice-must-flow'}
+    })
+    response
+  end
+
+  describe '#headers' do
+    it 'returns the headers for the underlying response' do
+      expect(response.header).to eq('the-spice-must-flow')
+    end
+  end
+end

data/spec/sekken/wsdl/document_spec.rb

@@ -0,0 +1,191 @@
+require 'spec_helper'
+
+describe Sekken::WSDL::Document do
+
+  describe '#messages' do
+    it 'works with single element parts' do
+      document = get_documents('wsdl/oracle').first
+
+      expect(document.messages.keys).to include(
+        'addReportToPageIn', 'addReportToPageOut', 'applyReportDefaultsIn', 'applyReportDefaultsOut'
+      )
+
+      # message
+
+      message = document.messages['addReportToPageIn']
+      expect(message.name).to eq('addReportToPageIn')
+
+      namespaces = {
+        'xmlns:sawsoap' => 'urn://oracle.bi.webservices/v7',
+        'xmlns:soap'    => 'http://schemas.xmlsoap.org/wsdl/soap/',
+        'xmlns:wsdl'    => 'http://schemas.xmlsoap.org/wsdl/',
+        'xmlns:xsd'     => 'http://www.w3.org/2001/XMLSchema'
+      }
+
+      expect(message.parts).to eq([
+        { :name => 'parameters', :namespaces => namespaces,
+          :type => nil, :element => 'sawsoap:addReportToPage' }
+      ])
+    end
+
+    it 'works with multiple type parts' do
+      document = get_documents('wsdl/telefonkatalogen').first
+
+      expect(document.messages.keys).to include(
+        'sendsmsRequest', 'sendsmsResponse'
+      )
+
+      # message
+
+      message = document.messages['sendsmsRequest']
+      expect(message.name).to eq('sendsmsRequest')
+
+      namespaces = {
+        'xmlns:tns'  => 'http://bedrift.telefonkatalogen.no',
+        'xmlns:xsd'  => 'http://www.w3.org/2001/XMLSchema',
+        'xmlns:soap' => 'http://schemas.xmlsoap.org/wsdl/soap/',
+        'xmlns'      => 'http://schemas.xmlsoap.org/wsdl/'
+      }
+
+      expect(message.parts).to eq([
+        { :name => 'sender',      :namespaces => namespaces, :type  => 'xsd:string', :element => nil },
+        { :name => 'cellular',    :namespaces => namespaces, :type  => 'xsd:string', :element => nil },
+        { :name => 'msg',         :namespaces => namespaces, :type  => 'xsd:string', :element => nil },
+        { :name => 'smsnumgroup', :namespaces => namespaces, :type  => 'xsd:string', :element => nil },
+        { :name => 'emailaddr',   :namespaces => namespaces, :type  => 'xsd:string', :element => nil },
+        { :name => 'udh',         :namespaces => namespaces, :type  => 'xsd:string', :element => nil },
+        { :name => 'datetime',    :namespaces => namespaces, :type  => 'xsd:string', :element => nil },
+        { :name => 'format',      :namespaces => namespaces, :type  => 'xsd:string', :element => nil },
+        { :name => 'dlrurl',      :namespaces => namespaces, :type  => 'xsd:string', :element => nil }
+      ])
+    end
+  end
+
+  describe '#port_types' do
+    it 'works with multiple bindings' do
+      document = get_documents('wsdl/oracle').first
+
+      expect(document.port_types.keys).to match_array([
+        'ConditionServiceSoap', 'HtmlViewServiceSoap', 'IBotServiceSoap',
+        'JobManagementServiceSoap', 'MetadataServiceSoap', 'ReplicationServiceSoap',
+        'ReportEditingServiceSoap', 'SAWSessionServiceSoap', 'SecurityServiceSoap',
+        'WebCatalogServiceSoap', 'XmlViewServiceSoap'
+      ])
+
+      # port type
+
+      port_type = document.port_types['IBotServiceSoap']
+      expect(port_type.name).to eq('IBotServiceSoap')
+
+      expect(port_type.operations.keys).to match_array([
+        "deleteIBot", "executeIBotNow", "moveIBot", "sendMessage",
+        "subscribe", "unsubscribe", "writeIBot"
+      ])
+
+      # port type operation
+
+      port_type_operation = port_type.operations['moveIBot']
+      expect(port_type_operation.name).to eq('moveIBot')
+
+      expect(port_type_operation.input).to eq(:name => nil, :message => 'sawsoap:moveIBotIn')
+      expect(port_type_operation.output).to eq(:name => nil, :message => 'sawsoap:moveIBotOut')
+    end
+  end
+
+  describe '#bindings' do
+    it 'works with multiple bindings' do
+      document = get_documents('wsdl/oracle').first
+
+      expect(document.bindings.keys).to match_array([
+        'ConditionService', 'HtmlViewService', 'IBotService', 'JobManagementService',
+        'MetadataService', 'ReplicationService', 'ReportEditingService', 'SAWSessionService',
+        'SecurityService', 'WebCatalogService', 'XmlViewService'
+      ])
+
+      # binding
+
+      binding = document.bindings['SecurityService']
+
+      expect(binding.name).to eq('SecurityService')
+      expect(binding.port_type).to eq('sawsoap:SecurityServiceSoap')
+      expect(binding.style).to eq('document')
+      expect(binding.transport).to eq('http://schemas.xmlsoap.org/soap/http')
+
+      expect(binding.operations.keys).to match_array([
+        'forgetAccounts', 'getAccountTenantID', 'getAccounts', 'getGlobalPrivilegeACL',
+        'getGlobalPrivileges', 'getGroups', 'getMembers', 'getPermissions', 'getPrivilegesStatus',
+        'isMember', 'joinGroups', 'leaveGroups', 'renameAccounts', 'updateGlobalPrivilegeACL'
+      ])
+
+      # binding operation
+
+      binding_operation = binding.operations['getAccounts']
+      expect(binding_operation.name).to eq('getAccounts')
+
+      expect(binding_operation.soap_action).to eq('#getAccounts')
+      expect(binding_operation.style).to eq('document')
+    end
+  end
+
+  describe '#services' do
+    it 'works with multiple services' do
+      document = get_documents('wsdl/oracle').first
+
+      expect(document.services.keys).to match_array([
+        'SAWSessionService', 'WebCatalogService', 'XmlViewService', 'SecurityService',
+        'ConditionService', 'HtmlViewService', 'IBotService', 'JobManagementService',
+        'MetadataService', 'ReplicationService', 'ReportEditingService'
+      ])
+
+      service = document.services['ConditionService']
+      expect(service.ports.keys).to eq(['ConditionServiceSoap'])
+
+      # soap 1.1 port
+
+      soap_port = service.ports['ConditionServiceSoap']
+
+      expect(soap_port.name).to eq('ConditionServiceSoap')
+      expect(soap_port.binding).to eq('sawsoap:ConditionService')
+
+      expect(soap_port.type).to eq(Sekken::NS_SOAP_1_1)
+      expect(soap_port.location).to eq('https://fap0023-bi.oracleads.com/analytics-ws/saw.dll?SoapImpl=conditionService')
+    end
+
+    it 'only knows about the SOAP ports of each service' do
+      document = get_documents('wsdl/email_verification').first
+
+      expect(document.services.keys).to eq(['EmailVerNoTestEmail'])
+
+      service = document.services['EmailVerNoTestEmail']
+      expect(service.ports.keys).to match_array([
+        'EmailVerNoTestEmailSoap', 'EmailVerNoTestEmailSoap12'
+      ])
+
+      # soap 1.1 port
+
+      soap_1_1_port = service.ports['EmailVerNoTestEmailSoap']
+
+      expect(soap_1_1_port.name).to eq('EmailVerNoTestEmailSoap')
+      expect(soap_1_1_port.binding).to eq('tns:EmailVerNoTestEmailSoap')
+
+      expect(soap_1_1_port.type).to eq(Sekken::NS_SOAP_1_1)
+      expect(soap_1_1_port.location).to eq('http://ws.cdyne.com/emailverify/Emailvernotestemail.asmx')
+
+      # soap 1.2 port
+
+      soap_1_2_port = service.ports['EmailVerNoTestEmailSoap12']
+
+      expect(soap_1_2_port.name).to eq('EmailVerNoTestEmailSoap12')
+      expect(soap_1_2_port.binding).to eq('tns:EmailVerNoTestEmailSoap12')
+
+      expect(soap_1_2_port.type).to eq(Sekken::NS_SOAP_1_2)
+      expect(soap_1_2_port.location).to eq('http://ws.cdyne.com/emailverify/Emailvernotestemail.asmx')
+    end
+  end
+
+  def get_documents(fixture)
+    client = Sekken.new fixture(fixture)
+    client.wsdl.documents
+  end
+
+end