factory_girl 1.3.3 → 2.0.0.beta1

data/spec/acceptance/syntax/sham_spec.rb

@@ -1,24 +1,22 @@
 require 'spec_helper'
+require 'acceptance/acceptance_helper'
 
 require 'factory_girl/syntax/sham'
 
 describe "a factory using sham syntax" do
   before do
-    Sham.name  { "Name" }
-    Sham.email { "somebody#{rand(5)}@example.com" }
+    Sham.name        { "Name" }
+    Sham.email       { "somebody#{rand(5)}@example.com" }
+    Sham.user("FOO") { |c| "User-#{c}" }
 
     Factory.define :user do |factory|
       factory.first_name { Sham.name }
       factory.last_name  { Sham.name }
       factory.email      { Sham.email }
+      factory.username   { Sham.user }
     end
   end
 
-  after do
-    Factory.factories.clear
-    Factory.sequences.clear
-  end
-
   describe "after making an instance" do
     before do
       @instance = Factory(:user, :last_name => 'Rye')
@@ -28,6 +26,10 @@ describe "a factory using sham syntax" do
       @instance.first_name.should == 'Name'
     end
 
+    it "should support shams with starting values" do
+      @instance.username.should == 'User-FOO'
+    end
+    
     it "should use the sham for the email" do
       @instance.email.should =~ /somebody\d@example.com/
     end

data/spec/acceptance/syntax/vintage_spec.rb

@@ -0,0 +1,184 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+describe "default syntax" do
+  before do
+    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 "should raise an ArgumentError when trying to use a non-existent strategy" do
+    lambda {
+      Factory.define(:object, :default_strategy => :nonexistent) {}
+    }.should raise_error(ArgumentError)
+  end
+end
+
+describe Factory, "given a parent factory" do
+  before do
+    @parent = FactoryGirl::Factory.new(:object)
+    @parent.define_attribute(FactoryGirl::Attribute::Static.new(:name, 'value'))
+    FactoryGirl.register_factory(@parent)
+  end
+
+  it "should raise an ArgumentError when trying to use a non-existent factory as parent" do
+    lambda {
+      Factory.define(:child, :parent => :nonexsitent) {}
+    }.should raise_error(ArgumentError)
+  end
+end
+
+describe "defining a factory" do
+  before do
+    @name    = :user
+    @factory = "factory"
+    @proxy   = "proxy"
+    stub(@factory).name { @name }
+    @options = { :class => 'magic' }
+    stub(FactoryGirl::Factory).new { @factory }
+    stub(FactoryGirl::DefinitionProxy).new { @proxy }
+  end
+
+  it "should create a new factory using the specified name and options" do
+    mock(FactoryGirl::Factory).new(@name, @options) { @factory }
+    Factory.define(@name, @options) {|f| }
+  end
+
+  it "should pass the factory do the block" do
+    yielded = nil
+    Factory.define(@name) do |y|
+      yielded = y
+    end
+    yielded.should == @proxy
+  end
+
+  it "should add the factory to the list of factories" do
+    Factory.define(@name) {|f| }
+    @factory.should == FactoryGirl.factories[@name]
+  end
+
+  it "should allow a factory to be found by name" do
+    Factory.define(@name) {|f| }
+    FactoryGirl.factory_by_name(@name).should == @factory
+  end
+end
+
+describe "after defining a factory" do
+  before do
+    @name    = :user
+    @factory = "factory"
+
+    FactoryGirl.factories[@name] = @factory
+  end
+
+  it "should use Proxy::AttributesFor for Factory.attributes_for" do
+    mock(@factory).run(FactoryGirl::Proxy::AttributesFor, :attr => 'value') { 'result' }
+    Factory.attributes_for(@name, :attr => 'value').should == 'result'
+  end
+
+  it "should use Proxy::Build for Factory.build" do
+    mock(@factory).run(FactoryGirl::Proxy::Build, :attr => 'value') { 'result' }
+    Factory.build(@name, :attr => 'value').should == 'result'
+  end
+
+  it "should use Proxy::Create for Factory.create" do
+    mock(@factory).run(FactoryGirl::Proxy::Create, :attr => 'value') { 'result' }
+    Factory.create(@name, :attr => 'value').should == 'result'
+  end
+
+  it "should use Proxy::Stub for Factory.stub" do
+    mock(@factory).run(FactoryGirl::Proxy::Stub, :attr => 'value') { 'result' }
+    Factory.stub(@name, :attr => 'value').should == 'result'
+  end
+
+  it "should use default strategy option as Factory.default_strategy" do
+    stub(@factory).default_strategy { :create }
+    mock(@factory).run(FactoryGirl::Proxy::Create, :attr => 'value') { 'result' }
+    Factory.default_strategy(@name, :attr => 'value').should == 'result'
+  end
+
+  it "should use the default strategy for the global Factory method" do
+    stub(@factory).default_strategy { :create }
+    mock(@factory).run(FactoryGirl::Proxy::Create, :attr => 'value') { 'result' }
+    Factory(@name, :attr => 'value').should == 'result'
+  end
+
+  [:build, :create, :attributes_for, :stub].each do |method|
+    it "should raise an ArgumentError on #{method} with a nonexistant factory" do
+      lambda { Factory.send(method, :bogus) }.should raise_error(ArgumentError)
+    end
+
+    it "should recognize either 'name' or :name for Factory.#{method}" do
+      stub(@factory).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
+    @sequence = "sequence"
+    @name     = :count
+    stub(FactoryGirl::Sequence).new { @sequence }
+  end
+
+  it "should create a new sequence" do
+    mock(FactoryGirl::Sequence).new(1) { @sequence }
+    Factory.sequence(@name)
+  end
+
+  it "should use the supplied block as the sequence generator" do
+    stub(FactoryGirl::Sequence).new.yields(1)
+    yielded = false
+    Factory.sequence(@name) {|n| yielded = true }
+    (yielded).should be
+  end
+
+  it "should use the supplied start_value as the sequence start_value" do
+    mock(FactoryGirl::Sequence).new("A") { @sequence }
+    Factory.sequence(@name, "A")
+  end
+end
+
+describe "after defining a sequence" do
+  before do
+    @sequence = "sequence"
+    @name     = :test
+    @value    = '1 2 5'
+
+    stub(@sequence).next { @value }
+    stub(FactoryGirl::Sequence).new { @sequence }
+
+    Factory.sequence(@name) {}
+  end
+
+  it "should call next on the sequence when sent next" do
+    mock(@sequence).next
+
+    Factory.next(@name)
+  end
+
+  it "should return the value from the sequence" do
+    Factory.next(@name).should == @value
+  end
+end

data/spec/factory_girl/aliases_spec.rb

@@ -3,19 +3,19 @@ require 'spec_helper'
 describe Factory, "aliases" do
 
   it "should include an attribute as an alias for itself by default" do
-    Factory.aliases_for(:test).should include(:test)
+    FactoryGirl.aliases_for(:test).should include(:test)
   end
 
   it "should include the root of a foreign key as an alias by default" do
-    Factory.aliases_for(:test_id).should include(:test)
+    FactoryGirl.aliases_for(:test_id).should include(:test)
   end
 
   it "should include an attribute's foreign key as an alias by default" do
-    Factory.aliases_for(:test).should include(:test_id)
+    FactoryGirl.aliases_for(:test).should include(:test_id)
   end
 
   it "should NOT include an attribute as an alias when it starts with underscore" do
-    Factory.aliases_for(:_id).should_not include(:id)
+    FactoryGirl.aliases_for(:_id).should_not include(:id)
   end
 
   describe "after adding an alias" do
@@ -25,7 +25,7 @@ describe Factory, "aliases" do
     end
 
     it "should return the alias in the aliases list" do
-      Factory.aliases_for(:test_suffix).should include(:test)
+      FactoryGirl.aliases_for(:test_suffix).should include(:test)
     end
 
   end

data/spec/factory_girl/attribute/association_spec.rb

@@ -1,11 +1,11 @@
 require 'spec_helper'
 
-describe Factory::Attribute::Association do
+describe FactoryGirl::Attribute::Association do
   before do
     @name      = :author
     @factory   = :user
     @overrides = { :first_name => 'John' }
-    @attr      = Factory::Attribute::Association.new(@name, @factory, @overrides)
+    @attr      = FactoryGirl::Attribute::Association.new(@name, @factory, @overrides)
   end
 
   it "should have a name" do
@@ -24,6 +24,6 @@ describe Factory::Attribute::Association do
   end
 
   it "should convert names to symbols" do
-    Factory::Attribute::Association.new('name', :user, {}).name.should == :name
+    FactoryGirl::Attribute::Association.new('name', :user, {}).name.should == :name
   end
 end

data/spec/factory_girl/attribute/callback_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe Factory::Attribute::Callback do
+describe FactoryGirl::Attribute::Callback do
   before do
     @name  = :after_create
     @block = proc{ 'block' }
-    @attr  = Factory::Attribute::Callback.new(@name, @block)
+    @attr  = FactoryGirl::Attribute::Callback.new(@name, @block)
   end
 
   it "should have a name" do
@@ -18,6 +18,6 @@ describe Factory::Attribute::Callback do
   end
 
   it "should convert names to symbols" do
-    Factory::Attribute::Callback.new('name', nil).name.should == :name
+    FactoryGirl::Attribute::Callback.new('name', nil).name.should == :name
   end
 end

data/spec/factory_girl/attribute/dynamic_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe Factory::Attribute::Dynamic do
+describe FactoryGirl::Attribute::Dynamic do
   before do
     @name  = :first_name
     @block = lambda { 'value' }
-    @attr  = Factory::Attribute::Dynamic.new(@name, @block)
+    @attr  = FactoryGirl::Attribute::Dynamic.new(@name, @block)
   end
 
   it "should have a name" do
@@ -20,30 +20,41 @@ describe Factory::Attribute::Dynamic do
 
   it "should yield the proxy to the block when adding its value to a proxy" do
     @block = lambda {|a| a }
-    @attr  = Factory::Attribute::Dynamic.new(:user, @block)
+    @attr  = FactoryGirl::Attribute::Dynamic.new(:user, @block)
     @proxy = "proxy"
     stub(@proxy).set
     @attr.add_to(@proxy)
     @proxy.should have_received.set(:user, @proxy)
   end
 
+  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)
+  end
+
   it "should raise an error when defining an attribute writer" do
     lambda {
-      Factory::Attribute::Dynamic.new('test=', nil)
-    }.should raise_error(Factory::AttributeDefinitionError)
+      FactoryGirl::Attribute::Dynamic.new('test=', nil)
+    }.should raise_error(FactoryGirl::AttributeDefinitionError)
   end
 
   it "should raise an error when returning a sequence" do
-    stub(Factory).sequence { Factory::Sequence.new }
+    stub(Factory).sequence { FactoryGirl::Sequence.new }
     block = lambda { Factory.sequence(:email) }
-    attr = Factory::Attribute::Dynamic.new(:email, block)
+    attr = FactoryGirl::Attribute::Dynamic.new(:email, block)
     proxy = stub!.set.subject
     lambda {
       attr.add_to(proxy)
-    }.should raise_error(Factory::SequenceAbuseError)
+    }.should raise_error(FactoryGirl::SequenceAbuseError)
   end
 
   it "should convert names to symbols" do
-    Factory::Attribute::Dynamic.new('name', nil).name.should == :name
+    FactoryGirl::Attribute::Dynamic.new('name', nil).name.should == :name
   end
 end

data/spec/factory_girl/attribute/static_spec.rb

@@ -1,10 +1,10 @@
 require 'spec_helper'
 
-describe Factory::Attribute::Static do
+describe FactoryGirl::Attribute::Static do
   before do
     @name  = :first_name
     @value = 'John'
-    @attr  = Factory::Attribute::Static.new(@name, @value)
+    @attr  = FactoryGirl::Attribute::Static.new(@name, @value)
   end
 
   it "should have a name" do
@@ -19,11 +19,11 @@ describe Factory::Attribute::Static do
 
   it "should raise an error when defining an attribute writer" do
     lambda {
-      Factory::Attribute::Static.new('test=', nil)
-    }.should raise_error(Factory::AttributeDefinitionError)
+      FactoryGirl::Attribute::Static.new('test=', nil)
+    }.should raise_error(FactoryGirl::AttributeDefinitionError)
   end
 
   it "should convert names to symbols" do
-    Factory::Attribute::Static.new('name', nil).name.should == :name
+    FactoryGirl::Attribute::Static.new('name', nil).name.should == :name
   end
 end

data/spec/factory_girl/attribute_spec.rb

@@ -1,9 +1,9 @@
 require 'spec_helper'
 
-describe Factory::Attribute do
+describe FactoryGirl::Attribute do
   before do
     @name  = :user
-    @attr  = Factory::Attribute.new(@name)
+    @attr  = FactoryGirl::Attribute.new(@name)
   end
 
   it "should have a name" do
@@ -20,11 +20,11 @@ describe Factory::Attribute do
   it "should raise an error when defining an attribute writer" do
     error_message = %{factory_girl uses 'f.test value' syntax rather than 'f.test = value'}
     lambda {
-      Factory::Attribute.new('test=')
-    }.should raise_error(Factory::AttributeDefinitionError, error_message)
+      FactoryGirl::Attribute.new('test=')
+    }.should raise_error(FactoryGirl::AttributeDefinitionError, error_message)
   end
 
   it "should convert names to symbols" do
-    Factory::Attribute.new('name').name.should == :name
+    FactoryGirl::Attribute.new('name').name.should == :name
   end
 end

data/spec/factory_girl/definition_proxy_spec.rb

@@ -0,0 +1,138 @@
+require 'spec_helper'
+
+describe FactoryGirl::DefinitionProxy do
+  let(:factory) { FactoryGirl::Factory.new(:object) }
+  subject { FactoryGirl::DefinitionProxy.new(factory) }
+
+  it "should add a static attribute for type" do
+    subject.type 'value'
+    factory.attributes.last.should be_kind_of(FactoryGirl::Attribute::Static)
+  end
+
+  it "should add a static attribute for id" do
+    subject.id 'value'
+    factory.attributes.last.should be_kind_of(FactoryGirl::Attribute::Static)
+  end
+
+  it "should add a static attribute when an attribute is defined with a value" do
+    attribute = 'attribute'
+    stub(attribute).name { :name }
+    mock(FactoryGirl::Attribute::Static).new(:name, 'value') { attribute }
+    mock(factory).define_attribute(attribute)
+    subject.add_attribute(:name, 'value')
+  end
+
+  it "should add a dynamic attribute when an attribute is defined with a block" do
+    attribute = 'attribute'
+    stub(attribute).name { :name }
+    block     = lambda {}
+    mock(FactoryGirl::Attribute::Dynamic).new(:name, block) { attribute }
+    mock(factory).define_attribute(attribute)
+    subject.add_attribute(:name, &block)
+  end
+
+  it "should raise for an attribute with a value and a block" do
+    lambda {
+      subject.add_attribute(:name, 'value') {}
+    }.should raise_error(FactoryGirl::AttributeDefinitionError)
+  end
+
+  describe "adding an attribute using a in-line sequence" do
+    it "should create the sequence" do
+      mock(FactoryGirl::Sequence).new(1)
+      subject.sequence(:name) {}
+    end
+
+    it "should create the sequence with a custom default value" do
+      mock(FactoryGirl::Sequence).new("A")
+      subject.sequence(:name, "A") {}
+    end
+
+    it "should add a dynamic attribute" do
+      attribute = 'attribute'
+      stub(attribute).name { :name }
+      mock(FactoryGirl::Attribute::Dynamic).new(:name, is_a(Proc)) { attribute }
+      subject.sequence(:name) {}
+      factory.attributes.should include(attribute)
+    end
+  end
+
+  it "should add a callback attribute when the after_build attribute is defined" do
+    mock(FactoryGirl::Attribute::Callback).new(:after_build, is_a(Proc)) { 'after_build callback' }
+    subject.after_build {}
+    factory.attributes.should include('after_build callback')
+  end
+
+  it "should add a callback attribute when the after_create attribute is defined" do
+    mock(FactoryGirl::Attribute::Callback).new(:after_create, is_a(Proc)) { 'after_create callback' }
+    subject.after_create {}
+    factory.attributes.should include('after_create callback')
+  end
+
+  it "should add a callback attribute when the after_stub attribute is defined" do
+    mock(FactoryGirl::Attribute::Callback).new(:after_stub, is_a(Proc)) { 'after_stub callback' }
+    subject.after_stub {}
+    factory.attributes.should include('after_stub callback')
+  end
+
+  it "should add an association without a factory name or overrides" do
+    name = :user
+    attr = 'attribute'
+    stub(attr).name { name }
+    mock(FactoryGirl::Attribute::Association).new(name, name, {}) { attr }
+    subject.association(name)
+    factory.attributes.should include(attr)
+  end
+
+  it "should add an association with overrides" do
+    name      = :user
+    attr      = 'attribute'
+    overrides = { :first_name => 'Ben' }
+    stub(attr).name { name }
+    mock(FactoryGirl::Attribute::Association).new(name, name, overrides) { attr }
+    subject.association(name, overrides)
+    factory.attributes.should include(attr)
+  end
+
+  it "should add an attribute using the method name when passed an undefined method" do
+    attribute = 'attribute'
+    stub(attribute).name { :name }
+    mock(FactoryGirl::Attribute::Static).new(:name, 'value') { attribute }
+    subject.send(:name, 'value')
+    factory.attributes.should include(attribute)
+  end
+
+  it "adds an attribute using when passed an undefined method and block" do
+    attribute = 'attribute'
+    stub(attribute).name { :name }
+    block = lambda {}
+    mock(FactoryGirl::Attribute::Dynamic).new(:name, block) { attribute }
+    subject.send(:name, &block)
+    factory.attributes.should include(attribute)
+  end
+
+  it "adds an association when passed an undefined method without arguments or a block" do
+    name = :user
+    attr = 'attribute'
+    stub(attr).name { name }
+    mock(FactoryGirl::Attribute::Association).new(name, name, {}) { attr }
+    subject.send(name)
+    factory.attributes.should include(attr)
+  end
+
+  it "adds a sequence when passed an undefined method without arguments or a block" do
+    name = :airport
+    proxy = 'proxy'
+    FactoryGirl.sequences[name] = FactoryGirl::Sequence.new { |value| "expected" }
+    subject.send(name)
+    stub(proxy).set
+    factory.attributes.last.add_to(proxy)
+    proxy.should have_received.set(name, 'expected')
+  end
+
+  it "registers its factory for an alias" do
+    aliased_name = :guest
+    mock(FactoryGirl).register_factory(factory, :as => aliased_name)
+    subject.aliased_as aliased_name
+  end
+end