jellyfish 1.0.2 → 1.1.0

data/test/sinatra/test_multi_actions.rb

@@ -1,217 +0,0 @@
-
-require 'jellyfish/test'
-
-# stolen from sinatra
-describe 'Sinatra filter_test.rb' do
-  paste :jellyfish
-
-  def new_app base=Object, &block
-    Class.new(base){
-      include Jellyfish
-      controller_include(Jellyfish::MultiActions)
-      instance_eval(&block)
-    }.new
-  end
-
-  would 'executes filters in the order defined' do
-    count = 0
-    app = new_app{
-      get     { count.should.eq 0; count = 1 }
-      get     { count.should.eq 1; count = 2 }
-      get('/'){ 'Hello World' }
-    }
-
-    status, _, body = get('/', app)
-    status.should.eq 200
-    count .should.eq 2
-    body  .should.eq ['Hello World']
-  end
-
-  would 'modify env' do
-    app = new_app{
-      get{ env['BOO'] = 'MOO' }
-      get('/foo'){ env['BOO'] }
-    }
-
-    status, _, body = get('/foo', app)
-    status.should.eq 200
-    body  .should.eq ['MOO']
-  end
-
-  would 'modify instance variables available to routes' do
-    app = new_app{
-      get{ @foo = 'bar' }
-      get('/foo') { @foo }
-    }
-
-    status, _, body = get('/foo', app)
-    status.should.eq 200
-    body  .should.eq ['bar']
-  end
-
-  would 'allows redirects' do
-    app = new_app{
-      get{ found '/bar' }
-      get('/foo') do
-        fail 'before block should have halted processing'
-        'ORLY?!'
-      end
-    }
-
-    status, headers, body = get('/foo', app)
-    status             .should.eq 302
-    headers['Location'].should.eq '/bar'
-    body.join          .should =~ %r{<h1>Jellyfish found: /bar</h1>}
-  end
-
-  would 'not modify the response with its return value' do
-    app = new_app{
-      get{ 'Hello World!' }
-      get '/foo' do
-        body.should.eq nil
-        'cool'
-      end
-    }
-
-    status, _, body = get('/foo', app)
-    status.should.eq 200
-    body  .should.eq ['cool']
-  end
-
-  would 'modify the response with halt' do
-    app = new_app{
-      get('/foo'){ halt [302, {}, ['Hi']] }
-      get('/foo'){ 'should not happen' }
-      get('/bar'){ status 402; body 'Ho'; halt }
-      get('/bar'){ 'should not happen' }
-    }
-
-    get('/foo', app).should.eq [302, {}, ['Hi']]
-    get('/bar', app).should.eq [402, {}, ['Ho']]
-  end
-
-  would 'give you access to params' do
-    app = new_app{
-      get{ @foo = Rack::Request.new(env).params['foo'] }
-      get('/foo'){ @foo.reverse }
-    }
-
-    status, _, body = get('/foo', app, 'QUERY_STRING' => 'foo=cool')
-    status.should.eq 200
-    body  .should.eq ['looc']
-  end
-
-  would 'run filters defined in superclasses' do
-    sup = new_app{ get{ @foo = 'hello from superclass' } }.class
-    app = new_app(sup){ get('/foo'){ @foo } }
-
-    _, _, body = get('/foo', app)
-    body.should.eq ['hello from superclass']
-
-    sup      .routes['get'].size.should.eq 1
-    app.class.routes['get'].size.should.eq 2
-  end
-
-  would 'take an optional route pattern' do
-    ran_filter = false
-    app = new_app{
-      get(%r{^/b}){ ran_filter = true }
-      get('/foo') {}
-      get('/bar') {}
-    }
-    get('/foo', app)
-    ran_filter.should.eq false
-    get('/bar', app)
-    ran_filter.should.eq true
-  end
-
-  would 'generate block arguments from route pattern' do
-    subpath = nil
-    app = new_app{
-      get(%r{^/foo/(\w+)}){ |m| subpath = m[1] }
-    }
-    get('/foo/bar', app)
-    subpath.should.eq 'bar'
-  end
-
-  would 'execute before and after filters in correct order' do
-    invoked = 0
-    app = new_app{
-      get     { invoked  = 2 }
-      get('/'){ invoked += 2; body 'hello' }
-      get     { invoked *= 2 }
-    }
-
-    status, _, body = get('/', app)
-    status .should.eq 200
-    body   .should.eq ['hello']
-    invoked.should.eq 8
-  end
-
-  would 'execute filters in the order defined' do
-    count = 0
-    app = new_app{
-      get('/'){ body 'Hello World' }
-      get{
-        count.should.eq 0
-        count = 1
-      }
-      get{
-        count.should.eq 1
-        count = 2
-      }
-    }
-
-    status, _, body = get('/', app)
-    status.should.eq 200
-    count .should.eq 2
-    body  .should.eq ['Hello World']
-  end
-
-  would 'allow redirects' do
-    app = new_app{
-      get('/foo'){ 'ORLY' }
-      get        { found '/bar' }
-    }
-
-    status, headers, body = get('/foo', app)
-    status             .should.eq 302
-    headers['Location'].should.eq '/bar'
-    body.join          .should =~ %r{<h1>Jellyfish found: /bar</h1>}
-  end
-
-  would 'not modify the response with its return value' do
-    app = new_app{
-      get('/foo'){ body 'cool' }
-      get        { 'Hello World!' }
-    }
-
-    status, _, body = get('/foo', app)
-    status.should.eq 200
-    body  .should.eq ['cool']
-  end
-
-  would 'modify the response with halt' do
-    app = new_app{
-      get('/foo'){ 'should not be returned' }
-      get{ halt [302, {}, ['Hi']] }
-    }
-
-    status, _, body = get('/foo', app)
-    status.should.eq 302
-    body  .should.eq ['Hi']
-  end
-
-  would 'take an optional route pattern' do
-    ran_filter = false
-    app = new_app{
-      get('/foo') {}
-      get('/bar') {}
-      get(%r{^/b}){ ran_filter = true }
-    }
-    get('/foo', app)
-    ran_filter.should.eq false
-    get('/bar', app)
-    ran_filter.should.eq true
-  end
-end

data/test/test_swagger.rb

@@ -1,131 +0,0 @@
-
-require 'jellyfish/test'
-
-describe Jellyfish do
-  paste :jellyfish
-
-  app = Rack::Builder.app do
-    eval File.read("#{File.dirname(__FILE__)}/../config.ru")
-  end
-
-  def string_keys hash
-    hash.inject({}){ |r, (k, v)| r[k.to_s] = v; r }
-  end
-
-  would '/swagger' do
-    status, headers, body = get('/swagger', app)
-    status                 .should.eq 200
-    headers['Content-Type'].should.eq 'application/json; charset=utf-8'
-    res = Jellyfish::Json.decode(body.to_a.join)
-    res['swaggerVersion'].should.eq '1.2'
-    res['info']          .should.eq string_keys(Jelly.info)
-    res['apiVersion']    .should.eq Jelly.swagger_apiVersion
-    res['apis']          .should.eq \
-      [{'path' => '/users'}, {'path' => '/posts'}]
-  end
-
-  would '/swagger/users' do
-    status, _, body = get('/swagger/users', app)
-    status                 .should.eq 200
-    res = Jellyfish::Json.decode(body.to_a.join)
-    res['basePath']    .should.eq 'https://localhost:8080'
-    res['resourcePath'].should.eq '/users'
-    res['apis']        .should.eq \
-      [{"path"=>"/users",
-        "operations"=>[{"summary"=>"List users",
-                        "notes"=>"List users<br>Note that we do not really" \
-                                 " have users.",
-                        "path"=>"/users",
-                        "method"=>"GET",
-                        "nickname"=>"/users",
-                        "parameters"=>[]},
-                       {"summary"=>"Create a user",
-                        "notes"=>"Create a user<br>Here we demonstrate how" \
-                                 " to write the swagger doc.",
-                        "parameters"=>[{"type"=>"string",
-                                        "required"=>true,
-                                        "description"=>"The name of the user",
-                                        "name"=>"name",
-                                        "paramType"=>"query"},
-                                       {"type"=>"boolean",
-                                        "description"=>"If the user is sane",
-                                        "name"=>"sane",
-                                        "required"=>false,
-                                        "paramType"=>"query"},
-                                       {"type"=>"string",
-                                        "description"=>"What kind of user",
-                                        "enum"=>["good", "neutral", "evil"],
-                                        "name"=>"type",
-                                        "required"=>false,
-                                        "paramType"=>"query"}],
-                        "responseMessages"=>[{"code"=>400,
-                                              "message"=>"Invalid name"}],
-                        "path"=>"/users",
-                        "method"=>"POST",
-                        "nickname"=>"/users"}]},
-       {"path"=>"/users/{id}",
-        "operations"=>[{"summary"=>"Update a user",
-                        "parameters"=>[{"type"=>"integer",
-                                        "description"=>"The id of the user",
-                                        "name"=>"id",
-                                        "required"=>true,
-                                        "paramType"=>"path"}],
-                        "path"=>"/users",
-                        "method"=>"PUT",
-                        "nickname"=>"/users/{id}",
-                        "notes"=>"Update a user"},
-                       {"path"=>"/users",
-                        "method"=>"DELETE",
-                        "nickname"=>"/users/{id}",
-                        "summary"=>nil,
-                        "notes"=>nil,
-                        "parameters"=>[{"name"=>"id",
-                                        "type"=>"integer",
-                                        "required"=>true,
-                                        "paramType"=>"path"}]}]}]
-  end
-
-  swagger = Jellyfish::Swagger.new(Class.new{include Jellyfish})
-
-  would 'swagger_path' do
-    swagger.send(:swagger_path, '/')          .should.eq '/'
-    swagger.send(:swagger_path, '/users/{id}').should.eq '/users'
-  end
-
-  would 'nickname' do
-    swagger.send(:nickname, '/')                    .should.eq '/'
-    swagger.send(:nickname, '/users/{id}')          .should.eq '/users/{id}'
-    swagger.send(:nickname, %r{\A/users/(?<id>\d+)}).should.eq '/users/{id}'
-    swagger.send(:nickname, %r{^/users/(?<id>\d+)$}).should.eq '/users/{id}'
-    swagger.send(:nickname, %r{/(?<a>\d)/(?<b>\w)$}).should.eq '/{a}/{b}'
-  end
-
-  would 'notes' do
-    swagger.send(:notes, :summary => 'summary', :notes => 'notes').
-      should.eq 'summary<br>notes'
-    swagger.send(:notes, :summary => 'summary').
-      should.eq 'summary'
-  end
-
-  would 'path_parameters' do
-    swagger.send(:path_parameters, %r{/(?<a>\d)/(?<b>\w)/(?<c>\d)$},
-                 :parameters => {:c => {:type => 'hash'}}).
-      should.eq([{:name => 'a', :type => 'integer',
-                  :required => true, :paramType => 'path'},
-                 {:name => 'b', :type => 'string',
-                  :required => true, :paramType => 'path'},
-                 {:name => 'c', :type => 'hash',
-                  :required => true, :paramType => 'path'}])
-  end
-
-  would 'query_parameters' do
-    swagger.send(:query_parameters,
-                 :parameters => {:c => {:type => 'hash'}}).
-      should.eq([:name => 'c', :type => 'hash',
-                 :required => false, :paramType => 'query'])
-    swagger.send(:query_parameters,
-                 :parameters => {:c => {:required => true}}).
-      should.eq([:name => 'c', :type => 'string',
-                 :required => true, :paramType => 'query'])
-  end
-end