factory_girl 4.1.0 → 4.2.0

data/spec/acceptance/attribute_existing_on_object_spec.rb

@@ -15,9 +15,9 @@ describe "declaring attributes on a Factory that are private methods on Object"
 
   subject { FactoryGirl.build(:website, sleep: -5) }
 
-  its(:system) { should == false }
-  its(:link)   { should == "http://example.com" }
-  its(:sleep)  { should == -5 }
+  its(:system) { should eq false }
+  its(:link)   { should eq "http://example.com" }
+  its(:sleep)  { should eq -5 }
 end
 
 describe "assigning overrides that are also private methods on object" do
@@ -42,10 +42,10 @@ describe "assigning overrides that are also private methods on object" do
   end
 
   subject { FactoryGirl.build(:website, format: "Great", y: 12345, some_funky_method: "foobar!") }
-  its(:format)            { should == "Great" }
-  its(:y)                 { should == 12345 }
-  its(:more_format)       { should == "format: Great" }
-  its(:some_funky_method) { should == "foobar!" }
+  its(:format)            { should eq "Great" }
+  its(:y)                 { should eq 12345 }
+  its(:more_format)       { should eq "format: Great" }
+  its(:some_funky_method) { should eq "foobar!" }
 end
 
 describe "accessing methods from the instance within a dynamic attribute that is also a private method on object" do
@@ -64,5 +64,5 @@ describe "accessing methods from the instance within a dynamic attribute that is
   end
 
   subject           { FactoryGirl.build(:website) }
-  its(:more_format) { should == "format: This is an awesome format" }
+  its(:more_format) { should eq "format: This is an awesome format" }
 end

data/spec/acceptance/attributes_for_spec.rb

@@ -34,20 +34,20 @@ describe "a generated attributes hash" do
   subject { attributes_for(:post, title: 'overridden title') }
 
   it "assigns an overridden value" do
-    subject[:title].should == "overridden title"
+    expect(subject[:title]).to eq "overridden title"
   end
 
   it "assigns a default value" do
-    subject[:body].should == "default body"
+    expect(subject[:body]).to eq "default body"
   end
 
   it "assigns a lazy, dependent attribute" do
-    subject[:summary].should == "overridden title"
+    expect(subject[:summary]).to eq "overridden title"
   end
 
   it "doesn't assign associations" do
-    subject.should_not have_key(:user_id)
-    subject.should_not have_key(:user)
+    expect(subject).not_to have_key(:user_id)
+    expect(subject).not_to have_key(:user)
   end
 end
 
@@ -64,16 +64,18 @@ describe "calling `attributes_for` with a block" do
 
   it "passes the hash of attributes" do
     attributes_for(:company, name: 'thoughtbot') do |attributes|
-      attributes[:name].should eq('thoughtbot')
+      expect(attributes[:name]).to eq('thoughtbot')
     end
   end
 
   it "returns the hash of attributes" do
     expected = nil
-    attributes_for(:company) do |attributes|
+
+    result = attributes_for(:company) do |attributes|
       expected = attributes
       "hello!"
-    end.should == expected
+    end
+    expect(result).to eq expected
   end
 end
 
@@ -91,5 +93,5 @@ describe "`attributes_for` for a class whose constructor has required params" do
   end
 
   subject      { FactoryGirl.attributes_for(:user) }
-  its([:name]) { should == "John Doe" }
+  its([:name]) { should eq "John Doe" }
 end

data/spec/acceptance/attributes_from_instance_spec.rb

@@ -17,37 +17,37 @@ describe "calling methods on the model instance" do
 
   context "without the attribute being overridden" do
     it "returns the correct value from the instance" do
-      FactoryGirl.build(:user).age_copy.should == 18
+      expect(FactoryGirl.build(:user).age_copy).to eq 18
     end
 
     it "returns nil during attributes_for" do
-      FactoryGirl.attributes_for(:user)[:age_copy].should be_nil
+      expect(FactoryGirl.attributes_for(:user)[:age_copy]).to be_nil
     end
 
     it "doesn't instantiate a record with attributes_for" do
       User.stubs(:new)
       FactoryGirl.attributes_for(:user)
-      User.should have_received(:new).never
+      expect(User).to have_received(:new).never
     end
   end
 
   context "with the attribute being overridden" do
     it "uses the overridden value" do
-      FactoryGirl.build(:user, age_copy: nil).age_copy.should be_nil
+      expect(FactoryGirl.build(:user, age_copy: nil).age_copy).to be_nil
     end
 
     it "uses the overridden value during attributes_for" do
-      FactoryGirl.attributes_for(:user, age_copy: 25)[:age_copy].should == 25
+      expect(FactoryGirl.attributes_for(:user, age_copy: 25)[:age_copy]).to eq 25
     end
   end
 
   context "with the referenced attribute being overridden" do
     it "uses the overridden value" do
-      FactoryGirl.build(:user, age: nil).age_copy.should be_nil
+      expect(FactoryGirl.build(:user, age: nil).age_copy).to be_nil
     end
 
     it "uses the overridden value during attributes_for" do
-      FactoryGirl.attributes_for(:user, age: 25)[:age_copy].should == 25
+      expect(FactoryGirl.attributes_for(:user, age: 25)[:age_copy]).to eq 25
     end
   end
 end

data/spec/acceptance/attributes_ordered_spec.rb

@@ -33,9 +33,9 @@ describe "a generated attributes hash where order matters" do
     subject { FactoryGirl.build(:child_model) }
 
     it "assigns attributes in the order they're defined with preference to static attributes" do
-      subject[:evaluates_first].should  == 1
-      subject[:evaluates_second].should == 1
-      subject[:evaluates_third].should  == 1
+      expect(subject[:evaluates_first]).to eq 1
+      expect(subject[:evaluates_second]).to eq 1
+      expect(subject[:evaluates_third]).to eq 1
     end
   end
 
@@ -43,9 +43,9 @@ describe "a generated attributes hash where order matters" do
     subject { FactoryGirl.build(:without_parent) }
 
     it "assigns attributes in the order they're defined with preference to static attributes without a parent class" do
-      subject[:evaluates_first].should  == 1
-      subject[:evaluates_second].should == 1
-      subject[:evaluates_third].should  == 1
+      expect(subject[:evaluates_first]).to eq 1
+      expect(subject[:evaluates_second]).to eq 1
+      expect(subject[:evaluates_third]).to eq 1
     end
   end
 end

data/spec/acceptance/build_list_spec.rb

@@ -2,11 +2,12 @@ require 'spec_helper'
 
 describe "build multiple instances" do
   before do
-    define_model('Post', title: :string)
+    define_model('Post', title: :string, position: :integer)
 
     FactoryGirl.define do
       factory(:post) do |post|
         post.title "Through the Looking Glass"
+        post.position { rand(10**4) }
       end
     end
   end
@@ -14,17 +15,17 @@ describe "build multiple instances" do
   context "without default attributes" do
     subject { FactoryGirl.build_list(:post, 20) }
 
-    its(:length) { should == 20 }
+    its(:length) { should eq 20 }
 
     it "builds (but doesn't save) all the posts" do
       subject.each do |record|
-        record.should be_new_record
+        expect(record).to be_new_record
       end
     end
 
     it "uses the default factory values" do
       subject.each do |record|
-        record.title.should == "Through the Looking Glass"
+        expect(record.title).to eq "Through the Looking Glass"
       end
     end
   end
@@ -34,7 +35,21 @@ describe "build multiple instances" do
 
     it "overrides the default values" do
       subject.each do |record|
-        record.title.should == "The Hunting of the Snark"
+        expect(record.title).to eq "The Hunting of the Snark"
+      end
+    end
+  end
+
+  context "with a block" do
+    subject do
+      FactoryGirl.build_list(:post, 20, title: "The Listing of the Block") do |post|
+        post.position = post.id
+      end
+    end
+
+    it "correctly uses the set value" do
+      subject.each_with_index do |record, index|
+        expect(record.position).to eq record.id
       end
     end
   end

data/spec/acceptance/build_spec.rb

@@ -21,13 +21,11 @@ describe "a built instance" do
 
   subject { build(:post) }
 
-  it "isn't saved" do
-    should be_new_record
-  end
+  it { should be_new_record }
 
   it "assigns and saves associations" do
-    subject.user.should be_kind_of(User)
-    subject.user.should_not be_new_record
+    expect(subject.user).to be_kind_of(User)
+    expect(subject.user).not_to be_new_record
   end
 end
 
@@ -52,13 +50,11 @@ describe "a built instance with strategy: :build" do
 
   subject { build(:post) }
 
-  it "isn't saved" do
-    should be_new_record
-  end
+  it { should be_new_record }
 
   it "assigns but does not save associations" do
-    subject.user.should be_kind_of(User)
-    subject.user.should be_new_record
+    expect(subject.user).to be_kind_of(User)
+    expect(subject.user).to be_new_record
   end
 end
 
@@ -75,15 +71,16 @@ describe "calling `build` with a block" do
 
   it "passes the built instance" do
     build(:company, name: 'thoughtbot') do |company|
-      company.name.should eq('thoughtbot')
+      expect(company.name).to eq('thoughtbot')
     end
   end
 
   it "returns the built instance" do
     expected = nil
-    build(:company) do |company|
+    result = build(:company) do |company|
       expected = company
       "hello!"
-    end.should == expected
+    end
+    expect(result).to eq expected
   end
 end

data/spec/acceptance/build_stubbed_spec.rb

@@ -27,28 +27,28 @@ describe "a generated stub instance" do
   subject { build_stubbed(:post, title: 'overridden title') }
 
   it "assigns a default attribute" do
-    subject.body.should == 'default body'
+    expect(subject.body).to eq 'default body'
   end
 
   it "assigns an overridden attribute" do
-    subject.title.should == 'overridden title'
+    expect(subject.title).to eq 'overridden title'
   end
 
   it "assigns associations" do
-    subject.user.should_not be_nil
+    expect(subject.user).not_to be_nil
   end
 
   it "has an id" do
-    subject.id.should > 0
+    expect(subject.id).to be > 0
   end
 
   it "generates unique ids" do
     other_stub = build_stubbed(:post)
-    subject.id.should_not == other_stub.id
+    expect(subject.id).not_to eq other_stub.id
   end
 
   it "isn't a new record" do
-    should_not be_new_record
+    expect(subject).not_to be_new_record
   end
 
   it "disables connection" do
@@ -89,17 +89,18 @@ describe "calling `build_stubbed` with a block" do
 
   it "passes the stub instance" do
     build_stubbed(:company, name: 'thoughtbot') do |company|
-      company.name.should eq('thoughtbot')
+      expect(company.name).to eq('thoughtbot')
       expect { company.save }.to raise_error(RuntimeError)
     end
   end
 
   it "returns the stub instance" do
     expected = nil
-    build_stubbed(:company) do |company|
+    result = build_stubbed(:company) do |company|
       expected = company
       "hello!"
-    end.should == expected
+    end
+    expect(result).to eq expected
   end
 end
 
@@ -115,22 +116,46 @@ describe "defaulting `created_at`" do
       factory :thing_without_timestamp
     end
 
-    Timecop.freeze Time.now
+    Timecop.freeze 2012, 1, 1
   end
 
   it "defaults created_at for objects with created_at" do
-    build_stubbed(:thing_with_timestamp).created_at.should == Time.now
+    expect(build_stubbed(:thing_with_timestamp).created_at).to eq Time.now
+  end
+
+  it "defaults created_at for objects with created_at to the correct time with zone" do
+    original_timezone = ENV['TZ']
+    ENV['TZ'] = 'UTC'
+    Time.zone = 'Eastern Time (US & Canada)'
+
+    expect(build_stubbed(:thing_with_timestamp).created_at.zone).to eq 'EST'
+
+    ENV['TZ'] = original_timezone
   end
 
   it "adds created_at to objects who don't have the method" do
-    build_stubbed(:thing_without_timestamp).should respond_to(:created_at)
+    expect(build_stubbed(:thing_without_timestamp)).to respond_to(:created_at)
   end
 
   it "allows overriding created_at for objects with created_at" do
-    build_stubbed(:thing_with_timestamp, created_at: 3.days.ago).created_at.should == 3.days.ago
+    expect(build_stubbed(:thing_with_timestamp, created_at: 3.days.ago).created_at).to eq 3.days.ago
   end
 
   it "doesn't allow setting created_at on an object that doesn't define it" do
     expect { build_stubbed(:thing_without_timestamp, :created_at => Time.now) }.to raise_error(NoMethodError, /created_at=/)
   end
 end
+
+describe 'defaulting `id`' do
+  before do
+    define_model('Post')
+
+    FactoryGirl.define do
+      factory :post
+    end
+  end
+
+  it 'allows overriding id' do
+    expect(FactoryGirl.build_stubbed(:post, id: 12).id).to eq 12
+  end
+end

data/spec/acceptance/callbacks_spec.rb

@@ -20,29 +20,29 @@ describe "callbacks" do
 
   it "runs the after(:stub) callback when stubbing" do
     user = FactoryGirl.build_stubbed(:user_with_callbacks)
-    user.first_name.should == 'Stubby'
+    expect(user.first_name).to eq 'Stubby'
   end
 
   it "runs the after(:build) callback when building" do
     user = FactoryGirl.build(:user_with_callbacks)
-    user.first_name.should == 'Buildy'
+    expect(user.first_name).to eq 'Buildy'
   end
 
   it "runs both the after(:build) and after(:create) callbacks when creating" do
     user = FactoryGirl.create(:user_with_callbacks)
-    user.first_name.should == 'Buildy'
-    user.last_name.should == 'Createy'
+    expect(user.first_name).to eq 'Buildy'
+    expect(user.last_name).to eq 'Createy'
   end
 
   it "runs both the after(:stub) callback on the factory and the inherited after(:stub) callback" do
     user = FactoryGirl.build_stubbed(:user_with_inherited_callbacks)
-    user.first_name.should == 'Stubby'
-    user.last_name.should == 'Double-Stubby'
+    expect(user.first_name).to eq 'Stubby'
+    expect(user.last_name).to eq 'Double-Stubby'
   end
 
   it "runs child callback after parent callback" do
     user = FactoryGirl.build(:user_with_inherited_callbacks)
-    user.first_name.should == 'Child-Buildy'
+    expect(user.first_name).to eq 'Child-Buildy'
   end
 end
 
@@ -65,15 +65,15 @@ describe "callbacks using syntax methods without referencing FactoryGirl explici
 
   it "works when the callback has no variables" do
     FactoryGirl.build_stubbed(:user)
-    FactoryGirl.generate(:sequence_3).should == 2
+    expect(FactoryGirl.generate(:sequence_3)).to eq 2
   end
 
   it "works when the callback has one variable" do
-    FactoryGirl.build(:user).first_name.should == 1
+    expect(FactoryGirl.build(:user).first_name).to eq 1
   end
 
   it "works when the callback has two variables" do
-    FactoryGirl.create(:user).last_name.should == 1
+    expect(FactoryGirl.create(:user).last_name).to eq 1
   end
 end
 
@@ -135,18 +135,18 @@ describe "custom callbacks" do
   end
 
   it "runs a custom before callback when the proper strategy executes" do
-    FactoryGirl.build(:user).name.should == "John Doe"
-    FactoryGirl.custom_before(:user).name.should == "Overridden First Doe"
+    expect(FactoryGirl.build(:user).name).to eq "John Doe"
+    expect(FactoryGirl.custom_before(:user).name).to eq "Overridden First Doe"
   end
 
   it "runs a custom after callback when the proper strategy executes" do
-    FactoryGirl.build(:user).name.should == "John Doe"
-    FactoryGirl.custom_after(:user).name.should == "John Overridden Last"
+    expect(FactoryGirl.build(:user).name).to eq "John Doe"
+    expect(FactoryGirl.custom_after(:user).name).to eq "John Overridden Last"
   end
 
   it "runs a custom callback without prepending before or after when the proper strategy executes" do
-    FactoryGirl.build(:user).name.should == "John Doe"
-    FactoryGirl.totally_custom(:user).name.should == "Totally Custom"
+    expect(FactoryGirl.build(:user).name).to eq "John Doe"
+    expect(FactoryGirl.totally_custom(:user).name).to eq "Totally Custom"
   end
 end
 
@@ -164,14 +164,14 @@ describe 'binding a callback to multiple callbacks' do
   end
 
   it 'binds the callback to creation' do
-    FactoryGirl.create(:user, name: 'John Doe').name.should == 'JOHN DOE'
+    expect(FactoryGirl.create(:user, name: 'John Doe').name).to eq 'JOHN DOE'
   end
 
   it 'does not bind the callback to building' do
-    FactoryGirl.build(:user, name: 'John Doe').name.should == 'John Doe'
+    expect(FactoryGirl.build(:user, name: 'John Doe').name).to eq 'John Doe'
   end
 
   it 'binds the callback to stubbing' do
-    FactoryGirl.build_stubbed(:user, name: 'John Doe').name.should == 'JOHN DOE'
+    expect(FactoryGirl.build_stubbed(:user, name: 'John Doe').name).to eq 'JOHN DOE'
   end
 end