sinatra 0.2.2 → 0.3.0

data/test/application_test.rb

@@ -19,49 +19,49 @@ context "Looking up a request" do
   specify "returns what's at the end" do
     block = Proc.new { 'Hello' }
     get '/', &block
-    
+
     result = Sinatra.application.lookup(
       Rack::Request.new(
         'REQUEST_METHOD' => 'GET',
         'PATH_INFO' => '/'
       )
     )
-    
+
     result.should.not.be.nil
     result.block.should.be block
   end
-  
+
   specify "takes params in path" do
     block = Proc.new { 'Hello' }
     get '/:foo', &block
-    
+
     result = Sinatra.application.lookup(
       Rack::Request.new(
         'REQUEST_METHOD' => 'GET',
         'PATH_INFO' => '/bar'
       )
     )
-    
+
     result.should.not.be.nil
     result.block.should.be block
     result.params.should.equal "foo" => 'bar'
   end
-              
+
 end
 
 context "An app returns" do
-  
+
   setup do
     Sinatra.application = nil
   end
-    
+
   specify "404 if no events found" do
     request = Rack::MockRequest.new(@app)
     get_it '/'
     should.be.not_found
     body.should.equal '<h1>Not Found</h1>'
   end
-  
+
   specify "200 if success" do
     get '/' do
       'Hello World'
@@ -70,106 +70,249 @@ context "An app returns" do
     should.be.ok
     body.should.equal 'Hello World'
   end
-  
+
   specify "an objects result from each if it has it" do
-    
+
     get '/' do
       TesterWithEach.new
     end
-    
+
     get_it '/'
     should.be.ok
     body.should.equal 'foobarbaz'
 
   end
-  
+
   specify "the body set if set before the last" do
-        
+
     get '/' do
       body 'Blake'
       'Mizerany'
     end
-    
+
     get_it '/'
     should.be.ok
     body.should.equal 'Blake'
 
   end
-  
+
+end
+
+context "Application#configure blocks" do
+
+  setup do
+    Sinatra.application = nil
+  end
+
+  specify "run when no environment specified" do
+    ref = false
+    configure { ref = true }
+    ref.should.equal true
+  end
+
+  specify "run when matching environment specified" do
+    ref = false
+    configure(:test) { ref = true }
+    ref.should.equal true
+  end
+
+  specify "do not run when no matching environment specified" do
+    configure(:foo) { flunk "block should not have been executed" }
+    configure(:development, :production, :foo) { flunk "block should not have been executed" }
+  end
+
+  specify "accept multiple environments" do
+    ref = false
+    configure(:foo, :test, :bar) { ref = true }
+    ref.should.equal true
+  end
+
+end
+
+context "Default Application Configuration" do
+
+  specify "includes 404 and 500 error handlers" do
+    Sinatra.application.errors.should.include(Sinatra::ServerError)
+    Sinatra.application.errors[Sinatra::ServerError].should.not.be.nil
+    Sinatra.application.errors.should.include(Sinatra::NotFound)
+    Sinatra.application.errors[Sinatra::NotFound].should.not.be.nil
+  end
+
+  specify "includes Static event" do
+    assert Sinatra.application.events[:get].any? { |e| Sinatra::Static === e }
+  end
+
 end
-  
+
 context "Events in an app" do
-  
+
   setup do
     Sinatra.application = nil
   end
-  
+
   specify "evaluate in a clean context" do
     helpers do
       def foo
         'foo'
       end
     end
-    
+
     get '/foo' do
       foo
     end
-    
+
     get_it '/foo'
     should.be.ok
     body.should.equal 'foo'
   end
-  
+
   specify "get access to request, response, and params" do
     get '/:foo' do
       params["foo"] + params["bar"]
     end
-    
+
     get_it '/foo?bar=baz'
     should.be.ok
     body.should.equal 'foobaz'
   end
-  
+
   specify "can filters by agent" do
-    
+
     get '/', :agent => /Windows/ do
       request.env['HTTP_USER_AGENT']
     end
-    
+
     get_it '/', :env => { :agent => 'Windows' }
     should.be.ok
     body.should.equal 'Windows'
 
-    get_it '/', :agent => 'Mac'
+    get_it '/', :env => { :agent => 'Mac' }
     should.not.be.ok
 
   end
 
-  specify "can filters by agent" do
-    
+  specify "can use regex to get parts of user-agent" do
+
     get '/', :agent => /Windows (NT)/ do
       params[:agent].first
     end
-    
+
     get_it '/', :env => { :agent => 'Windows NT' }
 
     body.should.equal 'NT'
 
   end
-  
+
   specify "can deal with spaces in paths" do
-    
+
     path = '/path with spaces'
-    
+
     get path do
       "Look ma, a path with spaces!"
     end
-    
+
     get_it URI.encode(path)
-    
+
     body.should.equal "Look ma, a path with spaces!"
   end
-  
+
+  specify "route based on host" do
+
+    get '/' do
+      'asdf'
+    end
+
+    get_it '/'
+    assert ok?
+    assert_equal('asdf', body)
+
+    get '/foo', :host => 'foo.sinatrarb.com' do
+      'in foo!'
+    end
+
+    get '/foo', :host => 'bar.sinatrarb.com'  do
+      'in bar!'
+    end
+
+    get_it '/foo', {}, 'HTTP_HOST' => 'foo.sinatrarb.com'
+    assert ok?
+    assert_equal 'in foo!', body
+
+    get_it '/foo', {}, 'HTTP_HOST' => 'bar.sinatrarb.com'
+    assert ok?
+    assert_equal 'in bar!', body
+
+    get_it '/foo'
+    assert not_found?
+
+  end
+
 end
 
 
+context "Options in an app" do
+
+  setup do
+    Sinatra.application = nil
+    @app = Sinatra::application
+  end
+
+  specify "can be set singly on app" do
+    @app.set :foo, 1234
+    @app.options.foo.should.equal 1234
+  end
+
+  specify "can be set singly from top-level" do
+    set_option :foo, 1234
+    @app.options.foo.should.equal 1234
+  end
+
+  specify "can be set multiply on app" do
+    @app.options.foo.should.be.nil
+    @app.set :foo => 1234,
+      :bar => 'hello, world'
+    @app.options.foo.should.equal 1234
+    @app.options.bar.should.equal 'hello, world'
+  end
+
+  specify "can be set multiply from top-level" do
+    @app.options.foo.should.be.nil
+    set_options :foo => 1234,
+      :bar => 'hello, world'
+    @app.options.foo.should.equal 1234
+    @app.options.bar.should.equal 'hello, world'
+  end
+
+  specify "can be enabled on app" do
+    @app.options.foo.should.be.nil
+    @app.enable :sessions, :foo, :bar
+    @app.options.sessions.should.equal true
+    @app.options.foo.should.equal true
+    @app.options.bar.should.equal true
+  end
+
+  specify "can be enabled from top-level" do
+    @app.options.foo.should.be.nil
+    enable :sessions, :foo, :bar
+    @app.options.sessions.should.equal true
+    @app.options.foo.should.equal true
+    @app.options.bar.should.equal true
+  end
+
+  specify "can be disabled on app" do
+    @app.options.foo.should.be.nil
+    @app.disable :sessions, :foo, :bar
+    @app.options.sessions.should.equal false
+    @app.options.foo.should.equal false
+    @app.options.bar.should.equal false
+  end
+
+  specify "can be enabled from top-level" do
+    @app.options.foo.should.be.nil
+    disable :sessions, :foo, :bar
+    @app.options.sessions.should.equal false
+    @app.options.foo.should.equal false
+    @app.options.bar.should.equal false
+  end
+
+end

data/test/custom_error_test.rb

@@ -1,67 +1,62 @@
 require File.dirname(__FILE__) + '/helper'
 
-context "Custom Errors (in general)" do
+context "Custom Errors" do
 
   setup do
     Sinatra.application = nil
   end
-  
+
   specify "override the default 404" do
-    
+
     get_it '/'
     should.be.not_found
     body.should.equal '<h1>Not Found</h1>'
-    
+
     error Sinatra::NotFound do
       'Custom 404'
     end
-    
+
     get_it '/'
     should.be.not_found
     body.should.equal 'Custom 404'
-    
+
   end
-  
+
   specify "override the default 500" do
     Sinatra.application.options.raise_errors = false
-    
+
     get '/' do
       raise 'asdf'
     end
-    
+
     get_it '/'
     status.should.equal 500
     body.should.equal '<h1>Internal Server Error</h1>'
-    
-    
+
+
     error do
       'Custom 500 for ' + request.env['sinatra.error'].message
     end
-    
+
     get_it '/'
-    
+
     get_it '/'
     status.should.equal 500
     body.should.equal 'Custom 500 for asdf'
-    
+
     Sinatra.application.options.raise_errors = true
   end
-  
+
   class UnmappedError < RuntimeError; end
-  
+
   specify "should bring unmapped error back to the top" do
     get '/' do
       raise UnmappedError, 'test'
     end
-    
+
     assert_raises(UnmappedError) do
       get_it '/'
     end
   end
 
 end
-
-
-
-
-

data/test/erb_test.rb

@@ -5,81 +5,101 @@ context "Erb" do
   setup do
     Sinatra.application = nil
   end
-  
+
   context "without layouts" do
-    
+
     setup do
       Sinatra.application = nil
     end
-    
+
     specify "should render" do
-    
+
       get '/no_layout' do
         erb '<%= 1 + 1 %>'
       end
-    
+
       get_it '/no_layout'
       should.be.ok
       body.should == '2'
 
     end
+
+    specify "should take an options hash with :locals set with a string" do
+      get '/locals' do
+        erb '<%= foo %>', :locals => {:foo => "Bar"}
+      end
+
+      get_it '/locals'
+      should.be.ok
+      body.should == 'Bar'
+    end
+
+    specify "should take an options hash with :locals set with a complex object" do
+      get '/locals-complex' do
+        erb '<%= foo[0] %>', :locals => {:foo => ["foo", "bar", "baz"]}
+      end
+
+      get_it '/locals-complex'
+      should.be.ok
+      body.should == 'foo'
+    end
   end
-  
+
   context "with layouts" do
 
     setup do
       Sinatra.application = nil
     end
-    
+
     specify "can be inline" do
-    
+
       layout do
         %Q{This is <%= yield %>!}
       end
-    
+
       get '/lay' do
         erb 'Blake'
       end
-    
+
       get_it '/lay'
       should.be.ok
       body.should.equal 'This is Blake!'
 
     end
-  
+
     specify "can use named layouts" do
-    
+
       layout :pretty do
         %Q{<h1><%= yield %></h1>}
       end
-        
+
       get '/pretty' do
         erb 'Foo', :layout => :pretty
       end
-    
+
       get '/not_pretty' do
         erb 'Bar'
       end
-    
+
       get_it '/pretty'
       body.should.equal '<h1>Foo</h1>'
-    
+
       get_it '/not_pretty'
       body.should.equal 'Bar'
-    
+
     end
-  
+
     specify "can be read from a file if they're not inlined" do
-    
+
       get '/foo' do
         @title = 'Welcome to the Hello Program'
         erb '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
 
   end
@@ -112,5 +132,5 @@ context "Erb" do
     end
 
   end
-  
+
 end