sinatra 1.4.8 → 2.0.0

data/test/integration/app.rb

@@ -1,79 +0,0 @@
-$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

@@ -1,236 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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 < Minitest::Test
-  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\s\(v#{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_raises(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

@@ -1,69 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-begin
-require 'less'
-
-class LessTest < Minitest::Test
-  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_raises(Errno::ENOENT) { get('/') }
-  end
-end
-
-rescue LoadError
-  warn "#{$!.to_s}: skipping less tests"
-end

data/test/liquid_test.rb

@@ -1,77 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-
-begin
-require 'liquid'
-
-class LiquidTest < Minitest::Test
-  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_raises(Errno::ENOENT) { get('/') }
-  end
-
-  it "allows passing locals" do
-    liquid_app {
-      liquid '{{ value }}', :locals => { :value => 'foo' }
-    }
-    assert ok?
-    assert_equal 'foo', body
-  end
-
-  it "can render truly nested layouts by accepting a layout and a block with the contents" do
-    mock_app do
-      template(:main_outer_layout) { "<h1>Title</h1>\n{{ yield }}" }
-      template(:an_inner_layout) { "<h2>Subtitle</h2>\n{{ yield }}" }
-      template(:a_page) { "<p>Contents.</p>\n" }
-      get('/') do
-        liquid :main_outer_layout, :layout => false do
-          liquid :an_inner_layout do
-            liquid :a_page
-          end
-        end
-      end
-    end
-    get '/'
-    assert ok?
-    assert_body "<h1>Title</h1>\n<h2>Subtitle</h2>\n<p>Contents.</p>\n"
-  end
-end
-
-rescue LoadError
-  warn "#{$!.to_s}: skipping liquid tests"
-end