sekken 0.1.0

data/spec/sekken/wsdl_spec.rb

@@ -0,0 +1,46 @@
+require 'spec_helper'
+
+describe Sekken::WSDL do
+
+  subject(:wsdl) { Sekken::WSDL.new fixture('wsdl/authentication'), http_mock }
+
+  let(:operation_name) { 'authenticate' }
+  let(:service_name)   { 'AuthenticationWebServiceImplService' }
+  let(:port_name)      { 'AuthenticationWebServiceImplPort' }
+
+  describe '#service_name' do
+    it 'returns the name of the service' do
+      expect(wsdl.service_name).to eq('AuthenticationWebServiceImplService')
+    end
+  end
+
+  describe '#services' do
+    it 'returns a map of services and ports' do
+      expect(wsdl.services).to eq(
+        'AuthenticationWebServiceImplService' => {
+          :ports => {
+            'AuthenticationWebServiceImplPort' => {
+              :type     => 'http://schemas.xmlsoap.org/wsdl/soap/',
+              :location => 'http://example.com/validation/1.0/AuthenticationService'
+            }
+          }
+        }
+      )
+    end
+  end
+
+  describe '#operations' do
+    it 'returns an Array of operation names' do
+      operations = wsdl.operations(service_name, port_name)
+      expect(operations).to eq([operation_name])
+    end
+  end
+
+  describe '#operation' do
+    it 'returns a single operation by name' do
+      operation = wsdl.operation(service_name, port_name, operation_name)
+      expect(operation).to be_a(Sekken::WSDL::Operation)
+    end
+  end
+
+end

data/spec/sekken/xs/complex_type_spec.rb

@@ -0,0 +1,197 @@
+require 'spec_helper'
+
+describe Sekken::XS::ComplexType do
+
+  specify 'all/element' do
+    complex_type = new_complex_type('
+      <xs:complexType name="MpUser" xmlns="http://www.w3.org/2001/XMLSchema">
+        <xs:all>
+          <xs:element name="speciality" type="xs:string"/>
+          <xs:element name="firstname" type="xs:string"/>
+          <xs:element name="lastname" type="xs:string"/>
+          <xs:element name="login" type="xs:string"/>
+        </xs:all>
+      </xs:complexType>
+    ')
+
+    expect(complex_type).to be_a(Sekken::XS::ComplexType)
+
+    all = complex_type.children.first
+    expect(all).to be_a(Sekken::XS::All)
+
+    elements = all.children
+    expect(elements.count).to eq(4)
+
+    elements.each do |element|
+      expect(element).to be_a(Sekken::XS::Element)
+    end
+
+    element_names = elements.map(&:name)
+    expect(element_names).to eq(%w[speciality firstname lastname login])
+
+    expect(complex_type.collect_child_elements).to eq(elements)
+  end
+
+  specify 'complexContent/extension/sequence/element' do
+    base_type = new_complex_type('
+      <complexType name="baseObject">
+        <sequence>
+          <element minOccurs="0" maxOccurs="unbounded" name="ExemptState" nillable="true" type="tns:ExemptState" />
+        </sequence>
+      </complexType>
+    ')
+
+    # mock the schemas for #collect_child_elements
+    schemas = mock('schemas')
+    schemas.expects(:complex_type).with('http://example.com/ons', 'baseObject').returns(base_type)
+
+    complex_type = new_complex_type('
+			<complexType name="Account" xmlns="http://www.w3.org/2001/XMLSchema"
+                                  xmlns:ons="http://example.com/ons"
+                                  xmlns:ens="http://example.com/ens">
+				<complexContent>
+					<extension base="ons:baseObject">
+						<sequence>
+							<element minOccurs="0" name="Description" nillable="true" type="string" />
+							<element minOccurs="0" name="ProcessId" nillable="true" type="ens:ID" />
+              <element minOccurs="0" name="CreatedDate" nillable="true" type="dateTime" />
+						</sequence>
+					</extension>
+				</complexContent>
+      </complexType>
+    ', schemas)
+
+    expect(complex_type).to be_a(Sekken::XS::ComplexType)
+
+    complex_content = complex_type.children.first
+    expect(complex_content).to be_a(Sekken::XS::ComplexContent)
+
+    extension = complex_content.children.first
+    expect(extension).to be_a(Sekken::XS::Extension)
+
+    expect(extension['base']).to eq('ons:baseObject')
+
+    sequence = extension.children.first
+    expect(sequence).to be_a(Sekken::XS::Sequence)
+
+    sequence_elements = sequence.children
+    expect(sequence_elements.count).to eq(3)
+
+    expect(sequence_elements[0]).to be_a(Sekken::XS::Element)
+    expect(sequence_elements[0].name).to eq('Description')
+
+    expect(sequence_elements[1]).to be_a(Sekken::XS::Element)
+    expect(sequence_elements[1].name).to eq('ProcessId')
+
+    expect(sequence_elements[1].type).to eq('ens:ID')
+    expect(sequence_elements[1].namespaces).to include('xmlns:ens' => 'http://example.com/ens')
+
+    expect(sequence_elements[2]).to be_a(Sekken::XS::Element)
+    expect(sequence_elements[2].name).to eq('CreatedDate')
+
+    # complex_type#collect_child_elements resolves extensions
+    extension_elements = base_type.elements
+    all_elements = extension_elements + sequence_elements
+
+    expect(complex_type.collect_child_elements).to eq(all_elements)
+  end
+
+  specify 'complexType/simpleContent/attribute (plus annotations)' do
+    complex_type = new_complex_type('
+      <xs:complexType name="MeasureType">
+        <xs:annotation>
+          <xs:documentation>
+            Basic type for specifying measures and the system of measurement.
+          </xs:documentation>
+        </xs:annotation>
+        <xs:simpleContent>
+          <xs:extension base="xs:decimal">
+            <xs:attribute name="unit" type="xs:token" use="optional">
+              <xs:annotation>
+                <xs:documentation>
+                  Unit of measure. This attribute is shared by various fields,
+                  representing units such as lbs, oz, kg, g, in, cm.
+                </xs:documentation>
+                <xs:appinfo>
+                  <CallInfo>
+                    <CallName>AddItem</CallName>
+                    <CallName>AddItems</CallName>
+                    <RequiredInput>No</RequiredInput>
+                  </CallInfo>
+                  <CallInfo>
+                    <CallName>GetItemShipping</CallName>
+                    <CallName>GetSellerTransactions</CallName>
+                    <CallName>GetShippingDiscountProfiles</CallName>
+                    <Returned>Conditionally</Returned>
+                  </CallInfo>
+                  <CallInfo>
+                    <CallName>GetItem</CallName>
+                    <Details>DetailLevel: none, ItemReturnDescription, ItemReturnAttributes, ReturnAll</Details>
+                    <Returned>Conditionally</Returned>
+                  </CallInfo>
+                </xs:appinfo>
+              </xs:annotation>
+            </xs:attribute>
+          </xs:extension>
+        </xs:simpleContent>
+      </xs:complexType>
+    ')
+
+    expect(complex_type).to be_a(Sekken::XS::ComplexType)
+    expect(complex_type.collect_child_elements).to be_empty
+  end
+
+  specify 'complexType/sequence/element/simpleType' do
+    complex_type = new_complex_type('
+      <xsd:complexType name="JobStats">
+        <xsd:sequence>
+          <xsd:element name="jobID" type="xsd:integer"/>
+          <xsd:element name="jobType" type="xsd:string"/>
+          <xsd:element name="jobState">
+            <xsd:simpleType>
+              <xsd:restriction base="xsd:string">
+                <xsd:enumeration value="Running"/>
+                <xsd:enumeration value="Finished"/>
+                <xsd:enumeration value="Error"/>
+                <xsd:enumeration value="Queued"/>
+                <xsd:enumeration value="Cancelled"/>
+              </xsd:restriction>
+            </xsd:simpleType>
+          </xsd:element>
+        </xsd:sequence>
+      </xsd:complexType>
+    ')
+
+    expect(complex_type).to be_a(Sekken::XS::ComplexType)
+
+    elements = complex_type.collect_child_elements
+    expect(elements.count).to eq(3)
+
+    expect(elements[0].type).to eq('xsd:integer')
+    expect(elements[1].type).to eq('xsd:string')
+
+    expect(elements[2].type).to be_nil
+    expect(elements[2].inline_type).to be_a(Sekken::XS::SimpleType)
+    expect(elements[2].inline_type.base).to eq('xsd:string')
+  end
+
+  specify 'complexType/sequence' do
+    complex_type = new_complex_type('
+      <xs:complexType name="paypal">
+        <xs:sequence/>
+      </xs:complexType>
+    ')
+
+    expect(complex_type).to be_a(Sekken::XS::ComplexType)
+    expect(complex_type).to be_empty
+  end
+
+  def new_complex_type(xml, schemas = nil)
+    node = Nokogiri.XML(xml).root
+    schemas ||= mock('schemas')
+    schema = {}
+
+    Sekken::XS::ComplexType.new(node, schemas, schema)
+  end
+
+end

data/spec/sekken/xs/element_spec.rb

@@ -0,0 +1,82 @@
+require 'spec_helper'
+
+describe Sekken::XS::Element do
+
+  specify 'complexType/sequence/element' do
+    element = new_element('
+      <xs:element name="TermOfPayment" xmlns="http://www.w3.org/2001/XMLSchema"
+                                       xmlns:tns="http://example.com">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:element minOccurs="0" maxOccurs="1" name="termOfPaymentHandle" type="tns:TermOfPaymentHandle" />
+            <xs:element minOccurs="1" maxOccurs="1" name="value" nillable="true" type="xs:decimal" />
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+    ')
+
+    expect(element).to be_a(Sekken::XS::Element)
+
+    complex_type = element.children.first
+    expect(complex_type).to be_a(Sekken::XS::ComplexType)
+
+    sequence = complex_type.children.first
+    expect(sequence).to be_a(Sekken::XS::Sequence)
+
+    elements = sequence.children
+    expect(elements.count).to eq(2)
+
+    expect(elements[0]).to be_a(Sekken::XS::Element)
+    expect(elements[0].name).to eq('termOfPaymentHandle')
+
+    expect(elements[1]).to be_a(Sekken::XS::Element)
+    expect(elements[1].name).to eq('value')
+
+    expect(element.collect_child_elements).to eq(elements)
+  end
+
+  specify 'element/complexType/sequence/choice/element' do
+    element = new_element('
+      <xs:element name="source">
+        <xs:complexType>
+          <xs:sequence>
+            <xs:choice minOccurs="1">
+              <xs:element name="account" type="tns:id"/>
+              <xs:element name="linkedExternalAccountId" type="tns:id"/>
+              <xs:element name="newExternalAccount" type="tns:collectExternalAccount"/>
+            </xs:choice>
+          </xs:sequence>
+        </xs:complexType>
+      </xs:element>
+    ')
+
+    expect(element).to be_a(Sekken::XS::Element)
+    expect(element.collect_child_elements.count).to eq(3)
+  end
+
+  specify 'element/complexType/sequence/choice/element' do
+    element = new_element('
+      <xsd:element name="commandGroup">
+        <xsd:simpleType>
+          <xsd:restriction base="xsd:string"/>
+        </xsd:simpleType>
+      </xsd:element>
+    ')
+
+    expect(element).to be_a(Sekken::XS::Element)
+
+    expect(element.collect_child_elements).to be_empty
+    expect(element.type).to be_nil
+    expect(element.inline_type).to be_a(Sekken::XS::SimpleType)
+    expect(element.inline_type.base).to eq('xsd:string')
+  end
+
+  def new_element(xml)
+    node = Nokogiri.XML(xml).root
+    schemas ||= mock('schemas')
+    schema = {}
+
+    Sekken::XS::Element.new(node, schemas, schema)
+  end
+
+end

data/spec/sekken/xs/simple_type_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe Sekken::XS::SimpleType do
+
+  specify 'complexType/sequence/element' do
+    simple_type = new_simple_type('
+      <xs:simpleType name="TemperatureUnit" xmlns="http://www.w3.org/2001/XMLSchema">
+        <xs:restriction base="xs:string">
+          <xs:enumeration value="degreeCelsius" />
+          <xs:enumeration value="degreeFahrenheit" />
+          <xs:enumeration value="degreeRankine" />
+          <xs:enumeration value="degreeReaumur" />
+          <xs:enumeration value="kelvin" />
+        </xs:restriction>
+      </xs:simpleType>
+    ')
+
+    expect(simple_type).to be_a(Sekken::XS::SimpleType)
+
+    restriction = simple_type.children.first
+    expect(restriction).to be_a(Sekken::XS::Restriction)
+
+    enums = restriction.children
+    expect(enums.count).to eq(5)
+
+    enums.each do |enum|
+      expect(enum).to be_a(Sekken::XS::Enumeration)
+    end
+  end
+
+  def new_simple_type(xml)
+    node = Nokogiri.XML(xml).root
+    schemas ||= mock('schemas')
+    schema = {}
+
+    Sekken::XS::SimpleType.new(node, schemas, schema)
+  end
+
+end

data/spec/sekken_spec.rb

@@ -0,0 +1,128 @@
+require 'spec_helper'
+
+describe Sekken do
+
+  subject(:client) { Sekken.new(wsdl, http_mock) }
+
+  let(:wsdl) { fixture('wsdl/amazon') }
+
+  let(:service_name)   { 'AmazonFPS' }
+  let(:port_name)      { 'AmazonFPSPort' }
+  let(:operation_name) { 'Pay' }
+
+  describe '.http_adapter' do
+    it 'returns the default HTTP client to use' do
+      expect(Sekken.http_adapter).to eq(Sekken::HTTPClient)
+    end
+
+    it 'can be changed to use a custom adapter' do
+      adapter = mock('http-adapter')
+
+      Sekken.http_adapter = adapter
+      expect(Sekken.http_adapter).to eq(adapter)
+
+      adapter.expects(:new).returns(adapter)
+      adapter.expects(:client).returns('http-client')
+
+      client = Sekken.new(wsdl)
+      expect(client.http).to eq('http-client')
+
+      # reset global state!
+      Sekken.http_adapter = nil
+    end
+  end
+
+  describe '.new' do
+    it 'expects a local or remote WSDL document' do
+      Sekken::WSDL.expects(:new).with(wsdl, instance_of(Sekken.http_adapter)).returns(:wasabi)
+      Sekken.new(wsdl)
+    end
+
+    it 'also accepts a custom HTTP adapter to replace the default' do
+      http = :my_http_adapter
+      Sekken::WSDL.expects(:new).with(wsdl, http).returns(:wasabi)
+
+      Sekken.new(wsdl, http)
+    end
+  end
+
+  describe '#wsdl' do
+    it 'returns the WSDL' do
+      expect(client.wsdl).to be_an_instance_of(Sekken::WSDL)
+    end
+  end
+
+  describe '#http' do
+    it 'returns the HTTP adapter\'s client to configure' do
+      client = Sekken.new(wsdl)
+      expect(client.http).to be_an_instance_of(HTTPClient)
+    end
+  end
+
+  describe '#services' do
+    it 'returns the services and ports defined by the WSDL' do
+      expect(client.services).to eq(
+        'AmazonFPS' => {
+          ports: {
+            'AmazonFPSPort' => {
+              type:     'http://schemas.xmlsoap.org/wsdl/soap/',
+              location: 'https://fps.amazonaws.com'
+            }
+          }
+        }
+      )
+    end
+  end
+
+  describe '#operations' do
+    it 'returns an Array of operations for a service and port' do
+      operations = client.operations(service_name, port_name)
+
+      expect(operations.count).to eq(25)
+      expect(operations).to include('GetAccountBalance', 'GetTransaction', 'SettleDebt')
+    end
+
+    it 'also accepts symbols for the service and port name' do
+      operations = client.operations(:AmazonFPS, :AmazonFPSPort)
+      expect(operations.count).to eq(25)
+    end
+
+    it 'raises if the service could not be found' do
+      expect { client.operations(:UnknownService, :UnknownPort) }.
+        to raise_error(ArgumentError, /Unknown service "UnknownService"/)
+    end
+
+    it 'raises if the port could not be found' do
+      expect { client.operations(service_name, :UnknownPort) }.
+        to raise_error(ArgumentError, /Unknown service "AmazonFPS" or port "UnknownPort"/)
+    end
+  end
+
+  describe '#operation' do
+    it 'returns an Operation by service, port and operation name' do
+      operation = client.operation(service_name, port_name, operation_name)
+      expect(operation).to be_a(Sekken::Operation)
+    end
+
+    it 'also accepts symbols for the service, port and operation name' do
+      operation = client.operation(:AmazonFPS, :AmazonFPSPort, :Pay)
+      expect(operation).to be_a(Sekken::Operation)
+    end
+
+    it 'raises if the service could not be found' do
+      expect { client.operation(:UnknownService, :UnknownPort, :UnknownOperation) }.
+        to raise_error(ArgumentError, /Unknown service "UnknownService"/)
+    end
+
+    it 'raises if the port could not be found' do
+      expect { client.operation(service_name, :UnknownPort, :UnknownOperation) }.
+        to raise_error(ArgumentError, /Unknown service "AmazonFPS" or port "UnknownPort"/)
+    end
+
+    it 'raises if the operation could not be found' do
+      expect { client.operation(service_name, port_name, :UnknownOperation) }.
+        to raise_error(ArgumentError, /Unknown operation "UnknownOperation" for service "AmazonFPS" and port "AmazonFPSPort"/)
+    end
+  end
+
+end