factory_girl 2.0.0.beta1 → 2.0.0.beta2

data/spec/acceptance/syntax/blueprint_spec.rb

@@ -5,17 +5,19 @@ require 'factory_girl/syntax/blueprint'
 
 describe "a blueprint" do
   before do
+    define_model('User', :first_name => :string, :last_name => :string, :email => :string)
+
     Factory.sequence(:email) { |n| "somebody#{n}@example.com" }
     User.blueprint do
-      first_name { 'Bill'               }
-      last_name  { 'Nye'                }
-      email      { Factory.next(:email) }
+      first_name { 'Bill'                     }
+      last_name  { 'Nye'                      }
+      email      { FactoryGirl.create(:email) }
     end
   end
 
   describe "after making an instance" do
     before do
-      @instance = Factory(:user, :last_name => 'Rye')
+      @instance = FactoryGirl.create(:user, :last_name => 'Rye')
     end
 
     it "should use attributes from the blueprint" do
@@ -24,7 +26,7 @@ describe "a blueprint" do
 
     it "should evaluate attribute blocks for each instance" do
       @instance.email.should =~ /somebody\d+@example.com/
-      Factory(:user).email.should_not == @instance.email
+      FactoryGirl.create(:user).email.should_not == @instance.email
     end
   end
 end

data/spec/acceptance/syntax/generate_spec.rb

@@ -5,10 +5,16 @@ require 'factory_girl/syntax/generate'
 
 describe "a factory using generate syntax" do
   before do
-    Factory.define :user do |factory|
-      factory.first_name 'Bill'
-      factory.last_name  'Nye'
-      factory.email      'science@guys.net'
+    define_model('User', :first_name => :string, :last_name => :string, :email => :string) do
+      validates_presence_of :first_name
+    end
+
+    FactoryGirl.define do
+      factory :user do
+        first_name 'Bill'
+        last_name  'Nye'
+        email      'science@guys.net'
+      end
     end
   end
 

data/spec/acceptance/syntax/make_spec.rb

@@ -5,10 +5,13 @@ require 'factory_girl/syntax/make'
 
 describe "a factory using make syntax" do
   before do
-    Factory.define :user do |factory|
-      factory.first_name 'Bill'
-      factory.last_name  'Nye'
-      factory.email      'science@guys.net'
+    define_model('User', :first_name => :string, :last_name => :string)
+
+    FactoryGirl.define do
+      factory :user do
+        first_name 'Bill'
+        last_name  'Nye'
+      end
     end
   end
 

data/spec/acceptance/syntax/sham_spec.rb

@@ -5,21 +5,28 @@ require 'factory_girl/syntax/sham'
 
 describe "a factory using sham syntax" do
   before do
+    define_model('User', :first_name => :string,
+                         :last_name  => :string,
+                         :email      => :string,
+                         :username   => :string)
+
     Sham.name        { "Name" }
     Sham.email       { "somebody#{rand(5)}@example.com" }
-    Sham.user("FOO") { |c| "User-#{c}" }
+    Sham.username("FOO") { |c| "User-#{c}" }
 
-    Factory.define :user do |factory|
-      factory.first_name { Sham.name }
-      factory.last_name  { Sham.name }
-      factory.email      { Sham.email }
-      factory.username   { Sham.user }
+    FactoryGirl.define do
+      factory :user do
+        first_name { Sham.name }
+        last_name  { Sham.name }
+        email      { Sham.email }
+        username   { Sham.username }
+      end
     end
   end
 
   describe "after making an instance" do
     before do
-      @instance = Factory(:user, :last_name => 'Rye')
+      @instance = FactoryGirl.create(:user, :last_name => 'Rye')
     end
 
     it "should support a sham called 'name'" do
@@ -29,7 +36,7 @@ describe "a factory using sham syntax" do
     it "should support shams with starting values" do
       @instance.username.should == 'User-FOO'
     end
-    
+
     it "should use the sham for the email" do
       @instance.email.should =~ /somebody\d@example.com/
     end

data/spec/acceptance/syntax/vintage_spec.rb

@@ -1,13 +1,17 @@
 require 'spec_helper'
 require 'acceptance/acceptance_helper'
 
-describe "default syntax" do
+describe "vintage syntax" do
   before do
+    define_model('User', :first_name => :string,
+                         :last_name  => :string,
+                         :email      => :string)
+
     Factory.sequence(:email) { |n| "somebody#{n}@example.com" }
     Factory.define :user do |factory|
       factory.first_name { 'Bill'               }
       factory.last_name  { 'Nye'                }
-      factory.email      { Factory.next(:email) }
+      factory.email      { Factory(:email) }
     end
   end
 
@@ -31,13 +35,23 @@ describe "default syntax" do
       Factory.define(:object, :default_strategy => :nonexistent) {}
     }.should raise_error(ArgumentError)
   end
+
+  it "should raise Factory::SequenceAbuseError" do
+    Factory.define :sequence_abuser, :class => User do |factory|
+      factory.first_name { Factory.sequence(:name) }
+    end
+
+    lambda {
+      Factory(:sequence_abuser)
+    }.should raise_error(FactoryGirl::SequenceAbuseError)
+  end
 end
 
 describe Factory, "given a parent factory" do
   before do
     @parent = FactoryGirl::Factory.new(:object)
     @parent.define_attribute(FactoryGirl::Attribute::Static.new(:name, 'value'))
-    FactoryGirl.register_factory(@parent)
+    FactoryGirl.register(@parent)
   end
 
   it "should raise an ArgumentError when trying to use a non-existent factory as parent" do
@@ -52,7 +66,7 @@ describe "defining a factory" do
     @name    = :user
     @factory = "factory"
     @proxy   = "proxy"
-    stub(@factory).name { @name }
+    stub(@factory).names { [@name] }
     @options = { :class => 'magic' }
     stub(FactoryGirl::Factory).new { @factory }
     stub(FactoryGirl::DefinitionProxy).new { @proxy }
@@ -73,21 +87,16 @@ describe "defining a factory" do
 
   it "should add the factory to the list of factories" do
     Factory.define(@name) {|f| }
-    @factory.should == FactoryGirl.factories[@name]
-  end
-
-  it "should allow a factory to be found by name" do
-    Factory.define(@name) {|f| }
-    FactoryGirl.factory_by_name(@name).should == @factory
+    @factory.should == FactoryGirl.find(@name)
   end
 end
 
 describe "after defining a factory" do
   before do
     @name    = :user
-    @factory = "factory"
+    @factory = FactoryGirl::Factory.new(@name)
 
-    FactoryGirl.factories[@name] = @factory
+    FactoryGirl.register(@factory)
   end
 
   it "should use Proxy::AttributesFor for Factory.attributes_for" do
@@ -137,33 +146,33 @@ end
 
 describe "defining a sequence" do
   before do
-    @sequence = "sequence"
     @name     = :count
+    @sequence = FactoryGirl::Sequence.new(@name) {}
     stub(FactoryGirl::Sequence).new { @sequence }
   end
 
   it "should create a new sequence" do
-    mock(FactoryGirl::Sequence).new(1) { @sequence }
+    mock(FactoryGirl::Sequence).new(@name, 1) { @sequence }
     Factory.sequence(@name)
   end
 
   it "should use the supplied block as the sequence generator" do
-    stub(FactoryGirl::Sequence).new.yields(1)
+    stub(FactoryGirl::Sequence).new { @sequence }.yields(1)
     yielded = false
     Factory.sequence(@name) {|n| yielded = true }
     (yielded).should be
   end
 
   it "should use the supplied start_value as the sequence start_value" do
-    mock(FactoryGirl::Sequence).new("A") { @sequence }
+    mock(FactoryGirl::Sequence).new(@name, "A") { @sequence }
     Factory.sequence(@name, "A")
   end
 end
 
 describe "after defining a sequence" do
   before do
-    @sequence = "sequence"
     @name     = :test
+    @sequence = FactoryGirl::Sequence.new(@name) {}
     @value    = '1 2 5'
 
     stub(@sequence).next { @value }
@@ -182,3 +191,34 @@ describe "after defining a sequence" do
     Factory.next(@name).should == @value
   end
 end
+
+describe "an attribute generated by an in-line sequence" do
+  before do
+    define_model('User', :username => :string)
+
+    Factory.define :user do |factory|
+      factory.sequence(:username) { |n| "username#{n}" }
+    end
+
+    @username = Factory.attributes_for(:user)[:username]
+  end
+
+  it "should match the correct format" do
+    @username.should =~ /^username\d+$/
+  end
+
+  describe "after the attribute has already been generated once" do
+    before do
+      @another_username = Factory.attributes_for(:user)[:username]
+    end
+
+    it "should match the correct format" do
+      @username.should =~ /^username\d+$/
+    end
+
+    it "should not be the same as the first generated value" do
+      @another_username.should_not == @username
+    end
+  end
+end
+

data/spec/factory_girl/attribute/dynamic_spec.rb

@@ -45,7 +45,7 @@ describe FactoryGirl::Attribute::Dynamic do
   end
 
   it "should raise an error when returning a sequence" do
-    stub(Factory).sequence { FactoryGirl::Sequence.new }
+    stub(Factory).sequence { FactoryGirl::Sequence.new(:email) }
     block = lambda { Factory.sequence(:email) }
     attr = FactoryGirl::Attribute::Dynamic.new(:email, block)
     proxy = stub!.set.subject

data/spec/factory_girl/definition_proxy_spec.rb

@@ -39,12 +39,12 @@ describe FactoryGirl::DefinitionProxy do
 
   describe "adding an attribute using a in-line sequence" do
     it "should create the sequence" do
-      mock(FactoryGirl::Sequence).new(1)
+      mock(FactoryGirl::Sequence).new(:name, 1)
       subject.sequence(:name) {}
     end
 
     it "should create the sequence with a custom default value" do
-      mock(FactoryGirl::Sequence).new("A")
+      mock(FactoryGirl::Sequence).new(:name, "A")
       subject.sequence(:name, "A") {}
     end
 
@@ -113,6 +113,7 @@ describe FactoryGirl::DefinitionProxy do
 
   it "adds an association when passed an undefined method without arguments or a block" do
     name = :user
+    FactoryGirl.register(FactoryGirl::Factory.new(name))
     attr = 'attribute'
     stub(attr).name { name }
     mock(FactoryGirl::Attribute::Association).new(name, name, {}) { attr }
@@ -122,17 +123,18 @@ describe FactoryGirl::DefinitionProxy do
 
   it "adds a sequence when passed an undefined method without arguments or a block" do
     name = :airport
-    proxy = 'proxy'
-    FactoryGirl.sequences[name] = FactoryGirl::Sequence.new { |value| "expected" }
+    FactoryGirl.register(FactoryGirl::Sequence.new(name))
+    attr = 'attribute'
+    stub(attr).name { name }
+    mock(FactoryGirl::Attribute::Association).new(name, name, {}) { attr }
     subject.send(name)
-    stub(proxy).set
-    factory.attributes.last.add_to(proxy)
-    proxy.should have_received.set(name, 'expected')
+    factory.attributes.should include(attr)
   end
 
-  it "registers its factory for an alias" do
-    aliased_name = :guest
-    mock(FactoryGirl).register_factory(factory, :as => aliased_name)
-    subject.aliased_as aliased_name
+  it "delegates to_create" do
+    result = 'expected'
+    mock(factory).to_create { result }
+
+    subject.to_create.should == result
   end
 end

data/spec/factory_girl/factory_spec.rb

@@ -1,30 +1,11 @@
 require 'spec_helper'
 
-describe FactoryGirl::Factory, "registering a factory" do
-  before do
-    @name    = :user
-    @factory = "factory"
-    stub(@factory).name { @name }
-  end
-
-  it "should add the factory to the list of factories" do
-    FactoryGirl.register_factory(@factory)
-    FactoryGirl.factory_by_name(@name).should == @factory
-  end
-
-  it "should not allow a duplicate factory definition" do
-    lambda {
-      2.times { FactoryGirl.register_factory(@factory) }
-    }.should raise_error(FactoryGirl::DuplicateDefinitionError)
-  end
-end
-
 describe FactoryGirl::Factory do
   include DefinesConstants
 
   before do
     @name    = :user
-    @class   = define_constant('User')
+    @class   = define_class('User')
     @factory = FactoryGirl::Factory.new(@name)
   end
 
@@ -88,11 +69,24 @@ describe FactoryGirl::Factory do
     end
 
     it "should return the result from the proxy when running" do
-      mock(@proxy).result() { 'result' }
+      mock(@proxy).result(nil) { 'result' }
       @factory.run(FactoryGirl::Proxy::Build, {}).should == 'result'
     end
   end
 
+  it "passes a custom creation block" do
+    proxy = 'proxy'
+    stub(FactoryGirl::Proxy::Build).new { proxy }
+    stub(proxy).result {}
+    block = lambda {}
+    factory = FactoryGirl::Factory.new(:object)
+    factory.to_create(&block)
+
+    factory.run(FactoryGirl::Proxy::Build, {})
+
+    proxy.should have_received.result(block)
+  end
+
   it "should return associations" do
     factory = FactoryGirl::Factory.new(:post)
     factory.define_attribute(FactoryGirl::Attribute::Association.new(:author, :author, {}))
@@ -265,7 +259,7 @@ describe FactoryGirl::Factory, "with a name ending in s" do
   include DefinesConstants
 
   before do
-    define_constant('Business')
+    define_class('Business')
     @name    = :business
     @class   = Business
     @factory = FactoryGirl::Factory.new(@name)
@@ -291,38 +285,12 @@ describe FactoryGirl::Factory, "with a string for a name" do
   end
 end
 
-describe FactoryGirl::Factory, "registered with a string name" do
-  before do
-    @name    = :string
-    @factory = FactoryGirl::Factory.new(@name)
-    FactoryGirl.register_factory(@factory)
-  end
-
-  it "should store the factory using a symbol" do
-    FactoryGirl.factories[@name].should == @factory
-  end
-end
-
-describe FactoryGirl::Factory, "registered with a custom name" do
-  before do
-    @actual_name = :string
-    @custom_name = :words
-    @factory = FactoryGirl::Factory.new(@actual_name)
-
-    FactoryGirl.register_factory(@factory, :as => @custom_name)
-  end
-
-  it "finds the factory using the custom name" do
-    FactoryGirl.factory_by_name(@custom_name).should == @factory
-  end
-end
-
 describe FactoryGirl::Factory, "for namespaced class" do
   include DefinesConstants
 
   before do
-    define_constant('Admin')
-    define_constant('Admin::Settings')
+    define_class('Admin')
+    define_class('Admin::Settings')
 
     @name  = :settings
     @class = Admin::Settings
@@ -343,8 +311,8 @@ describe FactoryGirl::Factory do
   include DefinesConstants
 
   before do
-    define_constant('User')
-    define_constant('Admin', User)
+    define_class('User')
+    define_class('Admin', User)
   end
 
   it "should raise an ArgumentError when trying to use a non-existent strategy" do
@@ -392,3 +360,12 @@ describe FactoryGirl::Factory, "with an underscore in the name" do
   end
 end
 
+
+describe FactoryGirl::Factory, "with aliases" do
+  it "registers the aliases" do
+    name = :user
+    aliased_name = :guest
+    factory = FactoryGirl::Factory.new(:user, :aliases => [aliased_name])
+    factory.names.should =~ [name, aliased_name]
+  end
+end