factory_girl 4.5.0 → 4.7.0

data/spec/acceptance/build_list_spec.rb

@@ -1,56 +0,0 @@
-require 'spec_helper'
-
-describe "build multiple instances" do
-  before do
-    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
-
-  context "without default attributes" do
-    subject { FactoryGirl.build_list(:post, 20) }
-
-    its(:length) { should eq 20 }
-
-    it "builds (but doesn't save) all the posts" do
-      subject.each do |record|
-        expect(record).to be_new_record
-      end
-    end
-
-    it "uses the default factory values" do
-      subject.each do |record|
-        expect(record.title).to eq "Through the Looking Glass"
-      end
-    end
-  end
-
-  context "with default attributes" do
-    subject { FactoryGirl.build_list(:post, 20, title: "The Hunting of the Snark") }
-
-    it "overrides the default values" do
-      subject.each do |record|
-        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
-end

data/spec/acceptance/build_spec.rb

@@ -1,86 +0,0 @@
-require 'spec_helper'
-
-describe "a built instance" do
-  include FactoryGirl::Syntax::Methods
-
-  before do
-    define_model('User')
-
-    define_model('Post', user_id: :integer) do
-      belongs_to :user
-    end
-
-    FactoryGirl.define do
-      factory :user
-
-      factory :post do
-        user
-      end
-    end
-  end
-
-  subject { build(:post) }
-
-  it { should be_new_record }
-
-  it "assigns and saves associations" do
-    expect(subject.user).to be_kind_of(User)
-    expect(subject.user).not_to be_new_record
-  end
-end
-
-describe "a built instance with strategy: :build" do
-  include FactoryGirl::Syntax::Methods
-
-  before do
-    define_model('User')
-
-    define_model('Post', user_id: :integer) do
-      belongs_to :user
-    end
-
-    FactoryGirl.define do
-      factory :user
-
-      factory :post do
-        association(:user, strategy: :build)
-      end
-    end
-  end
-
-  subject { build(:post) }
-
-  it { should be_new_record }
-
-  it "assigns but does not save associations" do
-    expect(subject.user).to be_kind_of(User)
-    expect(subject.user).to be_new_record
-  end
-end
-
-describe "calling `build` with a block" do
-  include FactoryGirl::Syntax::Methods
-
-  before do
-    define_model('Company', name: :string)
-
-    FactoryGirl.define do
-      factory :company
-    end
-  end
-
-  it "passes the built instance" do
-    build(:company, name: 'thoughtbot') do |company|
-      expect(company.name).to eq('thoughtbot')
-    end
-  end
-
-  it "returns the built instance" do
-    expected = nil
-    result = build(:company) do |company|
-      expected = company
-      "hello!"
-    end
-    expect(result).to eq expected
-  end
-end

data/spec/acceptance/build_stubbed_spec.rb

@@ -1,161 +0,0 @@
-require 'spec_helper'
-
-describe "a generated stub instance" do
-  include FactoryGirl::Syntax::Methods
-
-  before do
-    define_model('User')
-
-    define_model('Post', title:   :string,
-                         body:    :string,
-                         age:     :integer,
-                         user_id: :integer) do
-      belongs_to :user
-    end
-
-    FactoryGirl.define do
-      factory :user
-
-      factory :post do
-        title { "default title" }
-        body { "default body" }
-        user
-      end
-    end
-  end
-
-  subject { build_stubbed(:post, title: 'overridden title') }
-
-  it "assigns a default attribute" do
-    expect(subject.body).to eq 'default body'
-  end
-
-  it "assigns an overridden attribute" do
-    expect(subject.title).to eq 'overridden title'
-  end
-
-  it "assigns associations" do
-    expect(subject.user).not_to be_nil
-  end
-
-  it "has an id" do
-    expect(subject.id).to be > 0
-  end
-
-  it "generates unique ids" do
-    other_stub = build_stubbed(:post)
-    expect(subject.id).not_to eq other_stub.id
-  end
-
-  it "isn't a new record" do
-    expect(subject).not_to be_new_record
-  end
-
-  it "disables connection" do
-    expect { subject.connection }.to raise_error(RuntimeError)
-  end
-
-  it "disables update_attribute" do
-    expect { subject.update_attribute(:title, "value") }.to raise_error(RuntimeError)
-  end
-
-  it "disables reload" do
-    expect { subject.reload }.to raise_error(RuntimeError)
-  end
-
-  it "disables destroy" do
-    expect { subject.destroy }.to raise_error(RuntimeError)
-  end
-
-  it "disables save" do
-    expect { subject.save }.to raise_error(RuntimeError)
-  end
-
-  it "disables increment" do
-    expect { subject.increment!(:age) }.to raise_error(RuntimeError)
-  end
-end
-
-describe "calling `build_stubbed` with a block" do
-  include FactoryGirl::Syntax::Methods
-
-  before do
-    define_model('Company', name: :string)
-
-    FactoryGirl.define do
-      factory :company
-    end
-  end
-
-  it "passes the stub instance" do
-    build_stubbed(:company, name: 'thoughtbot') do |company|
-      expect(company.name).to eq('thoughtbot')
-      expect { company.save }.to raise_error(RuntimeError)
-    end
-  end
-
-  it "returns the stub instance" do
-    expected = nil
-    result = build_stubbed(:company) do |company|
-      expected = company
-      "hello!"
-    end
-    expect(result).to eq expected
-  end
-end
-
-describe "defaulting `created_at`" do
-  include FactoryGirl::Syntax::Methods
-
-  before do
-    define_model('ThingWithTimestamp', created_at: :datetime)
-    define_model('ThingWithoutTimestamp')
-
-    FactoryGirl.define do
-      factory :thing_with_timestamp
-      factory :thing_without_timestamp
-    end
-
-    Timecop.freeze 2012, 1, 1
-  end
-
-  it "defaults created_at for objects with created_at" do
-    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
-    expect(build_stubbed(:thing_without_timestamp)).to respond_to(:created_at)
-  end
-
-  it "allows overriding created_at for objects with created_at" do
-    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

@@ -1,253 +0,0 @@
-require 'spec_helper'
-
-describe "callbacks" do
-  before do
-    define_model("User", first_name: :string, last_name: :string)
-
-    FactoryGirl.define do
-      factory :user_with_callbacks, class: :user do
-        after(:stub)   { |user| user.first_name = 'Stubby' }
-        after(:build)  { |user| user.first_name = 'Buildy' }
-        after(:create) { |user| user.last_name  = 'Createy' }
-      end
-
-      factory :user_with_inherited_callbacks, parent: :user_with_callbacks do
-        after(:stub)  { |user| user.last_name  = 'Double-Stubby' }
-        after(:build) { |user| user.first_name = 'Child-Buildy' }
-      end
-    end
-  end
-
-  it "runs the after(:stub) callback when stubbing" do
-    user = FactoryGirl.build_stubbed(:user_with_callbacks)
-    expect(user.first_name).to eq 'Stubby'
-  end
-
-  it "runs the after(:build) callback when building" do
-    user = FactoryGirl.build(:user_with_callbacks)
-    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)
-    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)
-    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)
-    expect(user.first_name).to eq 'Child-Buildy'
-  end
-end
-
-describe 'callbacks using Symbol#to_proc' do
-  before do
-    define_model('User') do
-      def confirmed?
-        !!@confirmed
-      end
-
-      def confirm!
-        @confirmed = true
-      end
-    end
-
-    FactoryGirl.define do
-      factory :user do
-        after :build, &:confirm!
-      end
-    end
-  end
-
-  it 'runs the callback correctly' do
-    user = FactoryGirl.build(:user)
-    expect(user).to be_confirmed
-  end
-end
-
-describe "callbacks using syntax methods without referencing FactoryGirl explicitly" do
-  before do
-    define_model("User", first_name: :string, last_name: :string)
-
-    FactoryGirl.define do
-      sequence(:sequence_1)
-      sequence(:sequence_2)
-      sequence(:sequence_3)
-
-      factory :user do
-        after(:stub)   { generate(:sequence_3) }
-        after(:build)  { |user| user.first_name = generate(:sequence_1) }
-        after(:create) { |user, evaluator| user.last_name = generate(:sequence_2) }
-      end
-    end
-  end
-
-  it "works when the callback has no variables" do
-    FactoryGirl.build_stubbed(:user)
-    expect(FactoryGirl.generate(:sequence_3)).to eq 2
-  end
-
-  it "works when the callback has one variable" do
-    expect(FactoryGirl.build(:user).first_name).to eq 1
-  end
-
-  it "works when the callback has two variables" do
-    expect(FactoryGirl.create(:user).last_name).to eq 1
-  end
-end
-
-describe "custom callbacks" do
-  let(:custom_before) do
-    Class.new do
-      def result(evaluation)
-        evaluation.object.tap do |instance|
-          evaluation.notify(:before_custom, instance)
-        end
-      end
-    end
-  end
-
-  let(:custom_after) do
-    Class.new do
-      def result(evaluation)
-        evaluation.object.tap do |instance|
-          evaluation.notify(:after_custom, instance)
-        end
-      end
-    end
-  end
-
-  let(:totally_custom) do
-    Class.new do
-      def result(evaluation)
-        evaluation.object.tap do |instance|
-          evaluation.notify(:totally_custom, instance)
-        end
-      end
-    end
-  end
-
-  before do
-    define_model("User", first_name: :string, last_name: :string) do
-      def name
-        [first_name, last_name].join(" ")
-      end
-    end
-
-    FactoryGirl.register_strategy(:custom_before, custom_before)
-    FactoryGirl.register_strategy(:custom_after, custom_after)
-    FactoryGirl.register_strategy(:totally_custom, totally_custom)
-
-    FactoryGirl.define do
-      factory :user do
-        first_name "John"
-        last_name  "Doe"
-
-        before(:custom) { |instance| instance.first_name = "Overridden First" }
-        after(:custom)  { |instance| instance.last_name  = "Overridden Last" }
-        callback(:totally_custom) do |instance|
-          instance.first_name = "Totally"
-          instance.last_name  = "Custom"
-        end
-      end
-    end
-  end
-
-  it "runs a custom before callback when the proper strategy executes" do
-    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
-    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
-    expect(FactoryGirl.build(:user).name).to eq "John Doe"
-    expect(FactoryGirl.totally_custom(:user).name).to eq "Totally Custom"
-  end
-end
-
-describe 'binding a callback to multiple callbacks' do
-  before do
-    define_model('User', name: :string)
-
-    FactoryGirl.define do
-      factory :user do
-        callback(:before_create, :after_stub) do |instance|
-          instance.name = instance.name.upcase
-        end
-      end
-    end
-  end
-
-  it 'binds the callback to creation' do
-    expect(FactoryGirl.create(:user, name: 'John Doe').name).to eq 'JOHN DOE'
-  end
-
-  it 'does not bind the callback to building' do
-    expect(FactoryGirl.build(:user, name: 'John Doe').name).to eq 'John Doe'
-  end
-
-  it 'binds the callback to stubbing' do
-    expect(FactoryGirl.build_stubbed(:user, name: 'John Doe').name).to eq 'JOHN DOE'
-  end
-end
-
-describe 'global callbacks' do
-  include FactoryGirl::Syntax::Methods
-
-  before do
-    define_model('User', name: :string)
-    define_model('Company', name: :string)
-
-    FactoryGirl.define do
-      after :build do |object|
-        object.name = case object.class.to_s
-                      when 'User' then 'John Doe'
-                      when 'Company' then 'Acme Suppliers'
-                      end
-      end
-
-      after :create do |object|
-        object.name = "#{object.name}!!!"
-      end
-
-      trait :awesome do
-        after :build do |object|
-          object.name = "___#{object.name}___"
-        end
-
-        after :create do |object|
-          object.name = "A#{object.name}Z"
-        end
-      end
-
-      factory :user do
-        after :build do |user|
-          user.name = user.name.downcase
-        end
-      end
-
-      factory :company do
-        after :build do |company|
-          company.name = company.name.upcase
-        end
-      end
-    end
-  end
-
-  it 'triggers after build callbacks for all factories' do
-    expect(build(:user).name).to eq 'john doe'
-    expect(create(:user).name).to eq 'john doe!!!'
-    expect(create(:user, :awesome).name).to eq 'A___john doe___!!!Z'
-    expect(build(:company).name).to eq 'ACME SUPPLIERS'
-  end
-end