rapuncel 0.0.1.alpha

data/test/functional/client_test.rb

@@ -0,0 +1,54 @@
+require 'functional_test_helper'
+
+class FunctionalClientTest < FunctionalTest
+  test "Simple XMLRPC call" do
+    client = Rapuncel::Client.new :port => 8080, :raise_on => :both
+    proxy = client.proxy_for 'num'
+
+    result = proxy.add 40, 2
+
+    assert_equal 42, result
+  end
+  
+  test "Fault rpc call without raise" do
+    client = Rapuncel::Client.new :port => 8080
+    proxy = client.proxy_for 'num'
+    
+    assert_nothing_raised Rapuncel::Response::Exception do
+      proxy.add 20, 20, 2
+    end
+    
+    assert_kind_of Rapuncel::Response::Fault, proxy.add(20, 20, 2)    
+  end
+
+  test "Fault rpc call" do
+    client = Rapuncel::Client.new :port => 8080, :raise_on => :both
+    proxy = client.proxy_for 'num'
+    
+    assert_raise Rapuncel::Response::Fault do
+      proxy.add 20, 20, 2
+    end
+  end
+  
+  test "Error rpc connection" do
+    client = Rapuncel::Client.new :host => 'www.cice-online.net', :port => 80, :path => '/hullahoobahubbahooo', :raise_on => :both
+    proxy = client.proxy
+    
+    assert_raise Rapuncel::Response::Error do
+      proxy.foo :bar, :baz
+    end
+  end
+  
+  test "Error rpc connection without raise" do
+    client = Rapuncel::Client.new :host => 'www.google.de', :port => 80, :path => '/hullahoobahubbahooo'
+    proxy = client.proxy
+    
+    assert_nothing_raised Rapuncel::Response::Error do
+      proxy.foo :bar, :baz
+    end
+    
+    err = proxy.foo(:bar, :baz)
+    assert_kind_of Rapuncel::Response::Error, err
+    assert_equal 404, err.code
+  end
+end

data/test/functional_test_helper.rb

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

data/test/test_helper.rb

@@ -0,0 +1,38 @@
+lib_dir = File.join File.dirname(__FILE__), '..', 'lib'
+$:.unshift lib_dir
+
+require 'rubygems'
+require 'active_support'
+require 'test/unit'
+require 'mocha'
+require 'rapuncel'
+require 'nokogiri'
+require 'ruby-debug'
+
+class ActiveSupport::TestCase
+  def assert_select xml, xpath, eq, count = nil
+    doc = Nokogiri::XML.parse xml, nil, nil, Nokogiri::XML::ParseOptions::STRICT
+    res = doc.xpath xpath
+
+    eq.nil? && assert(res.blank?) && return
+
+    case eq
+    when Integer
+      assert_equal eq, res.size
+    when String
+      eq = eq.strip
+
+      if count
+        assert_equal count, res.to_a.select{ |node|
+          node.text.strip == eq
+        }.size
+      else
+        assert res.to_a.all?{ |node|
+          node.text.strip == eq
+        }
+      end
+    else
+      raise "Third argument should be String or Integer"
+    end
+  end
+end

data/test/test_server.rb

@@ -0,0 +1,28 @@
+require "xmlrpc/server"
+
+class Num
+  INTERFACE = XMLRPC::interface("num") {
+    meth 'int add(int, int)', 'Add two numbers', 'add'
+    meth 'int div(int, int)', 'Divide two numbers'
+  }
+
+  def add(a, b) a + b end
+  def div(a, b) a / b end
+end
+
+
+class TestServer
+  def initialize
+    @server = XMLRPC::Server.new(8080, '127.0.0.1', 4, File.open('/dev/null','w')).tap do |s|
+      s.add_handler(Num::INTERFACE, Num.new)
+    end
+  end
+
+  def start
+    Thread.new { @server.serve }
+  end
+
+  def stop
+    @server.shutdown
+  end
+end

data/test/unit/array_test.rb

@@ -0,0 +1,96 @@
+require 'test_helper'
+
+class ArrayTest < ActiveSupport::TestCase
+
+  test "an array of 10 entries should have 10x /array/data/value" do
+    arr = (1..10).to_a.map &:to_s
+    xml = arr.to_xml_rpc
+
+    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>
+      <value><struct>
+      <member>
+      <name>state</name>
+      <value><string>uninstalled</string></value>
+      </member>
+      <member>
+      <name>name</name>
+      <value><string>account_cancel</string></value>
+      </member>
+      <member>
+      <name>id</name>
+      <value><int>1</int></value>
+      </member>
+      </struct></value>
+      <value><struct>
+      <member>
+      <name>state</name>
+      <value><string>uninstalled</string></value>
+      </member>
+      <member>
+      <name>name</name>
+      <value><string>document_ftp</string></value>
+      </member>
+      <member>
+      <name>id</name>
+      <value><int>3</int></value>
+      </member>
+      </struct></value>
+      <value><struct>
+      <member>
+      <name>state</name>
+      <value><string>uninstalled</string></value>
+      </member>
+      <member>
+      <name>name</name>
+      <value><string>mrp_repair</string></value>
+      </member>
+      <member>
+      <name>id</name>
+      <value><int>2</int></value>
+      </member>
+      </struct></value>
+      </data></array>
+    XML
+
+    arr = Object.from_xml_rpc response_body
+
+    assert_kind_of Array, arr
+    assert_equal 3, arr.size
+  end
+
+end

data/test/unit/boolean_test.rb

@@ -0,0 +1,34 @@
+require 'test_helper'
+
+class BooleanTest < ActiveSupport::TestCase
+
+  test "true must evaluate to 1" do
+    assert_select true.to_xml_rpc, '/boolean', 1
+    assert_select true.to_xml_rpc, '/boolean', '1'
+  end
+
+  test "false must evaluate to 0" do
+    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/connection_test.rb

@@ -0,0 +1,17 @@
+require 'test_helper'
+
+class ConnectionTest < ActiveSupport::TestCase
+  test "Connection.new should return an AuthConnection if user, password or auth_method is set" do
+    assert_kind_of Rapuncel::AuthConnection, Rapuncel::Connection.build(:auth_method => 'basic')
+    assert_kind_of Rapuncel::AuthConnection, Rapuncel::Connection.build(:user => '')
+    assert_kind_of Rapuncel::AuthConnection, Rapuncel::Connection.build(:password => '')
+  end
+
+  test "Connection.new should return an ApiKeyAuthConnection if api_key is set" do
+    assert_kind_of Rapuncel::ApiKeyAuthConnection, Rapuncel::Connection.build(:api_key => 'xyz')
+  end
+
+  test "ApiKeyAuthConnection should contain api key in headers" do
+    assert_equal 'xyz', Rapuncel::Connection.build(:api_key => 'xyz').headers['X-ApiKey']
+  end
+end

data/test/unit/float_test.rb

@@ -0,0 +1,23 @@
+require 'test_helper'
+
+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

@@ -0,0 +1,54 @@
+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
+    assert_select xml, '/struct/member/value/string', 'one and two', 1
+    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
+
+    assert_equal hash4.stringify_keys.symbolize_keys, result4
+  end
+end

data/test/unit/int_test.rb

@@ -0,0 +1,27 @@
+require 'test_helper'
+
+class IntTest < ActiveSupport::TestCase
+
+  def test_number num = 1
+    assert_select num.to_xml_rpc, '/int', 1
+    assert_select num.to_xml_rpc, '/int', num.to_s
+  end
+
+  test "should convert the number 1234567 to the string '<int>1234567</int>'" do
+    num = 1234567
+
+    test_number num
+  end
+
+  test "should warn if numbers go out of 4 byte signed integer range [#{(-2**31).to_s}, #{(2**31-1)}], e.g #{(2**31).to_s},
+        but should still give the right result as long as ruby can handle the number" do
+    num = 2**31
+
+    test_number num
+  end
+
+  test "An int converted to xml and back should be the same number!" do
+    num = 234132
+    assert_equal num, Integer.from_xml_rpc(Nokogiri::XML(num.to_xml_rpc).children.first)
+  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

@@ -0,0 +1,83 @@
+require 'test_helper'
+
+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
+    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
+    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
+    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
+    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
+    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
+    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
+    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
+end