wasabi 3.3.0 → 3.3.1

data/spec/wasabi/core_ext/string_spec.rb

@@ -4,33 +4,33 @@ describe String do
 
   describe "#snakecase" do
     it "lowercases one word CamelCase" do
-      "Merb".snakecase.should == "merb"
+      expect("Merb".snakecase).to eq("merb")
     end
 
     it "makes one underscore snakecase two word CamelCase" do
-      "MerbCore".snakecase.should == "merb_core"
+      expect("MerbCore".snakecase).to eq("merb_core")
     end
 
     it "handles CamelCase with more than 2 words" do
-      "SoYouWantContributeToMerbCore".snakecase.should == "so_you_want_contribute_to_merb_core"
+      expect("SoYouWantContributeToMerbCore".snakecase).to eq("so_you_want_contribute_to_merb_core")
     end
 
     it "handles CamelCase with more than 2 capital letter in a row" do
-      "CNN".snakecase.should == "cnn"
-      "CNNNews".snakecase.should == "cnn_news"
-      "HeadlineCNNNews".snakecase.should == "headline_cnn_news"
+      expect("CNN".snakecase).to eq("cnn")
+      expect("CNNNews".snakecase).to eq("cnn_news")
+      expect("HeadlineCNNNews".snakecase).to eq("headline_cnn_news")
     end
 
     it "does NOT change one word lowercase" do
-      "merb".snakecase.should == "merb"
+      expect("merb".snakecase).to eq("merb")
     end
 
     it "leaves snake_case as is" do
-      "merb_core".snakecase.should == "merb_core"
+      expect("merb_core".snakecase).to eq("merb_core")
     end
 
     it "converts period characters to underscores" do
-      "User.GetEmail".snakecase.should == "user_get_email"
+      expect("User.GetEmail".snakecase).to eq("user_get_email")
     end
   end
 

data/spec/wasabi/document/authentication_spec.rb

@@ -5,19 +5,33 @@ describe Wasabi::Document do
 
     subject { Wasabi::Document.new fixture(:authentication).read }
 
-    its(:namespace) { should == "http://v1_0.ws.auth.order.example.com/" }
+    describe '#namespace' do
+      subject { super().namespace }
+      it { should == "http://v1_0.ws.auth.order.example.com/" }
+    end
 
-    its(:endpoint) { should == URI("http://example.com/validation/1.0/AuthenticationService") }
+    describe '#endpoint' do
+      subject { super().endpoint }
+      it { should == URI("http://example.com/validation/1.0/AuthenticationService") }
+    end
 
-    its(:element_form_default) { should == :unqualified }
+    describe '#element_form_default' do
+      subject { super().element_form_default }
+      it { should == :unqualified }
+    end
 
-    it { should have(1).operations }
+    it 'has 1 operation' do
+      expect(subject.operations.size).to eq(1)
+    end
 
-    its(:operations) do
+    describe '#operations' do
+      subject { super().operations }
+      it do
       should == {
         :authenticate => { :input => "authenticate", :output => "authenticateResponse", :action => "authenticate", :namespace_identifier => "tns" }
       }
     end
+    end
 
   end
 end

data/spec/wasabi/document/encoded_endpoint_spec.rb

@@ -5,7 +5,10 @@ describe Wasabi::Document do
 
     subject { Wasabi::Document.new fixture(:encoded_endpoint).read }
 
-    its(:endpoint) { should == URI("http://localhost/soapservice/execute?path=/base/includes/Test+Soap/Return+Rows") }
+    describe '#endpoint' do
+      subject { super().endpoint }
+      it { should == URI("http://localhost/soapservice/execute?path=/base/includes/Test+Soap/Return+Rows") }
+    end
 
   end
 end

data/spec/wasabi/document/geotrust_spec.rb

@@ -5,20 +5,34 @@ describe Wasabi::Document do
 
     subject { Wasabi::Document.new fixture(:geotrust).read }
 
-    its(:namespace) { should == "http://api.geotrust.com/webtrust/query" }
+    describe '#namespace' do
+      subject { super().namespace }
+      it { should == "http://api.geotrust.com/webtrust/query" }
+    end
 
-    its(:endpoint) { should == URI("https://test-api.geotrust.com:443/webtrust/query.jws") }
+    describe '#endpoint' do
+      subject { super().endpoint }
+      it { should == URI("https://test-api.geotrust.com:443/webtrust/query.jws") }
+    end
 
-    its(:element_form_default) { should == :qualified }
+    describe '#element_form_default' do
+      subject { super().element_form_default }
+      it { should == :qualified }
+    end
 
-    it { should have(2).operations }
+    it 'has 2 operations' do
+      expect(subject.operations.size).to eq(2)
+    end
 
-    its(:operations) do
+    describe '#operations' do
+      subject { super().operations }
+      it do
       should include(
         { :get_quick_approver_list => { :input => "GetQuickApproverList", :action => "GetQuickApproverList", :parameters=>{:Request=>{:name=>"Request", :type=>"GetQuickApproverListInput"}}}},
         { :hello => { :input => "hello", :action => "hello", :parameters=>{:Input=>{:name=>"Input", :type=>"string"}} } }
       )
     end
+    end
 
   end
 end

data/spec/wasabi/document/inherited_spec.rb

@@ -5,33 +5,36 @@ describe Wasabi::Document do
 
     subject { Wasabi::Document.new fixture(:inherited).read }
 
-    its(:type_definitions) do
+    describe '#type_definitions' do
+      subject { super().type_definitions }
+      it do
       should include([["Account", "Id"], "ID"])
       should include([["Account", "ProcessId"], "ID"])
       should include([["Account", "CreatedDate"], "dateTime"])
       should include([["Account", "Description"], "string"])
       should include([["Account", "fieldsToNull"], "string"])
     end
+    end
 
     it "should position base class attributes before subclass attributes in :order! array" do
       account = subject.parser.types["Account"]
-      account[:order!].should == ["fieldsToNull", "Id", "Description", "ProcessId", "CreatedDate"]
+      expect(account[:order!]).to eq(["fieldsToNull", "Id", "Description", "ProcessId", "CreatedDate"])
     end
 
     it "should have each type's hash remember it's base type in :base_type element" do
       account = subject.parser.types["Account"]
-      account[:base_type].should == "baseObject"
+      expect(account[:base_type]).to eq("baseObject")
 
       base_object = subject.parser.types["baseObject"]
-      base_object.should_not have_key(:base_type)
+      expect(base_object).not_to have_key(:base_type)
     end
 
     it "should have element's hash contain all these attributes (:nillable, :minOccurs, :maxOccurs) in addition to :type" do
       base_object = subject.parser.types["baseObject"]
       fields_to_null = base_object["fieldsToNull"]
-      fields_to_null[:nillable].should == "true"
-      fields_to_null[:minOccurs].should == "0"
-      fields_to_null[:maxOccurs].should == "unbounded"
+      expect(fields_to_null[:nillable]).to eq("true")
+      expect(fields_to_null[:minOccurs]).to eq("0")
+      expect(fields_to_null[:maxOccurs]).to eq("unbounded")
     end
   end
 end

data/spec/wasabi/document/multiple_namespaces_spec.rb

@@ -5,19 +5,35 @@ describe Wasabi::Document do
 
     subject { Wasabi::Document.new fixture(:multiple_namespaces).read }
 
-    its(:namespace) { should == "http://example.com/actions" }
+    describe '#namespace' do
+      subject { super().namespace }
+      it { should == "http://example.com/actions" }
+    end
 
-    its(:endpoint) { should == URI("http://example.com:1234/soap") }
+    describe '#endpoint' do
+      subject { super().endpoint }
+      it { should == URI("http://example.com:1234/soap") }
+    end
 
-    its(:element_form_default) { should == :qualified }
+    describe '#element_form_default' do
+      subject { super().element_form_default }
+      it { should == :qualified }
+    end
 
-    it { should have(1).operations }
+    it 'has 1 operation' do
+      expect(subject.operations.size).to eq(1)
+    end
 
-    its(:operations) do
+    describe '#operations' do
+      subject { super().operations }
+      it do
       should == { :save => { :input => "Save", :output=>"SaveResponse", :action => "http://example.com/actions.Save", :namespace_identifier => "actions", :parameters => { :article => { :name => "article", :type => "Article" } } } }
     end
+    end
 
-    its(:type_namespaces) do
+    describe '#type_namespaces' do
+      subject { super().type_namespaces }
+      it do
       should =~ [
         [["Save"], "http://example.com/actions"],
         [["Save", "article"], "http://example.com/actions"],
@@ -26,10 +42,14 @@ describe Wasabi::Document do
         [["Article", "Title"], "http://example.com/article"]
       ]
     end
+    end
 
-    its(:type_definitions) do
+    describe '#type_definitions' do
+      subject { super().type_definitions }
+      it do
       should =~ [ [["Save", "article"], "Article"] ]
     end
+    end
 
   end
 end

data/spec/wasabi/document/namespaced_actions_spec.rb

@@ -5,21 +5,35 @@ describe Wasabi::Document do
 
     subject { Wasabi::Document.new fixture(:namespaced_actions).read }
 
-    its(:namespace) { should == "http://api.example.com/api/" }
+    describe '#namespace' do
+      subject { super().namespace }
+      it { should == "http://api.example.com/api/" }
+    end
 
-    its(:endpoint) { should == URI("https://api.example.com/api/api.asmx") }
+    describe '#endpoint' do
+      subject { super().endpoint }
+      it { should == URI("https://api.example.com/api/api.asmx") }
+    end
 
-    its(:element_form_default) { should == :qualified }
+    describe '#element_form_default' do
+      subject { super().element_form_default }
+      it { should == :qualified }
+    end
 
-    it { should have(3).operations }
+    it 'has 3 operations' do
+      expect(subject.operations.size).to eq(3)
+    end
 
-    its(:operations) do
+    describe '#operations' do
+      subject { super().operations }
+      it do
       should include(
         { :delete_client => { :input => "Client.Delete", :output => "Client.DeleteResponse", :action => "http://api.example.com/api/Client.Delete", :namespace_identifier => "tns" } },
         { :get_clients   => { :input => "User.GetClients", :output => "User.GetClientsResponse", :action => "http://api.example.com/api/User.GetClients", :namespace_identifier => "tns" } },
         { :get_api_key   => { :input => "User.GetApiKey", :output => "User.GetApiKeyResponse", :action => "http://api.example.com/api/User.GetApiKey", :namespace_identifier => "tns" } }
       )
     end
+    end
 
   end
 end

data/spec/wasabi/document/no_namespace_spec.rb

@@ -5,21 +5,35 @@ describe Wasabi::Document do
 
     subject { Wasabi::Document.new fixture(:no_namespace).read }
 
-    its(:namespace) { should == "urn:ActionWebService" }
+    describe '#namespace' do
+      subject { super().namespace }
+      it { should == "urn:ActionWebService" }
+    end
 
-    its(:endpoint) { should == URI("http://example.com/api/api") }
+    describe '#endpoint' do
+      subject { super().endpoint }
+      it { should == URI("http://example.com/api/api") }
+    end
 
-    its(:element_form_default) { should == :unqualified }
+    describe '#element_form_default' do
+      subject { super().element_form_default }
+      it { should == :unqualified }
+    end
 
-    it { should have(3).operations }
+    it 'has 3 operations' do
+      expect(subject.operations.size).to eq(3)
+    end
 
-    its(:operations) do
+    describe '#operations' do
+      subject { super().operations }
+      it do
       should include(
         { :get_user_login_by_id => { :input => "GetUserLoginById", :output => "GetUserLoginById", :action => "/api/api/GetUserLoginById", :namespace_identifier => "typens" } },
         { :get_all_contacts => { :input => "GetAllContacts", :output =>"GetAllContacts", :action => "/api/api/GetAllContacts", :namespace_identifier => "typens" } },
         { :search_user => { :input => "SearchUser", :output =>"SearchUser", :action => "/api/api/SearchUser", :namespace_identifier => nil } }
       )
     end
+    end
 
   end
 end

data/spec/wasabi/document/savon295_spec.rb

@@ -5,11 +5,14 @@ describe Wasabi::Document do
 
     subject { Wasabi::Document.new fixture(:savon295).read }
 
-    its(:operations) do
+    describe '#operations' do
+      subject { super().operations }
+      it do
       should include(
         { :sendsms => { :input => "sendsms", :output => "sendsms", :action => "sendsms", :namespace_identifier => "tns" } }
       )
     end
+    end
 
   end
 end

data/spec/wasabi/document/soap12_spec.rb

@@ -5,7 +5,10 @@ describe Wasabi::Document do
 
     subject { Wasabi::Document.new fixture(:soap12).read }
 
-    its(:endpoint) { should == URI("http://blogsite.example.com/endpoint12") }
+    describe '#endpoint' do
+      subject { super().endpoint }
+      it { should == URI("http://blogsite.example.com/endpoint12") }
+    end
 
   end
 end

data/spec/wasabi/document/two_bindings_spec.rb

@@ -5,17 +5,25 @@ describe Wasabi::Document do
 
     subject { Wasabi::Document.new fixture(:two_bindings).read }
 
-    its(:element_form_default) { should == :unqualified }
+    describe '#element_form_default' do
+      subject { super().element_form_default }
+      it { should == :unqualified }
+    end
 
-    it { should have(3).operations }
+    it 'has 3 operations' do
+      expect(subject.operations.size).to eq(3)
+    end
 
-    its(:operations) do
+    describe '#operations' do
+      subject { super().operations }
+      it do
       should include(
         { :post => { :input => "Post", :action => "Post" } },
         { :post11only => { :input => "Post11only", :action => "Post11only" } },
         { :post12only => { :input => "Post12only", :action => "Post12only" } }
       )
     end
+    end
 
   end
 end

data/spec/wasabi/document_spec.rb

@@ -5,20 +5,20 @@ describe Wasabi::Document do
   subject { Wasabi::Document.new fixture(:authentication).read }
 
   it "accepts a URL" do
-    HTTPI.should_receive(:get) { HTTPI::Response.new(200, {}, "wsdl") }
+    expect(HTTPI).to receive(:get) { HTTPI::Response.new(200, {}, "wsdl") }
 
     document = Wasabi::Document.new("http://example.com?wsdl")
-    document.xml.should == "wsdl"
+    expect(document.xml).to eq("wsdl")
   end
 
   it "accepts a path" do
     document = Wasabi::Document.new fixture(:authentication).path
-    document.xml.should == fixture(:authentication).read
+    expect(document.xml).to eq(fixture(:authentication).read)
   end
 
   it "accepts raw XML" do
     document = Wasabi::Document.new fixture(:authentication).read
-    document.xml.should == fixture(:authentication).read
+    expect(document.xml).to eq(fixture(:authentication).read)
   end
 
   describe ".validate_element_form_default!" do
@@ -39,13 +39,13 @@ describe Wasabi::Document do
 
   describe "#element_form_default" do
     it "defaults to :unqualified" do
-      subject.element_form_default.should == :unqualified
+      expect(subject.element_form_default).to eq(:unqualified)
     end
 
     [:unqualified, :qualified].each do |value|
       it "accepts :#{value}" do
         subject.element_form_default = value
-        subject.element_form_default.should == value
+        expect(subject.element_form_default).to eq(value)
       end
     end
 

data/spec/wasabi/parser/get_servicename_spec.rb

@@ -12,7 +12,7 @@ describe Wasabi::Parser do
     let(:xml) { fixture(:geotrust).read }
 
     it "returns the #service_name attribute" do
-      subject.service_name.should == "queryDefinitions"
+      expect(subject.service_name).to eq("queryDefinitions")
     end
 
   end

data/spec/wasabi/parser/import_port_types_spec.rb

@@ -14,8 +14,8 @@ describe Wasabi::Parser do
     it "does blow up when portTypes are imported" do
       get_customer = subject.operations[:get_customer]
 
-      get_customer[:input].should == "GetCustomer"
-      get_customer[:namespace_identifier].should be_nil
+      expect(get_customer[:input]).to eq("GetCustomer")
+      expect(get_customer[:namespace_identifier]).to be_nil
     end
 
   end

data/spec/wasabi/parser/juniper_spec.rb

@@ -14,9 +14,9 @@ describe Wasabi::Parser do
     it 'does not blow up when an extension base element is defined in an import' do
       request = subject.operations[:get_system_info_request]
 
-      request[:input].should == 'GetSystemInfoRequest'
-      request[:action].should == 'urn:#GetSystemInfoRequest'
-      request[:namespace_identifier].should == 'impl'
+      expect(request[:input]).to eq('GetSystemInfoRequest')
+      expect(request[:action]).to eq('urn:#GetSystemInfoRequest')
+      expect(request[:namespace_identifier]).to eq('impl')
     end
 
   end