adamwiggins-sinatra 0.8.9 → 0.10.1

data/test/base_test.rb

@@ -1,72 +1,160 @@
-require 'test/spec'
-require 'sinatra/base'
-require 'sinatra/test'
+require File.dirname(__FILE__) + '/helper'
 
-describe 'Sinatra::Base' do
-  include Sinatra::Test
-
-  it 'includes Rack::Utils' do
-    Sinatra::Base.should.include Rack::Utils
+class BaseTest < Test::Unit::TestCase
+  def test_default
+    assert true
   end
 
-  it 'can be used as a Rack application' do
-    mock_app {
+  describe 'Sinatra::Base subclasses' do
+    class TestApp < Sinatra::Base
       get '/' do
         'Hello World'
       end
-    }
-    @app.should.respond_to :call
+    end
+
+    it 'include Rack::Utils' do
+      assert TestApp.included_modules.include?(Rack::Utils)
+    end
+
+    it 'processes requests with #call' do
+      assert TestApp.respond_to?(:call)
+
+      request = Rack::MockRequest.new(TestApp)
+      response = request.get('/')
+      assert response.ok?
+      assert_equal 'Hello World', response.body
+    end
 
-    request = Rack::MockRequest.new(@app)
-    response = request.get('/')
-    response.should.be.ok
-    response.body.should.equal 'Hello World'
+    class TestApp < Sinatra::Base
+      get '/state' do
+        @foo ||= "new"
+        body = "Foo: #{@foo}"
+        @foo = 'discard'
+        body
+      end
+    end
+
+    it 'does not maintain state between requests' do
+      request = Rack::MockRequest.new(TestApp)
+      2.times do
+        response = request.get('/state')
+        assert response.ok?
+        assert_equal 'Foo: new', response.body
+      end
+    end
+
+    it "passes the subclass to configure blocks" do
+      ref = nil
+      TestApp.configure { |app| ref = app }
+      assert_equal TestApp, ref
+    end
+
+    it "allows the configure block arg to be omitted and does not change context" do
+      context = nil
+      TestApp.configure { context = self }
+      assert_equal self, context
+    end
   end
 
-  it 'can be used as Rack middleware' do
-    app = lambda { |env| [200, {}, ['Goodbye World']] }
-    mock_middleware =
-      mock_app {
-        get '/' do
-          'Hello World'
-        end
-        get '/goodbye' do
-          @app.call(request.env)
-        end
-      }
-    middleware = mock_middleware.new(app)
-    middleware.app.should.be app
+  describe "Sinatra::Base as Rack middleware" do
+    app = lambda { |env|
+      headers = {'X-Downstream' => 'true'}
+      headers['X-Route-Missing'] = env['sinatra.route-missing'] || ''
+      [210, headers, ['Hello from downstream']] }
+
+    class TestMiddleware < Sinatra::Base
+    end
 
+    it 'creates a middleware that responds to #call with .new' do
+      middleware = TestMiddleware.new(app)
+      assert middleware.respond_to?(:call)
+    end
+
+    it 'exposes the downstream app' do
+      middleware = TestMiddleware.new(app)
+      assert_same app, middleware.app
+    end
+
+    class TestMiddleware < Sinatra::Base
+      def route_missing
+        env['sinatra.route-missing'] = '1'
+        super
+      end
+
+      get '/' do
+        'Hello from middleware'
+      end
+    end
+
+    middleware = TestMiddleware.new(app)
     request = Rack::MockRequest.new(middleware)
-    response = request.get('/')
-    response.should.be.ok
-    response.body.should.equal 'Hello World'
 
-    response = request.get('/goodbye')
-    response.should.be.ok
-    response.body.should.equal 'Goodbye World'
-  end
+    it 'intercepts requests' do
+      response = request.get('/')
+      assert response.ok?
+      assert_equal 'Hello from middleware', response.body
+    end
+
+    it 'automatically forwards requests downstream when no matching route found' do
+      response = request.get('/missing')
+      assert_equal 210, response.status
+      assert_equal 'Hello from downstream', response.body
+    end
 
-  it 'can take multiple definitions of a route' do
-    app = mock_app {
-      user_agent(/Foo/)
-      get '/foo' do
-        'foo'
+    it 'calls #route_missing before forwarding downstream' do
+      response = request.get('/missing')
+      assert_equal '1', response['X-Route-Missing']
+    end
+
+    class TestMiddleware < Sinatra::Base
+      get '/low-level-forward' do
+        app.call(env)
+      end
+    end
+
+    it 'can call the downstream app directly and return result' do
+      response = request.get('/low-level-forward')
+      assert_equal 210, response.status
+      assert_equal 'true', response['X-Downstream']
+      assert_equal 'Hello from downstream', response.body
+    end
+
+    class TestMiddleware < Sinatra::Base
+      get '/explicit-forward' do
+        response['X-Middleware'] = 'true'
+        res = forward
+        assert_nil res
+        assert_equal 210, response.status
+        assert_equal 'true', response['X-Downstream']
+        assert_equal ['Hello from downstream'], response.body
+        'Hello after explicit forward'
       end
+    end
+
+    it 'forwards the request downstream and integrates the response into the current context' do
+      response = request.get('/explicit-forward')
+      assert_equal 210, response.status
+      assert_equal 'true', response['X-Downstream']
+      assert_equal 'Hello after explicit forward', response.body
+      assert_equal '28', response['Content-Length']
+    end
+
+    app_content_length = lambda {|env|
+      [200, {'Content-Length' => '16'}, 'From downstream!']}
 
-      get '/foo' do
-        'not foo'
+    class TestMiddlewareContentLength < Sinatra::Base
+      get '/forward' do
+        res = forward
+        'From after explicit forward!'
       end
-    }
+    end
 
-    request = Rack::MockRequest.new(app)
-    response = request.get('/foo', 'HTTP_USER_AGENT' => 'Foo')
-    response.should.be.ok
-    response.body.should.equal 'foo'
+    middleware_content_length = TestMiddlewareContentLength.new(app_content_length)
+    request_content_length = Rack::MockRequest.new(middleware_content_length)
 
-    request = Rack::MockRequest.new(app)
-    response = request.get('/foo')
-    response.should.be.ok
-    response.body.should.equal 'not foo'
+    it "sets content length for last response" do
+      response = request_content_length.get('/forward')
+      assert_equal '28', response['Content-Length']
+    end
   end
 end

data/test/builder_test.rb

@@ -1,10 +1,7 @@
-require 'test/spec'
-require 'sinatra/base'
-require 'sinatra/test'
-
-describe "Builder Templates" do
-  include Sinatra::Test
+require File.dirname(__FILE__) + '/helper'
+require 'builder'
 
+class BuilderTest < Test::Unit::TestCase
   def builder_app(&block)
     mock_app {
       set :views, File.dirname(__FILE__) + '/views'
@@ -15,8 +12,8 @@ describe "Builder Templates" do
 
   it 'renders inline Builder strings' do
     builder_app { builder 'xml.instruct!' }
-    should.be.ok
-    body.should.equal %{<?xml version="1.0" encoding="UTF-8"?>\n}
+    assert ok?
+    assert_equal %{<?xml version="1.0" encoding="UTF-8"?>\n}, body
   end
 
   it 'renders inline blocks' do
@@ -26,8 +23,8 @@ describe "Builder Templates" do
         xml.couple @name
       end
     }
-    should.be.ok
-    body.should.equal "<couple>Frank &amp; Mary</couple>\n"
+    assert ok?
+    assert_equal "<couple>Frank &amp; Mary</couple>\n", body
   end
 
   it 'renders .builder files in views path' do
@@ -35,8 +32,8 @@ describe "Builder Templates" do
       @name = "Blue"
       builder :hello
     }
-    should.be.ok
-    body.should.equal %(<exclaim>You're my boy, Blue!</exclaim>\n)
+    assert ok?
+    assert_equal %(<exclaim>You're my boy, Blue!</exclaim>\n), body
   end
 
   it "renders with inline layouts" do
@@ -47,22 +44,22 @@ describe "Builder Templates" do
       get('/') { builder %(xml.em 'Hello World') }
     }
     get '/'
-    should.be.ok
-    body.should.equal "<layout>\n<em>Hello World</em>\n</layout>\n"
+    assert ok?
+    assert_equal "<layout>\n<em>Hello World</em>\n</layout>\n", body
   end
 
   it "renders with file layouts" do
     builder_app {
       builder %(xml.em 'Hello World'), :layout => :layout2
     }
-    should.be.ok
-    body.should.equal "<layout>\n<em>Hello World</em>\n</layout>\n"
+    assert ok?
+    assert_equal "<layout>\n<em>Hello World</em>\n</layout>\n", body
   end
 
   it "raises error if template not found" do
     mock_app {
       get('/') { builder :no_such_template }
     }
-    lambda { get('/') }.should.raise(Errno::ENOENT)
+    assert_raise(Errno::ENOENT) { get('/') }
   end
 end

data/test/contest.rb

@@ -0,0 +1,64 @@
+require "test/unit"
+
+# Test::Unit loads a default test if the suite is empty, and the only
+# purpose of that test is to fail. As having empty contexts is a common
+# practice, we decided to overwrite TestSuite#empty? in order to
+# allow them. Having a failure when no tests have been defined seems
+# counter-intuitive.
+class Test::Unit::TestSuite
+  unless method_defined?(:empty?)
+    def empty?
+      false
+    end
+  end
+end
+
+# We added setup, test and context as class methods, and the instance
+# method setup now iterates on the setup blocks. Note that all setup
+# blocks must be defined with the block syntax. Adding a setup instance
+# method defeats the purpose of this library.
+class Test::Unit::TestCase
+  def self.setup(&block)
+    setup_blocks << block
+  end
+
+  def setup
+    self.class.setup_blocks.each do |block|
+      instance_eval(&block)
+    end
+  end
+
+  def self.context(name, &block)
+    subclass = Class.new(self.superclass)
+    subclass.setup_blocks.unshift(*setup_blocks)
+    subclass.class_eval(&block)
+    const_set(context_name(name), subclass)
+  end
+
+  def self.test(name, &block)
+    define_method(test_name(name), &block)
+  end
+
+  class << self
+    alias_method :should, :test
+    alias_method :describe, :context
+  end
+
+private
+
+  def self.setup_blocks
+    @setup_blocks ||= []
+  end
+
+  def self.context_name(name)
+    "Test#{sanitize_name(name).gsub(/(^| )(\w)/) { $2.upcase }}".to_sym
+  end
+
+  def self.test_name(name)
+    "test_#{sanitize_name(name).gsub(/\s+/,'_')}".to_sym
+  end
+
+  def self.sanitize_name(name)
+    name.gsub(/\W+/, ' ').strip
+  end
+end

data/test/erb_test.rb

@@ -1,10 +1,6 @@
-require 'test/spec'
-require 'sinatra/base'
-require 'sinatra/test'
-
-describe "ERB Templates" do
-  include Sinatra::Test
+require File.dirname(__FILE__) + '/helper'
 
+class ERBTest < Test::Unit::TestCase
   def erb_app(&block)
     mock_app {
       set :views, File.dirname(__FILE__) + '/views'
@@ -15,14 +11,14 @@ describe "ERB Templates" do
 
   it 'renders inline ERB strings' do
     erb_app { erb '<%= 1 + 1 %>' }
-    should.be.ok
-    body.should.equal '2'
+    assert ok?
+    assert_equal '2', body
   end
 
   it 'renders .erb files in views path' do
     erb_app { erb :hello }
-    should.be.ok
-    body.should.equal "Hello World\n"
+    assert ok?
+    assert_equal "Hello World\n", body
   end
 
   it 'takes a :locals option' do
@@ -30,8 +26,8 @@ describe "ERB Templates" do
       locals = {:foo => 'Bar'}
       erb '<%= foo %>', :locals => locals
     }
-    should.be.ok
-    body.should.equal 'Bar'
+    assert ok?
+    assert_equal 'Bar', body
   end
 
   it "renders with inline layouts" do
@@ -40,16 +36,46 @@ describe "ERB Templates" do
       get('/') { erb 'Sparta' }
     }
     get '/'
-    should.be.ok
-    body.should.equal 'THIS. IS. SPARTA!'
+    assert ok?
+    assert_equal 'THIS. IS. SPARTA!', body
   end
 
   it "renders with file layouts" do
     erb_app {
       erb 'Hello World', :layout => :layout2
     }
-    should.be.ok
-    body.should.equal "ERB Layout!\nHello World\n"
+    assert ok?
+    assert_equal "ERB Layout!\nHello World\n", body
+  end
+
+  it "renders erb with blocks" do
+    mock_app {
+      def container
+        @_out_buf << "THIS."
+        yield
+        @_out_buf << "SPARTA!"
+      end
+      def is; "IS." end
+      get '/' do
+        erb '<% container do %> <%= is %> <% end %>'
+      end
+    }
+    get '/'
+    assert ok?
+    assert_equal 'THIS. IS. SPARTA!', body
   end
 
+  it "can be used in a nested fashion for partials and whatnot" do
+    mock_app {
+      template(:inner) { "<inner><%= 'hi' %></inner>" }
+      template(:outer) { "<outer><%= erb :inner %></outer>" }
+      get '/' do
+        erb :outer
+      end
+    }
+
+    get '/'
+    assert ok?
+    assert_equal '<outer><inner>hi</inner></outer>', body
+  end
 end

data/test/extensions_test.rb

@@ -0,0 +1,100 @@
+require File.dirname(__FILE__) + '/helper'
+
+class ExtensionsTest < Test::Unit::TestCase
+  module FooExtensions
+    def foo
+    end
+
+    private
+      def im_hiding_in_ur_foos
+      end
+  end
+
+  module BarExtensions
+    def bar
+    end
+  end
+
+  module BazExtensions
+    def baz
+    end
+  end
+
+  module QuuxExtensions
+    def quux
+    end
+  end
+
+  module PainExtensions
+    def foo=(name); end
+    def bar?(name); end
+    def fizz!(name); end
+  end
+
+  it 'will add the methods to the DSL for the class in which you register them and its subclasses' do
+    Sinatra::Base.register FooExtensions
+    assert Sinatra::Base.respond_to?(:foo)
+
+    Sinatra::Default.register BarExtensions
+    assert Sinatra::Default.respond_to?(:bar)
+    assert Sinatra::Default.respond_to?(:foo)
+    assert !Sinatra::Base.respond_to?(:bar)
+  end
+
+  it 'allows extending by passing a block' do
+    Sinatra::Base.register {
+      def im_in_ur_anonymous_module; end
+    }
+    assert Sinatra::Base.respond_to?(:im_in_ur_anonymous_module)
+  end
+
+  it 'will make sure any public methods added via Default#register are delegated to Sinatra::Delegator' do
+    Sinatra::Default.register FooExtensions
+    assert Sinatra::Delegator.private_instance_methods.
+      map { |m| m.to_sym }.include?(:foo)
+    assert !Sinatra::Delegator.private_instance_methods.
+      map { |m| m.to_sym }.include?(:im_hiding_in_ur_foos)
+  end
+
+  it 'will handle special method names' do
+    Sinatra::Default.register PainExtensions
+    assert Sinatra::Delegator.private_instance_methods.
+      map { |m| m.to_sym }.include?(:foo=)
+    assert Sinatra::Delegator.private_instance_methods.
+      map { |m| m.to_sym }.include?(:bar?)
+    assert Sinatra::Delegator.private_instance_methods.
+      map { |m| m.to_sym }.include?(:fizz!)
+  end
+
+  it 'will not delegate methods on Base#register' do
+    Sinatra::Base.register QuuxExtensions
+    assert !Sinatra::Delegator.private_instance_methods.include?("quux")
+  end
+
+  it 'will extend the Sinatra::Default application by default' do
+    Sinatra.register BazExtensions
+    assert !Sinatra::Base.respond_to?(:baz)
+    assert Sinatra::Default.respond_to?(:baz)
+  end
+
+  module BizzleExtension
+    def bizzle
+      bizzle_option
+    end
+
+    def self.registered(base)
+      fail "base should be BizzleApp" unless base == BizzleApp
+      fail "base should have already extended BizzleExtension" unless base.respond_to?(:bizzle)
+      base.set :bizzle_option, 'bizzle!'
+    end
+  end
+
+  class BizzleApp < Sinatra::Base
+  end
+
+  it 'sends .registered to the extension module after extending the class' do
+    BizzleApp.register BizzleExtension
+    assert_equal 'bizzle!', BizzleApp.bizzle_option
+    assert_equal 'bizzle!', BizzleApp.bizzle
+  end
+end