active_factory 0.1.0

data/lib/generators/active_factory/install/USAGE

@@ -0,0 +1,2 @@
+Description:
+    Copy ActiveFactory files to your application.

data/lib/generators/active_factory/install/install_generator.rb

@@ -0,0 +1,15 @@
+module ActiveFactory
+  module Generators #:nodoc:
+    class InstallGenerator < Rails::Generators::Base #:nodoc:
+      source_root File.expand_path('../templates', __FILE__)
+
+      def define_factories_file
+        copy_file "define_factories.rb", "spec/define_factories.rb"
+      end
+
+      def active_factory_file
+        copy_file "active_factory.rb", "spec/support/active_factory.rb"
+      end
+    end
+  end
+end

data/lib/generators/active_factory/install/templates/active_factory.rb

@@ -0,0 +1,9 @@
+require 'active_factory'
+
+RSpec::configure do |config|
+  config.include ActiveFactory::API, :type => :controller
+  config.include ActiveFactory::API, :type => :model
+  config.include ActiveFactory::API, :type => :request
+end
+
+require File.expand_path "../../define_factories", __FILE__

data/lib/generators/active_factory/install/templates/define_factories.rb

@@ -0,0 +1,7 @@
+class ActiveFactory::Define
+  # define your factories here, e.g.
+  #
+  # factory :post, :class => Post do
+  #   title { "example title #{index}" }
+  # end
+end

data/lib/hash_struct.rb

@@ -0,0 +1,16 @@
+class HashStruct < Hash
+  def initialize hash
+    merge! hash
+      keys.each { |key|
+        eval %{ def self.#{key}; self[:#{key}] end }
+      }
+  end
+
+  def self.[] hash
+    new Hash[hash]
+  end
+
+  def merge *args
+    HashStruct.new(super(*args))
+  end
+end

data/spec/active_factory_define_spec.rb

@@ -0,0 +1,95 @@
+require 'support/active_record_environment'
+require 'active_factory'
+require "#{File.dirname(__FILE__)}/spec_helper"
+require "#{File.dirname(__FILE__)}/define_lib_factories"
+
+describe ActiveFactory::Define do
+  include ActiveFactory::API
+  include Test::Unit::Assertions
+  include ActiveRecordEnvironment
+
+  before(:each) do
+    empty_database!
+  end
+
+  describe "Processes factory definitions:" do
+
+    def get_factory name
+      ActiveFactory::Define.factories_hash[name]
+    end
+
+    it "with explicit class and explicit values for attributes" do
+      factory = get_factory :simple_user
+      factory.model_class.should == User
+      factory.after_build.should == nil
+      factory.prefer_associations.should == nil
+      factory.attributes_for(0).should ==
+          {:email => 'simple_user@gmail.com',
+           :password => 'simple_password'}
+    end
+
+    it "with implicit class and blocks for attributes" do
+      factory = get_factory :user
+      factory.model_class.should == User
+      factory.after_build.should == nil
+      factory.prefer_associations.should == nil
+      factory.attributes_for(0).should ==
+          {:email => 'user0@tut.by',
+           :password => 'password00'}
+      factory.attributes_for(1).should ==
+          {:email => 'user1@tut.by',
+           :password => 'password11'}
+    end
+
+    it "with explicit class and blocks for attributes" do
+      factory = get_factory :post
+      factory.model_class.should == Post
+      factory.after_build.should == nil
+      factory.prefer_associations.should == nil
+      factory.attributes_for(0).should ==
+          {:text => "Content 0"}
+    end
+
+    it "with after_build block" do
+      factory = get_factory :post_with_after_build
+      factory.model_class.should == Post
+      factory.after_build.should be_an_instance_of Proc
+      factory.prefer_associations.should == nil
+      factory.attributes_for(0).should ==
+          {:text => "Post with after_build"}
+
+      post = mock "Post"
+      post.should_receive(:text=).with("After Build 0").and_return(nil)
+      factory.apply_after_build 0, nil, post
+    end
+
+    it "with before_save block" do
+      factory = get_factory :post_with_before_save
+      factory.model_class.should == Post
+      factory.before_save.should be_an_instance_of Proc
+      factory.prefer_associations.should == nil
+      factory.attributes_for(0).should ==
+          {:text => "Post with before_save"}
+
+      post = mock "Post"
+      post.should_receive(:text=).with("Before Save 0").and_return(nil)
+      factory.apply_before_save 0, nil, post
+    end
+
+    it "with preferred associations" do
+      factory = get_factory :follower
+      factory.prefer_associations.should == [:following]
+    end
+    
+    it "with parent" do
+      factory = get_factory :user_with_parent
+      factory.name.should == :user_with_parent
+      factory.parent.name.should == :user
+      factory.model_class.should == User
+      factory.attributes_for(0).should == {
+        :email => "user0@tut.by",
+        :password => "overriden"
+      }
+    end
+  end
+end

data/spec/active_factory_spec.rb

@@ -0,0 +1,324 @@
+require 'support/active_record_environment'
+require 'active_factory'
+require "#{File.dirname(__FILE__)}/spec_helper"
+require "#{File.dirname(__FILE__)}/define_lib_factories"
+
+describe "ActiveFactory" do
+  include ActiveFactory::API
+  include Test::Unit::Assertions
+  include ActiveRecordEnvironment
+
+  before(:each) do
+    empty_database!
+  end
+
+# INTRODUCING METHODS
+
+  it "defines methods in models{} section to declare a singleton object and hash, collection of objects and hashes" do
+    models {
+      respond_to?(:user).should == true
+      respond_to?(:user_).should == true
+      respond_to?(:users).should == true
+      respond_to?(:users_).should == true
+
+      respond_to?(:simple_user).should == true
+      respond_to?(:follower).should == true
+      respond_to?(:post).should == true
+    }
+  end
+
+  it "defines methods in the current spec context to access a singleton object, a singleton hash, a collection and a collection of hashes" do
+    models { user }
+
+    respond_to?(:user).should == true
+    respond_to?(:user_).should == true
+    respond_to?(:users).should == true
+    respond_to?(:users_).should == true
+
+    respond_to?(:post).should == false
+    respond_to?(:post_).should == false
+    respond_to?(:posts).should == false
+    respond_to?(:posts_).should == false
+  end
+
+  it "vice versa" do
+    models { post }
+
+    respond_to?(:post).should == true
+    respond_to?(:user).should == false
+  end
+
+# CREATING IN MODELS SECTION
+
+  it "creates singleton model without blocks and with explicit class" do
+    models { simple_user }
+
+    simple_user.email.should == "simple_user@gmail.com"
+    simple_user.password.should == "simple_password"
+    simple_user.should be_an_instance_of User
+    simple_user.should_not be_new_record
+
+    User.all.should == [simple_user]
+  end
+
+  it "creates singleton model 'user' with index and implicit class" do
+    models { user }
+
+    user.email.should == "user0@tut.by"
+    user.password.should == "password00"
+
+    user.should be_an_instance_of User
+    user.should_not be_new_record
+
+    User.all.should == [user]
+  end
+
+  it "creates a collection" do
+    models { users(2) }
+
+    users[0].email.should == "user0@tut.by"
+    users[1].email.should == "user1@tut.by"
+    users[1].password.should == "password11"
+
+    users.size.should == 2
+    User.all.should == users
+  end
+
+  it "collection(i) adds specified number of new instances to a collection" do
+    models { users(1); users(2) }
+
+    users[0].email.should == "user0@tut.by"
+    users[1].email.should == "user1@tut.by"
+    users[2].email.should == "user2@tut.by"
+
+    users.size.should == 3
+    User.all.should == users
+  end
+
+  it "collection() syntax allows to refer to all entities already created by a factory" do
+    models { users }
+
+    users.size.should == 0
+  end
+  
+  it "collection(1) syntax creates additional instance" do
+    models { user; users(1) }
+
+    users[0].email.should == "user0@tut.by"
+    users[1].email.should == "user1@tut.by"
+
+    users.size.should == 2
+  end
+
+  it "singleton syntax does not create additional instances, if it already exist" do
+    models { users(1); user }
+
+    users.size.should == 1
+
+    User.all.should == users
+  end
+
+  it "cannot use singleton syntax when many instances are created" do
+    assert_raise RuntimeError do
+      models { users(2); user }
+    end
+  end
+
+# HASHES IN PRODUCE SECTION
+
+  it "singleton syntax defines 'user_' method to access a hash" do
+    models { user } #.define_all
+
+    user_.should == {:email => "user0@tut.by", :password => "password00" }
+    user.should be_an_instance_of User
+  end
+
+  it "declares hash without creating an object" do
+    models { user_ }
+
+    user_.should == {:email => "user0@tut.by", :password => "password00" }
+    user.should == nil
+
+    User.all.should == []
+  end
+
+  it "defines symbols 'users' and 'users_' for a collection" do
+    models { users(1) } #.define_all
+
+    users[0].email.should == "user0@tut.by"
+    users_[0].email.should == "user0@tut.by"
+    users[0].should_not be_new_record
+
+    users.size.should == 1
+    User.all.should == users
+  end
+
+  it "declares many hashes without creating" do
+    models { posts_(2) }
+
+    posts_[0].text.should == "Content 0"
+    posts_[1].text.should == "Content 1"
+
+    Post.all.should == []
+  end
+
+  it "" do
+    models { users(1) ; users_(1); users(1) }
+
+    users[0].should be_an_instance_of User
+    users[1].should be_an_instance_of NilClass
+    users[2].should be_an_instance_of User
+  end
+
+# LINKING
+  
+  it "associates through belongs_to" do
+    models { post - user }
+
+    post.user.should == user
+    user.posts.should == [post]
+
+    Post.all.should == [post]
+    Post.all.map(&:user).should == [user]
+  end
+
+  it "associates through has_many" do
+    models { user - post }
+
+    post.user.should == user
+    user.posts.should == [post]
+
+    User.all.should == [user]
+    User.all.map(&:posts).should == [[post]]
+  end
+
+  it "associates singleton and collection" do
+    models { user - posts(2) }
+
+    user.posts.should == posts
+    posts.map(&:user).should == [user, user]
+
+    User.all.should == [user]
+    User.all.map(&:posts).should =~ [posts]
+  end
+
+  it "associates collections" do
+    models { posts(3) - users(1) }
+
+    _posts = 3.times.map { |n| Post.find_by_text("Content #{n}") }
+
+    user.posts.all.should == _posts
+  end
+
+  it "zips links" do
+    models { users(2) - posts(2) }
+
+    2.times { |i|
+      posts[i].user_id.should == users[i].id
+    }
+
+    Post.all.should =~ posts
+    Post.all.map(&:user).should =~ users
+  end
+
+  it "it associates only specified number of posts, not all" do
+    models { posts(1); posts(1) - user }
+
+    posts[0].user.should == nil
+    posts[1].user.should == user
+
+    Post.all.map(&:user).should =~ [nil, user]
+  end
+
+# ADVANCED FACTORY OPTIONS
+
+  it "uses prefer_associations option to disambiguate associations (followers & following)" do
+    models { follower - user }
+    
+    follower.following.should == [user]
+    follower.followers.should == []
+
+    User.all.should =~ [follower, user]
+  end
+
+  it "allows to redefine prefer_associations" do
+    models { follower - :followers - user }
+
+    follower.followers.should == [user]
+    follower.following.should == []
+
+    User.all.should =~ [follower, user]
+  end
+  
+  it "invokes after_build" do
+    models { post_with_after_build }
+
+    post_with_after_build.text.should == "After Build 0"
+  end
+
+  it "provides methods for hash keys" do
+    models { post_with_after_builds(1) }
+
+    post_with_after_builds_[0].text.should == "Post with after_build"
+  end  
+
+  it "syntax sugar to merge" do
+    models { user_ }
+
+    user_(:text => "new@email.com").should == user_.merge(:text => "new@email.com")
+  end
+
+  it "syntax sugar for update_attribute" do
+    models { simple_user(:email => "modified@email.com") }
+
+    simple_user.email.should == "modified@email.com"
+  end
+
+  it "syntax sugar for update_attribute for multiple instances" do
+    models { simple_users({:email => "1st@email.com"}, {:email => "2nd@email.com"})}
+
+    simple_users.size.should == 2
+    simple_users[0].email.should == "1st@email.com"
+    simple_users[1].email.should == "2nd@email.com"
+  end
+
+# MORE
+
+  it "leaves no coincidental methods in following specs" do
+    models { post_overrides_method }
+
+    assert_raise(NameError) { simple_user }
+    assert_raise(NameError) { simple_user_ }
+    assert_raise(NameError) { simple_users }
+    assert_raise(NameError) { simple_users_ }
+    assert_raise(NameError) { post }
+  end
+
+  def post_overrides_method_; "invoke function" end
+
+  it "preserves old methods" do
+    post_overrides_method_.should == "invoke function"
+  end
+
+  def some_method
+    :some_outer_method_result
+  end
+
+  it "outer methods are accessible in models {} section" do
+    should_receive(:some_method).with(:some_arg, 1).and_return(:some_result)
+
+    models { some_method(:some_arg, 1).should == :some_result }
+  end
+
+  it "#factory_attributes returns attributes" do
+
+    assert_equal({:text => "Content 1"}, self.class.class_eval { factory_attributes(:post, 1) })
+  end
+
+  it "::Define.models[:user] is model" do
+    factory = ActiveFactory::Define.factories_hash[:user]
+
+    assert factory
+    factory.model_class.should == User
+  end
+end