JamieFlournoy-machinist 1.0.6

data/spec/active_record_spec.rb

@@ -0,0 +1,200 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'machinist/active_record'
+require 'active_support/whiny_nil'
+
+module MachinistActiveRecordSpecs
+  
+  class Person < ActiveRecord::Base
+    attr_protected :password
+  end
+
+  class Admin < Person
+  end
+
+  class Post < ActiveRecord::Base
+    has_many :comments
+  end
+
+  class Comment < ActiveRecord::Base
+    belongs_to :post
+    belongs_to :author, :class_name => "Person"
+  end
+
+  describe Machinist, "ActiveRecord adapter" do
+    before(:suite) do
+      ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + "/log/test.log")
+      ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+      load(File.dirname(__FILE__) + "/db/schema.rb")
+    end
+  
+    before(:each) do
+      [Person, Admin, Post, Comment].each(&:clear_blueprints!)
+    end
+  
+    describe "make method" do
+      it "should support single-table inheritance" do
+        Person.blueprint { }
+        Admin.blueprint  { }
+        admin = Admin.make
+        admin.should_not be_new_record
+        admin.type.should == "Admin"
+      end
+
+      it "should save the constructed object" do
+        Person.blueprint { }
+        person = Person.make
+        person.should_not be_new_record
+      end
+  
+      it "should create an object through belongs_to association" do
+        Post.blueprint { }
+        Comment.blueprint { post }
+        Comment.make.post.class.should == Post
+      end
+  
+      it "should create an object through belongs_to association with a class_name attribute" do
+        Person.blueprint { }
+        Comment.blueprint { author }
+        Comment.make.author.class.should == Person
+      end
+
+      it "should create an object through belongs_to association using a named blueprint" do
+        Post.blueprint { }
+        Post.blueprint(:dummy) do
+          title { 'Dummy Post' }
+        end
+        Comment.blueprint { post(:dummy) }
+        Comment.make.post.title.should == 'Dummy Post'
+      end
+      
+      it "should allow creating an object through a has_many association" do
+        Post.blueprint do
+          comments { [Comment.make] }
+        end
+        Comment.blueprint { }
+        Post.make.comments.should have(1).instance_of(Comment)
+      end
+      
+      it "should allow setting a protected attribute in the blueprint" do
+        Person.blueprint do
+          password { "Test" }
+        end
+        Person.make.password.should == "Test"
+      end
+      
+      it "should allow overriding a protected attribute" do
+        Person.blueprint do
+          password { "Test" }
+        end
+        Person.make(:password => "New").password.should == "New"
+      end
+      
+      it "should allow setting the id attribute in a blueprint" do
+        Person.blueprint do
+          id { 12345 }
+        end
+        Person.make.id.should == 12345
+      end
+      
+      it "should allow setting the type attribute in a blueprint" do
+        Person.blueprint do
+          type { "Person" }
+        end
+        Person.make.type.should == "Person"
+      end
+
+      describe "on a has_many association" do
+        before do 
+          Post.blueprint { }
+          Comment.blueprint { post }
+          @post = Post.make
+          @comment = @post.comments.make
+        end
+    
+        it "should save the created object" do
+          @comment.should_not be_new_record
+        end
+    
+        it "should set the parent association on the created object" do
+          @comment.post.should == @post
+        end
+      end
+    end
+
+    describe "plan method" do
+      it "should not save the constructed object" do
+        person_count = Person.count
+        Person.blueprint { }
+        person = Person.plan
+        Person.count.should == person_count
+      end
+  
+      it "should create an object through a belongs_to association, and return its id" do
+        Post.blueprint { }
+        Comment.blueprint { post }
+        post_count = Post.count
+        comment = Comment.plan
+        Post.count.should == post_count + 1
+        comment[:post].should be_nil
+        comment[:post_id].should_not be_nil
+      end
+
+      describe "on a belongs_to association" do
+        it "should allow explicitly setting the association to nil" do
+          Comment.blueprint { post }
+          Comment.blueprint(:no_post) { post { nil } }
+          lambda {
+            @comment = Comment.plan(:no_post)
+          }.should_not raise_error
+        end
+      end
+  
+      describe "on a has_many association" do
+        before do
+          Post.blueprint { }
+          Comment.blueprint do
+            post
+            body { "Test" }
+          end
+          @post = Post.make
+          @post_count = Post.count
+          @comment = @post.comments.plan
+        end
+    
+        it "should not include the parent in the returned hash" do
+          @comment[:post].should be_nil
+          @comment[:post_id].should be_nil
+        end
+    
+        it "should not create an extra parent object" do
+          Post.count.should == @post_count
+        end
+      end
+    end
+
+    describe "make_unsaved method" do
+      it "should not save the constructed object" do
+        Person.blueprint { }
+        person = Person.make_unsaved
+        person.should be_new_record
+      end
+  
+      it "should not save associated objects" do
+        Post.blueprint { }
+        Comment.blueprint { post }
+        comment = Comment.make_unsaved
+        comment.post.should be_new_record
+      end
+  
+      it "should save objects made within a passed-in block" do
+        Post.blueprint { }
+        Comment.blueprint { }
+        comment = nil
+        post = Post.make_unsaved { comment = Comment.make }
+        post.should be_new_record
+        comment.should_not be_new_record
+      end
+    end
+  
+  end
+end

data/spec/data_mapper_spec.rb

@@ -0,0 +1,136 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'machinist/data_mapper'
+require 'dm-validations'
+
+module MachinistDataMapperSpecs
+  
+  class Person
+    include DataMapper::Resource
+    property :id,       Serial
+    property :name,     String,  :length => (0..10)
+    property :type,     Discriminator
+    property :password, String
+    property :admin,    Boolean, :default => false
+  end
+
+  class Admin < Person
+  end
+
+  class Post
+    include DataMapper::Resource
+    property :id,        Serial
+    property :title,     String
+    property :body,      Text
+    property :published, Boolean, :default => true
+    has n, :comments
+  end
+
+  class Comment
+    include DataMapper::Resource
+    property :id,        Serial
+    property :post_id,   Integer
+    property :author_id, Integer
+    belongs_to :post
+    belongs_to :author, :model => "Person", :child_key => [:author_id]
+  end
+
+  describe Machinist, "DataMapper adapter" do  
+    before(:suite) do
+      DataMapper::Logger.new(File.dirname(__FILE__) + "/log/test.log", :debug)
+      DataMapper.setup(:default, "sqlite3::memory:")
+      DataMapper.auto_migrate!
+    end
+
+    before(:each) do
+      [Person, Admin, Post, Comment].each(&:clear_blueprints!)
+    end
+
+    describe "make method" do
+      it "should support inheritance" do
+        Person.blueprint {}
+        Admin.blueprint {}
+
+        admin = Admin.make
+        admin.should_not be_new
+        admin.type.should_not be_nil
+      end
+
+      it "should save the constructed object" do
+        Person.blueprint { }
+        person = Person.make
+        person.should_not be_new
+      end
+
+      it "should create an object through a belongs_to association" do
+        Post.blueprint { }
+        Comment.blueprint { post }
+        Comment.make.post.class.should == Post
+      end
+
+
+      it "should create an object through a belongs_to association with a class_name attribute" do
+        Person.blueprint { }
+        Comment.blueprint { author }
+        Comment.make.author.class.should == Person
+      end
+
+      it "should raise an exception if the object can't be saved" do
+        Person.blueprint { }
+        lambda { Person.make(:name => "More than ten characters") }.should raise_error(RuntimeError)
+      end
+    end
+
+    describe "plan method" do
+      it "should not save the constructed object" do
+        person_count = Person.all.length
+        Person.blueprint { }
+        person = Person.plan
+        Person.all.length.should == person_count
+      end
+  
+      it "should return a regular attribute in the hash" do
+        Post.blueprint do
+          title { "Test" }
+        end
+        post = Post.plan
+        post[:title].should == "Test"
+      end
+
+      it "should create an object through a belongs_to association, and return its id" do
+        Post.blueprint { }
+        Comment.blueprint { post }
+        post_count = Post.all.length
+        comment = Comment.plan
+        Post.all.length.should == post_count + 1
+        comment[:post].should be_nil
+        comment[:post_id].should_not be_nil
+      end
+    end
+
+    describe "make_unsaved method" do
+      it "should not save the constructed object" do
+        Person.blueprint { }
+        person = Person.make_unsaved
+        person.should be_new
+      end
+  
+      it "should not save associated objects" do
+        Post.blueprint { }
+        Comment.blueprint { post }
+        comment = Comment.make_unsaved
+        comment.post.should be_new
+      end
+  
+      it "should save objects made within a passed-in block" do
+        Post.blueprint { }
+        Comment.blueprint { }
+        comment = nil
+        post = Post.make_unsaved { comment = Comment.make }
+        post.should be_new
+        comment.should_not be_new
+      end
+    end
+  
+  end
+end
+

data/spec/db/.gitignore

@@ -0,0 +1 @@
+*.sqlite3

data/spec/db/schema.rb

@@ -0,0 +1,20 @@
+ActiveRecord::Schema.define(:version => 0) do
+  create_table :people, :force => true do |t|
+    t.column :name, :string
+    t.column :type, :string
+    t.column :password, :string
+    t.column :admin, :boolean, :default => false
+  end
+  
+  create_table :posts, :force => true do |t|
+    t.column :title, :string
+    t.column :body, :text
+    t.column :published, :boolean, :default => true
+  end
+  
+  create_table :comments, :force => true do |t|
+    t.column :post_id, :integer
+    t.column :author_id, :integer
+    t.column :body, :text
+  end
+end

data/spec/log/.gitignore

@@ -0,0 +1 @@
+*.log

data/spec/machinist_spec.rb

@@ -0,0 +1,208 @@
+require File.dirname(__FILE__) + '/spec_helper'
+require 'machinist/object'
+
+module MachinistSpecs
+  
+  class Person
+    attr_accessor :name, :admin
+  end
+
+  class Post
+    attr_accessor :title, :body, :published
+  end
+
+  class Grandpa
+    attr_accessor :name
+  end
+  
+  class Dad < Grandpa
+    attr_accessor :name
+  end
+
+  class Son < Dad
+    attr_accessor :name
+  end
+
+  describe Machinist do
+    before(:each) do
+      [Person, Post, Grandpa, Dad, Son].each(&:clear_blueprints!)
+    end
+
+    it "should raise for make on a class with no blueprint" do
+      lambda { Person.make }.should raise_error(RuntimeError, "No blueprint for class MachinistSpecs::Person")
+    end
+  
+    it "should set an attribute on the constructed object from a constant in the blueprint" do
+      Person.blueprint do
+        name "Fred"
+      end
+      Person.make.name.should == "Fred"
+    end
+  
+    it "should set an attribute on the constructed object from a block in the blueprint" do
+      Person.blueprint do
+        name { "Fred" }
+      end
+      Person.make.name.should == "Fred"
+    end
+  
+    it "should default to calling Sham for an attribute in the blueprint" do
+      Sham.clear
+      Sham.name { "Fred" }
+      Person.blueprint { name }
+      Person.make.name.should == "Fred"
+    end
+  
+    it "should let the blueprint override an attribute with a default value" do
+      Post.blueprint do
+        published { false }
+      end
+      Post.make.published.should be_false
+    end
+  
+    it "should allow overridden attribute names to be strings" do
+      Person.blueprint do
+        name { "Fred" }
+      end
+      Person.make("name" => "Bill").name.should == "Bill"
+    end
+  
+    it "should override an attribute from the blueprint with a passed-in attribute" do
+      block_called = false
+      Person.blueprint do
+        name { block_called = true; "Fred" }
+      end
+      Person.make(:name => "Bill").name.should == "Bill"
+      block_called.should be_false
+    end
+  
+    it "should call a passed-in block with the object being constructed" do
+      Person.blueprint { }
+      block_called = false
+      Person.make do |person|
+        block_called = true
+        person.class.should == Person
+      end
+      block_called.should be_true
+    end
+  
+    it "should provide access to the object being constructed from within the blueprint" do
+      person = nil
+      Person.blueprint { person = object }
+      Person.make
+      person.class.should == Person
+    end
+  
+    it "should allow reading of a previously assigned attribute from within the blueprint" do
+      Post.blueprint do
+        title { "Test" }
+        body  { title }
+      end
+      Post.make.body.should == "Test"
+    end
+  
+    describe "named blueprints" do
+      before do
+        @block_called = false
+        Person.blueprint do
+          name  { "Fred" }
+          admin { @block_called = true; false }
+        end
+        Person.blueprint(:admin) do
+          admin { true }
+        end
+        @person = Person.make(:admin)
+      end
+      
+      it "should override an attribute from the parent blueprint in the child blueprint" do
+        @person.admin.should == true
+      end
+    
+      it "should not call the block for an attribute from the parent blueprint if that attribute is overridden in the child" do
+        @block_called.should be_false
+      end
+    
+      it "should set an attribute defined in the parent blueprint" do
+        @person.name.should == "Fred"
+      end
+
+      it "should return the correct list of named blueprints" do
+        Person.blueprint(:foo) { }
+        Person.blueprint(:bar) { }
+        Person.named_blueprints.to_set.should == [:admin, :foo, :bar].to_set
+      end
+
+      it "should raise exception for make if named blueprint is not defined" do
+        lambda { Person.make(:bogus) }.should raise_error(
+          RuntimeError, "No blueprint named 'bogus' defined for class MachinistSpecs::Person"
+        )
+      end
+      
+      it "should raise a sensible error when calling a named blueprint with no master" do
+        Post.blueprint(:foo) { }
+        lambda { Post.make(:foo) }.should raise_error(
+          RuntimeError, "Can't construct an object from a named blueprint without a default blueprint for class MachinistSpecs::Post"
+        )
+      end
+    end
+
+    describe "blueprint inheritance" do
+      it "should inherit blueprinted attributes from the parent class" do
+        Dad.blueprint do
+          name { "Fred" }
+        end
+        Son.blueprint { }
+        Son.make.name.should == "Fred"
+      end
+
+      it "should override blueprinted attributes in the child class" do
+        Dad.blueprint do
+          name { "Fred" }
+        end
+        Son.blueprint do
+          name { "George" }
+        end
+        Dad.make.name.should == "Fred"
+        Son.make.name.should == "George"
+      end
+
+      it "should inherit from blueprinted attributes in ancestor class" do
+        Grandpa.blueprint do
+          name { "Fred" }
+        end
+        Son.blueprint { }
+        Grandpa.make.name.should == "Fred"
+        lambda { Dad.make }.should raise_error(RuntimeError)
+        Son.make.name.should == "Fred"
+      end
+
+      it "should follow inheritance for named blueprints correctly" do
+        Dad.blueprint do
+          name { "John" }
+        end
+        Dad.blueprint(:special) do
+          name { "Paul" }
+        end
+        Son.blueprint           { }
+        Son.blueprint(:special) { }
+        Son.make(:special).name.should == "John"
+      end
+    end
+
+    describe "clear_blueprints! method" do
+      it "should clear the list of blueprints" do
+        Person.blueprint(:foo){}
+        Person.clear_blueprints!
+        Person.named_blueprints.should == []
+      end
+  
+      it "should clear master blueprint too" do
+        Person.blueprint(:foo) {}
+        Person.blueprint {} # master
+        Person.clear_blueprints!
+        lambda { Person.make }.should raise_error(RuntimeError)
+      end
+    end
+    
+  end
+end