factory_girl 2.0.0.beta1 → 2.0.0.beta2

data/spec/factory_girl/find_definitions_spec.rb

@@ -8,6 +8,22 @@ share_examples_for "finds definitions" do
   subject { FactoryGirl }
 end
 
+RSpec::Matchers.define :require_definitions_from do |file|
+  match do |given|
+    @has_received = have_received.method_missing(:require, file)
+    @has_received.matches?(given)
+  end
+
+  description do
+    "require definitions from #{file}"
+  end
+
+  failure_message_for_should do
+    @has_received.failure_message
+  end
+end
+
+
 describe "definition loading" do
   def self.in_directory_with_files(*files)
     before do
@@ -28,41 +44,35 @@ describe "definition loading" do
     end
   end
 
-  def require_definitions_from(file)
-    simple_matcher do |given, matcher|
-      has_received = have_received.method_missing(:require, file)
-      result = has_received.matches?(given)
-      matcher.description = "require definitions from #{file}"
-      matcher.failure_message = has_received.failure_message
-      result
-    end
-  end
-
   describe "with factories.rb" do
     in_directory_with_files 'factories.rb'
-    it_should_behave_like "finds definitions"
-    it { should require_definitions_from('factories.rb') }
+    it_should_behave_like "finds definitions" do
+      it { should require_definitions_from('factories.rb') }
+    end
   end
 
   %w(spec test).each do |dir|
     describe "with a factories file under #{dir}" do
       in_directory_with_files File.join(dir, 'factories.rb')
-      it_should_behave_like "finds definitions"
-      it { should require_definitions_from("#{dir}/factories.rb") }
+      it_should_behave_like "finds definitions" do
+        it { should require_definitions_from("#{dir}/factories.rb") }
+      end
     end
 
     describe "with a factories file under #{dir}/factories" do
       in_directory_with_files File.join(dir, 'factories', 'post_factory.rb')
-      it_should_behave_like "finds definitions"
-      it { should require_definitions_from("#{dir}/factories/post_factory.rb") }
+      it_should_behave_like "finds definitions" do
+        it { should require_definitions_from("#{dir}/factories/post_factory.rb") }
+      end
     end
 
     describe "with several factories files under #{dir}/factories" do
       in_directory_with_files File.join(dir, 'factories', 'post_factory.rb'),
                               File.join(dir, 'factories', 'person_factory.rb')
-      it_should_behave_like "finds definitions"
-      it { should require_definitions_from("#{dir}/factories/post_factory.rb") }
-      it { should require_definitions_from("#{dir}/factories/person_factory.rb") }
+      it_should_behave_like "finds definitions" do
+        it { should require_definitions_from("#{dir}/factories/post_factory.rb") }
+        it { should require_definitions_from("#{dir}/factories/person_factory.rb") }
+      end
     end
 
     describe "with several factories files under #{dir}/factories in non-alphabetical order" do
@@ -80,10 +90,11 @@ describe "definition loading" do
       in_directory_with_files File.join(dir, 'factories.rb'),
                               File.join(dir, 'factories', 'post_factory.rb'),
                               File.join(dir, 'factories', 'person_factory.rb')
-      it_should_behave_like "finds definitions"
-      it { should require_definitions_from("#{dir}/factories.rb") }
-      it { should require_definitions_from("#{dir}/factories/post_factory.rb") }
-      it { should require_definitions_from("#{dir}/factories/person_factory.rb") }
+      it_should_behave_like "finds definitions" do
+        it { should require_definitions_from("#{dir}/factories.rb") }
+        it { should require_definitions_from("#{dir}/factories/post_factory.rb") }
+        it { should require_definitions_from("#{dir}/factories/person_factory.rb") }
+      end
     end
   end
 end

data/spec/factory_girl/proxy/attributes_for_spec.rb

@@ -7,12 +7,12 @@ describe FactoryGirl::Proxy::AttributesFor do
 
   describe "when asked to associate with another factory" do
     before do
-      stub(Factory).create
+      stub(FactoryGirl).create
       @proxy.associate(:owner, :user, {})
     end
 
     it "should not set a value for the association" do
-      (@proxy.result.key?(:owner)).should_not be
+      (@proxy.result(nil).key?(:owner)).should_not be
     end
   end
 
@@ -21,9 +21,9 @@ describe FactoryGirl::Proxy::AttributesFor do
   end
 
   it "should not call Factory.create when building an association" do
-    stub(Factory).create
+    stub(FactoryGirl).create
     @proxy.association(:user).should be_nil
-    Factory.should have_received.create.never
+    FactoryGirl.should have_received.create.never
   end
 
   it "should always return nil when building an association" do
@@ -32,7 +32,7 @@ describe FactoryGirl::Proxy::AttributesFor do
   end
 
   it "should return a hash when asked for the result" do
-    @proxy.result.should be_kind_of(Hash)
+    @proxy.result(nil).should be_kind_of(Hash)
   end
 
   describe "after setting an attribute" do
@@ -41,7 +41,7 @@ describe FactoryGirl::Proxy::AttributesFor do
     end
 
     it "should set that value in the resulting hash" do
-      @proxy.result[:attribute].should == 'value'
+      @proxy.result(nil)[:attribute].should == 'value'
     end
 
     it "should return that value when asked for that attribute" do

data/spec/factory_girl/proxy/build_spec.rb

@@ -21,7 +21,7 @@ describe FactoryGirl::Proxy::Build do
     before do
       @association = "associated-instance"
       @associated_factory = "associated-factory"
-      stub(FactoryGirl).factory_by_name { @associated_factory }
+      stub(FactoryGirl).find { @associated_factory }
       stub(@associated_factory).run { @association }
       @overrides = { 'attr' => 'value' }
       @proxy.associate(:owner, :user, @overrides)
@@ -39,7 +39,7 @@ describe FactoryGirl::Proxy::Build do
   it "should run create when building an association" do
     association = "associated-instance"
     associated_factory = "associated-factory"
-    stub(FactoryGirl).factory_by_name { associated_factory }
+    stub(FactoryGirl).find { associated_factory }
     stub(associated_factory).run { association }
     overrides = { 'attr' => 'value' }
     @proxy.association(:user, overrides).should == association
@@ -47,14 +47,14 @@ describe FactoryGirl::Proxy::Build do
   end
 
   it "should return the built instance when asked for the result" do
-    @proxy.result.should == @instance
+    @proxy.result(nil).should == @instance
   end
 
   it "should run the :after_build callback when retrieving the result" do
     spy = Object.new
     stub(spy).foo
     @proxy.add_callback(:after_build, proc{ spy.foo })
-    @proxy.result
+    @proxy.result(nil)
     spy.should have_received.foo
   end
 

data/spec/factory_girl/proxy/create_spec.rb

@@ -22,7 +22,7 @@ describe FactoryGirl::Proxy::Create do
     before do
       @association = "associated-instance"
       @associated_factory = "associated-factory"
-      stub(FactoryGirl).factory_by_name { @associated_factory }
+      stub(FactoryGirl).find { @associated_factory }
       stub(@associated_factory).run { @association }
       @overrides = { 'attr' => 'value' }
       @proxy.associate(:owner, :user, @overrides)
@@ -40,7 +40,7 @@ describe FactoryGirl::Proxy::Create do
   it "should run create when building an association" do
     association = "associated-instance"
     associated_factory = "associated-factory"
-    stub(FactoryGirl).factory_by_name { associated_factory }
+    stub(FactoryGirl).find { associated_factory }
     stub(associated_factory).run { association }
     overrides = { 'attr' => 'value' }
     @proxy.association(:user, overrides).should == association
@@ -55,7 +55,7 @@ describe FactoryGirl::Proxy::Create do
       stub(@create_spy).foo
       @proxy.add_callback(:after_build,  proc{ @build_spy.foo })
       @proxy.add_callback(:after_create, proc{ @create_spy.foo })
-      @result = @proxy.result
+      @result = @proxy.result(nil)
     end
 
     it "should save the instance" do
@@ -72,6 +72,14 @@ describe FactoryGirl::Proxy::Create do
     end
   end
 
+  it "runs a custom create block" do
+    block = 'custom create block'
+    stub(block).call
+    stub(@instance).save! { raise }
+    instance = @proxy.result(block)
+    block.should have_received.call(instance)
+  end
+
   describe "when setting an attribute" do
     before do
       @proxy.set(:attribute, 'value')

data/spec/factory_girl/proxy/stub_spec.rb

@@ -13,17 +13,17 @@ describe FactoryGirl::Proxy::Stub do
   end
 
   it "should not be a new record" do
-    @stub.result.should_not be_new_record
+    @stub.result(nil).should_not be_new_record
   end
 
   it "should not be able to connect to the database" do
-    lambda { @stub.result.reload }.should raise_error(RuntimeError)
+    lambda { @stub.result(nil).reload }.should raise_error(RuntimeError)
   end
 
   describe "when a user factory exists" do
     before do
       @user = "user"
-      stub(FactoryGirl).factory_by_name { @associated_factory }
+      stub(FactoryGirl).find { @associated_factory }
       @associated_factory = 'associate-factory'
     end
 
@@ -37,7 +37,7 @@ describe FactoryGirl::Proxy::Stub do
       end
 
       it "should set a value for the association" do
-        @stub.result.owner.should == @user
+        @stub.result(nil).owner.should == @user
       end
     end
 
@@ -48,14 +48,14 @@ describe FactoryGirl::Proxy::Stub do
 
     describe "when asked for the result" do
       it "should return the actual instance" do
-        @stub.result.should == @instance
+        @stub.result(nil).should == @instance
       end
 
       it "should run the :after_stub callback" do
         @spy = Object.new
         stub(@spy).foo
         @stub.add_callback(:after_stub, proc{ @spy.foo })
-        @stub.result
+        @stub.result(nil)
         @spy.should have_received.foo
       end
     end

data/spec/factory_girl/proxy_spec.rb

@@ -23,7 +23,7 @@ describe FactoryGirl::Proxy do
   end
 
   it "should raise an error when asked for the result" do
-    lambda { @proxy.result }.should raise_error(NotImplementedError)
+    lambda { @proxy.result(nil) }.should raise_error(NotImplementedError)
   end
 
   describe "when adding callbacks" do

data/spec/factory_girl/registry_spec.rb

@@ -0,0 +1,92 @@
+require 'spec_helper'
+
+describe FactoryGirl::Registry do
+  let(:factory) { FactoryGirl::Factory.new(:object) }
+
+  subject { FactoryGirl::Registry.new }
+
+  it "finds a registered a factory" do
+    subject.add(factory)
+    subject.find(factory.name).should == factory
+  end
+
+  it "raises when finding an unregistered factory" do
+    expect { subject.find(:bogus) }.to raise_error(ArgumentError)
+  end
+
+  it "adds and returns a factory" do
+    subject.add(factory).should == factory
+  end
+
+  it "knows that a factory is registered by symbol" do
+    subject.add(factory)
+    subject.should be_registered(factory.name.to_sym)
+  end
+
+  it "knows that a factory is registered by string" do
+    subject.add(factory)
+    subject.should be_registered(factory.name.to_s)
+  end
+
+  it "knows that a factory isn't registered" do
+    subject.should_not be_registered("bogus")
+  end
+
+  it "can be accessed like a hash" do
+    subject.add(factory)
+    subject[factory.name].should == factory
+  end
+
+  it "iterates registered factories" do
+    other_factory = FactoryGirl::Factory.new(:string)
+    subject.add(factory)
+    subject.add(other_factory)
+    result = {}
+
+    subject.each do |name, value|
+      result[name] = value
+    end
+
+    result.should == { factory.name       => factory,
+                       other_factory.name => other_factory }
+  end
+
+  it "registers an sequence" do
+    sequence = FactoryGirl::Sequence.new(:email) { |n| "somebody#{n}@example.com" }
+    subject.add(sequence)
+    subject.find(:email).should == sequence
+  end
+
+  it "doesn't allow a duplicate name" do
+    expect { 2.times { subject.add(factory) } }.
+      to raise_error(FactoryGirl::DuplicateDefinitionError)
+  end
+
+  it "registers aliases" do
+    aliases = [:thing, :widget]
+    factory = FactoryGirl::Factory.new(:object, :aliases => aliases)
+    subject.add(factory)
+    aliases.each do |name|
+      subject.find(name).should == factory
+    end
+  end
+
+  context "on the FactoryGirl module" do
+    it "finds a registered a factory" do
+      FactoryGirl.register(factory)
+      FactoryGirl.find(factory.name).should == factory
+    end
+
+    it "knows that a factory is registered by symbol" do
+      FactoryGirl.register(factory)
+      FactoryGirl.should be_registered(factory.name.to_sym)
+    end
+
+    it "sets the registry" do
+      registry = FactoryGirl::Registry.new
+      FactoryGirl.registry = registry
+      FactoryGirl.registry.should == registry
+    end
+  end
+end
+

data/spec/factory_girl/sequence_spec.rb

@@ -3,40 +3,97 @@ require 'spec_helper'
 describe FactoryGirl::Sequence do
   describe "a basic sequence" do
     before do
-      @sequence = FactoryGirl::Sequence.new {|n| "=#{n}" }
+      @name = :test
+      @sequence = FactoryGirl::Sequence.new(@name) {|n| "=#{n}" }
+    end
+
+    it "has names" do
+      @sequence.names.should == [@name]
     end
 
     it "should start with a value of 1" do
+      @sequence.run.should == "=1"
+    end
+
+    it "responds to next" do
       @sequence.next.should == "=1"
     end
 
+    it "responds to default_strategy" do
+      @sequence.default_strategy.should == :create
+    end
+
+    it "runs compatible with the Factory interface" do
+      @sequence.run(nil, nil).should == "=1"
+    end
+
     describe "after being called" do
       before do
-        @sequence.next
+        @sequence.run
       end
 
       it "should use the next value" do
-        @sequence.next.should == "=2"
+        @sequence.run.should == "=2"
       end
     end
   end
-  
+
   describe "a custom sequence" do
     before do
-      @sequence = FactoryGirl::Sequence.new("A") {|n| "=#{n}" }
+      @sequence = FactoryGirl::Sequence.new(:name, "A") {|n| "=#{n}" }
+    end
+
+    it "should start with a value of A" do
+      @sequence.run.should == "=A"
+    end
+
+    describe "after being called" do
+      before do
+        @sequence.run
+      end
+
+      it "should use the next value" do
+        @sequence.run.should == "=B"
+      end
+    end
+  end
+
+  describe "a basic sequence without a block" do
+    before do
+      @sequence = FactoryGirl::Sequence.new(:name)
+    end
+
+    it "should start with a value of 1" do
+      @sequence.run.should == 1
+    end
+
+    describe "after being called" do
+      before do
+        @sequence.run
+      end
+
+      it "should use the next value" do
+        @sequence.run.should == 2
+      end
+    end
+  end
+
+  describe "a custom sequence without a block" do
+    before do
+      @sequence = FactoryGirl::Sequence.new(:name, "A")
     end
 
     it "should start with a value of A" do
-      @sequence.next.should == "=A"
+      @sequence.run.should == "A"
     end
 
     describe "after being called" do
       before do
-        @sequence.next
+        @sequence.run
       end
 
       it "should use the next value" do
-        @sequence.next.should == "=B"
+        @sequence.run.should == "B"
       end
     end
   end