Roman2K-web-service 0.1.1

data/lib/web_service/site.rb

@@ -0,0 +1,40 @@
+module WebService
+  class Site
+    def initialize(url)
+      @url = URI(url)
+    end
+    
+    # Returns a URI.
+    def url(options={})
+      @url
+    end
+    
+    def credentials
+      [url.user, url.password] if url.user
+    end
+
+    # Returns a String.
+    def url_for(path, options={})
+      url_to_path = url(options)
+      url_to_path.path = path
+      return url_to_path.to_s
+    end
+  
+    def root
+      url_for '/'
+    end
+    
+    # This class is supposed to be used within a Rails app.
+    class Switch < Site
+      def initialize(public, local)
+        @public, @local = URI.parse(public), URI.parse(local)
+      end
+      
+      def url(options={})
+        url = (Rails.env.production? || options[:public] ? @public : @local).dup
+        url.port = @local.port if options[:public] && !Rails.env.production?
+        return url
+      end
+    end
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,59 @@
+require 'test/unit'
+require 'mocha'
+require 'test_unit_ext'
+
+require 'net/http'
+Net::HTTP.class_eval do
+  undef :start if method_defined? :start
+end
+
+require 'web_service'
+WebService::Resource.site = WebService::Site.new("http://example.com")
+WebService.logger = Logger.new(STDERR)
+WebService.logger.level = Logger::ERROR
+
+class Foo < WebService::Resource
+  has_many :bars
+  has_one  :bar
+  has_one  :details
+end
+class Bar < WebService::Resource
+  belongs_to :foo
+end
+class Details < WebService::Resource
+end
+
+Test::Unit::TestCase.class_eval do
+  include TestUnitExt
+  
+  def expect_request(resource_or_collection, method, path, details)
+    connection  = stub
+    response    = Net::HTTPResponse::CODE_TO_OBJ[details[:return][:status].to_s].new(*[stub_everything] * 3)
+    body        = nil
+    
+    collection =
+      case resource_or_collection
+      when WebService::RemoteCollection
+        resource_or_collection
+      else
+        resource_or_collection.ieval { remote_collection }
+      end
+    
+    collection.
+      stubs(:open_http_connection_to).
+      yields(connection).
+      returns(response)
+    
+    connection.expects(:request).with { |req, body|
+      assert_equal(method.to_s.upcase, req.method)
+      assert_equal(path, req.path)
+      assert_equal(details[:body], ActiveSupport::JSON.decode(body || "null"))
+      true
+    }.returns(response)
+    
+    response.metaclass.instance_eval do
+      define_method(:code) { details[:return][:status].to_s }
+      define_method(:data) { details[:return][:body] }
+    end
+  end
+end

data/test/web_service/attribute_accessors_test.rb

@@ -0,0 +1,236 @@
+require 'test_helper'
+
+class WebService::AttributeAccessorsTest < Test::Unit::TestCase
+  class Resource
+    def self.element_name() "resource" end
+    include WebService::AttributeAccessors
+  end
+  
+  def setup
+    @res = Resource.new(:foo => :bar, :baz => nil, :void => " ")
+  end
+  
+  def test_attributes
+    res = Resource.new(:foo => :bar, "baz" => :foo)
+    
+    assert_equal({"foo" => :bar, "baz" => :foo}, res.attributes)
+    
+    hash = res.attributes
+    hash[:hijack] = :value
+    assert !res.respond_to?(:hijack)
+  end
+  
+  def test_attributes=
+    res = Resource.new(:foo => :bar)
+    res.attributes = {:bar => :foo}
+    assert !res.respond_to?(:foo)
+    assert_equal :foo, res.bar
+    
+    # ID is set first
+    res = Resource.new
+    class << res
+      def assigned()  @assigned ||= []  end
+      def id=(id)     assigned << :id   end
+      def foo=(foo)   assigned << :foo  end
+      def bar=(bar)   assigned << :bar  end
+    end
+    # a) Symbol
+    res.assigned.clear
+    res.attributes = {:bar => :foo, :id => 1, :foo => :bar}
+    assert_equal [:bar, :foo, :id], res.assigned.sort_by(&:to_s)
+    # b) String
+    res.assigned.clear
+    res.attributes = {:bar => :foo, "id" => 1, :foo => :bar}
+    assert_equal [:bar, :foo, :id], res.assigned.sort_by(&:to_s)
+  end
+  
+  def test_methods
+    res = Resource.new(:foo => :bar)
+    
+    if RUBY_VERSION < '1.9'
+      assert_equal ["foo", "foo=", "foo?"], res.methods - Resource.instance_methods
+    else
+      assert_equal [:foo, :foo=, :foo?], res.methods - Resource.instance_methods
+    end
+  end
+  
+  def test_respond_to
+    res = Resource.new(:foo => :bar)
+    
+    # Still responds to regular methods
+    assert_respond_to(res, :object_id)
+
+    # Respond to attribute accessor methods
+    assert_respond_to(res, :foo)
+    assert_respond_to(res, :foo=)
+    assert_respond_to(res, :foo?)
+    
+    # Doesn't respond to other methods
+    assert !res.respond_to?(:bar)
+  end
+  
+  def test_querying
+    assert @res.foo?    # present
+    assert !@res.baz?   # blank
+    assert !@res.void?  # blank
+    
+    # wrong number of arguments
+    assert_raise ArgumentError do
+      @res.foo?(:extra)
+    end
+    
+    # inexistent
+    assert_raise NoMethodError do
+      @res.bar?
+    end
+  end
+  
+  def test_readers
+    assert_equal :bar, @res.foo
+    assert_equal nil,  @res.baz
+    assert_raise NoMethodError do
+      @res.unknown_attribute
+    end
+    
+    # wrong number of arguments
+    assert_raise ArgumentError do
+      @res.foo("a")
+    end
+    
+    @res.write_attribute("bool?", :value)
+    assert_equal :value, @res.bool?
+  end
+  
+  def test_writers
+    res = Resource.new
+    
+    # first value
+    res.foo = :bar
+    assert_equal(:bar, res.foo)
+    assert_equal({"foo" => :bar}, res.attributes)
+    
+    # reset to nil...
+    res.foo = nil
+    assert_equal(nil, res.foo)
+    assert_equal({"foo" => nil}, res.attributes)
+    
+    # ...and back to a value
+    res.foo = :bar
+    assert_equal(:bar, res.foo)
+    assert_equal({"foo" => :bar}, res.attributes)
+    
+    # second value
+    res.foo = :foo
+    assert_equal(:foo, res.foo)
+    assert_equal({"foo" => :foo}, res.attributes)
+    
+    # wrong number of arguments
+    assert_raise ArgumentError do
+      res.send(:foo=, "a", "b")
+    end
+    
+    # first value is nil
+    res = Resource.new
+    res.nothing = nil
+    assert_equal(nil, res.nothing)
+    assert_equal({"nothing" => nil}, res.attributes)
+  end
+  
+  ##########################
+  #  Association accessors
+  ##########################
+
+  Object.class_eval %q{
+    class NotResource
+    end
+  }
+  
+  def test_association_querying
+    bar = Bar.new
+    
+    assert !bar.respond_to?(:foo?)
+    
+    bar.foo = Foo.new('id' => 1)
+    assert bar.foo?
+    assert bar.foo_id?
+    
+    bar.foo = nil
+    assert !bar.foo?
+    assert !bar.foo_id?
+  end
+  
+  def test_association_writers
+    bar = Resource.new
+    
+    bar.foo = nil
+    bar.foo = {"id" => 1}
+    assert_equal Foo.new('id' => 1), bar.foo
+    assert_equal 1, bar.foo_id
+    
+    bar.foo = nil
+    bar.foo = {"foo" => {"id" => 1}}
+    assert_equal Foo.new('id' => 1), bar.foo
+    assert_equal 1, bar.foo_id
+    
+    bar.foo = nil
+    bar.foo = {"bar" => {"id" => 1}}
+    assert_equal Bar.new('id' => 1), bar.foo
+    assert_equal 1, bar.foo_id
+    
+    bar.foo = nil
+    bar.foo = [{"bar" => {"id" => 1}}, 'other-value']
+    assert_equal [Bar.new('id' => 1), 'other-value'], bar.foo
+    assert_equal nil, bar.foo_id
+    
+    bar.foo = {"id" => 1}
+    bar.foo = nil
+    assert_equal nil, bar.foo
+    assert_equal nil, bar.foo_id
+    
+    bar.foo = {"id" => 1}
+    bar.foo_id = nil
+    assert_equal nil, bar.foo
+    assert_equal nil, bar.foo_id
+    
+    bar.foo = {"id" => 1}
+    bar.foo_id = 1
+    Foo.stubs(:find).with(1).returns("reset").once
+    assert_equal "reset", bar.foo
+    assert_equal 1, bar.foo_id
+    
+    foo = Foo.new('id' => 2)
+    bar.foo = foo
+    assert_equal foo.object_id, bar.foo.object_id
+    assert_equal 2, bar.foo_id
+    
+    bar.foo = nil
+    assert_raise WebService::ResourceNotSaved do
+      bar.foo = Foo.new('id' => nil)
+    end
+    assert_equal nil, bar.foo
+    
+    bar.foo = Foo.new('id' => 2)
+    bar.foo_id = 3
+    Foo.expects(:find).with(3).returns("fetched").once
+    assert_equal "fetched", bar.foo
+    assert_equal "fetched", bar.foo
+    
+    bar.not_resource = {"id" => 4}
+    assert_equal({"id" => 4}, bar.not_resource)
+    
+    bar.noclass_id = 5
+    assert_raise NameError, "uninitialized constant Noclass" do
+      bar.noclass
+    end
+    
+    bar.not_resource_id = 6
+    expected_message = "class NotResource found for association `not_resource' is not a resource class"
+    assert_raise WebService::NotResourceClass, expected_message do
+      bar.not_resource
+    end
+    
+    not_resource = NotResource.new
+    bar.attributes = {:not_resource => not_resource}
+    assert_equal not_resource, bar.not_resource
+  end
+end

data/test/web_service/core_ext_test.rb

@@ -0,0 +1,13 @@
+require "test_helper"
+
+class CoreExtTest < Test::Unit::TestCase
+  def test_uri_obfuscate
+    assert_equal "http://example.com", URI("http://example.com").obfuscate.to_s
+    assert_equal "http://***@example.com", URI("http://foo@example.com").obfuscate.to_s
+    assert_equal "http://***:***@example.com", URI("http://foo:secret@example.com").obfuscate.to_s
+  end
+  
+  def test_cgi_escape
+    assert_equal "example%2ecom", CGI.escape("example.com")
+  end
+end

data/test/web_service/crud_operations_test.rb

@@ -0,0 +1,61 @@
+require "test_helper"
+
+class WebService::CRUDOperationsTest < Test::Unit::TestCase
+  def test_all
+    will_return = expect_request_for_foos_index_with_param_bar_equals_baz
+    foos = Foo.all(:bar => :baz)
+    assert_equal will_return, foos
+  end
+  
+  def test_cache
+    collection = Foo.new('id' => 1).bars
+    
+    collection.cache = [{'id' => 1}, {'bar' => {'id' => 2}}, Bar.new('id' => 3)]
+    expected = [Bar.new('id' => 1), Bar.new('id' => 2), Bar.new('id' => 3)]
+    assert_equal expected, collection.all
+    
+    collection.flush_cache
+    expect_request collection,
+      :get, "/foos/1/bars", :return => {:status => "200", :body => []}
+    assert_equal [], collection.all
+  end
+  
+  def test_first
+    will_return = expect_request_for_foos_index_with_param_bar_equals_baz
+    assert_equal will_return.first, Foo.first(:bar => :baz)
+  end
+  
+  def test_last
+    will_return = expect_request_for_foos_index_with_param_bar_equals_baz
+    assert_equal will_return.last, Foo.last(:bar => :baz)
+  end
+  
+  def test_find
+    expect_request Foo,
+      :get, "/foos/1?bar=baz",
+      :return => {:status => "200", :body => {"foo" => {"id" => 1}}}
+    assert_equal Foo.new('id' => 1), Foo.find(1, :bar => :baz)
+    
+    expect_request Foo,
+      :get, "/foos/1", :return => {:status => "404"}
+    assert_raise WebService::ResourceNotFound do
+      Foo.find(1)
+    end
+  end
+  
+  def test_build
+    type_foo = Class.new(Foo)
+    def type_foo.implicit_attributes; {:a => :b, :c => :d} end
+    foo = type_foo.build("a" => :overridden, "e" => "f")
+    assert_equal({"a" => :overridden, "c" => :d, "e" => "f"}, foo.attributes)
+  end
+  
+private
+
+  def expect_request_for_foos_index_with_param_bar_equals_baz
+    expect_request Foo,
+      :get, "/foos?bar=baz",
+      :return => {:status => "200", :body => [{"foo" => {"id" => 1}}, {"foo" => {"id" => 2}}]}
+    [Foo.new("id" => 1), Foo.new("id" => 2)]
+  end
+end

data/test/web_service/named_request_methods_test.rb

@@ -0,0 +1,34 @@
+require "test_helper"
+
+class WebService::NamedRequestMethodsTest < Test::Unit::TestCase
+  def test_collection_actions
+    expect_request Foo,
+      :get, "/foos/bar",
+      :return => {:status => "200", :body => "bar"}
+    assert_equal "bar", Foo.get(:bar)
+    
+    expect_request Foo,
+      :get, "/foos/bar?a=b",
+      :return => {:status => "200", :body => "bar"}
+    assert_equal "bar", Foo.get(:bar, :a => :b)
+    
+    expect_request Foo,
+      :put, "/foos/bar",
+      :return => {:status => "200", :body => "bar"}
+    assert_equal "bar", Foo.put(:bar)
+  end
+  
+  def test_member_actions
+    foo = Foo.new("id" => 1)
+    
+    expect_request foo,
+      :put, "/foos/1/bar",
+      :return => {:status => "200", :body => "bar"}
+    assert_equal "bar", foo.put(:bar)
+    
+    expect_request foo,
+      :put, "/foos/1/bar",
+      :return => {:status => "200", :body => "bar"}
+    assert_equal "bar", foo.put("/bar")
+  end
+end