formnestic 1.0.0

data/spec/spec_helper.rb

@@ -0,0 +1,553 @@
+# encoding: utf-8
+
+require 'rubygems'
+require 'spork'
+require 'bundler/setup'
+require 'active_support'
+require 'action_pack'
+require 'action_view'
+require 'action_controller'
+require 'action_dispatch'
+require 'formtastic'
+
+# require 'ammeter/init'
+
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/formnestic'))
+
+#uncomment the following line to use spork with the debugger
+#require 'spork/ext/ruby-debug'
+
+Spork.prefork do
+  # Loading more in this block will cause your tests to run faster. However,
+  # if you change any configuration or code from libraries loaded here, you'll
+  # need to restart spork for it take effect.
+
+end
+
+Spork.each_run do
+  # This code will be run each time you run your specs.
+  # Requires supporting files with custom matchers and macros, etc,
+  # in ./support/ and its subdirectories in alphabetic order.
+  Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].sort.each {|f| require f}
+
+  module FakeHelpersModule
+  end
+
+  module FormtasticSpecHelper
+    include ActionPack
+    include ActionView::Context if defined?(ActionView::Context)
+    include ActionController::RecordIdentifier if defined?(ActionController::RecordIdentifier)
+    include ActionView::Helpers::FormHelper
+    include ActionView::Helpers::FormTagHelper
+    include ActionView::Helpers::FormOptionsHelper
+    include ActionView::Helpers::UrlHelper
+    include ActionView::Helpers::TagHelper
+    include ActionView::Helpers::TextHelper
+    include ActionView::Helpers::ActiveRecordHelper if defined?(ActionView::Helpers::ActiveRecordHelper)
+    include ActionView::Helpers::ActiveModelHelper if defined?(ActionView::Helpers::ActiveModelHelper)
+    include ActionView::Helpers::DateHelper
+    include ActionView::Helpers::CaptureHelper
+    include ActionView::Helpers::AssetTagHelper
+    include ActiveSupport
+    include ActionController::PolymorphicRoutes if defined?(ActionController::PolymorphicRoutes)
+
+    include Formtastic::Helpers::FormHelper
+
+    def default_input_type(column_type, column_name = :generic_column_name)
+      @new_post.stub(column_name)
+      @new_post.stub(:column_for_attribute).and_return(double('column', :type => column_type)) unless column_type.nil?
+
+      semantic_form_for(@new_post) do |builder|
+        @default_type = builder.send(:default_input_type, column_name)
+      end
+
+      return @default_type
+    end
+
+    def active_model_validator(kind, attributes, options = {})
+      validator = double("ActiveModel::Validations::#{kind.to_s.titlecase}Validator", :attributes => attributes, :options => options)
+      validator.stub(:kind).and_return(kind)
+      validator
+    end
+
+    def active_model_presence_validator(attributes, options = {})
+      active_model_validator(:presence, attributes, options)
+    end
+
+    def active_model_length_validator(attributes, options = {})
+      active_model_validator(:length, attributes, options)
+    end
+
+    def active_model_inclusion_validator(attributes, options = {})
+      active_model_validator(:inclusion, attributes, options)
+    end
+
+    def active_model_numericality_validator(attributes, options = {})
+      active_model_validator(:numericality, attributes, options)
+    end
+
+    class ::MongoPost
+      include MongoMapper::Document if defined?(MongoMapper::Document)
+
+      def id
+      end
+
+      def persisted?
+      end
+    end
+
+
+    class ::Post
+      extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+      include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+
+      def id
+      end
+
+      def persisted?
+      end
+      
+      def title
+        "sample title"
+      end
+      
+      def body
+        "sample body"
+      end
+      
+      def post_date
+        Date.today
+      end
+      
+      def recent
+        true
+      end      
+    end
+
+    module ::Namespaced
+      class Post
+        extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+        include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+
+        def id
+        end
+
+        def persisted?
+        end
+      end
+    end
+
+    class ::Author
+      extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+      include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+
+      def to_label
+      end
+
+      def persisted?
+      end
+    end
+
+    class ::HashBackedAuthor < Hash
+      extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+      include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+      def persisted?; false; end
+      def name
+        'hash backed author'
+      end
+    end
+
+    class ::Continent
+      extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+      include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+    end
+
+    class ::PostModel
+      extend ActiveModel::Naming if defined?(ActiveModel::Naming)
+      include ActiveModel::Conversion if defined?(ActiveModel::Conversion)
+    end
+
+    ##
+    # We can't mock :respond_to?, so we need a concrete class override
+    class ::MongoidReflectionMock < RSpec::Mocks::Mock
+      def initialize(name=nil, stubs_and_options={})
+        super name, stubs_and_options
+      end
+
+      def respond_to?(sym)
+        sym == :options ? false : super
+      end
+    end
+
+    def _routes
+      url_helpers = double('url_helpers')
+      url_helpers.stub(:hash_for_posts_path).and_return({})
+      url_helpers.stub(:hash_for_post_path).and_return({})
+      url_helpers.stub(:hash_for_post_models_path).and_return({})
+      url_helpers.stub(:hash_for_authors_path).and_return({})
+
+      double('_routes',
+        :url_helpers => url_helpers,
+        :url_for => "/mock/path"
+      )
+    end
+
+    def controller
+      env = double('env', :[] => nil)
+      request = double('request', :env => env)
+      double('controller', :controller_path= => '', :params => {}, :request => request)
+    end
+
+    def default_url_options
+      {}
+    end
+
+    def mock_everything
+
+      # Resource-oriented styles like form_for(@post) will expect a path method for the object,
+      # so we're defining some here.
+      def post_models_path(*args); "/postmodels/1"; end
+
+      def post_path(*args); "/posts/1"; end
+      def posts_path(*args); "/posts"; end
+      def new_post_path(*args); "/posts/new"; end
+
+      def author_path(*args); "/authors/1"; end
+      def authors_path(*args); "/authors"; end
+      def new_author_path(*args); "/authors/new"; end
+
+      @fred = ::Author.new
+      @fred.stub(:class).and_return(::Author)
+      @fred.stub(:to_label).and_return('Fred Smith')
+      @fred.stub(:login).and_return('fred_smith')
+      @fred.stub(:age).and_return(27)
+      @fred.stub(:id).and_return(37)
+      @fred.stub(:new_record?).and_return(false)
+      @fred.stub(:errors).and_return(double('errors', :[] => nil))
+      @fred.stub(:to_key).and_return(nil)
+      @fred.stub(:persisted?).and_return(nil)
+      @fred.stub(:name).and_return('Fred')
+
+      @bob = ::Author.new
+      @bob.stub(:to_label).and_return('Bob Rock')
+      @bob.stub(:login).and_return('bob')
+      @bob.stub(:age).and_return(43)
+      @bob.stub(:created_at)
+      @bob.stub(:id).and_return(42)
+      @bob.stub(:posts).and_return([])
+      @bob.stub(:post_ids).and_return([])
+      @bob.stub(:new_record?).and_return(false)
+      @bob.stub(:errors).and_return(double('errors', :[] => nil))
+      @bob.stub(:to_key).and_return(nil)
+      @bob.stub(:persisted?).and_return(nil)
+      @bob.stub(:name).and_return('Bob')
+
+      @james = ::Author.new
+      @james.stub(:to_label).and_return('James Shock')
+      @james.stub(:login).and_return('james')
+      @james.stub(:age).and_return(38)
+      @james.stub(:id).and_return(75)
+      @james.stub(:posts).and_return([])
+      @james.stub(:post_ids).and_return([])
+      @james.stub(:new_record?).and_return(false)
+      @james.stub(:errors).and_return(double('errors', :[] => nil))
+      @james.stub(:to_key).and_return(nil)
+      @james.stub(:persisted?).and_return(nil)
+      @james.stub(:name).and_return('James')
+      
+      @alan = ::Author.new
+      @alan.stub(:to_label).and_return('James Shock')
+      @alan.stub(:login).and_return('james')
+      @alan.stub(:age).and_return(38)
+      @alan.stub(:id).and_return(75)
+      @alan.stub(:posts).and_return([])
+      @alan.stub(:post_ids).and_return([])
+      @alan.stub(:new_record?).and_return(false)
+      @alan.stub(:errors).and_return(double('errors', :[] => nil))
+      @alan.stub(:to_key).and_return(nil)
+      @alan.stub(:persisted?).and_return(nil)
+      @alan.stub(:name).and_return('James')
+
+
+      ::Author.stub(:scoped).and_return(::Author)
+      ::Author.stub(:find).and_return([@fred, @bob])
+      ::Author.stub(:all).and_return([@fred, @bob])
+      ::Author.stub(:where).and_return([@fred, @bob])
+      ::Author.stub(:human_attribute_name).and_return { |column_name| column_name.humanize }
+      ::Author.stub(:human_name).and_return('::Author')
+      ::Author.stub(:reflect_on_association).and_return { |column_name| double('reflection', :options => {}, :klass => Post, :macro => :has_many) if column_name == :posts }
+      ::Author.stub(:content_columns).and_return([double('column', :name => 'login'), double('column', :name => 'created_at')])
+      ::Author.stub(:nested_attributes_options).and_return({:posts => {:allow_destroy => true, :update_only => false}})
+      ::Author.class_eval do 
+        def posts_attributes=(attributes)
+          # do nothing
+        end
+      end
+      ::Author.stub(:accepts_nested_attributes_for)
+      ::Author.stub(:to_key).and_return(nil)
+      ::Author.stub(:persisted?).and_return(nil)
+
+      @hash_backed_author = HashBackedAuthor.new
+
+      # Sometimes we need a mock @post object and some Authors for belongs_to
+      @new_post = double('post')
+      @new_post.stub(:class).and_return(::Post)
+      @new_post.stub(:id).and_return(nil)
+      @new_post.stub(:new_record?).and_return(true)
+      @new_post.stub(:errors).and_return(double('errors', :[] => nil))
+      @new_post.stub(:author).and_return(nil)
+      @new_post.stub(:author_attributes=).and_return(nil)
+      @new_post.stub(:authors).and_return([@fred])
+      @new_post.stub(:authors_attributes=)
+      @new_post.stub(:reviewer).and_return(nil)
+      @new_post.stub(:main_post).and_return(nil)
+      @new_post.stub(:sub_posts).and_return([]) #TODO should be a mock with methods for adding sub posts
+      @new_post.stub(:to_key).and_return(nil)
+      @new_post.stub(:to_model).and_return(@new_post)
+      @new_post.stub(:persisted?).and_return(nil)
+
+      @freds_post = double('post')
+      @freds_post.stub(:to_ary)
+      @freds_post.stub(:class).and_return(::Post)
+      @freds_post.stub(:to_label).and_return('Fred Smith')
+      @freds_post.stub(:id).and_return(19)
+      @freds_post.stub(:title).and_return("Hello World")
+      @freds_post.stub(:author).and_return(@fred)
+      @freds_post.stub(:author_id).and_return(@fred.id)
+      @freds_post.stub(:authors).and_return([@fred])
+      @freds_post.stub(:author_ids).and_return([@fred.id])
+      @freds_post.stub(:new_record?).and_return(false)
+      @freds_post.stub(:errors).and_return(double('errors', :[] => nil))
+      @freds_post.stub(:to_key).and_return(nil)
+      @freds_post.stub(:persisted?).and_return(nil)
+      @fred.stub(:posts).and_return([@freds_post])
+      @fred.stub(:post_ids).and_return([@freds_post.id])
+      
+      @alan_post1 = double('post')
+      @alan_post1.stub(:to_ary)
+      @alan_post1.stub(:class).and_return(::Post)
+      @alan_post1.stub(:to_label).and_return('Alan Smith 1')
+      @alan_post1.stub(:id).and_return(19)
+      @alan_post1.stub(:title).and_return("Hello World 1")
+      @alan_post1.stub(:body).and_return("Some Body 1")
+      @alan_post1.stub(:author).and_return(@fred)
+      @alan_post1.stub(:author_id).and_return(@fred.id)
+      @alan_post1.stub(:authors).and_return([@fred])
+      @alan_post1.stub(:author_ids).and_return([@fred.id])
+      @alan_post1.stub(:new_record?).and_return(false)
+      @alan_post1.stub(:errors).and_return(double('errors', :[] => nil))
+      @alan_post1.stub(:to_key).and_return(nil)
+      @alan_post1.stub(:persisted?).and_return(nil)
+      @alan_post1.stub(:recent).and_return(true)
+      
+      @alan_post2 = double('post')
+      @alan_post2.stub(:to_ary)
+      @alan_post2.stub(:class).and_return(::Post)
+      @alan_post2.stub(:to_label).and_return('Alan Smith 2')
+      @alan_post2.stub(:id).and_return(19)
+      @alan_post2.stub(:title).and_return("Hello World 2")
+      @alan_post2.stub(:body).and_return("Some Body 2")
+      @alan_post2.stub(:author).and_return(@fred)
+      @alan_post2.stub(:author_id).and_return(@fred.id)
+      @alan_post2.stub(:authors).and_return([@fred])
+      @alan_post2.stub(:author_ids).and_return([@fred.id])
+      @alan_post2.stub(:new_record?).and_return(false)
+      @alan_post2.stub(:errors).and_return(double('errors', :[] => nil))
+      @alan_post2.stub(:to_key).and_return(nil)
+      @alan_post2.stub(:persisted?).and_return(nil)
+      @alan_post2.stub(:recent).and_return(true)
+      
+      @alan.stub(:posts).and_return([@alan_post1, @alan_post2])
+
+      ::Post.stub(:scoped).and_return(::Post)
+      ::Post.stub(:human_attribute_name).and_return { |column_name| column_name.humanize }
+      ::Post.stub(:human_name).and_return('Post')
+      ::Post.stub(:reflect_on_all_validations).and_return([])
+      ::Post.stub(:reflect_on_validations_for).and_return([])
+      ::Post.stub(:reflections).and_return({})
+      ::Post.stub(:reflect_on_association).and_return do |column_name|
+        case column_name
+        when :author, :author_status
+          mock = double('reflection', :options => {}, :klass => ::Author, :macro => :belongs_to)
+          mock.stub(:[]).with(:class_name).and_return("Author")
+          mock
+        when :reviewer
+          mock = double('reflection', :options => {:class_name => 'Author'}, :klass => ::Author, :macro => :belongs_to)
+          mock.stub(:[]).with(:class_name).and_return("Author")
+          mock
+        when :authors
+          double('reflection', :options => {}, :klass => ::Author, :macro => :has_and_belongs_to_many)
+        when :sub_posts
+          double('reflection', :options => {}, :klass => ::Post, :macro => :has_many)
+        when :main_post
+          double('reflection', :options => {}, :klass => ::Post, :macro => :belongs_to)
+        when :mongoid_reviewer
+          ::MongoidReflectionMock.new('reflection',
+               :options => Proc.new { raise NoMethodError, "Mongoid has no reflection.options" },
+               :klass => ::Author, :macro => :referenced_in, :foreign_key => "reviewer_id") # custom id
+        end
+      end
+      ::Post.stub(:find).and_return([@freds_post])
+      ::Post.stub(:all).and_return([@freds_post])
+      ::Post.stub(:where).and_return([@freds_post])
+      ::Post.stub(:content_columns).and_return([double('column', :name => 'title'), double('column', :name => 'body'), double('column', :name => 'created_at')])
+      ::Post.stub(:to_key).and_return(nil)
+      ::Post.stub(:persisted?).and_return(nil)
+      ::Post.stub(:to_ary)
+
+      ::MongoPost.stub(:human_attribute_name).and_return { |column_name| column_name.humanize }
+      ::MongoPost.stub(:human_name).and_return('MongoPost')
+      ::MongoPost.stub(:associations).and_return({
+        :sub_posts => double('reflection', :options => {:polymorphic => true}, :klass => ::MongoPost, :macro => :has_many),
+        :options => []
+      })
+      ::MongoPost.stub(:find).and_return([@freds_post])
+      ::MongoPost.stub(:all).and_return([@freds_post])
+      ::MongoPost.stub(:where).and_return([@freds_post])
+      ::MongoPost.stub(:to_key).and_return(nil)
+      ::MongoPost.stub(:persisted?).and_return(nil)
+      ::MongoPost.stub(:to_ary)
+      ::MongoPost.stub(:model_name).and_return( double(:model_name_mock, :singular => "post", :plural => "posts", :param_key => "post", :route_key => "posts") )
+
+      @new_mm_post = double('mm_post')
+      @new_mm_post.stub(:class).and_return(::MongoPost)
+      @new_mm_post.stub(:id).and_return(nil)
+      @new_mm_post.stub(:new_record?).and_return(true)
+      @new_mm_post.stub(:errors).and_return(double('errors', :[] => nil))
+      @new_mm_post.stub(:title).and_return("Hello World")
+      @new_mm_post.stub(:sub_posts).and_return([]) #TODO should be a mock with methods for adding sub posts
+      @new_mm_post.stub(:to_key).and_return(nil)
+      @new_mm_post.stub(:to_model).and_return(@new_mm_post)
+      @new_mm_post.stub(:persisted?).and_return(nil)
+
+      @mock_file = double('file')
+      Formtastic::FormBuilder.file_methods.each do |method|
+        @mock_file.stub(method).and_return(true)
+      end
+
+      @new_post.stub(:title)
+      @new_post.stub(:email)
+      @new_post.stub(:url)
+      @new_post.stub(:phone)
+      @new_post.stub(:search)
+      @new_post.stub(:to_ary)
+      @new_post.stub(:body)
+      @new_post.stub(:published)
+      @new_post.stub(:publish_at)
+      @new_post.stub(:created_at)
+      @new_post.stub(:secret).and_return(1)
+      @new_post.stub(:url)
+      @new_post.stub(:email)
+      @new_post.stub(:search)
+      @new_post.stub(:phone)
+      @new_post.stub(:time_zone)
+      @new_post.stub(:category_name)
+      @new_post.stub(:allow_comments).and_return(true)
+      @new_post.stub(:answer_comments)
+      @new_post.stub(:country)
+      @new_post.stub(:country_subdivision)
+      @new_post.stub(:country_code)
+      @new_post.stub(:document).and_return(@mock_file)
+      @new_post.stub(:column_for_attribute).with(:meta_description).and_return(double('column', :type => :string, :limit => 255))
+      @new_post.stub(:column_for_attribute).with(:title).and_return(double('column', :type => :string, :limit => 50))
+      @new_post.stub(:column_for_attribute).with(:body).and_return(double('column', :type => :text))      
+      @new_post.stub(:column_for_attribute).with(:published).and_return(double('column', :type => :boolean))
+      @new_post.stub(:column_for_attribute).with(:publish_at).and_return(double('column', :type => :date))
+      @new_post.stub(:column_for_attribute).with(:time_zone).and_return(double('column', :type => :string))
+      @new_post.stub(:column_for_attribute).with(:allow_comments).and_return(double('column', :type => :boolean))
+      @new_post.stub(:column_for_attribute).with(:author).and_return(double('column', :type => :integer))
+      @new_post.stub(:column_for_attribute).with(:country).and_return(double('column', :type => :string, :limit => 255))
+      @new_post.stub(:column_for_attribute).with(:country_subdivision).and_return(double('column', :type => :string, :limit => 255))
+      @new_post.stub(:column_for_attribute).with(:country_code).and_return(double('column', :type => :string, :limit => 255))
+      @new_post.stub(:column_for_attribute).with(:email).and_return(double('column', :type => :string, :limit => 255))
+      @new_post.stub(:column_for_attribute).with(:url).and_return(double('column', :type => :string, :limit => 255))
+      @new_post.stub(:column_for_attribute).with(:phone).and_return(double('column', :type => :string, :limit => 255))
+      @new_post.stub(:column_for_attribute).with(:search).and_return(double('column', :type => :string, :limit => 255))
+      @new_post.stub(:column_for_attribute).with(:document).and_return(nil)
+
+      @new_post.stub(:author).and_return(@bob)
+      @new_post.stub(:author_id).and_return(@bob.id)
+
+      @new_post.stub(:reviewer).and_return(@fred)
+      @new_post.stub(:reviewer_id).and_return(@fred.id)
+
+      @new_post.stub(:publish_at=)
+      @new_post.stub(:title=)
+      @new_post.stub(:main_post_id).and_return(nil)
+
+    end
+
+    def self.included(base)
+      base.class_eval do
+
+        attr_accessor :output_buffer
+
+        def protect_against_forgery?
+          false
+        end
+
+        def _helpers
+          FakeHelpersModule
+        end
+
+      end
+    end
+
+    def with_config(config_method_name, value, &block)
+      old_value = Formtastic::FormBuilder.send(config_method_name)
+      Formtastic::FormBuilder.send(:"#{config_method_name}=", value)
+      yield
+      Formtastic::FormBuilder.send(:"#{config_method_name}=", old_value)
+    end
+
+  end
+
+  ::ActiveSupport::Deprecation.silenced = false
+
+  RSpec.configure do |config|
+    config.before(:each) do
+      Formtastic::Localizer.cache.clear!    
+    end
+  
+    config.before(:all) do
+      DeferredGarbageCollection.start unless ENV["DEFER_GC"] == "false"
+    end
+    config.after(:all) do
+      DeferredGarbageCollection.reconsider unless ENV["DEFER_GC"] == "false"    
+    end
+  end
+  
+end
+
+# --- Instructions ---
+# Sort the contents of this file into a Spork.prefork and a Spork.each_run
+# block.
+#
+# The Spork.prefork block is run only once when the spork server is started.
+# You typically want to place most of your (slow) initializer code in here, in
+# particular, require'ing any 3rd-party gems that you don't normally modify
+# during development.
+#
+# The Spork.each_run block is run each time you run your specs.  In case you
+# need to load files that tend to change during development, require them here.
+# With Rails, your application modules are loaded automatically, so sometimes
+# this block can remain empty.
+#
+# Note: You can modify files loaded *from* the Spork.each_run block without
+# restarting the spork server.  However, this file itself will not be reloaded,
+# so if you change any of the code inside the each_run block, you still need to
+# restart the server.  In general, if you have non-trivial code in this file,
+# it's advisable to move it into a separate file so you can easily edit it
+# without restarting spork.  (For example, with RSpec, you could move
+# non-trivial code into a file spec/support/my_helper.rb, making sure that the
+# spec/support/* files are require'd from inside the each_run block.)
+#
+# Any code that is left outside the two blocks will be run during preforking
+# *and* during each_run -- that's probably not what you want.
+#
+# These instructions should self-destruct in 10 seconds.  If they don't, feel
+# free to delete them.
+
+
+
+