factory_girl 2.0.4 → 2.0.5

data/spec/factory_girl/registry_spec.rb

@@ -1,10 +1,16 @@
 require 'spec_helper'
 
 describe FactoryGirl::Registry do
-  let(:factory) { FactoryGirl::Factory.new(:object) }
+  let(:aliases)              { [:thing, :widget] }
+  let(:sequence)             { FactoryGirl::Sequence.new(:email) { |n| "somebody#{n}@example.com" } }
+  let(:factory)              { FactoryGirl::Factory.new(:object) }
+  let(:other_factory)        { FactoryGirl::Factory.new(:string) }
+  let(:factory_with_aliases) { FactoryGirl::Factory.new(:string, :aliases => aliases) }
 
   subject { FactoryGirl::Registry.new }
 
+  it { should be_kind_of(Enumerable) }
+
   it "finds a registered a factory" do
     subject.add(factory)
     subject.find(factory.name).should == factory
@@ -38,33 +44,18 @@ describe FactoryGirl::Registry do
   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]
+    subject.to_a.should =~ [factory, other_factory]
   end
 
   it "iterates registered factories uniquely with aliases" do
-    other_factory = FactoryGirl::Factory.new(:string, :aliases => [:awesome])
     subject.add(factory)
-    subject.add(other_factory)
-    result = []
-
-    subject.each do |value|
-      result << value
-    end
-
-    result.should =~ [factory, other_factory]
+    subject.add(factory_with_aliases)
+    subject.to_a.should =~ [factory, factory_with_aliases]
   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
@@ -75,22 +66,15 @@ describe FactoryGirl::Registry do
   end
 
   it "registers aliases" do
-    aliases = [:thing, :widget]
-    factory = FactoryGirl::Factory.new(:object, :aliases => aliases)
-    subject.add(factory)
+    subject.add(factory_with_aliases)
     aliases.each do |name|
-      subject.find(name).should == factory
+      subject.find(name).should == factory_with_aliases
     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
+    subject.count.should be_zero
   end
 end
-

data/spec/factory_girl/sequence_spec.rb

@@ -2,95 +2,47 @@ 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
+    let(:name) { :test }
+    subject    { FactoryGirl::Sequence.new(name) {|n| "=#{n}" } }
 
-    it "has names" do
-      @sequence.names.should == [@name]
-    end
-
-    it "should start with a value of 1" do
-      @sequence.next.should == "=1"
-    end
+    its(:name)             { should == name }
+    its(:names)            { should == [name] }
+    its(:next)             { should == "=1" }
+    its(:default_strategy) { should == :create }
 
-    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
+    describe "when incrementing" do
+      before     { subject.next }
+      its(:next) { should == "=2" }
     end
   end
 
   describe "a custom sequence" do
-    before do
-      @sequence = FactoryGirl::Sequence.new(:name, "A") {|n| "=#{n}" }
-    end
+    subject    { FactoryGirl::Sequence.new(:name, "A") {|n| "=#{n}" } }
+    its(:next) { should == "=A" }
 
-    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
+    describe "when incrementing" do
+      before     { subject.next }
+      its(:next) { should == "=B" }
     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
+    subject    { FactoryGirl::Sequence.new(:name) }
+    its(:next) { should == 1 }
 
-    describe "after being called" do
-      before do
-        @sequence.next
-      end
-
-      it "should use the next value" do
-        @sequence.next.should == 2
-      end
+    describe "when incrementing" do
+      before     { subject.next }
+      its(:next) { should == 2 }
     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
+    subject    { FactoryGirl::Sequence.new(:name, "A") }
+    its(:next) { should == "A" }
 
-      it "should use the next value" do
-        @sequence.next.should == "B"
-      end
+    describe "when incrementing" do
+      before     { subject.next }
+      its(:next) { should == "B" }
     end
   end
 end

data/spec/factory_girl_spec.rb

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

data/spec/spec_helper.rb

@@ -4,93 +4,19 @@ $LOAD_PATH << File.join(File.dirname(__FILE__))
 require 'rubygems'
 require 'rspec'
 require 'rspec/autorun'
-require 'rr'
 
 require 'factory_girl'
+require "mocha"
+require "bourne"
 
-module RR
-  module Adapters
-    module Rspec
-      def self.included(mod)
-        RSpec.configuration.backtrace_clean_patterns.push(RR::Errors::BACKTRACE_IDENTIFIER)
-      end
-    end
-  end
-end
+Dir["spec/support/**/*.rb"].each { |f| require File.expand_path(f) }
 
 RSpec.configure do |config|
-  config.mock_framework = :rr
-  RSpec::Core::ExampleGroup.send(:include, RR::Adapters::Rspec)
+  config.mock_framework = :mocha
+
   config.after do
     FactoryGirl.factories.clear
     FactoryGirl.sequences.clear
     FactoryGirl.traits.clear
   end
 end
-
-module DefinesConstants
-  def self.included(example_group)
-    example_group.class_eval do
-      before do
-        @defined_constants ||= []
-        @created_tables ||= []
-      end
-
-      after do
-        @defined_constants.reverse.each do |path|
-          namespace, class_name = *constant_path(path)
-          namespace.send(:remove_const, class_name)
-        end
-        @defined_constants.clear
-
-        @created_tables.each do |table_name|
-          ActiveRecord::Base.
-            connection.
-            execute("DROP TABLE IF EXISTS #{table_name}")
-        end
-        @created_tables.clear
-      end
-
-      def define_class(path, base = Object, &block)
-        namespace, class_name = *constant_path(path)
-        klass = Class.new(base)
-        namespace.const_set(class_name, klass)
-        klass.class_eval(&block) if block_given?
-        @defined_constants << path
-        klass
-      end
-
-      def define_model(name, columns = {}, &block)
-        model = define_class(name, ActiveRecord::Base, &block)
-        create_table(model.table_name) do |table|
-          columns.each do |name, type|
-            table.column name, type
-          end
-        end
-        model
-      end
-
-      def create_table(table_name, &block)
-        connection = ActiveRecord::Base.connection
-
-        begin
-          connection.execute("DROP TABLE IF EXISTS #{table_name}")
-          connection.create_table(table_name, &block)
-          @created_tables << table_name
-          connection
-        rescue Exception => exception
-          connection.execute("DROP TABLE IF EXISTS #{table_name}")
-          raise exception
-        end
-      end
-
-      def constant_path(constant_name)
-        names = constant_name.split('::')
-        class_name = names.pop
-        namespace = names.inject(Object) { |result, name| result.const_get(name) }
-        [namespace, class_name]
-      end
-    end
-  end
-end
-

data/spec/support/macros/define_constant.rb

@@ -0,0 +1,86 @@
+require 'active_record'
+
+module DefineConstantMacros
+  def define_class(path, base = Object, &block)
+    namespace, class_name = *constant_path(path)
+    klass = Class.new(base)
+    namespace.const_set(class_name, klass)
+    klass.class_eval(&block) if block_given?
+    @defined_constants << path
+    klass
+  end
+
+  def define_model(name, columns = {}, &block)
+    model = define_class(name, ActiveRecord::Base, &block)
+    create_table(model.table_name) do |table|
+      columns.each do |name, type|
+        table.column name, type
+      end
+    end
+    model
+  end
+
+  def create_table(table_name, &block)
+    connection = ActiveRecord::Base.connection
+
+    begin
+      connection.execute("DROP TABLE IF EXISTS #{table_name}")
+      connection.create_table(table_name, &block)
+      @created_tables << table_name
+      connection
+    rescue Exception => exception
+      connection.execute("DROP TABLE IF EXISTS #{table_name}")
+      raise exception
+    end
+  end
+
+  def constant_path(constant_name)
+    names = constant_name.split('::')
+    class_name = names.pop
+    namespace = names.inject(Object) { |result, name| result.const_get(name) }
+    [namespace, class_name]
+  end
+
+  def default_constants
+    @defined_constants ||= []
+    @created_tables    ||= []
+  end
+
+  def clear_generated_constants
+    @defined_constants.reverse.each do |path|
+      namespace, class_name = *constant_path(path)
+      namespace.send(:remove_const, class_name)
+    end
+
+    @defined_constants.clear
+  end
+
+  def clear_generated_tables
+    @created_tables.each do |table_name|
+      ActiveRecord::Base.
+        connection.
+        execute("DROP TABLE IF EXISTS #{table_name}")
+    end
+    @created_tables.clear
+  end
+end
+
+RSpec.configure do |config|
+  config.include DefineConstantMacros
+
+  config.before(:all) do
+    ActiveRecord::Base.establish_connection(
+      :adapter  => 'sqlite3',
+      :database => File.join(File.dirname(__FILE__), 'test.db')
+    )
+  end
+
+  config.before do
+    default_constants
+  end
+
+  config.after do
+    clear_generated_constants
+    clear_generated_tables
+  end
+end

data/spec/support/shared_examples/proxy.rb

@@ -0,0 +1,99 @@
+shared_examples_for "proxy without association support" do
+  it "doesn't raise when asked to associate with another factory" do
+    expect { subject.associate(:owner, :user, {}) }.to_not raise_error
+  end
+
+  it "does not call FactoryGirl.create when building an association" do
+    FactoryGirl.stubs(:create)
+    subject.association(:user)
+    FactoryGirl.should have_received(:create).never
+  end
+
+  it "returns nil when building an association" do
+    subject.set(:association, 'x')
+    subject.association(:user).should be_nil
+  end
+end
+
+shared_examples_for "proxy with association support" do |factory_girl_proxy_class|
+  let(:factory_name)     { :user }
+  let(:association_name) { :owner }
+  let(:factory)          { stub("associate_factory") }
+  let(:overrides)        { { :one => 1, :two => 2 } }
+
+  before do
+    FactoryGirl.stubs(:factory_by_name => factory)
+    instance.stubs(association_name => factory_name)
+    factory.stubs(:run => factory_name)
+    subject.stubs(:set)
+  end
+
+  it "sets a value for the association" do
+    subject.associate(association_name, factory_name, {})
+    subject.result(nil).send(association_name).should == factory_name
+  end
+
+  it "sets the association attribute as the factory" do
+    subject.associate(association_name, factory_name, {})
+    subject.should have_received(:set).with(association_name, factory_name)
+  end
+
+  it "runs the factory with the correct proxy class" do
+    subject.associate(association_name, factory_name, {})
+    factory.should have_received(:run).with(factory_girl_proxy_class, {})
+  end
+
+  it "runs the factory with the correct proxy class and overrides" do
+    subject.associate(association_name, factory_name, overrides)
+    factory.should have_received(:run).with(factory_girl_proxy_class, overrides)
+  end
+end
+
+shared_examples_for "proxy with standard getters and setters" do |attribute, value|
+  before do
+    instance.stubs(:"#{attribute}=" => value, :"#{attribute}" => value)
+  end
+
+  describe "when setting an attribute" do
+    before do
+      subject.set(attribute, value)
+    end
+
+    its(attribute) { should == value }
+    it { instance.should have_received(:"#{attribute}=").with(value) }
+  end
+
+  describe "when setting an ignored attribute" do
+    before do
+      subject.set(attribute, value, true)
+    end
+
+    it { instance.should have_received(:"#{attribute}=").with(value).never }
+  end
+
+  describe "when getting an attribute" do
+    it { subject.get(attribute).should == value }
+
+    it "retrieves the value from the instance" do
+      subject.get(attribute)
+      instance.should have_received(:"#{attribute}")
+    end
+  end
+end
+
+shared_examples_for "proxy with callbacks" do |callback_name|
+  let(:callback) { stub("#{callback_name} callback", :foo => nil) }
+
+  before do
+    subject.add_callback(callback_name, proc { callback.foo })
+  end
+
+  it "runs the #{callback_name} callback" do
+    subject.result(nil)
+    callback.should have_received(:foo).once
+  end
+
+  it "returns the proxy instance" do
+    subject.result(nil).should == instance
+  end
+end