factory_girl 1.2.1 → 1.2.2

data/test/aliases_test.rb

@@ -1,29 +0,0 @@
-require 'test_helper'
-
-class AliasesTest < Test::Unit::TestCase
-
-  should "include an attribute as an alias for itself by default" do
-    assert Factory.aliases_for(:test).include?(:test)
-  end
-
-  should "include the root of a foreign key as an alias by default" do
-    assert Factory.aliases_for(:test_id).include?(:test)
-  end
-
-  should "include an attribute's foreign key as an alias by default" do
-    assert Factory.aliases_for(:test).include?(:test_id)
-  end
-
-  context "after adding an alias" do
-
-    setup do
-      Factory.alias(/(.*)_suffix/, '\1')
-    end
-
-    should "return the alias in the aliases list" do
-      assert Factory.aliases_for(:test_suffix).include?(:test)
-    end
-
-  end
-
-end

data/test/association_attribute_test.rb

@@ -1,31 +0,0 @@
-require 'test_helper'
-
-class AssociationAttributeTest < Test::Unit::TestCase
-
-  context "an association" do
-    setup do
-      @name      = :author
-      @factory   = :user
-      @overrides = { :first_name => 'John' }
-      @attr      = Factory::Attribute::Association.new(@name,
-                                                       @factory,
-                                                       @overrides)
-    end
-
-    should "have a name" do
-      assert_equal @name, @attr.name
-    end
-
-    should "tell the proxy to associate when being added to a proxy" do
-      proxy = mock('proxy')
-      proxy.expects(:associate).with(@name, @factory, @overrides)
-      @attr.add_to(proxy)
-    end
-  end
-
-  should "convert names to symbols" do
-    assert_equal :name, 
-                 Factory::Attribute::Association.new('name', :user, {}).name
-  end
-
-end

data/test/attribute_test.rb

@@ -1,32 +0,0 @@
-require 'test_helper'
-
-class AttributeTest < Test::Unit::TestCase
-
-  context "an attribute" do
-    setup do
-      @name  = :user
-      @attr  = Factory::Attribute.new(@name)
-    end
-
-    should "have a name" do
-      assert_equal @name, @attr.name
-    end
-
-    should "do nothing when being added to a proxy" do
-      @proxy = mock('proxy')
-      @proxy.expects(:set).never
-      @attr.add_to(@proxy)
-    end
-  end
-
-  should "raise an error when defining an attribute writer" do
-    assert_raise Factory::AttributeDefinitionError do
-      Factory::Attribute.new('test=')
-    end
-  end
-
-  should "convert names to symbols" do
-    assert_equal :name, Factory::Attribute.new('name').name
-  end
-
-end

data/test/attributes_for_strategy_test.rb

@@ -1,55 +0,0 @@
-require 'test_helper'
-
-class AttributesForProxyTest < Test::Unit::TestCase
-
-  context "the attributes_for proxy" do
-    setup do
-      @proxy = Factory::Proxy::AttributesFor.new(@class)
-    end
-
-    context "when asked to associate with another factory" do
-      setup do
-        Factory.stubs(:create)
-        @proxy.associate(:owner, :user, {})
-      end
-
-      should "not set a value for the association" do
-        assert !@proxy.result.key?(:owner)
-      end
-    end
-
-    should "return nil when building an association" do
-      assert_nil @proxy.association(:user)
-    end
-
-    should "not call Factory.create when building an association" do
-      Factory.expects(:create).never
-      assert_nil @proxy.association(:user)
-    end
-
-    should "always return nil when building an association" do
-      @proxy.set(:association, 'x')
-      assert_nil @proxy.association(:user)
-    end
-
-    should "return a hash when asked for the result" do
-      assert_kind_of Hash, @proxy.result
-    end
-
-    context "after setting an attribute" do
-      setup do
-        @proxy.set(:attribute, 'value')
-      end
-
-      should "set that value in the resulting hash" do
-        assert_equal 'value', @proxy.result[:attribute]
-      end
-
-      should "return that value when asked for that attribute" do
-        assert_equal 'value', @proxy.get(:attribute)
-      end
-    end
-  end
-
-end
-

data/test/build_strategy_test.rb

@@ -1,79 +0,0 @@
-require 'test_helper'
-
-class BuildProxyTest < Test::Unit::TestCase
-
-  context "with a class to build" do
-    setup do
-      @class       = Class.new
-      @instance    = mock('built-instance')
-      @association = mock('associated-instance')
-
-      @class.   stubs(:new).      returns(@instance)
-      @instance.stubs(:attribute).returns('value')
-      Factory.  stubs(:create).   returns(@association)
-      @instance.stubs(:attribute=)
-      @instance.stubs(:owner=)
-    end
-
-    context "the build proxy" do
-      setup do
-        @proxy = Factory::Proxy::Build.new(@class)
-      end
-
-      before_should "instantiate the class" do
-        @class.expects(:new).with().returns(@instance)
-      end
-
-      context "when asked to associate with another factory" do
-        setup do
-          @proxy.associate(:owner, :user, {})
-        end
-
-        before_should "create the associated instance" do
-          Factory.expects(:create).with(:user, {}).returns(@association)
-        end
-
-        before_should "set the associated instance" do
-          @instance.expects(:owner=).with(@association)
-        end
-      end
-
-      should "call Factory.create when building an association" do
-        association = 'association'
-        attribs     = { :first_name => 'Billy' }
-        Factory.expects(:create).with(:user, attribs).returns(association)
-        assert_equal association, @proxy.association(:user, attribs)
-      end
-
-      should "return the built instance when asked for the result" do
-        assert_equal @instance, @proxy.result
-      end
-
-      context "when setting an attribute" do
-        setup do
-          @proxy.set(:attribute, 'value')
-        end
-
-        before_should "set that value" do
-          @instance.expects(:attribute=).with('value')
-        end
-      end
-
-      context "when getting an attribute" do
-        setup do
-          @result = @proxy.get(:attribute)
-        end
-
-        before_should "ask the built class for the value" do
-          @instance.expects(:attribute).with().returns('value')
-        end
-
-        should "return the value for that attribute" do
-          assert_equal 'value', @result
-        end
-      end
-    end
-  end
-
-end
-

data/test/create_strategy_test.rb

@@ -1,90 +0,0 @@
-require 'test_helper'
-
-class CreateProxyTest < Test::Unit::TestCase
-
-  context "with a class to build" do
-    setup do
-      @class       = Class.new
-      @instance    = mock('built-instance')
-      @association = mock('associated-instance')
-
-      @class.   stubs(:new).      returns(@instance)
-      Factory.  stubs(:create).   returns(@association)
-      @instance.stubs(:attribute).returns('value')
-      @instance.stubs(:attribute=)
-      @instance.stubs(:owner=)
-      @instance.stubs(:save!)
-    end
-
-    context "the create proxy" do
-      setup do
-        @proxy = Factory::Proxy::Create.new(@class)
-      end
-
-      before_should "instantiate the class" do
-        @class.expects(:new).with().returns(@instance)
-      end
-
-      context "when asked to associate with another factory" do
-        setup do
-          @proxy.associate(:owner, :user, {})
-        end
-
-        before_should "create the associated instance" do
-          Factory.expects(:create).with(:user, {}).returns(@association)
-        end
-
-        before_should "set the associated instance" do
-          @instance.expects(:owner=).with(@association)
-        end
-      end
-
-      should "call Factory.create when building an association" do
-        association = 'association'
-        attribs     = { :first_name => 'Billy' }
-        Factory.expects(:create).with(:user, attribs).returns(association)
-        assert_equal association, @proxy.association(:user, attribs)
-      end
-
-      context "when asked for the result" do
-        setup do
-          @result = @proxy.result
-        end
-
-        before_should "save the instance" do
-          @instance.expects(:save!).with()
-        end
-
-        should "return the built instance" do
-          assert_equal @instance, @result
-        end
-      end
-
-      context "when setting an attribute" do
-        setup do
-          @proxy.set(:attribute, 'value')
-        end
-
-        before_should "set that value" do
-          @instance.expects(:attribute=).with('value')
-        end
-      end
-
-      context "when getting an attribute" do
-        setup do
-          @result = @proxy.get(:attribute)
-        end
-
-        before_should "ask the built class for the value" do
-          @instance.expects(:attribute).with().returns('value')
-        end
-
-        should "return the value for that attribute" do
-          assert_equal 'value', @result
-        end
-      end
-    end
-  end
-
-end
-

data/test/dynamic_attribute_test.rb

@@ -1,41 +0,0 @@
-require 'test_helper'
-
-class DynamicAttributeTest < Test::Unit::TestCase
-
-  context "a static attribute" do
-    setup do
-      @name  = :first_name
-      @block = lambda { 'value' }
-      @attr  = Factory::Attribute::Dynamic.new(@name, @block)
-    end
-
-    should "have a name" do
-      assert_equal @name, @attr.name
-    end
-
-    should "call the block to set a value" do
-      @proxy = mock('proxy')
-      @proxy.expects(:set).with(@name, 'value')
-      @attr.add_to(@proxy)
-    end
-
-    should "yield the proxy to the block when adding its value to a proxy" do
-      @block = lambda {|a| a }
-      @attr  = Factory::Attribute::Dynamic.new(:user, @block)
-      @proxy = mock('proxy')
-      @proxy.expects(:set).with(:user, @proxy)
-      @attr.add_to(@proxy)
-    end
-  end
-
-  should "raise an error when defining an attribute writer" do
-    assert_raise Factory::AttributeDefinitionError do
-      Factory::Attribute::Dynamic.new('test=', nil)
-    end
-  end
-
-  should "convert names to symbols" do
-    assert_equal :name, Factory::Attribute::Dynamic.new('name', nil).name
-  end
-
-end

data/test/factory_test.rb

@@ -1,513 +0,0 @@
-require 'test_helper'
-
-class FactoryTest < Test::Unit::TestCase
-factory = Factory.new(:post)
-  context "defining a factory" do
-    setup do
-      @name    = :user
-      @factory = mock('factory')
-      @factory.stubs(:factory_name).returns(@name)
-      @options = { :class => 'magic' }
-      Factory.stubs(:new).returns(@factory)
-    end
-
-    should "create a new factory using the specified name and options" do
-      Factory.expects(:new).with(@name, @options).returns(@factory)
-      Factory.define(@name, @options) {|f| }
-    end
-
-    should "pass the factory do the block" do
-      yielded = nil
-      Factory.define(@name) do |y|
-        yielded = y
-      end
-      assert_equal @factory, yielded
-    end
-
-    should "add the factory to the list of factories" do
-      Factory.define(@name) {|f| }
-      assert_equal Factory.factories[@name], 
-                   @factory,
-                   "Factories: #{Factory.factories.inspect}"
-    end
-  end
-  
-  context "a factory" do
-    setup do
-      @name    = :user
-      @class   = User
-      @factory = Factory.new(@name)
-    end
-
-    should "have a factory name" do
-      assert_equal @name, @factory.factory_name
-    end
-
-    should "have a build class" do
-      assert_equal @class, @factory.build_class
-    end
-    
-    should "have a default strategy" do
-      assert_equal :create, @factory.default_strategy
-    end
-
-    should "not allow the same attribute to be added twice" do
-      assert_raise(Factory::AttributeDefinitionError) do
-        2.times { @factory.add_attribute :first_name }
-      end
-    end
-    
-    should "add a static attribute when an attribute is defined with a value" do
-      attribute = mock('attribute', :name => :name)
-      Factory::Attribute::Static.
-        expects(:new).
-        with(:name, 'value').
-        returns(attribute)
-      @factory.add_attribute(:name, 'value')
-    end
-
-    should "add a dynamic attribute when an attribute is defined with a block" do
-      attribute = mock('attribute', :name => :name)
-      block     = lambda {}
-      Factory::Attribute::Dynamic.
-        expects(:new).
-        with(:name, block).
-        returns(attribute)
-      @factory.add_attribute(:name, &block)
-    end
-
-    should "raise for an attribute with a value and a block" do
-      assert_raise(Factory::AttributeDefinitionError) do
-        @factory.add_attribute(:name, 'value') {}
-      end
-    end
-    
-    context "adding an attribute using a in-line sequence" do
-      should 'create the sequence' do
-        Factory::Sequence.
-          expects(:new)
-        @factory.sequence(:name) {}
-      end    
-      
-      should 'add a dynamic attribute' do
-        attr = mock('attribute', :name => :name)      
-        Factory::Attribute::Dynamic.
-          expects(:new).
-          with(:name, instance_of(Proc)).
-          returns(attr)        
-        @factory.sequence(:name) {}
-        assert @factory.attributes.include?(attr)
-      end
-    end    
-
-    context "after adding an attribute" do
-      setup do
-        @attribute = mock('attribute')
-        @proxy     = mock('proxy')
-
-        @attribute.                stubs(:name).  returns(:name)
-        @attribute.                stubs(:add_to)
-        @proxy.                    stubs(:set)
-        @proxy.                    stubs(:result).returns('result')
-        Factory::Attribute::Static.stubs(:new).   returns(@attribute)
-        Factory::Proxy::Build.     stubs(:new).   returns(@proxy)
-
-        @factory.add_attribute(:name, 'value')
-      end
-
-      should "create the right proxy using the build class when running" do
-        Factory::Proxy::Build.
-          expects(:new).
-          with(@factory.build_class).
-          returns(@proxy)
-        @factory.run(Factory::Proxy::Build, {})
-      end
-
-      should "add the attribute to the proxy when running" do
-        @attribute.expects(:add_to).with(@proxy)
-        @factory.run(Factory::Proxy::Build, {})
-      end
-
-      should "return the result from the proxy when running" do
-        @proxy.expects(:result).with().returns('result')
-        assert_equal 'result',
-                     @factory.run(Factory::Proxy::Build, {})
-      end
-    end
-
-    should "add an association without a factory name or overrides" do
-      factory = Factory.new(:post)
-      name    = :user
-      attr    = 'attribute'
-      Factory::Attribute::Association.
-        expects(:new).
-        with(name, name, {}).
-        returns(attr)
-      factory.association(name)
-      assert factory.attributes.include?(attr)
-    end
-
-    should "add an association with overrides" do
-      factory   = Factory.new(:post)
-      name      = :user
-      attr      = 'attribute'
-      overrides = { :first_name => 'Ben' }
-      Factory::Attribute::Association.
-        expects(:new).
-        with(name, name, overrides).
-        returns(attr)
-      factory.association(name, overrides)
-      assert factory.attributes.include?(attr)
-    end
-
-    should "add an association with a factory name" do
-      factory = Factory.new(:post)
-      attr = 'attribute'
-      Factory::Attribute::Association.
-        expects(:new).
-        with(:author, :user, {}).
-        returns(attr)
-      factory.association(:author, :factory => :user)
-      assert factory.attributes.include?(attr)
-    end
-
-    should "add an association with a factory name and overrides" do
-      factory = Factory.new(:post)
-      attr = 'attribute'
-      Factory::Attribute::Association.
-        expects(:new).
-        with(:author, :user, :first_name => 'Ben').
-        returns(attr)
-      factory.association(:author, :factory => :user, :first_name => 'Ben')
-      assert factory.attributes.include?(attr)
-    end
-    
-    should "raise for a self referencing association" do
-      factory = Factory.new(:post)
-      assert_raise(Factory::AssociationDefinitionError) do
-        factory.association(:parent, :factory => :post)
-      end
-    end    
-
-    should "add an attribute using the method name when passed an undefined method" do
-      attr  = mock('attribute', :name => :name)
-      block = lambda {}
-      Factory::Attribute::Static.
-        expects(:new).
-        with(:name, 'value').
-        returns(attr)
-      @factory.send(:name, 'value')
-      assert @factory.attributes.include?(attr)
-    end
-    
-    context "when overriding generated attributes with a hash" do
-      setup do
-        @attr  = :name
-        @value = 'The price is right!'
-        @hash  = { @attr => @value }
-      end
-
-      should "return the overridden value in the generated attributes" do
-        @factory.add_attribute(@attr, 'The price is wrong, Bob!')
-        result = @factory.run(Factory::Proxy::AttributesFor, @hash)
-        assert_equal @value, result[@attr]
-      end
-
-      should "not call a lazy attribute block for an overridden attribute" do
-        @factory.add_attribute(@attr) { flunk }
-        result = @factory.run(Factory::Proxy::AttributesFor, @hash)
-      end
-
-      should "override a symbol parameter with a string parameter" do
-        @factory.add_attribute(@attr, 'The price is wrong, Bob!')
-        @hash = { @attr.to_s => @value }
-        result = @factory.run(Factory::Proxy::AttributesFor, @hash)
-        assert_equal @value, result[@attr]
-      end
-    end
-
-    context "overriding an attribute with an alias" do
-      setup do
-        @factory.add_attribute(:test, 'original')
-        Factory.alias(/(.*)_alias/, '\1')
-        @result = @factory.run(Factory::Proxy::AttributesFor, 
-                               :test_alias => 'new')
-      end
-
-      should "use the passed in value for the alias" do
-        assert_equal 'new', @result[:test_alias]
-      end
-
-      should "discard the predefined value for the attribute" do
-        assert_nil @result[:test]
-      end
-    end
-    
-    should "guess the build class from the factory name" do
-      assert_equal User, @factory.build_class
-    end
-
-    context "when defined with a custom class" do
-      setup do
-        @class   = User
-        @factory = Factory.new(:author, :class => @class)
-      end
-
-      should "use the specified class as the build class" do
-        assert_equal @class, @factory.build_class
-      end
-    end
-
-    context "when defined with a class instead of a name" do
-      setup do
-        @class   = ArgumentError
-        @name    = :argument_error
-        @factory = Factory.new(@class)
-      end
-
-      should "guess the name from the class" do
-        assert_equal @name, @factory.factory_name
-      end
-
-      should "use the class as the build class" do
-        assert_equal @class, @factory.build_class
-      end
-    end
-
-    context "when defined with a custom class name" do
-      setup do
-        @class   = ArgumentError
-        @factory = Factory.new(:author, :class => :argument_error)
-      end
-
-      should "use the specified class as the build class" do
-        assert_equal @class, @factory.build_class
-      end
-    end
-  end
-  
-  context "a factory with a name ending in s" do
-    setup do
-      @name    = :business
-      @class   = Business
-      @factory = Factory.new(@name)
-    end
-    
-    should "have a factory name" do
-      assert_equal @name, @factory.factory_name
-    end
-
-    should "have a build class" do
-      assert_equal @class, @factory.build_class
-    end
-  end
-
-  context "a factory with a string for a name" do
-    setup do
-      @name    = :user
-      @factory = Factory.new(@name.to_s) {}
-    end
-
-    should "convert the string to a symbol" do
-      assert_equal @name, @factory.factory_name
-    end
-  end
-
-  context "a factory defined with a string name" do
-    setup do
-      Factory.factories = {}
-      @name    = :user
-      @factory = Factory.define(@name.to_s) {}
-    end
-
-    should "store the factory using a symbol" do
-      assert_equal @factory, Factory.factories[@name]
-    end
-  end
-
-  context "after defining a factory" do
-    setup do
-      @name    = :user
-      @factory = mock('factory')
-
-      Factory.factories[@name] = @factory
-    end
-
-    teardown { Factory.factories.clear }
-
-    should "use Proxy::AttributesFor for Factory.attributes_for" do
-      @factory.
-        expects(:run).
-        with(Factory::Proxy::AttributesFor, :attr => 'value').
-        returns('result')
-      assert_equal 'result', Factory.attributes_for(@name, :attr => 'value')
-    end
-
-    should "use Proxy::Build for Factory.build" do
-      @factory.
-        expects(:run).
-        with(Factory::Proxy::Build, :attr => 'value').
-        returns('result')
-      assert_equal 'result', Factory.build(@name, :attr => 'value')
-    end
-
-    should "use Proxy::Create for Factory.create" do
-      @factory.
-        expects(:run).
-        with(Factory::Proxy::Create, :attr => 'value').
-        returns('result')
-      assert_equal 'result', Factory.create(@name, :attr => 'value')
-    end
-    
-    should "use Proxy::Stub for Factory.stub" do
-      @factory.
-        expects(:run).
-        with(Factory::Proxy::Stub, :attr => 'value').
-        returns('result')
-      assert_equal 'result', Factory.stub(@name, :attr => 'value')
-    end    
-    
-    should "use default strategy option as Factory.default_strategy" do
-      @factory.stubs(:default_strategy).returns(:create)
-      @factory.
-        expects(:run).
-        with(Factory::Proxy::Create, :attr => 'value').
-        returns('result')
-      assert_equal 'result', Factory.default_strategy(@name, :attr => 'value')
-    end    
-
-    should "use the default strategy for the global Factory method" do
-      @factory.stubs(:default_strategy).returns(:create)    
-      @factory.
-        expects(:run).
-        with(Factory::Proxy::Create, :attr => 'value').
-        returns('result')
-      assert_equal 'result', Factory(@name, :attr => 'value')
-    end
-
-    [:build, :create, :attributes_for, :stub].each do |method|
-      should "raise an ArgumentError on #{method} with a nonexistant factory" do
-        assert_raise(ArgumentError) { Factory.send(method, :bogus) }
-      end
-
-      should "recognize either 'name' or :name for Factory.#{method}" do
-        @factory.stubs(:run)
-        assert_nothing_raised { Factory.send(method, @name.to_s) }
-        assert_nothing_raised { Factory.send(method, @name.to_sym) }
-      end
-    end
-  end
-  
-  context 'defining a factory with a parent parameter' do
-    setup do
-      @parent = Factory.define :object do |f|
-        f.name  'Name'
-      end
-    end
-    
-    should 'raise an ArgumentError when trying to use a non-existent factory as parent' do
-      assert_raise(ArgumentError) { Factory.define(:child, :parent => :nonexsitent) {} }
-    end
-    
-    should 'create a new factory using the class of the parent' do
-      child = Factory.define(:child, :parent => :object) {}
-      assert_equal @parent.build_class, child.build_class
-    end
-
-    should 'create a new factory while overriding the parent class' do
-      class Other; end
-
-      child = Factory.define(:child, :parent => :object, :class => Other) {}
-      assert_equal Other, child.build_class
-    end
-    
-    should 'create a new factory with attributes of the parent' do
-      child = Factory.define(:child, :parent => :object) {}
-      assert_equal 1, child.attributes.size
-      assert_equal :name, child.attributes.first.name
-    end
-    
-    should 'allow to define additional attributes' do
-      child = Factory.define(:child, :parent => :object) do |f|
-        f.email 'person@somebody.com'
-      end
-      assert_equal 2, child.attributes.size
-    end
-    
-    should 'allow to override parent attributes' do
-      child = Factory.define(:child, :parent => :object) do |f|
-        f.name { 'Child Name' }
-      end
-      assert_equal 1, child.attributes.size
-      assert_kind_of Factory::Attribute::Dynamic, child.attributes.first
-    end
-  end
-  
-  context 'defining a factory with a default strategy parameter' do
-    should 'raise an ArgumentError when trying to use a non-existent factory' do
-      assert_raise(ArgumentError) { Factory.define(:object, :default_strategy => :nonexistent) {} }
-    end
-    
-    should 'create a new factory with a specified default strategy' do
-      factory = Factory.define(:object, :default_strategy => :stub) {}
-      assert_equal :stub, factory.default_strategy
-    end
-  end 
-  
-  def self.context_in_directory_with_files(*files)
-    context "in a directory with #{files.to_sentence}" do
-      setup do
-        @pwd = Dir.pwd
-        @tmp_dir = File.join(File.dirname(__FILE__), 'tmp')
-        FileUtils.mkdir_p @tmp_dir
-        Dir.chdir(@tmp_dir)
-        
-        files.each do |file|
-          FileUtils.mkdir_p File.dirname(file)
-          FileUtils.touch file
-          Factory.stubs(:require).with(file)
-        end
-      end
-      
-      teardown do
-        Dir.chdir(@pwd)
-        FileUtils.rm_rf(@tmp_dir)
-      end
-
-      yield
-    end
-  end
-  
-  def self.should_require_definitions_from(file)
-    should "load definitions from #{file}" do
-      Factory.expects(:require).with(file)
-      Factory.find_definitions
-    end    
-  end
-  
-  context_in_directory_with_files 'factories.rb' do
-    should_require_definitions_from 'factories.rb'
-  end
-  
-  %w(spec test).each do |dir|
-    context_in_directory_with_files File.join(dir, 'factories.rb') do
-      should_require_definitions_from "#{dir}/factories.rb"
-    end
-
-    context_in_directory_with_files File.join(dir, 'factories', 'post_factory.rb') do
-      should_require_definitions_from "#{dir}/factories/post_factory.rb"
-    end
-
-    context_in_directory_with_files File.join(dir, 'factories', 'post_factory.rb'), File.join(dir, 'factories', 'person_factory.rb') do
-      should_require_definitions_from "#{dir}/factories/post_factory.rb"
-      should_require_definitions_from "#{dir}/factories/person_factory.rb"
-    end
-
-    context_in_directory_with_files File.join(dir, 'factories.rb'), File.join(dir, 'factories', 'post_factory.rb'), File.join(dir, 'factories', 'person_factory.rb') do
-      should_require_definitions_from "#{dir}/factories.rb"
-      should_require_definitions_from "#{dir}/factories/post_factory.rb"
-      should_require_definitions_from "#{dir}/factories/person_factory.rb"
-    end
-  end
-
-end