lazy_resource 0.1.0

data/spec/lazy_resource/relation_spec.rb

@@ -0,0 +1,169 @@
+require 'spec_helper'
+
+describe LazyResource::Relation do
+  before :each do
+    LazyResource::HttpMock.respond_to do |responder|
+      responder.get('http://example.com', '')
+      responder.get('http://example.com/users', '')
+    end
+  end
+
+  describe '#new' do
+    it 'adds itself to the resource queue' do
+      users = LazyResource::Relation.new(User)
+      users.resource_queue.instance_variable_get("@queue").include?(users).should == true
+    end
+
+    it 'does not add itself to the resource queue if fetched' do
+      users = LazyResource::Relation.new(User, :fetched => true)
+      users.resource_queue.instance_variable_get("@queue").include?(users).should_not == true
+    end
+  end
+
+  describe '#load' do
+    it 'loads the objects passed' do
+      users = [{ :id => '1', :name => 'Andrew' }, { :id => '1', :name => 'James' }]
+      users_collection = LazyResource::Relation.new(User)
+      users_collection.load(users)
+      users_collection.to_a.should == User.load(users)
+    end
+  end
+
+  describe '#as_json' do
+    it 'returns the relation as an array of hashes' do
+      users = [User.load(:id => 1, :name => 'Andrew'), User.load(:id => 2, :name => 'James')]
+      users_collection = LazyResource::Relation.new(User, :fetched => true)
+      users_collection.load(users)
+      users_collection.as_json.should == [{ :id => 1, :name => 'Andrew' }, { :id => 2, :name => 'James' }]
+    end
+  end
+
+  describe '.resource_queue' do
+    it 'creates a new resource queue if one does not already exist' do
+      LazyResource::Relation.resource_queue.should_not be_nil
+    end
+  end
+
+  describe '#collection_name' do
+    it 'should return the collection name from the klass' do
+      relation = LazyResource::Relation.new(User)
+      relation.collection_name.should == User.collection_name
+    end
+  end
+
+  describe '#where' do
+    it 'sets the where values if none exist' do
+      relation = LazyResource::Relation.new(User)
+      relation.where(:name => 'Andrew')
+      relation.where_values.should == { :name => 'Andrew' }
+    end
+
+    it 'merges where values' do
+      relation = LazyResource::Relation.new(User, :where_values => { :id => 123 })
+      relation.where(:name => 'Andrew')
+      relation.where_values.should == { :id => 123, :name => 'Andrew' }
+    end
+
+    it 'overwrites values' do
+      relation = LazyResource::Relation.new(User, :where_values => { :name => 'Andrew' })
+      relation.where(:name => 'James')
+      relation.where_values.should == { :name => 'James' }
+    end
+  end
+
+  describe '#order' do
+    it 'sets the order value if none exists' do
+      relation = LazyResource::Relation.new(User)
+      relation.order('created_at')
+      relation.order_value.should == 'created_at'
+    end
+
+    it 'overwrites the order value' do
+      relation = LazyResource::Relation.new(User, :order_value => 'created_at')
+      relation.order('name')
+      relation.order_value.should == 'name'
+    end
+  end
+
+  describe '#limit' do
+    it 'sets the limit value if none exists' do
+      relation = LazyResource::Relation.new(User)
+      relation.limit(10)
+      relation.limit_value.should == 10
+    end
+
+    it 'overwrites the order value' do
+      relation = LazyResource::Relation.new(User, :limit_value => 10)
+      relation.limit(100)
+      relation.limit_value.should == 100
+    end
+  end
+
+  describe '#offset' do
+    it 'sets the offset value if none exists' do
+      relation = LazyResource::Relation.new(User)
+      relation.offset(10)
+      relation.offset_value.should == 10
+    end
+
+    it 'overwrites the limit value' do
+      relation = LazyResource::Relation.new(User, :offset_value => 10)
+      relation.offset(20)
+      relation.offset_value.should == 20
+    end
+  end
+
+  describe '#page' do
+    it 'sets the page value if none exists' do
+      relation = LazyResource::Relation.new(User)
+      relation.page(10)
+      relation.page_value.should == 10
+    end
+
+    it 'overwrites the page value' do
+      relation = LazyResource::Relation.new(User, :page_value => 10)
+      relation.page(20)
+      relation.page_value.should == 20
+    end
+  end
+
+  describe 'chaining' do
+    it 'supports chaining' do
+      relation = LazyResource::Relation.new(User)
+      relation.where(:name => 'Andrew').order('created_at').limit(10).offset(10).page(10)
+      relation.where_values.should == { :name => 'Andrew' }
+      relation.order_value.should == 'created_at'
+      relation.limit_value.should == 10
+      relation.offset_value.should == 10
+      relation.page_value.should == 10
+    end
+  end
+
+  describe '#to_params' do
+    it 'wraps up the where, order, limit, offset, and page values into a hash' do
+      params = { :where_values => { :name => 'Andrew' }, :order_value => 'created_at', :limit_value => 10, :offset_value => 10, :page_value => 10 }
+      relation = LazyResource::Relation.new(User, params)
+      relation.to_params.should == { :name => 'Andrew', :order => 'created_at', :limit => 10, :offset => 10, :page => 10 }
+    end
+  end
+
+  describe '#respond_to?' do
+    it 'returns true if array responds to the method' do
+      relation = LazyResource::Relation.new(User)
+      relation.respond_to?(:[]).should == true
+    end
+  end
+
+  describe '#method_missing' do
+    it 'acts like an array' do
+      relation = LazyResource::Relation.new(User)
+      relation.should_receive(:to_a).and_return([])
+      relation.method_missing(:[], 0)
+    end
+
+    it 'raises an error if a non-array method is called' do
+      relation = LazyResource::Relation.new(User)
+      lambda { relation.foo }.should raise_error(NoMethodError)
+    end
+  end
+end

data/spec/lazy_resource/request_spec.rb

@@ -0,0 +1,143 @@
+require 'spec_helper'
+
+class SampleResource
+  include LazyResource::Resource
+
+  attribute :id, Fixnum
+  attribute :name, String
+  attribute :created_at, DateTime
+end
+
+describe LazyResource::Request do
+  describe '#new' do
+    before :each do
+      LazyResource::HttpMock.respond_to do |responder|
+        responder.get('http://example.com/api', '')
+      end
+    end
+
+    after :each do
+      Thread.current[:default_headers] = nil
+    end
+
+    it 'sets a default Accept header of application/json' do
+      request = LazyResource::Request.new('http://example.com/api', nil)
+      headers = request.send(:instance_variable_get, "@headers")
+      headers[:Accept].should == 'application/json'
+    end
+
+    it 'sets the default method of GET' do
+      request = LazyResource::Request.new('http://example.com/api', nil)
+      request.send(:instance_variable_get, "@method").should == :get
+    end
+
+    it 'merges the headers from the current thread' do
+      Thread.current[:default_headers] = { :"X-Access-Token" => 'abc' }
+      request = LazyResource::Request.new('http://example.com/api', nil)
+      headers = request.send(:instance_variable_get, "@headers")
+      headers[:"X-Access-Token"].should == 'abc'
+    end
+  end
+
+  describe '#on_complete_proc' do
+    it 'raises an error unless 200 or 201' do
+      request = LazyResource::Request.new('http://example.com', nil)
+      response = Typhoeus::Response.new(:code => 404, :headers => {}, :body => '', :time => 0.3)
+      lambda { request.on_complete_proc.call(response) }.should raise_error(LazyResource::ConnectionError)
+    end
+
+    it 'does not raise an error on 200' do
+      request = LazyResource::Request.new('http://example.com', SampleResource.new)
+      response = Typhoeus::Response.new(:code => 200)
+      lambda { request.on_complete_proc.call(response) }.should_not raise_error(StandardError)
+    end
+
+    it 'does not raise an error on 201' do
+      request = LazyResource::Request.new('http://example.com', SampleResource.new)
+      response = Typhoeus::Response.new(:code => 201)
+      lambda { request.on_complete_proc.call(response) }.should_not raise_error(StandardError)
+    end
+  end
+
+  describe '#parse' do
+    describe 'single resources' do
+      it 'parses JSON and loads it onto the resource' do
+        request = LazyResource::Request.new('http://example.com', SampleResource.new)
+        response_options = { 
+          :code => 200, 
+          :body => { 
+            :id => 1,
+            :name => "Andrew", 
+            :created_at => "2012-08-01 00:00:00 -0500" 
+          }.to_json, 
+          :time => 0.3
+        }
+        response = Typhoeus::Response.new(response_options)
+        request.response = response
+        request.parse
+        request.resource.id.should == 1
+        request.resource.name.should == 'Andrew'
+        request.resource.created_at.should == DateTime.parse("2012-08-01 00:00:00 -0500")
+      end
+    end
+
+    describe 'resource collections' do
+      it 'parses JSON and loads it onto the resource' do
+        request = LazyResource::Request.new('http://example.com', LazyResource::Relation.new(SampleResource))
+        response_options = {
+          :code => 200,
+          :body => [{
+            :id => 1,
+            :name => 'Andrew',
+            :created_at => '2012-08-01 00:00:00 -0500'
+          }, {
+            :id => 2,
+            :name => 'James',
+            :created_at => '2012-07-01 00:00:00 -0500'
+          }].to_json,
+          :time => 0.3
+        }
+        response = Typhoeus::Response.new(response_options)
+        request.response = response
+        request.parse
+        users = request.resource.to_a
+        users.map(&:id).should == [1,2]
+        users.map(&:name).should == ['Andrew', 'James']
+        users.map(&:created_at).should == [DateTime.parse('2012-08-01 00:00:00 -0500'), DateTime.parse('2012-07-01 00:00:00 -0500')]
+      end
+    end
+  end
+
+  describe '#handle_errors' do
+    [
+      [301, LazyResource::Redirection],
+      [400, LazyResource::BadRequest],
+      [401, LazyResource::UnauthorizedAccess],
+      [403, LazyResource::ForbiddenAccess],
+      [404, LazyResource::ResourceNotFound],
+      [405, LazyResource::MethodNotAllowed],
+      [409, LazyResource::ResourceConflict],
+      [410, LazyResource::ResourceGone],
+      [422, LazyResource::UnprocessableEntity],
+      [500, LazyResource::ServerError]
+    ].each do |error|
+      describe "status: #{error[0]}" do
+        it "raises #{error[1]}" do
+          request = LazyResource::Request.new('http://example.com', nil)
+          response = Typhoeus::Response.new(:code => error[0], :headers => {}, :body => '', :time => 0.3)
+          request.response = response
+          lambda { request.handle_errors }.should raise_error(error[1])
+        end
+      end
+    end
+
+    describe 'status: 4xx' do
+      it 'raises ClientError' do
+        request = LazyResource::Request.new('http://example.com', nil)
+        response = Typhoeus::Response.new(:code => 402, :headers => {}, :body => '', :time => 0.3)
+        request.response = response
+        lambda { request.handle_errors }.should raise_error(LazyResource::ClientError)
+      end
+    end
+  end
+end

data/spec/lazy_resource/resource_queue_spec.rb

@@ -0,0 +1,66 @@
+require 'spec_helper'
+
+describe LazyResource::ResourceQueue do
+  before :each do
+    @queue = LazyResource::ResourceQueue.new
+    @relation = LazyResource::Relation.new(User)
+  end
+
+  after :each do
+    Thread.current[:request_queue] = nil
+    @queue.flush!
+  end
+
+  describe '#queue' do
+    it 'queues a relation' do
+      @queue.queue(@relation)
+      @queue.instance_variable_get("@queue").should include(@relation)
+    end
+  end
+
+  describe '#flush!' do
+    it 'flushes the request queue without processing any of the resources' do
+      LazyResource::Request.should_not_receive(:new)
+      @queue.queue(@relation)
+      @queue.flush!
+      @queue.instance_variable_get("@queue").should == []
+    end
+  end
+
+  describe '#request_queue' do
+    it 'creates a new Hydra queue on the current thread' do
+      Typhoeus::Hydra.should_receive(:new)
+      @queue.request_queue.should == Thread.current[:request_queue]
+    end
+  end
+
+  describe '#run' do
+    before :each do
+      LazyResource::HttpMock.respond_to do |responder|
+        responder.get('http://example.com/users', '')
+      end
+    end
+
+    it 'sends the requests to the request queue and runs the request queue' do
+      @queue.queue(@relation)
+      @queue.should_receive(:send_to_request_queue!)
+      @queue.request_queue.should_receive(:run)
+      @queue.run
+    end
+  end
+
+  describe '#send_to_request_queue!' do
+    it 'creates requests for the relations in the queue and puts them in the request_queue' do
+      @queue.request_queue.should_receive(:queue)
+      @queue.queue(@relation)
+      @queue.send_to_request_queue!
+      @queue.instance_variable_get("@queue").should == []
+    end
+  end
+
+  describe '#url_for' do
+    it 'creates a URL for the given resource' do
+      @queue.url_for(@relation).should == 'http://example.com/users'
+    end
+  end
+end

data/spec/lazy_resource/resource_spec.rb

@@ -0,0 +1,463 @@
+require 'spec_helper'
+
+class Admin < User; end
+
+describe LazyResource::Resource do
+  before :each do
+    Thread.current[:request_queue].clear_stubs unless Thread.current[:request_queue].nil?
+  end
+
+  describe '#new' do
+    it 'creates an object with the specified attributes' do
+      user = User.new({ :name => 'Andrew', :id => 123 })
+      user.name.should == 'Andrew'
+      user.id.should == 123
+    end
+  end
+
+  describe '#==' do
+    it 'returns true if the objects have the same type and data' do
+      user1 = User.new(:name => 'Andrew', :id => 123)
+      user2 = User.new(:name => 'Andrew', :id => 123)
+      user1.should == user2
+    end
+
+    it 'returns false if the objects do not have the same type' do
+      user = User.new(:name => 'Andrew')
+      admin = Admin.new(:name => 'Andrew')
+      user.should_not == admin
+    end
+
+    it 'returns false if the objects do not have the same data' do
+      user1 = User.new(:name => 'Andrew')
+      user2 = User.new(:name => 'James')
+      user1.should_not == user2
+    end
+  end
+
+  describe '#eql?' do
+    it 'returns true if the objects have the same type and data' do
+      user1 = User.new(:name => 'Andrew', :id => 123)
+      user2 = User.new(:name => 'Andrew', :id => 123)
+      user1.eql?(user2).should == true
+    end
+
+    it 'returns false if the objects do not have the same type' do
+      user = User.new(:name => 'Andrew')
+      admin = Admin.new(:name => 'Andrew')
+      user.eql?(admin).should == false
+    end
+
+    it 'returns false if the objects do not have the same data' do
+      user1 = User.new(:name => 'Andrew')
+      user2 = User.new(:name => 'James')
+      user1.eql?(user2).should == false
+    end
+  end
+
+  describe '#new_record?' do
+    it 'returns true if the record is new' do
+      user = User.new(:name => 'Andrew')
+      user.new_record?.should == true
+    end
+
+    it 'returns false if the record is not new' do
+      user = User.load(:name => 'Andrew')
+      user.new_record?.should == false
+    end
+  end
+
+  describe '#persisted?' do
+    it 'returns true if the record is persisted (exists on the server)' do
+      user = User.load(:name => 'Andrew')
+      user.persisted?.should == true
+    end
+
+    it 'returns false if the record is not persisted' do
+      user = User.new(:name => 'Andrew')
+      user.persisted?.should == false
+    end
+  end
+
+  describe '#save' do
+    describe 'new record' do
+      before :each do
+        LazyResource::HttpMock.respond_to do |responder|
+          responder.post('http://example.com/users', '{ "name": "Andrew" }')
+        end
+      end
+      
+      it 'calls #create' do
+        user = User.new(:name => 'Andrew')
+        user.should_receive(:create)
+        user.save
+      end
+    end
+
+    describe 'persisted record' do
+      before :each do
+        LazyResource::HttpMock.respond_to do |responder|
+          responder.put('http://example.com/users/1', '{ "name": "Andrew" }')
+        end
+      end
+
+      it 'calls #update' do
+        user = User.load(:name => 'Andrew')
+        user.name = 'James'
+        user.should_receive(:update)
+        user.save
+      end
+    end
+  end
+
+  describe '#create' do
+    before :each do
+      LazyResource::HttpMock.respond_to do |responder|
+        responder.post('http://example.com/users', '{ "name": "Andrew" }')
+      end
+    end
+
+    it 'issues a POST request with the set attributes' do
+      user = User.new(:name => 'Andrew')
+      params = ['http://example.com/users', user, {
+        :method => :post,
+        :params => { :user => { 'name' => 'Andrew' } }
+      }]
+      request = LazyResource::Request.new(*params)
+      LazyResource::Request.should_receive(:new).with(*params).and_return(request)
+      user.create
+    end
+
+    it 'resets the dirty attributes' do
+      user = User.new(:name => 'Andrew')
+      params = ['http://example.com/users', user, {
+        :method => :post,
+        :params => { :user => { 'name' => 'Andrew' } }
+      }]
+      user.create
+      user.changed?.should == false
+      user.changed_attributes.should == {}
+    end
+  end
+
+  describe '#update' do
+    before :each do
+      LazyResource::HttpMock.respond_to do |responder|
+        responder.put('http://example.com/users/1', '{ "name": "James" }')
+      end
+    end
+
+    it 'issues a PUT request with the set attributes' do
+      user = User.load(:name => 'Andrew', :id => 1)
+      user.name = 'James'
+      params = ['http://example.com/users/1', user, {
+        :method => :put,
+        :params => { :user => { 'name' => 'James' } }
+      }]
+      request = LazyResource::Request.new(*params)
+      LazyResource::Request.should_receive(:new).with(*params).and_return(request)
+      user.update
+    end
+  end
+
+  describe '#destroy' do
+    before :each do
+      LazyResource::HttpMock.respond_to do |responder|
+        responder.delete('http://example.com/users/1', '')
+      end
+    end
+
+    it 'issues a DELETE request to the resource\'s element url' do
+      user = User.load(:name => 'Andrew', :id => 1)
+      params = ['http://example.com/users/1', user, {
+        :method => :delete
+      }]
+      request = LazyResource::Request.new(*params)
+      LazyResource::Request.should_receive(:new).with(*params).and_return(request)
+      user.destroy
+    end
+  end
+
+  describe '#update_attributes' do
+    before :each do
+      LazyResource::HttpMock.respond_to do |responder|
+        responder.put('http://example.com/users/1', '')
+      end
+    end
+
+    it 'issues a PUT request to the resource\'s element url with the updated attributes' do
+      user = User.load(:name => 'Andrew', :id => 1)
+      params = ['http://example.com/users/1', user, {
+        :method => :put,
+        :params => { :user => { 'name' => 'James' } }
+      }]
+      request = LazyResource::Request.new(*params)
+      LazyResource::Request.should_receive(:new).with(*params).and_return(request)
+      user.update_attributes(:name => 'James')
+    end
+
+    it 'updates the local attributes' do
+      user = User.load(:name => 'Andrew', :id => 1)
+      user.update_attributes(:name => 'James')
+      user.name.should == 'James'
+    end
+  end
+
+  describe '#attribute_params' do
+    it 'returns a hash of all of the changed attributes' do
+      user = User.new(:name => 'Andrew')
+      user.attribute_params.should == { :user => { 'name' => 'Andrew' } }
+    end
+  end
+
+  describe '#as_json' do
+    it 'returns the resource as a hash' do
+      user = User.load(:id => 1, :name => 'Andrew')
+      user.as_json.should == { :id => 1, :name => 'Andrew' }
+    end
+
+    it 'converts associations to hashes' do
+      params = { :id => 1, :name => 'Andrew', :post => { :id => 1 }, :comments => [{ :id => 1 }, { :id => 2 }] }
+      user = User.load(params)
+      user.as_json.should == params
+    end
+
+    it 'converts datetimes to strings' do
+      params = { :id => 1, :created_at => DateTime.now.to_s }
+      user = User.load(params)
+      user.as_json.should == params
+    end
+  end
+
+  describe '.find' do
+    before :each do
+      LazyResource::HttpMock.respond_to do |responder|
+        responder.get('http://example.com/users/1', { :name => 'Andrew' }.to_json)
+      end
+    end
+
+    it 'generates a new resource and associated request and adds it to the request queue' do
+      LazyResource::Request.should_receive(:new)
+      User.request_queue.should_receive(:queue)
+      user = User.find(1)
+      user.fetched?.should == false
+    end
+
+    it 'sets the primary key' do
+      user = User.find(1)
+      user.id.should == 1
+      user.primary_key.should == 1
+    end
+
+    it 'finds the object' do
+      user = User.find(1)
+      user.name.should == 'Andrew'
+    end
+  end
+
+  describe '.where' do
+    it 'creates a new relation with the passed where values' do
+      users = User.where(:name => 'Andrew')
+      users.where_values.should == { :name => 'Andrew' }
+    end
+  end
+
+  describe '.order' do
+    it 'creates a new relation with the passed order value' do
+      users = User.order('created_at')
+      users.order_value.should == 'created_at'
+    end
+  end
+  
+  describe '.limit' do
+    it 'creates a new relation with the passed limit value' do
+      users = User.limit(10)
+      users.limit_value.should == 10
+    end
+  end
+
+  describe '.offset' do
+    it 'creates a new relation with the passed offset' do
+      users = User.offset(10)
+      users.offset_value.should == 10
+    end
+  end
+
+  describe '.page' do
+    it 'creates a new relation with the passed page' do
+      users = User.page(3)
+      users.page_value.should == 3
+    end
+  end
+
+  describe '.all' do
+    it 'creates a new relation with no options' do
+      users = User.all
+      users.where_values.should be_nil
+    end
+  end
+
+  describe '.create' do
+    before :each do
+      LazyResource::HttpMock.respond_to do |responder|
+        responder.post 'http://example.com/users', '{ "name": "Andrew", "id": 1 }'
+      end
+    end
+
+    it 'instantiates a new record with the passed values' do
+      user = User.create(:name => 'Andrew')
+      user.name.should == 'Andrew'
+    end
+
+    it 'issues a POST request with the passed parameters' do
+      user = User.new(:name => 'Andrew')
+      params = ['http://example.com/users', user, {
+        :method => :post,
+        :params => { :user => { 'name' => 'Andrew' } }
+      }]
+      request = LazyResource::Request.new(*params)
+      LazyResource::Request.should_receive(:new).with(*params).and_return(request)
+      User.create(:name => 'Andrew')
+    end
+  end
+
+  describe '.site' do
+    before :each do
+      @site = User.site
+    end
+
+    after :each do
+      User.site = @site
+    end
+
+    it 'returns the site if it is defined' do
+      User.site = 'http://github.com'
+      User.site.should == 'http://github.com'
+    end
+
+    it 'returns LazyResource::Resource.site if site is not defined' do
+      User.send(:remove_instance_variable, "@site")
+      User.site.should == LazyResource::Resource.site
+    end
+  end
+
+  describe '.site=' do
+    before :each do
+      @site = User.site
+    end
+
+    after :each do
+      User.site = @site
+    end
+
+    it 'sets the site' do
+      User.site = 'http://github.com'
+      User.site.should == 'http://github.com'
+    end
+  end
+
+  describe '.root_node_name=' do
+    before :each do
+      LazyResource::Mapping.root_node_name = nil
+    end
+
+    it 'sets the root node name of the Mapping module' do
+      LazyResource::Resource.root_node_name = 'data'
+      LazyResource::Mapping.root_node_name.should == 'data'
+    end
+  end
+
+  describe '.resource_queue' do
+    before :each do
+      Thread.current[:request_queue] = nil
+    end
+
+    after :each do
+      Thread.current[:resource_queue] = nil
+    end
+
+    it 'creates a new Hydra queue on the current thread' do
+      Typhoeus::Hydra.should_receive(:new)
+      User.request_queue.should == Thread.current[:request_queue]
+    end
+  end
+
+  describe 'callbacks' do
+    before :each do
+      LazyResource::HttpMock.respond_to do |responder|
+        responder.post('http://example.com/users', '')
+        responder.put('http://example.com/users/1', '')
+        responder.delete('http://example.com/users/1', '')
+      end
+    end
+
+    describe 'create' do
+      it 'adds a before_create callback' do
+        User.respond_to?(:before_create).should == true
+      end
+
+      it 'adds a around_create callback' do
+        User.respond_to?(:around_create).should == true
+      end
+
+      it 'adds a after_create callback' do
+        User.respond_to?(:after_create).should == true
+      end
+    end
+
+    describe 'update' do
+      it 'adds a before_update callback' do
+        User.respond_to?(:before_update).should == true
+      end
+
+      it 'adds a around_update callback' do
+        User.respond_to?(:around_update).should == true
+      end
+
+      it 'adds a after_update callback' do
+        User.respond_to?(:after_update).should == true
+      end
+    end
+
+    describe 'save' do
+      it 'adds a before_save callback' do
+        User.respond_to?(:before_save).should == true
+      end
+
+      it 'adds a around_save callback' do
+        User.respond_to?(:around_save).should == true
+      end
+
+      it 'adds a after_save callback' do
+        User.respond_to?(:after_save).should == true
+      end
+    end
+
+    describe 'destroy' do
+      it 'adds a before_destroy callback' do
+        User.respond_to?(:before_destroy).should == true
+      end
+
+      it 'adds a around_destroy callback' do
+        User.respond_to?(:around_destroy).should == true
+      end
+
+      it 'adds a after_destroy callback' do
+        User.respond_to?(:after_destroy).should == true
+      end
+    end
+  end
+
+  describe 'validations' do
+    class User
+      validates_presence_of :name
+    end
+
+    it 'validates' do
+      user = User.new
+      user.valid?.should == false
+      user.name = 'Andrew'
+      user.valid?.should == true
+    end
+  end
+end