factory_girl 4.5.0 → 4.7.0

data/spec/acceptance/transient_attributes_spec.rb

@@ -1,151 +0,0 @@
-require "spec_helper"
-
-describe "transient attributes" do
-  before do
-    define_model("User", name: :string, email: :string)
-
-    FactoryGirl.define do
-      sequence(:name) { |n| "John #{n}" }
-
-      factory :user do
-        transient do
-          four     { 2 + 2 }
-          rockstar true
-          upcased  false
-        end
-
-        name  { "#{FactoryGirl.generate(:name)}#{" - Rockstar" if rockstar}" }
-        email { "#{name.downcase}#{four}@example.com" }
-
-        after(:create) do |user, evaluator|
-          user.name.upcase! if evaluator.upcased
-        end
-      end
-    end
-  end
-
-  context "returning attributes for a factory" do
-    subject { FactoryGirl.attributes_for(:user, rockstar: true) }
-    it { should_not have_key(:four) }
-    it { should_not have_key(:rockstar) }
-    it { should_not have_key(:upcased) }
-    it { should     have_key(:name) }
-    it { should     have_key(:email) }
-  end
-
-  context "with a transient variable assigned" do
-    let(:rockstar)           { FactoryGirl.create(:user, rockstar: true, four: "1234") }
-    let(:rockstar_with_name) { FactoryGirl.create(:user, name: "Jane Doe", rockstar: true) }
-    let(:upcased_rockstar)   { FactoryGirl.create(:user, rockstar: true, upcased: true) }
-    let(:groupie)            { FactoryGirl.create(:user, rockstar: false) }
-
-    it "generates the correct attributes on a rockstar" do
-      expect(rockstar.name).to eq "John 1 - Rockstar"
-      expect(rockstar.email).to eq "john 1 - rockstar1234@example.com"
-    end
-
-    it "generates the correct attributes on an upcased rockstar" do
-      expect(upcased_rockstar.name).to eq "JOHN 1 - ROCKSTAR"
-      expect(upcased_rockstar.email).to eq "john 1 - rockstar4@example.com"
-    end
-
-    it "generates the correct attributes on a groupie" do
-      expect(groupie.name).to eq "John 1"
-      expect(groupie.email).to eq "john 14@example.com"
-    end
-
-    it "generates the correct attributes on a rockstar with a name" do
-      expect(rockstar_with_name.name).to eq "Jane Doe"
-      expect(rockstar_with_name.email).to eq "jane doe4@example.com"
-    end
-  end
-
-  context "without transient variables assigned" do
-    let(:rockstar) { FactoryGirl.create(:user) }
-
-    it "uses the default value of the attribute" do
-      expect(rockstar.name).to eq "John 1 - Rockstar"
-    end
-  end
-
-  context "using aliased 'ignore' method name" do
-    around do |example|
-      cached_silenced = ActiveSupport::Deprecation.silenced
-      ActiveSupport::Deprecation.silenced = true
-      example.run
-      ActiveSupport::Deprecation.silenced = cached_silenced
-    end
-
-    before do
-      FactoryGirl.define do
-        factory :user_using_ignore, class: User do
-          ignore do
-            honorific "Esteemed"
-          end
-
-          name { "#{honorific} Jane Doe" }
-        end
-      end
-    end
-
-    let(:esteemed) { FactoryGirl.create(:user_using_ignore) }
-
-    it "uses the default value of the attribute" do
-      expect(esteemed.name).to eq "Esteemed Jane Doe"
-    end
-  end
-end
-
-describe "transient sequences" do
-  before do
-    define_model("User", name: :string)
-
-    FactoryGirl.define do
-      factory :user do
-        transient do
-          sequence(:counter)
-        end
-
-        name { "John Doe #{counter}" }
-      end
-    end
-  end
-
-  it "increments sequences correctly" do
-    expect(FactoryGirl.build(:user).name).to eq "John Doe 1"
-    expect(FactoryGirl.build(:user).name).to eq "John Doe 2"
-  end
-end
-
-describe "assigning values from a transient attribute" do
-  before do
-    define_class("User") do
-      attr_accessor :foo_id, :foo_name
-    end
-
-    define_class("Foo") do
-      attr_accessor :id, :name
-      def initialize(id, name)
-        @id = id
-        @name = name
-      end
-    end
-
-    FactoryGirl.define do
-      factory :user do
-        transient do
-          foo { Foo.new('id-of-foo', 'name-of-foo')}
-        end
-
-        foo_id   { foo.id }
-        foo_name { foo.name }
-      end
-    end
-  end
-
-  it "does not ignore an _id attribute that is an alias for a transient attribute" do
-    user = FactoryGirl.build(:user, :foo => Foo.new('passed-in-id-of-foo', 'passed-in-name-of-foo'))
-    expect(user.foo_id).to eq 'passed-in-id-of-foo'
-    expect(user.foo_name).to eq 'passed-in-name-of-foo'
-  end
-end

data/spec/factory_girl/aliases_spec.rb

@@ -1,31 +0,0 @@
-require 'spec_helper'
-
-describe FactoryGirl, "aliases" do
-  context "aliases for an attribute" do
-    subject { FactoryGirl.aliases_for(:test) }
-    it      { should include(:test) }
-    it      { should include(:test_id) }
-  end
-
-  context "aliases for a foreign key" do
-    subject { FactoryGirl.aliases_for(:test_id) }
-    it      { should include(:test) }
-    it      { should include(:test_id) }
-  end
-
-  context "aliases for an attribute starting with an underscore" do
-    subject { FactoryGirl.aliases_for(:_id) }
-    it      { should_not include(:id) }
-  end
-end
-
-describe FactoryGirl, "after defining an alias" do
-  before do
-    FactoryGirl.aliases << [/(.*)_suffix/, '\1']
-  end
-
-  subject { FactoryGirl.aliases_for(:test_suffix) }
-
-  it { should include(:test) }
-  it { should include(:test_suffix_id) }
-end

data/spec/factory_girl/attribute/association_spec.rb

@@ -1,28 +0,0 @@
-require 'spec_helper'
-
-describe FactoryGirl::Attribute::Association do
-  let(:name)        { :author }
-  let(:factory)     { :user }
-  let(:overrides)   { { first_name: "John" } }
-  let(:association) { stub("association") }
-
-  subject { FactoryGirl::Attribute::Association.new(name, factory, overrides) }
-  before  { subject.stubs(association: association) }
-
-  it         { should be_association }
-  its(:name) { should eq name }
-
-  it "builds the association when calling the proc" do
-    expect(subject.to_proc.call).to eq association
-  end
-
-  it "builds the association when calling the proc" do
-    subject.to_proc.call
-    expect(subject).to have_received(:association).with(factory, overrides)
-  end
-end
-
-describe FactoryGirl::Attribute::Association, "with a string name" do
-  subject    { FactoryGirl::Attribute::Association.new("name", :user, {}) }
-  its(:name) { should eq :name }
-end

data/spec/factory_girl/attribute/dynamic_spec.rb

@@ -1,52 +0,0 @@
-require 'spec_helper'
-
-describe FactoryGirl::Attribute::Dynamic do
-  let(:name)  { :first_name }
-  let(:block) { -> { } }
-
-  subject { FactoryGirl::Attribute::Dynamic.new(name, false, block) }
-
-  its(:name) { should eq name }
-
-  context "with a block returning a static value" do
-    let(:block) { -> { "value" } }
-
-    it "returns the value when executing the proc" do
-      expect(subject.to_proc.call).to eq "value"
-    end
-  end
-
-  context "with a block returning its block-level variable" do
-    let(:block) { ->(thing) { thing } }
-
-    it "returns self when executing the proc" do
-      expect(subject.to_proc.call).to eq subject
-    end
-  end
-
-  context "with a block referencing an attribute on the attribute" do
-    let(:block)  { -> { attribute_defined_on_attribute } }
-    let(:result) { "other attribute value" }
-
-    before do
-      subject.stubs(attribute_defined_on_attribute: result)
-    end
-
-    it "evaluates the attribute from the attribute" do
-      expect(subject.to_proc.call).to eq result
-    end
-  end
-
-  context "with a block returning a sequence" do
-    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)
-    end
-  end
-end
-
-describe FactoryGirl::Attribute::Dynamic, "with a string name" do
-  subject    { FactoryGirl::Attribute::Dynamic.new("name", false, -> { } ) }
-  its(:name) { should eq :name }
-end

data/spec/factory_girl/attribute/sequence_spec.rb

@@ -1,16 +0,0 @@
-require 'spec_helper'
-
-describe FactoryGirl::Attribute::Sequence do
-  let(:sequence_name) { :name }
-  let(:name)          { :first_name }
-  let(:sequence)      { FactoryGirl::Sequence.new(sequence_name, 5) { |n| "Name #{n}" } }
-
-  subject { FactoryGirl::Attribute::Sequence.new(name, sequence_name, false) }
-  before  { FactoryGirl.register_sequence(sequence) }
-
-  its(:name) { should eq name }
-
-  it "assigns the next value in the sequence" do
-    expect(subject.to_proc.call).to eq "Name 5"
-  end
-end

data/spec/factory_girl/attribute/static_spec.rb

@@ -1,19 +0,0 @@
-require 'spec_helper'
-
-describe FactoryGirl::Attribute::Static do
-  let(:name)  { :first_name }
-  let(:value) { "John" }
-
-  subject { FactoryGirl::Attribute::Static.new(name, value, false) }
-
-  its(:name) { should eq name }
-
-  it "returns the value when executing the proc" do
-    expect(subject.to_proc.call).to eq value
-  end
-end
-
-describe FactoryGirl::Attribute::Static, "with a string name" do
-  subject    { FactoryGirl::Attribute::Static.new("name", nil, false) }
-  its(:name) { should eq :name }
-end

data/spec/factory_girl/attribute_list_spec.rb

@@ -1,143 +0,0 @@
-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, ->(u) { "#{u.full_name}@example.com" }) }
-
-  it "maintains a list of attributes" do
-    subject.define_attribute(static_attribute)
-    expect(subject.to_a).to eq [static_attribute]
-
-    subject.define_attribute(dynamic_attribute)
-    expect(subject.to_a).to eq [static_attribute, dynamic_attribute]
-  end
-
-  it "returns the attribute" do
-    expect(subject.define_attribute(static_attribute)).to eq static_attribute
-    expect(subject.define_attribute(dynamic_attribute)).to eq dynamic_attribute
-  end
-
-  it "raises if an attribute has already been defined" do
-    expect {
-      2.times { subject.define_attribute(static_attribute) }
-    }.to raise_error(FactoryGirl::AttributeDefinitionError, "Attribute already defined: full_name")
-  end
-end
-
-describe FactoryGirl::AttributeList, "#define_attribute with a named attribute list" do
-  subject { FactoryGirl::AttributeList.new(:author) }
-
-  let(:association_with_same_name)      { FactoryGirl::Attribute::Association.new(:author, :author, {}) }
-  let(:association_with_different_name) { FactoryGirl::Attribute::Association.new(:author, :post, {}) }
-
-  it "raises when the attribute is a self-referencing association" do
-    expect { subject.define_attribute(association_with_same_name) }.to raise_error(FactoryGirl::AssociationDefinitionError, "Self-referencing association 'author' in 'author'")
-  end
-
-  it "does not raise when the attribute is not a self-referencing association" do
-    expect { subject.define_attribute(association_with_different_name) }.to_not raise_error
-  end
-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, ->(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|
-      attributes.each { |attribute| list.define_attribute(attribute) }
-    end
-  end
-
-  it "adds attributes in the order defined regardless of attribute type" do
-    subject.define_attribute(full_name_attribute)
-    subject.define_attribute(login_attribute)
-    subject.apply_attributes(list(city_attribute, email_attribute))
-    expect(subject.to_a).to eq [full_name_attribute, login_attribute, city_attribute, email_attribute]
-  end
-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, ->(u) { "#{u.full_name}@example.com" }) }
-  let(:author_attribute)    { FactoryGirl::Attribute::Association.new(:author, :user, {}) }
-  let(:profile_attribute)   { FactoryGirl::Attribute::Association.new(:profile, :profile, {}) }
-
-  before do
-    subject.define_attribute(full_name_attribute)
-    subject.define_attribute(email_attribute)
-    subject.define_attribute(author_attribute)
-    subject.define_attribute(profile_attribute)
-  end
-
-  it "returns associations" do
-    expect(subject.associations.to_a).to eq [author_attribute, profile_attribute]
-  end
-end
-
-describe FactoryGirl::AttributeList, "filter based on ignored attributes" do
-  def build_ignored_attribute(name)
-    FactoryGirl::Attribute::Static.new(name, "value", true)
-  end
-
-  def build_non_ignored_attribute(name)
-    FactoryGirl::Attribute::Static.new(name, "value", false)
-  end
-
-  before do
-    subject.define_attribute(build_ignored_attribute(:comments_count))
-    subject.define_attribute(build_ignored_attribute(:posts_count))
-    subject.define_attribute(build_non_ignored_attribute(:email))
-    subject.define_attribute(build_non_ignored_attribute(:first_name))
-    subject.define_attribute(build_non_ignored_attribute(:last_name))
-  end
-
-  it "filters #ignored attributes" do
-    expect(subject.ignored.map(&:name)).to eq [:comments_count, :posts_count]
-  end
-
-  it "filters #non_ignored attributes" do
-    expect(subject.non_ignored.map(&:name)).to eq [:email, :first_name, :last_name]
-  end
-end
-
-describe FactoryGirl::AttributeList, "generating names" do
-  def build_ignored_attribute(name)
-    FactoryGirl::Attribute::Static.new(name, "value", true)
-  end
-
-  def build_non_ignored_attribute(name)
-    FactoryGirl::Attribute::Static.new(name, "value", false)
-  end
-
-  def build_association(name)
-    FactoryGirl::Attribute::Association.new(name, :user, {})
-  end
-
-  before do
-    subject.define_attribute(build_ignored_attribute(:comments_count))
-    subject.define_attribute(build_ignored_attribute(:posts_count))
-    subject.define_attribute(build_non_ignored_attribute(:email))
-    subject.define_attribute(build_non_ignored_attribute(:first_name))
-    subject.define_attribute(build_non_ignored_attribute(:last_name))
-    subject.define_attribute(build_association(:avatar))
-  end
-
-  it "knows all its #names" do
-    expect(subject.names).to eq [:comments_count, :posts_count, :email, :first_name, :last_name, :avatar]
-  end
-
-  it "knows all its #names for #ignored attributes" do
-    expect(subject.ignored.names).to eq [:comments_count, :posts_count]
-  end
-
-  it "knows all its #names for #non_ignored attributes" do
-    expect(subject.non_ignored.names).to eq [:email, :first_name, :last_name, :avatar]
-  end
-
-  it "knows all its #names for #associations" do
-    expect(subject.associations.names).to eq [:avatar]
-  end
-end