factory_girl 2.2.0 → 2.3.0

data/spec/factory_girl/attribute/dynamic_spec.rb

@@ -51,6 +51,6 @@ describe FactoryGirl::Attribute::Dynamic do
 end
 
 describe FactoryGirl::Attribute::Dynamic, "with a string name" do
-  subject    { FactoryGirl::Attribute::Dynamic.new("name", nil, false) }
+  subject    { FactoryGirl::Attribute::Dynamic.new("name", false, lambda { } ) }
   its(:name) { should == :name }
 end

data/spec/factory_girl/attribute_list_spec.rb

@@ -1,14 +1,5 @@
 require "spec_helper"
 
-describe FactoryGirl::AttributeList, "overridable" do
-  it { should_not be_overridable }
-
-  it "can set itself as overridable" do
-    subject.overridable
-    subject.should be_overridable
-  end
-end
-
 describe FactoryGirl::AttributeList, "#define_attribute" do
   let(:static_attribute)  { FactoryGirl::Attribute::Static.new(:full_name, "value", false) }
   let(:dynamic_attribute) { FactoryGirl::Attribute::Dynamic.new(:email, false, lambda {|u| "#{u.full_name}@example.com" }) }
@@ -31,29 +22,20 @@ describe FactoryGirl::AttributeList, "#define_attribute" do
       2.times { subject.define_attribute(static_attribute) }
     }.to raise_error(FactoryGirl::AttributeDefinitionError, "Attribute already defined: full_name")
   end
+end
 
-  context "when set as overridable" do
-    let(:static_attribute_with_same_name) { FactoryGirl::Attribute::Static.new(:full_name, "overridden value", false) }
-    before { subject.overridable }
+describe FactoryGirl::AttributeList, "#define_attribute with a named attribute list" do
+  subject { FactoryGirl::AttributeList.new(:author) }
 
-    it "redefines the attribute if the name already exists" do
-      subject.define_attribute(static_attribute)
-      subject.define_attribute(static_attribute_with_same_name)
+  let(:association_with_same_name)      { FactoryGirl::Attribute::Association.new(:author, :author, {}) }
+  let(:association_with_different_name) { FactoryGirl::Attribute::Association.new(:author, :post, {}) }
 
-      subject.to_a.should == [static_attribute_with_same_name]
-    end
+  it "raises when the attribute is a self-referencing association" do
+    expect { subject.define_attribute(association_with_same_name) }.to raise_error(FactoryGirl::AssociationDefinitionError, "Self-referencing association 'author' in 'author'")
   end
-end
-
-describe FactoryGirl::AttributeList, "#add_callback" do
-  let(:proxy_class) { mock("klass") }
-  let(:proxy) { FactoryGirl::Proxy.new(proxy_class) }
 
-  it "allows for defining adding a callback" do
-    subject.add_callback(FactoryGirl::Callback.new(:after_create, lambda { "Called after_create" }))
-
-    subject.callbacks.first.name.should == :after_create
-    subject.callbacks.first.run(nil, nil).should == "Called after_create"
+  it "does not raise when the attribute is not a self-referencing association" do
+    expect { subject.define_attribute(association_with_different_name) }.to_not raise_error
   end
 end
 
@@ -95,35 +77,4 @@ describe FactoryGirl::AttributeList, "#apply_attributes" do
     subject.apply_attributes(list(attribute_with_same_name))
     subject.to_a.should == [full_name_attribute]
   end
-
-  context "when set as overridable" do
-    before { subject.overridable }
-
-    it "prepends applied attributes" do
-      subject.define_attribute(full_name_attribute)
-      subject.apply_attributes(list(city_attribute))
-      subject.to_a.should == [city_attribute, full_name_attribute]
-    end
-
-    it "moves non-static attributes to the end of the list" do
-      subject.define_attribute(full_name_attribute)
-      subject.apply_attributes(list(city_attribute, email_attribute))
-      subject.to_a.should == [city_attribute, full_name_attribute, email_attribute]
-    end
-
-    it "maintains order of non-static attributes" do
-      subject.define_attribute(full_name_attribute)
-      subject.define_attribute(login_attribute)
-      subject.apply_attributes(list(city_attribute, email_attribute))
-      subject.to_a.should == [city_attribute, full_name_attribute, email_attribute, login_attribute]
-    end
-
-    it "overwrites attributes that are already defined" do
-      subject.define_attribute(full_name_attribute)
-      attribute_with_same_name = FactoryGirl::Attribute::Static.new(:full_name, "Benjamin Franklin", false)
-
-      subject.apply_attributes(list(attribute_with_same_name))
-      subject.to_a.should == [attribute_with_same_name]
-    end
-  end
 end

data/spec/factory_girl/declaration_list_spec.rb

@@ -0,0 +1,71 @@
+require "spec_helper"
+
+describe FactoryGirl::DeclarationList, "#attribute_list" do
+  let(:static_attribute_1)  { stub("static attribute 1") }
+  let(:static_attribute_2)  { stub("static attribute 2") }
+  let(:dynamic_attribute_1) { stub("dynamic attribute 1") }
+  let(:static_declaration)  { stub("static declaration", :to_attributes => [static_attribute_1, static_attribute_2]) }
+  let(:dynamic_declaration) { stub("static declaration", :to_attributes => [dynamic_attribute_1]) }
+
+  it "returns an AttributeList" do
+    subject.attribute_list.should be_a(FactoryGirl::AttributeList)
+  end
+
+  let(:attribute_list) { stub("attribute list", :define_attribute => true) }
+
+  it "defines each attribute on the attribute list" do
+    FactoryGirl::AttributeList.stubs(:new => attribute_list)
+
+    subject.declare_attribute(static_declaration)
+    subject.declare_attribute(dynamic_declaration)
+
+    subject.attribute_list
+
+    attribute_list.should have_received(:define_attribute).with(static_attribute_1)
+    attribute_list.should have_received(:define_attribute).with(static_attribute_2)
+    attribute_list.should have_received(:define_attribute).with(dynamic_attribute_1)
+  end
+
+  it "creates a new attribute list upon every invocation" do
+    subject.attribute_list.should_not == subject.attribute_list
+  end
+end
+
+describe FactoryGirl::DeclarationList, "#declare_attribute" do
+  let(:declaration_1)              { stub("declaration", :name => "declaration 1") }
+  let(:declaration_2)              { stub("declaration", :name => "declaration 2") }
+  let(:declaration_with_same_name) { stub("declaration", :name => "declaration 1") }
+
+  context "when not overridable" do
+    it "adds the declaration to the list" do
+      subject.declare_attribute(declaration_1)
+      subject.to_a.should == [declaration_1]
+
+      subject.declare_attribute(declaration_2)
+      subject.to_a.should == [declaration_1, declaration_2]
+    end
+  end
+
+  context "when overridable" do
+    before { subject.overridable }
+
+    it "adds the declaration to the list" do
+      subject.declare_attribute(declaration_1)
+      subject.to_a.should == [declaration_1]
+
+      subject.declare_attribute(declaration_2)
+      subject.to_a.should == [declaration_1, declaration_2]
+    end
+
+    it "deletes declarations with the same name" do
+      subject.declare_attribute(declaration_1)
+      subject.to_a.should == [declaration_1]
+
+      subject.declare_attribute(declaration_2)
+      subject.to_a.should == [declaration_1, declaration_2]
+
+      subject.declare_attribute(declaration_with_same_name)
+      subject.to_a.should == [declaration_2, declaration_with_same_name]
+    end
+  end
+end

data/spec/factory_girl/definition_proxy_spec.rb

@@ -1,190 +1,186 @@
 require 'spec_helper'
 
-describe FactoryGirl::DefinitionProxy do
-  let(:factory) { FactoryGirl::Factory.new(:object) }
-  subject { FactoryGirl::DefinitionProxy.new(factory) }
-
-  it "adds a static attribute when an attribute is defined with a value" do
-    attribute = stub('attribute', :name => :name)
-    FactoryGirl::Attribute::Static.stubs(:new => attribute)
-    factory.stubs(:define_attribute)
-    subject.add_attribute(:name, 'value')
-    factory.ensure_compiled
-    factory.should have_received(:define_attribute).with(attribute)
-    FactoryGirl::Attribute::Static.should have_received(:new).with(:name, "value", false)
-  end
-
-  it "adds a dynamic attribute when an attribute is defined with a block" do
-    attribute = stub('attribute', :name => :name)
-    block     = lambda {}
-    FactoryGirl::Attribute::Dynamic.stubs(:new => attribute)
-    factory.stubs(:define_attribute)
-    subject.add_attribute(:name, &block)
-    factory.ensure_compiled
-    FactoryGirl::Attribute::Dynamic.should have_received(:new).with(:name, false, block)
-    factory.should have_received(:define_attribute).with(attribute)
-  end
-
-  it "raises for an attribute with a value and a block" do
+describe FactoryGirl::DefinitionProxy, "#add_attribute" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
+
+  it "raises if both a block and value are given" do
     expect {
-      subject.add_attribute(:name, 'value') {}
-    }.to raise_error(FactoryGirl::AttributeDefinitionError)
+      proxy.add_attribute(:something, "great") { "will raise!" }
+    }.to raise_error(FactoryGirl::AttributeDefinitionError, "Both value and block given")
   end
 
-  describe "child factories" do
-    its(:child_factories) { should == [] }
+  it "declares a static attribute on the factory" do
+    proxy.add_attribute(:attribute_name, "attribute value")
+    subject.should have_static_declaration(:attribute_name).with_value("attribute value")
+  end
 
-    it "is be able to add child factories" do
-      block = lambda {}
-      subject.factory(:admin, { :aliases => [:great] }, &block)
-      subject.child_factories.should == [[:admin, { :aliases => [:great] }, block]]
-    end
+  it "declares a dynamic attribute on the factory" do
+    attribute_value = lambda { "dynamic attribute" }
+    proxy.add_attribute(:attribute_name, &attribute_value)
+    subject.should have_dynamic_declaration(:attribute_name).with_value(attribute_value)
   end
+end
 
-  describe "adding an attribute using a in-line sequence" do
-    it "creates the sequence" do
-      FactoryGirl::Sequence.stubs(:new)
-      subject.sequence(:name) {}
-      FactoryGirl::Sequence.should have_received(:new).with(:name, 1)
-    end
+describe FactoryGirl::DefinitionProxy, "#add_attribute when the proxy ignores attributes" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject, true) }
 
-    it "creates the sequence with a custom default value" do
-      FactoryGirl::Sequence.stubs(:new)
-      subject.sequence(:name, "A") {}
-      FactoryGirl::Sequence.should have_received(:new).with(:name, "A")
-    end
+  it "raises if both a block and value are given" do
+    expect {
+      proxy.add_attribute(:something, "great") { "will raise!" }
+    }.to raise_error(FactoryGirl::AttributeDefinitionError, "Both value and block given")
+  end
+
+  it "declares a static attribute on the factory" do
+    proxy.add_attribute(:attribute_name, "attribute value")
+    subject.should have_static_declaration(:attribute_name).ignored.with_value("attribute value")
+  end
+
+  it "declares a dynamic attribute on the factory" do
+    attribute_value = lambda { "dynamic attribute" }
+    proxy.add_attribute(:attribute_name, &attribute_value)
+    subject.should have_dynamic_declaration(:attribute_name).ignored.with_value(attribute_value)
   end
 end
 
-describe FactoryGirl::DefinitionProxy, "with a factory mock" do
-  before do
-    define_class("FactoryMock") do
-      def add_callback(callback, &block)
-        [callback, block.call]
-      end
+describe FactoryGirl::DefinitionProxy, "#ignore" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
 
-      def to_create(&block)
-        block.call
-      end
+  it "makes all attributes added ignored" do
+    proxy.ignore do
+      add_attribute(:attribute_name, "attribute value")
     end
+
+    subject.should have_static_declaration(:attribute_name).ignored.with_value("attribute value")
   end
+end
 
-  let(:factory_mock) { FactoryMock.new }
-  subject { FactoryGirl::DefinitionProxy.new(factory_mock) }
+describe FactoryGirl::DefinitionProxy, "#method_missing" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
 
-  it "defines after_build callbacks" do
-    subject.after_build { "after_build value" }.should == [:after_build, "after_build value"]
+  it "declares an implicit declaration without args or a block" do
+    proxy.bogus
+    subject.should have_implicit_declaration(:bogus).with_factory(subject)
   end
 
-  it "defines after_create callbacks" do
-    subject.after_create { "after_create value" }.should == [:after_create, "after_create value"]
+  it "declares an association when :factory is passed" do
+    proxy.author :factory => :user
+    subject.should have_association_declaration(:author).with_options(:factory => :user)
   end
 
-  it "defines after_stub callbacks" do
-    subject.after_stub { "after_stub value" }.should == [:after_stub, "after_stub value"]
+  it "declares a static attribute" do
+    proxy.attribute_name "attribute value"
+    subject.should have_static_declaration(:attribute_name).with_value("attribute value")
   end
 
-  it "defines to_create" do
-    subject.to_create { "to_create value" }.should == "to_create value"
+  it "declares a dynamic attribute" do
+    attribute_value = lambda { "dynamic attribute" }
+    proxy.attribute_name &attribute_value
+    subject.should have_dynamic_declaration(:attribute_name).with_value(attribute_value)
   end
 end
 
-describe FactoryGirl::DefinitionProxy, "adding attributes" do
-  let(:factory)         { FactoryGirl::Factory.new(:object) }
-  subject               { FactoryGirl::DefinitionProxy.new(factory) }
-  let(:attribute)       { stub("created attribute") }
-  let(:block)           { lambda { } }
-  let(:attribute_name)  { :full_name }
-  let(:attribute_value) { "passed value" }
+describe FactoryGirl::DefinitionProxy, "#sequence" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
 
-  before { factory.stubs(:define_attribute) }
+  before      { FactoryGirl::Sequence.stubs(:new) }
 
-  context "when a block is passed" do
-    before { FactoryGirl::Attribute::Dynamic.stubs(:new => attribute) }
-
-    it "creates a dynamic attribute" do
-      subject.add_attribute(attribute_name, &block)
-      factory.ensure_compiled
-      FactoryGirl::Attribute::Dynamic.should have_received(:new).with(attribute_name, false, block)
-      factory.should have_received(:define_attribute).with(attribute)
-    end
+  it "creates a new sequence starting at 1" do
+    proxy.sequence(:great)
+    FactoryGirl::Sequence.should have_received(:new).with(:great, 1)
+  end
 
-    it "creates a dynamic attribute without the method being defined" do
-      subject.send(attribute_name, &block)
-      factory.ensure_compiled
-      FactoryGirl::Attribute::Dynamic.should have_received(:new).with(attribute_name, false, block)
-      factory.should have_received(:define_attribute).with(attribute)
-    end
+  it "creates a new sequence with an overridden starting vaue" do
+    proxy.sequence(:great, "C")
+    FactoryGirl::Sequence.should have_received(:new).with(:great, "C")
   end
 
-  context "when a value is passed" do
-    before { FactoryGirl::Attribute::Static.stubs(:new => attribute) }
+  it "creates a new sequence with a block" do
+    sequence_block = Proc.new {|n| "user+#{n}@example.com" }
+    proxy.sequence(:great, 1, &sequence_block)
+    FactoryGirl::Sequence.should have_received(:new).with(:great, 1, &sequence_block)
+  end
+end
 
-    it "creates a static attribute" do
-      subject.add_attribute(attribute_name, attribute_value)
-      factory.ensure_compiled
-      FactoryGirl::Attribute::Static.should have_received(:new).with(attribute_name, attribute_value, false)
-      factory.should have_received(:define_attribute).with(attribute)
-    end
+describe FactoryGirl::DefinitionProxy, "#association" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
 
-    it "creates a static attribute without the method being defined" do
-      subject.send(attribute_name, attribute_value)
-      factory.ensure_compiled
-      FactoryGirl::Attribute::Static.should have_received(:new).with(attribute_name, attribute_value, false)
-      factory.should have_received(:define_attribute).with(attribute)
-    end
+  it "declares an association" do
+    proxy.association(:association_name)
+    subject.should have_association_declaration(:association_name)
   end
 
-  context "when a block and value are passed" do
-    it "raises an exception" do
-      expect do
-        subject.add_attribute(attribute_name, attribute_value) { "block" }
-      end.to raise_error(FactoryGirl::AttributeDefinitionError, "Both value and block given")
-    end
+  it "declares an association with options" do
+    proxy.association(:association_name, { :name => "Awesome" })
+    subject.should have_association_declaration(:association_name).with_options(:name => "Awesome")
   end
 end
 
-describe FactoryGirl::DefinitionProxy, "#association" do
-  let(:factory)          { FactoryGirl::Factory.new(:object) }
-  subject                { FactoryGirl::DefinitionProxy.new(factory) }
-  let(:attribute)        { stub("attribute") }
-  let(:association_name) { :author }
-  let(:factory_name)     { :user }
+describe FactoryGirl::DefinitionProxy, "adding callbacks" do
+  subject        { FactoryGirl::Definition.new }
+  let(:proxy)    { FactoryGirl::DefinitionProxy.new(subject) }
+  let(:callback) { lambda { "my awesome callback!" } }
 
-  before do
-    FactoryGirl::Attribute::Association.stubs(:new => attribute)
-    factory.stubs(:define_attribute)
+  context "#after_build" do
+    before { proxy.after_build(&callback) }
+    it     { should have_callback(:after_build).with_block(callback) }
   end
 
-  context "with a factory set in the hash" do
-    let(:options) { { :factory => factory_name, :name => "John Doe" } }
+  context "#after_create" do
+    before { proxy.after_create(&callback) }
+    it     { should have_callback(:after_create).with_block(callback) }
+  end
 
-    it "defines an association attribute with the factory name" do
-      subject.association(association_name, options)
-      factory.ensure_compiled
+  context "#after_stub" do
+    before { proxy.after_stub(&callback) }
+    it     { should have_callback(:after_stub).with_block(callback) }
+  end
+end
 
-      factory.should have_received(:define_attribute).with(attribute)
-      FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, factory_name, :name => "John Doe")
-    end
+describe FactoryGirl::DefinitionProxy, "#to_create" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
 
-    it "defines an association attribute when the association is called implicitly" do
-      subject.send(association_name, options)
-      factory.ensure_compiled
+  it "accepts a block to run in place of #save!" do
+    to_create_block = lambda {|record| record.persist }
+    proxy.to_create(&to_create_block)
+    subject.to_create.should == to_create_block
+  end
+end
 
-      factory.should have_received(:define_attribute).with(attribute)
-      FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, factory_name, :name => "John Doe")
-    end
+describe FactoryGirl::DefinitionProxy, "#factory" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
+
+  it "without options" do
+    proxy.factory(:child)
+    proxy.child_factories.should include([:child, {}, nil])
   end
 
-  context "without a factory set in the hash" do
-    let(:options) { { :name => "Jane Doe" } }
+  it "with options" do
+    proxy.factory(:child, { :awesome => true })
+    proxy.child_factories.should include([:child, { :awesome => true }, nil])
+  end
 
-    it "defines an association attribute with the association name" do
-      subject.association(association_name, options)
-      factory.ensure_compiled
+  it "with a block" do
+    child_block = lambda { }
+    proxy.factory(:child, {}, &child_block)
+    proxy.child_factories.should include([:child, {}, child_block])
+  end
+end
 
-      factory.should have_received(:define_attribute).with(attribute)
-      FactoryGirl::Attribute::Association.should have_received(:new).with(association_name, association_name, options)
-    end
+describe FactoryGirl::DefinitionProxy, "#trait" do
+  subject     { FactoryGirl::Definition.new }
+  let(:proxy) { FactoryGirl::DefinitionProxy.new(subject) }
+
+  it "declares a trait" do
+    male_trait = Proc.new { gender("Male") }
+    proxy.trait(:male, &male_trait)
+    subject.should have_trait(:male).with_block(male_trait)
   end
 end