factory_girl_kibiz0r 2.0.0.beta2

data/lib/factory_girl/syntax/vintage.rb

@@ -0,0 +1,152 @@
+module FactoryGirl
+  module Syntax
+    module Vintage
+      module Factory
+        # Defines a new factory that can be used by the build strategies (create and
+        # build) to build new objects.
+        #
+        # Arguments:
+        # * name: +Symbol+ or +String+
+        #   A unique name used to identify this factory.
+        # * options: +Hash+
+        #
+        # Options:
+        # * class: +Symbol+, +Class+, or +String+
+        #   The class that will be used when generating instances for this factory. If not specified, the class will be guessed from the factory name.
+        # * parent: +Symbol+
+        #   The parent factory. If specified, the attributes from the parent
+        #   factory will be copied to the current one with an ability to override
+        #   them.
+        # * default_strategy: +Symbol+
+        #   DEPRECATED.
+        #   The strategy that will be used by the Factory shortcut method.
+        #   Defaults to :create.
+        #
+        # Yields: +Factory+
+        # The newly created factory.
+        def self.define(name, options = {})
+          factory = FactoryGirl::Factory.new(name, options)
+          proxy = FactoryGirl::DefinitionProxy.new(factory)
+          yield(proxy)
+          if parent = options.delete(:parent)
+            factory.inherit_from(FactoryGirl.factory_by_name(parent))
+          end
+          FactoryGirl.register_factory(factory)
+        end
+
+        # Executes the default strategy for the given factory. This is usually create,
+        # but it can be overridden for each factory.
+        #
+        # DEPRECATED
+        #
+        # Use create instead.
+        #
+        # Arguments:
+        # * name: +Symbol+ or +String+
+        #   The name of the factory that should be used.
+        # * overrides: +Hash+
+        #   Attributes to overwrite for this instance.
+        #
+        # Returns: +Object+
+        # The result of the default strategy.
+        def self.default_strategy(name, overrides = {})
+          FactoryGirl.send(FactoryGirl.factory_by_name(name).default_strategy, name, overrides)
+        end
+
+        # Defines a new sequence that can be used to generate unique values in a specific format.
+        #
+        # Arguments:
+        #   name: (Symbol)
+        #     A unique name for this sequence. This name will be referenced when
+        #     calling next to generate new values from this sequence.
+        #   block: (Proc)
+        #     The code to generate each value in the sequence. This block will be
+        #     called with a unique number each time a value in the sequence is to be
+        #     generated. The block should return the generated value for the
+        #     sequence.
+        #
+        # Example:
+        #
+        #   Factory.sequence(:email) {|n| "somebody_#{n}@example.com" }
+        def self.sequence(name, start_value = 1, &block)
+          FactoryGirl.register_sequence(Sequence.new(name, start_value, &block))
+        end
+
+        # Generates and returns the next value in a sequence.
+        #
+        # Arguments:
+        #   name: (Symbol)
+        #     The name of the sequence that a value should be generated for.
+        #
+        # Returns:
+        #   The next value in the sequence. (Object)
+        def self.next(name)
+          FactoryGirl.generate(name)
+        end
+
+        # Defines a new alias for attributes.
+        #
+        # Arguments:
+        # * pattern: +Regexp+
+        #   A pattern that will be matched against attributes when looking for
+        #   aliases. Contents captured in the pattern can be used in the alias.
+        # * replace: +String+
+        #   The alias that results from the matched pattern. Captured strings can
+        #   be substituted like with +String#sub+.
+        #
+        # Example:
+        #
+        #   Factory.alias /(.*)_confirmation/, '\1'
+        #
+        # factory_girl starts with aliases for foreign keys, so that a :user
+        # association can be overridden by a :user_id parameter:
+        #
+        #   Factory.define :post do |p|
+        #     p.association :user
+        #   end
+        #
+        #   # The user association will not be built in this example. The user_id
+        #   # will be used instead.
+        #   Factory(:post, :user_id => 1)
+        def self.alias(pattern, replace)
+          FactoryGirl.aliases << [pattern, replace]
+        end
+
+        # Alias for FactoryGirl.attributes_for
+        def self.attributes_for(name, overrides = {})
+          FactoryGirl.attributes_for(name, overrides)
+        end
+
+        # Alias for FactoryGirl.build
+        def self.build(name, overrides = {})
+          FactoryGirl.build(name, overrides)
+        end
+
+        # Alias for FactoryGirl.create
+        def self.create(name, overrides = {})
+          FactoryGirl.create(name, overrides)
+        end
+
+        # Alias for FactoryGirl.build_stubbed.
+        def self.stub(name, overrides = {})
+          FactoryGirl.build_stubbed(name, overrides)
+        end
+      end
+
+      # Shortcut for Factory.default_strategy.
+      #
+      # DEPRECATION WARNING:
+      #
+      # In a future release, default_strategy will be removed and this will
+      # simply call create instead.
+      #
+      # Example:
+      #   Factory(:user, :name => 'Joe')
+      def Factory(name, attrs = {})
+        Factory.default_strategy(name, attrs)
+      end
+    end
+  end
+end
+
+include FactoryGirl::Syntax::Vintage

data/lib/factory_girl/syntax.rb

@@ -0,0 +1,12 @@
+module FactoryGirl
+  # Provides alternate syntaxes for factory_girl. If you don't like the default
+  # syntax for defining or using factories, look at one of the
+  # FactoryGirl::Syntax modules:
+  #
+  # * FactoryGirl::Syntax::Blueprint: definition syntax similar to Machinist
+  # * FactoryGirl::Syntax::Generate: usage syntax similar to Object Daddy
+  # * FactoryGirl::Syntax::Make: usage syntax similar to Machinist
+  # * FactoryGirl::Syntax::Sham: sequence syntax similar to Machinist
+  module Syntax
+  end
+end

data/lib/factory_girl/version.rb

@@ -0,0 +1,4 @@
+module FactoryGirl
+  VERSION = "2.0.0.beta2"
+end
+

data/lib/factory_girl.rb

@@ -0,0 +1,54 @@
+require 'factory_girl/proxy'
+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'
+require 'factory_girl/attribute/dynamic'
+require 'factory_girl/attribute/association'
+require 'factory_girl/attribute/callback'
+require 'factory_girl/attribute/sequence'
+require 'factory_girl/attribute/implicit'
+require 'factory_girl/attribute/list'
+require 'factory_girl/sequence'
+require 'factory_girl/aliases'
+require 'factory_girl/definition_proxy'
+require 'factory_girl/syntax/methods'
+require 'factory_girl/syntax/default'
+require 'factory_girl/syntax/vintage'
+require 'factory_girl/find_definitions'
+require 'factory_girl/deprecated'
+require 'factory_girl/version'
+
+if defined?(Rails) && Rails::VERSION::MAJOR == 2
+  require 'factory_girl/rails2'
+end
+
+module FactoryGirl
+  def self.factories
+    @factories ||= Registry.new
+  end
+
+  def self.register_factory(factory)
+    factories.add(factory)
+  end
+
+  def self.factory_by_name(name)
+    factories.find(name)
+  end
+
+  def self.sequences
+    @sequences ||= Registry.new
+  end
+
+  def self.register_sequence(sequence)
+    sequences.add(sequence)
+  end
+
+  def self.sequence_by_name(name)
+    sequences.find(name)
+  end
+end

data/spec/acceptance/acceptance_helper.rb

@@ -0,0 +1,11 @@
+require 'active_record'
+
+ActiveRecord::Base.establish_connection(
+  :adapter  => 'sqlite3',
+  :database => File.join(File.dirname(__FILE__), 'test.db')
+)
+
+RSpec.configure do |config|
+  config.include DefinesConstants
+end
+

data/spec/acceptance/attribute_aliases_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+describe "attribute aliases" do
+  before do
+    define_model('User')
+
+    define_model('Post', :user_id => :integer) do
+      belongs_to :user
+    end
+
+    FactoryGirl.define do
+      factory :user do
+      end
+
+      factory :post do
+        user
+      end
+    end
+  end
+
+  it "doesn't assign both an association and its foreign key" do
+    FactoryGirl.build(:post, :user_id => 1).user_id.should == 1
+  end
+end
+

data/spec/acceptance/attributes_for_spec.rb

@@ -0,0 +1,48 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+describe "a generated attributes hash" do
+  include FactoryGirl::Syntax::Methods
+
+  before do
+    define_model('User')
+
+    define_model('Post', :title   => :string,
+                         :body    => :string,
+                         :summary => :string,
+                         :user_id => :integer) do
+      belongs_to :user
+    end
+
+    FactoryGirl.define do
+      factory :user do
+      end
+
+      factory :post do
+        title { "default title" }
+        body { "default body" }
+        summary { title }
+        user
+      end
+    end
+  end
+
+  subject { attributes_for(:post, :title => 'overridden title') }
+
+  it "assigns an overridden value" do
+    subject[:title].should == "overridden title"
+  end
+
+  it "assigns a default value" do
+    subject[:body].should == "default body"
+  end
+
+  it "assigns a lazy, dependent attribute" do
+    subject[:summary].should == "overridden title"
+  end
+
+  it "doesn't assign associations" do
+    subject[:user_id].should be_nil
+  end
+end
+

data/spec/acceptance/build_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+describe "a built instance" do
+  include FactoryGirl::Syntax::Methods
+
+  before do
+    define_model('User')
+
+    define_model('Post', :user_id => :integer) do
+      belongs_to :user
+    end
+
+    FactoryGirl.define do
+      factory :user do
+      end
+
+      factory :post do
+        user
+      end
+    end
+  end
+
+  subject { build(:post) }
+
+  it "isn't saved" do
+    should be_new_record
+  end
+
+  it "assigns and saves associations" do
+    subject.user.should be_kind_of(User)
+    subject.user.should_not be_new_record
+  end
+end
+

data/spec/acceptance/build_stubbed_spec.rb

@@ -0,0 +1,79 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+describe "a generated stub instance" do
+  include FactoryGirl::Syntax::Methods
+
+  before do
+    define_model('User')
+
+    define_model('Post', :title   => :string,
+                         :body    => :string,
+                         :user_id => :integer) do
+      belongs_to :user
+    end
+
+    FactoryGirl.define do
+      factory :user do
+      end
+
+      factory :post do
+        title { "default title" }
+        body { "default body" }
+        user
+      end
+    end
+  end
+
+  subject { build_stubbed(:post, :title => 'overridden title') }
+
+  it "assigns a default attribute" do
+    subject.body.should == 'default body'
+  end
+
+  it "assigns an overridden attribute" do
+    subject.title.should == 'overridden title'
+  end
+
+  it "assigns associations" do
+    subject.user.should_not be_nil
+  end
+
+  it "has an id" do
+    subject.id.should > 0
+  end
+
+  it "generates unique ids" do
+    other_stub = build_stubbed(:post)
+    subject.id.should_not == other_stub.id
+  end
+
+  it "isn't a new record" do
+    should_not be_new_record
+  end
+
+  it "disables connection" do
+    lambda { subject.connection }.should raise_error(RuntimeError)
+  end
+
+  it "disables update_attribute" do
+    lambda { subject.update_attribute(:title, "value") }.should raise_error(RuntimeError)
+  end
+
+  it "disables reload" do
+    lambda { subject.reload }.should raise_error(RuntimeError)
+  end
+
+  it "disables destroy" do
+    lambda { subject.destroy }.should raise_error(RuntimeError)
+  end
+
+  it "disables save" do
+    lambda { subject.save }.should raise_error(RuntimeError)
+  end
+
+  it "disables increment" do
+    lambda { subject.increment!(:age) }.should raise_error(RuntimeError)
+  end
+end
+

data/spec/acceptance/callbacks_spec.rb

@@ -0,0 +1,53 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+describe "callbacks" do
+  before do
+    define_model("User", :first_name => :string, :last_name => :string)
+
+    FactoryGirl.define do
+      factory :user_with_callbacks, :class => :user do
+        after_stub   { |user| user.first_name = 'Stubby' }
+        after_build  { |user| user.first_name = 'Buildy' }
+        after_create { |user| user.last_name  = 'Createy' }
+      end
+
+      factory :user_with_inherited_callbacks, :parent => :user_with_callbacks do
+        after_stub { |user| user.last_name = 'Double-Stubby' }
+      end
+
+      factory :user_with_proxied_callbacks, :parent => :user_with_callbacks do |u|
+        u.proxified?(true).ignore
+        after_create { |user, proxy| user.last_name << ', Proxified' if proxy.proxified? }
+      end
+    end
+  end
+
+  it "runs the after_stub callback when stubbing" do
+    user = FactoryGirl.build_stubbed(:user_with_callbacks)
+    user.first_name.should == 'Stubby'
+  end
+
+  it "runs the after_build callback when building" do
+    user = FactoryGirl.build(:user_with_callbacks)
+    user.first_name.should == 'Buildy'
+  end
+
+  it "runs both the after_build and after_create callbacks when creating" do
+    user = FactoryGirl.create(:user_with_callbacks)
+    user.first_name.should == 'Buildy'
+    user.last_name.should == 'Createy'
+  end
+
+  it "runs both the after_stub callback on the factory and the inherited after_stub callback" do
+    user = FactoryGirl.build_stubbed(:user_with_inherited_callbacks)
+    user.first_name.should == 'Stubby'
+    user.last_name.should == 'Double-Stubby'
+  end
+
+  it "provides the proxy to callbacks that want it" do
+    user = FactoryGirl.create(:user_with_proxied_callbacks)
+    user.first_name.should == 'Buildy'
+    user.last_name.should == 'Createy, Proxified'
+  end
+end

data/spec/acceptance/create_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+describe "a created instance" do
+  include FactoryGirl::Syntax::Methods
+
+  before do
+    define_model('User')
+
+    define_model('Post', :user_id => :integer) do
+      belongs_to :user
+    end
+
+    FactoryGirl.define do
+      factory :user do
+      end
+
+      factory :post do
+        user
+      end
+    end
+  end
+
+  subject { create('post') }
+
+  it "saves" do
+    should_not be_new_record
+  end
+
+  it "assigns and saves associations" do
+    subject.user.should be_kind_of(User)
+    subject.user.should_not be_new_record
+  end
+end
+
+describe "a custom create" do
+  include FactoryGirl::Syntax::Methods
+
+  before do
+    define_class('User') do
+      def initialize
+        @persisted = false
+      end
+
+      def persist
+        @persisted = true
+      end
+
+      def persisted?
+        @persisted
+      end
+    end
+
+    FactoryGirl.define do
+      factory :user do
+        to_create do |user|
+          user.persist
+        end
+      end
+    end
+  end
+
+  it "uses the custom create block instead of save" do
+    FactoryGirl.create(:user).should be_persisted
+  end
+end
+

data/spec/acceptance/default_strategy_spec.rb

@@ -0,0 +1,27 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+describe "default strategy" do
+  it "uses create when not specified" do
+    define_model('User')
+
+    FactoryGirl.define do
+      factory :user do
+      end
+    end
+
+    Factory(:user).should_not be_new_record
+  end
+
+  it "can be overridden" do
+    define_model('User')
+
+    FactoryGirl.define do
+      factory :user, :default_strategy => :build do
+      end
+    end
+
+    Factory(:user).should be_new_record
+  end
+end
+

data/spec/acceptance/definition_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+describe "an instance generated by a factory with a custom class name" do
+  before do
+    define_model("User", :admin => :boolean)
+
+    FactoryGirl.define do
+      factory :user do
+      end
+
+      factory :admin, :class => User do
+        admin { true }
+      end
+    end
+  end
+
+  subject { FactoryGirl.create(:admin) }
+
+  it "uses the correct class name" do
+    should be_kind_of(User)
+  end
+
+  it "uses the correct factory definition" do
+    should be_admin
+  end
+end
+

data/spec/acceptance/parent_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+describe "an instance generated by a factory that inherits from another factory" do
+  before do
+    define_model("User", :name => :string, :admin => :boolean, :email => :string)
+
+    FactoryGirl.define do
+      factory :user do
+        name { "John" }
+        email { "john@example.com" }
+      end
+
+      factory :admin, :parent => :user do
+        admin { true }
+        email { "admin@example.com" }
+      end
+    end
+  end
+
+  subject { FactoryGirl.create(:admin) }
+
+  it "uses the parent build class" do
+    subject.should be_kind_of(User)
+  end
+
+  it "inherits attributes" do
+    subject.name.should == 'John'
+  end
+
+  it "has its own attributes" do
+    subject.should be_admin
+  end
+
+  it "overrides attributes" do
+    subject.email.should == 'admin@example.com'
+  end
+end
+

data/spec/acceptance/sequence_spec.rb

@@ -0,0 +1,34 @@
+require 'spec_helper'
+require 'acceptance/acceptance_helper'
+
+describe "sequences" do
+  include FactoryGirl::Syntax::Methods
+
+  it "generates several values in the correct format" do
+    FactoryGirl.define do
+      sequence :email do |n|
+        "somebody#{n}@example.com"
+      end
+    end
+
+    first_value = generate(:email)
+    another_value = generate(:email)
+
+    first_value.should =~ /^somebody\d+@example\.com$/
+    another_value.should =~ /^somebody\d+@example\.com$/
+    first_value.should_not == another_value
+  end
+
+  it "generates sequential numbers if no block is given" do
+    FactoryGirl.define do
+      sequence :order
+    end
+
+    first_value = generate(:order)
+    another_value = generate(:order)
+
+    first_value.should == 1
+    another_value.should == 2
+    first_value.should_not == another_value
+  end
+end