washout_builder 0.14.1 → 0.15.0

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

@@ -1,88 +1,83 @@
-#encoding:utf-8
+# encoding:utf-8
 require 'spec_helper'
 
-class InheritedExceptionModel 
+class InheritedExceptionModel
   include WashoutBuilder::Document::ExceptionModel
-  
 end
 
-
 describe WashoutBuilder::Document::ExceptionModel do
+  let(:subject) { WashoutBuilderTestError }
+
+  let(:structure) { { 'message' => { primitive: 'string', member_type: nil }, 'backtrace' => { primitive: 'string', member_type: nil } } }
+  let(:base_structure) { { 'code' => { primitive: 'integer', member_type: nil }, 'message' => { primitive: 'string', member_type: nil }, 'backtrace' => { primitive: 'string', member_type: nil } } }
+  let(:ancestors) { [base_exception] }
 
-  let(:subject) { WashoutBuilderTestError}
-  
-  let(:structure) { {"message"=>{:primitive=>"string", :member_type=>nil}, "backtrace"=>{:primitive=>"string", :member_type=>nil}}}
-  let(:base_structure) { {"code"=>{:primitive=>"integer", :member_type=>nil}, "message"=>{:primitive=>"string", :member_type=>nil}, "backtrace"=>{:primitive=>"string", :member_type=>nil}}}
-  let(:ancestors) {[base_exception]}
-  
   [
     WashoutBuilder::Document::SharedComplexType
   ].each do |extension|
     specify { described_class.included_modules.should include(extension) }
   end
-  
-  specify {InheritedExceptionModel.included_modules.should include(WashoutBuilder::Document::SharedComplexType) }
-  
-  def fault_ancestor_hash(subject,  structure, ancestors)
-    {:fault => subject,:structure =>structure  ,:ancestors => ancestors   }
+
+  specify { InheritedExceptionModel.included_modules.should include(WashoutBuilder::Document::SharedComplexType) }
+
+  def fault_ancestor_hash(subject, structure, ancestors)
+    { fault: subject, structure: structure, ancestors: ancestors }
   end
-  
-  it "gets the strcuture" do
-    subject.get_fault_model_structure.should eq(structure)
+
+  it 'gets the strcuture' do
+    subject.find_fault_model_structure.should eq(structure)
   end
-  
-  it "gets the strcuture" do
-    base_exception.get_fault_model_structure.should eq(base_structure)
+
+  it 'gets the strcuture' do
+    base_exception.find_fault_model_structure.should eq(base_structure)
   end
-  it "gets the strcuture" do
-    subject.get_fault_attributes.should eq(["message", "backtrace"])
+  it 'gets the strcuture' do
+    subject.find_fault_attributes.should eq(%w(message backtrace))
   end
-  it "gets the strcuture" do
-    base_exception.get_fault_attributes.should eq(["code","message", "backtrace"])
+  it 'gets the strcuture' do
+    base_exception.find_fault_attributes.should 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") }
-    
-  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}})
+
+  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') }
+
+  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 })
   end
-  
-  it "fault_ancestor_hash" do
-    subject.fault_ancestor_hash( structure, ancestors).should eq(fault_ancestor_hash(subject,  structure, ancestors))
+
+  it 'fault_ancestor_hash' do
+    subject.fault_ancestor_hash(structure, ancestors).should 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)
+
+  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
   end
-  
-  it "gets the attribute type" do
-    subject.get_fault_type_method("some_name").should eq "string"
+
+  it 'gets the attribute type' do
+    subject.get_fault_type_method('some_name').should eq 'string'
   end
-  
-  
-  it "gets the fault_without_inheritable_elements" do
-    ancestors[0].expects(:get_fault_model_structure).returns(structure)
+
+  it 'gets the fault_without_inheritable_elements' do
+    ancestors[0].expects(:find_fault_model_structure).returns(structure)
     subject.expects(:remove_fault_type_inheritable_elements).with(structure.keys)
     subject.fault_without_inheritable_elements(ancestors)
   end
-  
-  it "gets the ancestors" do
+
+  it 'gets the ancestors' do
     subject.expects(:fault_ancestors).returns(nil)
-    subject.expects(:get_fault_model_structure).returns(structure)
-    subject.expects(:fault_ancestor_hash).with(structure, []).returns(fault_ancestor_hash(subject,  structure, ancestors))
+    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)
   end
-  
-  it "gets the ancestors" do
-    expected_defined = fault_ancestor_hash(subject,  structure, ancestors)
+
+  it 'gets the ancestors' do
+    expected_defined = fault_ancestor_hash(subject, structure, ancestors)
     subject.expects(:fault_ancestors).returns(ancestors)
     subject.expects(:fault_without_inheritable_elements).with(ancestors).returns(structure)
     subject.expects(:fault_ancestor_hash).returns(expected_defined)
     subject.get_fault_class_ancestors([])
   end
-  
 end

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

@@ -1,73 +1,71 @@
-#encoding:utf-8
+# encoding:utf-8
 require 'spec_helper'
 mock_controller do
-  soap_service  namespace: "/api/wsdl", description: "some description"
+  soap_service namespace: '/api/wsdl', description: 'some description'
 
-  soap_action 'dispatcher_method', :args => nil, :return => nil
-  soap_action 'dispatcher_method2', :args => nil, :return => nil, :raises => WashoutBuilderTestError
-  soap_action 'dispatcher_method3', :args => ProjectType , :return => nil, :raises => [WashoutBuilderTestError]
+  soap_action 'dispatcher_method', args: nil, return: nil
+  soap_action 'dispatcher_method2', args: nil, return: nil, raises: WashoutBuilderTestError
+  soap_action 'dispatcher_method3', args: ProjectType, return: nil, raises: [WashoutBuilderTestError]
   def dispatcher_method
-    #nothing
+    # nothing
   end
+
   def dispatcher_method2
-    #nothing
+    # nothing
   end
+
   def dispatcher_method3
-    #nothing
+    # nothing
   end
 end
 
 describe WashoutBuilder::Document::Generator do
-  
-  let(:soap_config) { OpenStruct.new(
+  let(:soap_config) do
+    OpenStruct.new(
       camelize_wsdl: false,
-      namespace: "/api/wsdl",
-      description: "some description"
-    ) }
- 
+      namespace: '/api/wsdl',
+      description: 'some description'
+    )
+  end
+
   let(:service_class) { ApiController }
   before(:each) do
-    @document = WashoutBuilder::Document::Generator.new("api")
+    @document = WashoutBuilder::Document::Generator.new('api')
     @document.stubs(:controller_class).returns(service_class)
-    
-  end
-    
-  
-  
-  context "namespace" do
-    specify {  @document.namespace.should eq(soap_config.namespace) }
-  end
-  
-  context "endpoint" do
-    specify {  @document.endpoint.should eq(soap_config.namespace.gsub("/wsdl", "/action")) }
-  end
-  
-  context "service" do
-    specify { @document.service.should eq(service_class.name.underscore.gsub("_controller", "").camelize) }
-  end
-  
-  context "description" do
-    specify {@document.service_description.should eq(soap_config.description )}
-  end
-  
-  context "operations" do
-    specify { @document.operations.should 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
+  end
+
+  context 'namespace' do
+    specify { @document.namespace.should eq(soap_config.namespace) }
+  end
+
+  context 'endpoint' do
+    specify { @document.endpoint.should eq(soap_config.namespace.gsub('/wsdl', '/action')) }
+  end
+
+  context 'service' do
+    specify { @document.service.should eq(service_class.name.underscore.gsub('_controller', '').camelize) }
+  end
+
+  context 'description' do
+    specify { @document.service_description.should eq(soap_config.description) }
+  end
+
+  context 'operations' do
+    specify { @document.operations.should 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
     end
-    
   end
-  
+
   def argument_types(type)
-    format_type = (type == "input") ? "builder_in" : "builder_out"
+    format_type = (type == 'input') ? 'builder_in' : 'builder_out'
     types = []
     unless service_class.soap_actions.blank?
-      service_class.soap_actions.each do |operation, formats|
+      service_class.soap_actions.each do |_operation, formats|
         (formats[format_type.to_sym]).each do |p|
           types << p
         end
@@ -75,91 +73,68 @@ describe WashoutBuilder::Document::Generator do
     end
     types
   end
-  
-  
-  context "input types" do
-    
-    specify { @document.input_types.should eq(argument_types("input")) }
-    
-  end
-  
-  context "output types" do
-
-    specify { @document.output_types.should 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]) }
-  end
-  
-  context "get_soap_action_names" do
-    
-    let(:expected) {service_class.soap_actions.map { |operation, formats| operation }.map(&:to_s).sort_by { |name| name.downcase }.uniq}
-    
-    specify  { @document.get_soap_action_names.should eq(expected) }
-    
-    
-    it "returns nil on empty soap actions" do
+
+  context 'input types' do
+    specify { @document.input_types.should eq(argument_types('input')) }
+  end
+
+  context 'output types' do
+    specify { @document.output_types.should 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]) }
+  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) }
+
+    it 'returns nil on empty soap actions' do
       @document.stubs(:soap_actions).returns(nil)
-      @document.get_soap_action_names.should eq(nil)
+      @document.all_soap_action_names.should eq(nil)
     end
-    
-  end
-  
-  
-  context "actions with exceptions" do
-    let(:actions_with_exceptions) {service_class.soap_actions.select{|operation, formats| !formats[:raises].blank? } }
-    let(:exceptions_raised) { actions_with_exceptions.collect {|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?}
-    
+  end
+
+  context 'actions with exceptions' do
+    let(:actions_with_exceptions) { service_class.soap_actions.select { |_operation, formats| !formats[:raises].blank? } }
+    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 }
-    
-    it "returns the fault types" do
-      WashoutBuilder::Type.stubs(:get_fault_classes).returns([base_exception])
+
+    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.expects(:sort_complex_types).with([base_exception], 'fault').returns([base_exception])
       @document.fault_types.should eq([base_exception])
     end
-    
-    it "returns complex fault types" do
+
+    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([])
     end
-    
-  end
-  
-  
-  context "complex types" do
-    
-    let(:expected){
-      
-    }
-    
-    
-    it "returns nil on empty soap actions" do
+  end
+
+  context 'complex types' do
+    let(:expected)do
+    end
+
+    it 'returns nil on empty soap actions' do
       @document.stubs(:soap_actions).returns(nil)
       @document.complex_types.should eq(nil)
     end
-    
-    it "returns nil if no complex types detected" do
+
+    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.expects(:sort_complex_types).with([], 'class').returns(nil)
       @document.complex_types.should eq(nil)
     end
-    
-    
-    
-    
-    
-  end
-  
-  
-end
+  end
+end

data/spec/lib/washout_builder/type_spec.rb

@@ -1,42 +1,30 @@
-#encoding:utf-8
+# encoding:utf-8
 
 require 'spec_helper'
 
 describe WashoutBuilder::Type do
+  let(:exception) { WashoutBuilderTestError }
+  let(:fault_classes) { [exception] }
 
-  let(:exception) { WashoutBuilderTestError}
-  let(:fault_classes) {  [exception]  }
-  
-  it "defines a list of types" do
-    WashoutBuilder::Type::BASIC_TYPES.should eq([ 
-        "string",
-        "integer",
-        "double",
-        "boolean",
-        "date",
-        "datetime",
-        "float",
-        "time",
-        "int"])
+  it 'defines a list of types' do
+    WashoutBuilder::Type::BASIC_TYPES.should eq(%w(string integer double boolean date datetime float time int))
   end
-  
-  it "gets the fault classes defined" do
-    WashoutBuilder::Type.get_fault_classes.should eq ([base_exception])
+
+  it 'gets the fault classes defined' do
+    WashoutBuilder::Type.all_fault_classes.should eq([base_exception])
   end
-  
-  context "exception" do
+
+  context 'exception' do
     before(:each) do
-      WashoutBuilder::Type.stubs(:get_fault_classes).returns([base_exception])
+      WashoutBuilder::Type.stubs(:all_fault_classes).returns([base_exception])
     end
-    
-    it "checks if exception has ancestor" do
-      WashoutBuilder::Type.has_ancestor_fault?(exception).should eq(true)
+
+    it 'checks if exception has ancestor' do
+      WashoutBuilder::Type.ancestor_fault?(exception).should eq(true)
     end
-    
-    it "checks if exception valid" do
+
+    it 'checks if exception valid' do
       WashoutBuilder::Type.valid_fault_class?(exception).should eq(true)
     end
   end
-  
- 
-end
+end