Use a registry class for keeping factories and sequences. Treat
sequences largely like factories. Refactor name and aliases into a common names method.
This commit is contained in:
parent
0946f6d4bb
commit
5aea0f4096
|
@ -3,6 +3,7 @@ require 'factory_girl/proxy/build'
|
|||
require 'factory_girl/proxy/create'
|
||||
require 'factory_girl/proxy/attributes_for'
|
||||
require 'factory_girl/proxy/stub'
|
||||
require 'factory_girl/registry'
|
||||
require 'factory_girl/factory'
|
||||
require 'factory_girl/attribute'
|
||||
require 'factory_girl/attribute/static'
|
||||
|
|
|
@ -59,7 +59,7 @@ module FactoryGirl
|
|||
# or association with the same name. This means that:
|
||||
#
|
||||
# factory :user do
|
||||
# email { Factory.next(:email) }
|
||||
# email { create(:email) }
|
||||
# association :account
|
||||
# end
|
||||
#
|
||||
|
@ -73,11 +73,7 @@ module FactoryGirl
|
|||
# are equivilent.
|
||||
def method_missing(name, *args, &block)
|
||||
if args.empty? && block.nil?
|
||||
if sequence = FactoryGirl.sequences[name]
|
||||
add_attribute(name) { sequence.next }
|
||||
else
|
||||
association(name)
|
||||
end
|
||||
else
|
||||
add_attribute(name, *args, &block)
|
||||
end
|
||||
|
@ -95,13 +91,13 @@ module FactoryGirl
|
|||
# sequence(:email) { |n| "person#{n}@example.com" }
|
||||
#
|
||||
# factory :user do
|
||||
# email { Factory.next(:email) }
|
||||
# email { FactoryGirl.create(:email) }
|
||||
# end
|
||||
#
|
||||
# Except that no globally available sequence will be defined.
|
||||
def sequence(name, start_value = 1, &block)
|
||||
sequence = Sequence.new(start_value, &block)
|
||||
add_attribute(name) { sequence.next }
|
||||
sequence = Sequence.new(name, start_value, &block)
|
||||
add_attribute(name) { sequence.run }
|
||||
end
|
||||
|
||||
# Adds an attribute that builds an association. The associated instance will
|
||||
|
|
|
@ -1,29 +1,14 @@
|
|||
module FactoryGirl
|
||||
class << self
|
||||
attr_accessor :factories #:nodoc:
|
||||
def self.factories
|
||||
puts "WARNING: FactoryGirl.factories is deprecated."
|
||||
puts "Use FactoryGirl.registry instead."
|
||||
registry
|
||||
end
|
||||
|
||||
self.factories = {}
|
||||
|
||||
def self.factory_by_name(name)
|
||||
factories[name.to_sym] or raise ArgumentError.new("No such factory: #{name.to_s}")
|
||||
end
|
||||
|
||||
def self.register_factory(factory, options = {})
|
||||
if options[:as]
|
||||
name = options[:as]
|
||||
else
|
||||
name = factory.name
|
||||
factory.aliases.each do |alias_name|
|
||||
register_factory(factory, :as => alias_name)
|
||||
end
|
||||
end
|
||||
|
||||
if self.factories[name]
|
||||
raise DuplicateDefinitionError, "Factory already defined: #{name}"
|
||||
end
|
||||
|
||||
self.factories[name] = factory
|
||||
puts "WARNING: FactoryGirl.factory_by_name is deprecated."
|
||||
puts "Use FactoryGirl.find instead."
|
||||
registry.find(name)
|
||||
end
|
||||
|
||||
# Raised when a factory is defined that attempts to instantiate itself.
|
||||
|
@ -119,7 +104,7 @@ module FactoryGirl
|
|||
attributes.select {|attribute| attribute.is_a?(Attribute::Association) }
|
||||
end
|
||||
|
||||
# Alternate names for this factory.
|
||||
# Names for this factory, including aliases.
|
||||
#
|
||||
# Example:
|
||||
#
|
||||
|
@ -144,8 +129,8 @@ module FactoryGirl
|
|||
#
|
||||
# FactoryGirl.create(:post).author.class
|
||||
# # => User
|
||||
def aliases
|
||||
@options[:aliases] || []
|
||||
def names
|
||||
[name] + (@options[:aliases] || [])
|
||||
end
|
||||
|
||||
def to_create(&block)
|
||||
|
|
|
@ -14,12 +14,12 @@ module FactoryGirl
|
|||
end
|
||||
|
||||
def associate(name, factory_name, overrides)
|
||||
factory = FactoryGirl.factory_by_name(factory_name)
|
||||
factory = FactoryGirl.find(factory_name)
|
||||
set(name, factory.run(Proxy::Create, overrides))
|
||||
end
|
||||
|
||||
def association(factory_name, overrides = {})
|
||||
factory = FactoryGirl.factory_by_name(factory_name)
|
||||
factory = FactoryGirl.find(factory_name)
|
||||
factory.run(Proxy::Create, overrides)
|
||||
end
|
||||
|
||||
|
|
|
@ -46,12 +46,12 @@ module FactoryGirl
|
|||
end
|
||||
|
||||
def associate(name, factory_name, overrides)
|
||||
factory = FactoryGirl.factory_by_name(factory_name)
|
||||
factory = FactoryGirl.find(factory_name)
|
||||
set(name, factory.run(Proxy::Stub, overrides))
|
||||
end
|
||||
|
||||
def association(factory_name, overrides = {})
|
||||
factory = FactoryGirl.factory_by_name(factory_name)
|
||||
factory = FactoryGirl.find(factory_name)
|
||||
factory.run(Proxy::Stub, overrides)
|
||||
end
|
||||
|
||||
|
|
|
@ -0,0 +1,59 @@
|
|||
module FactoryGirl
|
||||
class Registry
|
||||
def initialize
|
||||
@items = {}
|
||||
end
|
||||
|
||||
def add(item)
|
||||
item.names.each { |name| add_as(name, item) }
|
||||
item
|
||||
end
|
||||
|
||||
def find(name)
|
||||
@items[name.to_sym] or raise ArgumentError.new("Not registered: #{name.to_s}")
|
||||
end
|
||||
|
||||
def each(&block)
|
||||
@items.each(&block)
|
||||
end
|
||||
|
||||
def [](name)
|
||||
find(name)
|
||||
end
|
||||
|
||||
def registered?(name)
|
||||
@items.key?(name.to_sym)
|
||||
end
|
||||
|
||||
private
|
||||
|
||||
def add_as(name, item)
|
||||
if registered?(name)
|
||||
raise DuplicateDefinitionError, "Already defined: #{name}"
|
||||
else
|
||||
@items[name.to_sym] = item
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
def self.register(item)
|
||||
registry.add(item)
|
||||
end
|
||||
|
||||
def self.registered?(name)
|
||||
registry.registered?(name)
|
||||
end
|
||||
|
||||
def self.find(name)
|
||||
registry.find(name)
|
||||
end
|
||||
|
||||
def self.registry
|
||||
@registry ||= Registry.new
|
||||
end
|
||||
|
||||
def self.registry=(registry)
|
||||
@registry = registry
|
||||
end
|
||||
end
|
||||
|
|
@ -6,23 +6,37 @@ module FactoryGirl
|
|||
# Sequences are defined using sequence within a FactoryGirl.define block.
|
||||
# Sequence values are generated using next.
|
||||
class Sequence
|
||||
|
||||
def initialize(value = 1, &proc) #:nodoc:
|
||||
def initialize(name, value = 1, &proc) #:nodoc:
|
||||
@name = name
|
||||
@proc = proc
|
||||
@value = value || 1
|
||||
end
|
||||
|
||||
# Returns the next value for this sequence
|
||||
def next
|
||||
def run(proxy_class = nil, overrides = {})
|
||||
@proc ? @proc.call(@value) : @value
|
||||
ensure
|
||||
@value = @value.next
|
||||
end
|
||||
|
||||
def next
|
||||
puts "WARNING: FactoryGirl::Sequence#next is deprecated."
|
||||
puts "Use #run instead."
|
||||
run
|
||||
end
|
||||
|
||||
class << self
|
||||
attr_accessor :sequences #:nodoc:
|
||||
def default_strategy
|
||||
:create
|
||||
end
|
||||
|
||||
def names
|
||||
[@name]
|
||||
end
|
||||
end
|
||||
|
||||
def self.sequences
|
||||
puts "WARNING: FactoryGirl.sequences is deprecated."
|
||||
puts "Use FactoryGirl.registry instead."
|
||||
registry
|
||||
end
|
||||
self.sequences = {}
|
||||
end
|
||||
|
|
|
@ -3,7 +3,7 @@ module FactoryGirlStepHelpers
|
|||
def convert_association_string_to_instance(factory_name, assignment)
|
||||
attribute, value = assignment.split(':', 2)
|
||||
return if value.blank?
|
||||
factory = FactoryGirl.factory_by_name(factory_name)
|
||||
factory = FactoryGirl.find(factory_name)
|
||||
attributes = convert_human_hash_to_attribute_hash({attribute => value.strip}, factory.associations)
|
||||
attributes_find = {}
|
||||
attributes.each do |k, v|
|
||||
|
@ -28,7 +28,7 @@ end
|
|||
|
||||
World(FactoryGirlStepHelpers)
|
||||
|
||||
FactoryGirl.factories.values.each do |factory|
|
||||
FactoryGirl.registry.each do |name, factory|
|
||||
Given /^the following (?:#{factory.human_name}|#{factory.human_name.pluralize}) exists?:$/ do |table|
|
||||
table.hashes.each do |human_hash|
|
||||
attributes = convert_human_hash_to_attribute_hash(human_hash, factory.associations)
|
||||
|
|
|
@ -29,7 +29,7 @@ module FactoryGirl
|
|||
instance = Factory.new(name.underscore, :class => self)
|
||||
proxy = FactoryGirl::DefinitionProxy.new(instance)
|
||||
proxy.instance_eval(&block)
|
||||
FactoryGirl.register_factory(instance)
|
||||
FactoryGirl.register(instance)
|
||||
end
|
||||
|
||||
end
|
||||
|
|
|
@ -17,13 +17,13 @@ module FactoryGirl
|
|||
proxy = FactoryGirl::DefinitionProxy.new(factory)
|
||||
proxy.instance_eval(&block)
|
||||
if parent = options.delete(:parent)
|
||||
factory.inherit_from(FactoryGirl.factory_by_name(parent))
|
||||
factory.inherit_from(FactoryGirl.find(parent))
|
||||
end
|
||||
FactoryGirl.register_factory(factory)
|
||||
FactoryGirl.register(factory)
|
||||
end
|
||||
|
||||
def sequence(name, start_value = 1, &block)
|
||||
FactoryGirl.sequences[name] = Sequence.new(start_value, &block)
|
||||
FactoryGirl.register(Sequence.new(name, start_value, &block))
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
|
@ -42,7 +42,7 @@ module FactoryGirl
|
|||
module ClassMethods #:nodoc:
|
||||
|
||||
def generate(overrides = {}, &block)
|
||||
factory = FactoryGirl.factory_by_name(name.underscore)
|
||||
factory = FactoryGirl.find(name.underscore)
|
||||
instance = factory.run(Proxy::Build, overrides)
|
||||
instance.save
|
||||
yield(instance) if block_given?
|
||||
|
@ -50,14 +50,14 @@ module FactoryGirl
|
|||
end
|
||||
|
||||
def generate!(overrides = {}, &block)
|
||||
factory = FactoryGirl.factory_by_name(name.underscore)
|
||||
factory = FactoryGirl.find(name.underscore)
|
||||
instance = factory.run(Proxy::Create, overrides)
|
||||
yield(instance) if block_given?
|
||||
instance
|
||||
end
|
||||
|
||||
def spawn(overrides = {}, &block)
|
||||
factory = FactoryGirl.factory_by_name(name.underscore)
|
||||
factory = FactoryGirl.find(name.underscore)
|
||||
instance = factory.run(Proxy::Build, overrides)
|
||||
yield(instance) if block_given?
|
||||
instance
|
||||
|
|
|
@ -28,7 +28,7 @@ module FactoryGirl
|
|||
module ClassMethods #:nodoc:
|
||||
|
||||
def make(overrides = {})
|
||||
FactoryGirl.factory_by_name(name.underscore).run(Proxy::Create, overrides)
|
||||
FactoryGirl.find(name.underscore).run(Proxy::Create, overrides)
|
||||
end
|
||||
|
||||
end
|
||||
|
|
|
@ -15,7 +15,7 @@ module FactoryGirl
|
|||
# A set of attributes that can be used to build an instance of the class
|
||||
# this factory generates.
|
||||
def attributes_for(name, overrides = {})
|
||||
FactoryGirl.factory_by_name(name).run(Proxy::AttributesFor, overrides)
|
||||
FactoryGirl.find(name).run(Proxy::AttributesFor, overrides)
|
||||
end
|
||||
|
||||
# Generates and returns an instance from this factory. Attributes can be
|
||||
|
@ -31,7 +31,7 @@ module FactoryGirl
|
|||
# An instance of the class this factory generates, with generated attributes
|
||||
# assigned.
|
||||
def build(name, overrides = {})
|
||||
FactoryGirl.factory_by_name(name).run(Proxy::Build, overrides)
|
||||
FactoryGirl.find(name).run(Proxy::Build, overrides)
|
||||
end
|
||||
|
||||
# Generates, saves, and returns an instance from this factory. Attributes can
|
||||
|
@ -51,7 +51,7 @@ module FactoryGirl
|
|||
# A saved instance of the class this factory generates, with generated
|
||||
# attributes assigned.
|
||||
def create(name, overrides = {})
|
||||
FactoryGirl.factory_by_name(name).run(Proxy::Create, overrides)
|
||||
FactoryGirl.find(name).run(Proxy::Create, overrides)
|
||||
end
|
||||
|
||||
# Generates and returns an object with all attributes from this factory
|
||||
|
@ -67,7 +67,7 @@ module FactoryGirl
|
|||
# Returns: +Object+
|
||||
# An object with generated attributes stubbed out.
|
||||
def build_stubbed(name, overrides = {})
|
||||
FactoryGirl.factory_by_name(name).run(Proxy::Stub, overrides)
|
||||
FactoryGirl.find(name).run(Proxy::Stub, overrides)
|
||||
end
|
||||
|
||||
end
|
||||
|
|
|
@ -27,9 +27,9 @@ module FactoryGirl
|
|||
def self.method_missing(name, *args, &block)
|
||||
if block_given?
|
||||
start_value = args.first
|
||||
FactoryGirl.sequences[name] = Sequence.new(start_value || 1, &block)
|
||||
FactoryGirl.register(Sequence.new(name, start_value || 1, &block))
|
||||
else
|
||||
FactoryGirl.sequences[name].next
|
||||
FactoryGirl.find(name).run
|
||||
end
|
||||
end
|
||||
|
||||
|
|
|
@ -31,9 +31,9 @@ module FactoryGirl
|
|||
proxy = FactoryGirl::DefinitionProxy.new(factory)
|
||||
yield(proxy)
|
||||
if parent = options.delete(:parent)
|
||||
factory.inherit_from(FactoryGirl.factory_by_name(parent))
|
||||
factory.inherit_from(FactoryGirl.find(parent))
|
||||
end
|
||||
FactoryGirl.register_factory(factory)
|
||||
FactoryGirl.register(factory)
|
||||
end
|
||||
|
||||
# Executes the default strategy for the given factory. This is usually create,
|
||||
|
@ -48,7 +48,7 @@ module FactoryGirl
|
|||
# Returns: +Object+
|
||||
# The result of the default strategy.
|
||||
def self.default_strategy(name, overrides = {})
|
||||
self.send(FactoryGirl.factory_by_name(name).default_strategy, name, overrides)
|
||||
self.send(FactoryGirl.find(name).default_strategy, name, overrides)
|
||||
end
|
||||
|
||||
# Defines a new sequence that can be used to generate unique values in a specific format.
|
||||
|
@ -67,7 +67,7 @@ module FactoryGirl
|
|||
#
|
||||
# Factory.sequence(:email) {|n| "somebody_#{n}@example.com" }
|
||||
def self.sequence(name, start_value = 1, &block)
|
||||
FactoryGirl.sequences[name] = Sequence.new(start_value, &block)
|
||||
FactoryGirl.register(Sequence.new(name, start_value, &block))
|
||||
end
|
||||
|
||||
# Generates and returns the next value in a sequence.
|
||||
|
@ -76,14 +76,12 @@ module FactoryGirl
|
|||
# name: (Symbol)
|
||||
# The name of the sequence that a value should be generated for.
|
||||
#
|
||||
# DEPRECATED. Use create instead.
|
||||
#
|
||||
# Returns:
|
||||
# The next value in the sequence. (Object)
|
||||
def self.next(sequence)
|
||||
unless FactoryGirl.sequences.key?(sequence)
|
||||
raise "No such sequence: #{sequence}"
|
||||
end
|
||||
|
||||
FactoryGirl.sequences[sequence].next
|
||||
def self.next(name)
|
||||
FactoryGirl.find(name).next
|
||||
end
|
||||
|
||||
# Defines a new alias for attributes.
|
||||
|
|
|
@ -9,8 +9,8 @@ describe "sequences" do
|
|||
end
|
||||
end
|
||||
|
||||
first_value = Factory.next(:email)
|
||||
another_value = Factory.next(:email)
|
||||
first_value = FactoryGirl.create(:email)
|
||||
another_value = FactoryGirl.create(:email)
|
||||
|
||||
first_value.should =~ /^somebody\d+@example\.com$/
|
||||
another_value.should =~ /^somebody\d+@example\.com$/
|
||||
|
@ -22,8 +22,8 @@ describe "sequences" do
|
|||
sequence :order
|
||||
end
|
||||
|
||||
first_value = Factory.next(:order)
|
||||
another_value = Factory.next(:order)
|
||||
first_value = FactoryGirl.create(:order)
|
||||
another_value = FactoryGirl.create(:order)
|
||||
|
||||
first_value.should == 1
|
||||
another_value.should == 2
|
||||
|
|
|
@ -11,7 +11,7 @@ describe "a blueprint" do
|
|||
User.blueprint do
|
||||
first_name { 'Bill' }
|
||||
last_name { 'Nye' }
|
||||
email { Factory.next(:email) }
|
||||
email { FactoryGirl.create(:email) }
|
||||
end
|
||||
end
|
||||
|
||||
|
|
|
@ -12,14 +12,14 @@ describe "a factory using sham syntax" do
|
|||
|
||||
Sham.name { "Name" }
|
||||
Sham.email { "somebody#{rand(5)}@example.com" }
|
||||
Sham.user("FOO") { |c| "User-#{c}" }
|
||||
Sham.username("FOO") { |c| "User-#{c}" }
|
||||
|
||||
FactoryGirl.define do
|
||||
factory :user do
|
||||
first_name { Sham.name }
|
||||
last_name { Sham.name }
|
||||
email { Sham.email }
|
||||
username { Sham.user }
|
||||
username { Sham.username }
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
|
@ -11,7 +11,7 @@ describe "vintage syntax" do
|
|||
Factory.define :user do |factory|
|
||||
factory.first_name { 'Bill' }
|
||||
factory.last_name { 'Nye' }
|
||||
factory.email { Factory.next(:email) }
|
||||
factory.email { Factory(:email) }
|
||||
end
|
||||
end
|
||||
|
||||
|
@ -37,8 +37,8 @@ describe "vintage syntax" do
|
|||
end
|
||||
|
||||
it "should raise Factory::SequenceAbuseError" do
|
||||
Factory.define :sequence_abuser, :class => Object do |factory|
|
||||
factory.first_name { Factory.sequence(:email) }
|
||||
Factory.define :sequence_abuser, :class => User do |factory|
|
||||
factory.first_name { Factory.sequence(:name) }
|
||||
end
|
||||
|
||||
lambda {
|
||||
|
@ -51,7 +51,7 @@ describe Factory, "given a parent factory" do
|
|||
before do
|
||||
@parent = FactoryGirl::Factory.new(:object)
|
||||
@parent.define_attribute(FactoryGirl::Attribute::Static.new(:name, 'value'))
|
||||
FactoryGirl.register_factory(@parent)
|
||||
FactoryGirl.register(@parent)
|
||||
end
|
||||
|
||||
it "should raise an ArgumentError when trying to use a non-existent factory as parent" do
|
||||
|
@ -66,8 +66,7 @@ describe "defining a factory" do
|
|||
@name = :user
|
||||
@factory = "factory"
|
||||
@proxy = "proxy"
|
||||
stub(@factory).name { @name }
|
||||
stub(@factory).aliases { [] }
|
||||
stub(@factory).names { [@name] }
|
||||
@options = { :class => 'magic' }
|
||||
stub(FactoryGirl::Factory).new { @factory }
|
||||
stub(FactoryGirl::DefinitionProxy).new { @proxy }
|
||||
|
@ -88,21 +87,16 @@ describe "defining a factory" do
|
|||
|
||||
it "should add the factory to the list of factories" do
|
||||
Factory.define(@name) {|f| }
|
||||
@factory.should == FactoryGirl.factories[@name]
|
||||
end
|
||||
|
||||
it "should allow a factory to be found by name" do
|
||||
Factory.define(@name) {|f| }
|
||||
FactoryGirl.factory_by_name(@name).should == @factory
|
||||
@factory.should == FactoryGirl.find(@name)
|
||||
end
|
||||
end
|
||||
|
||||
describe "after defining a factory" do
|
||||
before do
|
||||
@name = :user
|
||||
@factory = "factory"
|
||||
@factory = FactoryGirl::Factory.new(@name)
|
||||
|
||||
FactoryGirl.factories[@name] = @factory
|
||||
FactoryGirl.register(@factory)
|
||||
end
|
||||
|
||||
it "should use Proxy::AttributesFor for Factory.attributes_for" do
|
||||
|
@ -152,33 +146,33 @@ end
|
|||
|
||||
describe "defining a sequence" do
|
||||
before do
|
||||
@sequence = "sequence"
|
||||
@name = :count
|
||||
@sequence = FactoryGirl::Sequence.new(@name) {}
|
||||
stub(FactoryGirl::Sequence).new { @sequence }
|
||||
end
|
||||
|
||||
it "should create a new sequence" do
|
||||
mock(FactoryGirl::Sequence).new(1) { @sequence }
|
||||
mock(FactoryGirl::Sequence).new(@name, 1) { @sequence }
|
||||
Factory.sequence(@name)
|
||||
end
|
||||
|
||||
it "should use the supplied block as the sequence generator" do
|
||||
stub(FactoryGirl::Sequence).new.yields(1)
|
||||
stub(FactoryGirl::Sequence).new { @sequence }.yields(1)
|
||||
yielded = false
|
||||
Factory.sequence(@name) {|n| yielded = true }
|
||||
(yielded).should be
|
||||
end
|
||||
|
||||
it "should use the supplied start_value as the sequence start_value" do
|
||||
mock(FactoryGirl::Sequence).new("A") { @sequence }
|
||||
mock(FactoryGirl::Sequence).new(@name, "A") { @sequence }
|
||||
Factory.sequence(@name, "A")
|
||||
end
|
||||
end
|
||||
|
||||
describe "after defining a sequence" do
|
||||
before do
|
||||
@sequence = "sequence"
|
||||
@name = :test
|
||||
@sequence = FactoryGirl::Sequence.new(@name) {}
|
||||
@value = '1 2 5'
|
||||
|
||||
stub(@sequence).next { @value }
|
||||
|
|
|
@ -45,7 +45,7 @@ describe FactoryGirl::Attribute::Dynamic do
|
|||
end
|
||||
|
||||
it "should raise an error when returning a sequence" do
|
||||
stub(Factory).sequence { FactoryGirl::Sequence.new }
|
||||
stub(Factory).sequence { FactoryGirl::Sequence.new(:email) }
|
||||
block = lambda { Factory.sequence(:email) }
|
||||
attr = FactoryGirl::Attribute::Dynamic.new(:email, block)
|
||||
proxy = stub!.set.subject
|
||||
|
|
|
@ -39,12 +39,12 @@ describe FactoryGirl::DefinitionProxy do
|
|||
|
||||
describe "adding an attribute using a in-line sequence" do
|
||||
it "should create the sequence" do
|
||||
mock(FactoryGirl::Sequence).new(1)
|
||||
mock(FactoryGirl::Sequence).new(:name, 1)
|
||||
subject.sequence(:name) {}
|
||||
end
|
||||
|
||||
it "should create the sequence with a custom default value" do
|
||||
mock(FactoryGirl::Sequence).new("A")
|
||||
mock(FactoryGirl::Sequence).new(:name, "A")
|
||||
subject.sequence(:name, "A") {}
|
||||
end
|
||||
|
||||
|
@ -113,6 +113,7 @@ describe FactoryGirl::DefinitionProxy do
|
|||
|
||||
it "adds an association when passed an undefined method without arguments or a block" do
|
||||
name = :user
|
||||
FactoryGirl.register(FactoryGirl::Factory.new(name))
|
||||
attr = 'attribute'
|
||||
stub(attr).name { name }
|
||||
mock(FactoryGirl::Attribute::Association).new(name, name, {}) { attr }
|
||||
|
@ -122,12 +123,12 @@ describe FactoryGirl::DefinitionProxy do
|
|||
|
||||
it "adds a sequence when passed an undefined method without arguments or a block" do
|
||||
name = :airport
|
||||
proxy = 'proxy'
|
||||
FactoryGirl.sequences[name] = FactoryGirl::Sequence.new { |value| "expected" }
|
||||
FactoryGirl.register(FactoryGirl::Sequence.new(name))
|
||||
attr = 'attribute'
|
||||
stub(attr).name { name }
|
||||
mock(FactoryGirl::Attribute::Association).new(name, name, {}) { attr }
|
||||
subject.send(name)
|
||||
stub(proxy).set
|
||||
factory.attributes.last.add_to(proxy)
|
||||
proxy.should have_received.set(name, 'expected')
|
||||
factory.attributes.should include(attr)
|
||||
end
|
||||
|
||||
it "delegates to_create" do
|
||||
|
|
|
@ -1,33 +1,5 @@
|
|||
require 'spec_helper'
|
||||
|
||||
describe FactoryGirl::Factory, "registering a factory" do
|
||||
before do
|
||||
@name = :user
|
||||
@factory = "factory"
|
||||
@aliases = [:one, :two]
|
||||
stub(@factory).name { @name }
|
||||
stub(@factory).aliases { @aliases }
|
||||
end
|
||||
|
||||
it "should add the factory to the list of factories" do
|
||||
FactoryGirl.register_factory(@factory)
|
||||
FactoryGirl.factory_by_name(@name).should == @factory
|
||||
end
|
||||
|
||||
it "should not allow a duplicate factory definition" do
|
||||
lambda {
|
||||
2.times { FactoryGirl.register_factory(@factory) }
|
||||
}.should raise_error(FactoryGirl::DuplicateDefinitionError)
|
||||
end
|
||||
|
||||
it "registers aliases" do
|
||||
FactoryGirl.register_factory(@factory)
|
||||
@aliases.each do |name|
|
||||
FactoryGirl.factory_by_name(name).should == @factory
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
describe FactoryGirl::Factory do
|
||||
include DefinesConstants
|
||||
|
||||
|
@ -313,32 +285,6 @@ describe FactoryGirl::Factory, "with a string for a name" do
|
|||
end
|
||||
end
|
||||
|
||||
describe FactoryGirl::Factory, "registered with a string name" do
|
||||
before do
|
||||
@name = :string
|
||||
@factory = FactoryGirl::Factory.new(@name)
|
||||
FactoryGirl.register_factory(@factory)
|
||||
end
|
||||
|
||||
it "should store the factory using a symbol" do
|
||||
FactoryGirl.factories[@name].should == @factory
|
||||
end
|
||||
end
|
||||
|
||||
describe FactoryGirl::Factory, "registered with a custom name" do
|
||||
before do
|
||||
@actual_name = :string
|
||||
@custom_name = :words
|
||||
@factory = FactoryGirl::Factory.new(@actual_name)
|
||||
|
||||
FactoryGirl.register_factory(@factory, :as => @custom_name)
|
||||
end
|
||||
|
||||
it "finds the factory using the custom name" do
|
||||
FactoryGirl.factory_by_name(@custom_name).should == @factory
|
||||
end
|
||||
end
|
||||
|
||||
describe FactoryGirl::Factory, "for namespaced class" do
|
||||
include DefinesConstants
|
||||
|
||||
|
@ -417,8 +363,9 @@ end
|
|||
|
||||
describe FactoryGirl::Factory, "with aliases" do
|
||||
it "registers the aliases" do
|
||||
name = :user
|
||||
aliased_name = :guest
|
||||
factory = FactoryGirl::Factory.new("user", :aliases => [aliased_name])
|
||||
factory.aliases.should == [aliased_name]
|
||||
factory = FactoryGirl::Factory.new(:user, :aliases => [aliased_name])
|
||||
factory.names.should =~ [name, aliased_name]
|
||||
end
|
||||
end
|
||||
|
|
|
@ -21,7 +21,7 @@ describe FactoryGirl::Proxy::Build do
|
|||
before do
|
||||
@association = "associated-instance"
|
||||
@associated_factory = "associated-factory"
|
||||
stub(FactoryGirl).factory_by_name { @associated_factory }
|
||||
stub(FactoryGirl).find { @associated_factory }
|
||||
stub(@associated_factory).run { @association }
|
||||
@overrides = { 'attr' => 'value' }
|
||||
@proxy.associate(:owner, :user, @overrides)
|
||||
|
@ -39,7 +39,7 @@ describe FactoryGirl::Proxy::Build do
|
|||
it "should run create when building an association" do
|
||||
association = "associated-instance"
|
||||
associated_factory = "associated-factory"
|
||||
stub(FactoryGirl).factory_by_name { associated_factory }
|
||||
stub(FactoryGirl).find { associated_factory }
|
||||
stub(associated_factory).run { association }
|
||||
overrides = { 'attr' => 'value' }
|
||||
@proxy.association(:user, overrides).should == association
|
||||
|
|
|
@ -22,7 +22,7 @@ describe FactoryGirl::Proxy::Create do
|
|||
before do
|
||||
@association = "associated-instance"
|
||||
@associated_factory = "associated-factory"
|
||||
stub(FactoryGirl).factory_by_name { @associated_factory }
|
||||
stub(FactoryGirl).find { @associated_factory }
|
||||
stub(@associated_factory).run { @association }
|
||||
@overrides = { 'attr' => 'value' }
|
||||
@proxy.associate(:owner, :user, @overrides)
|
||||
|
@ -40,7 +40,7 @@ describe FactoryGirl::Proxy::Create do
|
|||
it "should run create when building an association" do
|
||||
association = "associated-instance"
|
||||
associated_factory = "associated-factory"
|
||||
stub(FactoryGirl).factory_by_name { associated_factory }
|
||||
stub(FactoryGirl).find { associated_factory }
|
||||
stub(associated_factory).run { association }
|
||||
overrides = { 'attr' => 'value' }
|
||||
@proxy.association(:user, overrides).should == association
|
||||
|
|
|
@ -23,7 +23,7 @@ describe FactoryGirl::Proxy::Stub do
|
|||
describe "when a user factory exists" do
|
||||
before do
|
||||
@user = "user"
|
||||
stub(FactoryGirl).factory_by_name { @associated_factory }
|
||||
stub(FactoryGirl).find { @associated_factory }
|
||||
@associated_factory = 'associate-factory'
|
||||
end
|
||||
|
||||
|
|
|
@ -0,0 +1,92 @@
|
|||
require 'spec_helper'
|
||||
|
||||
describe FactoryGirl::Registry do
|
||||
let(:factory) { FactoryGirl::Factory.new(:object) }
|
||||
|
||||
subject { FactoryGirl::Registry.new }
|
||||
|
||||
it "finds a registered a factory" do
|
||||
subject.add(factory)
|
||||
subject.find(factory.name).should == factory
|
||||
end
|
||||
|
||||
it "raises when finding an unregistered factory" do
|
||||
expect { subject.find(:bogus) }.to raise_error(ArgumentError)
|
||||
end
|
||||
|
||||
it "adds and returns a factory" do
|
||||
subject.add(factory).should == factory
|
||||
end
|
||||
|
||||
it "knows that a factory is registered by symbol" do
|
||||
subject.add(factory)
|
||||
subject.should be_registered(factory.name.to_sym)
|
||||
end
|
||||
|
||||
it "knows that a factory is registered by string" do
|
||||
subject.add(factory)
|
||||
subject.should be_registered(factory.name.to_s)
|
||||
end
|
||||
|
||||
it "knows that a factory isn't registered" do
|
||||
subject.should_not be_registered("bogus")
|
||||
end
|
||||
|
||||
it "can be accessed like a hash" do
|
||||
subject.add(factory)
|
||||
subject[factory.name].should == factory
|
||||
end
|
||||
|
||||
it "iterates registered factories" do
|
||||
other_factory = FactoryGirl::Factory.new(:string)
|
||||
subject.add(factory)
|
||||
subject.add(other_factory)
|
||||
result = {}
|
||||
|
||||
subject.each do |name, value|
|
||||
result[name] = value
|
||||
end
|
||||
|
||||
result.should == { factory.name => factory,
|
||||
other_factory.name => other_factory }
|
||||
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
|
||||
|
||||
it "doesn't allow a duplicate name" do
|
||||
expect { 2.times { subject.add(factory) } }.
|
||||
to raise_error(FactoryGirl::DuplicateDefinitionError)
|
||||
end
|
||||
|
||||
it "registers aliases" do
|
||||
aliases = [:thing, :widget]
|
||||
factory = FactoryGirl::Factory.new(:object, :aliases => aliases)
|
||||
subject.add(factory)
|
||||
aliases.each do |name|
|
||||
subject.find(name).should == factory
|
||||
end
|
||||
end
|
||||
|
||||
context "on the FactoryGirl module" do
|
||||
it "finds a registered a factory" do
|
||||
FactoryGirl.register(factory)
|
||||
FactoryGirl.find(factory.name).should == factory
|
||||
end
|
||||
|
||||
it "knows that a factory is registered by symbol" do
|
||||
FactoryGirl.register(factory)
|
||||
FactoryGirl.should be_registered(factory.name.to_sym)
|
||||
end
|
||||
|
||||
it "sets the registry" do
|
||||
registry = FactoryGirl::Registry.new
|
||||
FactoryGirl.registry = registry
|
||||
FactoryGirl.registry.should == registry
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
@ -3,80 +3,97 @@ require 'spec_helper'
|
|||
describe FactoryGirl::Sequence do
|
||||
describe "a basic sequence" do
|
||||
before do
|
||||
@sequence = FactoryGirl::Sequence.new {|n| "=#{n}" }
|
||||
@name = :test
|
||||
@sequence = FactoryGirl::Sequence.new(@name) {|n| "=#{n}" }
|
||||
end
|
||||
|
||||
it "has names" do
|
||||
@sequence.names.should == [@name]
|
||||
end
|
||||
|
||||
it "should start with a value of 1" do
|
||||
@sequence.run.should == "=1"
|
||||
end
|
||||
|
||||
it "responds to next" do
|
||||
@sequence.next.should == "=1"
|
||||
end
|
||||
|
||||
it "responds to default_strategy" do
|
||||
@sequence.default_strategy.should == :create
|
||||
end
|
||||
|
||||
it "runs compatible with the Factory interface" do
|
||||
@sequence.run(nil, nil).should == "=1"
|
||||
end
|
||||
|
||||
describe "after being called" do
|
||||
before do
|
||||
@sequence.next
|
||||
@sequence.run
|
||||
end
|
||||
|
||||
it "should use the next value" do
|
||||
@sequence.next.should == "=2"
|
||||
@sequence.run.should == "=2"
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
describe "a custom sequence" do
|
||||
before do
|
||||
@sequence = FactoryGirl::Sequence.new("A") {|n| "=#{n}" }
|
||||
@sequence = FactoryGirl::Sequence.new(:name, "A") {|n| "=#{n}" }
|
||||
end
|
||||
|
||||
it "should start with a value of A" do
|
||||
@sequence.next.should == "=A"
|
||||
@sequence.run.should == "=A"
|
||||
end
|
||||
|
||||
describe "after being called" do
|
||||
before do
|
||||
@sequence.next
|
||||
@sequence.run
|
||||
end
|
||||
|
||||
it "should use the next value" do
|
||||
@sequence.next.should == "=B"
|
||||
@sequence.run.should == "=B"
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
describe "a basic sequence without a block" do
|
||||
before do
|
||||
@sequence = FactoryGirl::Sequence.new
|
||||
@sequence = FactoryGirl::Sequence.new(:name)
|
||||
end
|
||||
|
||||
it "should start with a value of 1" do
|
||||
@sequence.next.should == 1
|
||||
@sequence.run.should == 1
|
||||
end
|
||||
|
||||
describe "after being called" do
|
||||
before do
|
||||
@sequence.next
|
||||
@sequence.run
|
||||
end
|
||||
|
||||
it "should use the next value" do
|
||||
@sequence.next.should == 2
|
||||
@sequence.run.should == 2
|
||||
end
|
||||
end
|
||||
end
|
||||
|
||||
describe "a custom sequence without a block" do
|
||||
before do
|
||||
@sequence = FactoryGirl::Sequence.new("A")
|
||||
@sequence = FactoryGirl::Sequence.new(:name, "A")
|
||||
end
|
||||
|
||||
it "should start with a value of A" do
|
||||
@sequence.next.should == "A"
|
||||
@sequence.run.should == "A"
|
||||
end
|
||||
|
||||
describe "after being called" do
|
||||
before do
|
||||
@sequence.next
|
||||
@sequence.run
|
||||
end
|
||||
|
||||
it "should use the next value" do
|
||||
@sequence.next.should == "B"
|
||||
@sequence.run.should == "B"
|
||||
end
|
||||
end
|
||||
end
|
||||
|
|
|
@ -22,8 +22,7 @@ RSpec.configure do |config|
|
|||
config.mock_framework = :rr
|
||||
RSpec::Core::ExampleGroup.send(:include, RR::Adapters::Rspec)
|
||||
config.after do
|
||||
FactoryGirl.factories.clear
|
||||
FactoryGirl.sequences.clear
|
||||
FactoryGirl.registry = FactoryGirl::Registry.new
|
||||
end
|
||||
end
|
||||
|
||||
|
|
Loading…
Reference in New Issue