dm-factory_girl 1.2.3

data/spec/factory_girl/proxy/attributes_for_spec.rb

@@ -0,0 +1,52 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe Factory::Proxy::AttributesFor do
+  before do
+    @proxy = Factory::Proxy::AttributesFor.new(@class)
+  end
+
+  describe "when asked to associate with another factory" do
+    before do
+      stub(Factory).create
+      @proxy.associate(:owner, :user, {})
+    end
+
+    it "should not set a value for the association" do
+      (@proxy.result.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(Factory).create
+    @proxy.association(:user).should be_nil
+    Factory.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.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[: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,81 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe Factory::Proxy::Build do
+  before do
+    @class       = Class.new
+    @instance    = "built-instance"
+    @association = "associated-instance"
+
+    stub(@class).new { @instance }
+    stub(@instance).attribute { 'value' }
+    stub(Factory).create { @association }
+    stub(@instance, :attribute=)
+    stub(@instance, :owner=)
+
+    @proxy = Factory::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
+      @proxy.associate(:owner, :user, {})
+    end
+
+    it "should create the associated instance" do
+      Factory.should have_received.create(:user, {})
+    end
+
+    it "should set the associated instance" do
+      @instance.should have_received.method_missing(:owner=, @association)
+    end
+  end
+
+  it "should call Factory.create when building an association" do
+    association = 'association'
+    attribs     = { :first_name => 'Billy' }
+    stub(Factory).create { association }
+    @proxy.association(:user, attribs).should == association
+    Factory.should have_received.create(:user, attribs)
+  end
+
+  it "should return the built instance when asked for the result" do
+    @proxy.result.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
+    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,94 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe Factory::Proxy::Create do
+  before do
+    @class       = Class.new
+    @instance    = "built-instance"
+    @association = "associated-instance"
+
+    stub(@class).new { @instance }
+    stub(Factory).create { @association }
+    stub(@instance).attribute { 'value' }
+    stub(@instance, :attribute=)
+    stub(@instance, :owner=)
+    stub(@instance).save { 'true' }
+
+    @proxy = Factory::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
+      @proxy.associate(:owner, :user, {})
+    end
+
+    it "should create the associated instance" do
+      Factory.should have_received.create(:user, {})
+    end
+
+    it "should set the associated instance" do
+      @instance.should have_received.method_missing(:owner=, @association)
+    end
+  end
+
+  it "should call Factory.create when building an association" do
+    association = 'association'
+    attribs     = { :first_name => 'Billy' }
+    stub(Factory).create { association }
+    @proxy.association(:user, attribs).should == association
+    Factory.should have_received.create(:user, attribs)
+  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
+    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
+
+  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,79 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+describe Factory::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 = Factory::Proxy::Stub.new(@class)
+  end
+
+  it "should not be a new record" do
+    @stub.result.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)
+  end
+
+  describe "when a user factory exists" do
+    before do
+      @user = "user"
+      stub(Factory).stub(:user, {}) { @user }
+    end
+
+    describe "when asked to associate with another factory" do
+      before do
+        stub(@instance).owner { @user }
+        mock(Factory).stub(:user, {}) { @user }
+        mock(@stub).set(:owner, @user)
+
+        @stub.associate(:owner, :user, {})
+      end
+
+      it "should set a value for the association" do
+        @stub.result.owner.should == @user
+      end
+    end
+
+    it "should return the association when building one" do
+      mock(Factory).create.never
+      @stub.association(:user).should == @user
+    end
+
+    describe "when asked for the result" do
+      it "should return the actual instance" do
+        @stub.result.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
+        @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,84 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe Factory::Proxy do
+  before do
+    @proxy = Factory::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 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 }.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
+  end
+end

data/spec/factory_girl/sequence_spec.rb

@@ -0,0 +1,66 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
+
+describe Factory::Sequence do
+  describe "a sequence" do
+    before do
+      @sequence = Factory::Sequence.new {|n| "=#{n}" }
+    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 "defining a sequence" do
+    before do
+      @sequence = "sequence"
+      @name     = :count
+      stub(Factory::Sequence).new { @sequence }
+    end
+
+    it "should create a new sequence" do
+      mock(Factory::Sequence).new() { @sequence }
+      Factory.sequence(@name)
+    end
+
+    it "should use the supplied block as the sequence generator" do
+      stub(Factory::Sequence).new.yields(1)
+      yielded = false
+      Factory.sequence(@name) {|n| yielded = true }
+      (yielded).should be
+    end
+  end
+
+  describe "after defining a sequence" do
+    before do
+      @sequence = "sequence"
+      @name     = :test
+      @value    = '1 2 5'
+
+      stub(@sequence).next { @value }
+      stub(Factory::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
+end