sinatra-contrib 2.0.0.rc1 → 2.0.0.rc2

data/spec/required_params_spec.rb

@@ -1,68 +0,0 @@
-require_relative 'spec_helper'
-
-describe Sinatra::RequiredParams do
-  context "#required_params" do
-    context "simple keys" do
-      before do
-        mock_app do
-          helpers Sinatra::RequiredParams
-          get('/') { required_params(:p1, :p2) }
-        end
-      end
-      it 'return 400 if required params do not exist' do
-        get('/')
-        expect(last_response.status).to eq(400)
-      end
-      it 'return 400 if required params do not exist partially' do
-        get('/', :p1 => 1)
-        expect(last_response.status).to eq(400)
-      end
-      it 'return 200 if required params exist' do
-        get('/', :p1 => 1, :p2 => 2)
-        expect(last_response.status).to eq(200)
-      end
-      it 'return 200 if required params exist with array' do
-        get('/', :p1 => 1, :p2 => [31, 32, 33])
-        expect(last_response.status).to eq(200)
-      end
-    end
-    context "hash keys" do
-      before do
-        mock_app do
-          helpers Sinatra::RequiredParams
-          get('/') { required_params(:p1, :p2 => :p21) }
-        end
-      end
-      it 'return 400 if required params do not exist' do
-        get('/')
-        expect(last_response.status).to eq(400)
-      end
-      it 'return 200 if required params exist' do
-        get('/', :p1 => 1, :p2 => {:p21 => 21})
-        expect(last_response.status).to eq(200)
-      end
-    end
-    context "complex keys" do
-      before do
-        mock_app do
-          helpers Sinatra::RequiredParams
-          get('/') { required_params(:p1 => [:p11, {:p12 => :p121, :p122 => [:p123, {:p124 => :p1241}]}]) }
-        end
-      end
-      it 'return 400 if required params do not exist' do
-        get('/')
-        expect(last_response.status).to eq(400)
-      end
-      it 'return 200 if required params exist' do
-        get('/', :p1 => {:p11 => 11, :p12 => {:p121 => 121}, :p122 => {:p123 => 123, :p124 => {:p1241 => 1241}}})
-        expect(last_response.status).to eq(200)
-      end
-    end
-  end
-
-  context "#_required_params" do
-    it "is invisible" do
-      expect { _required_params }.to raise_error(NameError)
-    end
-  end
-end

data/spec/respond_with/bar.erb

@@ -1 +0,0 @@
-guten Tag!

data/spec/respond_with/bar.json.erb

@@ -1 +0,0 @@
-json!

data/spec/respond_with/baz.yajl

@@ -1 +0,0 @@
-json = "yajl!"

data/spec/respond_with/foo.html.erb

@@ -1 +0,0 @@
-Hello <%= name %>!

data/spec/respond_with/not_html.sass

@@ -1,2 +0,0 @@
-body
-  color: red

data/spec/respond_with_spec.rb

@@ -1,317 +0,0 @@
-require 'multi_json'
-
-require 'spec_helper'
-require 'okjson'
-
-describe Sinatra::RespondWith do
-  def provides(*args)
-    @provides = args
-  end
-
-  def respond_app(&block)
-    types = @provides
-    mock_app do
-      set :app_file, __FILE__
-      set :views, root + '/respond_with'
-      register Sinatra::RespondWith
-      respond_to(*types) if types
-      class_eval(&block)
-    end
-  end
-
-  def respond_to(*args, &block)
-    respond_app { get('/') { respond_to(*args, &block) } }
-  end
-
-  def respond_with(*args, &block)
-    respond_app { get('/') { respond_with(*args, &block) } }
-  end
-
-  def req(*types)
-    p = types.shift if types.first.is_a? String and types.first.start_with? '/'
-    accept = types.map { |t| Sinatra::Base.mime_type(t).to_s }.join ','
-    get (p || '/'), {}, 'HTTP_ACCEPT' => accept
-  end
-
-  describe "Helpers#respond_to" do
-    it 'allows defining handlers by file extensions' do
-      respond_to do |format|
-        format.html { "html!" }
-        format.json { "json!" }
-      end
-
-      expect(req(:html).body).to eq("html!")
-      expect(req(:json).body).to eq("json!")
-    end
-
-    it 'respects quality' do
-      respond_to do |format|
-        format.html { "html!" }
-        format.json { "json!" }
-      end
-
-      expect(req("text/html;q=0.7, application/json;q=0.3").body).to eq("html!")
-      expect(req("text/html;q=0.3, application/json;q=0.7").body).to eq("json!")
-    end
-
-    it 'allows using mime types' do
-      respond_to do |format|
-        format.on('text/html') { "html!" }
-        format.json { "json!" }
-      end
-
-      expect(req(:html).body).to eq("html!")
-    end
-
-    it 'allows using wildcards in format matchers' do
-      respond_to do |format|
-        format.on('text/*') { "text!" }
-        format.json { "json!" }
-      end
-
-      expect(req(:html).body).to eq("text!")
-    end
-
-    it 'allows using catch all wildcards in format matchers' do
-      respond_to do |format|
-        format.on('*/*') { "anything!" }
-        format.json { "json!" }
-      end
-
-      expect(req(:html).body).to eq("anything!")
-    end
-
-    it 'prefers concret over generic' do
-      respond_to do |format|
-        format.on('text/*') { "text!" }
-        format.on('*/*') { "anything!" }
-        format.json { "json!" }
-      end
-
-      expect(req(:json).body).to eq("json!")
-      expect(req(:html).body).to eq("text!")
-    end
-
-    it 'does not set up default handlers' do
-      respond_to
-      expect(req).not_to be_ok
-      expect(status).to eq(500)
-      expect(body).to eq("Unknown template engine")
-    end
-  end
-
-  describe "Helpers#respond_with" do
-    describe "matching" do
-      it 'allows defining handlers by file extensions' do
-        respond_with(:ignore) do |format|
-          format.html { "html!" }
-          format.json { "json!" }
-        end
-
-        expect(req(:html).body).to eq("html!")
-        expect(req(:json).body).to eq("json!")
-      end
-
-      it 'respects quality' do
-        respond_with(:ignore) do |format|
-          format.html { "html!" }
-          format.json { "json!" }
-        end
-
-        expect(req("text/html;q=0.7, application/json;q=0.3").body).to eq("html!")
-        expect(req("text/html;q=0.3, application/json;q=0.7").body).to eq("json!")
-      end
-
-      it 'allows using mime types' do
-        respond_with(:ignore) do |format|
-          format.on('text/html') { "html!" }
-          format.json { "json!" }
-        end
-
-        expect(req(:html).body).to eq("html!")
-      end
-
-      it 'allows using wildcards in format matchers' do
-        respond_with(:ignore) do |format|
-          format.on('text/*') { "text!" }
-          format.json { "json!" }
-        end
-
-        expect(req(:html).body).to eq("text!")
-      end
-
-      it 'allows using catch all wildcards in format matchers' do
-        respond_with(:ignore) do |format|
-          format.on('*/*') { "anything!" }
-          format.json { "json!" }
-        end
-
-        expect(req(:html).body).to eq("anything!")
-      end
-
-      it 'prefers concret over generic' do
-        respond_with(:ignore) do |format|
-          format.on('text/*') { "text!" }
-          format.on('*/*') { "anything!" }
-          format.json { "json!" }
-        end
-
-        expect(req(:json).body).to eq("json!")
-        expect(req(:html).body).to eq("text!")
-      end
-    end
-
-    describe "default behavior" do
-      it 'converts objects to json out of the box' do
-        respond_with 'a' => 'b'
-        expect(OkJson.decode(req(:json).body)).to eq({'a' => 'b'})
-      end
-
-      it 'handles multiple routes correctly' do
-        respond_app do
-          get('/') { respond_with 'a' => 'b' }
-          get('/:name') { respond_with 'a' => params[:name] }
-        end
-        expect(OkJson.decode(req('/',  :json).body)).to eq({'a' => 'b'})
-        expect(OkJson.decode(req('/b', :json).body)).to eq({'a' => 'b'})
-        expect(OkJson.decode(req('/c', :json).body)).to eq({'a' => 'c'})
-      end
-
-      it "calls to_EXT if available" do
-        respond_with Struct.new(:to_pdf).new("hello")
-        expect(req(:pdf).body).to eq("hello")
-      end
-
-      it 'results in a 500 if format cannot be produced' do
-        respond_with({})
-        expect(req(:html)).not_to be_ok
-        expect(status).to eq(500)
-        expect(body).to eq("Unknown template engine")
-      end
-    end
-
-    describe 'templates' do
-      it 'looks for templates with name.target.engine' do
-        respond_with :foo, :name => 'World'
-        expect(req(:html)).to be_ok
-        expect(body).to eq("Hello World!")
-      end
-
-      it 'looks for templates with name.engine for specific engines' do
-        respond_with :bar
-        expect(req(:html)).to be_ok
-        expect(body).to eq("guten Tag!")
-      end
-
-      it 'does not use name.engine for engines producing other formats' do
-        respond_with :not_html
-        expect(req(:html)).not_to be_ok
-        expect(status).to eq(500)
-        expect(body).to eq("Unknown template engine")
-      end
-
-      it 'falls back to #json if no template is found' do
-        respond_with :foo, :name => 'World'
-        expect(req(:json)).to be_ok
-        expect(OkJson.decode(body)).to eq({'name' => 'World'})
-      end
-
-      it 'favors templates over #json' do
-        respond_with :bar, :name => 'World'
-        expect(req(:json)).to be_ok
-        expect(body).to eq('json!')
-      end
-
-      it 'falls back to to_EXT if no template is found' do
-        object = {:name => 'World'}
-        def object.to_pdf; "hi" end
-        respond_with :foo, object
-        expect(req(:pdf)).to be_ok
-        expect(body).to eq("hi")
-      end
-
-      unless defined? JRUBY_VERSION
-        it 'uses yajl for json' do
-          respond_with :baz
-          expect(req(:json)).to be_ok
-          expect(body).to eq("\"yajl!\"")
-        end
-      end
-    end
-
-    describe 'customizing' do
-      it 'allows customizing' do
-        respond_with(:foo, :name => 'World') { |f| f.html { 'html!' }}
-        expect(req(:html)).to be_ok
-        expect(body).to eq("html!")
-      end
-
-      it 'falls back to default behavior if none matches' do
-        respond_with(:foo, :name => 'World') { |f| f.json { 'json!' }}
-        expect(req(:html)).to be_ok
-        expect(body).to eq("Hello World!")
-      end
-
-      it 'favors generic rule over default behavior' do
-        respond_with(:foo, :name => 'World') { |f| f.on('*/*') { 'generic!' }}
-        expect(req(:html)).to be_ok
-        expect(body).to eq("generic!")
-      end
-    end
-
-    describe "inherited" do
-      it "registers RespondWith in an inherited app" do
-        app = Sinatra.new do
-          set :app_file, __FILE__
-          set :views, root + '/respond_with'
-          register Sinatra::RespondWith
-
-          get '/a' do
-            respond_with :json
-          end
-        end
-
-        self.app = Sinatra.new(app)
-        expect(req('/a', :json)).not_to be_ok
-      end
-    end
-  end
-
-  describe :respond_to do
-    it 'acts as global provides condition' do
-      respond_app do
-        respond_to :json, :html
-        get('/a') { 'ok' }
-        get('/b') { 'ok' }
-      end
-
-      expect(req('/b', :xml)).not_to be_ok
-      expect(req('/b', :html)).to be_ok
-    end
-
-    it 'still allows provides' do
-      respond_app do
-        respond_to :json, :html
-        get('/a') { 'ok' }
-        get('/b', :provides => :json) { 'ok' }
-      end
-
-      expect(req('/b', :html)).not_to be_ok
-      expect(req('/b', :json)).to be_ok
-    end
-
-    it 'plays well with namespaces' do
-      respond_app do
-        register Sinatra::Namespace
-        namespace '/a' do
-          respond_to :json
-          get { 'json' }
-        end
-        get('/b') { 'anything' }
-      end
-
-      expect(req('/a', :html)).not_to be_ok
-      expect(req('/b', :html)).to be_ok
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,7 +0,0 @@
-ENV['RACK_ENV'] = 'test'
-require 'sinatra/contrib'
-
-RSpec.configure do |config|
-  config.expect_with :rspec
-  config.include Sinatra::TestHelpers
-end

data/spec/streaming_spec.rb

@@ -1,415 +0,0 @@
-require 'backports'
-require 'spec_helper'
-
-describe Sinatra::Streaming do
-  def stream(&block)
-    rack_middleware = @use
-    out = nil
-    mock_app do
-      rack_middleware.each { |args| use(*args) }
-      helpers Sinatra::Streaming
-      get('/') { out = stream(&block) }
-    end
-    get('/')
-    out
-  end
-
-  def use(*args)
-    @use << args
-  end
-
-  before do
-    @use = []
-  end
-
-  context 'stream test helper' do
-    it 'runs the given block' do
-      ran = false
-      stream { ran = true }
-      expect(ran).to be true
-    end
-
-    it 'returns the stream object' do
-      out = stream { }
-      expect(out).to be_a(Sinatra::Helpers::Stream)
-    end
-
-    it 'fires a request against that stream' do
-      stream { |out| out << "Hello World!" }
-      expect(last_response).to be_ok
-      expect(body).to eq("Hello World!")
-    end
-
-    it 'passes the stream object to the block' do
-      passed   = nil
-      returned = stream { |out| passed = out }
-      expect(passed).to eq(returned)
-    end
-  end
-
-  context Sinatra::Streaming::Stream do
-    it 'should extend the stream object' do
-      out = stream { }
-      expect(out).to be_a(Sinatra::Streaming::Stream)
-    end
-
-    it 'should not extend stream objects of other apps' do
-      out = nil
-      mock_app { get('/') { out = stream { }}}
-      get('/')
-      expect(out).to be_a(Sinatra::Helpers::Stream)
-      expect(out).not_to be_a(Sinatra::Streaming::Stream)
-    end
-  end
-
-  context 'app' do
-    it 'is the app instance the stream was created from' do
-      out = stream { }
-      expect(out.app).to be_a(Sinatra::Base)
-    end
-  end
-
-  context 'lineno' do
-    it 'defaults to 0' do
-      expect(stream { }.lineno).to eq(0)
-    end
-
-    it 'does not increase on write' do
-      stream do |out|
-        out << "many\nlines\n"
-        expect(out.lineno).to eq(0)
-      end
-    end
-
-    it 'is writable' do
-      out = stream { }
-      out.lineno = 10
-      expect(out.lineno).to eq(10)
-    end
-  end
-
-  context 'pos' do
-    it 'defaults to 0' do
-      expect(stream { }.pos).to eq(0)
-    end
-
-    it 'increases when writing data' do
-      stream do |out|
-        expect(out.pos).to eq(0)
-        out << 'hi'
-        expect(out.pos).to eq(2)
-      end
-    end
-
-    it 'is writable' do
-      out = stream { }
-      out.pos = 10
-      expect(out.pos).to eq(10)
-    end
-
-    it 'aliased to #tell' do
-      out = stream { }
-      expect(out.tell).to eq(0)
-      out.pos = 10
-      expect(out.tell).to eq(10)
-    end
-  end
-
-  context 'closed' do
-    it 'returns false while streaming' do
-      stream { |out| expect(out).not_to be_closed }
-    end
-
-    it 'returns true after streaming' do
-      expect(stream {}).to be_closed
-    end
-  end
-
-  context 'map!' do
-    it 'applies transformations later' do
-      stream do |out|
-        out.map! { |s| s.upcase }
-        out << 'ok'
-      end
-      expect(body).to eq("OK")
-    end
-
-    it 'is chainable' do
-      stream do |out|
-        out.map! { |s| s.upcase }
-        out.map! { |s| s.reverse }
-        out << 'ok'
-      end
-      expect(body).to eq("KO")
-    end
-
-    it 'works with middleware' do
-      middleware = Class.new do
-        def initialize(app) @app = app end
-        def call(env)
-          status, headers, body = @app.call(env)
-          body.map! { |s| s.upcase }
-          [status, headers, body]
-        end
-      end
-
-      use middleware
-      stream { |out| out << "ok" }
-      expect(body).to eq("OK")
-    end
-
-    it 'modifies each value separately' do
-      stream do |out|
-        out.map! { |s| s.reverse }
-        out << "ab" << "cd"
-      end
-      expect(body).to eq("badc")
-    end
-  end
-
-  context 'map' do
-    it 'works with middleware' do
-      middleware = Class.new do
-        def initialize(app) @app = app end
-        def call(env)
-          status, headers, body = @app.call(env)
-          [status, headers, body.map(&:upcase)]
-        end
-      end
-
-      use middleware
-      stream { |out| out << "ok" }
-      expect(body).to eq("OK")
-    end
-
-    it 'is chainable' do
-      middleware = Class.new do
-        def initialize(app) @app = app end
-        def call(env)
-          status, headers, body = @app.call(env)
-          [status, headers, body.map(&:upcase).map(&:reverse)]
-        end
-      end
-
-      use middleware
-      stream { |out| out << "ok" }
-      expect(body).to eq("KO")
-    end
-
-    it 'can be written as each.map' do
-      middleware = Class.new do
-        def initialize(app) @app = app end
-        def call(env)
-          status, headers, body = @app.call(env)
-          [status, headers, body.each.map(&:upcase)]
-        end
-      end
-
-      use middleware
-      stream { |out| out << "ok" }
-      expect(body).to eq("OK")
-    end
-
-    it 'does not modify the original body' do
-      stream do |out|
-        out.map { |s| s.reverse }
-        out << 'ok'
-      end
-      expect(body).to eq('ok')
-    end
-  end
-
-  context 'write' do
-    it 'writes to the stream' do
-      stream { |out| out.write 'hi' }
-      expect(body).to eq('hi')
-    end
-
-    it 'returns the number of bytes' do
-      stream do |out|
-        expect(out.write('hi')).to eq(2)
-        expect(out.write('hello')).to eq(5)
-      end
-    end
-
-    it 'accepts non-string objects' do
-      stream do |out|
-        expect(out.write(12)).to eq(2)
-      end
-    end
-
-    it 'should be aliased to syswrite' do
-      stream { |out| expect(out.syswrite('hi')).to eq(2) }
-      expect(body).to eq('hi')
-    end
-
-    it 'should be aliased to write_nonblock' do
-      stream { |out| expect(out.write_nonblock('hi')).to eq(2) }
-      expect(body).to eq('hi')
-    end
-  end
-
-  context 'print' do
-    it 'writes to the stream' do
-      stream { |out| out.print('hi') }
-      expect(body).to eq('hi')
-    end
-
-    it 'accepts multiple arguments' do
-      stream { |out| out.print(1, 2, 3, 4) }
-      expect(body).to eq('1234')
-    end
-
-    it 'returns nil' do
-      stream { |out| expect(out.print('hi')).to be_nil }
-    end
-  end
-
-  context 'printf' do
-    it 'writes to the stream' do
-      stream { |out| out.printf('hi') }
-      expect(body).to eq('hi')
-    end
-
-    it 'interpolates the format string' do
-      stream { |out| out.printf("%s: %d", "answer", 42) }
-      expect(body).to eq('answer: 42')
-    end
-
-    it 'returns nil' do
-      stream { |out| expect(out.printf('hi')).to be_nil }
-    end
-  end
-
-  context 'putc' do
-    it 'writes the first character of a string' do
-      stream { |out| out.putc('hi') }
-      expect(body).to eq('h')
-    end
-
-    it 'writes the character corresponding to an integer' do
-      stream { |out| out.putc(42) }
-      expect(body).to eq('*')
-    end
-
-    it 'returns nil' do
-      stream { |out| expect(out.putc('hi')).to be_nil }
-    end
-  end
-
-  context 'puts' do
-    it 'writes to the stream' do
-      stream { |out| out.puts('hi') }
-      expect(body).to eq("hi\n")
-    end
-
-    it 'accepts multiple arguments' do
-      stream { |out| out.puts(1, 2, 3, 4) }
-      expect(body).to eq("1\n2\n3\n4\n")
-    end
-
-    it 'returns nil' do
-      stream { |out| expect(out.puts('hi')).to be_nil }
-    end
-  end
-
-  context 'close' do
-    it 'sets #closed? to true' do
-      stream do |out|
-        out.close
-        expect(out).to be_closed
-      end
-    end
-
-    it 'sets #closed_write? to true' do
-      stream do |out|
-        expect(out).not_to be_closed_write
-        out.close
-        expect(out).to be_closed_write
-      end
-    end
-
-    it 'fires callbacks' do
-      stream do |out|
-        fired = false
-        out.callback { fired = true }
-        out.close
-        expect(fired).to be true
-      end
-    end
-
-    it 'prevents from further writing' do
-      stream do |out|
-        out.close
-        expect { out << 'hi' }.to raise_error(IOError, 'not opened for writing')
-      end
-    end
-  end
-
-  context 'close_read' do
-    it 'raises the appropriate exception' do
-      expect { stream { |out| out.close_read }}.
-        to raise_error(IOError, "closing non-duplex IO for reading")
-    end
-  end
-
-  context 'closed_read?' do
-    it('returns true') { stream { |out| expect(out).to be_closed_read }}
-  end
-
-  context 'rewind' do
-    it 'resets pos' do
-      stream do |out|
-        out << 'hi'
-        out.rewind
-        expect(out.pos).to eq(0)
-      end
-    end
-
-    it 'resets lineno' do
-      stream do |out|
-        out.lineno = 10
-        out.rewind
-        expect(out.lineno).to eq(0)
-      end
-    end
-  end
-
-  raises = %w[
-    bytes eof? eof getbyte getc gets read read_nonblock readbyte readchar
-    readline readlines readpartial sysread ungetbyte ungetc
-  ]
-
-  enum    = %w[chars each_line each_byte each_char lines]
-  dummies = %w[flush fsync internal_encoding pid]
-
-  raises.each do |method|
-    context method do
-      it 'raises the appropriate exception' do
-        expect { stream { |out| out.public_send(method) }}.
-          to raise_error(IOError, "not opened for reading")
-      end
-    end
-  end
-
-  enum.each do |method|
-    context method do
-      it 'creates an Enumerator' do
-        stream { |out| expect(out.public_send(method)).to be_a(Enumerator) }
-      end
-
-      it 'calling each raises the appropriate exception' do
-        expect { stream { |out| out.public_send(method).each { }}}.
-          to raise_error(IOError, "not opened for reading")
-      end
-    end
-  end
-
-  dummies.each do |method|
-    context method do
-      it 'returns nil' do
-        stream { |out| expect(out.public_send(method)).to be_nil }
-      end
-    end
-  end
-end