factory_girl 4.5.0 → 4.7.0

data/spec/acceptance/initialize_with_spec.rb

@@ -1,217 +0,0 @@
-require "spec_helper"
-
-describe "initialize_with with non-FG attributes" do
-  include FactoryGirl::Syntax::Methods
-
-  before do
-    define_model("User", name: :string, age: :integer) do
-      def self.construct(name, age)
-        new(name: name, age: age)
-      end
-    end
-
-    FactoryGirl.define do
-      factory :user do
-        initialize_with { User.construct("John Doe", 21) }
-      end
-    end
-  end
-
-  subject    { build(:user) }
-  its(:name) { should eq "John Doe" }
-  its(:age)  { should eq 21 }
-end
-
-describe "initialize_with with FG attributes that are transient" do
-  include FactoryGirl::Syntax::Methods
-
-  before do
-    define_model("User", name: :string) do
-      def self.construct(name)
-        new(name: "#{name} from .construct")
-      end
-    end
-
-    FactoryGirl.define do
-      factory :user do
-        transient do
-          name { "Handsome Chap" }
-        end
-
-        initialize_with { User.construct(name) }
-      end
-    end
-  end
-
-  subject    { build(:user) }
-  its(:name) { should eq "Handsome Chap from .construct" }
-end
-
-describe "initialize_with non-ORM-backed objects" do
-  include FactoryGirl::Syntax::Methods
-
-  before do
-    define_class("ReportGenerator") do
-      attr_reader :name, :data
-
-      def initialize(name, data)
-        @name = name
-        @data = data
-      end
-    end
-
-    FactoryGirl.define do
-      sequence(:random_data) { 5.times.map { Kernel.rand(200) } }
-
-      factory :report_generator do
-        transient do
-          name "My Awesome Report"
-        end
-
-        initialize_with { ReportGenerator.new(name, FactoryGirl.generate(:random_data)) }
-      end
-    end
-  end
-
-  it "allows for overrides" do
-    expect(build(:report_generator, name: "Overridden").name).to eq "Overridden"
-  end
-
-  it "generates random data" do
-    expect(build(:report_generator).data.length).to eq 5
-  end
-end
-
-describe "initialize_with parent and child factories" do
-  before do
-    define_class("Awesome") do
-      attr_reader :name
-
-      def initialize(name)
-        @name = name
-      end
-    end
-
-    FactoryGirl.define do
-      factory :awesome do
-        transient do
-          name "Great"
-        end
-
-        initialize_with { Awesome.new(name) }
-
-        factory :sub_awesome do
-          transient do
-            name "Sub"
-          end
-        end
-
-        factory :super_awesome do
-          initialize_with { Awesome.new("Super") }
-        end
-      end
-    end
-  end
-
-  it "uses the parent's constructor when the child factory doesn't assign it" do
-    expect(FactoryGirl.build(:sub_awesome).name).to eq "Sub"
-  end
-
-  it "allows child factories to override initialize_with" do
-    expect(FactoryGirl.build(:super_awesome).name).to eq "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
-        transient do
-          name "Great"
-        end
-
-        initialize_with { new(name) }
-      end
-    end
-  end
-
-  it "instantiates the correct object" do
-    expect(FactoryGirl.build(:awesome, name: "Awesome name").name).to eq "Awesome name"
-  end
-end
-
-describe "initialize_with doesn't duplicate assignment on attributes accessed from initialize_with" do
-  before do
-    define_class("User") do
-      attr_reader :name
-      attr_accessor :email
-
-      def initialize(name)
-        @name = name
-      end
-    end
-
-    FactoryGirl.define do
-      sequence(:email) { |n| "person#{n}@example.com" }
-
-      factory :user do
-        email
-
-        name { email.gsub(/\@.+/, "") }
-
-        initialize_with { new(name) }
-      end
-    end
-  end
-
-  it "instantiates the correct object" do
-    built_user = FactoryGirl.build(:user)
-    expect(built_user.name).to eq "person1"
-    expect(built_user.email).to eq "person1@example.com"
-  end
-end
-
-describe "initialize_with has access to all attributes for construction" do
-  before do
-    define_class("User") do
-      attr_reader :name, :email, :ignored
-
-      def initialize(attributes = {})
-        @name = attributes[:name]
-        @email = attributes[:email]
-        @ignored = attributes[:ignored]
-      end
-    end
-
-    FactoryGirl.define do
-      sequence(:email) { |n| "person#{n}@example.com" }
-
-      factory :user do
-        transient do
-          ignored "of course!"
-        end
-
-        email
-
-        name { email.gsub(/\@.+/, "") }
-
-        initialize_with { new(attributes) }
-      end
-    end
-  end
-
-  it "assigns attributes correctly" do
-    user_with_attributes = FactoryGirl.build(:user)
-    expect(user_with_attributes.email).to eq "person1@example.com"
-    expect(user_with_attributes.name).to eq "person1"
-    expect(user_with_attributes.ignored).to be_nil
-  end
-end

data/spec/acceptance/keyed_by_class_spec.rb

@@ -1,22 +0,0 @@
-require 'spec_helper'
-
-describe 'finding factories keyed by class instead of symbol' do
-  before do
-    define_model("User") do
-      attr_accessor :name, :email
-    end
-
-    FactoryGirl.define do
-      factory :user do
-        name 'John Doe'
-        sequence(:email) { |n| "person#{n}@example.com" }
-      end
-    end
-  end
-
-  it 'allows interaction based on class name' do
-    user = FactoryGirl.create User, email: 'person@example.com'
-    expect(user.email).to eq 'person@example.com'
-    expect(user.name).to eq 'John Doe'
-  end
-end

data/spec/acceptance/lint_spec.rb

@@ -1,65 +0,0 @@
-require 'spec_helper'
-
-describe 'FactoryGirl.lint' do
-  it 'raises when a factory is invalid' do
-    define_model 'User', name: :string do
-      validates :name, presence: true
-    end
-
-    define_model 'AlwaysValid'
-
-    FactoryGirl.define do
-      factory :user do
-        factory :admin_user
-      end
-
-      factory :always_valid
-    end
-
-    error_message = <<-ERROR_MESSAGE.strip
-The following factories are invalid:
-
-* user - Validation failed: Name can't be blank (ActiveRecord::RecordInvalid)
-* admin_user - Validation failed: Name can't be blank (ActiveRecord::RecordInvalid)
-    ERROR_MESSAGE
-
-    expect do
-      FactoryGirl.lint
-    end.to raise_error FactoryGirl::InvalidFactoryError, error_message
-  end
-
-  it 'does not raise when all factories are valid' do
-    define_model 'User', name: :string do
-      validates :name, presence: true
-    end
-
-    FactoryGirl.define do
-      factory :user do
-        name 'assigned'
-      end
-    end
-
-    expect { FactoryGirl.lint }.not_to raise_error
-  end
-
-  it 'allows for selective linting' do
-    define_model 'InvalidThing', name: :string do
-      validates :name, presence: true
-    end
-
-    define_model 'ValidThing', name: :string
-
-    FactoryGirl.define do
-      factory :valid_thing
-      factory :invalid_thing
-    end
-
-    expect do
-      only_valid_factories = FactoryGirl.factories.reject do |factory|
-        factory.name =~ /invalid/
-      end
-
-      FactoryGirl.lint only_valid_factories
-    end.not_to raise_error
-  end
-end

data/spec/acceptance/modify_factories_spec.rb

@@ -1,184 +0,0 @@
-require "spec_helper"
-
-describe "modifying factories" do
-  include FactoryGirl::Syntax::Methods
-
-  before do
-    define_model('User', name: :string, admin: :boolean, email: :string, login: :string)
-
-    FactoryGirl.define do
-      sequence(:email) { |n| "user#{n}@example.com" }
-
-      factory :user do
-        email
-
-        after(:create) do |user|
-          user.login = user.name.upcase if user.name
-        end
-
-        factory :admin do
-          admin true
-        end
-      end
-    end
-  end
-
-  context "simple modification" do
-    before do
-      FactoryGirl.modify do
-        factory :user do
-          name "Great User"
-        end
-      end
-    end
-
-    subject     { create(:user) }
-    its(:name)  { should eq "Great User" }
-    its(:login) { should eq "GREAT USER" }
-
-    it "doesn't allow the factory to be subsequently defined" do
-      expect do
-        FactoryGirl.define { factory :user }
-      end.to raise_error(FactoryGirl::DuplicateDefinitionError, "Factory already registered: user")
-    end
-
-    it "does allow the factory to be subsequently modified" do
-      FactoryGirl.modify do
-        factory :user do
-          name "Overridden again!"
-        end
-      end
-
-      expect(create(:user).name).to eq "Overridden again!"
-    end
-  end
-
-  context "adding callbacks" do
-    before do
-      FactoryGirl.modify do
-        factory :user do
-          name "Great User"
-          after(:create) do |user|
-            user.name = user.name.downcase
-            user.login = nil
-          end
-        end
-      end
-    end
-
-    subject { create(:user) }
-
-    its(:name)  { should eq "great user" }
-    its(:login) { should be_nil }
-  end
-
-  context "reusing traits" do
-    before do
-      FactoryGirl.define do
-        trait :rockstar do
-          name "Johnny Rockstar!!!"
-        end
-      end
-
-      FactoryGirl.modify do
-        factory :user do
-          rockstar
-          email { "#{name}@example.com" }
-        end
-      end
-    end
-
-    subject     { create(:user) }
-
-    its(:name)  { should eq "Johnny Rockstar!!!" }
-    its(:email) { should eq "Johnny Rockstar!!!@example.com" }
-    its(:login) { should eq "JOHNNY ROCKSTAR!!!" }
-  end
-
-  context "redefining attributes" do
-    before do
-      FactoryGirl.modify do
-        factory :user do
-          email { "#{name}-modified@example.com" }
-          name "Great User"
-        end
-      end
-    end
-
-    context "creating user" do
-      context "without overrides" do
-        subject     { create(:user) }
-
-        its(:name)  { should eq "Great User" }
-        its(:email) { should eq "Great User-modified@example.com" }
-      end
-
-      context "overriding dynamic attributes" do
-        subject     { create(:user, email: "perfect@example.com") }
-
-        its(:name)  { should eq "Great User" }
-        its(:email) { should eq "perfect@example.com" }
-      end
-
-      context "overriding static attributes" do
-        subject     { create(:user, name: "wonderful") }
-
-        its(:name)  { should eq "wonderful" }
-        its(:email) { should eq "wonderful-modified@example.com" }
-      end
-    end
-
-    context "creating admin" do
-      context "without overrides" do
-        subject     { create(:admin) }
-
-        its(:name)  { should eq "Great User" }
-        its(:email) { should eq "Great User-modified@example.com" }
-        its(:admin) { should be_true }
-      end
-
-      context "overriding dynamic attributes" do
-        subject     { create(:admin, email: "perfect@example.com") }
-
-        its(:name)  { should eq "Great User" }
-        its(:email) { should eq "perfect@example.com" }
-        its(:admin) { should be_true }
-      end
-
-      context "overriding static attributes" do
-        subject     { create(:admin, name: "wonderful") }
-
-        its(:name)  { should eq "wonderful" }
-        its(:email) { should eq "wonderful-modified@example.com" }
-        its(:admin) { should be_true }
-      end
-    end
-  end
-
-  it "doesn't overwrite already defined child's attributes" do
-    FactoryGirl.modify do
-      factory :user do
-        admin false
-      end
-    end
-    expect(create(:admin)).to be_admin
-  end
-
-  it "allows for overriding child classes" do
-    FactoryGirl.modify do
-      factory :admin do
-        admin false
-      end
-    end
-
-    expect(create(:admin)).not_to be_admin
-  end
-
-  it "raises an exception if the factory was not defined before" do
-    expect {
-      FactoryGirl.modify do
-        factory :unknown_factory
-      end
-    }.to raise_error(ArgumentError)
-  end
-end