wasabi 3.6.1 → 3.7.0

data/spec/wasabi/parser/marketo_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Wasabi::Parser do
-  context 'with: marketo.wsdl' do
-    subject do
-      parser = Wasabi::Parser.new Nokogiri::XML(xml)
-      parser.parse
-      parser
-    end
-
-    let(:xml) { fixture(:marketo).read }
-
-    it 'parses the operations' do
-      expect(subject.operations[:get_lead][:input]).to eq('paramsGetLead')
-    end
-  end
-end

data/spec/wasabi/parser/multiple_namespaces_spec.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Wasabi::Parser do
-  context "with: multiple_namespaces.wsdl" do
-
-    subject do
-      parser = Wasabi::Parser.new Nokogiri::XML(xml)
-      parser.parse
-      parser
-    end
-
-    let(:xml) { fixture(:multiple_namespaces).read }
-
-    it "lists the types" do
-      expect(subject.types.keys.sort).to eq(["Article", "Save"])
-    end
-
-    it "records the namespace for each type" do
-      expect(subject.types["Save"][:namespace]).to eq("http://example.com/actions")
-    end
-
-    it "records the fields under a type" do
-      expect(subject.types["Save"].keys).to match_array(["article", :namespace, :order!])
-    end
-
-    it "records multiple fields when there are more than one" do
-      expect(subject.types["Article"].keys).to match_array(["Title", "Author", :namespace, :order!])
-    end
-
-    it "records the type of a field" do
-      expect(subject.types["Save"]["article"][:type]).to eq("article:Article")
-      expect(subject.namespaces["article"]).to eq("http://example.com/article")
-    end
-
-    it "lists the order of the type elements" do
-      expect(subject.types["Article"][:order!]).to eq(["Author", "Title"])
-    end
-
-  end
-end

data/spec/wasabi/parser/multiple_parts_in_message_spec.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Wasabi::Parser do
-  context 'with: multiple_parts_in_message.wsdl' do
-
-    subject do
-      parser = Wasabi::Parser.new Nokogiri::XML(xml)
-      parser.parse
-      parser
-    end
-
-    let(:xml) { fixture(:multiple_parts_in_message).read }
-
-    context "with a parts attribute in soap:body element" do
-      it 'uses the part specified in parts attribute' do
-        request = subject.operations[:some_operation][:input]
-
-        expect(request).to eq("SomeRequestBody")
-      end
-    end
-    
-    context "with no parts attribute in soap:body element" do
-      it 'uses the first part element in message' do
-        request = subject.operations[:other_operation][:input]
-
-        expect(request).to eq("SomeRequest")
-      end
-    end
-    
-  end
-end

data/spec/wasabi/parser/no_message_parts_spec.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Wasabi::Parser do
-  context 'with: no_message_parts.wsdl' do
-
-    subject do
-      parser = Wasabi::Parser.new Nokogiri::XML(xml)
-      parser.parse
-      parser
-    end
-
-    let(:xml) { fixture(:no_message_parts).read }
-
-    it 'falls back to using the message type in the port element' do
-      # Operation's input has no part element in the message, so using the message type.
-      expect(subject.operations[:save][:input]).to eq('Save')
-
-      # Operation's output has part element in the message, so using part element's type.
-      expect(subject.operations[:save][:output]).to eq('SaveResponse')
-    end
-
-    it 'falls back to using the namespace ID in the port element' do
-      expect(subject.operations[:save][:namespace_identifier]).to eq('actions')
-    end
-
-    it 'gracefully handles port messages without a colon' do
-      expect(subject.operations[:delete][:input]).to eq('Delete')
-      expect(subject.operations[:delete][:output]).to eq('DeleteResponse')
-      expect(subject.operations[:delete][:namespace_identifier]).to be_nil
-    end
-  end
-end

data/spec/wasabi/parser/no_namespace_spec.rb

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Wasabi::Parser do
-  context "with: no_namespace.wsdl" do
-
-    subject do
-      parser = Wasabi::Parser.new Nokogiri::XML(xml)
-      parser.parse
-      parser
-    end
-
-    let(:xml) { fixture(:no_namespace).read }
-
-    it "lists the types" do
-      expect(subject.types.keys.sort).to eq(["McContact", "McContactArray", "MpUser", "MpUserArray"])
-    end
-
-    it "ignores xsd:all" do
-      keys =  subject.types["MpUser"].keys
-      expect(keys.size).to eq(2)
-
-      expect(keys).to include(:namespace)
-      expect(keys).to include(:order!)
-    end
-  end
-end

data/spec/wasabi/parser/no_target_namespace_spec.rb

@@ -1,38 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Wasabi::Parser do
-  context "with a WSDL defining xs:schema without targetNamespace" do
-
-    subject do
-      parser = Wasabi::Parser.new Nokogiri::XML(xml)
-      parser.parse
-      parser
-    end
-
-    let(:xml) do
-      %Q{
-        <definitions xmlns='http://schemas.xmlsoap.org/wsdl/'
-          xmlns:xs='http://www.w3.org/2001/XMLSchema'
-          targetNamespace='http://def.example.com'>
-          <types>
-            <xs:schema elementFormDefault='qualified'>
-              <xs:element name='Save'>
-                <xs:complexType></xs:complexType>
-              </xs:element>
-            </xs:schema>
-          </types>
-        </definitions>
-      }
-    end
-
-    # Don't know if real WSDL files omit targetNamespace from xs:schema,
-    # but I suppose we should do something reasonable if they do.
-
-    it "defaults to the target namespace from xs:definitions" do
-      expect(subject.types["Save"][:namespace]).to eq("http://def.example.com")
-    end
-
-  end
-end

data/spec/wasabi/parser/softlayer_spec.rb

@@ -1,20 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Wasabi::Parser do
-  context 'with: brand.wsdl' do
-    subject do
-      parser = Wasabi::Parser.new Nokogiri::XML(xml)
-      parser.parse
-      parser
-    end
-
-    let(:xml) { fixture(:brand).read }
-
-    it 'parses the operations' do
-      expect(subject.operations[:create_object][:input]).to eq('createObject' => { 'templateObject' => ['tns', 'SoftLayer_Brand'] })
-      expect(subject.operations[:create_customer_account][:input]).to eq('createCustomerAccount' => {'account' => ['tns', 'SoftLayer_Account'], 'bypassDuplicateAccountCheck' => ['xsd', 'boolean']})
-    end
-  end
-end

data/spec/wasabi/parser/symbolic_endpoint_spec.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Wasabi::Parser do
-  context "with: symbolic_endpoint.wsdl" do
-    subject(:parser) { described_class.new Nokogiri::XML(xml) }
-
-    let(:xml) { fixture(:symbolic_endpoint).read }
-
-    before { parser.parse }
-
-    it "allows symbolic endpoints" do
-      expect(parser.endpoint).to be_nil
-    end
-
-    it "should position base class attributes before subclass attributes in :order! array" do
-      type = parser.types["ROPtsLiesListe"]
-      expect(type[:order!]).to eq(["messages", "returncode", "listenteil"])
-    end
-
-  end
-end

data/spec/wasabi/parser/tradetracker_spec.rb

@@ -1,19 +0,0 @@
-# frozen_string_literal: true
-
-require 'spec_helper'
-
-describe Wasabi::Parser do
-  context 'with: tradetracker.wsdl' do
-    subject do
-      parser = Wasabi::Parser.new Nokogiri::XML(xml)
-      parser.parse
-      parser
-    end
-
-    let(:xml) { fixture(:tradetracker).read }
-
-    it 'parses the operations' do
-      expect(subject.operations[:get_feeds][:input]).to eq('getFeeds' => {"affiliateSiteID"=>["xsd", "nonNegativeInteger"], "options"=>["tns", "FeedFilter"]})
-    end
-  end
-end

data/spec/wasabi/resolver_spec.rb

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Wasabi::Resolver do
-
-  describe "#resolve" do
-    it "resolves remote documents" do
-      expect(HTTPI).to receive(:get) { HTTPI::Response.new(200, {}, "wsdl") }
-      xml = Wasabi::Resolver.new("http://example.com?wsdl").resolve
-      expect(xml).to eq("wsdl")
-    end
-
-    it "resolves remote documents with custom adapter" do
-      prev_logging = HTTPI.instance_variable_get(:@log)
-      HTTPI.log = false # Don't pollute rspec output by request logging
-      xml = Wasabi::Resolver.new("http://example.com?wsdl", nil, :fake_adapter_for_test).resolve
-      expect(xml).to eq("wsdl_by_adapter")
-      expect(FakeAdapterForTest.class_variable_get(:@@requests).size).to eq(1)
-      expect(FakeAdapterForTest.class_variable_get(:@@requests).first.url).to eq(URI.parse("http://example.com?wsdl"))
-      expect(FakeAdapterForTest.class_variable_get(:@@methods)).to eq([:get])
-      HTTPI.log = prev_logging
-    end
-
-    it "resolves local documents" do
-      xml = Wasabi::Resolver.new(fixture(:authentication).path).resolve
-      expect(xml).to eq(fixture(:authentication).read)
-    end
-
-    it "simply returns raw XML" do
-      xml = Wasabi::Resolver.new("<xml/>").resolve
-      expect(xml).to eq("<xml/>")
-    end
-
-    it "raises HTTPError when #load_from_remote gets a response error" do
-      code = 404
-      headers = {
-        "content-type" => "text/html"
-      }
-      body = "<html><head><title>404 Not Found</title></head><body>Oops!</body></html>"
-      failed_response = HTTPI::Response.new(code, headers, body)
-
-      expect(HTTPI).to receive(:get) { failed_response }
-
-      url = "http://example.com?wsdl"
-
-      expect do
-        Wasabi::Resolver.new(url).resolve
-      end.to raise_error { |ex|
-        expect(ex).to be_a(Wasabi::Resolver::HTTPError)
-        expect(ex.message).to eq("Error: #{code} for url #{url}")
-        expect(ex.response).to eq(failed_response)
-      }
-    end
-  end
-
-end

data/spec/wasabi/wasabi_spec.rb

@@ -1,14 +0,0 @@
-# frozen_string_literal: true
-
-require "spec_helper"
-
-describe Wasabi do
-
-  describe ".document" do
-    it "should return a new Wasabi::Document" do
-      document = Wasabi.document fixture(:authentication).read
-      expect(document).to be_a(Wasabi::Document)
-    end
-  end
-
-end