challah 0.5.2 → 0.5.3

data/vendor/bundle/gems/factory_girl-3.0.0/spec/acceptance/syntax/vintage_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+describe "vintage syntax" do
+  before do
+    define_model('User', first_name: :string,
+                         last_name:  :string,
+                         email:      :string)
+
+    Factory.sequence(:email) { |n| "somebody#{n}@example.com" }
+    Factory.define :user do |factory|
+      factory.first_name { 'Bill'               }
+      factory.last_name  { 'Nye'                }
+      factory.email      { Factory.next(:email) }
+    end
+  end
+
+  describe "after making an instance" do
+    before do
+      @instance = Factory(:user, last_name: 'Rye')
+    end
+
+    it "should use attributes from the definition" do
+      @instance.first_name.should == 'Bill'
+    end
+
+    it "should evaluate attribute blocks for each instance" do
+      @instance.email.should =~ /somebody\d+@example.com/
+      Factory(:user).email.should_not == @instance.email
+    end
+  end
+
+  it "raises Factory::SequenceAbuseError" do
+    Factory.define :sequence_abuser, class: User do |factory|
+      factory.first_name { Factory.sequence(:name) }
+    end
+
+    expect {
+      Factory(:sequence_abuser)
+    }.to raise_error(FactoryGirl::SequenceAbuseError)
+  end
+end
+
+describe Factory, "referencing a nonexistent factory as a parent" do
+  it "raises an ArgumentError when trying to use a non-existent factory as parent" do
+    expect {
+      Factory.define(:child, parent: :nonexsitent) {}
+      Factory.build(:child)
+    }.to raise_error(ArgumentError)
+  end
+end
+
+describe "defining a factory" do
+  before do
+    @name    = :user
+    @factory = stub("factory", names: [@name])
+    @proxy   = "proxy"
+    @options = { class: 'magic' }
+    FactoryGirl::Factory.stubs(new: @factory)
+    FactoryGirl::DefinitionProxy.stubs(new: @proxy)
+  end
+
+  it "creates a new factory using the specified name and options" do
+    FactoryGirl::Factory.stubs(new: @factory)
+    Factory.define(@name, @options) {|f| }
+    FactoryGirl::Factory.should have_received(:new).with(@name, @options)
+  end
+
+  it "passes the factory do the block" do
+    yielded = nil
+    Factory.define(@name) do |y|
+      yielded = y
+    end
+    yielded.should == @proxy
+  end
+
+  it "adds the factory to the list of factories" do
+    Factory.define(@name) {|f| }
+    @factory.should == FactoryGirl.factory_by_name(@name)
+  end
+end
+
+describe "after defining a factory" do
+  before do
+    @name    = :user
+    @factory = FactoryGirl::Factory.new(@name)
+
+    FactoryGirl.register_factory(@factory)
+  end
+
+  it "uses Strategy::AttributesFor for Factory.attributes_for" do
+    @factory.stubs(run: "result")
+    Factory.attributes_for(@name, attr: 'value').should == 'result'
+    @factory.should have_received(:run).with(FactoryGirl::Strategy::AttributesFor, attr: 'value')
+  end
+
+  it "uses Strategy::Build for Factory.build" do
+    @factory.stubs(run: "result")
+    Factory.build(@name, attr: 'value').should == 'result'
+    @factory.should have_received(:run).with(FactoryGirl::Strategy::Build, attr: 'value')
+  end
+
+  it "uses Strategy::Create for Factory.create" do
+    @factory.stubs(run: "result")
+    Factory.create(@name, attr: 'value').should == 'result'
+    @factory.should have_received(:run).with(FactoryGirl::Strategy::Create, attr: 'value')
+  end
+
+  it "uses Strategy::Stub for Factory.stub" do
+    @factory.stubs(run: "result")
+    Factory.stub(@name, attr: 'value').should == 'result'
+    @factory.should have_received(:run).with(FactoryGirl::Strategy::Stub, attr: 'value')
+  end
+
+  [:build, :create, :attributes_for, :stub].each do |method|
+    it "raises an ArgumentError on #{method} with a nonexistent factory" do
+      expect { Factory.send(method, :bogus) }.to raise_error(ArgumentError)
+    end
+
+    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
+    end
+  end
+end
+
+describe "defining a sequence" do
+  before do
+    @name = :count
+  end
+
+  it "creates a new sequence" do
+    Factory.sequence(@name)
+    Factory.next(@name).should == 1
+  end
+
+  it "uses the supplied block as the sequence generator" do
+    Factory.sequence(@name) {|n| "user-#{n}" }
+    Factory.next(@name).should == "user-1"
+  end
+
+  it "uses the supplied start_value as the sequence start_value" do
+    Factory.sequence(@name, "A")
+    Factory.next(@name).should == "A"
+  end
+end
+
+describe "after defining a sequence" do
+  before do
+    @name     = :test
+    @sequence = FactoryGirl::Sequence.new(@name) {}
+    @value    = '1 2 5'
+
+    @sequence.stubs(next: @value)
+    FactoryGirl::Sequence.stubs(new: @sequence)
+
+    Factory.sequence(@name) {}
+  end
+
+  it "calls next on the sequence when sent next" do
+    Factory.next(@name)
+    @sequence.should have_received(:next)
+  end
+
+  it "returns the value from the sequence" do
+    Factory.next(@name).should == @value
+  end
+end
+
+describe "an attribute generated by an in-line sequence" do
+  before do
+    define_model('User', username: :string)
+
+    Factory.define :user do |factory|
+      factory.sequence(:username) { |n| "username#{n}" }
+    end
+
+    @username = Factory.attributes_for(:user)[:username]
+  end
+
+  it "matches the correct format" do
+    @username.should =~ /^username\d+$/
+  end
+
+  describe "after the attribute has already been generated once" do
+    before do
+      @another_username = Factory.attributes_for(:user)[:username]
+    end
+
+    it "matches the correct format" do
+      @username.should =~ /^username\d+$/
+    end
+
+    it "is not the same as the first generated value" do
+      @another_username.should_not == @username
+    end
+  end
+end
+
+
+describe "a factory with a parent" do
+  before do
+    define_model("User", username: :string)
+
+    Factory.define(:user) do |factory|
+      factory.username "awesome_username"
+    end
+
+    Factory.define(:boring_user, parent: :user) do |factory|
+      factory.username "boring_username"
+    end
+  end
+
+  it "supports defining parents" do
+    Factory.build(:boring_user).username.should == "boring_username"
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/acceptance/traits_spec.rb

@@ -0,0 +1,421 @@
+require "spec_helper"
+
+describe "an instance generated by a factory with multiple traits" do
+  before do
+    define_model("User",
+                 name:          :string,
+                 admin:         :boolean,
+                 gender:        :string,
+                 email:         :string,
+                 date_of_birth: :date,
+                 great:         :string)
+
+    FactoryGirl.define do
+      factory :user_without_admin_scoping, class: User do
+        admin_trait
+      end
+
+      factory :user do
+        name "John"
+
+        trait :great do
+          great "GREAT!!!"
+        end
+
+        trait :admin do
+          admin true
+        end
+
+        trait :admin_trait do
+          admin true
+        end
+
+        trait :male do
+          name   "Joe"
+          gender "Male"
+        end
+
+        trait :female do
+          name   "Jane"
+          gender "Female"
+        end
+
+        factory :great_user do
+          great
+        end
+
+        factory :admin, traits: [:admin]
+
+        factory :male_user do
+          male
+
+          factory :child_male_user do
+            date_of_birth { Date.parse("1/1/2000") }
+          end
+        end
+
+        factory :female, traits: [:female] do
+          trait :admin do
+            admin true
+            name "Judy"
+          end
+
+          factory :female_great_user do
+            great
+          end
+
+          factory :female_admin_judy, traits: [:admin]
+        end
+
+        factory :female_admin,            traits: [:female, :admin]
+        factory :female_after_male_admin, traits: [:male, :female, :admin]
+        factory :male_after_female_admin, traits: [:female, :male, :admin]
+      end
+
+      trait :email do
+        email { "#{name}@example.com" }
+      end
+
+      factory :user_with_email, class: User, traits: [:email] do
+        name "Bill"
+      end
+    end
+  end
+
+  context "the parent class" do
+    subject      { FactoryGirl.create(:user) }
+    its(:name)   { should == "John" }
+    its(:gender) { should be_nil }
+    it           { should_not be_admin }
+  end
+
+  context "the child class with one trait" do
+    subject      { FactoryGirl.create(:admin) }
+    its(:name)   { should == "John" }
+    its(:gender) { should be_nil }
+    it           { should be_admin }
+  end
+
+  context "the other child class with one trait" do
+    subject      { FactoryGirl.create(:female) }
+    its(:name)   { should == "Jane" }
+    its(:gender) { should == "Female" }
+    it           { should_not be_admin }
+  end
+
+  context "the child with multiple traits" do
+    subject      { FactoryGirl.create(:female_admin) }
+    its(:name)   { should == "Jane" }
+    its(:gender) { should == "Female" }
+    it           { should be_admin }
+  end
+
+  context "the child with multiple traits and overridden attributes" do
+    subject      { FactoryGirl.create(:female_admin, name: "Jill", gender: nil) }
+    its(:name)   { should == "Jill" }
+    its(:gender) { should be_nil }
+    it           { should be_admin }
+  end
+
+  context "the child with multiple traits who override the same attribute" do
+    context "when the male assigns name after female" do
+      subject      { FactoryGirl.create(:male_after_female_admin) }
+      its(:name)   { should == "Joe" }
+      its(:gender) { should == "Male" }
+      it           { should be_admin }
+    end
+
+    context "when the female assigns name after male" do
+      subject      { FactoryGirl.create(:female_after_male_admin) }
+      its(:name)   { should == "Jane" }
+      its(:gender) { should == "Female" }
+      it           { should be_admin }
+    end
+  end
+
+  context "child class with scoped trait and inherited trait" do
+    subject      { FactoryGirl.create(:female_admin_judy) }
+    its(:name)   { should == "Judy" }
+    its(:gender) { should == "Female" }
+    it           { should be_admin }
+  end
+
+  context "factory using global trait" do
+    subject     { FactoryGirl.create(:user_with_email) }
+    its(:name)  { should == "Bill" }
+    its(:email) { should == "Bill@example.com"}
+  end
+
+  context "factory created with alternate syntax for specifying trait" do
+    subject      { FactoryGirl.create(:male_user) }
+    its(:gender) { should == "Male" }
+  end
+
+  context "factory created with alternate syntax where trait name and attribute are the same" do
+    subject     { FactoryGirl.create(:great_user) }
+    its(:great) { should == "GREAT!!!" }
+  end
+
+  context "factory created with alternate syntax where trait name and attribute are the same and attribute is overridden" do
+    subject     { FactoryGirl.create(:great_user, great: "SORT OF!!!") }
+    its(:great) { should == "SORT OF!!!" }
+  end
+
+  context "child factory created where trait attributes are inherited" do
+    subject             { FactoryGirl.create(:child_male_user) }
+    its(:gender)        { should == "Male" }
+    its(:date_of_birth) { should == Date.parse("1/1/2000") }
+  end
+
+  context "factory outside of scope" do
+    subject     { FactoryGirl.create(:user_without_admin_scoping) }
+    it { expect { subject }.to raise_error(ArgumentError, "Trait not registered: admin_trait") }
+  end
+
+  context "child factory using grandparents' trait" do
+    subject     { FactoryGirl.create(:female_great_user) }
+    its(:great) { should == "GREAT!!!" }
+  end
+end
+
+describe "traits with callbacks" do
+  before do
+    define_model("User", name: :string)
+
+    FactoryGirl.define do
+      factory :user do
+        name "John"
+
+        trait :great do
+          after_create {|user| user.name.upcase! }
+        end
+
+        trait :awesome do
+          after_create {|user| user.name = "awesome" }
+        end
+
+        factory :caps_user, traits: [:great]
+        factory :awesome_user, traits: [:great, :awesome]
+
+        factory :caps_user_implicit_trait do
+          great
+        end
+      end
+    end
+  end
+
+  context "when the factory has a trait passed via arguments" do
+    subject    { FactoryGirl.create(:caps_user) }
+    its(:name) { should == "JOHN" }
+  end
+
+  context "when the factory has an implicit trait" do
+    subject    { FactoryGirl.create(:caps_user_implicit_trait) }
+    its(:name) { should == "JOHN" }
+  end
+
+  it "executes callbacks in the order assigned" do
+    FactoryGirl.create(:awesome_user).name.should == "awesome"
+  end
+end
+
+describe "traits added via strategy" do
+  before do
+    define_model("User", name: :string, admin: :boolean)
+
+    FactoryGirl.define do
+      factory :user do
+        name "John"
+
+        trait :admin do
+          admin true
+        end
+
+        trait :great do
+          after_create {|user| user.name.upcase! }
+        end
+      end
+    end
+  end
+
+  context "adding traits in create" do
+    subject { FactoryGirl.create(:user, :admin, :great, name: "Joe") }
+
+    its(:admin) { should be_true }
+    its(:name)  { should == "JOE" }
+
+    it "doesn't modify the user factory" do
+      subject
+      FactoryGirl.create(:user).should_not be_admin
+      FactoryGirl.create(:user).name.should == "John"
+    end
+  end
+
+  context "adding traits in build" do
+    subject { FactoryGirl.build(:user, :admin, :great, name: "Joe") }
+
+    its(:admin) { should be_true }
+    its(:name)  { should == "Joe" }
+  end
+
+  context "adding traits in attributes_for" do
+    subject { FactoryGirl.attributes_for(:user, :admin, :great) }
+
+    its([:admin]) { should be_true }
+    its([:name])  { should == "John" }
+  end
+
+  context "adding traits in build_stubbed" do
+    subject { FactoryGirl.build_stubbed(:user, :admin, :great, name: "Jack") }
+
+    its(:admin) { should be_true }
+    its(:name)  { should == "Jack" }
+  end
+
+  context "adding traits in create_list" do
+    subject { FactoryGirl.create_list(:user, 2, :admin, :great, name: "Joe") }
+
+    its(:length) { should == 2 }
+
+    it "creates all the records" do
+      subject.each do |record|
+        record.admin.should be_true
+        record.name.should == "JOE"
+      end
+    end
+  end
+
+  context "adding traits in build_list" do
+    subject { FactoryGirl.build_list(:user, 2, :admin, :great, name: "Joe") }
+
+    its(:length) { should == 2 }
+
+    it "builds all the records" do
+      subject.each do |record|
+        record.admin.should be_true
+        record.name.should == "Joe"
+      end
+    end
+  end
+end
+
+describe "traits and dynamic attributes that are applied simultaneously" do
+  before do
+    define_model("User", name: :string, email: :string, combined: :string)
+
+    FactoryGirl.define do
+      trait :email do
+        email { "#{name}@example.com" }
+      end
+
+      factory :user do
+        name "John"
+        email
+        combined { "#{name} <#{email}>" }
+      end
+    end
+  end
+
+  subject        { FactoryGirl.build(:user) }
+  its(:name)     { should == "John" }
+  its(:email)    { should == "John@example.com" }
+  its(:combined) { should == "John <John@example.com>" }
+end
+
+describe "applying inline traits" do
+  before do
+    define_model("User") do
+      has_many :posts
+    end
+
+    define_model("Post", user_id: :integer) do
+      belongs_to :user
+    end
+
+    FactoryGirl.define do
+      factory :user do
+        trait :with_post do
+          posts { [ Post.new ] }
+        end
+      end
+    end
+  end
+
+  it "applies traits only to the instance generated for that call" do
+    FactoryGirl.create(:user, :with_post).posts.should_not be_empty
+    FactoryGirl.create(:user).posts.should be_empty
+    FactoryGirl.create(:user, :with_post).posts.should_not be_empty
+  end
+end
+
+describe "inline traits overriding existing attributes" do
+  before do
+    define_model("User", status: :string)
+
+    FactoryGirl.define do
+      factory :user do
+        status "pending"
+
+        trait(:accepted) { status "accepted" }
+        trait(:declined) { status "declined" }
+
+        factory :declined_user, traits: [:declined]
+        factory :extended_declined_user, traits: [:declined] do
+          status "extended_declined"
+        end
+      end
+    end
+  end
+
+  it "returns the default status" do
+    FactoryGirl.build(:user).status.should == "pending"
+  end
+
+  it "prefers inline trait attributes over default attributes" do
+    FactoryGirl.build(:user, :accepted).status.should == "accepted"
+  end
+
+  it "prefers traits on a factory over default attributes" do
+    FactoryGirl.build(:declined_user).status.should == "declined"
+  end
+
+  it "prefers inline trait attributes over traits on a factory" do
+    FactoryGirl.build(:declined_user, :accepted).status.should == "accepted"
+  end
+
+  it "prefers attributes on factories over attributes from non-inline traits" do
+    FactoryGirl.build(:extended_declined_user).status.should == "extended_declined"
+  end
+
+  it "prefers inline traits over attributes on factories" do
+    FactoryGirl.build(:extended_declined_user, :accepted).status.should == "accepted"
+  end
+
+  it "prefers overridden attributes over attributes from traits, inline traits, or attributes on factories" do
+    FactoryGirl.build(:extended_declined_user, :accepted, status: "completely overridden").status.should == "completely overridden"
+  end
+end
+
+describe "making sure the factory is properly compiled the first time we want to instantiate it" do
+  before do
+    define_model("User", role: :string, gender: :string, age: :integer)
+
+    FactoryGirl.define do
+      factory :user do
+        trait(:female) { gender "female" }
+        trait(:admin) { role "admin" }
+
+        factory :female_user do
+          female
+        end
+      end
+    end
+  end
+
+  it "can honor traits on the very first call" do
+    user = FactoryGirl.build(:female_user, :admin, age: 30)
+    user.gender.should == 'female'
+    user.age.should == 30
+    user.role.should == 'admin'
+  end
+end