sekken 0.1.0

data/spec/integration/email_verification_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe 'Integration with EmailVerification service' do
+
+  subject(:client) { Sekken.new fixture('wsdl/email_verification') }
+
+  let(:service_name) { :EmailVerNoTestEmail }
+  let(:port_name)    { :EmailVerNoTestEmailSoap12 }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'EmailVerNoTestEmail' => {
+        :ports => {
+          'EmailVerNoTestEmailSoap' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'http://ws.cdyne.com/emailverify/Emailvernotestemail.asmx'
+          },
+          'EmailVerNoTestEmailSoap12' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap12/',
+            :location => 'http://ws.cdyne.com/emailverify/Emailvernotestemail.asmx'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the operations' do
+    service, port = 'EmailVerNoTestEmail', 'EmailVerNoTestEmailSoap12'
+    operation = client.operation(service, port, 'VerifyEmail')
+
+    expect(operation.soap_action).to eq('http://ws.cdyne.com/VerifyEmail')
+    expect(operation.endpoint).to eq('http://ws.cdyne.com/emailverify/Emailvernotestemail.asmx')
+
+    namespace = 'http://ws.cdyne.com/'
+
+    expect(operation.body_parts).to eq([
+      [['VerifyEmail'],               { namespace: namespace, form: 'qualified', singular: true }],
+      [['VerifyEmail', 'email'],      { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['VerifyEmail', 'LicenseKey'], { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }]
+    ])
+  end
+
+  it 'creates an example request' do
+    operation = client.operation(service_name, port_name, :VerifyEmail)
+
+    expect(operation.example_body).to eq(
+      VerifyEmail: {
+        email: 'string',
+        LicenseKey: 'string'
+      }
+    )
+  end
+
+  it 'builds a request' do
+    operation = client.operation(service_name, port_name, :VerifyEmail)
+
+    operation.body = {
+      VerifyEmail: {
+        email: 'soap@example.com',
+        LicenseKey: '?'
+      }
+    }
+
+    expected = Nokogiri.XML(%{
+      <env:Envelope
+          xmlns:lol0="http://ws.cdyne.com/"
+          xmlns:env="http://www.w3.org/2003/05/soap-envelope">
+        <env:Header/>
+        <env:Body>
+          <lol0:VerifyEmail>
+            <lol0:email>soap@example.com</lol0:email>
+            <lol0:LicenseKey>?</lol0:LicenseKey>
+          </lol0:VerifyEmail>
+        </env:Body>
+      </env:Envelope>
+    })
+
+    expect(Nokogiri.XML operation.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+end

data/spec/integration/equifax_spec.rb

@@ -0,0 +1,216 @@
+require 'spec_helper'
+
+describe 'Integration with Equifax' do
+
+  subject(:client) { Sekken.new fixture('wsdl/equifax') }
+
+  let(:service_name) { :canadav2 }
+  let(:port_name)    { :canadaHttpPortV2 }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'canadav2' => {
+        ports: {
+          'canadaHttpPortV2' => {
+            type: 'http://schemas.xmlsoap.org/wsdl/soap/',
+            location: 'https://pilot.eidverifier.com/uru/soap/cert/canadav2'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows operations with attributes and attribute groups' do
+    operation = client.operation(service_name, port_name, 'startTransaction')
+
+    expect(operation.soap_action).to eq('')
+    expect(operation.endpoint).to eq('https://pilot.eidverifier.com/uru/soap/cert/canadav2')
+
+    ns1 = 'http://eid.equifax.com/soap/schema/canada/v2'
+
+    expect(operation.body_parts).to eq([
+      [['InitialRequest'],                                                          { namespace: ns1, form: 'qualified', singular: true }],
+      [['InitialRequest', 'Identity'],                                              { namespace: ns1, form: 'qualified', singular: true }],
+      [['InitialRequest', 'Identity', 'Name'],                                      { namespace: ns1, form: 'qualified', singular: true }],
+      [['InitialRequest', 'Identity', 'Name', 'FirstName'],                         { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'Identity', 'Name', 'MiddleName'],                        { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'Identity', 'Name', 'MiddleInitial'],                     { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'Identity', 'Name', 'LastName'],                          { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'Identity', 'Name', 'Suffix'],                            { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+
+      [['InitialRequest', 'Identity', 'Address'],                                   { namespace: ns1, form: 'qualified', singular: false,
+                                                                                      attributes: {
+                                                                                        'timeAtAddress' => { optional: true },
+                                                                                        'addressType'   => { optional: false }
+                                                                                      }
+                                                                                    }],
+
+      [['InitialRequest', 'Identity', 'Address', 'FreeFormAddress'],                { namespace: ns1, form: 'qualified', singular: true }],
+      [['InitialRequest', 'Identity', 'Address', 'FreeFormAddress', 'AddressLine'], { namespace: ns1, form: 'qualified', singular: false,  type: 'string' }],
+      [['InitialRequest', 'Identity', 'Address', 'HybridAddress'],                  { namespace: ns1, form: 'qualified', singular: true }],
+      [['InitialRequest', 'Identity', 'Address', 'HybridAddress', 'AddressLine'],   { namespace: ns1, form: 'qualified', singular: false, type: 'string' }],
+      [['InitialRequest', 'Identity', 'Address', 'HybridAddress', 'City'],          { namespace: ns1, form: 'qualified', singular: true,  type: 'string' }],
+      [['InitialRequest', 'Identity', 'Address', 'HybridAddress', 'Province'],      { namespace: ns1, form: 'qualified', singular: true,  type: 'string' }],
+      [['InitialRequest', 'Identity', 'Address', 'HybridAddress', 'PostalCode'],    { namespace: ns1, form: 'qualified', singular: true,  type: 'string' }],
+      [['InitialRequest', 'Identity', 'SIN'],                                       { namespace: ns1, form: 'qualified', singular: true,  type: 'string' }],
+      [['InitialRequest', 'Identity', 'DateOfBirth'],                               { namespace: ns1, form: 'qualified', singular: true }],
+      [['InitialRequest', 'Identity', 'DateOfBirth', 'Day'],                        { namespace: ns1, form: 'qualified', singular: true,  type: 'positiveInteger' }],
+      [['InitialRequest', 'Identity', 'DateOfBirth', 'Month'],                      { namespace: ns1, form: 'qualified', singular: true,  type: 'positiveInteger' }],
+      [['InitialRequest', 'Identity', 'DateOfBirth', 'Year'],                       { namespace: ns1, form: 'qualified', singular: true,  type: 'positiveInteger' }],
+
+      [['InitialRequest', 'Identity', 'DriversLicense'],                            { namespace: ns1, form: 'qualified', singular: true,
+                                                                                      attributes: {
+                                                                                        'driversLicenseAddressType'=> { optional: true }
+                                                                                      }
+                                                                                    }],
+
+      [['InitialRequest', 'Identity', 'DriversLicense', 'Number'],                  { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'Identity', 'DriversLicense', 'Province'],                { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+
+      [['InitialRequest', 'Identity', 'PhoneNumber'],                               { namespace: ns1, form: 'qualified', singular: false,
+                                                                                      attributes: {
+                                                                                        'phoneType' => { optional: true }
+                                                                                      }
+                                                                                    }],
+
+      [['InitialRequest', 'Identity', 'PhoneNumber', 'AreaCode'],                   { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'Identity', 'PhoneNumber', 'Exchange'],                   { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'Identity', 'PhoneNumber', 'Number'],                     { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'Identity', 'PhoneNumber', 'PhoneNumber'],                { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'Identity', 'Email'],                                     { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'Identity', 'IPAddress'],                                 { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'Identity', 'CreditCardNumber'],                          { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'Identity', 'CustomerId'],                                { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'ProcessingOptions'],                                     { namespace: ns1, form: 'qualified', singular: true }],
+      [['InitialRequest', 'ProcessingOptions', 'Language'],                         { namespace: ns1, form: 'qualified', singular: true, type: 'string' }],
+      [['InitialRequest', 'ProcessingOptions', 'EnvironmentOverride'],              { namespace: ns1, form: 'qualified', singular: true, type: 'string' }]
+    ])
+  end
+
+  it 'creates an example body with attributes' do
+    operation = client.operation(service_name, port_name, :startTransaction)
+
+    expect(operation.example_body).to eq(
+      InitialRequest: {
+        Identity: {
+          Name: {
+            FirstName: 'string',
+            MiddleName: 'string',
+            MiddleInitial: 'string',
+            LastName: 'string',
+            Suffix: 'string'
+          },
+          Address: [
+            {
+              FreeFormAddress: {
+                AddressLine: ['string']
+              },
+              HybridAddress: {
+                AddressLine: ['string'],
+                City: 'string',
+                Province: 'string',
+                PostalCode: 'string'
+              },
+
+              # attributes are prefixed with an underscore.
+              _timeAtAddress: 'nonNegativeInteger',
+              _addressType: 'string'
+            }
+          ],
+          SIN: 'string',
+          DateOfBirth: {
+            Day: 'positiveInteger',
+            Month: 'positiveInteger',
+            Year: 'positiveInteger'
+          },
+          DriversLicense: {
+            Number: 'string',
+            Province: 'string',
+
+            # another attribute
+            _driversLicenseAddressType: 'string'
+          },
+          PhoneNumber: [
+            {
+              AreaCode: 'string',
+              Exchange: 'string',
+              Number: 'string',
+              PhoneNumber: 'string',
+
+              # another attribute
+              _phoneType: 'string'
+            }
+          ],
+          Email: 'string',
+          IPAddress: 'string',
+          CreditCardNumber: 'string',
+          CustomerId: 'string'
+        },
+        ProcessingOptions: {
+          Language: 'string',
+          EnvironmentOverride: 'string'
+        }
+      }
+    )
+  end
+
+  it 'creates a request with attributes' do
+    operation = client.operation(service_name, port_name, :startTransaction)
+
+    operation.body = {
+      InitialRequest: {
+        Identity: {
+          Address: [
+            {
+              FreeFormAddress: {
+                AddressLine: ['The original', 'Abbey Road, London']
+              },
+              HybridAddress: {
+                AddressLine: ['The original', 'Abbey Road'],
+                City: 'London',
+                Province: 'Camden',
+                PostalCode: 'NW8 9BS'
+              },
+
+              # attributes are prefixed with an underscore
+              _timeAtAddress: 3,
+              _addressType: 'public'
+            }
+          ]
+        }
+      }
+    }
+
+    expected = Nokogiri.XML('
+      <env:Envelope
+          xmlns:lol0="http://eid.equifax.com/soap/schema/canada/v2"
+          xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+        <env:Header>
+        </env:Header>
+        <env:Body>
+          <lol0:InitialRequest>
+            <lol0:Identity>
+              <lol0:Address timeAtAddress="3" addressType="public">
+                <lol0:FreeFormAddress>
+                  <lol0:AddressLine>The original</lol0:AddressLine>
+                  <lol0:AddressLine>Abbey Road, London</lol0:AddressLine>
+                </lol0:FreeFormAddress>
+                <lol0:HybridAddress>
+                  <lol0:AddressLine>The original</lol0:AddressLine>
+                  <lol0:AddressLine>Abbey Road</lol0:AddressLine>
+                  <lol0:City>London</lol0:City>
+                  <lol0:Province>Camden</lol0:Province>
+                  <lol0:PostalCode>NW8 9BS</lol0:PostalCode>
+                </lol0:HybridAddress>
+              </lol0:Address>
+            </lol0:Identity>
+          </lol0:InitialRequest>
+        </env:Body>
+      </env:Envelope>
+    ')
+
+    expect(Nokogiri.XML operation.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+end

data/spec/integration/geotrust_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe 'Integration with Geotrust' do
+
+  subject(:client) { Sekken.new fixture('wsdl/geotrust') }
+
+  it 'knows the operations' do
+    pending "this fixture is missing a message element! " \
+            "find out if we need to handle this case or if the fixture is incomplete." do
+
+      operation = client.operation('GetQuickApproverList')
+      expect(operation.name).to eq('THIS-TEST-FAILS')
+      expect(operation.endpoint).to eq('https://test-api.geotrust.com:443/webtrust/query.jws')
+    end
+  end
+
+end

data/spec/integration/interhome_spec.rb

@@ -0,0 +1,156 @@
+require 'spec_helper'
+
+describe 'Integration with Interhome' do
+
+  subject(:client) { Sekken.new fixture('wsdl/interhome') }
+
+  let(:service_name) { :WebService }
+  let(:port_name)    { :WebServiceSoap }
+
+  it 'returns a map of services and ports' do
+    expect(client.services).to eq(
+      'WebService' => {
+        :ports => {
+          'WebServiceSoap' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+            :location => 'https://webservices.interhome.com/quality/partnerV3/WebService.asmx'
+          },
+          'WebServiceSoap12' => {
+            :type     => 'http://schemas.xmlsoap.org/wsdl/soap12/',
+            :location => 'https://webservices.interhome.com/quality/partnerV3/WebService.asmx'
+          }
+        }
+      }
+    )
+  end
+
+  it 'knows the operations' do
+    operation = client.operation(service_name, port_name, 'ClientBooking')
+
+    expect(operation.soap_action).to eq('http://www.interhome.com/webservice/ClientBooking')
+    expect(operation.endpoint).to eq('https://webservices.interhome.com/quality/partnerV3/WebService.asmx')
+
+    namespace = 'http://www.interhome.com/webservice'
+
+    expect(operation.body_parts).to eq([
+      [['ClientBooking'],                                    { namespace: namespace, form: 'qualified', singular: true }],
+      [['ClientBooking', 'inputValue'],                      { namespace: namespace, form: 'qualified', singular: true }],
+      [['ClientBooking', 'inputValue', 'SalesOfficeCode'],   { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'AccommodationCode'], { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+
+      [['ClientBooking', 'inputValue', 'AdditionalServices'],
+        {namespace: namespace, form: 'qualified', singular: true }],
+      [['ClientBooking', 'inputValue', 'AdditionalServices', 'AdditionalServiceInputItem'],
+        {namespace: namespace, form: 'qualified', singular: false }],
+      [['ClientBooking', 'inputValue', 'AdditionalServices', 'AdditionalServiceInputItem', 'Code'],
+        {namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'AdditionalServices', 'AdditionalServiceInputItem', 'Count'],
+        {namespace: namespace, form: 'qualified', singular: true, type: 's:int' }],
+
+      [['ClientBooking', 'inputValue', 'CustomerSalutationType'],          { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CustomerName'],                    { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CustomerFirstName'],               { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CustomerPhone'],                   { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CustomerFax'],                     { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CustomerEmail'],                   { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CustomerAddressStreet'],           { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CustomerAddressAdditionalStreet'], { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CustomerAddressZIP'],              { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CustomerAddressPlace'],            { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CustomerAddressState'],            { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CustomerAddressCountryCode'],      { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'Comment'],                         { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'Adults'],                          { namespace: namespace, form: 'qualified', singular: true, type: 's:int' }],
+      [['ClientBooking', 'inputValue', 'Babies'],                          { namespace: namespace, form: 'qualified', singular: true, type: 's:int' }],
+      [['ClientBooking', 'inputValue', 'Children'],                        { namespace: namespace, form: 'qualified', singular: true, type: 's:int' }],
+      [['ClientBooking', 'inputValue', 'CheckIn'],                         { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CheckOut'],                        { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'LanguageCode'],                    { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CurrencyCode'],                    { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'RetailerCode'],                    { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'RetailerExtraCode'],               { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'PaymentType'],                     { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CreditCardType'],                  { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CreditCardNumber'],                { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CreditCardCvc'],                   { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CreditCardExpiry'],                { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'CreditCardHolder'],                { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'BankAccountNumber'],               { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'BankCode'],                        { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }],
+      [['ClientBooking', 'inputValue', 'BankAccountHolder'],               { namespace: namespace, form: 'qualified', singular: true, type: 's:string' }]
+    ])
+  end
+
+  # 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, :Availability)
+
+    expect(operation.example_header).to eq(
+      ServiceAuthHeader: {
+        Username: 'string',
+        Password: 'string'
+      }
+    )
+  end
+
+  it 'creates an example body including optional elements' do
+    operation = client.operation(service_name, port_name, :Availability)
+
+    expect(operation.example_body).to eq(
+      Availability: {
+
+        # These are optional.
+        inputValue: {
+          AccommodationCode: 'string',
+          CheckIn: 'string',
+          CheckOut: 'string'
+        }
+
+      }
+    )
+  end
+
+  it 'skips optional elements in the request' do
+    operation = client.operation(service_name, port_name, :Availability)
+
+    operation.header = {
+      ServiceAuthHeader: {
+        Username: 'test',
+        Password: 'secret'
+      }
+    }
+
+    operation.body = {
+      Availability: {
+        inputValue: {
+          # Leaving out two optional elements on purpose.
+          AccommodationCode: 'secret'
+        }
+      }
+    }
+
+    expected = Nokogiri.XML('
+      <env:Envelope
+          xmlns:lol0="http://www.interhome.com/webservice"
+          xmlns:env="http://schemas.xmlsoap.org/soap/envelope/">
+        <env:Header>
+          <lol0:ServiceAuthHeader>
+            <lol0:Username>test</lol0:Username>
+            <lol0:Password>secret</lol0:Password>
+          </lol0:ServiceAuthHeader>
+        </env:Header>
+        <env:Body>
+          <lol0:Availability>
+            <lol0:inputValue>
+              <lol0:AccommodationCode>secret</lol0:AccommodationCode>
+            </lol0:inputValue>
+          </lol0:Availability>
+        </env:Body>
+      </env:Envelope>
+    ')
+
+    expect(Nokogiri.XML operation.build).
+      to be_equivalent_to(expected).respecting_element_order
+  end
+
+end