superdupe 0.4.0

data/spec/lib_specs/mock_definitions_spec.rb

@@ -0,0 +1,58 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe "Mock Definition Methods" do
+  before do
+    Dupe.reset
+  end
+  
+  describe "Get" do    
+    it "should require a url pattern that is a regex" do
+      proc { Get() }.should raise_error(ArgumentError)
+      proc { Get 'not a regexp' }.should raise_error(ArgumentError)
+      proc { Get %r{/some_url} }.should_not raise_error
+    end
+    
+    it "should create and return a Dupe::Network::Mock of type :get" do
+      Dupe.network.mocks[:get].should be_empty
+      @book = Dupe.create :book, :label => 'rooby'
+      Dupe.network.mocks[:get].should_not be_empty
+      Dupe.network.mocks[:get].length.should == 2
+      
+      mock = Get %r{/books/([^&]+)\.xml} do |label|
+        Dupe.find(:book) {|b| b.label == label}
+      end
+      
+      Dupe.network.mocks[:get].length.should == 3
+      Dupe.network.mocks[:get].last.should == mock
+      Dupe.network.mocks[:get].last.url_pattern.should == %r{/books/([^&]+)\.xml}
+      book = Dupe.find(:book)
+      Dupe.network.request(:get, '/books/rooby.xml').should == book.to_xml_safe(:root => 'book')
+    end
+  end
+  
+  describe "Post" do    
+    it "should require a url pattern that is a regex" do
+      proc { Post() }.should raise_error(ArgumentError)
+      proc { Post 'not a regexp' }.should raise_error(ArgumentError)
+      proc { Post %r{/some_url} }.should_not raise_error
+    end
+    
+    it "should create and return a Dupe::Network::Mock of type :post" do
+      @book = Dupe.create :book, :label => 'rooby'
+      Dupe.network.mocks[:post].should_not be_empty
+      Dupe.network.mocks[:post].length.should == 1
+      
+      mock = Post %r{/books\.xml} do |post_data|
+        Dupe.create(:book, post_data)
+      end
+      
+      Dupe.network.mocks[:post].length.should == 2
+      Dupe.network.mocks[:post].first.should == mock
+      Dupe.network.mocks[:post].first.url_pattern.should == %r{/books\.xml}
+      book_post = Dupe.create(:book, {:title => "Rooby", :label => "rooby"})
+      book_post.delete(:id)
+      book_response = Dupe.create(:book, {:title => "Rooby", :label => "rooby"})
+      Dupe.network.request(:post, '/books.xml', book_post).should == [Dupe.find(:book) {|b| b.id == 4}.to_xml_safe(:root => 'book'), "/books/4.xml"]
+    end
+  end
+end

data/spec/lib_specs/mock_spec.rb

@@ -0,0 +1,194 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Network::Mock do
+  before do
+    Dupe.reset
+  end
+  
+  describe "new" do
+    it "should require the url be a kind of regular expression" do
+      proc { Dupe::Network::Mock.new '', proc {} }.should raise_error(
+        ArgumentError,
+        "The URL pattern parameter must be a type of regular expression."
+      )
+    end
+    
+    it "should set the, @url, and @response parameters accordingly" do
+      url_pattern = /\//
+      response = proc {}
+      mock = Dupe::Network::Mock.new url_pattern, response
+      mock.url_pattern.should == url_pattern
+      mock.response.should == response
+    end
+  end
+  
+  describe "match?" do
+    it "should determine if a given string matches the mock's url pattern" do
+      url = %r{/blogs/(\d+).xml}
+      response = proc {}
+      mock = Dupe::Network::Mock.new url, response
+      mock.match?('/blogs/1.xml').should == true
+      mock.match?('/bogs/1.xml').should == false
+    end
+  end
+end
+
+describe Dupe::Network::GetMock do
+  before do
+    Dupe.reset
+  end
+  
+  describe "mocked_response" do
+    describe "on a mock object whose response returns a Dupe.find with actual results" do
+      it "should convert the response result to xml" do
+        url_pattern = %r{/books/(\d+)\.xml}
+        response = proc {|id| Dupe.find(:book) {|b| b.id == id.to_i}}
+        book = Dupe.create :book
+        mock = Dupe::Network::GetMock.new url_pattern, response
+        mock.mocked_response('/books/1.xml').should == book.to_xml(:root => 'book')
+        
+        proc { mock.mocked_response('/books/2.xml') }.should raise_error(Dupe::Network::GetMock::ResourceNotFoundError)
+        
+        Dupe.define :author
+        mock = Dupe::Network::GetMock.new %r{/authors\.xml$}, proc {Dupe.find :authors}
+        mock.mocked_response('/authors.xml').should == [].to_xml(:root => 'results')
+      end
+      
+      it "should add a request to the Dupe::Network#log" do
+        url_pattern = %r{/books/([a-zA-Z0-9-]+)\.xml}
+        response = proc {|label| Dupe.find(:book) {|b| b.label == label}}
+        book = Dupe.create :book, :label => 'rooby'
+        mock = Dupe::Network::GetMock.new url_pattern, response
+        Dupe.network.log.requests.length.should == 0
+        mock.mocked_response('/books/rooby.xml')
+        Dupe.network.log.requests.length.should == 1
+      end
+    end
+    
+    describe "on a mock object whose response returns nil" do
+      it "should raise an error" do
+        url_pattern = %r{/authors/(\d+)\.xml}
+        response = proc { |id| Dupe.find(:author) {|a| a.id == id.to_i}}
+        Dupe.define :author
+        mock = Dupe::Network::GetMock.new url_pattern, response
+        proc {mock.mocked_response('/authors/1.xml')}.should raise_error(Dupe::Network::GetMock::ResourceNotFoundError)
+      end
+    end
+    
+    describe "on a mock object whose response returns an empty array" do
+      it "should convert the empty array to an xml array record set with root 'results'" do        
+        Dupe.define :author
+        mock = Dupe::Network::GetMock.new %r{/authors\.xml$}, proc {Dupe.find :authors}
+        mock.mocked_response('/authors.xml').should == [].to_xml(:root => 'results')
+      end
+      
+      it "should add a request to the Dupe::Network#log" do
+        Dupe.define :author
+        mock = Dupe::Network::GetMock.new %r{/authors\.xml$}, proc {Dupe.find :authors}
+        Dupe.network.log.requests.length.should == 0
+        mock.mocked_response('/authors.xml')
+        Dupe.network.log.requests.length.should == 1
+      end
+    end
+    
+    describe "on a mock object whose response returns an array of duped records" do
+      it "should convert the array to xml" do        
+        Dupe.create :author  
+        mock = Dupe::Network::GetMock.new %r{/authors\.xml$}, proc {Dupe.find :authors}
+        mock.mocked_response('/authors.xml').should == Dupe.find(:authors).to_xml(:root => 'authors')
+      end
+      
+      it "should add a request to the Dupe::Network#log" do
+        Dupe.create :author
+        mock = Dupe::Network::GetMock.new %r{/authors\.xml$}, proc {Dupe.find :authors}
+        Dupe.network.log.requests.length.should == 0
+        mock.mocked_response('/authors.xml')
+        Dupe.network.log.requests.length.should == 1
+      end
+    end
+  end
+end
+
+describe Dupe::Network::PostMock do
+  before do
+    Dupe.reset
+  end
+  
+  describe "mocked_response" do
+    describe "on a mock object whose response returns a location of a new record" do
+      it "should convert the new post to xml" do        
+        Dupe.define :author  
+        mock = Dupe::Network::PostMock.new %r{/authors\.xml$}, proc {|post_data| Dupe.create(:author, post_data)}
+        resp, url = mock.mocked_response('/authors.xml', {:name => "Rachel"})
+        resp.should == Dupe.find(:authors).first.to_xml_safe(:root => 'author')
+        url.should == "/authors/1.xml"
+      end
+      
+      it "should add a request to the Dupe::Network#log" do
+        Dupe.define :author
+        mock = Dupe::Network::PostMock.new %r{/authors\.xml$}, proc {|post_data| Dupe.create(:author, post_data)}
+        Dupe.network.log.requests.length.should == 0
+        mock.mocked_response('/authors.xml', {:name => "Rachel"})
+        Dupe.network.log.requests.length.should == 1
+      end
+    end
+  end
+end
+
+describe Dupe::Network::PutMock do
+  before do
+    Dupe.reset
+  end
+  
+  describe "mocked_response" do
+    describe "on a mock object whose response returns a location of a new record" do
+      before do
+        Dupe.define :author  
+        @a = Dupe.create :author, :name => "Matt"
+        @mock = Dupe::Network::PutMock.new %r{/authors/(\d+)\.xml$}, proc {|id, put_data| Dupe.find(:author) {|a| a.id == id.to_i}.merge!(put_data)}
+      end
+
+      it "should convert the put to xml" do        
+        resp, url = @mock.mocked_response('/authors/1.xml', {:name => "Rachel"})
+        resp.should == nil
+        @a.name.should == "Rachel"
+        url.should == "/authors/1.xml"
+      end
+      
+      it "should add a request to the Dupe::Network#log" do
+        Dupe.network.log.requests.length.should == 0
+        @mock.mocked_response('/authors/1.xml', {:name => "Rachel"})
+        Dupe.network.log.requests.length.should == 1
+      end
+    end
+  end
+end
+
+describe Dupe::Network::DeleteMock do
+  before do
+    Dupe.reset
+  end
+  
+  describe "mocked_response" do
+    describe "on a mock object whose response returns a location of a new record" do
+      before do
+        Dupe.define :author  
+        @a = Dupe.create :author, :name => "Matt"
+        @mock = Dupe::Network::DeleteMock.new %r{/authors/(\d+)\.xml$}, proc {|id| Dupe.delete(:author) {|a| a.id == id.to_i}}
+      end
+
+      it "should convert the put to xml" do        
+        Dupe.find(:authors).length.should == 1
+        resp = @mock.mocked_response('/authors/1.xml')
+        resp.should == nil
+        Dupe.find(:authors).length.should == 0
+      end
+      
+      it "should add a request to the Dupe::Network#log" do
+        Dupe.network.log.requests.length.should == 0
+        @mock.mocked_response('/authors/1.xml')
+        Dupe.network.log.requests.length.should == 1
+      end
+    end
+  end
+end

data/spec/lib_specs/model_spec.rb

@@ -0,0 +1,95 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Model do
+  describe "new" do
+    it "should require a model name" do
+      proc { Dupe::Model.new }.should raise_error(ArgumentError)
+    end
+    
+    it "should set the model name to what was passed in during initialization" do
+      m = Dupe::Model.new :book
+      m.name.should == :book
+    end
+    
+    it "should initialize an empty schema" do
+      m = Dupe::Model.new :book
+      m.schema.should be_kind_of(Dupe::Model::Schema)
+    end
+    
+    it "should setup an id_sequence initialized to 0" do
+      m = Dupe::Model.new :book
+      m.id_sequence.current_value.should == 1
+    end
+  end
+  
+  describe "define" do
+    describe "when passed a proc" do
+      before do
+        @model = Dupe::Model.new :book
+        @definition = proc { |attrs|
+          attrs.author('Anonymous') do |dont_care|
+            'Flying Spaghetti Monster'
+          end
+        }
+      end
+      
+      it "should pass that proc off to it's schema" do
+        @model.schema.should_receive(:method_missing).once
+        @model.define @definition
+      end
+      
+      it "should result in a schema with the desired attribute templates" do
+        @model.define @definition
+        @model.schema.attribute_templates[:author].name.should == :author
+        @model.schema.attribute_templates[:author].default.should == 'Anonymous'
+        @model.schema.attribute_templates[:author].transformer.call(
+          'dont care'
+        ).should == 'Flying Spaghetti Monster'
+      end
+    end
+  end
+  
+  describe "create" do
+    before do 
+      Dupe.define :book do |attrs|
+        attrs.title 'Untitled'
+        attrs.author 'Anon' do |author|
+          "Author: #{author}"
+        end
+        attrs.after_create do |book|
+          book.label = book.title.downcase.gsub(/\ +/, '-')
+        end
+      end
+      
+      @book_model = Dupe.models[:book]
+    end
+    
+    it "shouldn't require any parameters" do
+      proc {
+        @book_model.create
+      }.should_not raise_error
+    end
+    
+    it "should return a Dupe::Database::Record instance with the desired parameters" do
+      book = @book_model.create
+      book.should be_kind_of(Dupe::Database::Record)
+      book.__model__.name.should == :book
+      book.id.should == 1
+      book.title.should == 'Untitled'
+      book.author.should == 'Anon'
+      
+      # the callback shouldn't get run until the database record is inserted into the duped 'database'
+      book.label.should == nil
+      
+      book = @book_model.create :title => 'Rooby On Rails', :author => 'Matt Parker'
+      book.__model__.name.should == :book
+      book.id.should == 2
+      book.title.should == 'Rooby On Rails'
+      
+      # the callback shouldn't get run until the database record is inserted into the duped 'database'
+      book.label.should == nil
+      
+      book.author.should == 'Author: Matt Parker'
+    end
+  end
+end

data/spec/lib_specs/network_spec.rb

@@ -0,0 +1,130 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Network do
+  
+  describe "new" do
+    before do
+      @network = Dupe::Network.new
+    end
+    
+    it "should initialize @mocks to a hash of empty arrays keyed with valid REST verbs" do
+      Dupe::Network::VERBS.each do |verb|
+        @network.mocks[verb].should == []
+      end
+    end
+    
+    it "should initialize @log to a new Dupe::Network::Log" do
+      @network.log.should be_kind_of(Dupe::Network::Log)
+    end
+  end
+  
+  describe "request" do
+    before do
+      @network = Dupe::Network.new
+    end
+    
+    it "should require a valid REST verb" do
+      proc { @network.request }.should raise_error
+      proc { @network.request :invalid_rest_verb, '/some_url' }.should raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { @network.request :get, '/some_url' }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { @network.request :post, '/some_url', 'some body' }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { @network.request :put, '/some_url' }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { @network.request :delete, '/some_url' }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+    end
+    
+    it "should require a URL" do
+      proc { @network.request :get }.should raise_error(ArgumentError)
+      proc { @network.request :get, 'some_url'}.should_not raise_error(ArgumentError)
+      proc { @network.request :post, 'some_url', 'some body'}.should_not raise_error(ArgumentError)
+      proc { @network.request :put, 'some_url'}.should_not raise_error(ArgumentError)
+      proc { @network.request :delete, 'some_url'}.should_not raise_error(ArgumentError)
+    end
+    
+    it "should raise an exception if the network has no mocks that match the url" do
+      proc { @network.request(:get, '/some_url')}.should raise_error(Dupe::Network::RequestNotFoundError)
+      proc { @network.request(:post, '/some_url', 'some body')}.should raise_error(Dupe::Network::RequestNotFoundError)
+      proc { @network.request(:put, '/some_url')}.should raise_error(Dupe::Network::RequestNotFoundError)
+      proc { @network.request(:delete, '/some_url')}.should raise_error(Dupe::Network::RequestNotFoundError)
+    end
+    
+    it "should return the appropriate mock response if a mock matches the url" do
+      @network.define_service_mock :get, %r{/greeting$}, proc { "hello" }
+      @network.request(:get, '/greeting').should == 'hello'
+      
+      @network.define_service_mock :post, %r{/greeting$}, proc { |post_data| Dupe.create(:greeting, post_data) }
+      resp, url = @network.request(:post, '/greeting', {} )
+      resp.should == Dupe.find(:greeting).to_xml_safe(:root => 'greeting')
+      url.should == "/greetings/1.xml"
+    end
+  end
+  
+  describe "define_service_mock" do
+    before do
+      @network = Dupe::Network.new
+    end
+    
+    it "should require a valid REST verb" do
+      proc { @network.define_service_mock }.should raise_error
+      proc { @network.define_service_mock :invalid_rest_verb, // }.should raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { @network.define_service_mock :get, // }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { @network.define_service_mock :post, // }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+      proc { @network.define_service_mock :put, // }.should_not raise_error(Dupe::Network::UnknownRestVerbError)
+    end
+    
+    it "should require a valid Regexp url pattern" do
+      proc { @network.define_service_mock :get, 'not a regular expression' }.should raise_error(ArgumentError)
+      proc { @network.define_service_mock :post, 'not a regular expression' }.should raise_error(ArgumentError)
+      proc { @network.define_service_mock :get, // }.should_not raise_error
+      proc { @network.define_service_mock :post, // }.should_not raise_error
+    end
+    
+    it "should create and return a new get service mock when given valid parameters" do
+      verb = :get
+      pattern = //
+      response = proc { 'test' }
+      @network.mocks[:get].should be_empty
+      mock = @network.define_service_mock verb, pattern, response
+      @network.mocks[:get].should_not be_empty
+      @network.mocks[:get].first.class.should == Dupe::Network::GetMock
+      @network.mocks[:get].length.should == 1
+      @network.mocks[:get].first.should == mock
+    end
+    
+    it "should create and return a new post service mock when given valid parameters" do
+      verb = :post
+      pattern = //
+      response = proc { 'test' }
+      @network.mocks[:post].should be_empty
+      mock = @network.define_service_mock verb, pattern, response
+      @network.mocks[:post].should_not be_empty
+      @network.mocks[:post].first.class.should == Dupe::Network::PostMock
+      @network.mocks[:post].length.should == 1
+      @network.mocks[:post].first.should == mock
+    end
+    
+    it "should create and return a new put service mock when given valid parameters" do
+      verb = :put
+      pattern = //
+      response = proc { 'test' }
+      @network.mocks[:put].should be_empty
+      mock = @network.define_service_mock verb, pattern, response
+      @network.mocks[:put].should_not be_empty
+      @network.mocks[:put].first.class.should == Dupe::Network::PutMock
+      @network.mocks[:put].length.should == 1
+      @network.mocks[:put].first.should == mock
+    end
+    
+    it "should create and return a new delete service mock when given valid parameters" do
+      verb = :delete
+      pattern = //
+      response = proc { 'test' }
+      @network.mocks[:delete].should be_empty
+      mock = @network.define_service_mock verb, pattern, response
+      @network.mocks[:delete].should_not be_empty
+      @network.mocks[:delete].first.class.should == Dupe::Network::DeleteMock
+      @network.mocks[:delete].length.should == 1
+      @network.mocks[:delete].first.should == mock
+    end
+  end
+  
+end

data/spec/lib_specs/record_spec.rb

@@ -0,0 +1,70 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Database::Record do
+  describe "new" do
+    it "should create an object that is a kind of Hash" do
+      Dupe::Database::Record.new.should be_kind_of(Hash)
+    end
+  end
+  
+  describe "id" do
+    it "should allow us to set the record id (and not the object id)" do
+      d = Dupe::Database::Record.new
+      d.id.should == nil
+      d[:id].should == nil
+      d.id = 1
+      d.id.should == 1
+      d[:id].should == 1
+    end
+  end
+  
+  describe "method_missing" do
+    it "should allow us to access hash keys as if they were object attributes" do
+      d = Dupe::Database::Record.new
+      d[:some_key].should == nil
+      d.some_key.should == nil
+      d.some_key = 1
+      d.some_key.should == 1
+      d[:some_key].should == 1
+      d[:another_key] = 2
+      d.another_key.should == 2
+      d[:another_key].should == 2
+    end
+  end
+  
+  describe "inspect" do
+    it "should show the class name" do
+      d = Dupe::Database::Record.new
+      d.inspect.should match(/^<#Dupe::Database::Record/)
+    end
+    
+    it "should show the key/value pairs as attributes" do
+      d = Dupe::Database::Record.new 
+      d.title = 'test'
+      d.inspect.should match(/title="test"/)
+      d.author = Dupe::Database::Record.new
+      d.inspect.should match(/author=<#Dupe::Database::Record/)
+    end
+    
+    it "should show Fake::<model_name> when the record has a model" do
+      b = Dupe.create :book
+      b.inspect.should match(/^<#Duped::Book/)
+      b.author = Dupe.create :author
+      b.inspect.should match(/^<#Duped::Book/)
+      b.inspect.should match(/author=<#Duped::Author/)
+    end
+  end
+  
+  describe "__model__" do  
+    it "should have a __model__ instance variable" do
+      proc {Dupe::Database::Record.new.__model__}.should_not raise_error
+    end
+    
+    it "should all you to set the __model_name__ instance variable" do
+      r = Dupe::Database::Record.new
+      proc {r.__model__ = :book}.should_not raise_error
+      r.__model__.should == :book
+    end
+  end
+  
+end

data/spec/lib_specs/rest_validation_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Network::RestValidation do
+  before do
+    class TestRestValidation
+      include Dupe::Network::RestValidation
+    end
+  end
+  
+  describe "validate_request_type" do
+    it "should raise an exception if the request type isn't :get, :post, :put, or :delete" do
+      proc { 
+        TestRestValidation.new.validate_request_type(:unknown_request_type) 
+      }.should raise_error(Dupe::Network::UnknownRestVerbError)
+    end
+  end
+end

data/spec/lib_specs/schema_spec.rb

@@ -0,0 +1,109 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Dupe::Model::Schema do
+  describe "new" do
+    it "should initialize attribute_templates to an empty hash" do
+      Dupe::Model::Schema.new.attribute_templates.should == {}
+    end
+    
+    it "should initialize after_create_callbacks to an empty array" do
+      Dupe::Model::Schema.new.after_create_callbacks.should == []
+    end
+  end
+  
+  describe "dynamic attribute_template creation methods" do
+    before do
+      @schema = Dupe::Model::Schema.new
+    end
+    
+    describe "called with no parameters" do
+      it "should create a new attribute template with no transformer and no default value" do
+        @schema.title
+        @schema.attribute_templates[:title].should be_kind_of(Dupe::Model::Schema::AttributeTemplate)
+        @schema.attribute_templates[:title].name.should == :title
+        @schema.attribute_templates[:title].default.should be_nil
+        @schema.attribute_templates[:title].transformer.should be_nil
+      end
+    end
+    
+    describe "called with a single parameter, but no block" do
+      it "should create a new attribute template with a default value but no transformer" do
+        @schema.title 'Untitled'
+        @schema.attribute_templates[:title].should be_kind_of(Dupe::Model::Schema::AttributeTemplate)
+        @schema.attribute_templates[:title].name.should == :title
+        @schema.attribute_templates[:title].default.should == 'Untitled'
+        @schema.attribute_templates[:title].transformer.should be_nil
+      end
+    end
+    
+    describe "called with a block that accepts a parameter" do
+      it "should create a new attribute template without a default value, but with a tranformer" do
+        @schema.title {|dont_care| 'test'}
+        @schema.attribute_templates[:title].should be_kind_of(Dupe::Model::Schema::AttributeTemplate)
+        @schema.attribute_templates[:title].name.should == :title
+        @schema.attribute_templates[:title].default.should be_nil
+        @schema.attribute_templates[:title].transformer.should be_kind_of(Proc)
+      end
+    end
+    
+    describe "called with a block that doesn't accept a parameter" do
+      it "should create a new attribute template without a transformer, and with the block as the default value" do
+        @schema.title { 'knock' * 3 }
+        @schema.attribute_templates[:title].should be_kind_of(Dupe::Model::Schema::AttributeTemplate)
+        @schema.attribute_templates[:title].name.should == :title
+        @schema.attribute_templates[:title].default.should be_kind_of(Proc)
+        @schema.attribute_templates[:title].default.call.should == "knockknockknock"
+        @schema.attribute_templates[:title].transformer.should be_nil
+      end
+    end
+    
+    describe "called with a block and a parameter" do
+      it "should create a new attribute template with a default value AND with a tranformer" do
+        @schema.title('Untitled') {|dont_care| 'test'}
+        @schema.attribute_templates[:title].should be_kind_of(Dupe::Model::Schema::AttributeTemplate)
+        @schema.attribute_templates[:title].name.should == :title
+        @schema.attribute_templates[:title].default.should == 'Untitled'
+        @schema.attribute_templates[:title].transformer.should be_kind_of(Proc)
+      end
+    end
+  end
+  
+  describe "#after_create" do
+    before do
+      @schema = Dupe::Model::Schema.new
+    end
+    
+    it "should require a block that accepts a single parameter" do
+      proc { @schema.after_create }.should raise_error(ArgumentError)
+      proc { @schema.after_create { "parameterless block" } }.should raise_error(ArgumentError)
+      proc { @schema.after_create {|s| s.title = 'test' } }.should_not raise_error
+    end
+    
+    it "should add the callback to the list of after_create_callbacks" do
+      @schema.after_create_callbacks.should be_empty
+      @schema.after_create {|s| s.title = 'test'}
+      @schema.after_create_callbacks.length.should == 1
+      @schema.after_create_callbacks.first.should be_kind_of(Proc)
+    end
+    
+  end
+
+  describe "#uniquify" do
+    before do
+      @schema = Dupe::Model::Schema.new
+    end
+
+    it "should only accept a list of symbols" do
+      proc { @schema.uniquify }.should raise_error(ArgumentError, "You must pass at least one attribute to uniquify.")
+      proc { @schema.uniquify :hash => 'value' }.should raise_error(ArgumentError, "You may only pass symbols to uniquify.")
+      proc { @schema.uniquify :one, :two}.should_not raise_error
+    end
+
+    it "should create after_create_callbacks for each symbol passed to it" do
+      @schema.after_create_callbacks.should be_empty
+      @schema.uniquify :title, :label
+      @schema.after_create_callbacks.length.should == 2
+      @schema.after_create_callbacks.first.should be_kind_of(Proc)
+    end
+  end
+end