wash_out 0.9.0 → 0.11.0.beta.1

data/spec/lib/wash_out/dispatcher_spec.rb

@@ -12,20 +12,127 @@ describe WashOut::Dispatcher do
     end
   end
 
-  it "finds nested hashes" do
-    WashOut::Dispatcher.deep_select(:foo => 1){|k,v| k == :foo}.should == [1]
-    WashOut::Dispatcher.deep_select({:foo => {:foo => 1}}){|k,v| k == :foo}.should == [{:foo => 1}, 1]
+  describe ".deep_select" do
+    blk = lambda{|v| v.is_a?(Hash) && v.has_key?(:@id)}
+
+    it "find no elements if there aren't any ids" do
+      expect(WashOut::Dispatcher.deep_select({k: {v: :v2}}, &blk)).to eq []
+    end
+
+    it "finds elements with ids in a hash" do
+      expect(WashOut::Dispatcher.deep_select({k: {:@id => 5, x: :y}}, &blk)).to eq [{:@id => 5, x: :y}]
+    end
+
+    it "finds elements with ids in a array" do
+      expect(WashOut::Dispatcher.deep_select({k: [{:@id => 5, x: :y}]}, &blk)).to eq [{:@id => 5, x: :y}]
+    end
+
+    it "finds elements with ids in hashes" do
+      expect(WashOut::Dispatcher.deep_select(
+        {
+          k: {:@id => 5, x: :y},
+          k2: {:@id => 6, n: :m}
+        }, &blk)).to eq [{:@id => 5, x: :y}, {:@id => 6, n: :m}]
+    end
+
+    it "finds elements in a hash and in a array" do
+      expect(WashOut::Dispatcher.deep_select(
+        {
+          k: [{:@id => 5, x: :y}],
+          k2: {:@id => 6, n: :m}
+        }, &blk)).to contain_exactly({:@id => 5, x: :y}, {:@id => 6, n: :m})
+    end
+
+    it "finds elements with ids in multiple arrays" do
+      expect(WashOut::Dispatcher.deep_select(
+        {
+          k: [{:@id => 5, x: :y}],
+          k2: [{:@id => 6, n: :m}]
+        }, &blk)).to eq [{:@id => 5, x: :y}, {:@id => 6, n: :m}]
+    end
   end
 
-  it "replaces nested hashed" do
-    WashOut::Dispatcher.deep_replace_href({:foo => {:@href => 1}}, {1 => 2}).should == {:foo => 2}
-    WashOut::Dispatcher.deep_replace_href({:bar => {:foo => {:@href => 1}}}, {1 => 2}).should == {:bar => {:foo => 2}}
+  describe ".deep_replace_href" do
+    it "replaces nested hashed" do
+      expect(WashOut::Dispatcher.deep_replace_href(
+        {:foo => {:@href => 1}},
+        {1 => 2})).to eq(
+          {:foo => 2}
+        )
+    end
+
+    it "replaces deeper nested hashes" do
+      expect(WashOut::Dispatcher.deep_replace_href(
+        {:bar => {:foo => {:@href => 1}}},
+        {1 => 2}
+      )).to eq(
+        {:bar => {:foo => 2}}
+      )
+    end
+
+    it "replace nested refs" do
+      hash = {fizz: {:@href => "#id4"}}
+      replaces = {
+        "#id4" => {:@href => "#id6"},
+        "#id6" => {foo: :bar}
+      }
+      expect(WashOut::Dispatcher.deep_replace_href(hash, replaces)).to eq({
+        fizz: {foo: :bar}})
+    end
+
+    it "replace really nested refs" do
+      hash = {fizz: {:@href => "#id4"}}
+      replaces = {
+        "#id4" => {:@href => "#id6"},
+        "#id6" => {:@href => "#id7"},
+        "#id7" => {foo: :bar}
+      }
+      expect(WashOut::Dispatcher.deep_replace_href(hash, replaces)).to eq({
+        fizz: {foo: :bar}})
+    end
+
+    it "replaces arrays in nested hashes" do
+      hash = {
+        fizz: {:@href => "#id4"},
+        Array: [
+          {Item: [{:@href => "#id6"}, {:@href => "#id7"}]},
+          {Item: {loo: :iioo}}
+        ]
+      }
+      replaces = {
+        "#id4" => {Item: [{:@href => "#id6"}, {:@href => "#id7"}]},
+        "#id6" => {foo: :bar},
+        "#id7" => {baz: :bats}
+      }
+      expect(WashOut::Dispatcher.deep_replace_href(hash, replaces)).to eq({
+        fizz: {Item: [
+          {foo: :bar},
+          {baz: :bats}
+        ]},
+        Array: [
+          {Item: [{foo: :bar}, {baz: :bats}]},
+          {Item: {loo: :iioo}}
+        ]
+      })
+    end
+
+    it "can traverse arrays that do not contain hashes" do
+      hash = {
+        fizz: {:@href => "#id1"},
+      }
+      replaces = {
+        "#id1" => {Item: ["1", "2"]},
+      }
+      expect(WashOut::Dispatcher.deep_replace_href(hash, replaces)).to eq({
+        fizz: {Item: ["1", "2"]},
+      })
+    end
   end
 
   xit "parses typical request" do
     dispatcher = Dispatcher.mock("<foo>1</foo>")
     dispatcher._parse_soap_parameters
-    dispatcher.params.should == {:foo => "1"}
+    expect(dispatcher.params).to eq({:foo => "1"})
   end
 
   xit "parses href request" do
@@ -45,11 +152,26 @@ describe WashOut::Dispatcher do
       </root>
     XML
     dispatcher._parse_soap_parameters
-    dispatcher.params[:root][:request][:entities].should == {
+    expect(dispatcher.params[:root][:request][:entities]).to eq({
       :foo => {:bar=>"1"},
       :sub => {:foo=>"1", :@id=>"id2"},
       :@id => "id1"
-    }
+    })
+  end
+
+  describe "#_map_soap_parameters" do
+    let(:dispatcher) { Dispatcher.new }
+    let(:soap_config) { WashOut::SoapConfig.new(camelize_wsdl: false) }
+
+    before do
+      allow(dispatcher).to receive(:action_spec).and_return(in: WashOut::Param.parse_def(soap_config, { foo: { "@bar" => :string, empty: :string } } ))
+      allow(dispatcher).to receive(:xml_data).and_return(foo: { "@bar" => "buzz", empty: { :"@xsi:type" => "xsd:string" } })
+    end
+
+    it "should handle empty strings that have been parsed wrong by nori, but preserve attrs" do
+      dispatcher._map_soap_parameters
+      expect(dispatcher.params).to eq("foo" => { "bar" => "buzz", "empty" => nil })
+    end
   end
 
   describe "#_load_params" do
@@ -58,25 +180,25 @@ describe WashOut::Dispatcher do
     it "should load params for an array" do
       spec = WashOut::Param.parse_def(soap_config, {:my_array => [:integer] } )
       xml_data = {:my_array => [1, 2, 3]}
-      dispatcher._load_params(spec, xml_data).should == {"my_array" => [1, 2, 3]}
+      expect(dispatcher._load_params(spec, xml_data)).to eq({"my_array" => [1, 2, 3]})
     end
 
     it "should load params for an empty array" do
       spec = WashOut::Param.parse_def(soap_config, {:my_array => [:integer] } )
       xml_data = {}
-      dispatcher._load_params(spec, xml_data).should == {}
+      expect(dispatcher._load_params(spec, xml_data)).to eq({})
     end
 
     it "should load params for a nested array" do
       spec = WashOut::Param.parse_def(soap_config, {:nested => {:my_array => [:integer]}} )
       xml_data = {:nested => {:my_array => [1, 2, 3]}}
-      dispatcher._load_params(spec, xml_data).should == {"nested" => {"my_array" => [1, 2, 3]}}
+      expect(dispatcher._load_params(spec, xml_data)).to eq({"nested" => {"my_array" => [1, 2, 3]}})
     end
 
     it "should load params for an empty nested array" do
       spec = WashOut::Param.parse_def(soap_config, {:nested => {:empty => [:integer] }} )
       xml_data = {:nested => nil}
-      dispatcher._load_params(spec, xml_data).should == {"nested" => {}}
+      expect(dispatcher._load_params(spec, xml_data)).to eq({"nested" => {}})
     end
 
   end

data/spec/lib/wash_out/middleware_spec.rb

@@ -11,23 +11,23 @@ describe WashOut::Middleware do
     end
 
     env = {}
-    lambda {
+    expect {
       WashOut::Middleware.raise_or_render_rexml_parse_error err, env
-    }.should raise_exception
+    }.to raise_exception(REXML::ParseException)
 
     env['HTTP_SOAPACTION'] = 'pretend_action'
     env['rack.errors'] = double 'logger', {:puts => true} 
     env['rack.input'] = double 'basic-rack-input', {:string => '<hi>'} 
     result = WashOut::Middleware.raise_or_render_rexml_parse_error err, env
-    result[0].should == 400
-    result[1]['Content-Type'].should == 'text/xml'
+    expect(result[0]).to eq 400
+    expect(result[1]['Content-Type']).to eq 'text/xml'
     msg = result[2][0]
-    msg.should include 'Error parsing SOAP Request XML'
-    msg.should include 'soap:Fault'
-    msg.should_not include __FILE__
+    expect(msg).to include 'Error parsing SOAP Request XML'
+    expect(msg).to include 'soap:Fault'
+    expect(msg).not_to include __FILE__
     
     env['rack.input'] = double 'passenger-input', {:read => '<hi>'}
     result = WashOut::Middleware.raise_or_render_rexml_parse_error err, env
-    result[0].should == 400
+    expect(result[0]).to eq 400
   end
 end

data/spec/lib/wash_out/param_spec.rb

@@ -21,9 +21,9 @@ describe WashOut::Param do
       soap_config = WashOut::SoapConfig.new({ camelize_wsdl: false })
       map = WashOut::Param.parse_def soap_config, Abraka2
 
-      map.should be_a_kind_of(Array)
-      map[0].name.should == 'foo'
-      map[0].map[0].name.should == 'test'
+      expect(map).to be_a_kind_of(Array)
+      expect(map[0].name).to eq 'foo'
+      expect(map[0].map[0].name).to eq 'test'
     end
 
     it "respects camelization setting" do
@@ -31,16 +31,16 @@ describe WashOut::Param do
 
       map = WashOut::Param.parse_def soap_config, Abraka2
 
-      map.should be_a_kind_of(Array)
-      map[0].name.should == 'Foo'
-      map[0].map[0].name.should == 'Test'
+      expect(map).to be_a_kind_of(Array)
+      expect(map[0].name).to eq 'Foo'
+      expect(map[0].map[0].name).to eq 'Test'
     end
   end
 
   it "should accept nested empty arrays" do
     soap_config = WashOut::SoapConfig.new({ camelize_wsdl: false })
     map = WashOut::Param.parse_def(soap_config, {:nested => {:some_attr => :string, :empty => [:integer] }} )
-    map[0].load( {:nested => nil}, :nested).should == {}
+    expect(map[0].load( {:nested => nil}, :nested)).to eq({})
   end
 
   describe "booleans" do
@@ -50,13 +50,45 @@ describe WashOut::Param do
     let(:map) { WashOut::Param.parse_def(soap_config, :value => :boolean) }
 
     it "should accept 'true' and '1'" do
-      map[0].load({:value => true}, :value).should be_true
-      map[0].load({:value => "1"}, :value).should be_true
+      expect(map[0].load({:value => true}, :value)).to be true
+      expect(map[0].load({:value => "1"}, :value)).to be true
     end
 
     it "should accept 'false' and '0'" do
-      map[0].load({:value => false}, :value).should be_false
-      map[0].load({:value => "0"}, :value).should be_false
+      expect(map[0].load({:value => false}, :value)).to be false
+      expect(map[0].load({:value => "0"}, :value)).to be false
+    end
+  end
+
+  describe 'longs' do
+    let(:soap_config) { WashOut::SoapConfig.new({ camelize_wsdl: false }) }
+    let(:map) { WashOut::Param.parse_def(soap_config, :value => :long) }
+
+    it "should accept positive long" do
+      expect(map[0].load({:value => 9223372036854775807}, :value)).to eq 9223372036854775807
+    end
+
+    it "should accept negative long" do
+      expect(map[0].load({:value => -9223372036854775807}, :value)).to eq -9223372036854775807
+    end
+  end
+
+  describe '#flat_copy' do
+    it 'should copy everything' do
+      soap_config = WashOut::SoapConfig.new({})
+      type = :foo
+      multiplied = "of course"
+
+      param = WashOut::Param.new(soap_config, 'name', type, multiplied)
+      param.source_class = "middle class"
+      evil_clone = param.flat_copy
+
+      expect(evil_clone.source_class).to eq "middle class"
+      expect(evil_clone.name).to eq 'name'
+      expect(evil_clone.raw_name).to eq 'name'
+      expect(evil_clone.type).to eq "foo"
+      expect(evil_clone.multiplied).to eq "of course"
+      expect(evil_clone.soap_config).to eq soap_config
     end
   end
 end

data/spec/lib/wash_out/router_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+require 'wash_out/router'
+
+describe WashOut::Router do
+  it 'returns a 200 with empty soap action' do
+
+    mock_controller do
+      # nothing
+    end
+
+    env = {}
+    env['REQUEST_METHOD'] = 'GET'
+    env['rack.input'] = double 'basic-rack-input', {:string => ''}
+    result = WashOut::Router.new('Route::Space::Api').call env
+
+    expect(result[0]).to eq(500)
+    expect(result[1]['Content-Type']).to eq('text/xml; charset=utf-8')
+  end
+
+  def parse_soap_params_from_xml(filename)
+    xml = File.read(File.expand_path("../../../fixtures/#{filename}", __FILE__))
+    env = {'rack.input' => StringIO.new(xml)}
+
+    router = WashOut::Router.new('')
+    controller = double("controller", soap_config: WashOut::SoapConfig.new)
+    allow(router).to receive(:controller).and_return(controller)
+
+    router.parse_soap_parameters(env)[:Envelope][:Body]
+  end
+
+  it "returns refs to arrays correctly" do
+    body = parse_soap_params_from_xml('ref_to_one_array.xml')
+
+    expect(body[:list][:Item]).to eq(["1", "2"])
+  end
+
+  it "returns refs to multiple arrays correctly" do
+    body = parse_soap_params_from_xml('refs_to_arrays.xml')
+
+    expect(body[:first_list][:Item]).to eq(["1", "2"])
+    expect(body[:second_list][:Item]).to eq(["11", "22"])
+  end
+
+  it "returns nested refs to multiple arrays correctly" do
+    body = parse_soap_params_from_xml('nested_refs_to_arrays.xml')
+
+    expect(body[:parent][:first_list][:Item]).to eq(["1", "2"])
+    expect(body[:parent][:second_list][:Item]).to eq(["11", "22"])
+  end
+end

data/spec/lib/wash_out/type_spec.rb

@@ -1,4 +1,4 @@
-#encoding:utf-8
+  #encoding:utf-8
 
 require 'spec_helper'
 
@@ -15,11 +15,11 @@ describe WashOut::Type do
       map :foo => Abraka1
     end
 
-    Abraka1.wash_out_param_name.should == 'abraka1'
-    Abraka1.wash_out_param_map.should == {:test => :string}
+    expect(Abraka1.wash_out_param_name).to eq 'abraka1'
+    expect(Abraka1.wash_out_param_map).to eq({:test => :string})
 
-    Abraka2.wash_out_param_name.should == 'test'
-    Abraka2.wash_out_param_map.should == {:foo => Abraka1}
+    expect(Abraka2.wash_out_param_name).to eq 'test'
+    expect(Abraka2.wash_out_param_map).to eq({:foo => Abraka1})
   end
 
   it "allows arrays inside custom types" do
@@ -31,11 +31,11 @@ describe WashOut::Type do
       map :foo => [:bar => Abraka1]
     end
 
-    Abraka1.wash_out_param_name.should == 'abraka1'
-    Abraka1.wash_out_param_map.should == {:test => :string}
+    expect(Abraka1.wash_out_param_name).to eq 'abraka1'
+    expect(Abraka1.wash_out_param_map).to eq({:test => :string})
 
-    Abraka2.wash_out_param_name.should == 'test'
-    Abraka2.wash_out_param_map.should == {:foo => [:bar => Abraka1]}
+    expect(Abraka2.wash_out_param_name).to eq 'test'
+    expect(Abraka2.wash_out_param_map).to eq({:foo => [:bar => Abraka1]})
   end
 
 end