wash_out 0.9.2 → 0.10.0

data/spec/lib/wash_out/dispatcher_spec.rb

@@ -13,19 +13,19 @@ describe WashOut::Dispatcher do
   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]
+    expect(WashOut::Dispatcher.deep_select(:foo => 1){|k,v| k == :foo}).to eq [1]
+    expect(WashOut::Dispatcher.deep_select({:foo => {:foo => 1}}){|k,v| k == :foo}).to eq([{:foo => 1}, 1])
   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}}
+    expect(WashOut::Dispatcher.deep_replace_href({:foo => {:@href => 1}}, {1 => 2})).to eq({:foo => 2})
+    expect(WashOut::Dispatcher.deep_replace_href({:bar => {:foo => {:@href => 1}}}, {1 => 2})).to eq({:bar => {:foo => 2}})
   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 +45,11 @@ 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
@@ -57,13 +57,13 @@ describe WashOut::Dispatcher do
     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, {:empty => :string } ))
-      allow(dispatcher).to receive(:xml_data).and_return(:empty => { :"@xsi:type" => "xsd:string" })
+      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" do
+    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('empty' => nil)
+      expect(dispatcher.params).to eq("foo" => { "bar" => "buzz", "empty" => nil })
     end
   end
 
@@ -73,25 +73,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/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