darkhelmet-sinatra_more 0.3.33

data/test/helper.rb

@@ -0,0 +1,73 @@
+require 'rubygems'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'rack/test'
+require 'webrat'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+require 'active_support_helpers'
+require 'sinatra_more'
+
+class Test::Unit::TestCase
+  include Sinatra::MarkupPlugin::OutputHelpers
+  include Sinatra::MarkupPlugin::TagHelpers
+  include Sinatra::MarkupPlugin::AssetTagHelpers
+  include Rack::Test::Methods
+  include Webrat::Methods
+  include Webrat::Matchers
+
+  Webrat.configure do |config|
+    config.mode = :rack
+  end
+
+  def stop_time_for_test
+    time = Time.now
+    Time.stubs(:now).returns(time)
+    return time
+  end
+
+  # assert_has_tag(:h1, :content => "yellow") { "<h1>yellow</h1>" }
+  # In this case, block is the html to evaluate
+  def assert_has_tag(name, attributes = {}, &block)
+    html = block && block.call
+    matcher = HaveSelector.new(name, attributes)
+    raise "Please specify a block!" if html.blank?
+    assert matcher.matches?(html), matcher.failure_message
+  end
+
+  # assert_has_no_tag, tag(:h1, :content => "yellow") { "<h1>green</h1>" }
+  # In this case, block is the html to evaluate
+  def assert_has_no_tag(name, attributes = {}, &block)
+    html = block && block.call
+    attributes.merge!(:count => 0)
+    matcher = HaveSelector.new(name, attributes)
+    raise "Please specify a block!" if html.blank?
+    assert matcher.matches?(html), matcher.failure_message
+  end
+
+  # Silences the output by redirecting to stringIO
+  # silence_logger { ...commands... } => "...output..."
+  def silence_logger(&block)
+    orig_stdout = $stdout
+    $stdout = log_buffer = StringIO.new
+    block.call
+    $stdout = orig_stdout
+    log_buffer.rewind && log_buffer.read
+  end
+
+  # Asserts that a file matches the pattern
+  def assert_match_in_file(pattern, file)
+    assert File.exist?(file), "File '#{file}' does not exist!"
+    assert_match pattern, File.read(file)
+  end
+end
+
+module Webrat
+  module Logging
+    def logger # :nodoc:
+      @logger = nil
+    end
+  end
+end

data/test/mailer_plugin/test_mail_object.rb

@@ -0,0 +1,24 @@
+require 'helper'
+require 'sinatra_more'
+
+class TestMailObject < Test::Unit::TestCase
+  context 'for #deliver method' do
+    should "send mail with attributes default to sendmail no smtp" do
+      mail_object = Sinatra::MailerPlugin::MailObject.new({:to => "test@john.com", :from => "sender@sent.com", :body => "Hello"}, {})
+      Pony.expects(:mail).with(:to => "test@john.com", :from => "sender@sent.com", :body => "Hello", :via => :sendmail)
+      mail_object.deliver
+    end
+
+    should "send mail with attributes default to smtp if set" do
+      mail_object = Sinatra::MailerPlugin::MailObject.new({:to => "test@john.com", :body => "Hello"}, { :host => 'smtp.gmail.com' })
+      Pony.expects(:mail).with(:to => "test@john.com", :body => "Hello", :via => :smtp, :smtp => { :host => 'smtp.gmail.com' })
+      mail_object.deliver
+    end
+
+    should "send mail with attributes use sendmail if explicit" do
+      mail_object = Sinatra::MailerPlugin::MailObject.new({:to => "test@john.com", :via => :sendmail }, { :host => 'smtp.gmail.com' })
+      Pony.expects(:mail).with(:to => "test@john.com", :via => :sendmail)
+      mail_object.deliver
+    end
+  end
+end

data/test/mailer_plugin/test_mailer_base.rb

@@ -0,0 +1,81 @@
+require 'helper'
+require 'sinatra_more'
+
+class DemoMailer < Sinatra::MailerPlugin::MailerBase
+  def sample_mail
+    from 'test@default.com'
+    to 'test@test.com'
+    body "Hello world!"
+    via :sendmail
+  end
+
+  def sample_mail_smtp
+   from 'test@default.com'
+    to 'test@test.com'
+    body "SMTP Hello world!"
+  end
+end
+
+class TestMailerBase < Test::Unit::TestCase
+  context 'for defining email attributes' do
+    DemoMailer.mail_fields.each do |field|
+      should "support setting '#{field}' attribute" do
+        demo_mailer = DemoMailer.new(:sample_mail)
+        demo_mailer.send(field, "some_value")
+        assert_equal({ field => "some_value" }, demo_mailer.mail_attributes)
+      end
+    end
+
+    should "allow defining text body" do
+      demo_mailer = DemoMailer.new(:sample_mail)
+      demo_mailer.body("Hello world!")
+      assert_equal({ :body => "Hello world!" }, demo_mailer.mail_attributes)
+    end
+  end
+
+  context 'for retrieving template path' do
+    should "return correct path" do
+      demo_mailer = DemoMailer.new(:sample_mail)
+      assert_match %r{demo_mailer/sample_mail.erb}, demo_mailer.template_path
+    end
+  end
+
+  context 'for #deliver class method' do
+    should "perform the email delivery for sendmail" do
+      Pony.expects(:mail).with(:from => 'test@default.com', :to => 'test@test.com', :body => "Hello world!", :via => :sendmail)
+      DemoMailer.deliver(:sample_mail)
+    end
+
+   should "perform the email delivery for smtp" do
+      DemoMailer.smtp_settings = { :host => 'smtp.arcadic.com' }
+      Pony.expects(:mail).with(:from => 'test@default.com', :to => 'test@test.com',
+                               :body => "SMTP Hello world!", :via => :smtp, :smtp => { :host => 'smtp.arcadic.com' })
+      DemoMailer.deliver(:sample_mail_smtp)
+    end
+  end
+
+  context 'for #respond_to? class method' do
+    should "respond as true for any delivery method calls for mails that exist" do
+      assert DemoMailer.respond_to?(:deliver_sample_mail)
+    end
+
+    should "respond as false for any delivery method calls for mails that don't exist" do
+      assert_equal false, DemoMailer.respond_to?(:deliver_faker_mail)
+    end
+
+    should "respond as true for any non-delivery methods that exist" do
+      assert DemoMailer.respond_to?(:inspect)
+    end
+
+    should "respond as false for any non-delivery methods that don't exist" do
+      assert_equal false, DemoMailer.respond_to?(:fake_method)
+    end
+  end
+
+  context 'for #method_missing dynamic delivery' do
+    should 'invoke deliver method with appropriate parameters' do
+      DemoMailer.expects(:deliver).with("example_name", "test", 5)
+      DemoMailer.deliver_example_name("test", 5)
+    end
+  end
+end

data/test/markup_plugin/test_asset_tag_helpers.rb

@@ -0,0 +1,171 @@
+require 'helper'
+require 'fixtures/markup_app/app'
+
+class TestAssetTagHelpers < Test::Unit::TestCase
+  include Sinatra::MarkupPlugin::AssetTagHelpers
+
+  def app
+    MarkupDemo.tap { |app| app.set :environment, :test }
+  end
+
+  def flash
+    { :notice => "Demo notice" }
+  end
+
+  context 'for #flash_tag method' do
+    should "display flash with no given attributes" do
+      assert_has_tag('div.flash', :content => "Demo notice") { flash_tag(:notice) }
+    end
+    should "display flash with given attributes" do
+      actual_html = flash_tag(:notice, :class => 'notice', :id => 'notice-area')
+      assert_has_tag('div.notice#notice-area', :content => "Demo notice") { actual_html }
+    end
+  end
+
+  context 'for #link_to method' do
+    should "display link element with no given attributes" do
+      assert_has_tag('a', :content => "Sign up", :href => '/register') { link_to('Sign up', '/register') }
+    end
+    should "display link element with given attributes" do
+      actual_html = link_to('Sign up', '/register', :class => 'first', :id => 'linky')
+      assert_has_tag('a#linky.first', :content => "Sign up", :href => '/register') { actual_html }
+    end
+    should "display link element with ruby block" do
+      actual_link = link_to('/register', :class => 'first', :id => 'binky') { "Sign up" }
+      assert_has_tag('a#binky.first', :content => "Sign up", :href => '/register') { actual_link }
+    end
+    should "display link block element in haml" do
+      visit '/haml/link_to'
+      assert_have_selector :a, :content => "Test 1 No Block", :href => '/test1', :class => 'test', :id => 'test1'
+      assert_have_selector :a, :content => "Test 2 With Block", :href => '/test2', :class => 'test', :id => 'test2'
+    end
+    should "display link block element in erb" do
+      visit '/erb/link_to'
+      assert_have_selector :a, :content => "Test 1 No Block", :href => '/test1', :class => 'test', :id => 'test1'
+      assert_have_selector :a, :content => "Test 2 With Block", :href => '/test2', :class => 'test', :id => 'test2'
+    end
+  end
+
+  context 'for #mail_to method' do
+    should "display link element for mail to no caption" do
+      actual_html = mail_to('test@demo.com')
+      assert_has_tag(:a, :href => "mailto:test@demo.com", :content => 'test@demo.com') { actual_html }
+    end
+
+    should "display link element for mail to with caption" do
+      actual_html = mail_to('test@demo.com', "My Email", :class => 'demo')
+      assert_has_tag(:a, :href => "mailto:test@demo.com", :content => 'My Email', :class => 'demo') { actual_html }
+    end
+
+    should "display link element for mail to with caption and mail options" do
+      actual_html = mail_to('test@demo.com', "My Email", :subject => 'demo test', :class => 'demo', :cc => 'foo@test.com')
+      assert_has_tag(:a, :class => 'demo') { actual_html }
+      assert_match /mailto\:test\@demo.com\?/, actual_html
+      assert_match /cc=foo\@test\.com/, actual_html
+      assert_match /subject\=demo\%20test/, actual_html
+    end
+
+    should "display mail link element in haml" do
+      visit '/haml/mail_to'
+      assert_have_selector 'p.simple a', :href => 'mailto:test@demo.com', :content => 'test@demo.com'
+      assert_have_selector 'p.captioned a', :href => 'mailto:test@demo.com', :content => 'Click my Email'
+    end
+
+    should "display mail link element in erb" do
+      visit '/erb/mail_to'
+      assert_have_selector 'p.simple a', :href => 'mailto:test@demo.com', :content => 'test@demo.com'
+      assert_have_selector 'p.captioned a', :href => 'mailto:test@demo.com', :content => 'Click my Email'
+    end
+  end
+
+  context 'for #image_tag method' do
+    should "display image tag absolute link with no options" do
+      assert_has_tag('img', :src => "/absolute/pic.gif") { image_tag('/absolute/pic.gif') }
+    end
+    should "display image tag relative link with options" do
+      assert_has_tag('img.photo', :src => "/images/relative/pic.gif") { image_tag('relative/pic.gif', :class => 'photo') }
+    end
+    should "display image tag uri link with options" do
+      assert_has_tag('img.photo', :src => "http://demo.org/pic.gif") { image_tag('http://demo.org/pic.gif', :class => 'photo') }
+    end
+    should "display image tag relative link with incorrect spacing" do
+      assert_has_tag('img.photo', :src => "/images/relative/pic.gif") { image_tag(' relative/ pic.gif  ', :class => 'photo') }
+    end
+  end
+
+  context 'for #stylesheet_link_tag method' do
+    should "display stylesheet link item" do
+      time = stop_time_for_test
+      expected_options = { :media => "screen", :rel => "stylesheet", :type => "text/css" }
+      assert_has_tag('link', expected_options.merge(:href => "/stylesheets/style.css?#{time.to_i}")) { stylesheet_link_tag('style') }
+    end
+    should "display stylesheet link item for long relative path" do
+      time = stop_time_for_test
+      expected_options = { :media => "screen", :rel => "stylesheet", :type => "text/css" }
+      actual_html = stylesheet_link_tag('example/demo/style')
+      assert_has_tag('link', expected_options.merge(:href => "/stylesheets/example/demo/style.css?#{time.to_i}")) { actual_html }
+    end
+    should "display stylesheet link items" do
+      time = stop_time_for_test
+      actual_html = stylesheet_link_tag('style', 'layout.css', 'http://google.com/style.css')
+      assert_has_tag('link', :media => "screen", :rel => "stylesheet", :type => "text/css", :count => 3) { actual_html }
+      assert_has_tag('link', :href => "/stylesheets/style.css?#{time.to_i}") { actual_html }
+      assert_has_tag('link', :href => "/stylesheets/layout.css?#{time.to_i}") { actual_html }
+      assert_has_tag('link', :href => "http://google.com/style.css") { actual_html }
+    end
+  end
+
+  context 'for #javascript_include_tag method' do
+    should "display javascript item" do
+      time = stop_time_for_test
+      actual_html = javascript_include_tag('application')
+      assert_has_tag('script', :src => "/javascripts/application.js?#{time.to_i}", :type => "text/javascript") { actual_html }
+    end
+    should "display javascript item for path containing js" do
+      time = stop_time_for_test
+      actual_html = javascript_include_tag 'test/jquery.json'
+      assert_has_tag('script', :src => "/javascripts/test/jquery.json?#{time.to_i}", :type => "text/javascript") { actual_html }
+    end
+    should "display javascript item for path containing period" do
+      time = stop_time_for_test
+      actual_html = javascript_include_tag 'test/jquery.min'
+      assert_has_tag('script', :src => "/javascripts/test/jquery.min.js?#{time.to_i}", :type => "text/javascript") { actual_html }
+    end
+    should "display javascript item for long relative path" do
+      time = stop_time_for_test
+      actual_html = javascript_include_tag('example/demo/application')
+      assert_has_tag('script', :src => "/javascripts/example/demo/application.js?#{time.to_i}", :type => "text/javascript") { actual_html }
+    end
+    should "display javascript items" do
+      time = stop_time_for_test
+      actual_html = javascript_include_tag('application', 'base.js', 'http://google.com/lib.js')
+      assert_has_tag('script', :type => "text/javascript", :count => 3) { actual_html }
+      assert_has_tag('script', :src => "/javascripts/application.js?#{time.to_i}") { actual_html }
+      assert_has_tag('script', :src => "/javascripts/base.js?#{time.to_i}") { actual_html }
+      assert_has_tag('script', :src => "http://google.com/lib.js") { actual_html }
+    end
+  end
+
+  context 'for #meta_tag method' do
+    should "display meta tag with given content and name" do
+      actual_html = meta_tag("weblog,news", :name => "keywords")
+      assert_has_tag("meta", :name => "keywords", "content" => "weblog,news") { actual_html }
+    end
+    should "display meta tag with given content and http-equiv" do
+      actual_html = meta_tag("text/html; charset=UTF-8", :"http-equiv" => "Content-Type")
+      assert_has_tag("meta", :"http-equiv" => "Content-Type", "content" => "text/html; charset=UTF-8") { actual_html }
+    end
+    should "display meta tag element in haml" do
+      visit '/haml/meta_tag'
+      assert_have_selector 'meta', "content" => "weblog,news", :name => "keywords"
+      assert_have_selector 'meta', "content" => "text/html; charset=UTF-8", :"http-equiv" => "Content-Type"
+    end
+    should "display meta tag element in erb" do
+      visit '/erb/meta_tag'
+      assert_have_selector 'meta', "content" => "weblog,news", :name => "keywords"
+      assert_have_selector 'meta', "content" => "text/html; charset=UTF-8", :"http-equiv" => "Content-Type"
+    end
+
+  end
+
+end

data/test/markup_plugin/test_form_builder.rb

@@ -0,0 +1,627 @@
+require 'helper'
+require 'fixtures/markup_app/app'
+
+class TestFormBuilder < Test::Unit::TestCase
+  include Sinatra::MarkupPlugin::FormHelpers
+
+  def app
+    MarkupDemo.tap { |app| app.set :environment, :test }
+  end
+
+  def setup
+    error_stub = stub(:full_messages => ["1", "2"], :none? => false)
+    role_types = [stub(:name => 'Admin', :id => 1), stub(:name => 'Moderate', :id => 2),  stub(:name => 'Limited', :id => 3)]
+    @user = stub(:errors => error_stub, :class => 'User', :first_name => "Joe", :session_id => 54)
+    @user.stubs(:role_types => role_types, :role => "1")
+    @user_none = stub(:errors => stub(:none? => true), :class => 'User')
+  end
+
+  def standard_builder(object=@user)
+    StandardFormBuilder.new(self, object)
+  end
+
+  context 'for #form_for method' do
+    should "display correct form html" do
+      actual_html = form_for(@user, '/register', :id => 'register', :method => 'post') { "Demo" }
+      assert_has_tag('form', :action => '/register', :id => 'register', :method => 'post', :content => "Demo") { actual_html }
+      assert_has_tag('form input[type=hidden]', :name => '_method', :count => 0) { actual_html } # no method action field
+    end
+
+    should "display correct form html with fake object" do
+      actual_html = form_for(:markup_user, '/register', :id => 'register', :method => 'post') { |f| f.text_field :username }
+      assert_has_tag('form', :action => '/register', :id => 'register', :method => 'post') { actual_html }
+      assert_has_tag('form input', :type => 'text', :name => 'markup_user[username]') { actual_html }
+      assert_has_tag('form input[type=hidden]', :name => '_method', :count => 0) { actual_html } # no method action field
+    end
+
+    should "display correct form html for namespaced object" do
+      actual_html = form_for(Outer::UserAccount.new, '/register', :method => 'post') { |f| f.text_field :username }
+      assert_has_tag('form', :action => '/register', :method => 'post') { actual_html }
+      assert_has_tag('form input', :type => 'text', :name => 'outer-user_account[username]') { actual_html }
+    end
+
+    should "display correct form html with method :put" do
+      actual_html = form_for(@user, '/update', :method => 'put') { "Demo" }
+      assert_has_tag('form', :action => '/update', :method => 'post') { actual_html }
+      assert_has_tag('form input', :type => 'hidden', :name => "_method", :value => 'put') { actual_html }
+    end
+
+    should "display correct form html with method :delete" do
+      actual_html = form_for(@user, '/destroy', :method => 'delete') { "Demo" }
+      assert_has_tag('form', :action => '/destroy', :method => 'post') { actual_html }
+      assert_has_tag('form input', :type => 'hidden', :name => "_method", :value => 'delete') { actual_html }
+    end
+
+    should "display correct form html with multipart" do
+      actual_html = form_for(@user, '/register', :multipart => true) { "Demo" }
+      assert_has_tag('form', :action => '/register', :enctype => "multipart/form-data") { actual_html }
+    end
+
+    should "support changing form builder type" do
+      form_html = lambda { form_for(@user, '/register', :builder => "AbstractFormBuilder") { |f| f.text_field_block(:name) } }
+      assert_raise(NoMethodError) { form_html.call }
+    end
+
+    should "support using default standard builder" do
+      actual_html = form_for(@user, '/register') { |f| f.text_field_block(:name) }
+      assert_has_tag('form p input[type=text]') { actual_html }
+    end
+
+    should "display fail for form with nil object" do
+      assert_raises(RuntimeError) { form_for(@not_real, '/register', :id => 'register', :method => 'post') { "Demo" } }
+    end
+
+    should "display correct form in haml" do
+      visit '/haml/form_for'
+      assert_have_selector :form, :action => '/demo', :id => 'demo'
+      assert_have_selector :form, :action => '/another_demo', :id => 'demo2', :method => 'get'
+      assert_have_selector :form, :action => '/third_demo', :id => 'demo3', :method => 'get'
+    end
+
+    should "display correct form in erb" do
+      visit '/erb/form_for'
+      assert_have_selector :form, :action => '/demo', :id => 'demo'
+      assert_have_selector :form, :action => '/another_demo', :id => 'demo2', :method => 'get'
+      assert_have_selector :form, :action => '/third_demo', :id => 'demo3', :method => 'get'
+    end
+  end
+
+  context 'for #fields_for method' do
+    should 'display correct fields html' do
+      actual_html = fields_for(@user) { |f| f.text_field(:first_name) }
+      assert_has_tag(:input, :type => 'text', :name => 'user[first_name]', :id => 'user_first_name') { actual_html }
+    end
+
+    should 'display correct fields html with symbol object' do
+      actual_html = fields_for(:markup_user) { |f| f.text_field(:first_name) }
+      assert_has_tag(:input, :type => 'text', :name => 'markup_user[first_name]', :id => 'markup_user_first_name') { actual_html }
+    end
+
+    should "display fail for nil object" do
+      assert_raises(RuntimeError) { fields_for(@not_real) { |f| "Demo" } }
+    end
+
+    should 'display correct simple fields in haml' do
+      visit '/haml/fields_for'
+      assert_have_selector :form, :action => '/demo1', :id => 'demo-fields-for'
+      assert_have_selector '#demo-fields-for input', :type => 'text', :name => 'markup_user[gender]', :value => 'male'
+      assert_have_selector '#demo-fields-for input', :type => 'checkbox', :name => 'permission[can_edit]', :value => '1', :checked => 'checked'
+      assert_have_selector '#demo-fields-for input', :type => 'checkbox', :name => 'permission[can_delete]'
+    end
+
+    should "display correct simple fields in erb" do
+      visit '/erb/fields_for'
+      assert_have_selector :form, :action => '/demo1', :id => 'demo-fields-for'
+      assert_have_selector '#demo-fields-for input', :type => 'text', :name => 'markup_user[gender]', :value => 'male'
+      assert_have_selector '#demo-fields-for input', :type => 'checkbox', :name => 'permission[can_edit]', :value => '1', :checked => 'checked'
+      assert_have_selector '#demo-fields-for input', :type => 'checkbox', :name => 'permission[can_delete]'
+    end
+  end
+
+  # ===========================
+  # AbstractFormBuilder
+  # ===========================
+
+  context 'for #error_messages method' do
+    should "display correct form html with no record" do
+      actual_html = standard_builder(@user_none).error_messages(:header_message => "Demo form cannot be saved")
+      assert actual_html.blank?
+    end
+
+    should "display correct form html with valid record" do
+      actual_html = standard_builder.error_messages(:header_message => "Demo form cannot be saved")
+      assert_has_tag('div.field-errors p', :content => "Demo form cannot be saved") { actual_html }
+      assert_has_tag('div.field-errors ul.errors-list li', :content => "1") { actual_html }
+      assert_has_tag('div.field-errors ul.errors-list li', :content => "2") { actual_html }
+    end
+
+    should "display correct form in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo div.field-errors p', :content => "custom MarkupUser cannot be saved!"
+      assert_have_selector '#demo div.field-errors ul.errors-list li', :content => "This is a fake error"
+      assert_have_selector '#demo2 div.field-errors p', :content => "custom MarkupUser cannot be saved!"
+      assert_have_selector '#demo2 div.field-errors ul.errors-list li', :content => "This is a fake error"
+    end
+
+    should "display correct form in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo div.field-errors p', :content => "custom MarkupUser cannot be saved!"
+      assert_have_selector '#demo div.field-errors ul.errors-list li', :content => "This is a fake error"
+      assert_have_selector '#demo2 div.field-errors p', :content => "custom MarkupUser cannot be saved!"
+      assert_have_selector '#demo2 div.field-errors ul.errors-list li', :content => "This is a fake error"
+    end
+  end
+
+  context 'for #label method' do
+    should "display correct label html" do
+      actual_html = standard_builder.label(:first_name, :class => 'large', :caption => "F. Name: ")
+      assert_has_tag('label', :class => 'large', :for => 'user_first_name', :content => "F. Name: ") { actual_html }
+    end
+
+    should "display correct label in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo label', :content => "Login: ", :class => 'user-label'
+      assert_have_selector '#demo label', :content => "About Me: "
+      assert_have_selector '#demo2 label', :content => "Nickname: ", :class => 'label'
+    end
+
+    should "display correct label in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo label', :content => "Login: ", :class => 'user-label'
+      assert_have_selector '#demo label', :content => "About Me: "
+      assert_have_selector '#demo2 label', :content => "Nickname: ", :class => 'label'
+    end
+  end
+
+  context 'for #hidden_field method' do
+    should "display correct hidden field html" do
+      actual_html = standard_builder.hidden_field(:session_id, :class => 'hidden')
+      assert_has_tag('input.hidden[type=hidden]', :value => "54", :id => 'user_session_id', :name => 'user[session_id]') { actual_html }
+    end
+
+    should "display correct hidden field in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo input[type=hidden]', :id => 'markup_user_session_id', :value => "45"
+      assert_have_selector '#demo2 input', :type => 'hidden', :name => 'markup_user[session_id]'
+    end
+
+    should "display correct hidden field in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo input[type=hidden]', :id => 'markup_user_session_id', :value => "45"
+      assert_have_selector '#demo2 input', :type => 'hidden', :name => 'markup_user[session_id]'
+    end
+  end
+
+  context 'for #text_field method' do
+    should "display correct text field html" do
+      actual_html = standard_builder.text_field(:first_name, :class => 'large')
+      assert_has_tag('input.large[type=text]', :value => "Joe", :id => 'user_first_name', :name => 'user[first_name]') { actual_html }
+    end
+
+    should "display correct text field in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo input.user-text[type=text]', :id => 'markup_user_username', :value => "John"
+      assert_have_selector '#demo2 input', :type => 'text', :class => 'input', :name => 'markup_user[username]'
+    end
+
+    should "display correct text field in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo input.user-text[type=text]', :id => 'markup_user_username', :value => "John"
+      assert_have_selector '#demo2 input', :type => 'text', :class => 'input', :name => 'markup_user[username]'
+    end
+  end
+
+  context 'for #check_box method' do
+    should "display correct checkbox html" do
+      actual_html = standard_builder.check_box(:confirm_destroy, :class => 'large')
+      assert_has_tag('input.large[type=checkbox]', :id => 'user_confirm_destroy', :name => 'user[confirm_destroy]') { actual_html }
+      assert_has_tag('input[type=hidden]', :name => 'user[confirm_destroy]', :value => '0') { actual_html }
+    end
+
+    should "display correct checkbox html when checked" do
+      actual_html = standard_builder.check_box(:confirm_destroy, :checked => true)
+      assert_has_tag('input[type=checkbox]', :checked => 'checked', :name => 'user[confirm_destroy]') { actual_html }
+    end
+
+    should "display correct checkbox html as checked when object value matches" do
+      @user.stubs(:show_favorites => 'human')
+      actual_html = standard_builder.check_box(:show_favorites, :value => 'human')
+      assert_has_tag('input[type=checkbox]', :checked => 'checked', :name => 'user[show_favorites]') { actual_html }
+    end
+
+    should "display correct checkbox html as checked when object value is true" do
+      @user.stubs(:show_favorites => true)
+      actual_html = standard_builder.check_box(:show_favorites, :value => '1')
+      assert_has_tag('input[type=checkbox]', :checked => 'checked', :name => 'user[show_favorites]') { actual_html }
+    end
+
+    should "display correct checkbox html as unchecked when object value doesn't match" do
+      @user.stubs(:show_favorites => 'alien')
+      actual_html = standard_builder.check_box(:show_favorites, :value => 'human')
+      assert_has_no_tag('input[type=checkbox]', :checked => 'checked') { actual_html }
+    end
+
+    should "display correct checkbox html as unchecked when object value is false" do
+      @user.stubs(:show_favorites => false)
+      actual_html = standard_builder.check_box(:show_favorites, :value => '1')
+      assert_has_no_tag('input[type=checkbox]', :checked => 'checked') { actual_html }
+    end
+
+    should "display correct unchecked hidden field when specified" do
+      actual_html = standard_builder.check_box(:show_favorites, :value => 'female', :uncheck_value => 'false')
+      assert_has_tag('input[type=hidden]', :name => 'user[show_favorites]', :value => 'false') { actual_html }
+    end
+
+    should "display correct checkbox in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo input[type=checkbox]', :checked => 'checked', :id => 'markup_user_remember_me', :name => 'markup_user[remember_me]'
+    end
+
+    should "display correct checkbox in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo input[type=checkbox]', :checked => 'checked', :id => 'markup_user_remember_me', :name => 'markup_user[remember_me]'
+    end
+  end
+
+  context 'for #radio_button method' do
+    should "display correct radio button html" do
+      actual_html = standard_builder.radio_button(:gender, :value => 'male', :class => 'large')
+      assert_has_tag('input.large[type=radio]', :id => 'user_gender_male', :name => 'user[gender]', :value => 'male') { actual_html }
+    end
+
+    should "display correct radio button html when checked" do
+      actual_html = standard_builder.radio_button(:gender, :checked => true)
+      assert_has_tag('input[type=radio]', :checked => 'checked', :name => 'user[gender]') { actual_html }
+    end
+
+    should "display correct radio button html as checked when object value matches" do
+      @user.stubs(:gender => 'male')
+      actual_html = standard_builder.radio_button(:gender, :value => 'male')
+      assert_has_tag('input[type=radio]', :checked => 'checked', :name => 'user[gender]') { actual_html }
+    end
+
+    should "display correct radio button html as unchecked when object value doesn't match" do
+      @user.stubs(:gender => 'male')
+      actual_html = standard_builder.radio_button(:gender, :value => 'female')
+      assert_has_no_tag('input[type=radio]', :checked => 'checked') { actual_html }
+    end
+
+    should "display correct radio button in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo input[type=radio]', :id => 'markup_user_gender_male', :name => 'markup_user[gender]', :value => 'male'
+      assert_have_selector '#demo input[type=radio]', :id => 'markup_user_gender_female', :name => 'markup_user[gender]', :value => 'female'
+      assert_have_selector '#demo input[type=radio][checked=checked]', :id => 'markup_user_gender_male'
+    end
+
+    should "display correct radio button in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo input[type=radio]', :id => 'markup_user_gender_male', :name => 'markup_user[gender]', :value => 'male'
+      assert_have_selector '#demo input[type=radio]', :id => 'markup_user_gender_female', :name => 'markup_user[gender]', :value => 'female'
+      assert_have_selector '#demo input[type=radio][checked=checked]', :id => 'markup_user_gender_male'
+    end
+  end
+
+  context 'for #text_area method' do
+    should "display correct text_area html" do
+      actual_html = standard_builder.text_area(:about, :class => 'large')
+      assert_has_tag('textarea.large', :id => 'user_about', :name => 'user[about]') { actual_html }
+    end
+
+    should "display correct text_area html and custom content" do
+      actual_html = standard_builder.text_area(:about, :value => "Demo")
+      assert_has_tag('textarea', :id => 'user_about', :content => 'Demo') { actual_html }
+    end
+
+    should "display correct text_area html and default content" do
+      actual_html = standard_builder(MarkupUser.new).text_area(:about)
+      assert_has_tag('textarea', :id => 'markup_user_about', :content => '') { actual_html }
+    end
+
+    should "display correct text_area in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'user-about'
+      assert_have_selector '#demo2 textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'textarea'
+    end
+
+    should "display correct text_area in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'user-about'
+      assert_have_selector '#demo2 textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'textarea'
+    end
+  end
+
+  context 'for #password_field method' do
+    should "display correct password_field html" do
+      actual_html = standard_builder.password_field(:code, :class => 'large')
+      assert_has_tag('input.large[type=password]', :id => 'user_code', :name => 'user[code]') { actual_html }
+    end
+
+    should "display correct password_field in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo input', :type => 'password', :class => 'user-password', :value => 'secret'
+      assert_have_selector '#demo2 input', :type => 'password', :class => 'input', :name => 'markup_user[code]'
+    end
+
+    should "display correct password_field in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo input', :type => 'password', :class => 'user-password', :value => 'secret'
+      assert_have_selector '#demo2 input', :type => 'password', :class => 'input', :name => 'markup_user[code]'
+    end
+  end
+
+  context 'for #file_field method' do
+    should "display correct file_field html" do
+      actual_html = standard_builder.file_field(:photo, :class => 'large')
+      assert_has_tag('input.large[type=file]', :id => 'user_photo', :name => 'user[photo]') { actual_html }
+    end
+
+    should "display correct file_field in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo  input.user-photo', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
+      assert_have_selector '#demo2 input.upload', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
+    end
+
+    should "display correct file_field in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo  input.user-photo', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
+      assert_have_selector '#demo2 input.upload', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
+    end
+  end
+
+  context 'for #select method' do
+    should "display correct select html" do
+      actual_html = standard_builder.select(:state, :options => ['California', 'Texas', 'Wyoming'], :class => 'selecty')
+      assert_has_tag('select.selecty', :id => 'user_state', :name => 'user[state]') { actual_html }
+      assert_has_tag('select.selecty option', :count => 3) { actual_html }
+      assert_has_tag('select.selecty option', :value => 'California', :content => 'California') { actual_html }
+      assert_has_tag('select.selecty option', :value => 'Texas',      :content => 'Texas')      { actual_html }
+      assert_has_tag('select.selecty option', :value => 'Wyoming',    :content => 'Wyoming')    { actual_html }
+    end
+
+    should "display correct select html with selected item if it matches value" do
+      @user.stubs(:state => 'California')
+      actual_html = standard_builder.select(:state, :options => ['California', 'Texas', 'Wyoming'])
+      assert_has_tag('select', :id => 'user_state', :name => 'user[state]') { actual_html }
+      assert_has_tag('select option', :selected => 'selected', :count => 1) { actual_html }
+      assert_has_tag('select option', :value => 'California', :selected => 'selected') { actual_html }
+    end
+
+    should "display correct select html with include_blank" do
+      actual_html = standard_builder.select(:state, :options => ['California', 'Texas', 'Wyoming'], :include_blank => true)
+      assert_has_tag('select', :id => 'user_state', :name => 'user[state]') { actual_html }
+      assert_has_tag('select option', :count => 4) { actual_html }
+      assert_has_tag('select option:first-child', :content => '') { actual_html }
+    end
+
+    should "display correct select html with collection passed in" do
+      actual_html = standard_builder.select(:role, :collection => @user.role_types, :fields => [:name, :id])
+      assert_has_tag('select', :id => 'user_role', :name => 'user[role]') { actual_html }
+      assert_has_tag('select option', :count => 3) { actual_html }
+      assert_has_tag('select option', :value => '1', :content => 'Admin', :selected => 'selected')     { actual_html }
+      assert_has_tag('select option', :value => '2', :content => 'Moderate')  { actual_html }
+      assert_has_tag('select option', :value => '3', :content => 'Limited')   { actual_html }
+    end
+
+    should "display correct select in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'user-about'
+      assert_have_selector '#demo2 textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'textarea'
+    end
+
+    should "display correct select in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'user-about'
+      assert_have_selector '#demo2 textarea', :name => 'markup_user[about]', :id => 'markup_user_about', :class => 'textarea'
+    end
+  end
+
+  context 'for #submit method' do
+    should "display correct submit button html with no options" do
+      actual_html = standard_builder.submit
+      assert_has_tag('input[type=submit]', :value => "Submit") { actual_html }
+    end
+
+    should "display correct submit button html" do
+      actual_html = standard_builder.submit("Commit", :class => 'large')
+      assert_has_tag('input.large[type=submit]', :value => "Commit") { actual_html }
+    end
+
+    should "display correct submit button in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo input', :type => 'submit', :id => 'demo-button', :class => 'success'
+      assert_have_selector '#demo2 input', :type => 'submit', :class => 'button', :value => "Create"
+    end
+
+    should "display correct submit button in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo input', :type => 'submit', :id => 'demo-button', :class => 'success'
+      assert_have_selector '#demo2 input', :type => 'submit', :class => 'button', :value => "Create"
+    end
+  end
+
+  context 'for #image_submit method' do
+    should "display correct image submit button html with no options" do
+      actual_html = standard_builder.image_submit('buttons/ok.png')
+      assert_has_tag('input[type=image]', :src => "/images/buttons/ok.png") { actual_html }
+    end
+
+    should "display correct image submit button html" do
+      actual_html = standard_builder.image_submit('/system/ok.png', :class => 'large')
+      assert_has_tag('input.large[type=image]', :src => "/system/ok.png") { actual_html }
+    end
+
+    should "display correct image submit button in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo input', :type => 'image', :id => 'image-button', :src => '/images/buttons/post.png'
+      assert_have_selector '#demo2 input', :type => 'image', :class => 'image', :src => "/images/buttons/ok.png"
+    end
+
+    should "display correct image submit button in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo input', :type => 'image', :id => 'image-button', :src => '/images/buttons/post.png'
+      assert_have_selector '#demo2 input', :type => 'image', :class => 'image', :src => "/images/buttons/ok.png"
+    end
+  end
+
+  # ===========================
+  # StandardFormBuilder
+  # ===========================
+
+  context 'for #text_field_block method' do
+    should "display correct text field block html" do
+      actual_html = standard_builder.text_field_block(:first_name, :class => 'large', :caption => "FName")
+      assert_has_tag('p label', :for => 'user_first_name', :content => "FName") { actual_html }
+      assert_has_tag('p input.large[type=text]', :value => "Joe", :id => 'user_first_name', :name => 'user[first_name]') { actual_html }
+    end
+
+    should "display correct text field block in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo2 p label', :for => 'markup_user_username', :content => "Nickname", :class => 'label'
+      assert_have_selector '#demo2 p input', :type => 'text', :name => 'markup_user[username]', :id => 'markup_user_username'
+    end
+
+    should "display correct text field block in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo2 p label', :for => 'markup_user_username', :content => "Nickname", :class => 'label'
+      assert_have_selector '#demo2 p input', :type => 'text', :name => 'markup_user[username]', :id => 'markup_user_username'
+    end
+  end
+
+  context 'for #text_area_block method' do
+    should "display correct text area block html" do
+      actual_html = standard_builder.text_area_block(:about, :class => 'large', :caption => "About Me")
+      assert_has_tag('p label', :for => 'user_about', :content => "About Me") { actual_html }
+      assert_has_tag('p textarea', :id => 'user_about', :name => 'user[about]') { actual_html }
+    end
+
+    should "display correct text area block in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo2 p label', :for => 'markup_user_about', :content => "About: "
+      assert_have_selector '#demo2 p textarea', :name => 'markup_user[about]', :id => 'markup_user_about'
+    end
+
+    should "display correct text area block in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo2 p label', :for => 'markup_user_about', :content => "About: "
+      assert_have_selector '#demo2 p textarea', :name => 'markup_user[about]', :id => 'markup_user_about'
+    end
+  end
+
+  context 'for #password_field_block method' do
+    should "display correct password field block html" do
+      actual_html = standard_builder.password_field_block(:keycode, :class => 'large', :caption => "Code: ")
+      assert_has_tag('p label', :for => 'user_keycode', :content => "Code: ") { actual_html }
+      assert_has_tag('p input.large[type=password]', :id => 'user_keycode', :name => 'user[keycode]') { actual_html }
+    end
+
+    should "display correct password field block in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo2 p label', :for => 'markup_user_code', :content => "Code: "
+      assert_have_selector '#demo2 p input', :type => 'password', :name => 'markup_user[code]', :id => 'markup_user_code'
+    end
+
+    should "display correct password field block in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo2 p label', :for => 'markup_user_code', :content => "Code: "
+      assert_have_selector '#demo2 p input', :type => 'password', :name => 'markup_user[code]', :id => 'markup_user_code'
+    end
+  end
+
+  context 'for #file_field_block method' do
+    should "display correct file field block html" do
+      actual_html = standard_builder.file_field_block(:photo, :class => 'large', :caption => "Photo: ")
+      assert_has_tag('p label', :for => 'user_photo', :content => "Photo: ") { actual_html }
+      assert_has_tag('p input.large[type=file]', :id => 'user_photo', :name => 'user[photo]') { actual_html }
+    end
+
+    should "display correct file field block in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo2 p label', :for => 'markup_user_photo', :content => "Photo: "
+      assert_have_selector '#demo2 p input.upload', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
+    end
+
+    should "display correct file field block in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo2 p label', :for => 'markup_user_photo', :content => "Photo: "
+      assert_have_selector '#demo2 p input.upload', :type => 'file', :name => 'markup_user[photo]', :id => 'markup_user_photo'
+    end
+  end
+
+  context 'for #check_box_block method' do
+    should "display correct check box block html" do
+      actual_html = standard_builder.check_box_block(:remember_me, :class => 'large', :caption => "Remember session?")
+      assert_has_tag('p label', :for => 'user_remember_me', :content => "Remember session?") { actual_html }
+      assert_has_tag('p input.large[type=checkbox]', :id => 'user_remember_me', :name => 'user[remember_me]') { actual_html }
+    end
+
+    should "display correct check box block in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo2 p label', :for => 'markup_user_remember_me', :content => "Remember Me: "
+      assert_have_selector '#demo2 p input.checker', :type => 'checkbox', :name => 'markup_user[remember_me]'
+    end
+
+    should "display correct check box block in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo2 p label', :for => 'markup_user_remember_me', :content => "Remember Me: "
+      assert_have_selector '#demo2 p input.checker', :type => 'checkbox', :name => 'markup_user[remember_me]'
+    end
+  end
+
+  context 'for #select_block method' do
+    should "display correct select_block block html" do
+      actual_html = standard_builder.select_block(:country, :options => ['USA', 'Canada'], :class => 'large', :caption => "Your country")
+      assert_has_tag('p label', :for => 'user_country', :content => "Your country") { actual_html }
+      assert_has_tag('p select', :id => 'user_country', :name => 'user[country]') { actual_html }
+      assert_has_tag('p select option', :content => 'USA')   { actual_html }
+      assert_has_tag('p select option', :content => 'Canada') { actual_html }
+    end
+
+    should "display correct select_block block in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo2 p label', :for => 'markup_user_state', :content => "State: "
+      assert_have_selector '#demo2 p select', :name => 'markup_user[state]', :id => 'markup_user_state'
+      assert_have_selector '#demo2 p select option',  :content => 'California'
+      assert_have_selector '#demo2 p select option',  :content => 'Texas'
+    end
+
+    should "display correct select_block block in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo2 p label', :for => 'markup_user_state', :content => "State: "
+      assert_have_selector '#demo2 p select', :name => 'markup_user[state]', :id => 'markup_user_state'
+    end
+  end
+
+  context 'for #submit_block method' do
+    should "display correct submit block html" do
+      actual_html = standard_builder.submit_block("Update", :class => 'large')
+      assert_has_tag('p input.large[type=submit]', :value => 'Update') { actual_html }
+    end
+
+    should "display correct submit block in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo2 p input', :type => 'submit', :class => 'button'
+    end
+
+    should "display correct submit block in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo2 p input', :type => 'submit', :class => 'button'
+    end
+  end
+
+  context 'for #image_submit_block method' do
+    should "display correct image submit block html" do
+      actual_html = standard_builder.image_submit_block("buttons/ok.png", :class => 'large')
+      assert_has_tag('p input.large[type=image]', :src => '/images/buttons/ok.png') { actual_html }
+    end
+
+    should "display correct image submit block in haml" do
+      visit '/haml/form_for'
+      assert_have_selector '#demo2 p input', :type => 'image', :class => 'image', :src => '/images/buttons/ok.png'
+    end
+
+    should "display correct image submit block in erb" do
+      visit '/erb/form_for'
+      assert_have_selector '#demo2 p input', :type => 'image', :class => 'image', :src => '/images/buttons/ok.png'
+    end
+  end
+end