factory_girl 2.6.4 → 3.0.0.rc1

data/spec/acceptance/transient_attributes_spec.rb

@@ -2,7 +2,7 @@ require "spec_helper"
 
 describe "transient attributes" do
   before do
-    define_model("User", :name => :string, :email => :string)
+    define_model("User", name: :string, email: :string)
 
     FactoryGirl.define do
       sequence(:name) {|n| "John #{n}" }
@@ -25,7 +25,7 @@ describe "transient attributes" do
   end
 
   context "returning attributes for a factory" do
-    subject { FactoryGirl.attributes_for(:user, :rockstar => true) }
+    subject { FactoryGirl.attributes_for(:user, rockstar: true) }
     it { should_not have_key(:four) }
     it { should_not have_key(:rockstar) }
     it { should_not have_key(:upcased) }
@@ -34,10 +34,10 @@ describe "transient attributes" do
   end
 
   context "with a transient variable assigned" do
-    let(:rockstar)           { FactoryGirl.create(:user, :rockstar => true, :four => "1234") }
-    let(:rockstar_with_name) { FactoryGirl.create(:user, :name => "Jane Doe", :rockstar => true) }
-    let(:upcased_rockstar)   { FactoryGirl.create(:user, :rockstar => true, :upcased => true) }
-    let(:groupie)            { FactoryGirl.create(:user, :rockstar => false) }
+    let(:rockstar)           { FactoryGirl.create(:user, rockstar: true, four: "1234") }
+    let(:rockstar_with_name) { FactoryGirl.create(:user, name: "Jane Doe", rockstar: true) }
+    let(:upcased_rockstar)   { FactoryGirl.create(:user, rockstar: true, upcased: true) }
+    let(:groupie)            { FactoryGirl.create(:user, rockstar: false) }
 
     it "generates the correct attributes on a rockstar" do
       rockstar.name.should  == "John 1 - Rockstar"
@@ -69,28 +69,9 @@ describe "transient attributes" do
   end
 end
 
-describe "deprecated way of ignoring attributes" do
-  before do
-    define_model("User", :name => :string)
-
-    FactoryGirl.define do
-      factory :user do
-        rockstar(false).ignore
-
-        name { "John Doe#{" Rockstar" if rockstar}" }
-      end
-    end
-  end
-
-  it "assigns attributes correctly" do
-    FactoryGirl.build(:user, :rockstar => true).name.should == "John Doe Rockstar"
-    FactoryGirl.build(:user).name.should == "John Doe"
-  end
-end
-
 describe "transient sequences" do
   before do
-    define_model("User", :name => :string)
+    define_model("User", name: :string)
 
     FactoryGirl.define do
       factory :user do
@@ -108,36 +89,3 @@ describe "transient sequences" do
     FactoryGirl.build(:user).name.should == "John Doe 2"
   end
 end
-
-describe "assigning values from a transient attribute" do
-  before do
-    define_class("User") do
-      attr_accessor :foo_id, :foo_name
-    end
-
-    define_class("Foo") do
-      attr_accessor :id, :name
-      def initialize(id, name)
-        @id = id
-        @name = name
-      end
-    end
-
-    FactoryGirl.define do
-      factory :user do
-        ignore do
-          foo { Foo.new('id-of-foo', 'name-of-foo')}
-        end
-
-        foo_id   { foo.id }
-        foo_name { foo.name }
-      end
-    end
-  end
-
-  it "does not ignore an _id attribute that is an alias for a transient attribute" do
-    user = FactoryGirl.build(:user, :foo => Foo.new('passed-in-id-of-foo', 'passed-in-name-of-foo'))
-    user.foo_id.should == 'passed-in-id-of-foo'
-    user.foo_name.should == 'passed-in-name-of-foo'
-  end
-end

data/spec/factory_girl/aliases_spec.rb

@@ -21,7 +21,7 @@ end
 
 describe Factory, "after defining an alias" do
   before do
-    Factory.alias(/(.*)_suffix/, '\1')
+    FactoryGirl.aliases << [/(.*)_suffix/, '\1']
   end
 
   subject { FactoryGirl.aliases_for(:test_suffix) }

data/spec/factory_girl/attribute/association_spec.rb

@@ -3,11 +3,11 @@ require 'spec_helper'
 describe FactoryGirl::Attribute::Association do
   let(:name)        { :author }
   let(:factory)     { :user }
-  let(:overrides)   { { :first_name => "John" } }
+  let(:overrides)   { { first_name: "John" } }
   let(:association) { stub("association") }
 
   subject { FactoryGirl::Attribute::Association.new(name, factory, overrides) }
-  before  { subject.stubs(:association => association) }
+  before  { subject.stubs(association: association) }
 
   it         { should be_association }
   its(:name) { should == name }

data/spec/factory_girl/attribute/dynamic_spec.rb

@@ -29,7 +29,7 @@ describe FactoryGirl::Attribute::Dynamic do
     let(:result) { "other attribute value" }
 
     before do
-      subject.stubs(:attribute_defined_on_attribute => result)
+      subject.stubs(attribute_defined_on_attribute: result)
     end
 
     it "evaluates the attribute from the attribute" do
@@ -38,7 +38,7 @@ describe FactoryGirl::Attribute::Dynamic do
   end
 
   context "with a block returning a sequence" do
-    let(:block) { lambda { Factory.sequence(:email) } }
+    let(:block) { lambda { FactoryGirl.register_sequence(FactoryGirl::Sequence.new(:email, 1) {|n| "foo#{n}" }) } }
 
     it "raises a sequence abuse error" do
       expect { subject.to_proc.call }.to raise_error(FactoryGirl::SequenceAbuseError)

data/spec/factory_girl/declaration_list_spec.rb

@@ -4,17 +4,17 @@ 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]) }
+  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) }
+  let(:attribute_list) { stub("attribute list", define_attribute: true) }
 
   it "defines each attribute on the attribute list" do
-    FactoryGirl::AttributeList.stubs(:new => attribute_list)
+    FactoryGirl::AttributeList.stubs(new: attribute_list)
 
     subject.declare_attribute(static_declaration)
     subject.declare_attribute(dynamic_declaration)
@@ -32,9 +32,9 @@ describe FactoryGirl::DeclarationList, "#attribute_list" do
 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") }
+  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

data/spec/factory_girl/definition_proxy_spec.rb

@@ -67,8 +67,8 @@ describe FactoryGirl::DefinitionProxy, "#method_missing" do
   end
 
   it "declares an association when :factory is passed" do
-    proxy.author :factory => :user
-    subject.should have_association_declaration(:author).with_options(:factory => :user)
+    proxy.author factory: :user
+    subject.should have_association_declaration(:author).with_options(factory: :user)
   end
 
   it "declares a static attribute" do
@@ -116,8 +116,8 @@ describe FactoryGirl::DefinitionProxy, "#association" do
   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")
+    proxy.association(:association_name, { name: "Awesome" })
+    subject.should have_association_declaration(:association_name).with_options(name: "Awesome")
   end
 end
 
@@ -163,8 +163,8 @@ describe FactoryGirl::DefinitionProxy, "#factory" do
   end
 
   it "with options" do
-    proxy.factory(:child, { :awesome => true })
-    proxy.child_factories.should include([:child, { :awesome => true }, nil])
+    proxy.factory(:child, { awesome: true })
+    proxy.child_factories.should include([:child, { awesome: true }, nil])
   end
 
   it "with a block" do

data/spec/factory_girl/definition_spec.rb

@@ -17,8 +17,8 @@ describe FactoryGirl::Definition, "with a name" do
 end
 
 describe FactoryGirl::Definition, "#overridable" do
-  let(:list) { stub("declaration list", :overridable => true) }
-  before { FactoryGirl::DeclarationList.stubs(:new => list) }
+  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
@@ -70,7 +70,7 @@ describe FactoryGirl::Definition, "#processing_order" do
 
   before do
     subject.define_trait(female_trait)
-    FactoryGirl.stubs(:trait_by_name => admin_trait)
+    FactoryGirl.stubs(trait_by_name: admin_trait)
   end
 
   context "without base traits" do

data/spec/factory_girl/evaluator_class_definer_spec.rb

@@ -1,14 +1,14 @@
 require "spec_helper"
 
 describe FactoryGirl::EvaluatorClassDefiner do
-  let(:simple_attribute)                    { stub("simple attribute",   :name => :simple, :to_proc => lambda { 1 }) }
-  let(:relative_attribute)                  { stub("relative attribute", :name => :relative, :to_proc => lambda { simple + 1 }) }
-  let(:attribute_that_raises_a_second_time) { stub("attribute that would raise without a cache", :name => :raises_without_proper_cache, :to_proc => lambda { raise "failed" if @run; @run = true; nil }) }
+  let(:simple_attribute)                    { stub("simple attribute",   name: :simple, to_proc: lambda { 1 }) }
+  let(:relative_attribute)                  { stub("relative attribute", name: :relative, to_proc: lambda { simple + 1 }) }
+  let(:attribute_that_raises_a_second_time) { stub("attribute that would raise without a cache", name: :raises_without_proper_cache, to_proc: lambda { raise "failed" if @run; @run = true; nil }) }
   let(:callbacks) { [stub("callback 1"), stub("callback 2")] }
 
   let(:attributes)    { [simple_attribute, relative_attribute, attribute_that_raises_a_second_time] }
   let(:class_definer) { FactoryGirl::EvaluatorClassDefiner.new(attributes, callbacks, FactoryGirl::Evaluator) }
-  let(:evaluator)     { class_definer.evaluator_class.new(stub("build strategy", :add_observer => true)) }
+  let(:evaluator)     { class_definer.evaluator_class.new(stub("build strategy", add_observer: true)) }
 
   it "returns an evaluator when accessing the evaluator class" do
     evaluator.should be_a(FactoryGirl::Evaluator)
@@ -38,7 +38,7 @@ describe FactoryGirl::EvaluatorClassDefiner do
 
   context "with a custom evaluator as a parent class" do
     let(:child_callbacks)  { [stub("child callback 1"), stub("child callback 2")] }
-    let(:child_attributes) { [stub("child attribute", :name => :simple, :to_proc => lambda { 1 })] }
+    let(:child_attributes) { [stub("child attribute", name: :simple, to_proc: lambda { 1 })] }
     let(:child_definer)    { FactoryGirl::EvaluatorClassDefiner.new(child_attributes, child_callbacks, class_definer.evaluator_class) }
 
     subject { child_definer.evaluator_class }

data/spec/factory_girl/factory_spec.rb

@@ -12,21 +12,13 @@ describe FactoryGirl::Factory do
     @factory.name.should == @name
   end
 
-  it "responds to factory_name" do
-    @factory.factory_name.should == @name
-  end
-
   it "has a build class" do
     @factory.build_class.should == @class
   end
 
-  it "has a default strategy" do
-    @factory.default_strategy.should == :create
-  end
-
   it "passes a custom creation block" do
-    strategy = stub("strategy", :result => nil, :add_observer => true)
-    FactoryGirl::Strategy::Build.stubs(:new => strategy)
+    strategy = stub("strategy", result: nil, add_observer: true)
+    FactoryGirl::Strategy::Build.stubs(new: strategy)
     block = lambda {}
     factory = FactoryGirl::Factory.new(:object)
     factory.to_create(&block)
@@ -56,7 +48,7 @@ describe FactoryGirl::Factory do
     factory.declare_attribute(association_on_parent)
     FactoryGirl.register_factory(factory)
 
-    child_factory = FactoryGirl::Factory.new(:child_post, :parent => :post)
+    child_factory = FactoryGirl::Factory.new(:child_post, parent: :post)
     child_factory.declare_attribute(association_on_child)
 
     child_factory.associations.map(&:name).should == [:association_on_parent, :association_on_child]
@@ -94,9 +86,9 @@ describe FactoryGirl::Factory do
   describe "overriding an attribute with an alias" do
     before do
       @factory.declare_attribute(FactoryGirl::Declaration::Static.new(:test, 'original'))
-      Factory.alias(/(.*)_alias/, '\1')
+      FactoryGirl.aliases << [/(.*)_alias/, '\1']
       @result = @factory.run(FactoryGirl::Strategy::AttributesFor,
-                             :test_alias => 'new')
+                             test_alias: 'new')
     end
 
     it "uses the passed in value for the alias" do
@@ -113,20 +105,20 @@ describe FactoryGirl::Factory do
   end
 
   it "creates a new factory using the class of the parent" do
-    child = FactoryGirl::Factory.new(:child, :parent => @factory.name)
+    child = FactoryGirl::Factory.new(:child, parent: @factory.name)
     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 = FactoryGirl::Factory.new(:child, class: String, parent: @factory.name)
     child.compile
     child.build_class.should == String
   end
 end
 
 describe FactoryGirl::Factory, "when defined with a custom class" do
-  subject           { FactoryGirl::Factory.new(:author, :class => Float) }
+  subject           { FactoryGirl::Factory.new(:author, class: Float) }
   its(:build_class) { should == Float }
 end
 
@@ -142,7 +134,7 @@ describe FactoryGirl::Factory, "when given a class that overrides #to_s" do
     end
   end
 
-  subject { FactoryGirl::Factory.new(:overriding_class, :class => Overriding::Class) }
+  subject { FactoryGirl::Factory.new(:overriding_class, class: Overriding::Class) }
 
   it "sets build_class correctly" do
     subject.build_class.should == overriding_class
@@ -160,7 +152,7 @@ describe FactoryGirl::Factory, "when defined with a class instead of a name" do
 end
 
 describe FactoryGirl::Factory, "when defined with a custom class name" do
-  subject           { FactoryGirl::Factory.new(:author, :class => :argument_error) }
+  subject           { FactoryGirl::Factory.new(:author, class: :argument_error) }
   its(:build_class) { should == ArgumentError }
 end
 
@@ -191,7 +183,7 @@ describe FactoryGirl::Factory, "for namespaced class" do
   end
 
   context "with a namespaced class with Namespace::Class syntax" do
-    subject { FactoryGirl::Factory.new(name, :class => "Admin::Settings") }
+    subject { FactoryGirl::Factory.new(name, class: "Admin::Settings") }
 
     it "sets build_class correctly" do
       subject.build_class.should == settings_class
@@ -199,7 +191,7 @@ describe FactoryGirl::Factory, "for namespaced class" do
   end
 
   context "with a namespaced class with namespace/class syntax" do
-    subject { FactoryGirl::Factory.new(name, :class => "admin/settings") }
+    subject { FactoryGirl::Factory.new(name, class: "admin/settings") }
 
     it "sets build_class correctly" do
       subject.build_class.should == settings_class
@@ -207,48 +199,6 @@ describe FactoryGirl::Factory, "for namespaced class" do
   end
 end
 
-describe FactoryGirl::Factory do
-  let(:factory_with_non_existent_strategy) do
-    FactoryGirl::Factory.new(:object, :default_strategy => :nonexistent) { }
-  end
-
-  let(:factory_with_stub_strategy) do
-    FactoryGirl::Factory.new(:object, :default_strategy => :stub)
-  end
-
-  before do
-    define_class("User")
-    define_class("Admin", User)
-    FactoryGirl.register_factory(factory_with_stub_strategy)
-  end
-
-  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
-    factory_with_stub_strategy.default_strategy.should == :stub
-  end
-
-  describe "defining a child factory without setting default strategy" do
-    subject { FactoryGirl::Factory.new(:other_object, :parent => factory_with_stub_strategy.name) }
-    before  { subject.compile }
-
-    it "inherits default strategy from its parent" do
-      subject.default_strategy.should == :stub
-    end
-  end
-
-  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.compile }
-
-    it "overrides the default strategy from parent" do
-      subject.default_strategy.should == :build
-    end
-  end
-end
-
 describe FactoryGirl::Factory, "human names" do
   context "factory name without underscores" do
     subject           { FactoryGirl::Factory.new(:user) }
@@ -269,7 +219,7 @@ describe FactoryGirl::Factory, "human names" do
   end
 
   context "factory name with aliases" do
-    subject           { FactoryGirl::Factory.new(:happy_user, :aliases => [:gleeful_user, :person]) }
+    subject           { FactoryGirl::Factory.new(:happy_user, aliases: [:gleeful_user, :person]) }
     its(:names)       { should == [:happy_user, :gleeful_user, :person] }
     its(:human_names) { should == ["happy user", "gleeful user", "person"] }
   end
@@ -279,15 +229,15 @@ describe FactoryGirl::Factory, "running a factory" do
   subject              { FactoryGirl::Factory.new(:user) }
   let(:attribute)      { FactoryGirl::Attribute::Static.new(:name, "value", false) }
   let(:declaration)    { FactoryGirl::Declaration::Static.new(:name, "value", false) }
-  let(:strategy)       { stub("strategy", :result => "result", :add_observer => true) }
+  let(:strategy)       { stub("strategy", result: "result", add_observer: true) }
   let(:attributes)     { [attribute] }
-  let(:attribute_list) { stub('attribute-list', :declarations => [declaration], :to_a => attributes) }
+  let(:attribute_list) { stub('attribute-list', declarations: [declaration], to_a: attributes) }
 
   before do
-    define_model("User", :name => :string)
-    FactoryGirl::Declaration::Static.stubs(:new => declaration)
-    declaration.stubs(:to_attributes => attributes)
-    FactoryGirl::Strategy::Build.stubs(:new => strategy)
+    define_model("User", name: :string)
+    FactoryGirl::Declaration::Static.stubs(new: declaration)
+    declaration.stubs(to_attributes: attributes)
+    FactoryGirl::Strategy::Build.stubs(new: strategy)
     subject.declare_attribute(declaration)
   end
 

data/spec/factory_girl/null_factory_spec.rb

@@ -6,9 +6,8 @@ describe FactoryGirl::NullFactory do
   it { should delegate(:attributes).to(:definition) }
   it { should delegate(:constructor).to(:definition) }
 
-  its(:compile)          { should be_nil }
-  its(:class_name)       { should be_nil }
-  its(:default_strategy) { should == :create }
-  its(:attributes)       { should be_an_instance_of(FactoryGirl::AttributeList) }
-  its(:evaluator_class)  { should == FactoryGirl::Evaluator }
+  its(:compile)         { should be_nil }
+  its(:class_name)      { should be_nil }
+  its(:attributes)      { should be_an_instance_of(FactoryGirl::AttributeList) }
+  its(:evaluator_class) { should == FactoryGirl::Evaluator }
 end