sinatra-acd 1.4.5

data/test/integration/app.rb

@@ -0,0 +1,79 @@
+$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
+
+get '/send_file' do
+  file = File.expand_path '../../views/a/in_a.str', __FILE__
+  send_file file
+end
+
+get '/streaming' do
+  headers['Content-Length'] = '46'
+  stream do |out|
+    out << "It's gonna be legen -\n"
+    sleep 0.5
+    out << " (wait for it) \n"
+    puts headers
+    sleep 1
+    out << "- dary!\n"
+  end
+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,236 @@
+require 'sinatra/base'
+require 'rbconfig'
+require 'open-uri'
+require 'net/http'
+require 'timeout'
+
+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 ping(timeout = 30)
+      loop do
+        return if alive?
+        if Time.now - @started > timeout
+          $stderr.puts command, log
+          fail "timeout"
+        else
+          sleep 0.1
+        end
+      end
+    end
+
+    def alive?
+      3.times { get('/ping') }
+      true
+    rescue Errno::ECONNREFUSED, Errno::ECONNRESET, EOFError, SystemCallError, OpenURI::HTTPError, Timeout::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_response(url)
+      Net::HTTP.start '127.0.0.1', port do |http|
+        request = Net::HTTP::Get.new url
+        http.request request do |response|
+          response
+        end
+      end
+    end
+
+    def get(url)
+      Timeout.timeout(1) { 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?
+      s = server == 'HTTP' ? 'net/http/server' : server
+      require s
+      @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 << "-w" unless thin? || net_http_server?
+        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
+
+    def thin?
+      name.to_s == "thin"
+    end
+
+    def puma?
+      name.to_s == "puma"
+    end
+
+    def trinidad?
+      name.to_s == "trinidad"
+    end
+
+    def net_http_server?
+      name.to_s == 'HTTP'
+    end
+
+    def warnings
+      log.scan(%r[(?:\(eval|lib/sinatra).*warning:.*$])
+    end
+
+    def run_test(target, &block)
+      retries ||= 3
+      target.server = self
+      run unless alive?
+      target.instance_eval(&block)
+    rescue Exception => error
+      retries -= 1
+      kill
+      retries < 0 ? retry : raise(error)
+    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 Sinatra::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}") { server.run_test(self, &block) }
+    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, base_port+index)
+    end
+  end
+end

data/test/integration_test.rb

@@ -0,0 +1,104 @@
+require File.expand_path('../helper', __FILE__)
+require File.expand_path('../integration_helper', __FILE__)
+
+# 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
+    next if server.puma? or RUBY_ENGINE == 'jruby'
+    random = "%064x" % Kernel.rand(2**256-1)
+    server.get "/ping?x=#{random}"
+    count = server.log.scan("GET /ping?x=#{random}").count
+    if server.net_http_server?
+      assert_equal 0, count
+    elsif server.webrick?
+      assert(count > 0)
+    else
+      assert_equal(1, count)
+    end
+  end
+
+  it 'streams' do
+    next if server.webrick? or server.trinidad?
+    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.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.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
+
+    # because Net HTTP Server logs to $stderr by default
+    assert_match exp, server.log unless server.net_http_server?
+  end
+
+  it 'does not generate warnings' do
+    assert_raise(OpenURI::HTTPError) { server.get '/' }
+    server.get '/app_file'
+    assert_equal [], server.warnings
+  end
+
+  it 'sets the Content-Length response header when sending files' do
+    response = server.get_response '/send_file'
+    assert response['Content-Length']
+  end
+
+  it "doesn't ignore Content-Length header when streaming" do
+    response = server.get_response '/streaming'
+    assert_equal '46', response['Content-Length']
+  end
+end

data/test/less_test.rb

@@ -0,0 +1,69 @@
+require File.expand_path('../helper', __FILE__)
+
+begin
+require 'less'
+
+class LessTest < Test::Unit::TestCase
+  def less_app(options = {}, &block)
+    mock_app do
+      set :views, File.dirname(__FILE__) + '/views'
+      set options
+      get('/', &block)
+    end
+    get '/'
+  end
+
+  it 'renders inline Less strings' do
+    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 "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;}", body.gsub(/\s/, "")
+  end
+
+  it 'ignores the layout option' do
+    less_app { less :hello, :layout => :layout2 }
+    assert ok?
+    assert_equal "#main{background-color:#ffffff;}", body.gsub(/\s/, "")
+  end
+
+  it "raises error if template not found" do
+    mock_app { get('/') { less :no_such_template } }
+    assert_raise(Errno::ENOENT) { get('/') }
+  end
+end
+
+rescue LoadError
+  warn "#{$!.to_s}: skipping less tests"
+end