restful_serializer 0.1.3 → 0.1.4

data/spec/serializer_spec.rb

@@ -1,5 +1,8 @@
 require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
 
+# These routes are only required by some tests, but route generation issues crop
+# up depending on the order in which restful/* files are required.  The reasons
+# are mysterious, though they may have something to do with ActionController::UrlWriter
 ActionController::Routing::Routes.clear!
 ActionController::Routing::Routes.draw do |map|
   map.resources :foos
@@ -73,15 +76,15 @@ describe Restful::Serializer do
   end
 
   after(:each) do
-    Restful.api_prefix = nil
-    Restful.model_configuration = {}
+    Restful.clear
   end
 
-  it "should not interfere with resource route generation" do
+  def check_routing
     ActionController::Routing::Routes.routes.size.should == 30
     by_method = ActionController::Routing::Routes.routes.group_by { |r|
       r.conditions[:method]
     }
+#    ActionController::Routing::Routes.routes.each { |r| puts r }
     by_method[:get].size.should == 4 * 4
     by_method[:put].size.should == 4
     by_method[:post].size.should == 4
@@ -89,44 +92,68 @@ describe Restful::Serializer do
     by_method[nil].size.should == 2
   end
 
-  it "should require a subject" do
-    lambda { Restful::Serializer.new }.should raise_error(ArgumentError)
-    Restful::Serializer.new('foo').should be_kind_of(Restful::Serializer)
+  it "should not interfere with resource route generation" do
+    check_routing
   end
 
-  it "should set klass" do
-    rs = Restful::Serializer.new(@foo)
-    rs.klass.should == 'foo'
+  it "should not interfere with resource route generation if we configure webservices" do
+    Restful.register_web_service('test',
+      :resources => {
+        :foo => { :serialization => { :only => :id } },
+      }
+    )
+    check_routing
   end
 
-  it "should serialize" do
-    @foo.save!
-    rs = Restful::Serializer.new(@foo)
-    rs.serialize.should == {
-      'name' => @foo.name,
-      'foo' => { 
-        'id' => @foo.id,
+  describe "with an empty web service" do
+
+    before(:each) do
+      @empty_ws = Restful.register_web_service('empty')
+    end
+
+    it "should require a subject and a web service" do
+      lambda { Restful::Serializer.new }.should raise_error(ArgumentError)
+      lambda { Restful::Serializer.new('foo') }.should raise_error(ArgumentError)
+      Restful::Serializer.new('foo', @empty_ws).should be_kind_of(Restful::Serializer)
+    end
+  
+    it "should set klass" do
+      rs = Restful::Serializer.new(@foo, @empty_ws)
+      rs.klass.should == 'foo'
+    end
+  
+    it "should serialize" do
+      @foo.save!
+      rs = Restful::Serializer.new(@foo, @empty_ws)
+      rs.serialize.should == {
         'name' => @foo.name,
-      },
-      'href' => "http://test.org/foos/#{@foo.id}",
-    }
+        'foo' => { 
+          'id' => @foo.id,
+          'name' => @foo.name,
+        },
+        'href' => "http://test.org/foos/#{@foo.id}",
+      }
+    end
   end
 
   describe "with configuration options" do
 
     before(:each) do
-      Restful.api_prefix = 'prefix'
-      Restful.model_configuration = {
-        :foo => {
-          :name => :fancy_name,
-          :serialization => { :only => [:name], :methods => [:a_method] },
+      Restful.register_web_service('test',
+        :api_prefix => 'prefix',
+        :resources => {
+          :foo => {
+            :name_method => :fancy_name,
+            :serialization => { :only => [:name], :methods => [:a_method] },
+          }
         }
-      }
+      )
+      @test_ws = Restful.web_service_configuration('test')
       @foo.save!
     end
 
     it "should take options from configuration" do
-      rs = Restful::Serializer.new(@foo)
+      rs = Restful::Serializer.new(@foo, @test_ws)
       rs.serialize.should == {
         'name' => @foo.fancy_name,
         'foo' => { 
@@ -137,9 +164,9 @@ describe Restful::Serializer do
       }
     end
   
-    it "should override options during initialization" do
-      rs = Restful::Serializer.new(@foo, 
-        :name => :name, 
+    it "should merge options during initialization" do
+      rs = Restful::Serializer.new(@foo, @test_ws,
+        :name_method => :name, 
         :serialization => { :only => [:id] }, 
         :url_for => :custom_foo
       )
@@ -147,21 +174,23 @@ describe Restful::Serializer do
         'name' => @foo.name,
         'foo' => { 
           'id' => @foo.id,
+          'name' => @foo.name,
+          'a_method' => @foo.a_method,
         },
         'href' => "http://test.org/custom_foo/#{@foo.id}",
       }
     end
 
-    it "should deeply merge overridden options" do
-      rs = Restful::Serializer.new(@foo, 
-        :deep_merge => { :serialization => { :only => [:id] } }
-      )
+    it "should provide fine grained configuration" do
+      rs = Restful::Serializer.new(@foo, @test_ws) do |config|
+        config.url_for = nil
+        config.serialization.only = :id
+        config.serialization.methods.clear
+      end
       rs.serialize.should == {
         'name' => @foo.fancy_name,
         'foo' => { 
           'id' => @foo.id,
-          'name' => @foo.name,
-          'a_method' => @foo.a_method,
         },
         'href' => "http://test.org/prefix/foos/#{@foo.id}",
       }
@@ -171,19 +200,22 @@ describe Restful::Serializer do
   describe "with associations" do
 
     before(:each) do
-      Restful.model_configuration = {
-        :foo => {
-          :associations => :bars,
-        },
-        :bar => {
-          :associations => { :special => :foo, :dingos => nil },
-        },
-      }
+      Restful.register_web_service('test',
+        :resources => {
+          :foo => {
+            :associations => :bars,
+          },
+          :bar => {
+            :associations => { :special => :foo, :dingos => nil },
+          },
+        }
+      )
+      @test_ws = Restful.web_service_configuration('test')
       generate_instances
     end
 
     it "should include references to associations" do
-      rs = Restful::Serializer.new(@foo)
+      rs = Restful::Serializer.new(@foo, @test_ws)
       rs.serialize.should == {
         'name' => @foo.name,
         'foo' => { 
@@ -196,7 +228,7 @@ describe Restful::Serializer do
     end
 
     it "should handle multiple and nested associations" do
-      rs = Restful::Serializer.new(@bar1)
+      rs = Restful::Serializer.new(@bar1, @test_ws)
       rs.serialize.should == {
         'name' => @bar1.name,
         'bar' => { 
@@ -214,17 +246,20 @@ describe Restful::Serializer do
   describe "with subclasses" do
     
     before(:each) do
-      Restful.model_configuration = {
-        :thing => {
-          :serialization => { :except => :secret }
+      Restful.register_web_service('test',
+        :resources => {
+          :thing => {
+            :serialization => { :except => :secret }
+          }
         }
-      }
+      )
+      @test_ws = Restful.web_service_configuration('test')
       @thing = Thing.create!(:name => 'a thing', :secret => 'a secret')
       @sub = Sub.create!(:name => 'a sub thing', :secret => 'another secret')
     end
 
     it "should pull superclass configuration up into a subclass serialization" do
-      rs = Restful::Serializer.new(@sub)
+      rs = Restful::Serializer.new(@sub, @test_ws)
       rs.serialize.should == {
         'name' => @sub.name,
         'href' => "http://test.org/things/#{@sub.id}",
@@ -238,20 +273,23 @@ describe Restful::Serializer do
 
   describe "with arrays" do
     before(:each) do
-      Restful.model_configuration = {
-        :foo => {
-          :associations => :bars,
-        },
-        :bar => {
-          :serialization => { :only => [:name], :include => { :dingos => { :only =>  [ :name, :id] } } },
-          :associations => [:foo, :dingos],
-        },
-      }
+      Restful.register_web_service('test',
+        :resources => {
+          :foo => {
+            :associations => :bars,
+          },
+          :bar => {
+            :serialization => { :only => [:name], :include => { :dingos => { :only =>  [ :name, :id] } } },
+            :associations => [:foo, :dingos],
+          },
+        }
+      )
+      @test_ws = Restful.web_service_configuration('test')
       generate_instances
     end
 
     it "should serialize arrays" do
-      rs = Restful::Serializer.new(@foo.bars)
+      rs = Restful::Serializer.new(@foo.bars, @test_ws)
       rs.serialize.should == [
         {
           'name' => @bar1.name,
@@ -271,7 +309,7 @@ describe Restful::Serializer do
     end
 
     it "should deeply serialize arrays if told to" do
-      rs = Restful::Serializer.new(@foo.bars, :shallow => false)
+      rs = Restful::Serializer.new(@foo.bars, @test_ws, :shallow => false)
       rs.serialize.should == [
         {
           'name' => @bar1.name,
@@ -302,8 +340,8 @@ describe Restful::Serializer do
       ] 
     end
 
-    it "should override options during initialization for each member" do
-      rs = Restful::Serializer.new(@foo.bars, 
+    it "should merge options during initialization for each member" do
+      rs = Restful::Serializer.new(@foo.bars, @test_ws,
         :serialization => { :only => :id } 
       )
       rs.serialize.should == [
@@ -311,30 +349,31 @@ describe Restful::Serializer do
           'name' => @bar1.name,
           'href' => "http://test.org/bars/#{@bar1.id}",
           'bar'  =>  {
-            'id' => @bar1.id,
+            'name' => @bar1.name,
+            'id'   => @bar1.id,
           },
         },
         {
           'name' => @bar2.name,
           'href' => "http://test.org/bars/#{@bar2.id}",
           'bar'  =>  {
-            'id' => @bar2.id,
+            'name' => @bar2.name,
+            'id'   => @bar2.id,
           },
         },
       ] 
     end
 
-    it "should deeply merge overridden options for each member" do
-      rs = Restful::Serializer.new(@foo.bars, 
-        :deep_merge => { :serialization => { :only => [:id] } }
-      )
+    it "should provide fine grained configuration for each member" do
+      rs = Restful::Serializer.new(@foo.bars, @test_ws) do |configure|
+        configure.serialization.only =  :id
+      end
       rs.serialize.should == [
         {
           'name' => @bar1.name,
           'href' => "http://test.org/bars/#{@bar1.id}",
           'bar'  =>  {
             'id' => @bar1.id,
-            'name' => @bar1.name,
           },
         },
         {
@@ -342,54 +381,92 @@ describe Restful::Serializer do
           'href' => "http://test.org/bars/#{@bar2.id}",
           'bar'  =>  {
             'id' => @bar2.id,
-            'name' => @bar2.name,
           },
         },
       ] 
     end
   end
 
-  it "should hook into activerecord" do
-    @foo.save!
-    @foo.should respond_to(:restful)
-    @foo.restful(:serialization => { :only => :name }).should == {
-      'name' => @foo.name,
-      'foo' => { 
+  describe "extensions" do
+    
+    before(:each) do
+      Restful.register_web_service('test',
+        :resources => {
+          :foo => {
+            :serialization => { :only => :name },
+            :associations => :bars,
+          },
+          :bar => {
+            :serialization => { :only => [:name], :include => { :dingos => { :only =>  [ :name, :id] } } },
+            :associations => [:foo, :dingos],
+          },
+        }
+      )
+      @test_ws = Restful.web_service_configuration('test')
+      generate_instances
+    end
+
+    it "should hook into activerecord" do
+      @foo.should respond_to(:restful)
+      result = @foo.restful('test', :serialization => { :only => [:id] })
+      result.should == {
         'name' => @foo.name,
-      },
-      'href' => "http://test.org/foos/#{@foo.id}",
-    }
-  end
+        'foo' => { 
+          'name' => @foo.name,
+          'id' => @foo.id,
+        },
+        'href' => "http://test.org/foos/#{@foo.id}",
+        'bars_href' => "http://test.org/bars",
+      }
+      # test default web service
+      @foo.restful(:serialization => {:only => :id}).should == result
+    end
+  
+    it "should hook into associations" do
+      result = @foo.bars.restful('test') do |configure|
+        configure.serialization.only = []
+      end
 
-  it "Should hook into associations" do
-    generate_instances
-    @foo.bars.restful.should == [
-      {
-        "href" => "http://test.org/bars/#{@bar1.id}",
-        "name" => @bar1.name,
-        "bar" => {
+      result.should == [
+        {
+          "href" => "http://test.org/bars/#{@bar1.id}",
           "name" => @bar1.name,
-          "foo_id" => @bar1.foo_id,
-          "id" => @bar1.id, 
+          "bar" => {
+            "name" => @bar1.name,
+            "foo_id" => @bar1.foo_id,
+            "id" => @bar1.id, 
+          },
         },
-      },
-      {
-        "href" => "http://test.org/bars/#{@bar2.id}",
-        "name" => @bar2.name,
-        "bar" => {
+        {
+          "href" => "http://test.org/bars/#{@bar2.id}",
           "name" => @bar2.name,
-          "foo_id" => @bar2.foo_id,
-          "id" => @bar2.id,
+          "bar" => {
+            "name" => @bar2.name,
+            "foo_id" => @bar2.foo_id,
+            "id" => @bar2.id,
+          },
         },
-      },
-    ]
+      ]
+
+      @foo.bars.to_a.restful('test') do |configure|
+        configure.serialization.only = []
+      end.should == result
+    end
+
   end
 
   it "should work with AssociationProxy.respond_to" do
-    pending('associations should respond_to :restful (AR 2.1 issue or AR issue in general?)') do
-      @foo.bars.should respond_to(:restful)
-    end
+    @foo.bars.should respond_to(:restful)
   end
+
+  it "should extend ActiveRecord" do
+    @foo.should respond_to(:restful)
+  end
+
+  it "should extend Array" do
+    [].should respond_to(:restful)
+  end
+
 end
 
 describe Restful::DeepHash do

data/spec/web_service_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'spec_helper'))
+
+describe Restful::Configuration::WebService do
+
+  after(:each) do
+    Restful.clear
+  end
+
+  describe "looking up resource configurations" do
+
+    class Super; end
+    class SubClass < Super; end
+
+    before(:each) do
+      @ws = Restful::Configuration::WebService.register('service') do |ws|
+        @super_config = ws.register_resource(:super)
+        @sub_class_config = ws.register_resource(:sub_class)
+      end 
+    end
+
+    it "should return nil if no configuration" do
+      @ws.resource_configuration_for(nil).should be_nil
+    end
+
+    it "should lookup entries by symbol" do
+      @ws.resource_configuration_for(:super).should == @super_config
+    end
+
+    it "should lookup entries from a string" do
+      @ws.resource_configuration_for('super').should == @super_config
+    end
+
+    it "should lookup entries by Class" do
+      @ws.resource_configuration_for(Super).should == @super_config
+      @ws.resource_configuration_for(SubClass).should == @sub_class_config
+    end
+
+    it "should lookup entries by instance class" do
+      @ws.resource_configuration_for(Super.new).should == @super_config
+      @ws.resource_configuration_for(SubClass.new).should == @sub_class_config
+    end
+
+  end
+
+  describe "provided resource configurations" do
+
+    before(:each) do
+      @ws = Restful::Configuration::WebService.register('service') do |ws|
+        @gold_config = ws.register_resource(:super, 
+          :serialization => { :only => :foo }
+        )
+      end
+      @config = @ws.resource_configuration_for(:super)
+    end
+
+    it "should produce a clone" do
+      @config.should == @gold_config
+      @config.should_not equal(@gold_config)
+    end
+
+    it "should produce a deep clone" do
+      @config.serialization.should == @gold_config.serialization
+      @config.serialization.should_not equal(@gold_config.serialization)
+    end
+  end
+end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification 
 name: restful_serializer
 version: !ruby/object:Gem::Version 
-  hash: 29
+  hash: 19
   prerelease: 
   segments: 
   - 0
   - 1
-  - 3
-  version: 0.1.3
+  - 4
+  version: 0.1.4
 platform: ruby
 authors: 
 - Josh Partlow
@@ -15,7 +15,7 @@ autorequire:
 bindir: bin
 cert_chain: []
 
-date: 2011-05-19 00:00:00 -07:00
+date: 2011-06-01 00:00:00 -07:00
 default_executable: 
 dependencies: 
 - !ruby/object:Gem::Dependency 
@@ -137,14 +137,17 @@ files:
 - README.rdoc
 - Rakefile
 - lib/restful.rb
+- lib/restful/configuration.rb
 - lib/restful/serializer.rb
 - lib/restful/version.rb
 - restful_serializer.gemspec
+- spec/configuration_spec.rb
 - spec/database.rb
 - spec/restful_spec.rb
 - spec/serializer_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/web_service_spec.rb
 has_rdoc: true
 homepage: http://github.com/jpartlow/restful_serializer
 licenses: []
@@ -183,8 +186,10 @@ signing_key:
 specification_version: 3
 summary: Helps with serializing activerecord instances as Restful resources.
 test_files: 
+- spec/configuration_spec.rb
 - spec/database.rb
 - spec/restful_spec.rb
 - spec/serializer_spec.rb
 - spec/spec.opts
 - spec/spec_helper.rb
+- spec/web_service_spec.rb