pendragon 0.6.2 → 1.0.0

data/lib/pendragon/version.rb

@@ -1,4 +1,4 @@
 
 module Pendragon
-  VERSION = '0.6.2'
+  VERSION = '1.0.0'
 end

data/pendragon.gemspec

@@ -11,10 +11,5 @@ Gem::Specification.new "pendragon", Pendragon::VERSION do |s|
   s.license = "MIT"
 
   s.add_dependency "rack", ">= 1.3.0"
-  s.add_dependency "mustermann19", "~> 0.3.0"
-  s.add_development_dependency "rake", ">= 0.8.7"
-  s.add_development_dependency "rack-test", ">= 0.5.0"
-  s.add_development_dependency "mocha", ">= 0.10.0"
-  s.add_development_dependency "haml"
-  s.add_development_dependency "padrino", "~> 0.12.2"
+  s.add_dependency "mustermann"
 end

data/test/helper.rb

@@ -1,92 +1,17 @@
 require 'bundler/setup'
-ENV['PADRINO_ENV'] = 'test'
-PADRINO_ROOT = File.dirname(__FILE__) unless defined?(PADRINO_ROOT)
-require File.expand_path('../../lib/pendragon', __FILE__)
+require File.expand_path('../lib/pendragon', __dir__)
+require File.expand_path('../lib/pendragon/realism', __dir__)
+require File.expand_path('../lib/pendragon/linear', __dir__)
 
-require 'minitest/autorun'
-require 'minitest/spec'
+Bundler.require(:default)
+
+require 'test/unit'
 require 'mocha/setup'
-require 'padrino-core'
-require 'padrino/rendering'
 require 'rack'
 require 'rack/test'
 
-begin
-  require 'ruby-debug'
-rescue LoadError; end
-
-class Sinatra::Base
-  include MiniTest::Assertions
+module Supports
 end
 
-class MiniTest::Spec
-  include Rack::Test::Methods
-
-  def pendragon(&block)
-    if !block_given? && defined?(ENABLE_COMPILER)
-      block = Proc.new do |config|
-        config.enable_compiler = true
-      end
-    end
-    @app = Pendragon.new(&block)
-  end
-
-  def mock_app(base = nil, &block)
-    @app = Sinatra.new(base || ::Padrino::Application, &block)
-    @app.class_eval{ set :pendragon, :enable_compiler => defined?(ENABLE_COMPILER) }
-  end
-
-  def app
-    Rack::Lint.new(@app)
-  end
-
-  def method_missing(name, *args, &block)
-    if response && response.respond_to?(name)
-      response.send(name, *args, &block)
-    else
-      super(name, *args, &block)
-    end
-  rescue Rack::Test::Error # no response yet
-    super(name, *args, &block)
-  end
-  alias response last_response
-
-  class << self
-    alias :setup :before unless defined?(Rails)
-    alias :teardown :after unless defined?(Rails)
-    alias :should :it
-    alias :context :describe
-    def should_eventually(desc)
-      it("should eventually #{desc}") { skip("Should eventually #{desc}") }
-    end
-  end
-  alias :assert_no_match :refute_match
-  alias :assert_not_nil :refute_nil
-  alias :assert_not_equal :refute_equal
-end
-
-
-if defined?(MiniTest::Unit.output)
-  class ColoredIO
-    def initialize(io)
-      @io = io
-    end
-  
-    def print(o)
-      case o
-      when "." then @io.send(:print, o.colorize(:green))
-      when "E" then @io.send(:print, o.colorize(:red))
-      when "F" then @io.send(:print, o.colorize(:yellow))
-      when "S" then @io.send(:print, o.colorize(:magenta))
-      else @io.send(:print, o)
-      end
-    end
-  
-    def puts(*o)
-      super
-    end
-  end
-  MiniTest::Unit.output = ColoredIO.new($stdout)
-else
-  require 'minitest/pride'
-end
+$:.unshift(File.expand_path('..', __dir__))
+Dir.glob('test/supports/*.rb').each(&method(:require))

data/test/router/test_linear.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../helper', __dir__)
+
+class TestLinear < Test::Unit::TestCase
+  include Supports::SharedExamplesForRouting
+  router_class Pendragon::Linear
+end

data/test/router/test_realism.rb

@@ -0,0 +1,6 @@
+require File.expand_path('../helper', __dir__)
+
+class TestRealism < Test::Unit::TestCase
+  include Supports::SharedExamplesForRouting
+  router_class Pendragon::Realism
+end

data/test/supports/shared_examples_for_routing.rb

@@ -0,0 +1,277 @@
+require 'json'
+
+module Supports::SharedExamplesForRouting
+  extend Modulla
+  include Rack::Test::Methods
+
+  module ClassMethods
+    def router_class(klass)
+      define_method(:router) { klass }
+    end
+
+    def disable(*features)
+      features.each do |feature|
+        define_method('%p disabled' % feature) {}
+      end
+    end
+  end
+
+  alias_method :response, :last_response
+
+  def disabled?(feature)
+    respond_to?('%p disabled' % feature)
+  end
+
+  def mock_env_for(path = ?/, **options)
+    Rack::MockRequest.env_for(path, **options)
+  end
+
+  def mock_app(base = nil, &block)
+    @app = router.new(&block)
+  end
+
+  def app
+    Rack::Lint.new(@app)
+  end
+
+  def assert_response(status, body, headers = {})
+    assert { last_response.status  == status }
+    assert { last_response.body    == body }
+    headers.each_pair do |key, val|
+      assert { last_response.headers[key] == val }
+    end
+  end
+
+  sub_test_case '#call' do
+    test 'return response conformed rack format' do
+      assert_nothing_raised do
+        Rack::Lint.new(router.new).call(mock_env_for)
+      end
+    end
+  end
+
+  sub_test_case 'default response' do
+    setup { mock_app { } }
+    test 'return default response if given request does not match with any routes' do
+      get ?/
+      assert_response 404, 'not found', 'Content-Type' => 'text/plain'
+    end
+  end
+
+  sub_test_case 'basic' do
+    setup do
+      mock_app do
+        get(?/) { [200, {}, ['hello']] }
+      end
+    end
+    test 'return response if given request matches with any routes' do
+      get ?/
+      assert_response 200, 'hello'
+    end
+  end
+
+  sub_test_case 'duck typing' do
+    setup do
+      _lambda = -> { [200, {}, ['lambda']] }
+      rack_app_class = Class.new {
+        def call(env)
+          [200, {}, ['rackapp']]
+        end
+      }
+      mock_app do
+        get '/lambda',   to: _lambda
+        get '/rack_app', to: rack_app_class.new
+      end
+    end
+
+    test 'duck typing for lambda' do
+      get '/lambda'
+      assert_response 200, 'lambda'
+    end
+
+    test 'duck typing for rack app' do
+      get '/rack_app'
+      assert_response 200, 'rackapp'
+    end
+  end
+
+  sub_test_case 'namespacing' do
+    setup do
+      mock_app do
+        namespace :foo do
+          get('/123') { [200, {}, ['hey']] }
+        end
+      end
+    end
+
+    test 'append given namespace as a prefix' do
+      get '/foo/123'
+      assert_response 200, 'hey'
+    end
+  end
+
+  sub_test_case 'nested namespacing' do
+    setup do
+      mock_app do
+        namespace :foo do
+          get('/') { [200, {}, ['foo']] }
+          namespace :bar do
+            get('/') { [200, {}, ['bar']] }
+            namespace :baz do
+              get('/') { [200, {}, ['baz']] }
+            end
+          end
+        end
+      end
+    end
+
+    test 'append given namespace as a prefix' do
+      get '/foo/'
+      assert_response 200, 'foo'
+      get '/foo/bar/'
+      assert_response 200, 'bar'
+      get '/foo/bar/baz/'
+      assert_response 200, 'baz'
+    end
+  end
+
+  sub_test_case 'complex routing' do
+    setup do
+      mock_app do
+        1000.times do |n|
+          [:get, :post, :put, :delete, :options].each do |verb|
+            public_send(verb, "/#{n}") { [200, {}, ["#{verb} #{n}"]] }
+          end
+        end
+      end
+    end
+
+    test 'recognize a route correctly' do
+      put '/376'
+      assert_response 200, 'put 376'
+    end
+
+    test 'recognize a route correctly (part 2)' do
+      delete '/999'
+      assert_response 200, 'delete 999'
+    end
+  end
+
+  sub_test_case 'method not allowed' do
+    setup do
+      mock_app do
+        get '/testing' do
+          [200, {}, ['hello testing']]
+        end
+      end
+    end
+
+    test 'returns 405 if given method is not allowed' do
+      post '/testing'
+      assert_response 405, 'method not allowed', { 'Allows' => 'GET' }
+    end
+  end
+
+  sub_test_case 'block arguments' do
+    setup do
+      mock_app do
+        get '/foo/:name/*/*' do |name, a, b|
+          body = "#{name}, #{a}, #{b}"
+          [200, {}, [body]]
+        end
+      end
+    end
+
+    test 'gets params as block parameters' do
+      omit_if disabled?(:multiple_splats)
+      get '/foo/yoman/1234/5678'
+      assert_response 200, 'yoman, 1234, 5678'
+    end
+  end
+
+  sub_test_case '#params' do
+    setup do
+      mock_app do
+        get '/foo/:name/*/*' do
+          body = params.to_json
+          [200, {}, [body]]
+        end
+      end
+    end
+
+    test 'gets params correctly' do
+      omit_if disabled?(:multiple_splats)
+      get '/foo/heyman/1234/5678'
+      assert_response 200, {name: 'heyman', splat: ['1234', '5678']}.to_json
+    end
+  end
+
+  sub_test_case 'capturing' do
+    setup do
+      mock_app do
+        get '/users/:name/articles/:article_id' do
+          [200, {}, [captures.join(' ')]]
+        end
+      end
+    end
+
+    test 'gets captures correctly' do
+      get '/users/namusyaka/articles/1234'
+      assert_response 200, 'namusyaka 1234'
+    end
+  end
+
+  sub_test_case 'splat' do
+    sub_test_case 'multiple splats' do
+      setup do
+        mock_app do
+          get '/splatting/*/*/*' do |a, b, c|
+            [200, {}, ["captures: #{captures.join(' ')}, block: #{a} #{b} #{c}"]]
+          end
+        end
+      end
+
+      test 'gets multiple splats correctly' do
+        omit_if disabled?(:multiple_splats)
+        get '/splatting/1234/5678/90'
+        assert_response 200, 'captures: 1234 5678 90, block: 1234 5678 90'
+      end
+    end
+  end
+
+  sub_test_case 'cascading' do
+    setup do
+      mock_app do
+        get '/cascading' do
+          [200, { 'X-Cascade' => 'pass' }, ['']]
+        end
+
+        get '/cascading' do
+          [200, {}, ['yay']]
+        end
+      end
+    end
+
+    test 'succeeds to cascading' do
+      omit_if disabled?(:cascading)
+      get '/cascading'
+      assert_response 200, 'yay'
+    end
+  end
+
+  sub_test_case 'halting' do
+    setup do
+      mock_app do
+        get ?/ do
+          throw :halt, [404, {}, ['not found']]
+          [200, {}, ['failed to halt']]
+        end
+      end
+    end
+
+    test 'succeeds to halting' do
+      get ?/
+      assert_response 404, 'not found'
+    end
+  end
+end

data/test/test_router.rb

@@ -0,0 +1,40 @@
+require File.expand_path('helper', __dir__)
+
+class TestRouter < Test::Unit::TestCase
+  attr_accessor :router
+
+  setup { self.router = Pendragon::Router.new }
+
+  sub_test_case '#call' do
+    setup do
+      @mock_request = Rack::MockRequest.env_for(?/)
+      router.get(?/) { 'hello' }
+    end
+
+    test 'should recognize a route inside #with_block' do
+      router.expects(:with_optimization)
+      router.call(@mock_request)
+    end
+
+    test 'raises NotImplementedError' do
+      assert_raise NotImplementedError do
+        router.call(@mock_request)
+      end
+    end
+
+    sub_test_case 'without matched route' do
+    end
+  end
+
+  %w[get post put delete head options].each do |request_method|
+    sub_test_case "##{request_method}" do
+      setup { @expected_block = Proc.new {} }
+      test "should append #{request_method} route correctly" do
+        router.public_send(request_method, ?/, &@expected_block)
+        actual = router.map[request_method.upcase].first
+        assert { actual.request_method == request_method.upcase }
+        assert { actual.path == ?/ }
+      end
+    end
+  end
+end