formtastic 3.0.0 → 5.0.0

data/spec/helpers/input_helper_spec.rb

@@ -1,31 +1,24 @@
 # encoding: utf-8
+# frozen_string_literal: true
 require 'spec_helper'
 
-describe 'Formtastic::FormBuilder#input' do
-
-  include FormtasticSpecHelper
+RSpec.describe 'with input class finder' do
+  include_context 'form builder'
 
   before do
-    @output_buffer = ''
-    mock_everything
-
     @errors = double('errors')
-    @errors.stub(:[]).and_return([])
-    @new_post.stub(:errors).and_return(@errors)
-  end
-
-  after do
-    ::I18n.backend.reload!
+    allow(@errors).to receive(:[]).and_return([])
+    allow(@new_post).to receive(:errors).and_return(@errors)
   end
 
   describe 'arguments and options' do
 
     it 'should require the first argument (the method on form\'s object)' do
-      lambda {
+      expect {
         concat(semantic_form_for(@new_post) do |builder|
           concat(builder.input()) # no args passed in at all
         end)
-      }.should raise_error(ArgumentError)
+      }.to raise_error(ArgumentError)
     end
 
     describe ':required option' do
@@ -37,8 +30,8 @@ describe 'Formtastic::FormBuilder#input' do
             concat(semantic_form_for(@new_post) do |builder|
               concat(builder.input(:title, :required => true))
             end)
-            output_buffer.should_not have_tag('form li.optional')
-            output_buffer.should have_tag('form li.required')
+            expect(output_buffer.to_str).not_to have_tag('form li.optional')
+            expect(output_buffer.to_str).to have_tag('form li.required')
           end
         end
 
@@ -47,7 +40,7 @@ describe 'Formtastic::FormBuilder#input' do
             concat(semantic_form_for(@new_post) do |builder|
               concat(builder.input(:title, :required => true))
             end)
-            output_buffer.should have_tag('form li.required label', /required yo/)
+            expect(output_buffer.to_str).to have_tag('form li.required label', :text => /required yo/)
           end
         end
       end
@@ -56,7 +49,7 @@ describe 'Formtastic::FormBuilder#input' do
 
         before do
           @string = Formtastic::FormBuilder.optional_string = " optional yo!" # ensure there's something in the string
-          @new_post.class.should_not_receive(:reflect_on_all_validations)
+          expect(@new_post.class).not_to receive(:reflect_on_all_validations)
         end
 
         after do
@@ -67,26 +60,26 @@ describe 'Formtastic::FormBuilder#input' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.input(:title, :required => false))
           end)
-          output_buffer.should_not have_tag('form li.required')
-          output_buffer.should have_tag('form li.optional')
+          expect(output_buffer.to_str).not_to have_tag('form li.required')
+          expect(output_buffer.to_str).to have_tag('form li.optional')
         end
 
         it 'should set and "optional" class also when there is presence validator' do
-          @new_post.class.should_receive(:validators_on).with(:title).at_least(:once).and_return([
-            active_model_presence_validator([:title])
-          ])
+          expect(@new_post.class).to receive(:validators_on).with(:title).at_least(:once).and_return([
+                                                                                                     active_model_presence_validator([:title])
+                                                                                                 ])
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.input(:title, :required => false))
           end)
-          output_buffer.should_not have_tag('form li.required')
-          output_buffer.should have_tag('form li.optional')
+          expect(output_buffer.to_str).not_to have_tag('form li.required')
+          expect(output_buffer.to_str).to have_tag('form li.optional')
         end
 
         it 'should append the "optional" string to the label' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.input(:title, :required => false))
           end)
-          output_buffer.should have_tag('form li.optional label', /#{@string}$/)
+          expect(output_buffer.to_str).to have_tag('form li.optional label', :text => /#{@string}$/)
         end
 
       end
@@ -96,14 +89,14 @@ describe 'Formtastic::FormBuilder#input' do
         describe 'and an object was not given' do
 
           it 'should use the default value' do
-            Formtastic::FormBuilder.all_fields_required_by_default.should == true
+            expect(Formtastic::FormBuilder.all_fields_required_by_default).to eq(true)
             Formtastic::FormBuilder.all_fields_required_by_default = false
 
             concat(semantic_form_for(:project, :url => 'http://test.host/') do |builder|
               concat(builder.input(:title))
             end)
-            output_buffer.should_not have_tag('form li.required')
-            output_buffer.should have_tag('form li.optional')
+            expect(output_buffer.to_str).not_to have_tag('form li.required')
+            expect(output_buffer.to_str).to have_tag('form li.optional')
 
             Formtastic::FormBuilder.all_fields_required_by_default = true
           end
@@ -112,90 +105,151 @@ describe 'Formtastic::FormBuilder#input' do
 
         describe 'and an object with :validators_on was given (ActiveModel, Active Resource)' do
           before do
-            @new_post.stub(:class).and_return(::PostModel)
+            allow(@new_post).to receive(:class).and_return(::PostModel)
           end
 
           after do
-            @new_post.stub(:class).and_return(::Post)
+            allow(@new_post).to receive(:class).and_return(::Post)
           end
           describe 'and validates_presence_of was called for the method' do
             it 'should be required' do
 
-              @new_post.class.should_receive(:validators_on).with(:title).at_least(:once).and_return([
-                active_model_presence_validator([:title])
-              ])
+              expect(@new_post.class).to receive(:validators_on).with(:title).at_least(:once).and_return([
+                                                                                                         active_model_presence_validator([:title])
+                                                                                                     ])
 
-              @new_post.class.should_receive(:validators_on).with(:body).at_least(:once).and_return([
-                active_model_presence_validator([:body], {:if => true})
-              ])
+              expect(@new_post.class).to receive(:validators_on).with(:body).at_least(:once).and_return([
+                                                                                                        active_model_presence_validator([:body], {:if => true})
+                                                                                                    ])
 
               concat(semantic_form_for(@new_post) do |builder|
                 concat(builder.input(:title))
                 concat(builder.input(:body))
               end)
-              output_buffer.should have_tag('form li.required')
-              output_buffer.should_not have_tag('form li.optional')
+              expect(output_buffer.to_str).to have_tag('form li.required')
+              expect(output_buffer.to_str).not_to have_tag('form li.optional')
             end
 
             it 'should be required when there is :on => :create option on create' do
               with_config :required_string, " required yo!" do
-                @new_post.class.should_receive(:validators_on).with(:title).at_least(:once).and_return([
-                  active_model_presence_validator([:title], {:on => :create})
-                ])
+                expect(@new_post.class).to receive(:validators_on).with(:title).at_least(:once).and_return([
+                                                                                                           active_model_presence_validator([:title], {:on => :create})
+                                                                                                       ])
+                concat(semantic_form_for(@new_post) do |builder|
+                  concat(builder.input(:title))
+                end)
+                expect(output_buffer.to_str).to have_tag('form li.required')
+                expect(output_buffer.to_str).not_to have_tag('form li.optional')
+              end
+            end
+
+            it 'should be required when there is :create option in validation contexts array on create' do
+              with_config :required_string, " required yo!" do
+                expect(@new_post.class).to receive(:validators_on).with(:title).at_least(:once).and_return([
+                                                                                                           active_model_presence_validator([:title], {:on => [:create]})
+                                                                                                       ])
                 concat(semantic_form_for(@new_post) do |builder|
                   concat(builder.input(:title))
                 end)
-                output_buffer.should have_tag('form li.required')
-                output_buffer.should_not have_tag('form li.optional')
+                expect(output_buffer.to_str).to have_tag('form li.required')
+                expect(output_buffer.to_str).not_to have_tag('form li.optional')
               end
             end
 
             it 'should be required when there is :on => :save option on create' do
               with_config :required_string, " required yo!" do
-                @new_post.class.should_receive(:validators_on).with(:title).at_least(:once).and_return([
-                  active_model_presence_validator([:title], {:on => :save})
-                ])
+                expect(@new_post.class).to receive(:validators_on).with(:title).at_least(:once).and_return([
+                                                                                                           active_model_presence_validator([:title], {:on => :save})
+                                                                                                       ])
+                concat(semantic_form_for(@new_post) do |builder|
+                  concat(builder.input(:title))
+                end)
+                expect(output_buffer.to_str).to have_tag('form li.required')
+                expect(output_buffer.to_str).not_to have_tag('form li.optional')
+              end
+            end
+
+            it 'should be required when there is :save option in validation contexts array on create' do
+              with_config :required_string, " required yo!" do
+                expect(@new_post.class).to receive(:validators_on).with(:title).at_least(:once).and_return([
+                                                                                                           active_model_presence_validator([:title], {:on => [:save]})
+                                                                                                       ])
                 concat(semantic_form_for(@new_post) do |builder|
                   concat(builder.input(:title))
                 end)
-                output_buffer.should have_tag('form li.required')
-                output_buffer.should_not have_tag('form li.optional')
+                expect(output_buffer.to_str).to have_tag('form li.required')
+                expect(output_buffer.to_str).not_to have_tag('form li.optional')
               end
             end
 
             it 'should be required when there is :on => :save option on update' do
               with_config :required_string, " required yo!" do
-                @fred.class.should_receive(:validators_on).with(:login).at_least(:once).and_return([
-                  active_model_presence_validator([:login], {:on => :save})
-                ])
+                expect(@fred.class).to receive(:validators_on).with(:login).at_least(:once).and_return([
+                                                                                                       active_model_presence_validator([:login], {:on => :save})
+                                                                                                   ])
                 concat(semantic_form_for(@fred) do |builder|
                   concat(builder.input(:login))
                 end)
-                output_buffer.should have_tag('form li.required')
-                output_buffer.should_not have_tag('form li.optional')
+                expect(output_buffer.to_str).to have_tag('form li.required')
+                expect(output_buffer.to_str).not_to have_tag('form li.optional')
+              end
+            end
+
+            it 'should be required when there is :save option in validation contexts array on update' do
+              with_config :required_string, " required yo!" do
+                expect(@fred.class).to receive(:validators_on).with(:login).at_least(:once).and_return([
+                                                                                                       active_model_presence_validator([:login], {:on => [:save]})
+                                                                                                   ])
+                concat(semantic_form_for(@fred) do |builder|
+                  concat(builder.input(:login))
+                end)
+                expect(output_buffer.to_str).to have_tag('form li.required')
+                expect(output_buffer.to_str).not_to have_tag('form li.optional')
               end
             end
 
             it 'should not be required when there is :on => :create option on update' do
-              @fred.class.should_receive(:validators_on).with(:login).at_least(:once).and_return([
-                active_model_presence_validator([:login], {:on => :create})
-              ])
+              expect(@fred.class).to receive(:validators_on).with(:login).at_least(:once).and_return([
+                                                                                                     active_model_presence_validator([:login], {:on => :create})
+                                                                                                 ])
+              concat(semantic_form_for(@fred) do |builder|
+                concat(builder.input(:login))
+              end)
+              expect(output_buffer.to_str).not_to have_tag('form li.required')
+              expect(output_buffer.to_str).to have_tag('form li.optional')
+            end
+
+            it 'should not be required when there is :create option in validation contexts array on update' do
+              expect(@fred.class).to receive(:validators_on).with(:login).at_least(:once).and_return([
+                                                                                                     active_model_presence_validator([:login], {:on => [:create]})
+                                                                                                 ])
               concat(semantic_form_for(@fred) do |builder|
                 concat(builder.input(:login))
               end)
-              output_buffer.should_not have_tag('form li.required')
-              output_buffer.should have_tag('form li.optional')
+              expect(output_buffer.to_str).not_to have_tag('form li.required')
+              expect(output_buffer.to_str).to have_tag('form li.optional')
             end
 
             it 'should not be required when there is :on => :update option on create' do
-              @new_post.class.should_receive(:validators_on).with(:title).at_least(:once).and_return([
-                active_model_presence_validator([:title], {:on => :update})
-              ])
+              expect(@new_post.class).to receive(:validators_on).with(:title).at_least(:once).and_return([
+                                                                                                         active_model_presence_validator([:title], {:on => :update})
+                                                                                                     ])
               concat(semantic_form_for(@new_post) do |builder|
                 concat(builder.input(:title))
               end)
-              output_buffer.should_not have_tag('form li.required')
-              output_buffer.should have_tag('form li.optional')
+              expect(output_buffer.to_str).not_to have_tag('form li.required')
+              expect(output_buffer.to_str).to have_tag('form li.optional')
+            end
+
+            it 'should not be required when there is :update option in validation contexts array on create' do
+              expect(@new_post.class).to receive(:validators_on).with(:title).at_least(:once).and_return([
+                                                                                                         active_model_presence_validator([:title], {:on => [:update]})
+                                                                                                     ])
+              concat(semantic_form_for(@new_post) do |builder|
+                concat(builder.input(:title))
+              end)
+              expect(output_buffer.to_str).not_to have_tag('form li.required')
+              expect(output_buffer.to_str).to have_tag('form li.optional')
             end
 
             it 'should be not be required if the optional :if condition is not satisifed' do
@@ -219,38 +273,38 @@ describe 'Formtastic::FormBuilder#input' do
             end
 
             it 'should be required if the optional :if with a method string evaluates to true' do
-              @new_post.should_receive(:required_condition).and_return(true)
+              expect(@new_post).to receive(:required_condition).and_return(true)
               presence_should_be_required(:required => true, :tag => :body, :options => { :if => :required_condition })
             end
 
             it 'should be required if the optional :if with a method string evaluates to false' do
-              @new_post.should_receive(:required_condition).and_return(false)
+              expect(@new_post).to receive(:required_condition).and_return(false)
               presence_should_be_required(:required => false, :tag => :body, :options => { :if => :required_condition })
             end
 
             it 'should be required if the optional :unless with a method string evaluates to false' do
-               @new_post.should_receive(:required_condition).and_return(false)
+              expect(@new_post).to receive(:required_condition).and_return(false)
               presence_should_be_required(:required => true, :tag => :body, :options => { :unless => :required_condition })
             end
 
-             it 'should not be required if the optional :unless with a method string evaluates to true' do
-               @new_post.should_receive(:required_condition).and_return(true)
-               presence_should_be_required(:required => false, :tag => :body, :options => { :unless => :required_condition })
-             end
+            it 'should not be required if the optional :unless with a method string evaluates to true' do
+              expect(@new_post).to receive(:required_condition).and_return(true)
+              presence_should_be_required(:required => false, :tag => :body, :options => { :unless => :required_condition })
+            end
           end
 
           describe 'and validates_inclusion_of was called for the method' do
             it 'should be required' do
-              @new_post.class.should_receive(:validators_on).with(:published).at_least(:once).and_return([
-                active_model_inclusion_validator([:published], {:in => [false, true]})
-              ])
+              expect(@new_post.class).to receive(:validators_on).with(:published).at_least(:once).and_return([
+                                                                                                             active_model_inclusion_validator([:published], {:in => [false, true]})
+                                                                                                         ])
               should_be_required(:tag => :published, :required => true)
             end
 
             it 'should not be required if allow_blank is true' do
-              @new_post.class.should_receive(:validators_on).with(:published).at_least(:once).and_return([
-                active_model_inclusion_validator([:published], {:in => [false, true], :allow_blank => true})
-              ])
+              expect(@new_post.class).to receive(:validators_on).with(:published).at_least(:once).and_return([
+                                                                                                             active_model_inclusion_validator([:published], {:in => [false, true], :allow_blank => true})
+                                                                                                         ])
               should_be_required(:tag => :published, :required => false)
             end
           end
@@ -282,14 +336,14 @@ describe 'Formtastic::FormBuilder#input' do
           end
 
           def add_presence_validator(options)
-            @new_post.class.stub(:validators_on).with(options[:tag]).and_return([
-              active_model_presence_validator([options[:tag]], options[:options])
-            ])
+            allow(@new_post.class).to receive(:validators_on).with(options[:tag]).and_return([
+                                                                                    active_model_presence_validator([options[:tag]], options[:options])
+                                                                                ])
           end
 
           def add_length_validator(options)
-            @new_post.class.should_receive(:validators_on).with(options[:tag]).at_least(:once) {[
-              active_model_length_validator([options[:tag]], options[:options])
+            expect(@new_post.class).to receive(:validators_on).with(options[:tag]).at_least(:once) {[
+                active_model_length_validator([options[:tag]], options[:options])
             ]}
           end
 
@@ -300,11 +354,11 @@ describe 'Formtastic::FormBuilder#input' do
             end)
 
             if options[:required]
-              output_buffer.should_not have_tag('form li.optional')
-              output_buffer.should have_tag('form li.required')
+              expect(output_buffer.to_str).not_to have_tag('form li.optional')
+              expect(output_buffer.to_str).to have_tag('form li.required')
             else
-              output_buffer.should have_tag('form li.optional')
-              output_buffer.should_not have_tag('form li.required')
+              expect(output_buffer.to_str).to have_tag('form li.optional')
+              expect(output_buffer.to_str).not_to have_tag('form li.required')
             end
           end
 
@@ -321,15 +375,15 @@ describe 'Formtastic::FormBuilder#input' do
           # TODO JF reversed this during refactor, need to make sure
           describe 'and there are no requirement validations on the method' do
             before do
-              @new_post.class.should_receive(:validators_on).with(:title).and_return([])
+              expect(@new_post.class).to receive(:validators_on).with(:title).and_return([])
             end
 
             it 'should not be required' do
               concat(semantic_form_for(@new_post) do |builder|
                 concat(builder.input(:title))
               end)
-              output_buffer.should_not have_tag('form li.required')
-              output_buffer.should have_tag('form li.optional')
+              expect(output_buffer.to_str).not_to have_tag('form li.required')
+              expect(output_buffer.to_str).to have_tag('form li.optional')
             end
           end
 
@@ -337,21 +391,21 @@ describe 'Formtastic::FormBuilder#input' do
 
         describe 'and an object without :validators_on' do
 
-            it 'should use the default value' do
-              Formtastic::FormBuilder.all_fields_required_by_default.should == true
-              Formtastic::FormBuilder.all_fields_required_by_default = false
-
-              concat(semantic_form_for(@new_post) do |builder|
-                concat(builder.input(:title))
-              end)
-              output_buffer.should_not have_tag('form li.required')
-              output_buffer.should have_tag('form li.optional')
+          it 'should use the default value' do
+            expect(Formtastic::FormBuilder.all_fields_required_by_default).to eq(true)
+            Formtastic::FormBuilder.all_fields_required_by_default = false
 
-              Formtastic::FormBuilder.all_fields_required_by_default = true
-            end
+            concat(semantic_form_for(@new_post) do |builder|
+              concat(builder.input(:title))
+            end)
+            expect(output_buffer.to_str).not_to have_tag('form li.required')
+            expect(output_buffer.to_str).to have_tag('form li.optional')
 
+            Formtastic::FormBuilder.all_fields_required_by_default = true
           end
 
+        end
+
       end
 
     end
@@ -364,7 +418,7 @@ describe 'Formtastic::FormBuilder#input' do
           concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
             concat(builder.input(:anything))
           end)
-          output_buffer.should have_tag('form li.string')
+          expect(output_buffer.to_str).to have_tag('form li.string')
         end
 
         it 'should default to password for forms without objects if column is password' do
@@ -373,107 +427,129 @@ describe 'Formtastic::FormBuilder#input' do
             concat(builder.input(:password_confirmation))
             concat(builder.input(:confirm_password))
           end)
-          output_buffer.should have_tag('form li.password', :count => 3)
+          expect(output_buffer.to_str).to have_tag('form li.password', :count => 3)
         end
 
         it 'should default to a string for methods on objects that don\'t respond to "column_for_attribute"' do
-          @new_post.stub(:method_without_a_database_column)
-          @new_post.stub(:column_for_attribute).and_return(nil)
-          default_input_type(nil, :method_without_a_database_column).should == :string
+          allow(@new_post).to receive(:method_without_a_database_column)
+          allow(@new_post).to receive(:column_for_attribute).and_return(nil)
+          expect(default_input_type(nil, :method_without_a_database_column)).to eq(:string)
         end
 
         it 'should default to :password for methods that don\'t have a column in the database but "password" is in the method name' do
-          @new_post.stub(:password_method_without_a_database_column)
-          @new_post.stub(:column_for_attribute).and_return(nil)
-          default_input_type(nil, :password_method_without_a_database_column).should == :password
+          allow(@new_post).to receive(:password_method_without_a_database_column)
+          allow(@new_post).to receive(:column_for_attribute).and_return(nil)
+          expect(default_input_type(nil, :password_method_without_a_database_column)).to eq(:password)
         end
 
         it 'should default to :password for methods on objects that don\'t respond to "column_for_attribute" but "password" is in the method name' do
-          @new_post.stub(:password_method_without_a_database_column)
-          @new_post.stub(:column_for_attribute).and_return(nil)
-          default_input_type(nil, :password_method_without_a_database_column).should == :password
+          allow(@new_post).to receive(:password_method_without_a_database_column)
+          allow(@new_post).to receive(:column_for_attribute).and_return(nil)
+          expect(default_input_type(nil, :password_method_without_a_database_column)).to eq(:password)
         end
 
         it 'should default to :number for "integer" column with name ending in "_id"' do
-          @new_post.stub(:aws_instance_id)
-          @new_post.stub(:column_for_attribute).with(:aws_instance_id).and_return(double('column', :type => :integer))
-          default_input_type(:integer, :aws_instance_id).should == :number
+          allow(@new_post).to receive(:aws_instance_id)
+          allow(@new_post).to receive(:column_for_attribute).with(:aws_instance_id).and_return(double('column', :type => :integer))
+          expect(default_input_type(:integer, :aws_instance_id)).to eq(:number)
         end
 
         it 'should default to :select for associations' do
-          @new_post.class.stub(:reflect_on_association).with(:user_id).and_return(double('ActiveRecord::Reflection::AssociationReflection'))
-          @new_post.class.stub(:reflect_on_association).with(:section_id).and_return(double('ActiveRecord::Reflection::AssociationReflection'))
-          default_input_type(:integer, :user_id).should == :select
-          default_input_type(:integer, :section_id).should == :select
+          allow(@new_post.class).to receive(:reflect_on_association).with(:user_id).and_return(double('ActiveRecord::Reflection::AssociationReflection'))
+          allow(@new_post.class).to receive(:reflect_on_association).with(:section_id).and_return(double('ActiveRecord::Reflection::AssociationReflection'))
+          expect(default_input_type(:integer, :user_id)).to eq(:select)
+          expect(default_input_type(:integer, :section_id)).to eq(:select)
+        end
+
+        it 'should default to :select for enum' do
+          statuses = ActiveSupport::HashWithIndifferentAccess.new("active"=>0, "inactive"=>1)
+          allow(@new_post.class).to receive(:statuses) { statuses }
+          allow(@new_post).to receive(:defined_enums) { {"status" => statuses } }
+
+          expect(default_input_type(:integer, :status)).to eq(:select)
         end
 
         it 'should default to :password for :string column types with "password" in the method name' do
-          default_input_type(:string, :password).should == :password
-          default_input_type(:string, :hashed_password).should == :password
-          default_input_type(:string, :password_hash).should == :password
+          expect(default_input_type(:string, :password)).to eq(:password)
+          expect(default_input_type(:string, :hashed_password)).to eq(:password)
+          expect(default_input_type(:string, :password_hash)).to eq(:password)
         end
 
         it 'should default to :text for :text column types' do
-          default_input_type(:text).should == :text
+          expect(default_input_type(:text)).to eq(:text)
         end
 
         it 'should default to :date_select for :date column types' do
-          default_input_type(:date).should == :date_select
+          expect(default_input_type(:date)).to eq(:date_select)
+        end
+
+        it 'should default to :text for :hstore, :json and :jsonb column types' do
+          expect(default_input_type(:hstore)).to eq(:text)
+          expect(default_input_type(:json)).to eq(:text)
+          expect(default_input_type(:jsonb)).to eq(:text)
         end
 
         it 'should default to :datetime_select for :datetime and :timestamp column types' do
-          default_input_type(:datetime).should == :datetime_select
-          default_input_type(:timestamp).should == :datetime_select
+          expect(default_input_type(:datetime)).to eq(:datetime_select)
+          expect(default_input_type(:timestamp)).to eq(:datetime_select)
         end
 
         it 'should default to :time_select for :time column types' do
-          default_input_type(:time).should == :time_select
+          expect(default_input_type(:time)).to eq(:time_select)
         end
 
         it 'should default to :boolean for :boolean column types' do
-          default_input_type(:boolean).should == :boolean
+          expect(default_input_type(:boolean)).to eq(:boolean)
         end
 
         it 'should default to :string for :string column types' do
-          default_input_type(:string).should == :string
+          expect(default_input_type(:string)).to eq(:string)
+        end
+
+        it 'should default to :string for :citext column types' do
+          expect(default_input_type(:citext)).to eq(:string)
+        end
+
+        it 'should default to :string for :inet column types' do
+          expect(default_input_type(:inet)).to eq(:string)
         end
 
         it 'should default to :number for :integer, :float and :decimal column types' do
-          default_input_type(:integer).should == :number
-          default_input_type(:float).should == :number
-          default_input_type(:decimal).should == :number
+          expect(default_input_type(:integer)).to eq(:number)
+          expect(default_input_type(:float)).to eq(:number)
+          expect(default_input_type(:decimal)).to eq(:number)
         end
 
         it 'should default to :country for :string columns named country' do
-          default_input_type(:string, :country).should == :country
+          expect(default_input_type(:string, :country)).to eq(:country)
         end
 
         it 'should default to :email for :string columns matching email' do
-          default_input_type(:string, :email).should == :email
-          default_input_type(:string, :customer_email).should == :email
-          default_input_type(:string, :email_work).should == :email
+          expect(default_input_type(:string, :email)).to eq(:email)
+          expect(default_input_type(:string, :customer_email)).to eq(:email)
+          expect(default_input_type(:string, :email_work)).to eq(:email)
         end
 
         it 'should default to :url for :string columns named url or website' do
-          default_input_type(:string, :url).should == :url
-          default_input_type(:string, :website).should == :url
-          default_input_type(:string, :my_url).should == :url
-          default_input_type(:string, :hurl).should_not == :url
+          expect(default_input_type(:string, :url)).to eq(:url)
+          expect(default_input_type(:string, :website)).to eq(:url)
+          expect(default_input_type(:string, :my_url)).to eq(:url)
+          expect(default_input_type(:string, :hurl)).not_to eq(:url)
         end
 
         it 'should default to :phone for :string columns named phone or fax' do
-          default_input_type(:string, :phone).should == :phone
-          default_input_type(:string, :fax).should == :phone
+          expect(default_input_type(:string, :phone)).to eq(:phone)
+          expect(default_input_type(:string, :fax)).to eq(:phone)
         end
 
         it 'should default to :search for :string columns named search' do
-          default_input_type(:string, :search).should == :search
+          expect(default_input_type(:string, :search)).to eq(:search)
         end
 
         it 'should default to :color for :string columns matching color' do
-          default_input_type(:string, :color).should == :color
-          default_input_type(:string, :user_color).should == :color
-          default_input_type(:string, :color_for_image).should == :color
+          expect(default_input_type(:string, :color)).to eq(:color)
+          expect(default_input_type(:string, :user_color)).to eq(:color)
+          expect(default_input_type(:string, :color_for_image)).to eq(:color)
         end
 
         describe 'defaulting to file column' do
@@ -483,13 +559,13 @@ describe 'Formtastic::FormBuilder#input' do
 
               Formtastic::FormBuilder.file_methods.each do |test|
                 ### TODO: Check if this is ok
-                column.stub(method).with(test).and_return(method == test)
+                allow(column).to receive(method).with(test).and_return(method == test)
               end
 
-              @new_post.should_receive(method).and_return(column)
+              expect(@new_post).to receive(method).and_return(column)
 
               semantic_form_for(@new_post) do |builder|
-                builder.send(:default_input_type, method).should == :file
+                expect(builder.send(:default_input_type, method)).to eq(:file)
               end
             end
           end
@@ -499,15 +575,15 @@ describe 'Formtastic::FormBuilder#input' do
 
       it 'should call the corresponding input class with .to_html' do
         [:select, :time_zone, :radio, :date_select, :datetime_select, :time_select, :boolean, :check_boxes, :hidden, :string, :password, :number, :text, :file].each do |input_style|
-          @new_post.stub(:generic_column_name)
-          @new_post.stub(:column_for_attribute).and_return(double('column', :type => :string, :limit => 255))
+          allow(@new_post).to receive(:generic_column_name)
+          allow(@new_post).to receive(:column_for_attribute).and_return(double('column', :type => :string, :limit => 255))
           semantic_form_for(@new_post) do |builder|
             input_instance = double('Input instance')
             input_class = "#{input_style.to_s}_input".classify
             input_constant = "Formtastic::Inputs::#{input_class}".constantize
 
-            input_constant.should_receive(:new).and_return(input_instance)
-            input_instance.should_receive(:to_html).and_return("some HTML")
+            expect(input_constant).to receive(:new).and_return(input_instance)
+            expect(input_instance).to receive(:to_html).and_return("some HTML")
 
             concat(builder.input(:generic_column_name, :as => input_style))
           end
@@ -523,21 +599,21 @@ describe 'Formtastic::FormBuilder#input' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.input(:title, :label => "Kustom"))
           end)
-          output_buffer.should have_tag("form li label", /Kustom/)
+          expect(output_buffer.to_str).to have_tag("form li label", :text => /Kustom/)
         end
 
         it 'should not generate a label if false' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.input(:title, :label => false))
           end)
-          output_buffer.should_not have_tag("form li label")
+          expect(output_buffer.to_str).not_to have_tag("form li label")
         end
 
         it 'should be dupped if frozen' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.input(:title, :label => "Kustom".freeze))
           end)
-          output_buffer.should have_tag("form li label", /Kustom/)
+          expect(output_buffer.to_str).to have_tag("form li label", :text => /Kustom/)
         end
       end
 
@@ -548,18 +624,18 @@ describe 'Formtastic::FormBuilder#input' do
               it 'should render a label with localized text and not apply the label_str_method' do
                 with_config :label_str_method, :reverse do
                   @localized_label_text = 'Localized title'
-                  @new_post.stub(:meta_description)
+                  allow(@new_post).to receive(:meta_description)
                   ::I18n.backend.store_translations :en,
-                    :formtastic => {
-                      :labels => {
-                        :meta_description => @localized_label_text
-                      }
-                    }
+                                                    :formtastic => {
+                                                        :labels => {
+                                                            :meta_description => @localized_label_text
+                                                        }
+                                                    }
 
                   concat(semantic_form_for(@new_post) do |builder|
                     concat(builder.input(:meta_description))
                   end)
-                  output_buffer.should have_tag('form li label', /Localized title/)
+                  expect(output_buffer.to_str).to have_tag('form li label', :text => /Localized title/)
                 end
               end
             end
@@ -574,32 +650,32 @@ describe 'Formtastic::FormBuilder#input' do
                 concat(semantic_form_for(:project, :url => 'http://test.host') do |builder|
                   concat(builder.input(:meta_description))
                 end)
-                output_buffer.should have_tag("form li label", /#{'meta_description'.humanize}/)
+                expect(output_buffer.to_str).to have_tag("form li label", :text => /#{'meta_description'.humanize}/)
               end
             end
           end
 
           describe 'and object is given' do
             it 'should delegate the label logic to class human attribute name and pass it down to the label tag' do
-              @new_post.stub(:meta_description) # a two word method name
-              @new_post.class.should_receive(:human_attribute_name).with('meta_description').and_return('meta_description'.humanize)
+              allow(@new_post).to receive(:meta_description) # a two word method name
+              expect(@new_post.class).to receive(:human_attribute_name).with('meta_description').and_return('meta_description'.humanize)
 
               concat(semantic_form_for(@new_post) do |builder|
                 concat(builder.input(:meta_description))
               end)
-              output_buffer.should have_tag("form li label", /#{'meta_description'.humanize}/)
+              expect(output_buffer.to_str).to have_tag("form li label", :text => /#{'meta_description'.humanize}/)
             end
           end
 
           describe 'and object is given with label_str_method set to :capitalize' do
             it 'should capitalize method name, passing it down to the label tag' do
               with_config :label_str_method, :capitalize do
-                @new_post.stub(:meta_description)
+                allow(@new_post).to receive(:meta_description)
 
                 concat(semantic_form_for(@new_post) do |builder|
                   concat(builder.input(:meta_description))
                 end)
-                output_buffer.should have_tag("form li label", /#{'meta_description'.capitalize}/)
+                expect(output_buffer.to_str).to have_tag("form li label", :text => /#{'meta_description'.capitalize}/)
               end
             end
           end
@@ -610,16 +686,16 @@ describe 'Formtastic::FormBuilder#input' do
             @localized_label_text = 'Localized title'
             @default_localized_label_text = 'Default localized title'
             ::I18n.backend.store_translations :en,
-              :formtastic => {
-                  :labels => {
-                    :title => @default_localized_label_text,
-                    :published => @default_localized_label_text,
-                    :post => {
-                      :title => @localized_label_text,
-                      :published => @default_localized_label_text
-                     }
-                   }
-                }
+                                              :formtastic => {
+                                                  :labels => {
+                                                      :title => @default_localized_label_text,
+                                                      :published => @default_localized_label_text,
+                                                      :post => {
+                                                          :title => @localized_label_text,
+                                                          :published => @default_localized_label_text
+                                                      }
+                                                  }
+                                              }
           end
 
           it 'should render a label with localized label (I18n)' do
@@ -628,26 +704,26 @@ describe 'Formtastic::FormBuilder#input' do
                 concat(builder.input(:title, :label => true))
                 concat(builder.input(:published, :as => :boolean, :label => true))
               end)
-              output_buffer.should have_tag('form li label', Regexp.new('^' + @localized_label_text))
+              expect(output_buffer.to_str).to have_tag('form li label', :text => Regexp.new('^' + @localized_label_text))
             end
           end
 
           it 'should render a hint paragraph containing an optional localized label (I18n) if first is not set' do
             with_config :i18n_lookups_by_default, false do
               ::I18n.backend.store_translations :en,
-                :formtastic => {
-                    :labels => {
-                      :post => {
-                        :title => nil,
-                        :published => nil
-                       }
-                     }
-                  }
+                                                :formtastic => {
+                                                    :labels => {
+                                                        :post => {
+                                                            :title => nil,
+                                                            :published => nil
+                                                        }
+                                                    }
+                                                }
               concat(semantic_form_for(@new_post) do |builder|
                 concat(builder.input(:title, :label => true))
                 concat(builder.input(:published, :as => :boolean, :label => true))
               end)
-              output_buffer.should have_tag('form li label', Regexp.new('^' + @default_localized_label_text))
+              expect(output_buffer.to_str).to have_tag('form li label', :text => Regexp.new('^' + @default_localized_label_text))
             end
           end
         end
@@ -668,7 +744,7 @@ describe 'Formtastic::FormBuilder#input' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.input(:title, :hint => hint_text))
           end)
-          output_buffer.should have_tag("form li p.inline-hints", hint_text)
+          expect(output_buffer.to_str).to have_tag("form li p.inline-hints", :text => hint_text)
         end
 
         it 'should have a custom hint class defaulted for all forms' do
@@ -677,7 +753,7 @@ describe 'Formtastic::FormBuilder#input' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.input(:title, :hint => hint_text))
           end)
-          output_buffer.should have_tag("form li p.custom-hint-class", hint_text)
+          expect(output_buffer.to_str).to have_tag("form li p.custom-hint-class", :text => hint_text)
         end
       end
 
@@ -687,11 +763,11 @@ describe 'Formtastic::FormBuilder#input' do
             @localized_hint_text = "This is the localized hint."
             @default_localized_hint_text = "This is the default localized hint."
             ::I18n.backend.store_translations :en,
-              :formtastic => {
-                  :hints => {
-                    :title => @default_localized_hint_text,
-                   }
-                }
+                                              :formtastic => {
+                                                  :hints => {
+                                                      :title => @default_localized_hint_text,
+                                                  }
+                                              }
           end
 
           after do
@@ -702,17 +778,17 @@ describe 'Formtastic::FormBuilder#input' do
             it 'should render a hint paragraph containing a localized hint (I18n)' do
               with_config :i18n_lookups_by_default, false do
                 ::I18n.backend.store_translations :en,
-                :formtastic => {
-                    :hints => {
-                      :post => {
-                        :title => @localized_hint_text
-                       }
-                     }
-                  }
+                                                  :formtastic => {
+                                                      :hints => {
+                                                          :post => {
+                                                              :title => @localized_hint_text
+                                                          }
+                                                      }
+                                                  }
                 concat(semantic_form_for(@new_post) do |builder|
                   concat(builder.input(:title, :hint => true))
                 end)
-                output_buffer.should have_tag('form li p.inline-hints', @localized_hint_text)
+                expect(output_buffer.to_str).to have_tag('form li p.inline-hints', :text => @localized_hint_text)
               end
             end
 
@@ -721,7 +797,7 @@ describe 'Formtastic::FormBuilder#input' do
                 concat(semantic_form_for(@new_post) do |builder|
                   concat(builder.input(:title, :hint => true))
                 end)
-                output_buffer.should have_tag('form li p.inline-hints', @default_localized_hint_text)
+                expect(output_buffer.to_str).to have_tag('form li p.inline-hints', :text => @default_localized_hint_text)
               end
             end
           end
@@ -732,7 +808,7 @@ describe 'Formtastic::FormBuilder#input' do
                 concat(semantic_form_for(@new_post) do |builder|
                   concat(builder.input(:title, :hint => false))
                 end)
-                output_buffer.should_not have_tag('form li p.inline-hints', @localized_hint_text)
+                expect(output_buffer.to_str).not_to have_tag('form li p.inline-hints', :text => @localized_hint_text)
               end
             end
           end
@@ -742,17 +818,17 @@ describe 'Formtastic::FormBuilder#input' do
           it "should see the provided hash as a blank entry" do
             with_config :i18n_lookups_by_default, false do
               ::I18n.backend.store_translations :en,
-              :formtastic => {
-                  :hints => {
-                    :title => { # movie title
-                      :summary => @localized_hint_text # summary of movie
-                     }
-                   }
-                }
+                                                :formtastic => {
+                                                    :hints => {
+                                                        :title => { # movie title
+                                                                    :summary => @localized_hint_text # summary of movie
+                                                        }
+                                                    }
+                                                }
               semantic_form_for(@new_post) do |builder|
                 concat(builder.input(:title, :hint => true))
               end
-              output_buffer.should_not have_tag('form li p.inline-hints', @localized_hint_text)
+              expect(output_buffer.to_str).not_to have_tag('form li p.inline-hints', :text => @localized_hint_text)
             end
           end
         end
@@ -763,7 +839,7 @@ describe 'Formtastic::FormBuilder#input' do
               concat(semantic_form_for(@new_post) do |builder|
                 concat(builder.input(:title))
               end)
-              output_buffer.should_not have_tag('form li p.inline-hints')
+              expect(output_buffer.to_str).not_to have_tag('form li p.inline-hints')
             end
           end
         end
@@ -778,25 +854,25 @@ describe 'Formtastic::FormBuilder#input' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.input(:title, :wrapper_html => {:id => :another_id}))
           end)
-          output_buffer.should have_tag("form li#another_id")
+          expect(output_buffer.to_str).to have_tag("form li#another_id")
         end
 
         it 'should append given classes to li default classes' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.input(:title, :wrapper_html => {:class => :another_class}, :required => true))
           end)
-          output_buffer.should have_tag("form li.string")
-          output_buffer.should have_tag("form li.required")
-          output_buffer.should have_tag("form li.another_class")
+          expect(output_buffer.to_str).to have_tag("form li.string")
+          expect(output_buffer.to_str).to have_tag("form li.required")
+          expect(output_buffer.to_str).to have_tag("form li.another_class")
         end
 
         it 'should allow classes to be an array' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.input(:title, :wrapper_html => {:class => [ :my_class, :another_class ]}))
           end)
-          output_buffer.should have_tag("form li.string")
-          output_buffer.should have_tag("form li.my_class")
-          output_buffer.should have_tag("form li.another_class")
+          expect(output_buffer.to_str).to have_tag("form li.string")
+          expect(output_buffer.to_str).to have_tag("form li.my_class")
+          expect(output_buffer.to_str).to have_tag("form li.another_class")
         end
 
         describe 'when nil' do
@@ -804,7 +880,7 @@ describe 'Formtastic::FormBuilder#input' do
             concat(semantic_form_for(@new_post) do |builder|
               concat(builder.input(:title, :wrapper_html => {:id => nil}))
             end)
-            output_buffer.should have_tag('form li:not([id])')
+            expect(output_buffer.to_str).to have_tag('form li:not([id])')
           end
         end
       end
@@ -814,8 +890,8 @@ describe 'Formtastic::FormBuilder#input' do
           concat(semantic_form_for(@new_post) do |builder|
             concat(builder.input(:title))
           end)
-          output_buffer.should have_tag("form li#post_title_input")
-          output_buffer.should have_tag("form li.string")
+          expect(output_buffer.to_str).to have_tag("form li#post_title_input")
+          expect(output_buffer.to_str).to have_tag("form li.string")
         end
       end
 
@@ -824,15 +900,15 @@ describe 'Formtastic::FormBuilder#input' do
     describe ':collection option' do
 
       it "should be required on polymorphic associations" do
-        @new_post.stub(:commentable)
-        @new_post.class.stub(:reflections).and_return({
-          :commentable => double('macro_reflection', :options => { :polymorphic => true }, :macro => :belongs_to)
-        })
-        @new_post.stub(:column_for_attribute).with(:commentable).and_return(
-          double('column', :type => :integer)
+        allow(@new_post).to receive(:commentable)
+        allow(@new_post.class).to receive(:reflections).and_return({
+                                                          :commentable => double('macro_reflection', :options => { :polymorphic => true }, :macro => :belongs_to)
+                                                      })
+        allow(@new_post).to receive(:column_for_attribute).with(:commentable).and_return(
+            double('column', :type => :integer)
         )
-        @new_post.class.stub(:reflect_on_association).with(:commentable).and_return(
-          double('reflection', :macro => :belongs_to, :options => { :polymorphic => true })
+        allow(@new_post.class).to receive(:reflect_on_association).with(:commentable).and_return(
+            double('reflection', :macro => :belongs_to, :options => { :polymorphic => true })
         )
         expect {
           concat(semantic_form_for(@new_post) do |builder|
@@ -857,21 +933,18 @@ describe 'Formtastic::FormBuilder#input' do
         concat(builder.input(:title, my_options))
         concat(builder.input(:publish_at, my_options))
       end)
-      output_buffer.should have_tag 'li.string', :count => 2
+      expect(output_buffer.to_str).to have_tag 'li.string', :count => 2
     end
-
-
   end
 
   describe 'instantiating an input class' do
-
     context 'when a class does not exist' do
       it "should raise an error" do
-        lambda {
+        expect {
           concat(semantic_form_for(@new_post) do |builder|
             builder.input(:title, :as => :non_existant)
           end)
-        }.should raise_error(Formtastic::UnknownInputError)
+        }.to raise_error(Formtastic::UnknownInputError)
       end
     end
 
@@ -879,7 +952,7 @@ describe 'Formtastic::FormBuilder#input' do
 
       it 'should instantiate the Formtastic input' do
         input = double('input', :to_html => 'some HTML')
-        Formtastic::Inputs::StringInput.should_receive(:new).and_return(input)
+        expect(Formtastic::Inputs::StringInput).to receive(:new).and_return(input)
         concat(semantic_form_for(@new_post) do |builder|
           builder.input(:title, :as => :string)
         end)
@@ -893,8 +966,8 @@ describe 'Formtastic::FormBuilder#input' do
         end
 
         input = double('input', :to_html => 'some HTML')
-        Formtastic::Inputs::StringInput.should_not_receive(:new)
-        ::StringInput.should_receive(:new).and_return(input)
+        expect(Formtastic::Inputs::StringInput).not_to receive(:new)
+        expect(::StringInput).to receive(:new).and_return(input)
 
         concat(semantic_form_for(@new_post) do |builder|
           builder.input(:title, :as => :string)
@@ -902,20 +975,6 @@ describe 'Formtastic::FormBuilder#input' do
       end
     end
 
-    describe 'when instantiated multiple times with the same input type' do
-
-      it "should be cached (not calling the internal methods)" do
-        # TODO this is really tied to the underlying implementation
-        concat(semantic_form_for(@new_post) do |builder|
-          builder.should_receive(:custom_input_class_name).with(:string).once.and_return(::Formtastic::Inputs::StringInput)
-          builder.input(:title, :as => :string)
-          builder.input(:title, :as => :string)
-        end)
-      end
-
-    end
 
   end
-
 end
-