Roman2K-web-service 0.1.1

data/test/web_service/remote_collection_test.rb

@@ -0,0 +1,114 @@
+require 'test_helper'
+
+class WebService::RemoteCollectionTest < Test::Unit::TestCase
+  def setup
+    @resource_details = Object.new
+    @collection = WebService::RemoteCollection.new(@resource_details)
+  end
+  
+  def res
+    @resource_details
+  end
+  
+# private
+
+  def test_build_url_for
+    build = lambda { |*args| @collection.ieval { build_url_for(*args) } }
+    
+    def res.site; WebService::Site.new("http://example.com") end
+    def res.singleton; false end
+    def res.element_name; "foo" end
+    
+    # Collection
+    assert_equal "/foos", build[nil, nil].path
+    
+    # Member
+    assert_equal "/foos/1", build[1, nil].path
+    
+    # Member (escaped)
+    assert_equal "/foos/example%2ecom", build["example.com", nil].path
+    
+    # Member action
+    assert_equal "/foos/1/action", build[1, :action].path
+    
+    # Singleton
+    def res.singleton; true end
+    assert_equal "/foo", build[nil, nil].path
+    
+    # Non-singleton
+    assert_raise ArgumentError, "singleton resources do not require an ID parameter" do
+      build[1, nil]
+    end
+    def res.singleton; false end
+    
+    # Nested collection
+    url = @collection.with_nesting([["bar", 1]]).ieval { build_url_for(nil, nil) }
+    assert_equal "/bars/1/foos", url.path
+    
+    # Nested collection missing the ID for the association
+    assert_raise RuntimeError, "attribute `bar_id' is missing" do
+      @collection.with_nesting([["bar", nil]]).ieval { build_url_for(nil, nil) }
+    end
+  end
+
+# private # utilities
+
+  def test_recognize
+    # Single pattern
+    hash, string, symbol = @collection.instance_eval { recognize([Hash, /^a/, Symbol], "abc", {:options => true}) }
+    assert_equal({:options => true}, hash)
+    assert_equal("abc", string)
+    assert_equal(nil, symbol)
+    
+    # Multiple patterns
+    symbol, integer = @collection.instance_eval { recognize([Symbol, [/^\d+$/, Integer]], 3, :other) }
+    assert_equal 3, integer
+    assert_equal :other, symbol
+    
+    symbol, integer = @collection.instance_eval { recognize([Symbol, [/^\d+$/, Integer]], "3", :other) }
+    assert_equal "3", integer
+    assert_equal :other, symbol
+  end
+end
+
+class WebService::RemoteCollection::ResponseDataUnserializationTest < Test::Unit::TestCase
+  class Response < Struct.new(:content_type, :body, :parse_count)
+    include WebService::RemoteCollection::ResponseDataUnserialization
+    
+    def parse_data
+      self.parse_count ||= 0
+      self.parse_count += 1
+      super
+    end
+  end
+  
+  def test_data
+    #################
+    #  Blank => nil
+    #################
+    response = Response.new
+    response.body = " "
+    assert_equal(nil, response.data)
+    
+    # Cache even nil
+    response.data
+    response.data
+    assert_equal(1, response.parse_count)
+    
+    #########
+    #  JSON
+    #########
+    response = Response.new
+    response.content_type = "application/json"
+    response.body = "{}"
+    assert_equal({}, response.data)
+    
+    #########
+    #  XML
+    #########
+    response = Response.new
+    response.content_type = "application/xml"
+    response.body = "<entries type='array'></entries>"
+    assert_equal({'entries' => []}, response.data)
+  end
+end

data/test/web_service/resource_test.rb

@@ -0,0 +1,200 @@
+require 'test_helper'
+
+class WebService::ResourceTest < Test::Unit::TestCase
+  @@anonymous = Class.new(WebService::Resource)
+  @@anonymous_with_named_parent = Class.new(Foo)
+  
+# class
+
+  def test_element_name
+    # Anonymous class
+    assert_raise NameError do
+      @@anonymous.instance_eval { element_name }
+    end
+
+    # Named class
+    assert_equal "foo", Foo.instance_eval { element_name }
+
+    # Anonymous class with named parent
+    assert_equal "foo", @@anonymous_with_named_parent.instance_eval { element_name }
+
+    # Anonymous class with explicit element name
+    anonymous = Class.new(WebService::Resource)
+    anonymous.element_name = "bar"
+    assert_equal "bar", anonymous.element_name
+  end
+  
+  def test_belongs_to
+    # Saving
+    bar = Bar.new("foo" => Foo.new("id" => 1), "a" => "b")
+    
+    expect_request bar,
+      :post, "/foos/1/bars", :body => {"bar" => {"foo_id" => 1, "a" => "b"}},
+      :return => {:status => "201", :body => {"bar" => {"c" => "d"}}}
+    
+    bar.save
+    assert_equal({"c" => "d"}, bar.attributes)
+    
+    # Fetching
+    expect_request Bar, :get, "/bars", :return => {:status => "200", :body => []}
+    Bar.all
+  end
+  
+  def test_has_many
+    foo = Foo.new("id" => 1)
+    
+    expect_creation_on = lambda do |collection|
+      expect_request collection,
+        :post, "/foos/1/bars", :body => {"bar" => {"foo_id" => 1, "a" => "b"}},
+        :return => {:status => "201", :body => {"bar" => {"c" => "d"}}}
+    end
+    
+    # Instantiation
+    bar = foo.bars.build("a" => "b")
+    assert_equal({"foo_id" => 1, "a" => "b"}, bar.attributes)
+    
+    # Fetching
+    expect_request foo.bars,
+      :get, "/foos/1/bars",
+      :return => {:status => "200", :body => []}
+    foo.bars.all
+    
+    # Creation (bars.create)
+    expect_creation_on[foo.bars]
+    foo.bars.create("a" => "b")
+    
+    # Creation (bars.build.save)
+    bar = foo.bars.build "a" => "b"
+    expect_creation_on[bar]
+    bar.save
+    
+    # Arbitrary actions
+    expect_request foo.bars,
+      :delete, "/foos/1/bars/99",
+      :return => {:status => "200"}
+    foo.bars.delete(99)
+  end
+  
+  def test_has_many=
+    foo = Foo.new("id" => 1)
+    foo.bars.expects(:cache=).with("collection")
+    foo.bars = "collection"
+  end
+  
+  def test_has_one
+    # Fetching
+    foo = Foo.new("id" => 1)
+    expect_request foo.instance_eval { association_collection_from_name(:bar, :singleton => true) },
+      :get, "/foos/1/bar",
+      :return => {:status => "200", :body => {"bar" => {"a" => "b"}}}
+    assert_equal Bar.new("a" => "b"), foo.bar
+    
+    # Building + saving = creating
+    foo = Foo.new("id" => 1)
+    bar = foo.build_bar("a" => "b")
+    expect_request bar,
+      :post, "/foos/1/bar", :body => {"bar" => {"foo_id" => 1, "a" => "b"}},
+      :return => {:status => "201", :body => {"bar" => {"c" => "d"}}}
+    assert_equal Bar.new("c" => "d"), bar.save
+    
+    # Plural-form resource class name
+    foo = Foo.new("id" => 1)
+    expect_request foo.instance_eval { association_collection_from_name(:details, :singleton => true) },
+      :get, "/foos/1/details",
+      :return => {:status => "200", :body => {"details" => {"a" => "b"}}}
+    assert_equal Details.new("a" => "b"), foo.details
+    
+    # Constant name resolution
+    assert_raise NameError, /uninitialized constant Things\b/ do
+      Class.new(Foo) { has_one :things }.new.things
+    end
+  end
+  
+# public
+  
+  def test_to_hash
+    res = WebService::Resource.new(:foo => :bar)
+    assert_equal res.attributes, res.to_hash
+  end
+  
+  def test_to_s
+    assert_equal "Foo(new)",  Foo.new.to_s
+    assert_equal "Foo[1]",    Foo.new('id' => 1).to_s
+  end
+  
+  def test_inspect
+    assert_equal "#<Foo(new)>", Foo.new.inspect
+    assert_equal "#<Foo[1]>",   Foo.new('id' => 1).inspect
+    assert_equal "#<Foo[1] bar=2.0 baz=\"abcdefghijklmnopqrstuv...\">", Foo.new('id' => 1, 'bar' => 2.0, 'baz' => Array('a'..'z').join).inspect
+    
+    # with custom to_s
+    foo = Foo.new
+    def foo.to_s; "custom" end
+    assert_equal "#<Foo(new)>", foo.inspect
+  end
+  
+  def test_save
+    #############
+    #  Creation
+    #############
+    foo = Foo.new("a" => "b")
+    
+    expect_request foo,
+      :post, "/foos", :body => {"foo" => {"a" => "b"}},
+      :return => {:status => '201', :body => {"foo" => {"c" => "d"}}}
+    
+    foo.save
+    assert_equal({"c" => "d"}, foo.attributes)
+    
+    # Accepted
+    foo = Foo.new("a" => "b")
+    expect_request foo,
+      :post, "/foos", :body => {"foo" => {"a" => "b"}},
+      :return => {:status => '202', :body => " "}
+    foo.save
+    assert_equal({"a" => "b"}, foo.attributes)
+    
+    ###########
+    #  Update
+    ###########
+    foo = Foo.new("id" => 1, "a" => "b")
+    
+    expect_request foo,
+      :put, "/foos/1", :body => {"foo" => {"id" => 1, "a" => "b"}},
+      :return => {:status => "200", :body => {"foo" => {"c" => "d"}}}
+    
+    foo.save
+    assert_equal({"c" => "d"}, foo.attributes)
+    
+    ##############
+    #  Singleton
+    ##############
+    type_foo = Class.new(Foo) { self.singleton = true }
+    
+    # Creation
+    foo = type_foo.new
+    expect_request foo,
+      :post, "/foo", :body => {"foo" => {}},
+      :return => {:status => "201", :body => {"foo" => {}}}
+    foo.save
+    
+    # Update
+    foo = type_foo.new("id" => 1)
+    expect_request foo,
+      :put, "/foo", :body => {"foo" => {"id" => 1}},
+      :return => {:status => "200", :body => {"foo" => {}}}
+    foo.save
+  end
+  
+  def test_reload
+    foo = Foo.new("id" => 1, "a" => "b")
+    expect_request foo,
+      :get, "/foos/1",
+      :return => {:status => 200, :body => {"foo" => {"id" => 1, "b" => "c"}}}
+    
+    result = foo.reload
+    
+    assert_equal Foo.new("id" => 1, "b" => "c"), foo
+    assert_equal foo.object_id, result.object_id
+  end
+end

data/test/web_service/response_handling_test.rb

@@ -0,0 +1,66 @@
+require 'test_helper'
+
+class WebService::ResponseHandlingTest < Test::Unit::TestCase
+  M = WebService::ResponseHandling
+  
+  def test_connection_error_message
+    error_type = M::ConnectionError
+    
+    # Can't use stub since stub(:method => :result) doesn't respond_to?(:method)
+    response = Object.new
+    def response.code; 400 end
+    
+    # Nil response / No custom message
+    err = error_type.new(nil)
+    assert_equal "Failed", err.to_s
+    
+    # Nil response + Custom message
+    err = error_type.new(nil, "message")
+    assert_equal "Failed: message", err.to_s
+    
+    # No response message / No custom message
+    err = error_type.new(response)
+    assert_equal "Failed with 400", err.to_s
+    
+    # Nil response message / No custom message
+    def response.message; nil end
+    err = error_type.new(response)
+    assert_equal "Failed with 400", err.to_s
+    
+    # Blank response message / No custom message
+    def response.message; "" end
+    err = error_type.new(response)
+    assert_equal "Failed with 400", err.to_s
+    
+    # Response message / No custom message
+    def response.message; "Bad Request" end
+    err = error_type.new(response)
+    assert_equal "Failed with 400 (Bad Request)", err.to_s
+    
+    # Response message + Custom message
+    err = error_type.new(response, "message")
+    assert_equal "Failed with 400 (Bad Request): message", err.to_s
+  end
+  
+# protected
+
+  def test_handle_response
+    handler = Object.new.extend M
+    
+    assert_raise_with_code = lambda do |code, exc|
+      response = stub(:code => code)
+      assert_raise(exc) do
+        handler.instance_eval { handle_response(response) }
+      end
+    end
+    
+    assert_raise_with_code[406, M::NotAcceptable]
+    assert_raise_with_code[502, M::BadGateway]
+    assert_raise_with_code[503, M::ServiceUnavailable]
+    assert_raise_with_code[504, M::GatewayTimeout]
+    
+    response = stub(:code => 200)
+    result = handler.instance_eval { handle_response(response) }
+    assert_equal response, response
+  end
+end

data/test/web_service/site_test.rb

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+class WebService::SiteTest < Test::Unit::TestCase
+  include WebService
+  
+  def setup
+    @site = Site.new("http://example")
+  end
+  
+  def test_url
+    assert_equal "http://example", @site.url().to_s
+    assert_equal "http://example", @site.url(:prefix => true).to_s
+  end
+  
+  def test_credentials
+    site = Site.new("http://example")
+    assert_equal nil, site.credentials
+    
+    site = Site.new("http://foo@example")
+    assert_equal ["foo", nil], site.credentials
+    
+    site = Site.new("http://foo:bar@example")
+    assert_equal ["foo", "bar"], site.credentials
+  end
+  
+  def test_url_for
+    assert_equal "http://example/foo", @site.url_for("/foo").to_s
+    
+    @site.expects(:url).with(:public => true).returns URI("http://public")
+    assert_equal "http://public/foo", @site.url_for("/foo", :public => true).to_s
+  end
+  
+  def test_root
+    assert_equal "http://example/", @site.root.to_s
+  end
+end
+
+module Rails
+  def self.env
+    @env ||= Object.new
+  end
+end
+
+class WebService::Site::SwitchTest < Test::Unit::TestCase
+  include WebService
+  
+  def setup
+    @site = Site::Switch.new("http://prod", "http://dev")
+  end
+  
+  def test_url
+    env = Rails.env
+    
+    def env.production?; true end
+    assert_equal "http://prod", @site.url.to_s
+    
+    def env.production?; false end
+    assert_equal "http://dev", @site.url.to_s
+    assert_equal "http://prod", @site.url(:public => true).to_s
+    assert_equal "http://dev", @site.url.to_s
+  end
+end

data/web-service.gemspec

@@ -0,0 +1,44 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{web-service}
+  s.version = "0.1.1"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 1.2") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Roman Le N\303\251grate"]
+  s.date = %q{2009-03-17}
+  s.description = %q{REST client; an alternative to ActiveResource}
+  s.email = %q{roman.lenegrate@gmail.com}
+  s.extra_rdoc_files = ["lib/web_service/attribute_accessors.rb", "lib/web_service/core_ext.rb", "lib/web_service/crud_operations.rb", "lib/web_service/named_request_methods.rb", "lib/web_service/remote_collection.rb", "lib/web_service/resource.rb", "lib/web_service/response_handling.rb", "lib/web_service/site.rb", "lib/web_service.rb", "LICENSE", "README.mdown"]
+  s.files = ["lib/web_service/attribute_accessors.rb", "lib/web_service/core_ext.rb", "lib/web_service/crud_operations.rb", "lib/web_service/named_request_methods.rb", "lib/web_service/remote_collection.rb", "lib/web_service/resource.rb", "lib/web_service/response_handling.rb", "lib/web_service/site.rb", "lib/web_service.rb", "LICENSE", "Manifest", "Rakefile", "README.mdown", "test/test_helper.rb", "test/web_service/attribute_accessors_test.rb", "test/web_service/core_ext_test.rb", "test/web_service/crud_operations_test.rb", "test/web_service/named_request_methods_test.rb", "test/web_service/remote_collection_test.rb", "test/web_service/resource_test.rb", "test/web_service/response_handling_test.rb", "test/web_service/site_test.rb", "web-service.gemspec"]
+  s.has_rdoc = true
+  s.homepage = %q{https://github.com/Roman2K/web-service}
+  s.rdoc_options = ["--main", "README.mdown", "--inline-source", "--line-numbers", "--charset", "UTF-8"]
+  s.require_paths = ["lib"]
+  s.rubyforge_project = %q{web-service}
+  s.rubygems_version = %q{1.3.1}
+  s.summary = %q{REST client; an alternative to ActiveResource}
+  s.test_files = ["test/test_helper.rb", "test/web_service/attribute_accessors_test.rb", "test/web_service/core_ext_test.rb", "test/web_service/crud_operations_test.rb", "test/web_service/named_request_methods_test.rb", "test/web_service/remote_collection_test.rb", "test/web_service/resource_test.rb", "test/web_service/response_handling_test.rb", "test/web_service/site_test.rb"]
+
+  if s.respond_to? :specification_version then
+    current_version = Gem::Specification::CURRENT_SPECIFICATION_VERSION
+    s.specification_version = 2
+
+    if Gem::Version.new(Gem::RubyGemsVersion) >= Gem::Version.new('1.2.0') then
+      s.add_runtime_dependency(%q<activesupport>, [">= 2.2.2"])
+      s.add_runtime_dependency(%q<class-inheritable-attributes>, [">= 0"])
+      s.add_development_dependency(%q<mocha>, [">= 0"])
+      s.add_development_dependency(%q<test-unit-ext>, [">= 0"])
+    else
+      s.add_dependency(%q<activesupport>, [">= 2.2.2"])
+      s.add_dependency(%q<class-inheritable-attributes>, [">= 0"])
+      s.add_dependency(%q<mocha>, [">= 0"])
+      s.add_dependency(%q<test-unit-ext>, [">= 0"])
+    end
+  else
+    s.add_dependency(%q<activesupport>, [">= 2.2.2"])
+    s.add_dependency(%q<class-inheritable-attributes>, [">= 0"])
+    s.add_dependency(%q<mocha>, [">= 0"])
+    s.add_dependency(%q<test-unit-ext>, [">= 0"])
+  end
+end