RubyGems - torquebox-console - Versions diffs - 0.2.5 → 0.3.0 - Mend

torquebox-console 0.2.5 → 0.3.0

Files changed (1091) hide show

data/vendor/bundle/ruby/1.8/gems/sinatra-1.3.5/test/sinatra_test.rb DELETED

@@ -1,17 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-class SinatraTest < Test::Unit::TestCase
-  it 'creates a new Sinatra::Base subclass on new' do
-    app =
-      Sinatra.new do
-        get '/' do
-          'Hello World'
-        end
-      end
-    assert_same Sinatra::Base, app.superclass
-  end
-  it "responds to #template_cache" do
-    assert_kind_of Tilt::Cache, Sinatra::Base.new!.template_cache
-  end
-end

data/vendor/bundle/ruby/1.8/gems/sinatra-1.3.5/test/slim_test.rb DELETED

@@ -1,88 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-begin
-require 'slim'
-class SlimTest < Test::Unit::TestCase
-  def slim_app(&block)
-    mock_app {
-      set :views, File.dirname(__FILE__) + '/views'
-      get '/', &block
-    }
-    get '/'
-  end
-  it 'renders inline slim strings' do
-    slim_app { slim "h1 Hiya\n" }
-    assert ok?
-    assert_equal "<h1>Hiya</h1>", body
-  end
-  it 'renders .slim files in views path' do
-    slim_app { slim :hello }
-    assert ok?
-    assert_equal "<h1>Hello From Slim</h1>", body
-  end
-  it "renders with inline layouts" do
-    mock_app {
-      layout { %(h1\n  | THIS. IS. \n  == yield.upcase ) }
-      get('/') { slim 'em Sparta' }
-    }
-    get '/'
-    assert ok?
-    assert_equal "<h1>THIS. IS. <EM>SPARTA</EM></h1>", body
-  end
-  it "renders with file layouts" do
-    slim_app {
-      slim '| Hello World', :layout => :layout2
-    }
-    assert ok?
-    assert_equal "<h1>Slim Layout!</h1><p>Hello World</p>", body
-  end
-  it "raises error if template not found" do
-    mock_app {
-      get('/') { slim :no_such_template }
-    }
-    assert_raise(Errno::ENOENT) { get('/') }
-  end
-  HTML4_DOCTYPE = "<!DOCTYPE html PUBLIC \"-//W3C//DTD HTML 4.01 Transitional//EN\" \"http://www.w3.org/TR/html4/loose.dtd\">"
-  it "passes slim options to the slim engine" do
-    mock_app { get('/') { slim "x foo='bar'", :attr_wrapper => "'" }}
-    get '/'
-    assert ok?
-    assert_body "<x foo='bar'></x>"
-  end
-  it "passes default slim options to the slim engine" do
-    mock_app do
-      set :slim, :attr_wrapper => "'"
-      get('/') { slim "x foo='bar'" }
-    end
-    get '/'
-    assert ok?
-    assert_body "<x foo='bar'></x>"
-  end
-  it "merges the default slim options with the overrides and passes them to the slim engine" do
-    mock_app do
-      set :slim, :attr_wrapper => "'"
-      get('/') { slim "x foo='bar'" }
-      get('/other') { slim "x foo='bar'", :attr_wrapper => '"' }
-    end
-    get '/'
-    assert ok?
-    assert_body "<x foo='bar'></x>"
-    get '/other'
-    assert ok?
-    assert_body '<x foo="bar"></x>'
-  end
-end
-rescue LoadError
-  warn "#{$!.to_s}: skipping slim tests"
-end

data/vendor/bundle/ruby/1.8/gems/sinatra-1.3.5/test/static_test.rb DELETED

@@ -1,178 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-class StaticTest < Test::Unit::TestCase
-  setup do
-    mock_app {
-      set :static, true
-      set :public_folder, File.dirname(__FILE__)
-    }
-  end
-  it 'serves GET requests for files in the public directory' do
-    get "/#{File.basename(__FILE__)}"
-    assert ok?
-    assert_equal File.read(__FILE__), body
-    assert_equal File.size(__FILE__).to_s, response['Content-Length']
-    assert response.headers.include?('Last-Modified')
-  end
-  it 'produces a body that can be iterated over multiple times' do
-    env = Rack::MockRequest.env_for("/#{File.basename(__FILE__)}")
-    status, headers, body = @app.call(env)
-    buf1, buf2 = [], []
-    body.each { |part| buf1 << part }
-    body.each { |part| buf2 << part }
-    assert_equal buf1.join, buf2.join
-    assert_equal File.read(__FILE__), buf1.join
-  end
-  it 'sets the sinatra.static_file env variable if served' do
-    env = Rack::MockRequest.env_for("/#{File.basename(__FILE__)}")
-    status, headers, body = @app.call(env)
-    assert_equal File.expand_path(__FILE__), env['sinatra.static_file']
-  end
-  it 'serves HEAD requests for files in the public directory' do
-    head "/#{File.basename(__FILE__)}"
-    assert ok?
-    assert_equal '', body
-    assert response.headers.include?('Last-Modified')
-    assert_equal File.size(__FILE__).to_s, response['Content-Length']
-  end
-  %w[POST PUT DELETE].each do |verb|
-    it "does not serve #{verb} requests" do
-      send verb.downcase, "/#{File.basename(__FILE__)}"
-      assert_equal 404, status
-    end
-  end
-  it 'serves files in preference to custom routes' do
-    @app.get("/#{File.basename(__FILE__)}") { 'Hello World' }
-    get "/#{File.basename(__FILE__)}"
-    assert ok?
-    assert body != 'Hello World'
-  end
-  it 'does not serve directories' do
-    get "/"
-    assert not_found?
-  end
-  it 'passes to the next handler when the static option is disabled' do
-    @app.set :static, false
-    get "/#{File.basename(__FILE__)}"
-    assert not_found?
-  end
-  it 'passes to the next handler when the public option is nil' do
-    @app.set :public_folder, nil
-    get "/#{File.basename(__FILE__)}"
-    assert not_found?
-  end
-  it '404s when a file is not found' do
-    get "/foobarbaz.txt"
-    assert not_found?
-  end
-  it 'serves files when .. path traverses within public directory' do
-    get "/data/../#{File.basename(__FILE__)}"
-    assert ok?
-    assert_equal File.read(__FILE__), body
-  end
-  it '404s when .. path traverses outside of public directory' do
-    mock_app {
-      set :static, true
-      set :public_folder, File.dirname(__FILE__) + '/data'
-    }
-    get "/../#{File.basename(__FILE__)}"
-    assert not_found?
-  end
-  def assert_valid_range(http_range, range, path, file)
-    request = Rack::MockRequest.new(@app)
-    response = request.get("/#{File.basename(path)}", 'HTTP_RANGE' => http_range)
-    should_be = file[range]
-    expected_range = "bytes #{range.begin}-#{range.end}/#{file.length}"
-    assert_equal 206,response.status, "Should be HTTP/1.1 206 Partial content"
-    assert_equal should_be.length, response.body.length, "Unexpected response length for #{http_range}"
-    assert_equal should_be, response.body, "Unexpected response data for #{http_range}"
-    assert_equal should_be.length.to_s, response['Content-Length'], "Incorrect Content-Length for #{http_range}"
-    assert_equal expected_range, response['Content-Range'], "Incorrect Content-Range for #{http_range}"
-  end
-  it 'handles valid byte ranges correctly' do
-    # Use the biggest file in this dir so we can test ranges > 8k bytes. (StaticFile sends in 8k chunks.)
-    path = File.dirname(__FILE__) + '/helpers_test.rb'  # currently 16k bytes
-    file = File.read(path)
-    length = file.length
-    assert length > 9000, "The test file #{path} is too short (#{length} bytes) to run these tests"
-    [0..0, 42..88, 1234..1234, 100..9000, 0..(length-1), (length-1)..(length-1)].each do |range|
-      assert_valid_range("bytes=#{range.begin}-#{range.end}", range, path, file)
-    end
-    [0, 100, length-100, length-1].each do |start|
-      assert_valid_range("bytes=#{start}-", (start..length-1), path, file)
-    end
-    [1, 100, length-100, length-1, length].each do |range_length|
-      assert_valid_range("bytes=-#{range_length}", (length-range_length..length-1), path, file)
-    end
-    # Some valid ranges that exceed the length of the file:
-    assert_valid_range("bytes=100-999999", (100..length-1), path, file)
-    assert_valid_range("bytes=100-#{length}", (100..length-1), path, file)
-    assert_valid_range("bytes=-#{length}", (0..length-1), path, file)
-    assert_valid_range("bytes=-#{length+1}", (0..length-1), path, file)
-    assert_valid_range("bytes=-999999", (0..length-1), path, file)
-  end
-  it 'correctly ignores syntactically invalid range requests' do
-    # ...and also ignores multi-range requests, which aren't supported yet
-    ["bytes=45-40", "bytes=IV-LXVI", "octets=10-20", "bytes=-", "bytes=1-2,3-4"].each do |http_range|
-      request = Rack::MockRequest.new(@app)
-      response = request.get("/#{File.basename(__FILE__)}", 'HTTP_RANGE' => http_range)
-      assert_equal 200,response.status, "Invalid range '#{http_range}' should be ignored"
-      assert_equal nil,response['Content-Range'], "Invalid range '#{http_range}' should be ignored"
-    end
-  end
-  it 'returns error 416 for unsatisfiable range requests' do
-    # An unsatisfiable request is one that specifies a start that's at or past the end of the file.
-    length = File.read(__FILE__).length
-    ["bytes=888888-", "bytes=888888-999999", "bytes=#{length}-#{length}"].each do |http_range|
-      request = Rack::MockRequest.new(@app)
-      response = request.get("/#{File.basename(__FILE__)}", 'HTTP_RANGE' => http_range)
-      assert_equal 416,response.status, "Unsatisfiable range '#{http_range}' should return 416"
-      assert_equal "bytes */#{length}",response['Content-Range'], "416 response should include actual length"
-    end
-  end
-  it 'does not include static cache control headers by default' do
-    env = Rack::MockRequest.env_for("/#{File.basename(__FILE__)}")
-    status, headers, body = @app.call(env)
-    assert !headers.has_key?('Cache-Control')
-  end
-  it 'sets cache control headers on static files if set' do
-    @app.set :static_cache_control, :public
-    env = Rack::MockRequest.env_for("/#{File.basename(__FILE__)}")
-    status, headers, body = @app.call(env)
-    assert headers.has_key?('Cache-Control')
-    assert_equal headers['Cache-Control'], 'public'
-    @app.set :static_cache_control, [:public, :must_revalidate, {:max_age => 300}]
-    env = Rack::MockRequest.env_for("/#{File.basename(__FILE__)}")
-    status, headers, body = @app.call(env)
-    assert headers.has_key?('Cache-Control')
-    assert_equal headers['Cache-Control'], 'public, must-revalidate, max-age=300'
-  end
-end

data/vendor/bundle/ruby/1.8/gems/sinatra-1.3.5/test/streaming_test.rb DELETED

@@ -1,140 +0,0 @@
-require File.expand_path('../helper', __FILE__)
-class StreamingTest < Test::Unit::TestCase
-  Stream = Sinatra::Helpers::Stream
-  it 'returns the concatinated body' do
-    mock_app do
-      get '/' do
-        stream do |out|
-          out << "Hello" << " "
-          out << "World!"
-        end
-      end
-    end
-    get('/')
-    assert_body "Hello World!"
-  end
-  it 'always yields strings' do
-    stream = Stream.new { |out| out << :foo }
-    stream.each { |str| assert_equal 'foo', str }
-  end
-  it 'postpones body generation' do
-    step = 0
-    stream = Stream.new do |out|
-      10.times do
-        out << step
-        step += 1
-      end
-    end
-    stream.each do |s|
-      assert_equal s, step.to_s
-      step += 1
-    end
-  end
-  it 'calls the callback after it is done' do
-    step   = 0
-    final  = 0
-    stream = Stream.new { |o| 10.times { step += 1 }}
-    stream.callback { final = step }
-    stream.each { |str| }
-    assert_equal 10, final
-  end
-  it 'does not trigger the callback if close is set to :keep_open' do
-    step   = 0
-    final  = 0
-    stream = Stream.new(Stream, :keep_open) { |o| 10.times { step += 1 } }
-    stream.callback { final = step }
-    stream.each { |str| }
-    assert_equal 0, final
-  end
-  it 'allows adding more than one callback' do
-    a = b = false
-    stream = Stream.new { }
-    stream.callback { a = true }
-    stream.callback { b = true }
-    stream.each { |str| }
-    assert a, 'should trigger first callback'
-    assert b, 'should trigger second callback'
-  end
-  class MockScheduler
-    def initialize(*)     @schedule, @defer = [], []                end
-    def schedule(&block)  @schedule << block                        end
-    def defer(&block)     @defer    << block                        end
-    def schedule!(*)      @schedule.pop.call until @schedule.empty? end
-    def defer!(*)         @defer.pop.call    until @defer.empty?    end
-  end
-  it 'allows dropping in another scheduler' do
-    scheduler  = MockScheduler.new
-    processing = sending = done = false
-    stream = Stream.new(scheduler) do |out|
-      processing = true
-      out << :foo
-    end
-    stream.each { sending = true}
-    stream.callback { done = true }
-    scheduler.schedule!
-    assert !processing
-    assert !sending
-    assert !done
-    scheduler.defer!
-    assert processing
-    assert !sending
-    assert !done
-    scheduler.schedule!
-    assert sending
-    assert done
-  end
-  it 'schedules exceptions to be raised on the main thread/event loop/...' do
-    scheduler = MockScheduler.new
-    Stream.new(scheduler) { fail 'should be caught' }.each { }
-    scheduler.defer!
-    assert_raise(RuntimeError) { scheduler.schedule! }
-  end
-  it 'does not trigger an infinite loop if you call close in a callback' do
-    stream = Stream.new { |out| out.callback { out.close }}
-    stream.each { |str| }
-  end
-  it 'gives access to route specific params' do
-    mock_app do
-      get('/:name') { stream { |o| o << params[:name] }}
-    end
-    get '/foo'
-    assert_body 'foo'
-  end
-  it 'sets up async.close if available' do
-    ran = false
-    mock_app do
-      get('/') do
-        close = Object.new
-        def close.callback; yield end
-        def close.errback; end
-        env['async.close'] = close
-        stream(:keep_open) do |out|
-          out.callback { ran = true }
-        end
-      end
-    end
-    get '/'
-    assert ran
-  end
-end

data/vendor/bundle/ruby/1.8/gems/sinatra-1.3.5/test/templates_test.rb DELETED

@@ -1,298 +0,0 @@
-# encoding: UTF-8
-require File.expand_path('../helper', __FILE__)
-File.delete(File.dirname(__FILE__) + '/views/layout.test') rescue nil
-class TestTemplate < Tilt::Template
-  def prepare
-  end
-  def evaluate(scope, locals={}, &block)
-    inner = block ? block.call : ''
-    data + inner
-  end
-  Tilt.register 'test', self
-end
-class TemplatesTest < Test::Unit::TestCase
-  def render_app(base=Sinatra::Base, options = {}, &block)
-    base, options = Sinatra::Base, base if base.is_a? Hash
-    mock_app(base) {
-      set :views, File.dirname(__FILE__) + '/views'
-      set options
-      get '/', &block
-      template(:layout3) { "Layout 3!\n" }
-    }
-    get '/'
-  end
-  def with_default_layout
-    layout = File.dirname(__FILE__) + '/views/layout.test'
-    File.open(layout, 'wb') { |io| io.write "Layout!\n" }
-    yield
-  ensure
-    File.unlink(layout) rescue nil
-  end
-  it 'renders String templates directly' do
-    render_app { render :test, 'Hello World' }
-    assert ok?
-    assert_equal 'Hello World', body
-  end
-  it 'renders Proc templates using the call result' do
-    render_app { render :test, Proc.new {'Hello World'} }
-    assert ok?
-    assert_equal 'Hello World', body
-  end
-  it 'looks up Symbol templates in views directory' do
-    render_app { render :test, :hello }
-    assert ok?
-    assert_equal "Hello World!\n", body
-  end
-  it 'uses the default layout template if not explicitly overridden' do
-    with_default_layout do
-      render_app { render :test, :hello }
-      assert ok?
-      assert_equal "Layout!\nHello World!\n", body
-    end
-  end
-  it 'uses the default layout template if not really overriden' do
-    with_default_layout do
-      render_app { render :test, :hello, :layout => true }
-      assert ok?
-      assert_equal "Layout!\nHello World!\n", body
-    end
-  end
-  it 'uses the layout template specified' do
-    render_app { render :test, :hello, :layout => :layout2 }
-    assert ok?
-    assert_equal "Layout 2!\nHello World!\n", body
-  end
-  it 'uses layout templates defined with the #template method' do
-    render_app { render :test, :hello, :layout => :layout3 }
-    assert ok?
-    assert_equal "Layout 3!\nHello World!\n", body
-  end
-  it 'avoids wrapping layouts around nested templates' do
-    render_app { render :str, :nested, :layout => :layout2 }
-    assert ok?
-    assert_equal "<h1>String Layout!</h1>\n<content><h1>Hello From String</h1></content>", body
-  end
-  it 'allows explicitly wrapping layouts around nested templates' do
-    render_app { render :str, :explicitly_nested, :layout => :layout2 }
-    assert ok?
-    assert_equal "<h1>String Layout!</h1>\n<content><h1>String Layout!</h1>\n<h1>Hello From String</h1></content>", body
-  end
-  it 'two independent render calls do not disable layouts' do
-    render_app do
-      render :str, :explicitly_nested, :layout => :layout2
-      render :str, :nested, :layout => :layout2
-    end
-    assert ok?
-    assert_equal "<h1>String Layout!</h1>\n<content><h1>Hello From String</h1></content>", body
-  end
-  it 'is possible to use partials in layouts' do
-    render_app do
-      settings.layout { "<%= erb 'foo' %><%= yield %>" }
-      erb 'bar'
-    end
-    assert ok?
-    assert_equal "foobar", body
-  end
-  it 'loads templates from source file' do
-    mock_app { enable :inline_templates }
-    assert_equal "this is foo\n\n", @app.templates[:foo][0]
-    assert_equal "X\n= yield\nX\n", @app.templates[:layout][0]
-  end
-  it 'ignores spaces after names of inline templates' do
-    mock_app { enable :inline_templates }
-    assert_equal "There's a space after 'bar'!\n\n", @app.templates[:bar][0]
-    assert_equal "this is not foo\n\n", @app.templates[:"foo bar"][0]
-  end
-  it 'loads templates from given source file' do
-    mock_app { set :inline_templates, __FILE__ }
-    assert_equal "this is foo\n\n", @app.templates[:foo][0]
-  end
-  test 'inline_templates ignores IO errors' do
-    assert_nothing_raised {
-      mock_app {
-        set :inline_templates, '/foo/bar'
-      }
-    }
-    assert @app.templates.empty?
-  end
-  it 'allows unicode in inline templates' do
-    mock_app { set :inline_templates, __FILE__ }
-    assert_equal "Den som tror at hemma det är där man bor har aldrig vart hos mig.\n\n",
-      @app.templates[:umlaut][0]
-  end
-  it 'loads templates from specified views directory' do
-    render_app { render :test, :hello, :views => settings.views + '/foo' }
-    assert_equal "from another views directory\n", body
-  end
-  it 'passes locals to the layout' do
-    mock_app {
-      template :my_layout do
-        'Hello <%= name %>!<%= yield %>'
-      end
-      get '/' do
-        erb '<p>content</p>', { :layout => :my_layout }, { :name => 'Mike'}
-      end
-    }
-    get '/'
-    assert ok?
-    assert_equal 'Hello Mike!<p>content</p>', body
-  end
-  it 'loads templates defined in subclasses' do
-    base = Class.new(Sinatra::Base)
-    base.template(:foo) { 'bar' }
-    render_app(base) { render :test, :foo }
-    assert ok?
-    assert_equal 'bar', body
-  end
-  it 'allows setting default content type per template engine' do
-    render_app(:str => { :content_type => :txt }) { render :str, 'foo' }
-    assert_equal 'text/plain;charset=utf-8', response['Content-Type']
-  end
-  it 'setting default content type does not affect other template engines' do
-    render_app(:str => { :content_type => :txt }) { render :test, 'foo' }
-    assert_equal 'text/html;charset=utf-8', response['Content-Type']
-  end
-  it 'setting default content type per template engine does not override content_type' do
-    render_app :str => { :content_type => :txt } do
-      content_type :html
-      render :str, 'foo'
-    end
-    assert_equal 'text/html;charset=utf-8', response['Content-Type']
-  end
-  it 'uses templates in superclasses before subclasses' do
-    base = Class.new(Sinatra::Base)
-    base.template(:foo) { 'template in superclass' }
-    assert_equal 'template in superclass', base.templates[:foo].first.call
-    mock_app(base) {
-      set :views, File.dirname(__FILE__) + '/views'
-      template(:foo) { 'template in subclass' }
-      get('/') { render :test, :foo }
-    }
-    assert_equal 'template in subclass', @app.templates[:foo].first.call
-    get '/'
-    assert ok?
-    assert_equal 'template in subclass', body
-  end
-  it "is possible to use a different engine for the layout than for the template itself explicitely" do
-    render_app do
-      settings.template(:layout) { 'Hello <%= yield %>!' }
-      render :str, "<%= 'World' %>", :layout_engine => :erb
-    end
-    assert_equal "Hello <%= 'World' %>!", body
-  end
-  it "is possible to use a different engine for the layout than for the template itself globally" do
-    render_app :str => { :layout_engine => :erb } do
-      settings.template(:layout) { 'Hello <%= yield %>!' }
-      render :str, "<%= 'World' %>"
-    end
-    assert_equal "Hello <%= 'World' %>!", body
-  end
-  it "does not leak the content type to the template" do
-    render_app :str => { :layout_engine => :erb } do
-      settings.template(:layout) { 'Hello <%= yield %>!' }
-      render :str, "<%= 'World' %>", :content_type => :txt
-    end
-    assert_equal "text/html;charset=utf-8", headers['Content-Type']
-  end
-  it "is possible to register another template" do
-    Tilt.register "html.erb", Tilt[:erb]
-    render_app { render :erb, :calc }
-    assert_equal '2', body
-  end
-  it "passes scope to the template" do
-    mock_app do
-      template :scoped do
-        'Hello <%= foo %>'
-      end
-      get '/' do
-        some_scope = Object.new
-        def some_scope.foo() 'World!' end
-        erb :scoped, :scope => some_scope
-      end
-    end
-    get '/'
-    assert ok?
-    assert_equal 'Hello World!', body
-  end
-  it "is possible to use custom logic for finding template files" do
-    mock_app do
-      set :views, ["a", "b"].map { |d| File.dirname(__FILE__) + '/views/' + d }
-      def find_template(views, name, engine, &block)
-        Array(views).each { |v| super(v, name, engine, &block) }
-      end
-      get('/:name') do
-        render :str, params[:name].to_sym
-      end
-    end
-    get '/in_a'
-    assert_body 'Gimme an A!'
-    get '/in_b'
-    assert_body 'Gimme a B!'
-  end
-end
-# __END__ : this is not the real end of the script.
-__END__
-@@ foo
-this is foo
-@@ bar
-There's a space after 'bar'!
-@@ foo bar
-this is not foo
-@@ umlaut
-Den som tror at hemma det är där man bor har aldrig vart hos mig.
-@@ layout
-X
-= yield
-X