factory_girl_kibiz0r 2.0.0.beta2

data/spec/factory_girl/proxy/attributes_for_spec.rb

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

data/spec/factory_girl/proxy/build_spec.rb

@@ -0,0 +1,86 @@
+require 'spec_helper'
+
+describe FactoryGirl::Proxy::Build do
+  before do
+    @class       = Class.new
+    @instance    = "built-instance"
+
+    stub(@class).new { @instance }
+    stub(@instance).attribute { 'value' }
+    stub(@instance, :attribute=)
+    stub(@instance, :owner=)
+
+    @proxy = FactoryGirl::Proxy::Build.new(@class)
+  end
+
+  it "should instantiate the class" do
+    @class.should have_received.new
+  end
+
+  describe "when asked to associate with another factory" do
+    before do
+      @association = "associated-instance"
+      @associated_factory = "associated-factory"
+      stub(FactoryGirl).factory_by_name { @associated_factory }
+      stub(@associated_factory).run { @association }
+      @overrides = { 'attr' => 'value' }
+      @proxy.associate(:owner, :user, @overrides)
+    end
+
+    it "should create the associated instance" do
+      @associated_factory.should have_received.run(FactoryGirl::Proxy::Create, @overrides)
+    end
+
+    it "should set the associated instance" do
+      @instance.should have_received.method_missing(:owner=, @association)
+    end
+  end
+
+  it "should run create when building an association" do
+    association = "associated-instance"
+    associated_factory = "associated-factory"
+    stub(FactoryGirl).factory_by_name { associated_factory }
+    stub(associated_factory).run { association }
+    overrides = { 'attr' => 'value' }
+    @proxy.association(:user, overrides).should == association
+    associated_factory.should have_received.run(FactoryGirl::Proxy::Create, overrides)
+  end
+
+  it "should return the built instance when asked for the result" do
+    @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(nil)
+    spy.should have_received.foo
+  end
+
+  describe "when setting an attribute" do
+    before do
+      stub(@instance).attribute = 'value'
+      @proxy.set(:attribute, 'value')
+    end
+
+    it "should set that value" do
+      @instance.should have_received.method_missing(:attribute=, 'value')
+    end
+  end
+
+  describe "when getting an attribute" do
+    before do
+      @result = @proxy.get(:attribute)
+    end
+
+    it "should ask the built class for the value" do
+      @instance.should have_received.attribute
+    end
+
+    it "should return the value for that attribute" do
+      @result.should == 'value'
+    end
+  end
+end
+

data/spec/factory_girl/proxy/create_spec.rb

@@ -0,0 +1,107 @@
+require 'spec_helper'
+
+describe FactoryGirl::Proxy::Create do
+  before do
+    @class       = Class.new
+    @instance    = "built-instance"
+
+    stub(@class).new { @instance }
+    stub(@instance).attribute { 'value' }
+    stub(@instance, :attribute=)
+    stub(@instance, :owner=)
+    stub(@instance).save!
+
+    @proxy = FactoryGirl::Proxy::Create.new(@class)
+  end
+
+  it "should instantiate the class" do
+    @class.should have_received.new
+  end
+
+  describe "when asked to associate with another factory" do
+    before do
+      @association = "associated-instance"
+      @associated_factory = "associated-factory"
+      stub(FactoryGirl).factory_by_name { @associated_factory }
+      stub(@associated_factory).run { @association }
+      @overrides = { 'attr' => 'value' }
+      @proxy.associate(:owner, :user, @overrides)
+    end
+
+    it "should create the associated instance" do
+      @associated_factory.should have_received.run(FactoryGirl::Proxy::Create, @overrides)
+    end
+
+    it "should set the associated instance" do
+      @instance.should have_received.method_missing(:owner=, @association)
+    end
+  end
+
+  it "should run create when building an association" do
+    association = "associated-instance"
+    associated_factory = "associated-factory"
+    stub(FactoryGirl).factory_by_name { associated_factory }
+    stub(associated_factory).run { association }
+    overrides = { 'attr' => 'value' }
+    @proxy.association(:user, overrides).should == association
+    associated_factory.should have_received.run(FactoryGirl::Proxy::Create, overrides)
+  end
+
+  describe "when asked for the result" do
+    before do
+      @build_spy = Object.new
+      @create_spy = Object.new
+      stub(@build_spy).foo
+      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(nil)
+    end
+
+    it "should save the instance" do
+      @instance.should have_received.save!
+    end
+
+    it "should return the built instance" do
+      @result.should == @instance
+    end
+
+    it "should run both the build and the create callbacks" do
+      @build_spy.should have_received.foo
+      @create_spy.should have_received.foo
+    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')
+    end
+
+    it "should set that value" do
+      @instance.should have_received.method_missing(:attribute=, 'value')
+    end
+  end
+
+  describe "when getting an attribute" do
+    before do
+      @result = @proxy.get(:attribute)
+    end
+
+    it "should ask the built class for the value" do
+      @instance.should have_received.attribute
+    end
+
+    it "should return the value for that attribute" do
+      @result.should == 'value'
+    end
+  end
+end
+

data/spec/factory_girl/proxy/stub_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+
+describe FactoryGirl::Proxy::Stub do
+  before do
+    @class = "class"
+    @instance = "instance"
+    stub(@class).new { @instance }
+    stub(@instance, :id=)
+    stub(@instance).id { 42 }
+    stub(@instance).reload { @instance.connection.reload }
+
+    @stub = FactoryGirl::Proxy::Stub.new(@class)
+  end
+
+  it "should not be a new record" do
+    @stub.result(nil).should_not be_new_record
+  end
+
+  it "should not be able to connect to the database" do
+    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 }
+      @associated_factory = 'associate-factory'
+    end
+
+    describe "when asked to associate with another factory" do
+      before do
+        stub(@instance).owner { @user }
+        mock(@associated_factory).run(FactoryGirl::Proxy::Stub, {}) { @user }
+        mock(@stub).set(:owner, @user)
+
+        @stub.associate(:owner, :user, {})
+      end
+
+      it "should set a value for the association" do
+        @stub.result(nil).owner.should == @user
+      end
+    end
+
+    it "should return the association when building one" do
+      mock(@associated_factory).run(FactoryGirl::Proxy::Stub, {}) { @user }
+      @stub.association(:user).should == @user
+    end
+
+    describe "when asked for the result" do
+      it "should return the actual instance" do
+        @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(nil)
+        @spy.should have_received.foo
+      end
+    end
+  end
+
+  describe "with an existing attribute" do
+    before do
+      @value = "value"
+      mock(@instance).send(:attribute) { @value }
+      mock(@instance).send(:attribute=, @value)
+      @stub.set(:attribute, @value)
+    end
+
+    it "should to the resulting object" do
+      @stub.attribute.should == 'value'
+    end
+
+    it "should return that value when asked for that attribute" do
+      @stub.get(:attribute).should == @value
+    end
+  end
+end

data/spec/factory_girl/proxy_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+describe FactoryGirl::Proxy do
+  before do
+    @proxy = FactoryGirl::Proxy.new(Class.new)
+  end
+
+  it "should do nothing when asked to set an attribute to a value" do
+    lambda { @proxy.set(:name, 'a name') }.should_not raise_error
+  end
+
+  it "should return nil when asked for an attribute" do
+    @proxy.get(:name).should be_nil
+  end
+
+  it "should call get for a missing method" do
+    mock(@proxy).get(:name) { "it's a name" }
+    @proxy.name.should == "it's a name"
+  end
+
+  it "should store ignored attributes" do
+    @proxy.ignore(:name, "it's a name").should == "it's a name"
+  end
+
+  it "should get an ignored attribute" do
+    @proxy.ignore(:name, "it's a name")
+    @proxy.get(:name).should == "it's a name"
+  end
+
+  it "should do nothing when asked to associate with another factory" do
+    lambda { @proxy.associate(:owner, :user, {}) }.should_not raise_error
+  end
+
+  it "should raise an error when asked for the result" do
+    lambda { @proxy.result(nil) }.should raise_error(NotImplementedError)
+  end
+
+  describe "when adding callbacks" do
+    before do
+      @first_block  = proc{ 'block 1' }
+      @second_block = proc{ 'block 2' }
+    end
+    it "should add a callback" do
+      @proxy.add_callback(:after_create, @first_block)
+      @proxy.callbacks[:after_create].should be_eql([@first_block])
+    end
+
+    it "should add multiple callbacks of the same name" do
+      @proxy.add_callback(:after_create, @first_block)
+      @proxy.add_callback(:after_create, @second_block)
+      @proxy.callbacks[:after_create].should be_eql([@first_block, @second_block])
+    end
+
+    it "should add multiple callbacks of different names" do
+      @proxy.add_callback(:after_create, @first_block)
+      @proxy.add_callback(:after_build,  @second_block)
+      @proxy.callbacks[:after_create].should be_eql([@first_block])
+      @proxy.callbacks[:after_build].should be_eql([@second_block])
+    end
+  end
+
+  describe "when running callbacks" do
+    before do
+      @first_spy = Object.new
+      @second_spy = Object.new
+      stub(@first_spy).foo
+      stub(@second_spy).foo
+    end
+
+    it "should run all callbacks with a given name" do
+      @proxy.add_callback(:after_create, proc{ @first_spy.foo })
+      @proxy.add_callback(:after_create, proc{ @second_spy.foo })
+      @proxy.run_callbacks(:after_create)
+      @first_spy.should have_received.foo
+      @second_spy.should have_received.foo
+    end
+
+    it "should only run callbacks with a given name" do
+      @proxy.add_callback(:after_create, proc{ @first_spy.foo })
+      @proxy.add_callback(:after_build,  proc{ @second_spy.foo })
+      @proxy.run_callbacks(:after_create)
+      @first_spy.should have_received.foo
+      @second_spy.should_not have_received.foo
+    end
+
+    it "should pass in the instance if the block takes an argument" do
+      @proxy.instance_variable_set("@instance", @first_spy)
+      @proxy.add_callback(:after_create, proc{|spy| spy.foo })
+      @proxy.run_callbacks(:after_create)
+      @first_spy.should have_received.foo
+    end
+
+    it "should pass in the proxy if the block takes two arguments" do
+      @proxy.instance_variable_set("@instance", @first_spy)
+      stub(@proxy).bar
+      @proxy.add_callback(:after_create, proc {|spy, proxy| spy.foo; proxy.bar })
+      @proxy.run_callbacks(:after_create)
+      @first_spy.should have_received.foo
+      @proxy.should have_received.bar
+    end
+  end
+end

data/spec/factory_girl/registry_spec.rb

@@ -0,0 +1,83 @@
+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 |value|
+      result << value
+    end
+
+    result.should =~ [factory, 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
+
+  it "is enumerable" do
+    should be_kind_of(Enumerable)
+  end
+
+  it "clears registered factories" do
+    subject.add(factory)
+    subject.clear
+    subject.count.should == 0
+  end
+end
+

data/spec/factory_girl/sequence_spec.rb

@@ -0,0 +1,96 @@
+require 'spec_helper'
+
+describe FactoryGirl::Sequence do
+  describe "a basic sequence" do
+    before do
+      @name = :test
+      @sequence = FactoryGirl::Sequence.new(@name) {|n| "=#{n}" }
+    end
+
+    it "has a name" do
+      @sequence.name.should == @name
+    end
+
+    it "has names" do
+      @sequence.names.should == [@name]
+    end
+
+    it "should start with a value of 1" do
+      @sequence.next.should == "=1"
+    end
+
+    it "responds to default_strategy" do
+      @sequence.default_strategy.should == :create
+    end
+
+    describe "after being called" do
+      before do
+        @sequence.next
+      end
+
+      it "should use the next value" do
+        @sequence.next.should == "=2"
+      end
+    end
+  end
+
+  describe "a custom sequence" do
+    before do
+      @sequence = FactoryGirl::Sequence.new(:name, "A") {|n| "=#{n}" }
+    end
+
+    it "should start with a value of A" do
+      @sequence.next.should == "=A"
+    end
+
+    describe "after being called" do
+      before do
+        @sequence.next
+      end
+
+      it "should use the next value" do
+        @sequence.next.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.next.should == 1
+    end
+
+    describe "after being called" do
+      before do
+        @sequence.next
+      end
+
+      it "should use the next value" do
+        @sequence.next.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"
+    end
+
+    describe "after being called" do
+      before do
+        @sequence.next
+      end
+
+      it "should use the next value" do
+        @sequence.next.should == "B"
+      end
+    end
+  end
+end

data/spec/factory_girl_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe FactoryGirl do
+  let(:factory) { FactoryGirl::Factory.new(:object) }
+  let(:sequence) { FactoryGirl::Sequence.new(:email) }
+
+  it "finds a registered a factory" do
+    FactoryGirl.register_factory(factory)
+    FactoryGirl.factory_by_name(factory.name).should == factory
+  end
+
+  it "finds a registered a sequence" do
+    FactoryGirl.register_sequence(sequence)
+    FactoryGirl.sequence_by_name(sequence.name).should == sequence
+  end
+end
+