factory_girl 3.1.1 → 3.2.0

data/spec/acceptance/build_stubbed_spec.rb

@@ -52,27 +52,27 @@ describe "a generated stub instance" do
   end
 
   it "disables connection" do
-    lambda { subject.connection }.should raise_error(RuntimeError)
+    expect { subject.connection }.to raise_error(RuntimeError)
   end
 
   it "disables update_attribute" do
-    lambda { subject.update_attribute(:title, "value") }.should raise_error(RuntimeError)
+    expect { subject.update_attribute(:title, "value") }.to raise_error(RuntimeError)
   end
 
   it "disables reload" do
-    lambda { subject.reload }.should raise_error(RuntimeError)
+    expect { subject.reload }.to raise_error(RuntimeError)
   end
 
   it "disables destroy" do
-    lambda { subject.destroy }.should raise_error(RuntimeError)
+    expect { subject.destroy }.to raise_error(RuntimeError)
   end
 
   it "disables save" do
-    lambda { subject.save }.should raise_error(RuntimeError)
+    expect { subject.save }.to raise_error(RuntimeError)
   end
 
   it "disables increment" do
-    lambda { subject.increment!(:age) }.should raise_error(RuntimeError)
+    expect { subject.increment!(:age) }.to raise_error(RuntimeError)
   end
 end
 

data/spec/acceptance/initialize_with_spec.rb

@@ -145,3 +145,29 @@ describe "initialize_with parent and child factories" do
     FactoryGirl.build(:super_awesome).name.should == "Super"
   end
 end
+
+describe "initialize_with implicit constructor" do
+  before do
+    define_class("Awesome") do
+      attr_reader :name
+
+      def initialize(name)
+        @name = name
+      end
+    end
+
+    FactoryGirl.define do
+      factory :awesome do
+        ignore do
+          name "Great"
+        end
+
+        initialize_with { new(name) }
+      end
+    end
+  end
+
+  it "instantiates the correct object" do
+    FactoryGirl.build(:awesome, name: "Awesome name").name.should == "Awesome name"
+  end
+end

data/spec/acceptance/modify_factories_spec.rb

@@ -175,10 +175,10 @@ describe "modifying factories" do
   end
 
   it "raises an exception if the factory was not defined before" do
-    lambda {
+    expect {
       FactoryGirl.modify do
         factory :unknown_factory
       end
-    }.should raise_error(ArgumentError)
+    }.to raise_error(ArgumentError)
   end
 end

data/spec/acceptance/register_strategies_spec.rb

@@ -0,0 +1,120 @@
+require "spec_helper"
+
+shared_context "registering custom strategies" do
+  before do
+    define_class("NamedObject") do
+      attr_accessor :name
+    end
+  end
+
+  let(:custom_strategy) do
+    Class.new do
+      def result(evaluation)
+        evaluation.object.tap do |instance|
+          instance.name = "Custom strategy"
+        end
+      end
+    end
+  end
+end
+
+describe "register custom strategies" do
+  include_context "registering custom strategies"
+
+  before do
+    FactoryGirl.define do
+      factory :named_object do
+        name "Great"
+      end
+    end
+  end
+
+  it "allows overriding default strategies" do
+    FactoryGirl.build(:named_object).name.should == "Great"
+    FactoryGirl.register_strategy(:build, custom_strategy)
+    FactoryGirl.build(:named_object).name.should == "Custom strategy"
+  end
+
+  it "allows adding additional strategies" do
+    FactoryGirl.register_strategy(:insert, custom_strategy)
+
+    FactoryGirl.build(:named_object).name.should == "Great"
+    FactoryGirl.insert(:named_object).name.should == "Custom strategy"
+  end
+end
+
+describe "including FactoryGirl::Syntax::Methods when custom strategies have been declared" do
+  include FactoryGirl::Syntax::Methods
+
+  include_context "registering custom strategies"
+
+  before do
+    FactoryGirl.define do
+      factory :named_object do
+        name "Great"
+      end
+    end
+  end
+
+  it "allows adding additional strategies" do
+    FactoryGirl.register_strategy(:insert, custom_strategy)
+
+    insert(:named_object).name.should == "Custom strategy"
+  end
+end
+
+describe "associations without overriding :strategy" do
+  include_context "registering custom strategies"
+
+  before do
+    define_model("Post", user_id: :integer) do
+      belongs_to :user
+    end
+
+    define_model("User", name: :string)
+
+    FactoryGirl.define do
+      factory :post do
+        user
+      end
+
+      factory :user do
+        name "John Doe"
+      end
+    end
+  end
+
+  it "uses the overridden create strategy to create the association" do
+    FactoryGirl.register_strategy(:create, custom_strategy)
+    post = FactoryGirl.build(:post)
+    post.user.name.should == "Custom strategy"
+  end
+end
+
+describe "associations overriding :strategy" do
+  include_context "registering custom strategies"
+
+  before do
+    define_model("Post", user_id: :integer) do
+      belongs_to :user
+    end
+
+    define_model("User", name: :string)
+
+    FactoryGirl.define do
+      factory :post do
+        association :user, strategy: :insert
+      end
+
+      factory :user do
+        name "John Doe"
+      end
+    end
+  end
+
+  it "uses the overridden create strategy to create the association" do
+    FactoryGirl.register_strategy(:insert, custom_strategy)
+    post = FactoryGirl.build(:post)
+    post.user.name.should == "Custom strategy"
+  end
+end

data/spec/acceptance/skip_create_spec.rb

@@ -0,0 +1,19 @@
+require "spec_helper"
+
+describe "skipping the default create" do
+  before do
+    define_model("User", email: :string)
+
+    FactoryGirl.define do
+      factory :user do
+        skip_create
+
+        email "john@example.com"
+      end
+    end
+  end
+
+  it "doesn't execute anything when creating the instance" do
+    FactoryGirl.create(:user).should_not be_persisted
+  end
+end

data/spec/acceptance/syntax/blueprint_spec.rb

@@ -4,6 +4,8 @@ require 'factory_girl/syntax/blueprint'
 
 describe "a blueprint" do
   before do
+    ActiveSupport::Deprecation.silenced = true
+
     define_model('User', first_name: :string, last_name: :string, email: :string)
 
     FactoryGirl.define do

data/spec/acceptance/syntax/generate_spec.rb

@@ -4,6 +4,8 @@ require 'factory_girl/syntax/generate'
 
 describe "a factory using generate syntax" do
   before do
+    ActiveSupport::Deprecation.silenced = true
+
     define_model('User', first_name: :string, last_name: :string, email: :string) do
       validates_presence_of :first_name
     end

data/spec/acceptance/syntax/make_spec.rb

@@ -4,6 +4,8 @@ require 'factory_girl/syntax/make'
 
 describe "a factory using make syntax" do
   before do
+    ActiveSupport::Deprecation.silenced = true
+
     define_model('User', first_name: :string, last_name: :string)
 
     FactoryGirl.define do

data/spec/acceptance/syntax/vintage_spec.rb

@@ -120,8 +120,8 @@ describe "after defining a factory" 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
+      expect { Factory.send(method, @name.to_s) }.to_not raise_error
+      expect { Factory.send(method, @name.to_sym) }.to_not raise_error
     end
   end
 end

data/spec/acceptance/syntax_methods_within_dynamic_attributes_spec.rb

@@ -0,0 +1,41 @@
+require "spec_helper"
+
+describe "syntax methods within dynamic attributes" do
+  before do
+    define_model("Post", title: :string, user_id: :integer) do
+      belongs_to :user
+
+      def generate
+        "generate result"
+      end
+    end
+    define_model("User", email: :string)
+
+    FactoryGirl.define do
+      sequence(:email_address) {|n| "person-#{n}@example.com" }
+
+      factory :user do
+        email { generate(:email_address) }
+      end
+
+      factory :post do
+        title { generate }
+        user { build(:user) }
+      end
+    end
+  end
+
+  it "can access syntax methods from dynamic attributes" do
+    FactoryGirl.build(:user).email.should == "person-1@example.com"
+    FactoryGirl.attributes_for(:user)[:email].should == "person-2@example.com"
+  end
+
+  it "can access syntax methods from dynamic attributes" do
+    FactoryGirl.build(:post).user.should be_instance_of(User)
+  end
+
+  it "can access methods already existing on the class" do
+    FactoryGirl.build(:post).title.should == "generate result"
+    FactoryGirl.attributes_for(:post)[:title].should be_nil
+  end
+end

data/spec/factory_girl/attribute/dynamic_spec.rb

@@ -2,14 +2,14 @@ require 'spec_helper'
 
 describe FactoryGirl::Attribute::Dynamic do
   let(:name)  { :first_name }
-  let(:block) { lambda { } }
+  let(:block) { -> { } }
 
   subject { FactoryGirl::Attribute::Dynamic.new(name, false, block) }
 
   its(:name) { should == name }
 
   context "with a block returning a static value" do
-    let(:block) { lambda { "value" } }
+    let(:block) { -> { "value" } }
 
     it "returns the value when executing the proc" do
       subject.to_proc.call.should == "value"
@@ -17,7 +17,7 @@ describe FactoryGirl::Attribute::Dynamic do
   end
 
   context "with a block returning its block-level variable" do
-    let(:block) { lambda {|thing| thing } }
+    let(:block) { ->(thing) { thing } }
 
     it "returns self when executing the proc" do
       subject.to_proc.call.should == subject
@@ -25,7 +25,7 @@ describe FactoryGirl::Attribute::Dynamic do
   end
 
   context "with a block referencing an attribute on the attribute" do
-    let(:block)  { lambda { attribute_defined_on_attribute } }
+    let(:block)  { -> { attribute_defined_on_attribute } }
     let(:result) { "other attribute value" }
 
     before do
@@ -38,7 +38,7 @@ describe FactoryGirl::Attribute::Dynamic do
   end
 
   context "with a block returning a sequence" do
-    let(:block) { lambda { FactoryGirl.register_sequence(FactoryGirl::Sequence.new(:email, 1) {|n| "foo#{n}" }) } }
+    let(:block) { -> { FactoryGirl.register_sequence(FactoryGirl::Sequence.new(:email, 1) {|n| "foo#{n}" }) } }
 
     it "raises a sequence abuse error" do
       expect { subject.to_proc.call }.to raise_error(FactoryGirl::SequenceAbuseError)
@@ -47,6 +47,6 @@ describe FactoryGirl::Attribute::Dynamic do
 end
 
 describe FactoryGirl::Attribute::Dynamic, "with a string name" do
-  subject    { FactoryGirl::Attribute::Dynamic.new("name", false, lambda { } ) }
+  subject    { FactoryGirl::Attribute::Dynamic.new("name", false, -> { } ) }
   its(:name) { should == :name }
 end

data/spec/factory_girl/attribute_list_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe FactoryGirl::AttributeList, "#define_attribute" do
   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" }) }
+  let(:dynamic_attribute) { FactoryGirl::Attribute::Dynamic.new(:email, false, ->(u) { "#{u.full_name}@example.com" }) }
 
   it "maintains a list of attributes" do
     subject.define_attribute(static_attribute)
@@ -42,8 +42,8 @@ end
 describe FactoryGirl::AttributeList, "#apply_attributes" do
   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}" }) }
+  let(:email_attribute)     { FactoryGirl::Attribute::Dynamic.new(:email, false, ->(model) { "#{model.full_name}@example.com" }) }
+  let(:login_attribute)     { FactoryGirl::Attribute::Dynamic.new(:login, false, ->(model) { "username-#{model.full_name}" }) }
 
   def list(*attributes)
     FactoryGirl::AttributeList.new.tap do |list|
@@ -61,7 +61,7 @@ end
 
 describe FactoryGirl::AttributeList, "#associations" do
   let(:full_name_attribute) { FactoryGirl::Attribute::Static.new(:full_name, "value", false) }
-  let(:email_attribute)     { FactoryGirl::Attribute::Dynamic.new(:email, false, lambda {|u| "#{u.full_name}@example.com" }) }
+  let(:email_attribute)     { FactoryGirl::Attribute::Dynamic.new(:email, false, ->(u) { "#{u.full_name}@example.com" }) }
   let(:author_attribute)    { FactoryGirl::Attribute::Association.new(:author, :user, {}) }
   let(:profile_attribute)   { FactoryGirl::Attribute::Association.new(:profile, :profile, {}) }
 

data/spec/factory_girl/callback_spec.rb

@@ -2,40 +2,40 @@ require 'spec_helper'
 
 describe FactoryGirl::Callback do
   it "has a name" do
-    FactoryGirl::Callback.new(:after_create, lambda {}).name.should == :after_create
+    FactoryGirl::Callback.new(:after_create, -> {}).name.should == :after_create
   end
 
   it "converts strings to symbols" do
-    FactoryGirl::Callback.new("after_create", lambda {}).name.should == :after_create
+    FactoryGirl::Callback.new("after_create", -> {}).name.should == :after_create
   end
 
   it "runs its block with no parameters" do
     ran_with = nil
-    FactoryGirl::Callback.new(:after_create, lambda { ran_with = [] }).run(:one, :two)
+    FactoryGirl::Callback.new(:after_create, -> { ran_with = [] }).run(:one, :two)
     ran_with.should == []
   end
 
   it "runs its block with one parameter" do
     ran_with = nil
-    FactoryGirl::Callback.new(:after_create, lambda { |one| ran_with = [one] }).run(:one, :two)
+    FactoryGirl::Callback.new(:after_create, ->(one) { ran_with = [one] }).run(:one, :two)
     ran_with.should == [:one]
   end
 
   it "runs its block with two parameters" do
     ran_with = nil
-    FactoryGirl::Callback.new(:after_create, lambda { |one, two| ran_with = [one, two] }).run(:one, :two)
+    FactoryGirl::Callback.new(:after_create, ->(one, two) { ran_with = [one, two] }).run(:one, :two)
     ran_with.should == [:one, :two]
   end
 
   it "allows valid callback names to be assigned" do
     FactoryGirl.callback_names.each do |callback_name|
-      expect { FactoryGirl::Callback.new(callback_name, lambda {}) }.
+      expect { FactoryGirl::Callback.new(callback_name, -> {}) }.
         to_not raise_error(FactoryGirl::InvalidCallbackNameError)
     end
   end
 
   it "raises if an invalid callback name is assigned" do
-    expect { FactoryGirl::Callback.new(:magic_fairies, lambda {}) }.
+    expect { FactoryGirl::Callback.new(:magic_fairies, -> {}) }.
       to raise_error(FactoryGirl::InvalidCallbackNameError, /magic_fairies is not a valid callback name/)
   end
 end

data/spec/factory_girl/definition_proxy_spec.rb

@@ -16,7 +16,7 @@ describe FactoryGirl::DefinitionProxy, "#add_attribute" do
   end
 
   it "declares a dynamic attribute on the factory" do
-    attribute_value = lambda { "dynamic attribute" }
+    attribute_value = -> { "dynamic attribute" }
     proxy.add_attribute(:attribute_name, &attribute_value)
     subject.should have_dynamic_declaration(:attribute_name).with_value(attribute_value)
   end
@@ -38,7 +38,7 @@ describe FactoryGirl::DefinitionProxy, "#add_attribute when the proxy ignores at
   end
 
   it "declares a dynamic attribute on the factory" do
-    attribute_value = lambda { "dynamic attribute" }
+    attribute_value = -> { "dynamic attribute" }
     proxy.add_attribute(:attribute_name, &attribute_value)
     subject.should have_dynamic_declaration(:attribute_name).ignored.with_value(attribute_value)
   end
@@ -77,7 +77,7 @@ describe FactoryGirl::DefinitionProxy, "#method_missing" do
   end
 
   it "declares a dynamic attribute" do
-    attribute_value = lambda { "dynamic attribute" }
+    attribute_value = -> { "dynamic attribute" }
     proxy.attribute_name &attribute_value
     subject.should have_dynamic_declaration(:attribute_name).with_value(attribute_value)
   end
@@ -124,7 +124,7 @@ end
 describe FactoryGirl::DefinitionProxy, "adding callbacks" do
   subject        { FactoryGirl::Definition.new }
   let(:proxy)    { FactoryGirl::DefinitionProxy.new(subject) }
-  let(:callback) { lambda { "my awesome callback!" } }
+  let(:callback) { -> { "my awesome callback!" } }
 
   context "#after_build" do
     before { proxy.after_build(&callback) }
@@ -147,7 +147,7 @@ describe FactoryGirl::DefinitionProxy, "#to_create" do
   let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
 
   it "accepts a block to run in place of #save!" do
-    to_create_block = lambda {|record| record.persist }
+    to_create_block = ->(record) { record.persist }
     proxy.to_create(&to_create_block)
     subject.to_create.should == to_create_block
   end
@@ -168,7 +168,7 @@ describe FactoryGirl::DefinitionProxy, "#factory" do
   end
 
   it "with a block" do
-    child_block = lambda { }
+    child_block = -> { }
     proxy.factory(:child, {}, &child_block)
     proxy.child_factories.should include([:child, {}, child_block])
   end