factory_girl_kibiz0r 2.0.0.beta2

data/spec/acceptance/syntax/blueprint_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+require 'factory_girl/syntax/blueprint'
+
+describe "a blueprint" do
+  before do
+    define_model('User', :first_name => :string, :last_name => :string, :email => :string)
+
+    Factory.sequence(:email) { |n| "somebody#{n}@example.com" }
+    User.blueprint do
+      first_name { 'Bill'                       }
+      last_name  { 'Nye'                        }
+      email      { FactoryGirl.generate(:email) }
+    end
+  end
+
+  describe "after making an instance" do
+    before do
+      @instance = FactoryGirl.create(:user, :last_name => 'Rye')
+    end
+
+    it "should use attributes from the blueprint" do
+      @instance.first_name.should == 'Bill'
+    end
+
+    it "should evaluate attribute blocks for each instance" do
+      @instance.email.should =~ /somebody\d+@example.com/
+      FactoryGirl.create(:user).email.should_not == @instance.email
+    end
+  end
+end

data/spec/acceptance/syntax/generate_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+require 'factory_girl/syntax/generate'
+
+describe "a factory using generate syntax" do
+  before do
+    define_model('User', :first_name => :string, :last_name => :string, :email => :string) do
+      validates_presence_of :first_name
+    end
+
+    FactoryGirl.define do
+      factory :user do
+        first_name 'Bill'
+        last_name  'Nye'
+        email      'science@guys.net'
+      end
+    end
+  end
+
+  it "should not raise an error when generating an invalid instance" do
+    lambda { User.generate(:first_name => nil) }.should_not raise_error
+  end
+
+  it "should raise an error when forcefully generating an invalid instance" do
+    lambda { User.generate!(:first_name => nil) }.should raise_error(ActiveRecord::RecordInvalid)
+  end
+
+  %w(generate generate! spawn).each do |method|
+    it "should yield a generated instance when using #{method} with a block" do
+      saved_instance = nil
+      User.send(method) {|instance| saved_instance = instance }
+      saved_instance.should be_kind_of(User)
+    end
+
+    describe "after generating an instance using #{method}" do
+      before do
+        @instance = User.send(method, :last_name => 'Rye')
+      end
+
+      it "should use attributes from the factory" do
+        @instance.first_name.should == 'Bill'
+      end
+
+      it "should use attributes passed to generate" do
+        @instance.last_name.should == 'Rye'
+      end
+
+      if method == 'spawn'
+        it "should not save the record" do
+          @instance.should be_new_record
+        end
+      else
+        it "should save the record" do
+          @instance.should_not be_new_record
+        end
+      end
+    end
+  end
+end

data/spec/acceptance/syntax/make_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+require 'factory_girl/syntax/make'
+
+describe "a factory using make syntax" do
+  before do
+    define_model('User', :first_name => :string, :last_name => :string)
+
+    FactoryGirl.define do
+      factory :user do
+        first_name 'Bill'
+        last_name  'Nye'
+      end
+    end
+  end
+
+  describe "after making an instance" do
+    before do
+      @instance = User.make(:last_name => 'Rye')
+    end
+
+    it "should use attributes from the factory" do
+      @instance.first_name.should == 'Bill'
+    end
+
+    it "should use attributes passed to make" do
+      @instance.last_name.should == 'Rye'
+    end
+
+    it "should save the record" do
+      @instance.should_not be_new_record
+    end
+  end
+end

data/spec/acceptance/syntax/sham_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+require 'factory_girl/syntax/sham'
+
+describe "a factory using sham syntax" do
+  before do
+    define_model('User', :first_name => :string,
+                         :last_name  => :string,
+                         :email      => :string,
+                         :username   => :string)
+
+    Sham.name        { "Name" }
+    Sham.email       { "somebody#{rand(5)}@example.com" }
+    Sham.username("FOO") { |c| "User-#{c}" }
+
+    FactoryGirl.define do
+      factory :user do
+        first_name { Sham.name }
+        last_name  { Sham.name }
+        email      { Sham.email }
+        username   { Sham.username }
+      end
+    end
+  end
+
+  describe "after making an instance" do
+    before do
+      @instance = FactoryGirl.create(:user, :last_name => 'Rye')
+    end
+
+    it "should support a sham called 'name'" 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
+  end
+end

data/spec/acceptance/syntax/vintage_spec.rb

@@ -0,0 +1,224 @@
+require 'spec_helper'
+require 'acceptance/acceptance_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 "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
+
+  it "should raise Factory::SequenceAbuseError" do
+    Factory.define :sequence_abuser, :class => User do |factory|
+      factory.first_name { Factory.sequence(:name) }
+    end
+
+    lambda {
+      Factory(:sequence_abuser)
+    }.should raise_error(FactoryGirl::SequenceAbuseError)
+  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).names { [@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.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 "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
+    @name     = :count
+    @sequence = FactoryGirl::Sequence.new(@name) {}
+    stub(FactoryGirl::Sequence).new { @sequence }
+  end
+
+  it "should create a new sequence" do
+    mock(FactoryGirl::Sequence).new(@name, 1) { @sequence }
+    Factory.sequence(@name)
+  end
+
+  it "should use the supplied block as the sequence generator" do
+    stub(FactoryGirl::Sequence).new { @sequence }.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(@name, "A") { @sequence }
+    Factory.sequence(@name, "A")
+  end
+end
+
+describe "after defining a sequence" do
+  before do
+    @name     = :test
+    @sequence = FactoryGirl::Sequence.new(@name) {}
+    @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
+
+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 "should match 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 "should match the correct format" do
+      @username.should =~ /^username\d+$/
+    end
+
+    it "should not be the same as the first generated value" do
+      @another_username.should_not == @username
+    end
+  end
+end
+

data/spec/factory_girl/aliases_spec.rb

@@ -0,0 +1,33 @@
+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)
+  end
+
+  it "should include the root of a foreign key as an alias by default" do
+    FactoryGirl.aliases_for(:test_id).should include(:test)
+  end
+
+  it "should include an attribute's foreign key as an alias by default" do
+    FactoryGirl.aliases_for(:test).should include(:test_id)
+  end
+
+  it "should NOT include an attribute as an alias when it starts with underscore" do
+    FactoryGirl.aliases_for(:_id).should_not include(:id)
+  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
+
+end

data/spec/factory_girl/attribute/association_spec.rb

@@ -0,0 +1,33 @@
+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
+
+  it "should have a name" do
+    @attr.name.should == @name
+  end
+
+  it "is an association" do
+    @attr.should be_association
+  end
+
+  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)
+  end
+
+  it "should convert names to symbols" do
+    FactoryGirl::Attribute::Association.new('name', :user, {}).name.should == :name
+  end
+end

data/spec/factory_girl/attribute/callback_spec.rb

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

data/spec/factory_girl/attribute/dynamic_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+describe FactoryGirl::Attribute::Dynamic do
+  before do
+    @name  = :first_name
+    @block = lambda { 'value' }
+    @attr  = FactoryGirl::Attribute::Dynamic.new(@name, @block)
+  end
+
+  it "should have a name" do
+    @attr.name.should == @name
+  end
+
+  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
+
+  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
+
+  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 {
+      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 { 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)
+  end
+
+  it "should convert names to symbols" do
+    FactoryGirl::Attribute::Dynamic.new('name', nil).name.should == :name
+  end
+end

data/spec/factory_girl/attribute/implicit_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+describe FactoryGirl::Attribute::Implicit do
+  before do
+    @name       = :author
+    @attr       = FactoryGirl::Attribute::Implicit.new(@name)
+  end
+
+  it "has a name" do
+    @attr.name.should == @name
+  end
+
+  context "with a known factory" do
+    before do
+      stub(FactoryGirl.factories).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 "is an association" do
+      @attr.should be_association
+    end
+
+    it "has a factory" do
+      @attr.factory.should == @name
+    end
+  end
+
+  context "with a known sequence" do
+    before do
+      FactoryGirl.register_sequence(FactoryGirl::Sequence.new(@name, 1) { "magic" })
+    end
+
+    it "generates the sequence" do
+      proxy = "proxy"
+      stub(proxy).set
+      @attr.add_to(proxy)
+      proxy.should have_received.set(@name, "magic")
+    end
+
+    it "isn't an association" do
+      @attr.should_not be_association
+    end
+  end
+end

data/spec/factory_girl/attribute/sequence_spec.rb

@@ -0,0 +1,21 @@
+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
+
+  it "should have a name" do
+    @attr.name.should == @name
+  end
+
+  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")
+  end
+end

data/spec/factory_girl/attribute/static_spec.rb

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

data/spec/factory_girl/attribute_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+describe FactoryGirl::Attribute do
+  before do
+    @name  = :user
+    @attr  = FactoryGirl::Attribute.new(@name)
+  end
+
+  it "should have a name" do
+    @attr.name.should == @name
+  end
+
+  it "isn't an association" do
+    @attr.should_not be_association
+  end
+
+  it "should do nothing when being added to a proxy" do
+    @proxy = "proxy"
+    stub(@proxy).set
+    @attr.add_to(@proxy)
+    @proxy.should have_received.set.never
+  end
+
+  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 {
+      FactoryGirl::Attribute.new('test=')
+    }.should raise_error(FactoryGirl::AttributeDefinitionError, error_message)
+  end
+
+  it "should convert names to symbols" do
+    FactoryGirl::Attribute.new('name').name.should == :name
+  end
+
+  it "should be ignorable" do
+    @attr.ignore
+    @attr.should be_ignored
+  end
+end