sinatra-base 1.0 → 1.4.0

data/test/integration/app.rb

@@ -0,0 +1,62 @@
+$stderr.puts "loading"
+require 'sinatra'
+
+configure do
+  set :foo, :bar
+end
+
+get '/app_file' do
+  content_type :txt
+  settings.app_file
+end
+
+get '/ping' do
+  'pong'
+end
+
+get '/stream' do
+  stream do |out|
+    sleep 0.1
+    out << "a"
+    sleep 1.2
+    out << "b"
+  end
+end
+
+get '/mainonly' do
+  object = Object.new
+  begin
+    object.send(:get, '/foo') { }
+    'false'
+  rescue NameError
+    'true'
+  end
+end
+
+set :out, nil
+get '/async' do
+  stream(:keep_open) { |o| (settings.out = o) << "hi!" }
+end
+
+get '/send' do
+  settings.out << params[:msg] if params[:msg]
+  settings.out.close if params[:close]
+  "ok"
+end
+
+class Subclass < Sinatra::Base
+  set :out, nil
+  get '/subclass/async' do
+    stream(:keep_open) { |o| (settings.out = o) << "hi!" }
+  end
+
+  get '/subclass/send' do
+    settings.out << params[:msg] if params[:msg]
+    settings.out.close if params[:close]
+    "ok"
+  end
+end
+
+use Subclass
+
+$stderr.puts "starting"

data/test/integration_helper.rb

@@ -0,0 +1,208 @@
+require 'sinatra/base'
+require 'rbconfig'
+require 'open-uri'
+require 'net/http'
+
+module IntegrationHelper
+  class BaseServer
+    extend Enumerable
+    attr_accessor :server, :port, :pipe
+    alias name server
+
+    def self.all
+      @all ||= []
+    end
+
+    def self.each(&block)
+      all.each(&block)
+    end
+
+    def self.run(server, port)
+      new(server, port).run
+    end
+
+    def app_file
+      File.expand_path('../integration/app.rb', __FILE__)
+    end
+
+    def environment
+      "development"
+    end
+
+    def initialize(server, port)
+      @installed, @pipe, @server, @port = nil, nil, server, port
+      Server.all << self
+    end
+
+    def run
+      return unless installed?
+      kill
+      @log     = ""
+      @pipe    = IO.popen(command)
+      @started = Time.now
+      warn "#{server} up and running on port #{port}" if ping
+      at_exit { kill }
+    end
+
+    def expect(str)
+      return if log.size < str.size or log[0, str.size] == str
+      raise "Server did not start properly:\n\n#{log}"
+    end
+
+    def ping(timeout = 10)
+      loop do
+        return if alive?
+        if Time.now - @started > timeout
+          $stderr.puts command, log
+          get('/ping')
+        else
+          expect "loading"
+          sleep 0.1
+        end
+      end
+    end
+
+    def alive?
+      3.times { get('/ping') }
+      true
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, EOFError, SystemCallError => error
+      false
+    end
+
+    def get_stream(url = "/stream", &block)
+      Net::HTTP.start '127.0.0.1', port do |http|
+        request = Net::HTTP::Get.new url
+        http.request request do |response|
+          response.read_body(&block)
+        end
+      end
+    end
+
+    def get(url)
+      open("http://127.0.0.1:#{port}#{url}").read
+    end
+
+    def log
+      @log ||= ""
+      loop { @log <<  @pipe.read_nonblock(1) }
+    rescue Exception
+      @log
+    end
+
+    def installed?
+      return @installed unless @installed.nil?
+      require server
+      @installed = true
+    rescue LoadError
+      warn "#{server} is not installed, skipping integration tests"
+      @installed = false
+    end
+
+    def command
+      @command ||= begin
+        cmd = ["RACK_ENV=#{environment}", "exec"]
+        if RbConfig.respond_to? :ruby
+          cmd << RbConfig.ruby.inspect
+        else
+          file, dir = RbConfig::CONFIG.values_at('ruby_install_name', 'bindir')
+          cmd << File.expand_path(file, dir).inspect
+        end
+        cmd << "-I" << File.expand_path('../../lib', __FILE__).inspect
+        cmd << app_file.inspect << '-s' << server << '-o' << '127.0.0.1' << '-p' << port
+        cmd << "-e" << environment.to_s << '2>&1'
+        cmd.join " "
+      end
+    end
+
+    def kill
+      return unless pipe
+      Process.kill("KILL", pipe.pid)
+    rescue NotImplementedError
+      system "kill -9 #{pipe.pid}"
+    rescue Errno::ESRCH
+    end
+
+    def webrick?
+      name.to_s == "webrick"
+    end
+  end
+
+  if RUBY_ENGINE == "jruby"
+    class JRubyServer < BaseServer
+      def start_vm
+        require 'java'
+        # Create a new container, set load paths and env
+        # SINGLETHREAD means create a new runtime
+        vm = org.jruby.embed.ScriptingContainer.new(org.jruby.embed.LocalContextScope::SINGLETHREAD)
+        vm.load_paths = [File.expand_path('../../lib', __FILE__)]
+        vm.environment = ENV.merge('RACK_ENV' => environment.to_s)
+
+        # This ensures processing of RUBYOPT which activates Bundler
+        vm.provider.ruby_instance_config.process_arguments []
+        vm.argv = ['-s', server.to_s, '-o', '127.0.0.1', '-p', port.to_s, '-e', environment.to_s]
+
+        # Set stdout/stderr so we can retrieve log
+        @pipe = java.io.ByteArrayOutputStream.new
+        vm.output = java.io.PrintStream.new(@pipe)
+        vm.error  = java.io.PrintStream.new(@pipe)
+
+        Thread.new do
+          # Hack to ensure that Kernel#caller has the same info as
+          # when run from command-line, for Sintra::Application.app_file.
+          # Also, line numbers are zero-based in JRuby's parser
+          vm.provider.runtime.current_context.set_file_and_line(app_file, 0)
+          # Run the app
+          vm.run_scriptlet org.jruby.embed.PathType::ABSOLUTE, app_file
+          # terminate launches at_exit hooks which start server
+          vm.terminate
+        end
+      end
+
+      def run
+        return unless installed?
+        kill
+        @thread  = start_vm
+        @started = Time.now
+        warn "#{server} up and running on port #{port}" if ping
+        at_exit { kill }
+      end
+
+      def log
+        String.from_java_bytes @pipe.to_byte_array
+      end
+
+      def kill
+        @thread.kill if @thread
+        @thread = nil
+      end
+    end
+    Server = JRubyServer
+  else
+    Server = BaseServer
+  end
+
+  def it(message, &block)
+    Server.each do |server|
+      next unless server.installed?
+      super "with #{server.name}: #{message}" do
+        self.server = server
+        server.run unless server.alive?
+        begin
+          instance_eval(&block)
+        rescue Exception => error
+          server.kill
+          raise error
+        end
+      end
+    end
+  end
+
+  def self.extend_object(obj)
+    super
+
+    base_port = 5000 + Process.pid % 100
+    Sinatra::Base.server.each_with_index do |server, index|
+      Server.run(server, 5000+index)
+    end
+  end
+end

data/test/integration_test.rb

@@ -0,0 +1,82 @@
+require File.expand_path('../helper', __FILE__)
+require File.expand_path('../integration_helper', __FILE__)
+require 'timeout'
+
+# These tests start a real server and talk to it over TCP.
+# Every test runs with every detected server.
+#
+# See test/integration/app.rb for the code of the app we test against.
+class IntegrationTest < Test::Unit::TestCase
+  extend IntegrationHelper
+  attr_accessor :server
+
+  it('sets the app_file') { assert_equal server.app_file, server.get("/app_file") }
+  it('only extends main') { assert_equal "true", server.get("/mainonly") }
+
+  it 'logs once in development mode' do
+    random = "%064x" % Kernel.rand(2**256-1)
+    server.get "/ping?x=#{random}"
+    count = server.log.scan("GET /ping?x=#{random}").count
+    server.webrick? ? assert(count > 0) : assert_equal(1, count)
+  end
+
+  it 'streams' do
+    next if server.webrick?
+    times, chunks = [Time.now], []
+    server.get_stream do |chunk|
+      next if chunk.empty?
+      chunks << chunk
+      times << Time.now
+    end
+    assert_equal ["a", "b"], chunks
+    assert times[1] - times[0] < 1
+    assert times[2] - times[1] > 1
+  end
+
+  it 'streams async' do
+    next unless server.name == 'thin'
+
+    Timeout.timeout(3) do
+      chunks = []
+      server.get_stream '/async' do |chunk|
+        next if chunk.empty?
+        chunks << chunk
+        case chunk
+        when "hi!"   then server.get "/send?msg=hello"
+        when "hello" then server.get "/send?close=1"
+        end
+      end
+
+      assert_equal ['hi!', 'hello'], chunks
+    end
+  end
+
+  it 'streams async from subclass' do
+    next unless server.name == 'thin'
+
+    Timeout.timeout(3) do
+      chunks = []
+      server.get_stream '/subclass/async' do |chunk|
+        next if chunk.empty?
+        chunks << chunk
+        case chunk
+        when "hi!"   then server.get "/subclass/send?msg=hello"
+        when "hello" then server.get "/subclass/send?close=1"
+        end
+      end
+
+      assert_equal ['hi!', 'hello'], chunks
+    end
+  end
+
+
+  it 'starts the correct server' do
+    exp = %r{
+      ==\sSinatra/#{Sinatra::VERSION}\s
+      has\staken\sthe\sstage\son\s\d+\sfor\sdevelopment\s
+      with\sbackup\sfrom\s#{server}
+    }ix
+
+    assert_match exp, server.log
+  end
+end

data/test/less_test.rb

@@ -1,31 +1,57 @@
-require File.dirname(__FILE__) + '/helper'
+require File.expand_path('../helper', __FILE__)
+
+begin
 require 'less'
 
 class LessTest < Test::Unit::TestCase
-  def less_app(&block)
+  def less_app(options = {}, &block)
     mock_app {
       set :views, File.dirname(__FILE__) + '/views'
+      set options
       get '/', &block
     }
     get '/'
   end
 
   it 'renders inline Less strings' do
-    less_app { less "@white_color: #fff; #main { background-color: @white_color }"}
+    less_app { less "@white_color: #fff; #main { background-color: @white_color }" }
+    assert ok?
+    assert_equal "#main{background-color:#ffffff;}", body.gsub(/\s/, "")
+  end
+
+  it 'defaults content type to css' do
+    less_app { less "@white_color: #fff; #main { background-color: @white_color }" }
+    assert ok?
+    assert_equal "text/css;charset=utf-8", response['Content-Type']
+  end
+
+  it 'defaults allows setting content type per route' do
+    less_app do
+      content_type :html
+      less "@white_color: #fff; #main { background-color: @white_color }"
+    end
+    assert ok?
+    assert_equal "text/html;charset=utf-8", response['Content-Type']
+  end
+
+  it 'defaults allows setting content type globally' do
+    less_app(:less => { :content_type => 'html' }) do
+      less "@white_color: #fff; #main { background-color: @white_color }"
+    end
     assert ok?
-    assert_equal "#main { background-color: #ffffff; }\n", body
+    assert_equal "text/html;charset=utf-8", response['Content-Type']
   end
 
   it 'renders .less files in views path' do
     less_app { less :hello }
     assert ok?
-    assert_equal "#main { background-color: #ffffff; }\n", body
+    assert_equal "#main{background-color:#ffffff;}", body.gsub(/\s/, "")
   end
 
   it 'ignores the layout option' do
     less_app { less :hello, :layout => :layout2 }
     assert ok?
-    assert_equal "#main { background-color: #ffffff; }\n", body
+    assert_equal "#main{background-color:#ffffff;}", body.gsub(/\s/, "")
   end
 
   it "raises error if template not found" do
@@ -35,3 +61,7 @@ class LessTest < Test::Unit::TestCase
     assert_raise(Errno::ENOENT) { get('/') }
   end
 end
+
+rescue LoadError
+  warn "#{$!.to_s}: skipping less tests"
+end

data/test/liquid_test.rb

@@ -0,0 +1,59 @@
+require File.expand_path('../helper', __FILE__)
+
+begin
+require 'liquid'
+
+class LiquidTest < Test::Unit::TestCase
+  def liquid_app(&block)
+    mock_app do
+      set :views, File.dirname(__FILE__) + '/views'
+      get '/', &block
+    end
+    get '/'
+  end
+
+  it 'renders inline liquid strings' do
+    liquid_app { liquid '<h1>Hiya</h1>' }
+    assert ok?
+    assert_equal "<h1>Hiya</h1>", body
+  end
+
+  it 'renders .liquid files in views path' do
+    liquid_app { liquid :hello }
+    assert ok?
+    assert_equal "<h1>Hello From Liquid</h1>\n", body
+  end
+
+  it "renders with inline layouts" do
+    mock_app do
+      layout { "<h1>THIS. IS. {{ yield }}</h1>" }
+      get('/') { liquid '<EM>SPARTA</EM>' }
+    end
+    get '/'
+    assert ok?
+    assert_equal "<h1>THIS. IS. <EM>SPARTA</EM></h1>", body
+  end
+
+  it "renders with file layouts" do
+    liquid_app { liquid 'Hello World', :layout => :layout2 }
+    assert ok?
+    assert_equal "<h1>Liquid Layout!</h1>\n<p>Hello World</p>\n", body
+  end
+
+  it "raises error if template not found" do
+    mock_app { get('/') { liquid :no_such_template } }
+    assert_raise(Errno::ENOENT) { get('/') }
+  end
+  
+  it "allows passing locals" do
+    liquid_app do
+      liquid '{{ value }}', :locals => { :value => 'foo' }
+    end
+    assert ok?
+    assert_equal 'foo', body
+  end
+end
+
+rescue LoadError
+  warn "#{$!.to_s}: skipping liquid tests"
+end