fabrication 0.6.0 → 0.6.2

data/spec/fabricator_spec.rb

@@ -2,52 +2,61 @@ require 'spec_helper'
 
 describe Fabrication::Fabricator do
 
-  it 'generates a new object every time' do
-    f = Fabrication::Fabricator.new(:person) { first_name '1' }
-    f.fabricate.should_not == f.fabricate
-  end
+  subject { Fabrication::Fabricator }
+
+  describe ".define" do
 
-  context 'with a plain old ruby object' do
+    before(:all) do
+      subject.define(:open_struct) do
+        first_name "Joe"
+        last_name { "Schmoe" }
+      end
+    end
+
+    it "returns the schematic" do
+      subject.define(:something, :class_name => :open_struct) do
+        name "Paul"
+      end.class.should == Fabrication::Schematic
+    end
 
-    let(:fabricator) { Fabrication::Fabricator.new(:person) { first_name '1' } }
+    it "creates a schematic" do
+      subject.schematics[:open_struct].should be
+    end
 
-    it 'fabricates a Person instance' do
-      fabricator.fabricate.instance_of?(Person).should be_true
+    it "has the correct class" do
+      subject.schematics[:open_struct].klass.should == OpenStruct
     end
 
-    it 'uses the base generator' do
-      fabricator.instance_variable_get(:@generator).instance_of?(Fabrication::Generator::Base).should be_true
+    it "has the attributes" do
+      subject.schematics[:open_struct].attributes.size.should == 2
     end
 
   end
 
-  context 'with an activerecord object' do
+  describe ".generate" do
 
-    before(:all) { TestMigration.up }
-    after(:all) { TestMigration.down }
+    context 'without definitions' do
 
-    let(:fabricator) { Fabrication::Fabricator.new(:company) { name '1' } }
+      before { subject.schematics.clear }
 
-    it 'fabricates a Company instance' do
-      fabricator.fabricate.instance_of?(Company).should be_true
-    end
+      it "finds definitions if none exist" do
+        Fabrication::Support.should_receive(:find_definitions)
+        subject.generate(:object)
+      end
 
-    it 'uses the activerecord generator' do
-      fabricator.instance_variable_get(:@generator).instance_of?(Fabrication::Generator::ActiveRecord).should be_true
     end
 
-  end
+    context 'with definitions' do
 
-  context 'with a mongoid document' do
+      it "raises an error if the object can't be fabricated" do
+        lambda { subject.generate(:somenonexistantclass) }.should raise_error(Fabrication::UnfabricatableError)
+      end
 
-    let(:fabricator) { Fabrication::Fabricator.new(:author) { name "Seth Godin" } }
-
-    it 'fabricates a Author instance' do
-      fabricator.fabricate.instance_of?(Author).should be_true
-    end
+      it 'generates a new object every time' do
+        subject.define(:person) { first_name '1' }
+        subject.generate(:person).should_not == subject.generate(:person)
+      end
 
-    it 'uses the activerecord generator' do
-      fabricator.instance_variable_get(:@generator).instance_of?(Fabrication::Generator::Mongoid).should be_true
     end
 
   end

data/spec/generator/active_record_spec.rb

@@ -5,30 +5,45 @@ describe Fabrication::Generator::ActiveRecord do
   before(:all) { TestMigration.up }
   after(:all) { TestMigration.down }
 
-  let(:schematic) do
-    Fabrication::Schematic.new do
-      name 'Company Name'
-      city { |c| c.name.reverse.downcase.titleize }
-      divisions(:count => 2) { |c, i| Fabricate(:division, :company => c, :name => "Division #{i}") }
+  describe ".supports?" do
+    subject { Fabrication::Generator::ActiveRecord }
+    it "returns true for active record objects" do
+      subject.supports?(Company).should be_true
+    end
+    it "returns false for non-active record objects" do
+      subject.supports?(Person).should be_false
     end
   end
 
-  let(:generator) do
-    Fabrication::Generator::ActiveRecord.new(Company, schematic)
-  end
+  describe "#after_generation" do
+    let(:instance) { mock(:instance) }
+    let(:generator) { Fabrication::Generator::ActiveRecord.new(Object) }
 
-  context 'active record object' do
+    before { generator.send(:instance=, instance) }
 
-    let(:company) do
-      generator.generate
+    it "saves with a true save flag" do
+      instance.should_receive(:save)
+      generator.send(:after_generation, {:save => true})
     end
 
-    before(:all) do
-      Fabricator(:division) do
-        name "Division Name"
-      end
+    it "does not save without a true save flag" do
+      instance.should_not_receive(:save)
+      generator.send(:after_generation, {})
+    end
+  end
+
+  describe "#generate" do
+
+    let(:attributes) do
+      Fabrication::Schematic.new(Company) do
+        name 'Company Name'
+        city { |c| c.name.downcase }
+        divisions(:count => 2) { |c, i| Division.create(:company => c, :name => "Division #{i}") }
+      end.attributes
     end
 
+    let(:generator) { Fabrication::Generator::ActiveRecord.new(Company) }
+    let(:company) { generator.generate({:save => true}, attributes) }
     before { company }
 
     it 'does not persist the divisions immediately' do
@@ -36,7 +51,7 @@ describe Fabrication::Generator::ActiveRecord do
     end
 
     it 'passes the object to blocks' do
-      company.city.should == 'Eman Ynapmoc'
+      company.city.should == 'company name'
     end
 
     it 'passes the object and count to blocks' do
@@ -68,18 +83,4 @@ describe Fabrication::Generator::ActiveRecord do
 
   end
 
-  context 'with the build option' do
-
-    let(:company) { Fabricate.build(:company, :name => "Epitaph") }
-
-    it 'creates the record' do
-      company.name.should == 'Epitaph'
-    end
-
-    it 'does not save it to the database' do
-      Company.count.should == 0
-    end
-
-  end
-
 end

data/spec/generator/base_spec.rb

@@ -2,43 +2,48 @@ require 'spec_helper'
 
 describe Fabrication::Generator::Base do
 
-  let(:schematic) do
-    Fabrication::Schematic.new do
-      first_name 'Some'
-      last_name { |person| person.first_name.reverse.capitalize }
-      age 40
-      shoes(:count => 4) { |person, index| "shoe #{index}" }
+  describe ".supports?" do
+    subject { Fabrication::Generator::Base }
+    it "supports any object" do
+      subject.supports?(Object).should be_true
     end
   end
 
-  let(:generator) { Fabrication::Generator::Base.new(Person, schematic) }
-
-  let(:person) do
-    generator.generate({:save => true}, {:first_name => 'Body'})
+  describe "#after_create" do
+    subject { Fabrication::Generator::Base.new(Object) }
+    before { subject.after_create { "something" } }
+    it "stores the after create block" do
+      Proc.should === subject.send(:after_create_block)
+    end
   end
 
-  it 'passes the object to blocks' do
-    person.last_name.should == 'Ydob'
-  end
+  describe "#generate" do
 
-  it 'passes the object and count to blocks' do
-    person.shoes.should == (1..4).map { |i| "shoe #{i}" }
-  end
+    let(:generator) { Fabrication::Generator::Base.new(Person) }
 
-  it 'generates an instance' do
-    person.instance_of?(Person).should be_true
-  end
+    let(:attributes) do
+      Fabrication::Schematic.new(Person) do
+        first_name 'Guy'
+        shoes(:count => 4) do |person, index|
+          "#{person.first_name}'s shoe #{index}"
+        end
+      end.attributes
+    end
 
-  it 'generates the first name immediately' do
-    person.instance_variable_get(:@first_name).should == 'Body'
-  end
+    let(:person) { generator.generate({}, attributes) }
 
-  it 'generates the last name immediately' do
-    person.instance_variable_get(:@last_name).should == 'Ydob'
-  end
+    it 'generates an instance' do
+      person.instance_of?(Person).should be_true
+    end
+
+    it 'passes the object and count to blocks' do
+      person.shoes.should == (1..4).map { |i| "Guy's shoe #{i}" }
+    end
+
+    it 'sets the static value' do
+      person.instance_variable_get(:@first_name).should == 'Guy'
+    end
 
-  it 'generates the age immediately' do
-    person.instance_variable_get(:@age).should == 40
   end
 
 end

data/spec/generator/mongoid_spec.rb

@@ -2,36 +2,31 @@ require 'spec_helper'
 
 describe Fabrication::Generator::Mongoid do
 
-  before(:all) do
-    Fabricator(:book) { title "book title" }
-  end
-
-  let(:schematic) do
-    Fabrication::Schematic.new do
-      name 'Name'
-      handle { |author| author.name.downcase }
-      books(:count => 3) { |author, index| Fabricate(:book, :title => "#{author.name} #{index}", :author => author) }
+  describe ".supports?" do
+    subject { Fabrication::Generator::Mongoid }
+    it "returns true for mongoid objects" do
+      subject.supports?(Author).should be_true
+    end
+    it "returns false for non-mongoid objects" do
+      subject.supports?(Person).should be_false
     end
   end
 
-  let(:generator) { Fabrication::Generator::Mongoid.new(Author, schematic) }
-
-  context 'mongoid object' do
+  describe "#after_generation" do
+    let(:instance) { mock(:instance) }
+    let(:generator) { Fabrication::Generator::Mongoid.new(Object) }
 
-    before { generator.generate({:save => true}, :name => 'Something') }
+    before { generator.send(:instance=, instance) }
 
-    it 'passes the object to blocks' do
-      generator.generate.handle.should == "name"
+    it "saves with a true save flag" do
+      instance.should_receive(:save)
+      generator.send(:after_generation, {:save => true})
     end
 
-    it 'passes the object and count to blocks' do
-      generator.generate.books.map(&:title).should == ["Name 1","Name 2","Name 3"]
+    it "does not save without a true save flag" do
+      instance.should_not_receive(:save)
+      generator.send(:after_generation, {})
     end
-
-    it 'persists the author upon creation' do
-      Author.where(:name => 'Something').first.should be
-    end
-
   end
 
 end

data/spec/schematic_spec.rb

@@ -3,109 +3,111 @@ require 'spec_helper'
 describe Fabrication::Schematic do
 
   let(:schematic) do
-    Fabrication::Schematic.new do
+    Fabrication::Schematic.new(OpenStruct) do
       name "Orgasmo"
       something(:param => 2) { "hi!" }
       another_thing { 25 }
     end
   end
 
-  context "without inheritance" do
-
-    subject { schematic }
-
-    it "stored 'name' correctly" do
-      attribute = subject.attribute(:name)
-      attribute.name.should == :name
-      attribute.params.should be_nil
-      attribute.value.should == "Orgasmo"
+  describe ".new" do
+    it "stores the klass" do
+      schematic.klass.should == OpenStruct
     end
-
-    it "stored 'something' correctly" do
-      attribute = subject.attribute(:something)
-      attribute.name.should == :something
-      attribute.params.should == { :param => 2 }
-      Proc.should === attribute.value
-      attribute.value.call.should == "hi!"
+    it "stores the generator" do
+      schematic.generator.should == Fabrication::Generator::Base
     end
-
-    it "stored 'another_thing' correctly" do
-      attribute = subject.attribute(:another_thing)
-      attribute.name.should == :another_thing
-      attribute.params.should be_nil
-      Proc.should === attribute.value
-      attribute.value.call.should == 25
+    it "stores the attributes" do
+      schematic.attributes.size.should == 3
     end
-
   end
 
-  context "with inheritance" do
-
-    subject do
-      schematic.merge! do
-        name { "Willis" }
-        something "Else!"
-        another_thing(:thats_what => 'she_said') { "Boo-ya!" }
-      end
+  describe "#attribute" do
+    it "returns the requested attribute if it exists" do
+      schematic.attribute(:name).name.should == :name
     end
-
-    it "stored 'name' correctly" do
-      attribute = subject.attribute(:name)
-      attribute.name.should == :name
-      attribute.params.should be_nil
-      Proc.should === attribute.value
-      attribute.value.call.should == "Willis"
+    it "returns nil if it does not exist" do
+      schematic.attribute(:not_there).should be_nil
     end
+  end
 
-    it "stored 'something' correctly" do
-      attribute = subject.attribute(:something)
-      attribute.name.should == :something
-      attribute.params.should be_nil
-      attribute.value.should == "Else!"
+  describe "#attributes" do
+    it "always returns an empty array" do
+      schematic.attributes = nil
+      schematic.attributes.should == []
     end
+  end
+
+  describe "#generate" do
 
-    it "stored 'another_thing' correctly" do
-      attribute = subject.attribute(:another_thing)
-      attribute.name.should == :another_thing
-      attribute.params.should == { :thats_what => 'she_said' }
-      Proc.should === attribute.value
-      attribute.value.call.should == "Boo-ya!"
+    it "generates a new instance" do
+      schematic.generate.should be_kind_of(OpenStruct)
     end
 
   end
 
-  it 'is deep clonable' do
-    schematic2 = schematic.clone
-    schematic.merge! do
-      name "Henry"
-    end
-    schematic.attribute(:name).value.should == 'Henry'
-    schematic2.attribute(:name).value.should == 'Orgasmo'
-  end
+  describe "#merge" do
 
-  it 'allows temporary parameter overrides' do
-    schematic2 = schematic.merge(:name => 'Henry')
-    schematic.attribute(:name).value.should == 'Orgasmo'
-    schematic2.attribute(:name).value.should == 'Henry'
-  end
+    context "without inheritance" do
+
+      subject { schematic }
+
+      it "stored 'name' correctly" do
+        attribute = subject.attribute(:name)
+        attribute.name.should == :name
+        attribute.params.should be_nil
+        attribute.value.should == "Orgasmo"
+      end
+
+      it "stored 'something' correctly" do
+        attribute = subject.attribute(:something)
+        attribute.name.should == :something
+        attribute.params.should == { :param => 2 }
+        Proc.should === attribute.value
+        attribute.value.call.should == "hi!"
+      end
+
+      it "stored 'another_thing' correctly" do
+        attribute = subject.attribute(:another_thing)
+        attribute.name.should == :another_thing
+        attribute.params.should be_nil
+        Proc.should === attribute.value
+        attribute.value.call.should == 25
+      end
 
-  describe ".merge" do
+    end
 
-    context "accepts options and a block parameter" do
+    context "with inheritance" do
 
-      let(:merged) do
-        schematic.merge(:name => "Paul") do
-          name "Barack"
-          something "else"
+      subject do
+        schematic.merge do
+          name { "Willis" }
+          something "Else!"
+          another_thing(:thats_what => 'she_said') { "Boo-ya!" }
         end
       end
 
-      it "sets name to 'Paul'" do
-        merged.attribute(:name).value.should == 'Paul'
+      it "stored 'name' correctly" do
+        attribute = subject.attribute(:name)
+        attribute.name.should == :name
+        attribute.params.should be_nil
+        Proc.should === attribute.value
+        attribute.value.call.should == "Willis"
+      end
+
+      it "stored 'something' correctly" do
+        attribute = subject.attribute(:something)
+        attribute.name.should == :something
+        attribute.params.should be_nil
+        attribute.value.should == "Else!"
       end
 
-      it "sets something to 'else'" do
-        merged.attribute(:something).value.should == 'else'
+      it "stored 'another_thing' correctly" do
+        attribute = subject.attribute(:another_thing)
+        attribute.name.should == :another_thing
+        attribute.params.should == { :thats_what => 'she_said' }
+        Proc.should === attribute.value
+        attribute.value.call.should == "Boo-ya!"
       end
 
     end