challah 0.5.2 → 0.5.3

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

@@ -0,0 +1,124 @@
+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
+        ignore 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
+      rockstar.name.should  == "John 1 - Rockstar"
+      rockstar.email.should == "john 1 - rockstar1234@example.com"
+    end
+
+    it "generates the correct attributes on an upcased rockstar" do
+      upcased_rockstar.name.should  == "JOHN 1 - ROCKSTAR"
+      upcased_rockstar.email.should == "john 1 - rockstar4@example.com"
+    end
+
+    it "generates the correct attributes on a groupie" do
+      groupie.name.should  == "John 1"
+      groupie.email.should == "john 14@example.com"
+    end
+
+    it "generates the correct attributes on a rockstar with a name" do
+      rockstar_with_name.name.should  == "Jane Doe"
+      rockstar_with_name.email.should == "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
+      rockstar.name.should == "John 1 - Rockstar"
+    end
+  end
+end
+
+describe "transient sequences" do
+  before do
+    define_model("User", name: :string)
+
+    FactoryGirl.define do
+      factory :user do
+        ignore do
+          sequence(:counter)
+        end
+
+        name { "John Doe #{counter}" }
+      end
+    end
+  end
+
+  it "increments sequences correctly" do
+    FactoryGirl.build(:user).name.should == "John Doe 1"
+    FactoryGirl.build(:user).name.should == "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
+        ignore 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'))
+    user.foo_id.should == 'passed-in-id-of-foo'
+    user.foo_name.should == 'passed-in-name-of-foo'
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/aliases_spec.rb

@@ -0,0 +1,31 @@
+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 Factory, "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/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/attribute/association_spec.rb

@@ -0,0 +1,28 @@
+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 == name }
+
+  it "builds the association when calling the proc" do
+    subject.to_proc.call.should == association
+  end
+
+  it "builds the association when calling the proc" do
+    subject.to_proc.call
+    subject.should 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 == :name }
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/attribute/dynamic_spec.rb

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

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/attribute/sequence_spec.rb

@@ -0,0 +1,16 @@
+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 == name }
+
+  it "assigns the next value in the sequence" do
+    subject.to_proc.call.should == "Name 5"
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/attribute/static_spec.rb

@@ -0,0 +1,19 @@
+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 == name }
+
+  it "returns the value when executing the proc" do
+    subject.to_proc.call.should == value
+  end
+end
+
+describe FactoryGirl::Attribute::Static, "with a string name" do
+  subject    { FactoryGirl::Attribute::Static.new("name", nil, false) }
+  its(:name) { should == :name }
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/attribute_list_spec.rb

@@ -0,0 +1,78 @@
+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, lambda {|u| "#{u.full_name}@example.com" }) }
+
+  it "maintains a list of attributes" do
+    subject.define_attribute(static_attribute)
+    subject.to_a.should == [static_attribute]
+
+    subject.define_attribute(dynamic_attribute)
+    subject.to_a.should == [static_attribute, dynamic_attribute]
+  end
+
+  it "returns the attribute" do
+    subject.define_attribute(static_attribute).should == static_attribute
+    subject.define_attribute(dynamic_attribute).should == 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, lambda {|model| "#{model.full_name}@example.com" }) }
+  let(:login_attribute)     { FactoryGirl::Attribute::Dynamic.new(:login, false, lambda {|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))
+    subject.to_a.should == [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, lambda {|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
+    subject.associations.should == [author_attribute, profile_attribute]
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/attribute_spec.rb

@@ -0,0 +1,16 @@
+require 'spec_helper'
+
+describe FactoryGirl::Attribute do
+  let(:name)  { "user" }
+  subject     { FactoryGirl::Attribute.new(name, false) }
+
+  its(:name) { should == name.to_sym }
+  it { should_not be_association }
+
+  it "raises an error when defining an attribute writer" do
+    error_message = %{factory_girl uses 'f.test value' syntax rather than 'f.test = value'}
+    expect {
+      FactoryGirl::Attribute.new('test=', false)
+    }.to raise_error(FactoryGirl::AttributeDefinitionError, error_message)
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/callback_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe FactoryGirl::Callback do
+  it "has a name" do
+    FactoryGirl::Callback.new(:after_create, lambda {}).name.should == :after_create
+  end
+
+  it "converts strings to symbols" do
+    FactoryGirl::Callback.new("after_create", lambda {}).name.should == :after_create
+  end
+
+  it "runs its block with no parameters" do
+    ran_with = nil
+    FactoryGirl::Callback.new(:after_create, lambda { ran_with = [] }).run(:one, :two)
+    ran_with.should == []
+  end
+
+  it "runs its block with one parameter" do
+    ran_with = nil
+    FactoryGirl::Callback.new(:after_create, lambda { |one| ran_with = [one] }).run(:one, :two)
+    ran_with.should == [:one]
+  end
+
+  it "runs its block with two parameters" do
+    ran_with = nil
+    FactoryGirl::Callback.new(:after_create, lambda { |one, two| ran_with = [one, two] }).run(:one, :two)
+    ran_with.should == [:one, :two]
+  end
+
+  it "allows valid callback names to be assigned" do
+    FactoryGirl.callback_names.each do |callback_name|
+      expect { FactoryGirl::Callback.new(callback_name, lambda {}) }.
+        to_not raise_error(FactoryGirl::InvalidCallbackNameError)
+    end
+  end
+
+  it "raises if an invalid callback name is assigned" do
+    expect { FactoryGirl::Callback.new(:magic_fairies, lambda {}) }.
+      to raise_error(FactoryGirl::InvalidCallbackNameError, /magic_fairies is not a valid callback name/)
+  end
+end

data/vendor/bundle/gems/factory_girl-3.0.0/spec/factory_girl/declaration/implicit_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe FactoryGirl::Declaration::Implicit do
+  let(:name)        { :author }
+  let(:declaration) { FactoryGirl::Declaration::Implicit.new(name) }
+  subject           { declaration.to_attributes.first }
+
+  context "with a known factory" do
+    before do
+      FactoryGirl.factories.stubs(:registered? => true)
+    end
+
+    it { should be_association }
+    its(:factory) { should == name }
+  end
+
+  context "with a known sequence" do
+    before do
+      FactoryGirl.sequences.stubs(:registered? => true)
+    end
+
+    it { should_not be_association }
+    it { should be_a(FactoryGirl::Attribute::Sequence) }
+  end
+end