socialcast-rapuncel 0.0.7.RC1

data/spec/unit/boolean_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe TrueClass, FalseClass do
+  describe "Serialization" do
+    it 'represents true as 1' do
+      Rapuncel::XmlRpc::Serializer[true].should have_xpath('/boolean', :content => '1')
+    end
+    
+    it 'represents false as 0' do
+      Rapuncel::XmlRpc::Serializer[false].should have_xpath('/boolean', :content => '0')
+    end
+  end
+  
+  describe "Deserialization" do
+    it 'reads 1 as true' do
+      xml = <<-XML
+        <boolean>1</boolean>
+      XML
+      
+      Rapuncel::XmlRpc::Deserializer[xml].should be_a TrueClass
+    end
+    
+    it 'reads 0 as false' do
+      xml = <<-XML
+        <boolean>0</boolean>
+      XML
+      
+      Rapuncel::XmlRpc::Deserializer[xml].should be_a FalseClass
+    end
+    
+    it 'reads anything else as false' do
+      xml = <<-XML
+        <boolean>abcd</boolean>
+      XML
+      
+      Rapuncel::XmlRpc::Deserializer[xml].should be_a FalseClass
+    end
+  end
+end

data/spec/unit/client_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'logger'
+
+describe Rapuncel::Client do
+  let(:logger) { nil }
+  subject { Rapuncel::Client.new :logger => logger }
+  
+  it { should_not respond_to :logger }
+  it { should_not respond_to :log_level }
+  
+  describe "with Logging enabled" do
+    let(:logger) { Logger.new(STDOUT) }
+    
+    it { should respond_to :logger }
+    it { should respond_to :log_level }
+  end
+  
+  describe "log devices" do
+    describe 'Symbol' do
+      let(:logger) { :stdout }
+      
+      its(:logger) { should be_a Logger }
+    end
+    
+    describe 'String' do
+      let(:logger) { 'stdout' }
+      
+      its(:logger) { should be_a Logger }
+    end
+    
+    describe 'IO' do
+      let(:logger) { File.open('/dev/null', 'w') }
+      
+      its(:logger) { should be_a Logger }
+    end
+    
+    describe 'true' do
+      let(:logger) { true }
+      
+      its(:logger) { should be_a Logger }
+    end
+  end
+end

data/spec/unit/connection_spec.rb

@@ -0,0 +1,22 @@
+require 'spec_helper'
+
+describe Rapuncel::Connection do
+  it 'can use the host option with or without an extra "http://"' do
+    connection = Rapuncel::Connection.new :host => "http://example.org"
+    
+    connection.host.should == "example.org"
+  end
+  
+  it 'can use the path option with or without leading "/"' do
+    connection = Rapuncel::Connection.new :host => "http://example.org", :path => "abcd"
+    
+    connection.path.should == "/abcd"
+  end
+  
+  it 'can set the ssl option via host' do
+    connection = Rapuncel::Connection.new :host => "https://example.org", :path => "abcd"
+    
+    connection.ssl.should be_true
+  end
+end
+

data/spec/unit/custom_serialization_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe "Custom serialization" do
+  module CustomSerialization
+    class Serializer < Rapuncel::XmlRpc::Serializer
+    end
+    
+    class Deserializer < Rapuncel::XmlRpc::Deserializer
+    end
+  end
+  
+  it 'client selects custom (de)serializer, if provided by Symbol' do
+    client = Rapuncel::Client.new :serialization => :CustomSerialization
+    
+    client.send(:serializer).should == CustomSerialization::Serializer
+  end
+  
+  it 'client selects custom (de)serializer, if provided by Class' do
+    client = Rapuncel::Client.new :serialization => CustomSerialization
+    
+    client.send(:serializer).should == CustomSerialization::Serializer
+  end
+end

data/spec/unit/float_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+
+describe Float do
+  describe "Serialization" do
+    it "can serialize Floats" do
+      number = 1.23456
+      Rapuncel::XmlRpc::Serializer[number].should have_xpath('/double', :content => "1.23456")
+    end
+    
+    it "can serialize BigDecimal" do
+      number = BigDecimal.new '1.23456'
+      Rapuncel::XmlRpc::Serializer[number].should have_xpath('/double', :content => "1.23456")
+    end
+  end
+  
+  describe "Deserialization" do
+    it "can deserialize double" do
+      xml = <<-XML
+        <double>1.23456</double>
+      XML
+      number = Rapuncel::XmlRpc::Deserializer[xml]
+      number.should be_a Float
+      number.should == 1.23456
+    end
+    
+    it "can optionally deserialize all double to BigDecimal" do
+      Rapuncel::XmlRpc::Deserializer.double_as_bigdecimal = true
+      
+      xml = <<-XML
+        <double>1.23456</double>
+      XML
+      number = Rapuncel::XmlRpc::Deserializer[xml]
+      
+      number.should be_a BigDecimal
+      number.to_s("F").should == "1.23456"
+    end
+  end
+end

data/spec/unit/hash_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+require 'active_support/core_ext/hash/keys'
+
+describe Hash do
+  describe "Serialization" do
+    before do
+      @hash = {
+        :abc => 'one and two',
+        40 => %w(foo bar bee),
+        BigDecimal.new('1.23') => "abcd"
+      }
+      
+      @xml = Rapuncel::XmlRpc::Serializer[@hash]
+    end
+    
+    it 'preserves number of key-value pairs' do
+      @xml.should have_xpath('/struct/member', :count => 3)
+    end
+    
+    it 'projects all keys to plain strings' do
+      @xml.should have_xpath('/struct/member/name', :content => 'abc')
+      @xml.should have_xpath('/struct/member/name', :content => '40')
+      @xml.should have_xpath('/struct/member/name', :content => '1.23')
+    end
+  end
+  
+  describe "Deserialization" do
+    before do
+      @xml = <<-XML
+        <struct>
+        <member><name>abcd</name>
+        <value><int>123></int></value></member>
+        <member><name>456</name>
+        <value><string>xyz</string></value></member>
+        </struct>
+      XML
+      
+      @hash = Rapuncel::XmlRpc::Deserializer[@xml]
+    end
+    
+    it 'preserves number of key-value pairs' do
+      @hash.length.should == 2
+    end
+    
+    it 'converts all keys to symbols' do
+      @hash.keys.should be_all{|key| Symbol === key}
+    end
+    
+    it 'casts values to their types' do
+      @hash[:abcd].should == 123
+      @hash[:'456'].should == 'xyz'
+    end
+  end
+end

data/spec/unit/int_spec.rb

@@ -0,0 +1,23 @@
+require 'spec_helper'
+
+describe Integer do
+  it "serialization" do
+    Rapuncel::XmlRpc::Serializer[123].should have_xpath('/int', :content => "123")
+  end
+  
+  it "deserialization of int" do
+    xml = <<-XML
+      <int>123</int>
+    XML
+    
+    Rapuncel::XmlRpc::Deserializer[xml].should == 123
+  end
+  
+  it 'deserialization of i4' do
+    xml = <<-XML
+      <i4>123</i4>
+    XML
+    
+    Rapuncel::XmlRpc::Deserializer[xml].should == 123
+  end
+end

data/spec/unit/nil_spec.rb

@@ -0,0 +1,7 @@
+require 'spec_helper'
+
+describe NilClass do
+  it 'serializes like false' do
+    Rapuncel::XmlRpc::Serializer[nil].should have_xpath('/boolean', :content => '0')
+  end
+end

data/spec/unit/object_spec.rb

@@ -0,0 +1,45 @@
+require 'spec_helper'
+
+describe Object do
+  class TestObject
+    attr_accessor :a, :b, :c
+  end
+  
+  class TestObjectWithOwnBehavior < TestObject
+    def to_xmlrpc serializer
+      serializer.builder.string "custom thing"
+    end
+  end
+  
+  describe "Serialization of an arbitrary Object" do
+    it "serializes all instance variables like a hash" do
+      obj = TestObject.new
+      obj.a = "one"
+      obj.b = "two"
+      
+      xml = Rapuncel::XmlRpc::Serializer[obj]
+      xml.should have_xpath('/struct/member', :count => 2)
+      
+      reparsed_object = Rapuncel::XmlRpc::Deserializer[xml]
+      reparsed_object.should == {
+        :a => 'one',
+        :b => 'two'
+      }
+    end
+    
+  end
+  
+  describe "Serialization of an Object with #to_xmlrpc" do
+    it "uses this method to serialize" do
+      obj = TestObjectWithOwnBehavior.new
+    
+      obj.a = 'one'
+    
+      xml = Rapuncel::XmlRpc::Serializer[obj]
+      xml.should have_xpath('/string')
+    
+      reparsed_object = Rapuncel::XmlRpc::Deserializer[xml]
+      reparsed_object.should == "custom thing"
+    end
+  end
+end

data/spec/unit/proxy_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe Rapuncel::Proxy do
+  before do
+    @client = mock "Rapuncel::Client"
+    @proxy =  Rapuncel::Proxy.new @client
+  end
+  
+  it "provides unproxied __ methods" do
+    @client.should_not_receive :call_to_ruby
+
+    @proxy.__inspect__
+    @proxy.__tap__ {}
+    @proxy.__freeze__
+    @proxy.__send__ :__inspect__
+  end
+  
+  it 'proxies inspect, freeze, tap' do
+    %w(inspect freeze tap).each do |method|
+      @client.should_receive(:call_to_ruby).with(method)
+      @proxy.__send__ method
+    end
+  end
+  
+  it 'proxies any method call' do
+    @client.should_receive(:call_to_ruby).with("abcd", 1, "foo")
+    @proxy.abcd 1, "foo"
+  end
+end

data/spec/unit/request_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+
+describe Rapuncel::Request do
+  describe "Serialization" do
+    before do
+      @request = Rapuncel::Request.new 'test_method', "one argument", "another"
+      @xml = Rapuncel::XmlRpc::Serializer[@request]
+    end
+  
+    it 'should be in xml version=1.0' do
+      @xml.should =~ /<\?xml version=['"]1.0['"]/
+    end
+  
+    it 'should contain a methodCall' do
+      @xml.should have_xpath('/methodCall', :count => 1)
+    end
+  
+    it 'should contain the method name' do
+      @xml.should have_xpath('/methodCall/methodName', :content => "test_method")
+    end
+  
+    it 'should contain the method arguments in correct order' do
+      @xml.should have_xpath('/methodCall/params/param[1]/value/string', :content => "one argument")
+      @xml.should have_xpath('/methodCall/params/param[2]/value/string', :content => "another")
+    end
+  end
+end

data/spec/unit/response_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe Rapuncel::Response do
+  class HttpResponse
+    attr_accessor :body, :code
+
+    def initialize body, success = true, code = 200
+      @body, @success, @code = body, success, code
+    end
+
+    def success?
+      @success
+    end
+  end
+  
+  it 'parses successful response' do
+    successful_response = HttpResponse.new <<-XML
+      <?xml version='1.0'?>
+      <methodResponse>
+        <params>
+          <param>
+            <value>
+              <string>foo foo foo</string>
+            </value>
+          </param>
+        </params>
+      </methodResponse>
+    XML
+    
+    response = Rapuncel::Response.new successful_response, Rapuncel::XmlRpc::Deserializer
+    response.should be_success
+    
+    response.result.should == "foo foo foo"
+  end
+  
+  it 'parses fault response' do
+    fault_response = HttpResponse.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
+    
+    response = Rapuncel::Response.new fault_response, Rapuncel::XmlRpc::Deserializer
+    response.should be_fault
+    
+    response.to_ruby.should be_a Hash
+    response.to_ruby[:faultCode].should == 42
+  end
+  
+  it 'should handle errors' do
+    error_response = HttpResponse.new "Not Found", false, 404
+    
+    response = Rapuncel::Response.new error_response, Rapuncel::XmlRpc::Deserializer
+    response.should be_error
+    
+    response.to_ruby.should be_a Hash
+    response.to_ruby[:http_code].should == 404
+  end
+end

data/spec/unit/string_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+describe String, Symbol do
+  it 'serialization of a String' do
+    string = "foobar"
+    xml = Rapuncel::XmlRpc::Serializer[string]
+    xml.should have_xpath('/string', :content => "foobar")
+  end
+  
+  it 'serialization of a Symbol' do
+    symbol = :foobar
+    xml = Rapuncel::XmlRpc::Serializer[symbol]
+    xml.should have_xpath('/string', :content => "foobar")
+  end
+  
+  it 'preservation of trailing an leading whitespaces' do
+    string = "\n\t  abcd\n  \t"
+    xml = Rapuncel::XmlRpc::Serializer[string]
+    xml.should have_xpath('/string', :content => "\n\t  abcd\n  \t")
+  end
+  
+  it 'deserialization of a String' do
+    xml = <<-XML
+      <string>abcd\nefgh  \n\t</string>
+    XML
+    string = Rapuncel::XmlRpc::Deserializer[xml]
+    string.should == "abcd\nefgh  \n\t"
+  end
+  
+  it 'normalization of linebreaks' do
+    string = "one\r\ntwo\rthree\nfour"
+    string2 = Rapuncel::XmlRpc::Deserializer[Rapuncel::XmlRpc::Serializer[string]]
+    string2.should == "one\ntwo\nthree\nfour"
+  end
+end

data/spec/unit/time_spec.rb

@@ -0,0 +1,20 @@
+require 'spec_helper'
+
+describe Time do
+  it 'serialization' do
+    time = Time.now
+    xml = Rapuncel::XmlRpc::Serializer[time]
+    xml.should have_xpath('/dateTime.iso8601', :content => time.iso8601)
+  end
+  
+  it 'deserialization' do
+    time = Time.now
+    xml = <<-XML
+      <dateTime.iso8601>#{time.iso8601}</dateTime.iso8601>
+    XML
+    
+    parsed_time = Rapuncel::XmlRpc::Deserializer[xml]
+    parsed_time.should be_a Time
+    parsed_time.to_i.should == time.to_i
+  end
+end

metadata

@@ -0,0 +1,140 @@
+--- !ruby/object:Gem::Specification
+name: socialcast-rapuncel
+version: !ruby/object:Gem::Version
+  version: 0.0.7.RC1
+  prerelease: 6
+platform: ruby
+authors:
+- Michael Eickenberg
+- Marian Theisen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-09-13 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &2159869340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2159869340
+- !ruby/object:Gem::Dependency
+  name: activesupport
+  requirement: &2159868840 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2159868840
+- !ruby/object:Gem::Dependency
+  name: cookiejar
+  requirement: &2159868340 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: 0.3.0
+  type: :runtime
+  prerelease: false
+  version_requirements: *2159868340
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2159867880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 2.6.0
+  type: :development
+  prerelease: false
+  version_requirements: *2159867880
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2159867500 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2159867500
+description: Rapuncel is a simple XML-RPC Client based on Nokogiri, thus provides
+  a fast and easy way to interact with XML-RPC services.
+email: marian@cice-online.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Gemfile
+- Gemfile.lock
+- lib/rapuncel/adapters/curb_adapter.rb
+- lib/rapuncel/adapters/net_http_adapter.rb
+- lib/rapuncel/base_64_string.rb
+- lib/rapuncel/client/logging.rb
+- lib/rapuncel/client.rb
+- lib/rapuncel/connection.rb
+- lib/rapuncel/proxy.rb
+- lib/rapuncel/request.rb
+- lib/rapuncel/response.rb
+- lib/rapuncel/xml_rpc/deserializer.rb
+- lib/rapuncel/xml_rpc/serializer.rb
+- lib/rapuncel.rb
+- MIT-LICENSE
+- Rakefile
+- rapuncel-0.0.6.RC3.gem
+- rapuncel.gemspec
+- README.md
+- socialcast-rapuncel-0.0.7.RC1.gem
+- spec/functional/client_spec.rb
+- spec/spec_helper.rb
+- spec/test_server.rb
+- spec/unit/array_spec.rb
+- spec/unit/base64_spec.rb
+- spec/unit/boolean_spec.rb
+- spec/unit/client_spec.rb
+- spec/unit/connection_spec.rb
+- spec/unit/custom_serialization_spec.rb
+- spec/unit/float_spec.rb
+- spec/unit/hash_spec.rb
+- spec/unit/int_spec.rb
+- spec/unit/nil_spec.rb
+- spec/unit/object_spec.rb
+- spec/unit/proxy_spec.rb
+- spec/unit/request_spec.rb
+- spec/unit/response_spec.rb
+- spec/unit/string_spec.rb
+- spec/unit/time_spec.rb
+homepage: http://github.com/cice/rapuncel
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>'
+    - !ruby/object:Gem::Version
+      version: 1.3.1
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Simple XML-RPC Client
+test_files: []