factory_girl 2.2.0 → 2.3.0

data/spec/factory_girl/definition_spec.rb

@@ -0,0 +1,81 @@
+require "spec_helper"
+
+describe FactoryGirl::Definition do
+  it { should delegate(:declare_attribute).to(:declarations) }
+  it { should delegate(:attributes).to(:declarations).as(:attribute_list) }
+end
+
+describe FactoryGirl::Definition, "with a name" do
+  let(:name) { :"great name" }
+  subject    { FactoryGirl::Definition.new(name) }
+
+  it "creates a new attribute list with the name passed" do
+    FactoryGirl::DeclarationList.stubs(:new)
+    subject
+    FactoryGirl::DeclarationList.should have_received(:new).with(name)
+  end
+end
+
+describe FactoryGirl::Definition, "#overridable" do
+  let(:list) { stub("declaration list", :overridable => true) }
+  before { FactoryGirl::DeclarationList.stubs(:new => list) }
+
+  it "sets the declaration list as overridable" do
+    subject.overridable.should == subject
+    list.should have_received(:overridable).once
+  end
+end
+
+describe FactoryGirl::Definition, "defining traits" do
+  let(:trait_1) { stub("trait") }
+  let(:trait_2) { stub("trait") }
+
+  it "maintains a list of traits" do
+    subject.define_trait(trait_1)
+    subject.define_trait(trait_2)
+    subject.defined_traits.should == [trait_1, trait_2]
+  end
+end
+
+describe FactoryGirl::Definition, "adding callbacks" do
+  let(:callback_1) { stub("callback") }
+  let(:callback_2) { stub("callback") }
+
+  it "maintains a list of callbacks" do
+    subject.add_callback(callback_1)
+    subject.add_callback(callback_2)
+    subject.callbacks.should == [callback_1, callback_2]
+  end
+end
+
+describe FactoryGirl::Definition, "#to_create" do
+  its(:to_create) { should be_nil }
+
+  it "returns the assigned value when given a block" do
+    block = proc { nil }
+    subject.to_create(&block)
+    subject.to_create.should == block
+  end
+end
+
+describe FactoryGirl::Definition, "#traits" do
+  let(:female_trait) { stub("female trait", :name => :female) }
+  let(:admin_trait)  { stub("admin trait", :name => :admin) }
+
+  before do
+    subject.define_trait(female_trait)
+    FactoryGirl.stubs(:trait_by_name => admin_trait)
+  end
+
+  its(:traits) { should be_empty }
+
+  it "finds the correct traits after inheriting" do
+    subject.inherit_traits([:female])
+    subject.traits.should == [female_trait]
+  end
+
+  it "looks for the trait on FactoryGirl" do
+    subject.inherit_traits([:female, :admin])
+    subject.traits.should == [admin_trait, female_trait]
+  end
+end

data/spec/factory_girl/factory_spec.rb

@@ -48,14 +48,6 @@ describe FactoryGirl::Factory do
     factory.associations.size.should == 3
   end
 
-  it "raises for a self referencing association" do
-    factory = FactoryGirl::Factory.new(:post)
-    lambda {
-      factory.declare_attribute(FactoryGirl::Declaration::Association.new(:parent, { :factory => :post }))
-      factory.ensure_compiled
-    }.should raise_error(FactoryGirl::AssociationDefinitionError)
-  end
-
   describe "when overriding generated attributes with a hash" do
     before do
       @name  = :name
@@ -71,9 +63,9 @@ describe FactoryGirl::Factory do
     end
 
     it "does not call a lazy attribute block for an overridden attribute" do
-      declaration = FactoryGirl::Declaration::Dynamic.new(@name, lambda { flunk })
+      declaration = FactoryGirl::Declaration::Dynamic.new(@name, false, lambda { flunk })
       @factory.declare_attribute(declaration)
-      result = @factory.run(FactoryGirl::Proxy::AttributesFor, @hash)
+      @factory.run(FactoryGirl::Proxy::AttributesFor, @hash)
     end
 
     it "overrides a symbol parameter with a string parameter" do
@@ -108,13 +100,13 @@ describe FactoryGirl::Factory do
 
   it "creates a new factory using the class of the parent" do
     child = FactoryGirl::Factory.new(:child, :parent => @factory.name)
-    child.ensure_compiled
+    child.compile
     child.build_class.should == @factory.build_class
   end
 
   it "creates a new factory while overriding the parent class" do
     child = FactoryGirl::Factory.new(:child, :class => String, :parent => @factory.name)
-    child.ensure_compiled
+    child.compile
     child.build_class.should == String
   end
 end
@@ -197,8 +189,8 @@ describe FactoryGirl::Factory do
     FactoryGirl.register_factory(factory_with_stub_strategy)
   end
 
-  it "raises an ArgumentError when trying to use a non-existent strategy" do
-    expect { factory_with_non_existent_strategy }.to raise_error(ArgumentError)
+  it "raises when trying to use a non-existent strategy" do
+    expect { factory_with_non_existent_strategy }.to raise_error
   end
 
   it "creates a new factory with a specified default strategy" do
@@ -207,7 +199,7 @@ describe FactoryGirl::Factory do
 
   describe "defining a child factory without setting default strategy" do
     subject { FactoryGirl::Factory.new(:other_object, :parent => factory_with_stub_strategy.name) }
-    before  { subject.ensure_compiled }
+    before  { subject.compile }
 
     it "inherits default strategy from its parent" do
       subject.default_strategy.should == :stub
@@ -216,7 +208,7 @@ describe FactoryGirl::Factory do
 
   describe "defining a child factory with a default strategy" do
     subject { FactoryGirl::Factory.new(:other_object, :default_strategy => :build, :parent => factory_with_stub_strategy.name) }
-    before  { subject.ensure_compiled }
+    before  { subject.compile }
 
     it "overrides the default strategy from parent" do
       subject.default_strategy.should == :build
@@ -237,6 +229,12 @@ describe FactoryGirl::Factory, "human names" do
     its(:human_names) { should == ["happy user"] }
   end
 
+  context "factory name with big letters" do
+    subject           { FactoryGirl::Factory.new(:LoL) }
+    its(:names)       { should == [:LoL] }
+    its(:human_names) { should == ["lol"] }
+  end
+
   context "factory name with aliases" do
     subject           { FactoryGirl::Factory.new(:happy_user, :aliases => [:gleeful_user, :person]) }
     its(:names)       { should == [:happy_user, :gleeful_user, :person] }
@@ -263,7 +261,7 @@ describe FactoryGirl::Factory, "running a factory" do
 
   it "creates the right proxy using the build class when running" do
     subject.run(FactoryGirl::Proxy::Build, {})
-    FactoryGirl::Proxy::Build.should have_received(:new).with(subject.build_class)
+    FactoryGirl::Proxy::Build.should have_received(:new).with(subject.build_class, [])
   end
 
   it "adds the attribute to the proxy when running" do
@@ -280,4 +278,31 @@ describe FactoryGirl::Factory, "running a factory" do
     subject.run(FactoryGirl::Proxy::Build, { :name => "John Doe" })
     proxy.should have_received(:set).once
   end
+
+  it "calls the block and returns the result" do
+    block_run = nil
+    block = lambda {|result| block_run = "changed" }
+    subject.run(FactoryGirl::Proxy::Build, { }, &block)
+    block_run.should == "changed"
+  end
+end
+
+describe FactoryGirl::Factory, "#with_traits" do
+  subject            { FactoryGirl::Factory.new(:user) }
+  let(:admin_trait)  { FactoryGirl::Trait.new(:admin) }
+  let(:female_trait) { FactoryGirl::Trait.new(:female) }
+
+  before do
+    FactoryGirl.register_trait(admin_trait)
+    FactoryGirl.register_trait(female_trait)
+  end
+
+  it "returns a factory with the correct traits" do
+    subject.with_traits([:admin, :female]).traits.should =~ [admin_trait, female_trait]
+  end
+
+  it "doesn't modify the original factory's traits" do
+    subject.with_traits([:admin, :female])
+    subject.traits.should be_empty
+  end
 end

data/spec/factory_girl/null_factory_spec.rb

@@ -0,0 +1,12 @@
+require "spec_helper"
+
+describe FactoryGirl::NullFactory do
+  it { should delegate(:defined_traits).to(:definition) }
+  it { should delegate(:callbacks).to(:definition) }
+  it { should delegate(:attributes).to(:definition) }
+
+  its(:compile)          { should be_nil }
+  its(:default_strategy) { should be_nil }
+  its(:class_name)       { should be_nil }
+  its(:attributes)       { should be_an_instance_of(FactoryGirl::AttributeList) }
+end

data/spec/factory_girl/proxy/build_spec.rb

@@ -9,28 +9,5 @@ describe FactoryGirl::Proxy::Build do
   it_should_behave_like "proxy with association support", FactoryGirl::Proxy::Create
   it_should_behave_like "proxy with standard getters and setters", :attribute_name, "attribute value!"
   it_should_behave_like "proxy with callbacks", :after_build
-  it_should_behave_like "proxy with :method => :build",
-    FactoryGirl::Proxy::Build
-
-  describe "specifying method" do
-    it "defaults to create" do
-      subject.send(:get_method, nil).should == FactoryGirl::Proxy::Create
-    end
-
-    it "can specify create explicitly" do
-      subject.send(:get_method, :create).should ==
-        FactoryGirl::Proxy::Create
-    end
-
-    it "can specify build explicitly" do
-      subject.send(:get_method, :build).should ==
-        FactoryGirl::Proxy::Build
-    end
-
-    it "complains if method is unrecognized" do
-      lambda { subject.send(:get_method, :froboznicate) }.
-        should raise_error("unrecognized method froboznicate")
-    end
-  end
-
+  it_should_behave_like "proxy with :method => :build", FactoryGirl::Proxy::Build
 end

data/spec/factory_girl/proxy/create_spec.rb

@@ -1,7 +1,6 @@
 require 'spec_helper'
 
 describe FactoryGirl::Proxy::Create do
-
   let(:instance)    { stub("created-instance", :save! => true) }
   let(:proxy_class) { stub("class", :new => instance) }
 
@@ -24,17 +23,21 @@ describe FactoryGirl::Proxy::Create do
     instance.should have_received(:save!).never
   end
 
-  context "callback execution order" do
-    it "runs after_build callbacks before after_create callbacks" do
-      ran = []
-      after_create = FactoryGirl::Callback.new(:after_create, lambda { ran << :after_create })
-      after_build = FactoryGirl::Callback.new(:after_build, lambda { ran << :after_build })
-      subject.add_callback(after_create)
-      subject.add_callback(after_build)
+end
+
+describe FactoryGirl::Proxy::Create, "when running callbacks" do
+  let(:instance)         { stub("created-instance", :save! => true) }
+  let(:proxy_class)      { stub("class", :new => instance) }
+  let!(:callback_result) { [] }
 
-      subject.result(nil)
+  let(:after_create_one) { FactoryGirl::Callback.new(:after_create, lambda { callback_result << :after_create_one }) }
+  let(:after_create_two) { FactoryGirl::Callback.new(:after_create, lambda { callback_result << :after_create_two }) }
+  let(:after_build_one)  { FactoryGirl::Callback.new(:after_build,  lambda { callback_result << :after_build_one }) }
 
-      ran.should == [:after_build, :after_create]
-    end
+  subject { FactoryGirl::Proxy::Create.new(proxy_class, [after_create_one, after_create_two, after_build_one]) }
+
+  it "runs callbacks in the correct order" do
+    subject.result(nil)
+    callback_result.should == [:after_build_one, :after_create_one, :after_create_two]
   end
 end

data/spec/factory_girl/proxy_spec.rb

@@ -21,51 +21,34 @@ describe FactoryGirl::Proxy do
   it "raises an error when asking for the result" do
     expect { subject.result(nil) }.to raise_error(NotImplementedError)
   end
+end
+
+describe FactoryGirl::Proxy, "when running callbacks" do
+  let!(:callback_result) { [] }
+
+  let(:after_create_one) { FactoryGirl::Callback.new(:after_create, lambda { callback_result << :after_create_one }) }
+  let(:after_create_two) { FactoryGirl::Callback.new(:after_create, lambda { callback_result << :after_create_two }) }
+  let(:after_build_one)  { FactoryGirl::Callback.new(:after_build,  lambda { callback_result << :after_build_one }) }
 
-  describe "when adding callbacks" do
-    it "adds a callback" do
-      callback = FactoryGirl::Callback.new(:after_create, lambda {})
-      subject.add_callback(callback)
-      subject.callbacks[:after_create].should == [callback]
-    end
+  subject { FactoryGirl::Proxy.new(Class.new, [after_create_one, after_create_two, after_build_one]) }
 
-    it "adds multiple callbacks of the same name" do
-      one = FactoryGirl::Callback.new(:after_create, lambda {})
-      two = FactoryGirl::Callback.new(:after_create, lambda {})
-      subject.add_callback(one)
-      subject.add_callback(two)
-      subject.callbacks[:after_create].should == [one, two]
-    end
+  it "runs callbacks in the correct order" do
+    subject.run_callbacks(:after_create)
+    callback_result.should == [:after_create_one, :after_create_two]
+  end
 
-    it "adds multiple callbacks with different names" do
-      after_create = FactoryGirl::Callback.new(:after_create, lambda {})
-      after_build = FactoryGirl::Callback.new(:after_build, lambda {})
-      subject.add_callback(after_create)
-      subject.add_callback(after_build)
-      subject.callbacks[:after_create].should == [after_create]
-      subject.callbacks[:after_build].should == [after_build]
-    end
+  it "runs the correct callbacks based on name" do
+    subject.run_callbacks(:after_build)
+    callback_result.should == [:after_build_one]
   end
+end
 
-  describe "when running callbacks" do
-    it "runs all callbacks with a given name" do
-      ran = []
-      one = FactoryGirl::Callback.new(:after_create, lambda { ran << :one })
-      two = FactoryGirl::Callback.new(:after_create, lambda { ran << :two })
-      subject.add_callback(one)
-      subject.add_callback(two)
-      subject.run_callbacks(:after_create)
-      ran.should == [:one, :two]
-    end
+describe FactoryGirl::Proxy, ".ensure_strategy_exists!" do
+  it "raises when passed a nonexistent strategy" do
+    expect { FactoryGirl::Proxy.ensure_strategy_exists!(:nonexistent) }.to raise_error(ArgumentError, "Unknown strategy: nonexistent")
+  end
 
-    it "only runs callbacks with a given name" do
-      ran = []
-      after_create = FactoryGirl::Callback.new(:after_create, lambda { ran << :after_create })
-      after_build = FactoryGirl::Callback.new(:after_build, lambda { ran << :after_build })
-      subject.add_callback(after_create)
-      subject.add_callback(after_build)
-      subject.run_callbacks(:after_create)
-      ran.should == [:after_create]
-    end
+  it "doesn't raise when passed a valid strategy" do
+    expect { FactoryGirl::Proxy.ensure_strategy_exists!(:create) }.to_not raise_error
   end
 end

data/spec/factory_girl/registry_spec.rb

@@ -6,8 +6,9 @@ describe FactoryGirl::Registry do
   let(:factory)              { FactoryGirl::Factory.new(:object) }
   let(:other_factory)        { FactoryGirl::Factory.new(:string) }
   let(:factory_with_aliases) { FactoryGirl::Factory.new(:string, :aliases => aliases) }
+  let(:registry_name)        { "Factory" }
 
-  subject { FactoryGirl::Registry.new }
+  subject { FactoryGirl::Registry.new(registry_name) }
 
   it { should be_kind_of(Enumerable) }
 
@@ -17,7 +18,7 @@ describe FactoryGirl::Registry do
   end
 
   it "raises when finding an unregistered factory" do
-    expect { subject.find(:bogus) }.to raise_error(ArgumentError)
+    expect { subject.find(:bogus) }.to raise_error(ArgumentError, "Factory not registered: bogus")
   end
 
   it "adds and returns a factory" do
@@ -62,7 +63,7 @@ describe FactoryGirl::Registry do
 
   it "doesn't allow a duplicate name" do
     expect { 2.times { subject.add(factory) } }.
-      to raise_error(FactoryGirl::DuplicateDefinitionError)
+      to raise_error(FactoryGirl::DuplicateDefinitionError, "Factory already registered: object")
   end
 
   it "registers aliases" do

data/spec/spec_helper.rb

@@ -15,6 +15,8 @@ Dir["spec/support/**/*.rb"].each { |f| require File.expand_path(f) }
 RSpec.configure do |config|
   config.mock_framework = :mocha
 
+  config.include DeclarationMatchers
+
   config.after do
     FactoryGirl.factories.clear
     FactoryGirl.sequences.clear

data/spec/support/matchers/callback.rb

@@ -0,0 +1,9 @@
+RSpec::Matchers.define :have_callback do |callback_name|
+  match do |instance|
+    instance.callbacks.include?(FactoryGirl::Callback.new(callback_name, @block))
+  end
+
+  chain :with_block do |block|
+    @block = block
+  end
+end

data/spec/support/matchers/declaration.rb

@@ -0,0 +1,71 @@
+module DeclarationMatchers
+  def have_static_declaration(name)
+    DeclarationMatcher.new(:static).named(name)
+  end
+
+  def have_dynamic_declaration(name)
+    DeclarationMatcher.new(:dynamic).named(name)
+  end
+
+  def have_association_declaration(name)
+    DeclarationMatcher.new(:association).named(name)
+  end
+
+  def have_implicit_declaration(name)
+    DeclarationMatcher.new(:implicit).named(name)
+  end
+
+  class DeclarationMatcher
+    def initialize(declaration_type)
+      @declaration_type = declaration_type
+    end
+
+    def matches?(subject)
+      subject.declarations.include?(expected_declaration)
+    end
+
+    def named(name)
+      @name = name
+      self
+    end
+
+    def ignored
+      @ignored = true
+      self
+    end
+
+    def with_value(value)
+      @value = value
+      self
+    end
+
+    def with_factory(factory)
+      @factory = factory
+      self
+    end
+
+    def with_options(options)
+      @options = options
+      self
+    end
+
+    private
+
+    def expected_declaration
+      case @declaration_type
+      when :static      then FactoryGirl::Declaration::Static.new(@name, @value, ignored?)
+      when :dynamic     then FactoryGirl::Declaration::Dynamic.new(@name, ignored?, @value)
+      when :implicit    then FactoryGirl::Declaration::Implicit.new(@name, @factory, ignored?)
+      when :association then FactoryGirl::Declaration::Association.new(@name, options)
+      end
+    end
+
+    def ignored?
+      !!@ignored
+    end
+
+    def options
+      @options || {}
+    end
+  end
+end