washout_builder 0.15.4 → 0.15.5

data/spec/lib/washout_builder/document/exception_model_spec.rb

@@ -15,49 +15,49 @@ describe WashoutBuilder::Document::ExceptionModel do
   [
     WashoutBuilder::Document::SharedComplexType
   ].each do |extension|
-    specify { described_class.included_modules.should include(extension) }
+    specify { expect(described_class.included_modules).to include(extension) }
   end
 
-  specify { InheritedExceptionModel.included_modules.should include(WashoutBuilder::Document::SharedComplexType) }
+  specify { expect(InheritedExceptionModel.included_modules).to include(WashoutBuilder::Document::SharedComplexType) }
 
   def fault_ancestor_hash(subject, structure, ancestors)
     { fault: subject, structure: structure, ancestors: ancestors }
   end
 
   it 'gets the strcuture' do
-    subject.find_fault_model_structure.should eq(structure)
+    expect(subject.find_fault_model_structure).to eq(structure)
   end
 
   it 'gets the strcuture' do
-    base_exception.find_fault_model_structure.should eq(base_structure)
+    expect(base_exception.find_fault_model_structure).to eq(base_structure)
   end
   it 'gets the strcuture' do
-    subject.find_fault_attributes.should eq(%w(message backtrace))
+    expect(subject.find_fault_attributes).to eq(%w(message backtrace))
   end
   it 'gets the strcuture' do
-    base_exception.find_fault_attributes.should eq(%w(code message backtrace))
+    expect(base_exception.find_fault_attributes).to eq(%w(code message backtrace))
   end
 
-  specify { subject.check_valid_fault_method?('code').should eq(true) }
-  specify { subject.get_fault_type_method('code').should eq('integer') }
-  specify { subject.get_fault_type_method('message').should eq('string') }
-  specify { subject.get_fault_type_method('backtrace').should eq('string') }
+  specify { expect(subject.check_valid_fault_method?('code')).to eq(true) }
+  specify { expect(subject.get_fault_type_method('code')).to eq('integer') }
+  specify { expect(subject.get_fault_type_method('message')).to eq('string') }
+  specify {  expect(subject.get_fault_type_method('backtrace')).to eq('string') }
 
   it 'gets the strcuture' do
-    subject.remove_fault_type_inheritable_elements(['code']).should eq('message' => { primitive: 'string', member_type: nil }, 'backtrace' => { primitive: 'string', member_type: nil })
+     expect(subject.remove_fault_type_inheritable_elements(['code'])).to eq('message' => { primitive: 'string', member_type: nil }, 'backtrace' => { primitive: 'string', member_type: nil })
   end
 
   it 'fault_ancestor_hash' do
-    subject.fault_ancestor_hash(structure, ancestors).should eq(fault_ancestor_hash(subject, structure, ancestors))
+     expect(subject.fault_ancestor_hash(structure, ancestors)).to eq(fault_ancestor_hash(subject, structure, ancestors))
   end
 
   it 'gets the fault_ancestors' do
     subject.expects(:get_complex_type_ancestors).with(subject, ['ActiveRecord::Base', 'Object', 'BasicObject', 'Exception']).returns(ancestors)
-    subject.fault_ancestors.should eq ancestors
+     expect(subject.fault_ancestors).to eq ancestors
   end
 
   it 'gets the attribute type' do
-    subject.get_fault_type_method('some_name').should eq 'string'
+     expect(subject.get_fault_type_method('some_name')).to eq 'string'
   end
 
   it 'gets the fault_without_inheritable_elements' do
@@ -70,7 +70,7 @@ describe WashoutBuilder::Document::ExceptionModel do
     subject.expects(:fault_ancestors).returns(nil)
     subject.expects(:find_fault_model_structure).returns(structure)
     subject.expects(:fault_ancestor_hash).with(structure, []).returns(fault_ancestor_hash(subject, structure, ancestors))
-    subject.get_fault_class_ancestors([]).should eq(nil)
+     expect(subject.get_fault_class_ancestors([])).to eq(nil)
   end
 
   it 'gets the ancestors' do

data/spec/lib/washout_builder/document/generator_spec.rb

@@ -35,29 +35,29 @@ describe WashoutBuilder::Document::Generator do
   end
 
   context 'namespace' do
-    specify { @document.namespace.should eq(soap_config.namespace) }
+    specify { expect(@document.namespace).to eq(soap_config.namespace) }
   end
 
   context 'endpoint' do
-    specify { @document.endpoint.should eq(soap_config.namespace.gsub('/wsdl', '/action')) }
+    specify {  expect(@document.endpoint).to eq(soap_config.namespace.gsub('/wsdl', '/action')) }
   end
 
   context 'service' do
-    specify { @document.service.should eq(service_class.name.underscore.gsub('_controller', '').camelize) }
+    specify {  expect(@document.service).to eq(service_class.name.underscore.gsub('_controller', '').camelize) }
   end
 
   context 'description' do
-    specify { @document.service_description.should eq(soap_config.description) }
+    specify {  expect(@document.service_description).to eq(soap_config.description) }
   end
 
   context 'operations' do
-    specify { @document.operations.should eq(service_class.soap_actions.map { |operation, _formats| operation }) }
+    specify {  expect(@document.operations).to eq(service_class.soap_actions.map { |operation, _formats| operation }) }
   end
 
   context 'sorted_operations' do
     it 'returns sorted operations' do
       expected = service_class.soap_actions.sort_by { |operation, _formats| operation.downcase }.uniq
-      @document.sorted_operations.should eq expected
+       expect(@document.sorted_operations).to eq expected
     end
   end
 
@@ -75,27 +75,27 @@ describe WashoutBuilder::Document::Generator do
   end
 
   context 'input types' do
-    specify { @document.input_types.should eq(argument_types('input')) }
+    specify {  expect(@document.input_types).to eq(argument_types('input')) }
   end
 
   context 'output types' do
-    specify { @document.output_types.should eq(argument_types('output')) }
+    specify {  expect(@document.output_types).to eq(argument_types('output')) }
   end
 
   context 'operation exceptions' do
-    specify { @document.operation_exceptions('dispatcher_method').should eq([]) }
-    specify { @document.operation_exceptions('dispatcher_method2').should eq([WashoutBuilderTestError]) }
-    specify { @document.operation_exceptions('dispatcher_method3').should eq([WashoutBuilderTestError]) }
+    specify {  expect(@document.operation_exceptions('dispatcher_method')).to eq([]) }
+    specify {  expect(@document.operation_exceptions('dispatcher_method2')).to eq([WashoutBuilderTestError]) }
+    specify {  expect(@document.operation_exceptions('dispatcher_method3')).to eq([WashoutBuilderTestError]) }
   end
 
   context 'all_soap_action_names' do
     let(:expected) { service_class.soap_actions.map { |operation, _formats| operation }.map(&:to_s).sort_by(&:downcase).uniq }
 
-    specify { @document.all_soap_action_names.should eq(expected) }
+    specify {  expect(@document.all_soap_action_names).to eq(expected) }
 
     it 'returns nil on empty soap actions' do
       @document.stubs(:soap_actions).returns(nil)
-      @document.all_soap_action_names.should eq(nil)
+       expect(@document.all_soap_action_names).to eq(nil)
     end
   end
 
@@ -104,21 +104,21 @@ describe WashoutBuilder::Document::Generator do
     let(:exceptions_raised) { actions_with_exceptions.map { |_operation, formats| formats[:raises].is_a?(Array) ? formats[:raises] : [formats[:raises]] }.flatten }
     let(:filter_exceptions_raised) { exceptions_raised.select { |x| WashoutBuilder::Type.valid_fault_class?(x) } unless actions_with_exceptions.blank? }
 
-    specify { @document.actions_with_exceptions.should eq actions_with_exceptions }
-    specify { @document.exceptions_raised.should eq exceptions_raised }
-    specify { @document.filter_exceptions_raised.should eq filter_exceptions_raised }
+    specify {  expect(@document.actions_with_exceptions).to eq actions_with_exceptions }
+    specify {  expect(@document.exceptions_raised).to eq exceptions_raised }
+    specify {  expect(@document.filter_exceptions_raised).to eq filter_exceptions_raised }
 
     it 'returns the fault types' do
       WashoutBuilder::Type.stubs(:all_fault_classes).returns([base_exception])
       @document.expects(:get_complex_fault_types).with([base_exception]).returns([base_exception])
       @document.expects(:sort_complex_types).with([base_exception], 'fault').returns([base_exception])
-      @document.fault_types.should eq([base_exception])
+       expect(@document.fault_types).to eq([base_exception])
     end
 
     it 'returns complex fault types' do
       base_exception.expects(:get_fault_class_ancestors).with([], true).returns(nil)
       @document.expects(:filter_exceptions_raised).returns(nil)
-      @document.get_complex_fault_types([base_exception]).should eq([])
+       expect(@document.get_complex_fault_types([base_exception])).to eq([])
     end
   end
 
@@ -128,13 +128,13 @@ describe WashoutBuilder::Document::Generator do
 
     it 'returns nil on empty soap actions' do
       @document.stubs(:soap_actions).returns(nil)
-      @document.complex_types.should eq(nil)
+       expect(@document.complex_types).to eq(nil)
     end
 
     it 'returns nil if no complex types detected' do
       WashOut::Param.any_instance.expects(:get_nested_complex_types).returns([])
       @document.expects(:sort_complex_types).with([], 'class').returns(nil)
-      @document.complex_types.should eq(nil)
+      expect( @document.complex_types).to eq(nil)
     end
   end
 end

data/spec/lib/washout_builder/type_spec.rb

@@ -7,11 +7,11 @@ describe WashoutBuilder::Type do
   let(:fault_classes) { [exception] }
 
   it 'defines a list of types' do
-    WashoutBuilder::Type::BASIC_TYPES.should eq(%w(string integer double boolean date datetime float time int))
+     expect(WashoutBuilder::Type::BASIC_TYPES).to eq(%w(string integer double boolean date datetime float time int))
   end
 
   it 'gets the fault classes defined' do
-    WashoutBuilder::Type.all_fault_classes.should eq([base_exception])
+     expect(WashoutBuilder::Type.all_fault_classes).to eq([base_exception])
   end
 
   context 'exception' do
@@ -20,11 +20,11 @@ describe WashoutBuilder::Type do
     end
 
     it 'checks if exception has ancestor' do
-      WashoutBuilder::Type.ancestor_fault?(exception).should eq(true)
+       expect(WashoutBuilder::Type.ancestor_fault?(exception)).to eq(true)
     end
 
     it 'checks if exception valid' do
-      WashoutBuilder::Type.valid_fault_class?(exception).should eq(true)
+       expect(WashoutBuilder::Type.valid_fault_class?(exception)).to eq(true)
     end
   end
 end

data/spec/lib/washout_builder_spec.rb

@@ -36,19 +36,21 @@ describe WashoutBuilder do
 
   describe 'Module' do
     it 'includes' do
-      lambda do
-        mock_controller do
+     expect { lambda do
+         mock_controller do
           # nothing
         end
-      end.should_not raise_exception
+     end
+    }.to_not raise_exception
     end
 
     it 'allows definition of a simple action' do
-      lambda do
-        mock_controller do
+     expect {  lambda do
+         mock_controller do
           soap_action 'answer', args: nil, return: :integer
         end
-      end.should_not raise_exception
+     end
+        }.to_not raise_exception
     end
   end
 
@@ -76,13 +78,13 @@ describe WashoutBuilder do
 
     it 'lists operations' do
       operations = xml[:definitions][:binding][:operation]
-      operations.should be_a_kind_of(Array)
+       expect(operations).to be_a_kind_of(Array)
 
-      operations.map { |e| e[:'@name'] }.sort.should == %w(Result getArea rocky).sort
+      expect(operations.map { |e| e[:'@name'] }.sort ).to eq %w(Result getArea rocky).sort
     end
 
     it 'defines complex types' do
-      wsdl.include?('<xsd:complexType name="Circle1">').should == true
+       expect(wsdl.include?('<xsd:complexType name="Circle1">')).to eq true
     end
 
     it 'defines arrays' do
@@ -90,8 +92,8 @@ describe WashoutBuilder do
           .find { |inneer_x| inneer_x[:'@name'] == 'Center' }[:sequence][:element]
           .find { |inneer_x| inneer_x[:'@name'] == 'X' }
 
-      x[:'@min_occurs'].should eq('0')
-      x[:'@max_occurs'].should eq('unbounded')
+       expect(x[:'@min_occurs']).to eq('0')
+      expect(x[:'@max_occurs']).to eq('unbounded')
     end
   end
 
@@ -116,7 +118,7 @@ describe WashoutBuilder do
           </env:Envelope>
         XML
 
-        HTTPI.post('http://app/api/action', request).body.should == <<-XML
+        expect( HTTPI.post('http://app/api/action', request).body).to eq( <<-XML
 <?xml version="1.0" encoding="UTF-8"?>
 <soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsd="http://www.w3.org/2001/XMLSchema" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:tns="false">
   <soap:Body>
@@ -126,6 +128,7 @@ describe WashoutBuilder do
   </soap:Body>
 </soap:Envelope>
         XML
+        )
       end
 
       it 'accept no parameters' do
@@ -136,8 +139,8 @@ describe WashoutBuilder do
           end
         end
 
-        savon(:answer)[:answer_response][:value]
-          .should == '42'
+         expect(savon(:answer)[:answer_response][:value]
+          ).to eq '42'
       end
 
       it 'accept insufficient parameters' do
@@ -148,8 +151,8 @@ describe WashoutBuilder do
           end
         end
 
-        savon(:answer)[:answer_response][:value]
-          .should == '42'
+         expect(savon(:answer)[:answer_response][:value]
+          ).to eq '42'
       end
 
       it 'accept empty parameter' do
@@ -159,8 +162,8 @@ describe WashoutBuilder do
             render soap: { a: params[:a] }
           end
         end
-        savon(:answer, a: '')[:answer_response][:a]
-          .should == { :"@xsi:type" => 'xsd:string' }
+         expect(savon(:answer, a: '')[:answer_response][:a]
+          ).to eq ({ :"@xsi:type" =>  'xsd:string' })
       end
 
       it 'accept one parameter' do
@@ -171,8 +174,8 @@ describe WashoutBuilder do
           end
         end
 
-        savon(:check_answer, 42)[:check_answer_response][:value].should eq true
-        savon(:check_answer, 13)[:check_answer_response][:value].should eq false
+         expect(savon(:check_answer, 42)[:check_answer_response][:value]).to eq true
+         expect(savon(:check_answer, 13)[:check_answer_response][:value]).to eq false
       end
 
       it 'accept two parameters' do
@@ -183,7 +186,7 @@ describe WashoutBuilder do
           end
         end
 
-        savon(:funky, a: 42, b: 'k')[:funky_response][:value].should == '420k'
+         expect(savon(:funky, a: 42, b: 'k')[:funky_response][:value]).to eq '420k'
       end
     end
 
@@ -206,8 +209,8 @@ describe WashoutBuilder do
         message = { circle: { center: { x: 3, y: 4 },
                               radius: 5 } }
 
-        savon(:find_area, message)[:find_area_response]
-          .should == ({ area: (Math::PI * 25).to_s, distance_from_o: (5.0).to_s })
+         expect(savon(:find_area, message)[:find_area_response]
+          ).to eq ({ area: (Math::PI * 25).to_s, distance_from_o: (5.0).to_s })
       end
 
       it 'accept arrays' do
@@ -297,8 +300,8 @@ describe WashoutBuilder do
           end
         end
 
-        savon(:gogogo)[:gogogo_response]
-          .should == { zoo: 'zoo', boo: { :moo => 'moo', :doo => 'doo', :"@xsi:type" => 'tns:Boo' } }
+         expect(savon(:gogogo)[:gogogo_response]
+          ).to eq ({ zoo: 'zoo', boo: { moo: 'moo', doo: 'doo', :"@xsi:type" => 'tns:Boo' } })
       end
 
       it 'respond with arrays' do
@@ -311,7 +314,7 @@ describe WashoutBuilder do
           end
         end
 
-        savon(:rumba)[:rumba_response].should == { value: %w(1 2 3) }
+         expect(savon(:rumba)[:rumba_response]).to eq ({ value: %w(1 2 3) })
       end
 
       it 'respond with complex structures inside arrays' do
@@ -330,12 +333,12 @@ describe WashoutBuilder do
           end
         end
 
-        savon(:rumba)[:rumba_response].should == {
+         expect(savon(:rumba)[:rumba_response]).to eq ({
           rumbas: [
-            { :zombies => 'suck1', :puppies => 'rock1', :"@xsi:type" => 'tns:Rumbas' },
-            { :zombies => 'suck2', :puppies => 'rock2', :"@xsi:type" => 'tns:Rumbas' }
+            { zombies: 'suck1', puppies: 'rock1', :"@xsi:type" => 'tns:Rumbas' },
+            { zombies: 'suck2', puppies: 'rock2', :"@xsi:type" => 'tns:Rumbas' }
           ]
-        }
+        })
       end
 
       it 'respond with structs in structs in arrays' do
@@ -349,24 +352,24 @@ describe WashoutBuilder do
           end
         end
 
-        savon(:rumba)[:rumba_response].should == {
+         expect(savon(:rumba)[:rumba_response]).to eq ({
           value: [
             {
-              :rumbas => {
-                :zombies => '100000',
+              rumbas: {
+                zombies: '100000',
                 :"@xsi:type" => 'tns:Rumbas'
               },
               :"@xsi:type" => 'tns:Value'
             },
             {
-              :rumbas => {
-                :zombies => '2',
-                :"@xsi:type" => 'tns:Rumbas'
+              rumbas: {
+                zombies: '2',
+                :"@xsi:type"=> 'tns:Rumbas'
               },
-              :"@xsi:type" => 'tns:Value'
+              :"@xsi:type"=> 'tns:Value'
             }
           ]
-        }
+        })
       end
 
       context 'with arrays missing' do
@@ -379,7 +382,7 @@ describe WashoutBuilder do
             end
           end
 
-          savon(:rocknroll)[:rocknroll_response].should be_nil
+          expect( savon(:rocknroll)[:rocknroll_response]).to be_nil
         end
 
         it 'respond with complext definition' do
@@ -391,7 +394,7 @@ describe WashoutBuilder do
             end
           end
 
-          savon(:rocknroll)[:rocknroll_response].should be_nil
+           expect(savon(:rocknroll)[:rocknroll_response]).to be_nil
         end
 
         it 'respond with nested simple definition' do
@@ -403,8 +406,8 @@ describe WashoutBuilder do
             end
           end
 
-          savon(:rocknroll)[:rocknroll_response][:my_value]
-            .should == { :"@xsi:type" => 'tns:MyValue' }
+           expect(savon(:rocknroll)[:rocknroll_response][:my_value]
+            ).to eq ({ :"@xsi:type" => 'tns:MyValue' })
         end
 
         it 'handles incomplete array response' do
@@ -416,7 +419,7 @@ describe WashoutBuilder do
             end
           end
 
-          expect { savon(:rocknroll) }.not_to raise_error
+          expect { savon(:rocknroll) }.to_not raise_error
         end
       end
     end
@@ -447,26 +450,26 @@ describe WashoutBuilder do
         mock_controller do
           soap_action 'date', args: :date, return: :nil
           def date
-            params[:value].should == Date.parse('2000-12-30') unless params[:value].blank?
+             raise Exception if params[:value].present? &&  params[:value] !=  Date.parse('2000-12-30') 
             render soap: nil
           end
         end
 
         savon(:date, value: '2000-12-30')
-        -> { savon(:date) }.should_not raise_exception
+        expect { savon(:date) }.not_to raise_exception
       end
 
       it 'recognize base64Binary' do
         mock_controller do
           soap_action 'base64', args: :base64Binary, return: :nil
           def base64
-            params[:value].should == 'test' unless params[:value].blank?
+            raise Exception if  params[:value].present? &&  params[:value] !=  'test'
             render soap: nil
           end
         end
 
         savon(:base64, value: Base64.encode64('test'))
-        -> { savon(:base64) }.should_not raise_exception
+        expect { savon(:base64) }.not_to raise_exception
       end
     end
 
@@ -481,9 +484,9 @@ describe WashoutBuilder do
           end
         end
 
-        lambda do
+       expect {
           savon(:duty, bad: 42, good: nil)
-        end.should raise_exception(Savon::SOAPFault)
+       }.to raise_exception(Savon::SOAPFault)
       end
 
       it 'raise for date in incorrect format' do
@@ -493,9 +496,9 @@ describe WashoutBuilder do
             render soap: nil
           end
         end
-        lambda do
+        expect { 
           savon(:date, value: 'incorrect format')
-        end.should raise_exception(Savon::SOAPFault)
+       }.to raise_exception(Savon::SOAPFault)
       end
 
       it 'raise to report SOAP errors', fails: true do
@@ -507,8 +510,8 @@ describe WashoutBuilder do
           end
         end
 
-        -> { savon(:error, need_error: false) }.should_not raise_exception
-        -> { savon(:error, need_error: true) }.should raise_exception(Savon::SOAPFault)
+        expect { savon(:error, need_error: false) }.not_to raise_exception
+        expect { savon(:error, need_error: true) }.to raise_exception(Savon::SOAPFault)
       end
 
       it 'raise for manual throws' do
@@ -519,7 +522,7 @@ describe WashoutBuilder do
           end
         end
 
-        -> { savon(:error) }.should raise_exception(Savon::SOAPFault)
+        expect { savon(:error) }.to raise_exception(Savon::SOAPFault)
       end
 
       it 'raise when response structure mismatches' do
@@ -552,12 +555,12 @@ describe WashoutBuilder do
           end
         end
 
-        -> { savon(:bad) }.should raise_exception(
+        expect { savon(:bad) }.to raise_exception(
           WashOut::Dispatcher::ProgrammerError,
           /SOAP response .*wyldness.*Array.*Hash.*stallion/
         )
 
-        -> { savon(:bad2) }.should raise_exception(
+        expect { savon(:bad2) }.to raise_exception(
           WashOut::Dispatcher::ProgrammerError,
           /SOAP response .*oops.*String.*telephone_booths.*Array/
         )
@@ -581,10 +584,10 @@ describe WashoutBuilder do
             end
           end
 
-          -> { savon(:bad) }.should raise_exception{ |error|
+          expect { savon(:bad) }.to raise_exception{ |error|
             error_hash = error.to_hash
-            error_hash[:fault][:faultcode].should eq(error_code.to_s)
-            error_hash[:fault][:faultstring].should eq(error_message)
+             expect(error_hash[:fault][:faultcode]).to eq(error_code.to_s)
+             expect(error_hash[:fault][:faultstring]).to eq(error_message)
             expect(error).to be_a(Savon::SOAPFault)
           }
         end
@@ -597,15 +600,16 @@ describe WashoutBuilder do
         raise_runtime_exception = raise_exception(RuntimeError)
 
         mock_controller do
-          lambda do
             soap_action 'rumba',
                         args: :integer,
-                        return: []
-          end.should raise_runtime_exception
+                        return: nil
           def rumba
+            raise RuntimeError
             render soap: nil
           end
         end
+        
+          expect { savon(:rumba) }.to raise_runtime_exception
       end
     end
 
@@ -619,8 +623,8 @@ describe WashoutBuilder do
         end
       end
 
-      savon(name.underscore.to_sym)["#{name.underscore}_response".to_sym][:value]
-        .should == 'forty two'
+      expect(savon(name.underscore.to_sym)["#{name.underscore}_response".to_sym][:value]
+        ).to eq 'forty two'
     end
 
     it 'respects :response_tag option' do
@@ -631,7 +635,7 @@ describe WashoutBuilder do
         end
       end
 
-      savon(:specific).should == { test: { value: 'test' } }
+       expect(savon(:specific)).to eq({ test: { value: 'test' } })
     end
 
     it 'handles snakecase option properly' do