Syd-sinatra 0.3.2 → 0.9.0.2

data/test/haml_test.rb

@@ -1,233 +1,68 @@
 require File.dirname(__FILE__) + '/helper'
 
-context "Haml" do
-
-  setup do
-    Sinatra.application = nil
+describe "HAML Templates" do
+  def haml_app(&block)
+    mock_app {
+      set :views, File.dirname(__FILE__) + '/views'
+      get '/', &block
+    }
+    get '/'
   end
 
-  context "without layouts" do
-
-    setup do
-      Sinatra.application = nil
-    end
-
-    specify "should render" do
-
-      get '/no_layout' do
-        haml '== #{1+1}'
-      end
-
-      get_it '/no_layout'
-      should.be.ok
-      body.should == "2\n"
-
-    end
+  it 'renders inline HAML strings' do
+    haml_app { haml '%h1 Hiya' }
+    assert ok?
+    assert_equal "<h1>Hiya</h1>\n", body
   end
 
-  context "with layouts" do
-
-    setup do
-      Sinatra.application = nil
-    end
-
-    specify "can be inline" do
-
-      layout do
-        '== This is #{yield}!'
-      end
-
-      get '/lay' do
-        haml 'Blake'
-      end
-
-      get_it '/lay'
-      should.be.ok
-      body.should.equal "This is Blake\n!\n"
-
-    end
-
-    specify "can use named layouts" do
-
-      layout :pretty do
-        '%h1== #{yield}'
-      end
-
-      get '/pretty' do
-        haml 'Foo', :layout => :pretty
-      end
-
-      get '/not_pretty' do
-        haml 'Bar'
-      end
-
-      get_it '/pretty'
-      body.should.equal "<h1>Foo</h1>\n"
-
-      get_it '/not_pretty'
-      body.should.equal "Bar\n"
-
-    end
-
-    specify "can be read from a file if they're not inlined" do
-
-      get '/foo' do
-        @title = 'Welcome to the Hello Program'
-        haml 'Blake', :layout => :foo_layout,
-                      :views_directory => File.dirname(__FILE__) + "/views"
-      end
-
-      get_it '/foo'
-      body.should.equal "Welcome to the Hello Program\nHi Blake\n"
-
-    end
-
-    specify "can be read from file and layout from text" do
-      get '/foo' do
-        haml 'Test', :layout => '== Foo #{yield}'
-      end
-
-      get_it '/foo'
-
-      body.should.equal "Foo Test\n"
-    end
-
+  it 'renders .haml files in views path' do
+    haml_app { haml :hello }
+    assert ok?
+    assert_equal "<h1>Hello From Haml</h1>\n", body
   end
 
-  context "Templates (in general)" do
-
-    setup do
-      Sinatra.application = nil
-    end
-
-    specify "are read from files if Symbols" do
-
-      get '/from_file' do
-        @name = 'Alena'
-        haml :foo, :views_directory => File.dirname(__FILE__) + "/views"
-      end
-
-      get_it '/from_file'
-
-      body.should.equal "You rock Alena!\n"
-
-    end
-
-    specify "use layout.ext by default if available" do
-
-      get '/' do
-        haml :foo, :views_directory => File.dirname(__FILE__) + "/views/layout_test"
-      end
-
-      get_it '/'
-      should.be.ok
-      body.should.equal "x This is foo!\n x\n"
-
-    end
-
-    specify "renders without layout" do
-
-      get '/' do
-        haml :no_layout, :views_directory => File.dirname(__FILE__) + "/views/no_layout"
-      end
-
-      get_it '/'
-      should.be.ok
-      body.should.equal "<h1>No Layout!</h1>\n"
-
-    end
-
-    specify "can render with no layout" do
-      layout do
-        "X\n= yield\nX"
-      end
-
-      get '/' do
-        haml 'blake', :layout => false
-      end
-
-      get_it '/'
-
-      body.should.equal "blake\n"
-    end
-
-    specify "raises error if template not found" do
-      get '/' do
-        haml :not_found
-      end
-
-      lambda { get_it '/' }.should.raise(Errno::ENOENT)
-    end
-
-    specify "use layout.ext by default if available" do
-
-      template :foo do
-        'asdf'
-      end
-
-      get '/' do
-        haml :foo, :layout => false,
-                   :views_directory => File.dirname(__FILE__) + "/views/layout_test"
-      end
-
-      get_it '/'
-      should.be.ok
-      body.should.equal "asdf\n"
-
-    end
-
+  it "renders with inline layouts" do
+    mock_app {
+      layout { %q(%h1= 'THIS. IS. ' + yield.upcase) }
+      get('/') { haml '%em Sparta' }
+    }
+    get '/'
+    assert ok?
+    assert_equal "<h1>THIS. IS. <EM>SPARTA</EM></h1>\n", body
   end
 
-  describe 'Options passed to the HAML interpreter' do
-    setup do
-      Sinatra.application = nil
-    end
-
-    specify 'are empty be default' do
-
-      get '/' do
-        haml 'foo'
-      end
-
-      Haml::Engine.expects(:new).with('foo', {}).returns(stub(:render => 'foo'))
-
-      get_it '/'
-      should.be.ok
-
-    end
-
-    specify 'can be configured by passing :options to haml' do
-
-      get '/' do
-        haml 'foo', :options => {:format => :html4}
-      end
-
-      Haml::Engine.expects(:new).with('foo', {:format => :html4}).returns(stub(:render => 'foo'))
-
-      get_it '/'
-      should.be.ok
-
-    end
+  it "renders with file layouts" do
+    haml_app {
+      haml 'Hello World', :layout => :layout2
+    }
+    assert ok?
+    assert_equal "<h1>HAML Layout!</h1>\n<p>Hello World</p>\n", body
+  end
 
-    specify 'can be configured using set_option :haml' do
+  it "raises error if template not found" do
+    mock_app {
+      get('/') { haml :no_such_template }
+    }
+    assert_raise(Errno::ENOENT) { get('/') }
+  end
 
-      configure do
-        set_option :haml, :format       => :html4,
-                          :escape_html  => true
-      end
+  it "passes HAML options to the Haml engine" do
+    haml_app {
+      haml "!!!\n%h1 Hello World", :options => {:format => :html5}
+    }
+    assert ok?
+    assert_equal "<!DOCTYPE html>\n<h1>Hello World</h1>\n", body
+  end
 
+  it "passes default HAML options to the Haml engine" do
+    mock_app {
+      set :haml, {:format => :html5}
       get '/' do
-        haml 'foo'
+        haml "!!!\n%h1 Hello World"
       end
-
-      Haml::Engine.expects(:new).with('foo', {:format => :html4,
-        :escape_html => true}).returns(stub(:render => 'foo'))
-
-      get_it '/'
-      should.be.ok
-
-    end
-
+    }
+    get '/'
+    assert ok?
+    assert_equal "<!DOCTYPE html>\n<h1>Hello World</h1>\n", body
   end
-
 end

data/test/helper.rb

@@ -1,7 +1,25 @@
-require 'rubygems'
-require 'mocha'
+begin
+  require 'test/spec'
+rescue LoadError
+  require 'rubygems'
+  require 'test/spec'
+end
 
-$:.unshift File.dirname(File.dirname(__FILE__)) + "/lib"
-
-require 'sinatra'
+$:.unshift File.dirname(File.dirname(__FILE__)) + '/lib'
+require 'sinatra/base'
+require 'sinatra/test'
 require 'sinatra/test/spec'
+
+module Sinatra::Test
+  # Sets up a Sinatra::Base subclass defined with the block
+  # given. Used in setup or individual spec methods to establish
+  # the application.
+  def mock_app(base=Sinatra::Base, &block)
+    @app = Sinatra.new(base, &block)
+  end
+end
+
+class Sinatra::Base
+  # Allow assertions in request context
+  include Test::Unit::Assertions
+end

data/test/helpers_test.rb

@@ -0,0 +1,361 @@
+require File.dirname(__FILE__) + '/helper'
+
+describe 'Sinatra::Helpers' do
+  describe '#status' do
+    setup do
+      mock_app {
+        get '/' do
+          status 207
+          nil
+        end
+      }
+    end
+
+    it 'sets the response status code' do
+      get '/'
+      assert_equal 207, response.status
+    end
+  end
+
+  describe '#body' do
+    it 'takes a block for defered body generation' do
+      mock_app {
+        get '/' do
+          body { 'Hello World' }
+        end
+      }
+
+      get '/'
+      assert_equal 'Hello World', body
+    end
+
+    it 'takes a String, Array, or other object responding to #each' do
+      mock_app {
+        get '/' do
+          body 'Hello World'
+        end
+      }
+
+      get '/'
+      assert_equal 'Hello World', body
+    end
+  end
+
+  describe '#redirect' do
+    it 'uses a 302 when only a path is given' do
+      mock_app {
+        get '/' do
+          redirect '/foo'
+          fail 'redirect should halt'
+        end
+      }
+
+      get '/'
+      assert_equal 302, status
+      assert_equal '', body
+      assert_equal '/foo', response['Location']
+    end
+
+    it 'uses the code given when specified' do
+      mock_app {
+        get '/' do
+          redirect '/foo', 301
+          fail 'redirect should halt'
+        end
+      }
+
+      get '/'
+      assert_equal 301, status
+      assert_equal '', body
+      assert_equal '/foo', response['Location']
+    end
+  end
+
+  describe '#error' do
+    it 'sets a status code and halts' do
+      mock_app {
+        get '/' do
+          error 501
+          fail 'error should halt'
+        end
+      }
+
+      get '/'
+      assert_equal 501, status
+      assert_equal '', body
+    end
+
+    it 'takes an optional body' do
+      mock_app {
+        get '/' do
+          error 501, 'FAIL'
+          fail 'error should halt'
+        end
+      }
+
+      get '/'
+      assert_equal 501, status
+      assert_equal 'FAIL', body
+    end
+
+    it 'uses a 500 status code when first argument is a body' do
+      mock_app {
+        get '/' do
+          error 'FAIL'
+          fail 'error should halt'
+        end
+      }
+
+      get '/'
+      assert_equal 500, status
+      assert_equal 'FAIL', body
+    end
+  end
+
+  describe '#not_found' do
+    it 'halts with a 404 status' do
+      mock_app {
+        get '/' do
+          not_found
+          fail 'not_found should halt'
+        end
+      }
+
+      get '/'
+      assert_equal 404, status
+      assert_equal '', body
+    end
+  end
+
+  describe '#session' do
+    it 'uses the existing rack.session' do
+      mock_app {
+        get '/' do
+          session[:foo]
+        end
+      }
+
+      get '/', :env => { 'rack.session' => { :foo => 'bar' } }
+      assert_equal 'bar', body
+    end
+
+    it 'creates a new session when none provided' do
+      mock_app {
+        get '/' do
+          assert session.empty?
+          session[:foo] = 'bar'
+          'Hi'
+        end
+      }
+
+      get '/'
+      assert_equal 'Hi', body
+    end
+  end
+
+  describe '#media_type' do
+    include Sinatra::Helpers
+    it "looks up media types in Rack's MIME registry" do
+      Rack::Mime::MIME_TYPES['.foo'] = 'application/foo'
+      assert_equal 'application/foo', media_type('foo')
+      assert_equal 'application/foo', media_type('.foo')
+      assert_equal 'application/foo', media_type(:foo)
+    end
+    it 'returns nil when given nil' do
+      assert media_type(nil).nil?
+    end
+    it 'returns nil when media type not registered' do
+      assert media_type(:bizzle).nil?
+    end
+    it 'returns the argument when given a media type string' do
+      assert_equal 'text/plain', media_type('text/plain')
+    end
+  end
+
+  describe '#content_type' do
+    it 'sets the Content-Type header' do
+      mock_app {
+        get '/' do
+          content_type 'text/plain'
+          'Hello World'
+        end
+      }
+
+      get '/'
+      assert_equal 'text/plain', response['Content-Type']
+      assert_equal 'Hello World', body
+    end
+
+    it 'takes media type parameters (like charset=)' do
+      mock_app {
+        get '/' do
+          content_type 'text/html', :charset => 'utf-8'
+          "<h1>Hello, World</h1>"
+        end
+      }
+
+      get '/'
+      assert ok?
+      assert_equal 'text/html;charset=utf-8', response['Content-Type']
+      assert_equal "<h1>Hello, World</h1>", body
+    end
+
+    it "looks up symbols in Rack's mime types dictionary" do
+      Rack::Mime::MIME_TYPES['.foo'] = 'application/foo'
+      mock_app {
+        get '/foo.xml' do
+          content_type :foo
+          "I AM FOO"
+        end
+      }
+
+      get '/foo.xml'
+      assert ok?
+      assert_equal 'application/foo', response['Content-Type']
+      assert_equal 'I AM FOO', body
+    end
+
+    it 'fails when no mime type is registered for the argument provided' do
+      mock_app {
+        get '/foo.xml' do
+          content_type :bizzle
+          "I AM FOO"
+        end
+      }
+      assert_raise(RuntimeError) { get '/foo.xml' }
+    end
+  end
+
+  describe '#send_file' do
+    before {
+      @file = File.dirname(__FILE__) + '/file.txt'
+      File.open(@file, 'wb') { |io| io.write('Hello World') }
+    }
+    after {
+      File.unlink @file
+      @file = nil
+    }
+
+    def send_file_app
+      path = @file
+      mock_app {
+        get '/file.txt' do
+          send_file path
+        end
+      }
+    end
+
+    it "sends the contents of the file" do
+      send_file_app
+      get '/file.txt'
+      assert ok?
+      assert_equal 'Hello World', body
+    end
+
+    it 'sets the Content-Type response header if a mime-type can be located' do
+      send_file_app
+      get '/file.txt'
+      assert_equal 'text/plain', response['Content-Type']
+    end
+
+    it 'sets the Content-Length response header' do
+      send_file_app
+      get '/file.txt'
+      assert_equal 'Hello World'.length.to_s, response['Content-Length']
+    end
+
+    it 'sets the Last-Modified response header' do
+      send_file_app
+      get '/file.txt'
+      assert_equal File.mtime(@file).httpdate, response['Last-Modified']
+    end
+
+    it "returns a 404 when not found" do
+      mock_app {
+        get '/' do
+          send_file 'this-file-does-not-exist.txt'
+        end
+      }
+      get '/'
+      assert not_found?
+    end
+  end
+
+  describe '#last_modified' do
+    before do
+      now = Time.now
+      mock_app {
+        get '/' do
+          body { 'Hello World' }
+          last_modified now
+          'Boo!'
+        end
+      }
+      @now = now
+    end
+
+    it 'sets the Last-Modified header to a valid RFC 2616 date value' do
+      get '/'
+      assert_equal @now.httpdate, response['Last-Modified']
+    end
+
+    it 'returns a body when conditional get misses' do
+      get '/'
+      assert_equal 200, status
+      assert_equal 'Boo!', body
+    end
+
+    it 'halts when a conditional GET matches' do
+      get '/', :env => { 'HTTP_IF_MODIFIED_SINCE' => @now.httpdate }
+      assert_equal 304, status
+      assert_equal '', body
+    end
+  end
+
+  describe '#etag' do
+    before do
+      mock_app {
+        get '/' do
+          body { 'Hello World' }
+          etag 'FOO'
+          'Boo!'
+        end
+      }
+    end
+
+    it 'sets the ETag header' do
+      get '/'
+      assert_equal '"FOO"', response['ETag']
+    end
+
+    it 'returns a body when conditional get misses' do
+      get '/'
+      assert_equal 200, status
+      assert_equal 'Boo!', body
+    end
+
+    it 'halts when a conditional GET matches' do
+      get '/', :env => { 'HTTP_IF_NONE_MATCH' => '"FOO"' }
+      assert_equal 304, status
+      assert_equal '', body
+    end
+
+    it 'should handle multiple ETag values in If-None-Match header' do
+      get '/', :env => { 'HTTP_IF_NONE_MATCH' => '"BAR", *' }
+      assert_equal 304, status
+      assert_equal '', body
+    end
+
+    it 'uses a weak etag with the :weak option' do
+      mock_app {
+        get '/' do
+          etag 'FOO', :weak
+          "that's weak, dude."
+        end
+      }
+      get '/'
+      assert_equal 'W/"FOO"', response['ETag']
+    end
+
+  end
+end