hobbit-contrib 0.5.2 → 0.5.3

data/spec/error_handling_spec.rb

@@ -1,136 +0,0 @@
-require 'minitest_helper'
-
-describe Hobbit::ErrorHandling do
-  include Hobbit::Contrib::Mock
-  include Rack::Test::Methods
-
-  class NotFoundException < Exception ; end
-  class SpecificNotFoundException < NotFoundException ; end
-  class UnknownException < Exception ; end
-  class MustUseResponseException < Exception ; end
-
-  let :app do
-    mock_app do
-      include Hobbit::ErrorHandling
-
-      error NotFoundException do
-        'Not Found'
-      end
-
-      error StandardError do
-        exception = env['hobbit.error']
-        exception.message
-      end
-
-      error MustUseResponseException do
-        response.redirect '/'
-      end
-
-      get '/' do
-        'hello'
-      end
-
-      get '/raises' do
-        raise StandardError, 'StandardError'
-        'not this'
-      end
-
-      get '/other_raises' do
-        raise NotFoundException
-        response.write 'not this'
-      end
-
-      get '/same_other_raises' do
-        raise SpecificNotFoundException
-        response.write 'not this'
-      end
-
-      get '/uncaught_raise' do
-        raise UnknownException
-        response.write 'not this'
-      end
-
-      get '/must_use_response' do
-        raise MustUseResponseException
-        response.write 'not this'
-      end
-    end
-  end
-
-  describe '::error' do
-    specify do
-      p = Proc.new { 'error' }
-      app = mock_app do
-        include Hobbit::ErrorHandling
-        error StandardError, &p
-      end
-
-      app.to_app.class.errors.must_include StandardError
-      app.to_app.class.errors[StandardError].call.must_equal p.call
-    end
-  end
-
-  describe '::errors' do
-    it 'must return a Hash' do
-      app.to_app.class.errors.must_be_kind_of Hash
-    end
-  end
-
-  describe 'when does not raise exception' do
-    it 'must work as expected' do
-      get '/'
-      last_response.must_be :ok?
-      last_response.body.must_equal 'hello'
-    end
-  end
-
-  describe 'when does raise an unknown exception class' do
-    it 'must not halt default propagation of the unknown class' do
-      proc { get '/uncaught_raise' }.must_raise UnknownException
-    end
-  end
-
-  describe 'when raises a known exception class' do
-    it 'must call the block set in error' do
-      get '/raises'
-      last_response.must_be :ok?
-      last_response.body.must_equal 'StandardError'
-    end
-
-    it 'must allow to define more than one exception' do
-      get '/other_raises'
-      last_response.must_be :ok?
-      last_response.body.must_equal 'Not Found'
-    end
-
-    it 'must allow to define a general exception class to catch' do
-      get '/same_other_raises'
-      last_response.must_be :ok?
-      last_response.body.must_equal 'Not Found'
-    end
-
-    it 'must set the returned value of the error block as the body' do
-      get '/other_raises'
-      last_response.must_be :ok?
-      last_response.body.must_equal 'Not Found'
-      last_response.body.wont_equal 'not this'
-    end
-
-    it 'must override a previous block if a new one is passed' do
-      app.to_app.class.error StandardError do
-        'other handler!'
-      end
-
-      get '/raises'
-      last_response.must_be :ok?
-      last_response.body.must_equal 'other handler!'
-    end
-
-    it 'must use response object' do
-      get '/must_use_response'
-      last_response.must_be :redirection?
-      follow_redirect!
-      last_response.body.must_equal 'hello'
-    end
-  end
-end

data/spec/filter_spec.rb

@@ -1,274 +0,0 @@
-require 'minitest_helper'
-
-describe Hobbit::Filter do
-  include Hobbit::Contrib::Mock
-  include Rack::Test::Methods
-
-  describe 'basic specs' do
-    let :app do
-      mock_app do
-        include Hobbit::Filter
-
-        before do
-          env['hobbit.before'] = 'this is before'
-        end
-
-        get '/' do
-          'GET /'
-        end
-
-        after do
-          env['hobbit.after'] = 'this is after'
-        end
-      end
-    end
-
-    %w(after before).each do |kind|
-      str = <<EOS
-    describe '::#{kind}' do
-      specify do
-        p = Proc.new { 'do something' }
-        app = mock_app do
-          include Hobbit::Filter
-          #{kind}('', &p)
-        end
-
-        app.to_app.class.filters[:#{kind}].size.must_equal 1
-        app.to_app.class.filters[:#{kind}].first[:block].call.must_equal p.call
-      end
-    end
-
-    describe 'when a filter matches' do
-      it "must call the filters' block" do
-        get '/'
-        last_response.must_be :ok?
-        last_request.env.must_include 'hobbit.#{kind}'
-        last_request.env['hobbit.#{kind}'].must_equal 'this is #{kind}'
-      end
-    end
-EOS
-      class_eval str
-    end
-
-    describe '::filters' do
-      it 'must return a Hash' do
-        app.to_app.class.filters.must_be_kind_of Hash
-      end
-    end
-
-    describe '::compile_filter' do
-      let(:block) { block = Proc.new { |env| [200, {}, []] } }
-
-      it 'must compile /' do
-        path = '/'
-        route = app.to_app.class.send :compile_filter, path, &block
-        route[:block].call({}).must_equal block.call({})
-        route[:compiled_path].to_s.must_equal /^\/$/.to_s
-      end
-
-      it 'must compile with .' do
-        path = '/route.json'
-        route = app.to_app.class.send :compile_filter, path, &block
-        route[:block].call({}).must_equal block.call({})
-        route[:compiled_path].to_s.must_equal /^\/route.json$/.to_s
-      end
-
-      it 'must compile with -' do
-        path = '/hello-world'
-        route = app.to_app.class.send :compile_filter, path, &block
-        route[:block].call({}).must_equal block.call({})
-        route[:compiled_path].to_s.must_equal /^\/hello-world$/.to_s
-      end
-
-      it 'must compile with params' do
-        path = '/hello/:name'
-        route = app.to_app.class.send :compile_filter, path, &block
-        route[:block].call({}).must_equal block.call({})
-        route[:compiled_path].to_s.must_equal /^\/hello\/([^\/?#]+)$/.to_s
-
-        path = '/say/:something/to/:someone'
-        route = app.to_app.class.send :compile_filter, path, &block
-        route[:block].call({}).must_equal block.call({})
-        route[:compiled_path].to_s.must_equal /^\/say\/([^\/?#]+)\/to\/([^\/?#]+)$/.to_s
-      end
-
-      it 'must compile with . and params' do
-        path = '/route/:id.json'
-        route = app.to_app.class.send :compile_filter, path, &block
-        route[:block].call({}).must_equal block.call({})
-        route[:compiled_path].to_s.must_equal /^\/route\/([^\/?#]+).json$/.to_s
-      end
-    end
-
-    it 'must call before and after filters' do
-      get '/'
-      last_response.must_be :ok?
-      last_request.env.must_include 'hobbit.before'
-      last_request.env['hobbit.before'].must_equal 'this is before'
-      last_request.env.must_include 'hobbit.after'
-      last_request.env['hobbit.after'].must_equal 'this is after'
-    end
-  end
-
-  describe 'filters with parameters' do
-    let :app do
-      mock_app do
-        include Hobbit::Filter
-
-        before '/:name' do
-          env['hobbit.before'] = 'this is before'
-        end
-
-        after '/:name' do
-          env['hobbit.after'] = 'this is after'
-        end
-
-        get('/:name') { env['hobbit.before'] }
-      end
-    end
-
-    it 'must call the before and after filters' do
-      get '/hobbit'
-      last_response.must_be :ok?
-      last_request.env.must_include 'hobbit.before'
-      last_request.env['hobbit.before'].must_equal 'this is before'
-      last_request.env.must_include 'hobbit.after'
-      last_request.env['hobbit.after'].must_equal 'this is after'
-    end
-  end
-
-  describe 'when multiple filters are declared' do
-    let :app do
-      mock_app do
-        include Hobbit::Filter
-
-        before do
-          env['hobbit.before'] = 'this will match'
-        end
-
-        before '/' do
-          env['hobbit.before'] = 'this wont match'
-        end
-
-        after do
-          env['hobbit.after'] = 'this will match'
-        end
-
-        after '/' do
-          env['hobbit.after'] = 'this wont match'
-        end
-
-        get('/') { 'GET /' }
-      end
-    end
-
-    it 'must call the first that matches' do
-      get '/'
-      last_response.must_be :ok?
-      last_request.env.must_include 'hobbit.before'
-      last_request.env['hobbit.before'].must_equal 'this will match'
-      last_request.env.must_include 'hobbit.after'
-      last_request.env['hobbit.after'].must_equal 'this will match'
-    end
-  end
-
-  describe 'when a before filter redirects the response' do
-    let :app do
-      mock_app do
-        include Hobbit::Filter
-
-        before do
-          response.redirect '/goodbye' unless request.path_info == '/goodbye'
-        end
-
-        get '/' do
-          'hello world'
-        end
-
-        get '/goodbye' do
-          'goodbye world'
-        end
-      end
-    end
-
-    it 'must redirect on before filters' do
-      get '/'
-      last_response.must_be :redirection?
-      follow_redirect!
-      last_response.must_be :ok?
-      last_response.body.must_match /goodbye world/
-    end
-  end
-
-  describe 'when halting in a before filter' do
-    let :app do
-      mock_app do
-        include Hobbit::Filter
-
-        before do
-          halt 401
-        end
-
-        get '/' do
-          'hello world'
-        end
-      end
-    end
-
-    it 'wont execute the route' do
-      get '/'
-      last_response.status.must_equal 401
-      last_response.body.must_be :empty?
-    end
-  end
-
-  describe 'when halting in a route' do
-    let :app do
-      mock_app do
-        include Hobbit::Filter
-
-        before do
-          response.headers['Content-Type'] = 'text/plain'
-        end
-
-        after do
-          response.headers['Content-Type'] = 'application/json'
-        end
-
-        get '/' do
-          halt 401, 'Unauthenticated'
-        end
-      end
-    end
-
-    it 'wont execute the after filter' do
-      get '/'
-      last_response.status.must_equal 401
-      last_response.headers.must_include 'Content-Type'
-      last_response.headers['Content-Type'].must_equal 'text/plain'
-      last_response.body.must_equal 'Unauthenticated'
-    end
-  end
-
-  describe 'when halting in an after filter' do
-    let :app do
-      mock_app do
-        include Hobbit::Filter
-
-        after do
-          halt 401
-        end
-
-        get '/' do
-          'hello world'
-        end
-      end
-    end
-
-    it 'wont execute the route' do
-      get '/'
-      last_response.status.must_equal 401
-      last_response.body.must_equal 'hello world'
-    end
-  end
-end

data/spec/minitest_helper.rb

@@ -1,25 +0,0 @@
-require 'codeclimate-test-reporter'
-CodeClimate::TestReporter.start
-
-ENV['RACK_ENV'] ||= 'test'
-
-require 'bundler'
-Bundler.require :default, ENV['RACK_ENV'].to_sym
-
-require 'minitest/autorun'
-require 'rack'
-require 'rack/test'
-
-require 'hobbit'
-require 'hobbit/contrib'
-
-module Hobbit
-  module Contrib
-    module Mock
-      def mock_app(&block)
-        app = Class.new Hobbit::Base, &block
-        app.new
-      end
-    end
-  end
-end

data/spec/mote_spec.rb

@@ -1,89 +0,0 @@
-require 'minitest_helper'
-
-describe Hobbit::Mote do
-  include Hobbit::Contrib::Mock
-  include Rack::Test::Methods
-
-  def app
-    mock_app do
-      include Hobbit::Mote
-
-      def views_path
-        File.expand_path '../fixtures/mote/views/', __FILE__
-      end
-
-      def name
-        'Hobbit'
-      end
-
-      get('/') { render 'index' }
-      get('/partial') { partial 'partial' }
-      get('/using-context') { render 'hello' }
-      get('/without-layout') { render '_partial', layout: false }
-    end
-  end
-
-  describe '#default_layout' do
-    it 'defaults to application.mote' do
-      app.to_app.default_layout.must_equal "#{app.to_app.layouts_path}/application.mote"
-    end
-  end
-
-  describe '#find_template' do
-    it 'must return a template path' do
-      app.to_app.find_template('index').must_equal "#{app.to_app.views_path}/index.mote"
-    end
-  end
-
-  describe '#layouts_path' do
-    it 'must return the path to the layouts directory' do
-      app.to_app.layouts_path.must_equal "#{app.to_app.views_path}/layouts"
-    end
-  end
-
-  describe '#partial' do
-    it 'must render a template without a layout' do
-      get '/partial'
-      last_response.must_be :ok?
-      last_response.body.wont_match /From application.mote/
-      last_response.body.must_match /Hello World!/
-    end
-  end
-
-  describe '#render' do
-    it 'must render a template (using a layout)' do
-      get '/'
-      last_response.must_be :ok?
-      last_response.body.must_match /From application.mote/
-      last_response.body.must_match /Hello World!/
-    end
-
-    it 'must render a template (not using a layout)' do
-      get '/without-layout'
-      last_response.must_be :ok?
-      last_response.body.wont_match /From application.mote/
-      last_response.body.must_match /Hello World!/
-    end
-
-    it 'must render a template using the app as context' do
-      get '/using-context'
-      last_response.must_be :ok?
-      last_response.body.must_match /From application.mote/
-      last_response.body.must_match /Hello Hobbit!/
-    end
-  end
-
-  describe '#views_path' do
-    it 'must return the path to the views directory' do
-      app.to_app.views_path.must_equal File.expand_path('../fixtures/mote/views', __FILE__)
-    end
-
-    it 'defaults to "views"' do
-      a = mock_app do
-        include Hobbit::Mote
-      end
-
-      a.to_app.views_path.must_equal 'views'
-    end
-  end
-end