voorhees 0.2.0

data/spec/resource_spec.rb

@@ -0,0 +1,335 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe User  do
+  
+  before :each do 
+    load_json
+  end
+  
+  describe "ClassMethods" do  
+    describe "new_from_json" do
+    
+      it "Should create a new User" do
+        User.should_receive(:new).once.and_return(mock(:user, :null_object => true))
+        user_from_json
+      end
+    
+      it "should assign the JSON to User#raw_json" do
+        mock_user = mock(:user, :null_object => true)
+        User.stub!(:new).and_return(mock_user)
+        mock_user.should_receive(:raw_json=).with(@json)
+        user_from_json
+      end
+    
+      it "should assign the hierarchy to User#json_hierarchy" do
+        mock_user = mock(:user, :null_object => true)
+        User.stub!(:new).and_return(mock_user)
+        mock_user.should_receive(:json_hierarchy=).with(@hierarchy)
+        user_from_json
+      end    
+    
+      it "should return the new user" do
+        user_from_json.should be_an_instance_of(User)
+      end  
+    end
+    
+    describe "json_request" do
+      
+      before :each do 
+        @json_string= "{}"
+        @json_hash  = {}
+        
+        @request  = mock(:request,  :null_object => true)
+        @response = mock(:response, :null_object => true)
+        @objects  = [mock(:object)]
+                
+        Voorhees::Request.stub!(:new).and_return(@request)
+        @request.stub!(:perform).and_return(@response)
+        
+        @response.stub!(:to_objects).and_return(@objects)
+        @response.stub!(:json).and_return(@json_hash)        
+        @response.stub!(:body).and_return(@json_string)            
+      end
+      
+      def perform_request
+        User.json_request{}
+      end
+      
+
+      it "should call Request.new with the current class if no class is passed" do
+        Voorhees::Request.should_receive(:new).with(User).and_return(@request)
+        perform_request
+      end
+      
+      it "should call Request.new with the specified class if a class is passed" do
+        Voorhees::Request.should_receive(:new).with(Message).and_return(@request)
+        User.json_request(:class => Message) do |request|
+          # ...
+        end
+      end
+      
+      
+      it "should yeild a request" do
+        User.json_request do |r|
+          r.should == @request
+        end
+      end
+      
+      it "should raise a LocalJumpError exception if a block is not given" do
+        lambda{
+          User.json_request
+        }.should raise_error(LocalJumpError)
+      end
+      
+      it "should implicitly call Request#perform" do
+        @request.should_receive(:perform).once
+        perform_request
+      end
+      
+      it "should return the result of Response#to_objects if :returning is not set" do
+        perform_request.should == @objects
+      end
+      
+      it "should return the JSON string if :returning is set to :raw" do
+        User.json_request(:returning => :raw){}.should == @json_string
+      end
+      
+      it "should return the JSON hash if :returning is set to :json" do
+        User.json_request(:returning => :json){}.should == @json_hash
+      end
+      
+      it "should return the objects string if :returning is set to :objects" do
+        User.json_request(:returning => :objects){}.should == @objects
+      end
+      
+      it "should return the response if :returning is set to :response" do
+        User.json_request(:returning => :response){}.should == @response
+      end
+              
+    end
+    
+    describe "json_service" do
+      
+      before :each do 
+        @service_name = :list
+        @service_attrs = {
+          :timeout  => 100,
+          :required => [:monkeys]
+        }
+      end
+      
+      def define_service
+        User.json_service @service_name, @service_attrs
+      end
+      
+      it "should define a method with the same name as the service" do
+        User.should_not respond_to(@service_name)
+        define_service
+        User.should respond_to(@service_name)        
+      end       
+      
+      describe "calling the defined method" do
+        
+        before :each do
+          define_service
+
+          @request  = mock(:request,  :null_object => true)
+          @response = mock(:response, :null_object => true)
+          @objects  = [mock(:object)]
+
+          Voorhees::Request.stub!(:new).and_return(@request)
+          @request.stub!(:perform).and_return(@response)
+        end
+        
+        it "should call User#json_request" do
+          User.should_receive(:json_request).and_return(@response)
+          User.list
+        end
+        
+        it "should pass service attributes onto the request" do
+          @service_attrs.each do |key, value|
+            @request.should_receive("#{key}=").with(value)
+          end
+          User.list
+        end
+        
+        it "should use any hash passed in to set the request parameters" do
+          params = {:monkeys => true}
+          @request.should_receive(:parameters=).with(params)
+          User.list(params)
+        end
+        
+        it "should return the result of Response#to_objects" do          
+          @response.should_receive(:to_objects).and_return(@objects)          
+          User.list.should == @objects
+        end
+      end
+    end
+  end
+
+  describe "InstanceMethods" do
+    
+    describe "#raw_json" do
+      it "should contain the raw json" do
+        user_from_json.raw_json.should == @json
+      end
+    end
+    
+    describe "#json_attributes" do
+      it "should contain symbols of the keys of the attributes available as underscored" do
+        user_from_json.json_attributes.sort.should == [:address, :camel_case, :email, :id, :messages, :name, :pet, :username]
+      end
+    end
+    
+    describe "#json_request" do
+      
+      before :each do 
+        @request  = mock(:request,  :null_object => true)
+        @response = mock(:response, :null_object => true)
+                
+        Voorhees::Request.stub!(:new).and_return(@request)
+        @request.stub!(:perform).and_return(@response)        
+      end
+      
+      def perform_request
+        user_from_json.json_request{}
+      end      
+      
+      it "should pass the request to the class method" do
+        User.should_receive(:json_request)
+        user_from_json.json_request{}
+      end
+      
+      it "should raise a LocalJumpError exception if a block is not given" do
+        lambda{
+          user_from_json.json_request
+        }.should raise_error(LocalJumpError)
+      end
+      
+      it "should implicitly call Request#perform" do
+        @request.should_receive(:perform).once
+        perform_request
+      end
+      
+      it "should return the result of Request#perform" do
+        perform_request.should == @response
+      end
+      
+    end
+    
+    describe "calling assignment method with name of a json attribute" do
+
+      it "should define an assignment method" do
+        user = user_from_json
+        
+        user.should_not respond_to(:email=)
+        user.email = "test"
+        user.should respond_to(:email=)
+      end
+      
+      it "should assign the value" do
+        user = user_from_json
+        new_email = "a_new_address@example.com"
+        
+        user.email = new_email
+        user.email.should == new_email
+      end
+      
+    end
+    
+    describe "calling method with the name of a json attribute" do
+      
+      it "should return the correct data from #id" do
+        user = user_from_json
+        user.id.should == @json["id"]
+      end
+      
+      it "should define a method of the same name" do
+        user = user_from_json
+        
+        user.should_not respond_to(:email)
+        user.email
+        user.should respond_to(:email)
+      end
+      
+      it "should return the correct data from defined methods" do
+        user = user_from_json
+        
+        user.email # first access, now it's defined
+        user.email.should == @json["email"]
+      end
+      
+      describe "which is a simple value" do
+        it "should return the value of the attribute" do
+          user_from_json.email.should == @json["email"]
+        end
+      end
+      
+      describe "which is camelCase in the JSON" do
+        it "should return the value of the attribute" do
+          user_from_json.camel_case.should == @json["camelCase"]
+        end
+      end
+      
+      describe "which is a collection" do
+        it "should return an array" do
+          user_from_json.messages.should be_an_instance_of(Array)
+        end
+
+        it "should infer the type of objects based on the collection name" do
+          user_from_json.messages.each do |m|
+            m.should be_an_instance_of(Message)
+          end
+        end        
+      end
+      
+      describe "which is a sub-object" do
+      
+        it "should return as a Hash if the hierarchy is not defined" do
+          @hierarchy = {
+          }          
+          user_from_json.pet.should be_a(Hash)
+        end
+        
+        it "should return as the right class if the hierarchy is defined as symbol" do
+          @hierarchy = {
+            :address => :address
+          }          
+          user_from_json.address.should be_a(Address)
+        end
+        
+        it "should return as the right class if the hierarchy is defined as Class" do
+          @hierarchy = {
+            :address => Address
+          }
+          user_from_json.address.should be_a(Address)
+        end
+        
+        it "should return as the right class for multiple depths" do
+          @hierarchy = {
+            :address => [Address, {
+              :coords => LatLon
+            }]
+          }
+          user_from_json.address.coords.should be_a(LatLon)          
+        end
+        
+      end
+      
+    end
+    
+  end
+end
+
+def load_json
+  body = ''
+  path = File.expand_path(File.dirname(__FILE__) + '/fixtures/user.json')
+  File.open(path, 'r') do |f|
+    body = f.read
+  end
+  @json = JSON.parse(body)
+end
+
+def user_from_json
+  User.new_from_json(@json, @hierarchy)
+end

data/spec/response_spec.rb

@@ -0,0 +1,93 @@
+require File.expand_path(File.dirname(__FILE__) + '/spec_helper')
+
+describe Voorhees::Response do
+
+  before :each do 
+    User.stub!(:new_from_json).and_return(User.new)
+  end
+
+  describe "to_objects" do
+
+    describe "with no class set" do
+      
+      before :each do
+        @klass = nil
+        build_response(:users)
+      end
+      
+      it "should return nil" do
+        @response.to_objects.should be_nil
+      end
+      
+    end
+
+    describe "with a class which does not have Voorhees::Resource mixed in" do
+      
+      before :each do 
+        @klass = NotResource
+        build_response(:users)
+      end
+      
+      it "should raise a Voorhees::NotResourceError exception" do
+        lambda{
+          @response.to_objects
+        }.should raise_error(Voorhees::NotResourceError)
+      end
+      
+    end
+
+    describe "with a class which has Voorhees::Resource mixed in" do
+
+      before :each do 
+        @klass = User        
+      end
+
+      describe "with JSON containing an array of 2 items" do
+
+        before :each do
+          build_response(:users)
+        end
+
+        it "should return an array of 2 objects of the right class" do
+          users = @response.to_objects
+          users.length.should == 2
+          users.each do |u|
+            u.should be_an_instance_of(User)
+          end
+        end
+
+        it "should create objects by sending the JSON and hierarchy to Class.new_from_json" do
+          User.should_receive(:new_from_json).with(@response.json[0], @hierarchy).ordered
+          User.should_receive(:new_from_json).with(@response.json[1], @hierarchy).ordered      
+          @response.to_objects
+        end
+      end
+
+      describe "with JSON containing one item" do
+
+        before :each do
+          build_response(:user)
+        end
+
+        it "should return one object of the right class" do
+          user = @response.to_objects
+          user.should be_an_instance_of(User)
+        end
+
+      end
+    end
+  end
+end
+
+def build_response(fixture)
+  body = ''
+  path = File.expand_path(File.dirname(__FILE__) + "/fixtures/#{fixture}.json")
+  File.open(path, 'r') do |f|
+    body = f.read
+  end
+  
+  @hierarchy = {
+    :address => Address
+  }
+  @response = Voorhees::Response.new(body, @klass, @hierarchy)
+end

data/spec/spec_helper.rb

@@ -0,0 +1,22 @@
+require 'spec'
+require 'rubygems'
+require 'json'
+require 'active_support'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'voorhees'
+
+require File.expand_path(File.dirname(__FILE__) + '/fixtures/resources')
+
+Spec::Runner.configure do |config|
+  
+end
+
+# allow sorting by symbol
+class Symbol
+  def <=>(a)
+    self.to_s <=> a.to_s
+  end
+end
+