factory_girl 2.0.4 → 2.0.5

data/spec/acceptance/traits_spec.rb

@@ -1,5 +1,4 @@
 require "spec_helper"
-require "acceptance/acceptance_helper"
 
 describe "an instance generated by a factory with multiple traits" do
   before do

data/spec/acceptance/transient_attributes_spec.rb

@@ -0,0 +1,68 @@
+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
+        four  { 2 + 2 }.ignore
+        rockstar(true).ignore
+        upcased(false).ignore
+
+        name  { "#{FactoryGirl.generate(:name)}#{" - Rockstar" if rockstar}" }
+        email { "#{name.downcase}#{four}@example.com" }
+
+        after_create do |user, proxy|
+          user.name.upcase! if proxy.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

data/spec/factory_girl/aliases_spec.rb

@@ -1,33 +1,31 @@
 require 'spec_helper'
 
-describe Factory, "aliases" do
-
-  it "should include an attribute as an alias for itself by default" do
-    FactoryGirl.aliases_for(:test).should include(:test)
+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
 
-  it "should include the root of a foreign key as an alias by default" do
-    FactoryGirl.aliases_for(:test_id).should include(:test)
+  context "aliases for a foreign key" do
+    subject { FactoryGirl.aliases_for(:test_id) }
+    it      { should include(:test) }
+    it      { should include(:test_id) }
   end
 
-  it "should include an attribute's foreign key as an alias by default" do
-    FactoryGirl.aliases_for(:test).should include(:test_id)
+  context "aliases for an attribute starting with an underscore" do
+    subject { FactoryGirl.aliases_for(:_id) }
+    it      { should_not include(:id) }
   end
+end
 
-  it "should NOT include an attribute as an alias when it starts with underscore" do
-    FactoryGirl.aliases_for(:_id).should_not include(:id)
+describe Factory, "after defining an alias" do
+  before do
+    Factory.alias(/(.*)_suffix/, '\1')
   end
 
-  describe "after adding an alias" do
-
-    before do
-      Factory.alias(/(.*)_suffix/, '\1')
-    end
-
-    it "should return the alias in the aliases list" do
-      FactoryGirl.aliases_for(:test_suffix).should include(:test)
-    end
-
-  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,33 +1,25 @@
 require 'spec_helper'
 
 describe FactoryGirl::Attribute::Association do
-  before do
-    @name      = :author
-    @factory   = :user
-    @overrides = { :first_name => 'John' }
-    @attr      = FactoryGirl::Attribute::Association.new(@name, @factory, @overrides)
-  end
+  let(:name)      { :author }
+  let(:factory)   { :user }
+  let(:overrides) { { :first_name => "John" } }
+  let(:proxy)     { stub("proxy") }
 
-  it "should have a name" do
-    @attr.name.should == @name
-  end
+  subject       { FactoryGirl::Attribute::Association.new(name, factory, overrides) }
 
-  it "is an association" do
-    @attr.should be_association
-  end
+  it            { should be_association }
+  its(:name)    { should == name }
+  its(:factory) { should == factory }
 
-  it "should have a factory" do
-    @attr.factory.should == @factory
-  end
-
-  it "should tell the proxy to associate when being added to a proxy" do
-    proxy = "proxy"
-    stub(proxy).associate
-    @attr.add_to(proxy)
-    proxy.should have_received.associate(@name, @factory, @overrides)
+  it "tells the proxy to create an association when being added" do
+    proxy.stubs(:associate)
+    subject.add_to(proxy)
+    proxy.should have_received(:associate).with(name, factory, overrides)
   end
+end
 
-  it "should convert names to symbols" do
-    FactoryGirl::Attribute::Association.new('name', :user, {}).name.should == :name
-  end
+describe FactoryGirl::Attribute::Association, "with a string name" do
+  subject    { FactoryGirl::Attribute::Association.new("name", :user, {}) }
+  its(:name) { should == :name }
 end

data/spec/factory_girl/attribute/callback_spec.rb

@@ -1,23 +1,22 @@
 require 'spec_helper'
 
 describe FactoryGirl::Attribute::Callback do
-  before do
-    @name  = :after_create
-    @block = proc{ 'block' }
-    @attr  = FactoryGirl::Attribute::Callback.new(@name, @block)
-  end
+  let(:name)  { :after_create }
+  let(:block) { proc { "block" } }
+  let(:proxy) { stub("proxy") }
 
-  it "should have a name" do
-    @attr.name.should == @name
-  end
+  subject     { FactoryGirl::Attribute::Callback.new(name, block) }
 
-  it "should set its callback on a proxy" do
-    @proxy = "proxy"
-    mock(@proxy).add_callback(@name, @block)
-    @attr.add_to(@proxy)
-  end
+  its(:name)  { should == name }
 
-  it "should convert names to symbols" do
-    FactoryGirl::Attribute::Callback.new('name', nil).name.should == :name
+  it "set its callback on a proxy" do
+    proxy.stubs(:add_callback)
+    subject.add_to(proxy)
+    proxy.should have_received(:add_callback).with(name, block)
   end
 end
+
+describe FactoryGirl::Attribute::Callback, "with a string name" do
+  subject    { FactoryGirl::Attribute::Callback.new("name", nil) }
+  its(:name) { should == :name }
+end

data/spec/factory_girl/attribute/dynamic_spec.rb

@@ -1,60 +1,56 @@
 require 'spec_helper'
 
 describe FactoryGirl::Attribute::Dynamic do
-  before do
-    @name  = :first_name
-    @block = lambda { 'value' }
-    @attr  = FactoryGirl::Attribute::Dynamic.new(@name, @block)
-  end
+  let(:name)  { :first_name }
+  let(:proxy) { stub("proxy", :set => nil) }
+  let(:block) { lambda { } }
 
-  it "should have a name" do
-    @attr.name.should == @name
-  end
+  subject { FactoryGirl::Attribute::Dynamic.new(name, block) }
 
-  it "should call the block to set a value" do
-    @proxy = "proxy"
-    stub(@proxy).set
-    @attr.add_to(@proxy)
-    @proxy.should have_received.set(@name, 'value')
-  end
+  its(:name) { should == name }
 
-  it "should yield the proxy to the block when adding its value to a proxy" do
-    @block = lambda {|a| a }
-    @attr  = FactoryGirl::Attribute::Dynamic.new(:user, @block)
-    @proxy = "proxy"
-    stub(@proxy).set
-    @attr.add_to(@proxy)
-    @proxy.should have_received.set(:user, @proxy)
-  end
+  context "with a block returning a static value" do
+    let(:block) { lambda { "value" } }
 
-  it "evaluates the block with in the context of the proxy without an argument" do
-    result = 'other attribute value'
-    @block = lambda { other_attribute }
-    @attr  = FactoryGirl::Attribute::Dynamic.new(:user, @block)
-    @proxy = "proxy"
-    stub(@proxy).set
-    stub(@proxy).other_attribute { result }
-    @attr.add_to(@proxy)
-    @proxy.should have_received.set(:user, result)
+    it "calls the block to set a value" do
+      subject.add_to(proxy)
+      proxy.should have_received(:set).with(name, "value", false)
+    end
   end
 
-  it "should raise an error when defining an attribute writer" do
-    lambda {
-      FactoryGirl::Attribute::Dynamic.new('test=', nil)
-    }.should raise_error(FactoryGirl::AttributeDefinitionError)
+  context "with a block returning its block-level variable" do
+    let(:block) { lambda {|thing| thing } }
+
+    it "yields the proxy to the block" do
+      subject.add_to(proxy)
+      proxy.should have_received(:set).with(name, proxy, false)
+    end
   end
 
-  it "should raise an error when returning a sequence" do
-    stub(Factory).sequence { FactoryGirl::Sequence.new(:email) }
-    block = lambda { Factory.sequence(:email) }
-    attr = FactoryGirl::Attribute::Dynamic.new(:email, block)
-    proxy = stub!.set.subject
-    lambda {
-      attr.add_to(proxy)
-    }.should raise_error(FactoryGirl::SequenceAbuseError)
+  context "with a block referencing an attribute on the proxy" do
+    let(:block)  { lambda { attribute_defined_on_proxy } }
+    let(:result) { "other attribute value" }
+
+    before do
+      proxy.stubs(:attribute_defined_on_proxy => result)
+    end
+
+    it "evaluates the attribute from the proxy" do
+      subject.add_to(proxy)
+      proxy.should have_received(:set).with(name, result, false)
+    end
   end
 
-  it "should convert names to symbols" do
-    FactoryGirl::Attribute::Dynamic.new('name', nil).name.should == :name
+  context "with a block returning a sequence" do
+    let(:block) { lambda { Factory.sequence(:email) } }
+
+    it "raises a sequence abuse error" do
+      expect { subject.add_to(proxy) }.to raise_error(FactoryGirl::SequenceAbuseError)
+    end
   end
 end
+
+describe FactoryGirl::Attribute::Dynamic, "with a string name" do
+  subject    { FactoryGirl::Attribute::Dynamic.new("name", nil) }
+  its(:name) { should == :name }
+end

data/spec/factory_girl/attribute/implicit_spec.rb

@@ -1,50 +1,38 @@
 require 'spec_helper'
 
 describe FactoryGirl::Attribute::Implicit do
-  before do
-    @name       = :author
-    @attr       = FactoryGirl::Attribute::Implicit.new(@name)
-  end
+  let(:name)  { :author }
+  let(:proxy) { stub("proxy") }
+  subject     { FactoryGirl::Attribute::Implicit.new(name) }
 
-  it "has a name" do
-    @attr.name.should == @name
-  end
+  its(:name) { should == name }
 
   context "with a known factory" do
     before do
-      stub(FactoryGirl.factories).registered? { true }
+      FactoryGirl.factories.stubs(:registered? => true)
     end
 
-    it "associates the factory" do
-      proxy = "proxy"
-      stub(proxy).associate
-      @attr.add_to(proxy)
-      proxy.should have_received.associate(@name, @name, {})
-    end
+    it { should be_association }
 
-    it "is an association" do
-      @attr.should be_association
-    end
+    its(:factory) { should == name }
 
-    it "has a factory" do
-      @attr.factory.should == @name
+    it "associates the factory" do
+      proxy.stubs(:associate)
+      subject.add_to(proxy)
+      proxy.should have_received(:associate).with(name, name, {})
     end
   end
 
   context "with a known sequence" do
-    before do
-      FactoryGirl.register_sequence(FactoryGirl::Sequence.new(@name, 1) { "magic" })
-    end
+    let(:sequence) { FactoryGirl::Sequence.new(name, 1) { "magic" } }
+    before         { FactoryGirl.register_sequence(sequence) }
 
-    it "generates the sequence" do
-      proxy = "proxy"
-      stub(proxy).set
-      @attr.add_to(proxy)
-      proxy.should have_received.set(@name, "magic")
-    end
+    it { should_not be_association }
 
-    it "isn't an association" do
-      @attr.should_not be_association
+    it "generates the sequence" do
+      proxy.stubs(:set)
+      subject.add_to(proxy)
+      proxy.should have_received(:set).with(name, "magic")
     end
   end
 end

data/spec/factory_girl/attribute/sequence_spec.rb

@@ -1,21 +1,19 @@
 require 'spec_helper'
 
 describe FactoryGirl::Attribute::Sequence do
-  before do
-    @name     = :first_name
-    @sequence = :name
-    FactoryGirl.register_sequence(FactoryGirl::Sequence.new(@sequence, 5) { |n| "Name #{n}" })
-    @attr  = FactoryGirl::Attribute::Sequence.new(@name, @sequence)
-  end
+  let(:sequence_name) { :name }
+  let(:name)          { :first_name }
+  let(:sequence)      { FactoryGirl::Sequence.new(sequence_name, 5) { |n| "Name #{n}" } }
+  let(:proxy)         { stub("proxy") }
 
-  it "should have a name" do
-    @attr.name.should == @name
-  end
+  subject { FactoryGirl::Attribute::Sequence.new(name, sequence_name) }
+  before  { FactoryGirl.register_sequence(sequence) }
+
+  its(:name) { should == name }
 
   it "assigns the next value in the sequence" do
-    proxy = "proxy"
-    stub(proxy).set
-    @attr.add_to(proxy)
-    proxy.should have_received.set(@name, "Name 5")
+    proxy.stubs(:set)
+    subject.add_to(proxy)
+    proxy.should have_received(:set).with(name, "Name 5")
   end
 end

data/spec/factory_girl/attribute/static_spec.rb

@@ -1,29 +1,22 @@
 require 'spec_helper'
 
 describe FactoryGirl::Attribute::Static do
-  before do
-    @name  = :first_name
-    @value = 'John'
-    @attr  = FactoryGirl::Attribute::Static.new(@name, @value)
-  end
+  let(:name)  { :first_name }
+  let(:value) { "John" }
+  let(:proxy) { stub("proxy") }
 
-  it "should have a name" do
-    @attr.name.should == @name
-  end
+  subject { FactoryGirl::Attribute::Static.new(name, value) }
 
-  it "should set its static value on a proxy" do
-    @proxy = "proxy"
-    mock(@proxy).set(@name, @value)
-    @attr.add_to(@proxy)
-  end
+  its(:name) { should == name }
 
-  it "should raise an error when defining an attribute writer" do
-    lambda {
-      FactoryGirl::Attribute::Static.new('test=', nil)
-    }.should raise_error(FactoryGirl::AttributeDefinitionError)
+  it "sets its static value on a proxy" do
+    proxy.stubs(:set)
+    subject.add_to(proxy)
+    proxy.should have_received(:set).with(name, value, false)
   end
+end
 
-  it "should convert names to symbols" do
-    FactoryGirl::Attribute::Static.new('name', nil).name.should == :name
-  end
+describe FactoryGirl::Attribute::Static, "with a string name" do
+  subject    { FactoryGirl::Attribute::Static.new("name", nil) }
+  its(:name) { should == :name }
 end