rapuncel 0.0.1 → 0.0.2

data/test/functional_test_helper.rb

@@ -1,12 +1,12 @@
 require 'test_helper'
 require 'test_server'
 
-class FunctionalTest < ActiveSupport::TestCase  
+class FunctionalTest < ActiveSupport::TestCase
   def setup
     @test_server = TestServer.new
     @test_server.start
   end
-  
+
   def teardown
     @test_server.stop
   end

data/test/test_server.rb

@@ -43,12 +43,12 @@ class TestServer
       s.add_handler(Num::INTERFACE, Num.new)
     end
   end
-  
+
   def start
     Thread.new { @server.serve }
   end
-  
+
   def stop
     @server.shutdown
-  end  
+  end
 end

data/test/unit/array_test.rb

@@ -8,37 +8,37 @@ class ArrayTest < ActiveSupport::TestCase
 
     assert_select xml, '/array/data/value', 10
   end
-  
+
   def test_array arr
     xml = arr.to_xml_rpc
-    
+
     xml_node = Nokogiri::XML(xml).children.first
-    
+
     reparsed = Array.from_xml_rpc xml_node
-    
+
     reparsed
   end
-  
-  
+
+
   test "An array, converted to xml and parsed back should be itself" do
     arr1 = (1..10).to_a
     arr2 = arr1.map &:to_s
-    
+
     arr3 = [arr1, arr2]
-    
+
     arr4 = ["hello", arr3]
-    
+
     reparsed1 = test_array arr1
     reparsed2 = test_array arr2
     reparsed3 = test_array arr3
     reparsed4 = test_array arr4
-    
+
     [reparsed1, reparsed2, reparsed3, reparsed4].zip([arr1, arr2, arr3, arr4]).each do |b|
       assert_equal *b
     end
-    
+
   end
-  
+
   test "real world repsonse" do
     response_body = <<-XML
       <array><data>
@@ -86,9 +86,9 @@ class ArrayTest < ActiveSupport::TestCase
       </struct></value>
       </data></array>
     XML
-    
+
     arr = Object.from_xml_rpc response_body
-    
+
     assert_kind_of Array, arr
     assert_equal 3, arr.size
   end

data/test/unit/boolean_test.rb

@@ -11,24 +11,24 @@ class BooleanTest < ActiveSupport::TestCase
     assert_select false.to_xml_rpc, '/boolean', 1
     assert_select false.to_xml_rpc, '/boolean', '0'
   end
-  
+
   test "true.to_xml_rpc reparsed must be true" do
     xml=true.to_xml_rpc
     xml_node = Nokogiri::XML(xml).children.first
-    
+
     assert Rapuncel::Boolean.from_xml_rpc(xml_node) #I assume assert takes a boolean?
     assert Rapuncel::Boolean.from_xml_rpc(xml_node) == true #is this different? just in case the other function gives back something non nil/false which is not necessarily true
   end
-  
+
   test "false.to_xml_rpc reparsed must be false" do
     xml=false.to_xml_rpc
     xml_node = Nokogiri::XML(xml).children.first
-    
+
     assert !Rapuncel::Boolean.from_xml_rpc(xml_node)
   end
-  
+
   test "anything else should evaluate to what now?" do
     assert true
   end
-  
+
 end

data/test/unit/float_test.rb

@@ -4,20 +4,20 @@ class FloatTest < ActiveSupport::TestCase
   test "A float should be a number between 'double' tags" do
     num=1.123456
     xml=num.to_xml_rpc
-    
+
     assert_select xml, '/double', 1
     assert_select xml, '/double', num.to_s
-    
+
   end
-  
+
   test "A float converted to xml and back should be the same number!" do
     num=1.123456
     xml=num.to_xml_rpc
-    
+
     xml_node=Nokogiri::XML(xml).children.first #make a nokogiri xml_node containing the float
-    
+
     assert_equal num, Float.from_xml_rpc(xml_node)
   end
-    
-    
+
+
 end

data/test/unit/hash_test.rb

@@ -2,24 +2,24 @@ require 'test_helper'
 require 'active_support/core_ext/hash/keys'
 
 class TestHelper < ActiveSupport::TestCase
-  
-  
-  
-  
+
+
+
+
   def to_and_from_xml_rpc hash
     xml = hash.to_xml_rpc
 
     xml_node = Nokogiri::XML(xml).children.first
-    
+
     Hash.from_xml_rpc xml_node
   end
-  
+
   test 'Hash#to_xml_rpc' do
     xml = {
       :abc => 'one and two',
       40 => %w(foo bar bee)
     }.to_xml_rpc
-    
+
     assert_select xml, '/struct', 1
     assert_select xml, '/struct/member', 2
     assert_select xml, '/struct/member/name', 'abc', 1
@@ -27,28 +27,28 @@ class TestHelper < ActiveSupport::TestCase
     assert_select xml, '/struct/member/name', '40', 1
     assert_select xml, '/struct/member/value/array/data/value', 3
   end
-  
-  
+
+
   test "A hash to xml and back should be itself" do
     hash1 = {:a => "b", :c => "d", :A => "B"}
     arr1 = (1..10).to_a
     hash2 = {:arr => arr1, :text => "sheeee"}
     hash3 = hash1.merge({:jooooo => hash2})
-    
+
     hash4 = Hash[*(1..10).to_a] #separate, non symbol keys
-    
+
     hashes = [hash1, hash2, hash3]
-    
+
     results = hashes.map do |h|
       to_and_from_xml_rpc h
     end
-    
+
     result4 = to_and_from_xml_rpc hash4 #separate, non symbol keys
-    
+
     hashes.zip(results).each do |hr|
       assert_equal *hr
-    end    
-    
+    end
+
     assert_equal hash4.stringify_keys.symbolize_keys, result4
   end
 end

data/test/unit/nil_test.rb

@@ -0,0 +1,16 @@
+require 'test_helper'
+
+class NilTest < ActiveSupport::TestCase
+
+  test "nil should have the same response as false" do
+    assert_equal false.to_xml_rpc, nil.to_xml_rpc
+  end
+
+  test "nil must evaluate to /boolean/0, as does false" do
+    assert_select nil.to_xml_rpc, '/boolean', 1
+    assert_select nil.to_xml_rpc, '/boolean', '0'
+  end
+
+
+
+end

data/test/unit/object_test.rb

@@ -4,79 +4,79 @@ class ObjectTest < ActiveSupport::TestCase
   class TestObject
     attr_accessor :a, :b, :c
   end
-  
+
   test 'Object#to_xml_rpc should collect instance_variables in a Hash and return Hash#to_xml_rpc' do
     obj = TestObject.new
     obj.a = "one"
     obj.b = "two"
-    
+
     assert_equal({'a' => 'one', 'b' => 'two'}, obj.send(:_collect_ivars_in_hash))
-    
+
     obj.a.expects :to_xml_rpc
     obj.b.expects :to_xml_rpc
-    
+
     obj.to_xml_rpc
   end
-  
+
   test "Object.from_xml_rpc should accept nodes as strings" do
     xml = "<int>42</int>"
-    
-    Integer.expects :from_xml_rpc    
+
+    Integer.expects :from_xml_rpc
     Object.from_xml_rpc xml
   end
-  
+
   test "Object.from_xml_rpc should accept Nokogiri nodes" do
     xml = Nokogiri::XML.parse("<int>42</int>").root
-    
+
     Integer.expects :from_xml_rpc
     Object.from_xml_rpc xml
   end
-  
+
   test "Object.from_xml_rpc should delegate int nodes" do
     xml = "<int>42</int>"
-    
-    Integer.expects :from_xml_rpc    
+
+    Integer.expects :from_xml_rpc
     Object.from_xml_rpc xml
   end
-  
+
   test "Object.from_xml_rpc should delegate string nodes" do
     xml = "<string>foo<string>"
-    
-    String.expects :from_xml_rpc    
+
+    String.expects :from_xml_rpc
     Object.from_xml_rpc xml
   end
-  
+
   test "Object.from_xml_rpc should delegate array nodes" do
     xml = "<array>42</array>"
-    
-    Array.expects :from_xml_rpc    
+
+    Array.expects :from_xml_rpc
     Object.from_xml_rpc xml
   end
-  
+
   test "Object.from_xml_rpc should delegate hash nodes" do
     xml = "<struct>42</struct>"
-    
-    Hash.expects :from_xml_rpc    
+
+    Hash.expects :from_xml_rpc
     Object.from_xml_rpc xml
   end
-  
+
   test "Object.from_xml_rpc should delegate boolean nodes" do
     xml = "<boolean>1</boolean>"
-    
-    Rapuncel::Boolean.expects :from_xml_rpc    
+
+    Rapuncel::Boolean.expects :from_xml_rpc
     Object.from_xml_rpc xml
   end
-  
+
   test "Object.from_xml_rpc should delegate double nodes" do
     xml = "<double>42.23</double>"
-    
-    Float.expects :from_xml_rpc    
+
+    Float.expects :from_xml_rpc
     Object.from_xml_rpc xml
   end
-  
+
   test "Object.from_xml_rpc should delegate Time nodes" do
     xml = "<dateTime.iso8601>2010-11-25T11:44:46+01:00</dateTime.iso8601>"
-    
+
     Time.expects :from_xml_rpc
     Object.from_xml_rpc xml
   end

data/test/unit/proxy_test.rb

@@ -2,14 +2,14 @@ require 'test_helper'
 
 class ProxyTest < ActiveSupport::TestCase
   class TestClient
-    def execute_to_ruby request
-      request
+    def call_to_ruby request, *args
+      [request] + args
     end
   end
 
   test "Proxy should still provide __ methods" do
     t = Object.new
-    t.expects(:execute_to_ruby).never
+    t.expects(:call_to_ruby).never
 
     p = Rapuncel::Proxy.new t
 
@@ -24,7 +24,7 @@ class ProxyTest < ActiveSupport::TestCase
     p = Rapuncel::Proxy.new t
     request = p.inspect
 
-    assert_equal 'inspect', request.method_name
+    assert_equal 'inspect', request.first
   end
 
   test "Proxy should delegate non-existing methods to Client" do
@@ -33,8 +33,8 @@ class ProxyTest < ActiveSupport::TestCase
     p = Rapuncel::Proxy.new t
     request = p.whatever 'arg1', 'foobar', 1234
 
-    assert_equal 'whatever', request.method_name
-    assert_equal ['arg1', 'foobar', 1234], request.arguments
+    assert_equal 'whatever', request.first
+    assert_equal ['arg1', 'foobar', 1234], request[1..-1]
   end
 
   test "Proxy should dynamically define methods as soon as needed" do
@@ -42,11 +42,11 @@ class ProxyTest < ActiveSupport::TestCase
 
     p = Rapuncel::Proxy.new t
 
-    assert !p.respond_to?('foobar')
+    assert p.respond_to?('foobar')
+    assert !Rapuncel::Proxy.instance_methods.include?('foobar')
 
     p.foobar
 
-    v = Rapuncel::Proxy.new t
-    assert v.respond_to?('foobar')
+    assert Rapuncel::Proxy.instance_methods.include?('foobar')
   end
 end

data/test/unit/response_test.rb

@@ -3,10 +3,10 @@ require 'test_helper'
 
 class ResponseTest < ActiveSupport::TestCase
   class MockReponse
-    attr_accessor :body
+    attr_accessor :body, :code
 
-    def initialize body, success = true
-      @body, @success = body, success
+    def initialize body, success = true, code = 200
+      @body, @success, @code = body, success, code
     end
 
     def success?
@@ -14,7 +14,7 @@ class ResponseTest < ActiveSupport::TestCase
     end
   end
 
-  test 'Response should be not an Array' do
+  test 'Response should not be an Array' do
     mock = MockReponse.new <<-XML
       <?xml version='1.0'?>
       <methodResponse>
@@ -30,7 +30,71 @@ class ResponseTest < ActiveSupport::TestCase
 
     r = Rapuncel::Response.new mock
 
+
+    assert r.success?
+    assert !r.fault?
+    assert !r.error?
     assert_equal "foo foo foo", r.to_ruby
+    assert_equal "foo foo foo", r.result
+  end
+
+  test "Response should handle faults" do
+    mock = MockReponse.new <<-XML
+      <?xml version='1.0'?>
+      <methodResponse>
+        <fault>
+          <value>
+            <struct>
+              <member>
+                <name>
+                  faultCode
+                </name>
+                <value>
+                  <int>
+                    42
+                  </int>
+                </value>
+              </member>
+              <member>
+                <name>
+                  faultString
+                </name>
+                <value>
+                  <string>
+                    Don't panic.
+                  </string>
+                </value>
+              </member>
+            </struct>
+          </value>
+        </fault>
+      </methodResponse>
+    XML
+
+    r = Rapuncel::Response.new mock
+
+    assert r.fault?
+    assert !r.success?
+    assert !r.error?
+
+    assert_kind_of Hash, r.to_ruby
+    assert_kind_of Hash, r.fault
+
+    assert_equal 42, r.fault[:faultCode]
+  end
+
+  test "Response should handle errors" do
+    mock = MockReponse.new "Not Found", false, 404
+
+    r = Rapuncel::Response.new mock
+
+    assert r.error?
+    assert !r.fault?
+    assert !r.success?
+
+    assert_kind_of Hash, r.to_ruby
+    assert_kind_of Hash, r.error
+
+    assert_equal 404, r.error[:http_code]
   end
-  
 end