factory_girl 2.1.2 → 2.2.0

data/spec/acceptance/syntax/vintage_spec.rb

@@ -29,28 +29,29 @@ describe "vintage syntax" do
     end
   end
 
-  it "should raise an ArgumentError when trying to use a non-existent strategy" do
-    lambda {
+  it "raises an ArgumentError when trying to use a non-existent strategy" do
+    expect {
       Factory.define(:object, :default_strategy => :nonexistent) {}
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 
-  it "should raise Factory::SequenceAbuseError" do
+  it "raises Factory::SequenceAbuseError" do
     Factory.define :sequence_abuser, :class => User do |factory|
       factory.first_name { Factory.sequence(:name) }
     end
 
-    lambda {
+    expect {
       Factory(:sequence_abuser)
-    }.should raise_error(FactoryGirl::SequenceAbuseError)
+    }.to raise_error(FactoryGirl::SequenceAbuseError)
   end
 end
 
 describe Factory, "referencing a nonexistent factory as a parent" do
-  it "should raise an ArgumentError when trying to use a non-existent factory as parent" do
-    lambda {
+  it "raises an ArgumentError when trying to use a non-existent factory as parent" do
+    expect {
       Factory.define(:child, :parent => :nonexsitent) {}
-    }.should raise_error(ArgumentError)
+      Factory.build(:child)
+    }.to raise_error(ArgumentError)
   end
 end
 
@@ -64,13 +65,13 @@ describe "defining a factory" do
     FactoryGirl::DefinitionProxy.stubs(:new => @proxy)
   end
 
-  it "should create a new factory using the specified name and options" do
+  it "creates a new factory using the specified name and options" do
     FactoryGirl::Factory.stubs(:new => @factory)
     Factory.define(@name, @options) {|f| }
     FactoryGirl::Factory.should have_received(:new).with(@name, @options)
   end
 
-  it "should pass the factory do the block" do
+  it "passes the factory do the block" do
     yielded = nil
     Factory.define(@name) do |y|
       yielded = y
@@ -78,7 +79,7 @@ describe "defining a factory" do
     yielded.should == @proxy
   end
 
-  it "should add the factory to the list of factories" do
+  it "adds the factory to the list of factories" do
     Factory.define(@name) {|f| }
     @factory.should == FactoryGirl.factory_by_name(@name)
   end
@@ -92,48 +93,48 @@ describe "after defining a factory" do
     FactoryGirl.register_factory(@factory)
   end
 
-  it "should use Proxy::AttributesFor for Factory.attributes_for" do
+  it "uses Proxy::AttributesFor for Factory.attributes_for" do
     @factory.stubs(:run => "result")
     Factory.attributes_for(@name, :attr => 'value').should == 'result'
     @factory.should have_received(:run).with(FactoryGirl::Proxy::AttributesFor, :attr => 'value')
   end
 
-  it "should use Proxy::Build for Factory.build" do
+  it "uses Proxy::Build for Factory.build" do
     @factory.stubs(:run => "result")
     Factory.build(@name, :attr => 'value').should == 'result'
     @factory.should have_received(:run).with(FactoryGirl::Proxy::Build, :attr => 'value')
   end
 
-  it "should use Proxy::Create for Factory.create" do
+  it "uses Proxy::Create for Factory.create" do
     @factory.stubs(:run => "result")
     Factory.create(@name, :attr => 'value').should == 'result'
     @factory.should have_received(:run).with(FactoryGirl::Proxy::Create, :attr => 'value')
   end
 
-  it "should use Proxy::Stub for Factory.stub" do
+  it "uses Proxy::Stub for Factory.stub" do
     @factory.stubs(:run => "result")
     Factory.stub(@name, :attr => 'value').should == 'result'
     @factory.should have_received(:run).with(FactoryGirl::Proxy::Stub, :attr => 'value')
   end
 
-  it "should use default strategy option as Factory.default_strategy" do
+  it "uses default strategy option as Factory.default_strategy" do
     @factory.stubs(:default_strategy => :create, :run => "result")
     Factory.default_strategy(@name, :attr => 'value').should == 'result'
     @factory.should have_received(:run).with(FactoryGirl::Proxy::Create, :attr => 'value')
   end
 
-  it "should use the default strategy for the global Factory method" do
+  it "uses the default strategy for the global Factory method" do
     @factory.stubs(:default_strategy => :create, :run => "result")
     Factory(@name, :attr => 'value').should == 'result'
     @factory.should have_received(:run).with(FactoryGirl::Proxy::Create, :attr => 'value')
   end
 
   [:build, :create, :attributes_for, :stub].each do |method|
-    it "should raise an ArgumentError on #{method} with a nonexistent factory" do
-      lambda { Factory.send(method, :bogus) }.should raise_error(ArgumentError)
+    it "raises an ArgumentError on #{method} with a nonexistent factory" do
+      expect { Factory.send(method, :bogus) }.to raise_error(ArgumentError)
     end
 
-    it "should recognize either 'name' or :name for Factory.#{method}" do
+    it "recognizes either 'name' or :name for Factory.#{method}" do
       @factory.stubs(:run)
       lambda { Factory.send(method, @name.to_s) }.should_not raise_error
       lambda { Factory.send(method, @name.to_sym) }.should_not raise_error
@@ -146,17 +147,17 @@ describe "defining a sequence" do
     @name = :count
   end
 
-  it "should create a new sequence" do
+  it "creates a new sequence" do
     Factory.sequence(@name)
     Factory.next(@name).should == 1
   end
 
-  it "should use the supplied block as the sequence generator" do
+  it "uses the supplied block as the sequence generator" do
     Factory.sequence(@name) {|n| "user-#{n}" }
     Factory.next(@name).should == "user-1"
   end
 
-  it "should use the supplied start_value as the sequence start_value" do
+  it "uses the supplied start_value as the sequence start_value" do
     Factory.sequence(@name, "A")
     Factory.next(@name).should == "A"
   end
@@ -174,12 +175,12 @@ describe "after defining a sequence" do
     Factory.sequence(@name) {}
   end
 
-  it "should call next on the sequence when sent next" do
+  it "calls next on the sequence when sent next" do
     Factory.next(@name)
     @sequence.should have_received(:next)
   end
 
-  it "should return the value from the sequence" do
+  it "returns the value from the sequence" do
     Factory.next(@name).should == @value
   end
 end
@@ -195,7 +196,7 @@ describe "an attribute generated by an in-line sequence" do
     @username = Factory.attributes_for(:user)[:username]
   end
 
-  it "should match the correct format" do
+  it "matches the correct format" do
     @username.should =~ /^username\d+$/
   end
 
@@ -204,11 +205,11 @@ describe "an attribute generated by an in-line sequence" do
       @another_username = Factory.attributes_for(:user)[:username]
     end
 
-    it "should match the correct format" do
+    it "matches the correct format" do
       @username.should =~ /^username\d+$/
     end
 
-    it "should not be the same as the first generated value" do
+    it "is not the same as the first generated value" do
       @another_username.should_not == @username
     end
   end

data/spec/acceptance/transient_attributes_spec.rb

@@ -8,9 +8,11 @@ describe "transient attributes" do
       sequence(:name) {|n| "John #{n}" }
 
       factory :user do
-        four  { 2 + 2 }.ignore
-        rockstar(true).ignore
-        upcased(false).ignore
+        ignore do
+          four     { 2 + 2 }
+          rockstar true
+          upcased  false
+        end
 
         name  { "#{FactoryGirl.generate(:name)}#{" - Rockstar" if rockstar}" }
         email { "#{name.downcase}#{four}@example.com" }
@@ -66,3 +68,43 @@ describe "transient attributes" do
     end
   end
 end
+
+describe "deprecated way of ignoring attributes" do
+  before do
+    define_model("User", :name => :string)
+
+    FactoryGirl.define do
+      factory :user do
+        rockstar(false).ignore
+
+        name { "John Doe#{" Rockstar" if rockstar}" }
+      end
+    end
+  end
+
+  it "assigns attributes correctly" do
+    FactoryGirl.build(:user, :rockstar => true).name.should == "John Doe Rockstar"
+    FactoryGirl.build(:user).name.should == "John Doe"
+  end
+end
+
+describe "transient sequences" do
+  before do
+    define_model("User", :name => :string)
+
+    FactoryGirl.define do
+      factory :user do
+        ignore do
+          sequence(:counter)
+        end
+
+        name { "John Doe #{counter}" }
+      end
+    end
+  end
+
+  it "increments sequences correctly" do
+    FactoryGirl.build(:user).name.should == "John Doe 1"
+    FactoryGirl.build(:user).name.should == "John Doe 2"
+  end
+end

data/spec/factory_girl/attribute/dynamic_spec.rb

@@ -5,7 +5,7 @@ describe FactoryGirl::Attribute::Dynamic do
   let(:proxy) { stub("proxy", :set => nil) }
   let(:block) { lambda { } }
 
-  subject { FactoryGirl::Attribute::Dynamic.new(name, block) }
+  subject { FactoryGirl::Attribute::Dynamic.new(name, false, block) }
 
   its(:name) { should == name }
 
@@ -14,7 +14,7 @@ describe FactoryGirl::Attribute::Dynamic do
 
     it "calls the block to set a value" do
       subject.add_to(proxy)
-      proxy.should have_received(:set).with(name, "value", false)
+      proxy.should have_received(:set).with(name, "value")
     end
   end
 
@@ -23,7 +23,7 @@ describe FactoryGirl::Attribute::Dynamic do
 
     it "yields the proxy to the block" do
       subject.add_to(proxy)
-      proxy.should have_received(:set).with(name, proxy, false)
+      proxy.should have_received(:set).with(name, proxy)
     end
   end
 
@@ -37,7 +37,7 @@ describe FactoryGirl::Attribute::Dynamic do
 
     it "evaluates the attribute from the proxy" do
       subject.add_to(proxy)
-      proxy.should have_received(:set).with(name, result, false)
+      proxy.should have_received(:set).with(name, result)
     end
   end
 
@@ -51,6 +51,6 @@ describe FactoryGirl::Attribute::Dynamic do
 end
 
 describe FactoryGirl::Attribute::Dynamic, "with a string name" do
-  subject    { FactoryGirl::Attribute::Dynamic.new("name", nil) }
+  subject    { FactoryGirl::Attribute::Dynamic.new("name", nil, false) }
   its(:name) { should == :name }
 end

data/spec/factory_girl/attribute/sequence_spec.rb

@@ -6,7 +6,7 @@ describe FactoryGirl::Attribute::Sequence do
   let(:sequence)      { FactoryGirl::Sequence.new(sequence_name, 5) { |n| "Name #{n}" } }
   let(:proxy)         { stub("proxy") }
 
-  subject { FactoryGirl::Attribute::Sequence.new(name, sequence_name) }
+  subject { FactoryGirl::Attribute::Sequence.new(name, sequence_name, false) }
   before  { FactoryGirl.register_sequence(sequence) }
 
   its(:name) { should == name }

data/spec/factory_girl/attribute/static_spec.rb

@@ -5,18 +5,18 @@ describe FactoryGirl::Attribute::Static do
   let(:value) { "John" }
   let(:proxy) { stub("proxy") }
 
-  subject { FactoryGirl::Attribute::Static.new(name, value) }
+  subject { FactoryGirl::Attribute::Static.new(name, value, false) }
 
   its(:name) { should == name }
 
   it "sets its static value on a proxy" do
     proxy.stubs(:set)
     subject.add_to(proxy)
-    proxy.should have_received(:set).with(name, value, false)
+    proxy.should have_received(:set).with(name, value)
   end
 end
 
 describe FactoryGirl::Attribute::Static, "with a string name" do
-  subject    { FactoryGirl::Attribute::Static.new("name", nil) }
+  subject    { FactoryGirl::Attribute::Static.new("name", nil, false) }
   its(:name) { should == :name }
 end

data/spec/factory_girl/attribute_list_spec.rb

@@ -10,8 +10,8 @@ describe FactoryGirl::AttributeList, "overridable" do
 end
 
 describe FactoryGirl::AttributeList, "#define_attribute" do
-  let(:static_attribute)  { FactoryGirl::Attribute::Static.new(:full_name, "value") }
-  let(:dynamic_attribute) { FactoryGirl::Attribute::Dynamic.new(:email, lambda {|u| "#{u.full_name}@example.com" }) }
+  let(:static_attribute)  { FactoryGirl::Attribute::Static.new(:full_name, "value", false) }
+  let(:dynamic_attribute) { FactoryGirl::Attribute::Dynamic.new(:email, false, lambda {|u| "#{u.full_name}@example.com" }) }
 
   it "maintains a list of attributes" do
     subject.define_attribute(static_attribute)
@@ -33,7 +33,7 @@ describe FactoryGirl::AttributeList, "#define_attribute" do
   end
 
   context "when set as overridable" do
-    let(:static_attribute_with_same_name) { FactoryGirl::Attribute::Static.new(:full_name, "overridden value") }
+    let(:static_attribute_with_same_name) { FactoryGirl::Attribute::Static.new(:full_name, "overridden value", false) }
     before { subject.overridable }
 
     it "redefines the attribute if the name already exists" do
@@ -45,21 +45,6 @@ describe FactoryGirl::AttributeList, "#define_attribute" do
   end
 end
 
-describe FactoryGirl::AttributeList, "#attribute_defined?" do
-  let(:static_attribute)                    { FactoryGirl::Attribute::Static.new(:full_name, "value") }
-  let(:callback_attribute)                  { FactoryGirl::Callback.new(:after_create, lambda { }) }
-  let(:static_attribute_named_after_create) { FactoryGirl::Attribute::Static.new(:after_create, "funky!") }
-
-  it "knows if an attribute has been defined" do
-    subject.attribute_defined?(static_attribute.name).should == false
-
-    subject.define_attribute(static_attribute)
-
-    subject.attribute_defined?(static_attribute.name).should == true
-    subject.attribute_defined?(:undefined_attribute).should == false
-  end
-end
-
 describe FactoryGirl::AttributeList, "#add_callback" do
   let(:proxy_class) { mock("klass") }
   let(:proxy) { FactoryGirl::Proxy.new(proxy_class) }
@@ -73,10 +58,10 @@ describe FactoryGirl::AttributeList, "#add_callback" do
 end
 
 describe FactoryGirl::AttributeList, "#apply_attributes" do
-  let(:full_name_attribute) { FactoryGirl::Attribute::Static.new(:full_name, "John Adams") }
-  let(:city_attribute)      { FactoryGirl::Attribute::Static.new(:city, "Boston") }
-  let(:email_attribute)     { FactoryGirl::Attribute::Dynamic.new(:email, lambda {|model| "#{model.full_name}@example.com" }) }
-  let(:login_attribute)     { FactoryGirl::Attribute::Dynamic.new(:login, lambda {|model| "username-#{model.full_name}" }) }
+  let(:full_name_attribute) { FactoryGirl::Attribute::Static.new(:full_name, "John Adams", false) }
+  let(:city_attribute)      { FactoryGirl::Attribute::Static.new(:city, "Boston", false) }
+  let(:email_attribute)     { FactoryGirl::Attribute::Dynamic.new(:email, false, lambda {|model| "#{model.full_name}@example.com" }) }
+  let(:login_attribute)     { FactoryGirl::Attribute::Dynamic.new(:login, false, lambda {|model| "username-#{model.full_name}" }) }
 
   def list(*attributes)
     FactoryGirl::AttributeList.new.tap do |list|
@@ -105,7 +90,7 @@ describe FactoryGirl::AttributeList, "#apply_attributes" do
 
   it "doesn't overwrite attributes that are already defined" do
     subject.define_attribute(full_name_attribute)
-    attribute_with_same_name = FactoryGirl::Attribute::Static.new(:full_name, "Benjamin Franklin")
+    attribute_with_same_name = FactoryGirl::Attribute::Static.new(:full_name, "Benjamin Franklin", false)
 
     subject.apply_attributes(list(attribute_with_same_name))
     subject.to_a.should == [full_name_attribute]
@@ -135,7 +120,7 @@ describe FactoryGirl::AttributeList, "#apply_attributes" do
 
     it "overwrites attributes that are already defined" do
       subject.define_attribute(full_name_attribute)
-      attribute_with_same_name = FactoryGirl::Attribute::Static.new(:full_name, "Benjamin Franklin")
+      attribute_with_same_name = FactoryGirl::Attribute::Static.new(:full_name, "Benjamin Franklin", false)
 
       subject.apply_attributes(list(attribute_with_same_name))
       subject.to_a.should == [attribute_with_same_name]

data/spec/factory_girl/attribute_spec.rb

@@ -3,7 +3,7 @@ require 'spec_helper'
 describe FactoryGirl::Attribute do
   let(:name)  { "user" }
   let(:proxy) { stub("proxy") }
-  subject     { FactoryGirl::Attribute.new(name) }
+  subject     { FactoryGirl::Attribute.new(name, false) }
 
   its(:name) { should == name.to_sym }
   it { should_not be_association }
@@ -17,7 +17,7 @@ describe FactoryGirl::Attribute do
   it "raises an error when defining an attribute writer" do
     error_message = %{factory_girl uses 'f.test value' syntax rather than 'f.test = value'}
     expect {
-      FactoryGirl::Attribute.new('test=')
+      FactoryGirl::Attribute.new('test=', false)
     }.to raise_error(FactoryGirl::AttributeDefinitionError, error_message)
   end
 
@@ -26,7 +26,7 @@ describe FactoryGirl::Attribute do
   end
 
   it "uses priority to perform comparisons" do
-    second_attribute = FactoryGirl::Attribute.new('name')
+    second_attribute = FactoryGirl::Attribute.new('name', false)
     (subject <=> second_attribute).should be_zero
   end
 end

data/spec/factory_girl/definition_proxy_spec.rb

@@ -4,56 +4,37 @@ describe FactoryGirl::DefinitionProxy do
   let(:factory) { FactoryGirl::Factory.new(:object) }
   subject { FactoryGirl::DefinitionProxy.new(factory) }
 
-  def attributes
-    factory.attributes
-  end
-
-  it "should add a static attribute for type" do
-    subject.type 'value'
-    attributes.to_a.last.should be_kind_of(FactoryGirl::Attribute::Static)
-  end
-
-  it "should add a static attribute for id" do
-    subject.id 'value'
-    attributes.to_a.last.should be_kind_of(FactoryGirl::Attribute::Static)
-  end
-
-  it "should add a static attribute when an attribute is defined with a value" do
+  it "adds a static attribute when an attribute is defined with a value" do
     attribute = stub('attribute', :name => :name)
     FactoryGirl::Attribute::Static.stubs(:new => attribute)
     factory.stubs(:define_attribute)
     subject.add_attribute(:name, 'value')
-    factory.compile
+    factory.ensure_compiled
     factory.should have_received(:define_attribute).with(attribute)
-    FactoryGirl::Attribute::Static.should have_received(:new).with(:name, "value")
+    FactoryGirl::Attribute::Static.should have_received(:new).with(:name, "value", false)
   end
 
-  it "should add a dynamic attribute when an attribute is defined with a block" do
+  it "adds a dynamic attribute when an attribute is defined with a block" do
     attribute = stub('attribute', :name => :name)
     block     = lambda {}
     FactoryGirl::Attribute::Dynamic.stubs(:new => attribute)
     factory.stubs(:define_attribute)
     subject.add_attribute(:name, &block)
-    factory.compile
-    FactoryGirl::Attribute::Dynamic.should have_received(:new).with(:name, block)
+    factory.ensure_compiled
+    FactoryGirl::Attribute::Dynamic.should have_received(:new).with(:name, false, block)
     factory.should have_received(:define_attribute).with(attribute)
   end
 
-  it "should raise for an attribute with a value and a block" do
-    lambda {
+  it "raises for an attribute with a value and a block" do
+    expect {
       subject.add_attribute(:name, 'value') {}
-    }.should raise_error(FactoryGirl::AttributeDefinitionError)
-  end
-
-  it "should add an attribute with a built-in private method" do
-    subject.instance_eval { sleep(0.1) }
-    attributes.map { |attribute| attribute.name }.should == [:sleep]
+    }.to raise_error(FactoryGirl::AttributeDefinitionError)
   end
 
   describe "child factories" do
     its(:child_factories) { should == [] }
 
-    it "should be able to add child factories" do
+    it "is be able to add child factories" do
       block = lambda {}
       subject.factory(:admin, { :aliases => [:great] }, &block)
       subject.child_factories.should == [[:admin, { :aliases => [:great] }, block]]
@@ -61,13 +42,13 @@ describe FactoryGirl::DefinitionProxy do
   end
 
   describe "adding an attribute using a in-line sequence" do
-    it "should create the sequence" do
+    it "creates the sequence" do
       FactoryGirl::Sequence.stubs(:new)
       subject.sequence(:name) {}
       FactoryGirl::Sequence.should have_received(:new).with(:name, 1)
     end
 
-    it "should create the sequence with a custom default value" do
+    it "creates the sequence with a custom default value" do
       FactoryGirl::Sequence.stubs(:new)
       subject.sequence(:name, "A") {}
       FactoryGirl::Sequence.should have_received(:new).with(:name, "A")
@@ -123,15 +104,15 @@ describe FactoryGirl::DefinitionProxy, "adding attributes" do
 
     it "creates a dynamic attribute" do
       subject.add_attribute(attribute_name, &block)
-      factory.compile
-      FactoryGirl::Attribute::Dynamic.should have_received(:new).with(attribute_name, block)
+      factory.ensure_compiled
+      FactoryGirl::Attribute::Dynamic.should have_received(:new).with(attribute_name, false, block)
       factory.should have_received(:define_attribute).with(attribute)
     end
 
     it "creates a dynamic attribute without the method being defined" do
       subject.send(attribute_name, &block)
-      factory.compile
-      FactoryGirl::Attribute::Dynamic.should have_received(:new).with(attribute_name, block)
+      factory.ensure_compiled
+      FactoryGirl::Attribute::Dynamic.should have_received(:new).with(attribute_name, false, block)
       factory.should have_received(:define_attribute).with(attribute)
     end
   end
@@ -141,15 +122,15 @@ describe FactoryGirl::DefinitionProxy, "adding attributes" do
 
     it "creates a static attribute" do
       subject.add_attribute(attribute_name, attribute_value)
-      factory.compile
-      FactoryGirl::Attribute::Static.should have_received(:new).with(attribute_name, attribute_value)
+      factory.ensure_compiled
+      FactoryGirl::Attribute::Static.should have_received(:new).with(attribute_name, attribute_value, false)
       factory.should have_received(:define_attribute).with(attribute)
     end
 
     it "creates a static attribute without the method being defined" do
       subject.send(attribute_name, attribute_value)
-      factory.compile
-      FactoryGirl::Attribute::Static.should have_received(:new).with(attribute_name, attribute_value)
+      factory.ensure_compiled
+      FactoryGirl::Attribute::Static.should have_received(:new).with(attribute_name, attribute_value, false)
       factory.should have_received(:define_attribute).with(attribute)
     end
   end
@@ -180,7 +161,7 @@ describe FactoryGirl::DefinitionProxy, "#association" do
 
     it "defines an association attribute with the factory name" do
       subject.association(association_name, options)
-      factory.compile
+      factory.ensure_compiled
 
       factory.should have_received(:define_attribute).with(attribute)
       FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, factory_name, :name => "John Doe")
@@ -188,7 +169,7 @@ describe FactoryGirl::DefinitionProxy, "#association" do
 
     it "defines an association attribute when the association is called implicitly" do
       subject.send(association_name, options)
-      factory.compile
+      factory.ensure_compiled
 
       factory.should have_received(:define_attribute).with(attribute)
       FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, factory_name, :name => "John Doe")
@@ -200,7 +181,7 @@ describe FactoryGirl::DefinitionProxy, "#association" do
 
     it "defines an association attribute with the association name" do
       subject.association(association_name, options)
-      factory.compile
+      factory.ensure_compiled
 
       factory.should have_received(:define_attribute).with(attribute)
       FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, association_name, options)