middleman-core 3.2.2 → 3.3.0

data/lib/vendored-middleman-deps/padrino-core-0.11.4/test/test_core.rb

@@ -1,77 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-describe "Core" do
-  def setup
-    Padrino.clear!
-  end
-
-  context 'for core functionality' do
-
-    should 'check some global methods' do
-      assert_respond_to Padrino, :root
-      assert_respond_to Padrino, :env
-      assert_respond_to Padrino, :application
-      assert_respond_to Padrino, :set_encoding
-      assert_respond_to Padrino, :load!
-      assert_respond_to Padrino, :reload!
-      assert_respond_to Padrino, :version
-      assert_respond_to Padrino, :configure_apps
-    end
-
-
-    should 'validate global helpers' do
-      assert_equal :test, Padrino.env
-      assert_match /\/test/, Padrino.root
-      assert_not_nil Padrino.version
-    end
-
-    should 'set correct utf-8 encoding' do
-      Padrino.set_encoding
-      if RUBY_VERSION <'1.9'
-        assert_equal 'UTF8', $KCODE
-      else
-        assert_equal Encoding.default_external, Encoding::UTF_8
-        assert_equal Encoding.default_internal, Encoding::UTF_8
-      end
-    end
-
-    should 'have load paths' do
-      assert_equal [Padrino.root('lib'), Padrino.root('models'), Padrino.root('shared')], Padrino.load_paths
-    end
-
-    should 'raise application error if I instantiate a new padrino application without mounted apps' do
-      assert_raises(Padrino::ApplicationLoadError) { Padrino.application.new }
-    end
-
-    should "check before/after padrino load hooks" do
-      Padrino.before_load { @_foo  = 1 }
-      Padrino.after_load  { @_foo += 1 }
-      Padrino.load!
-      assert_equal 1, Padrino.before_load.size
-      assert_equal 1, Padrino.after_load.size
-      assert_equal 2, @_foo
-    end
-
-    should "add middlewares in front if specified" do
-      test = Class.new {
-        def initialize(app)
-          @app = app
-        end
-
-        def call(env)
-          status, headers, body = @app.call(env)
-          headers["Middleware-Called"] = "yes"
-          return status, headers, body
-        end
-      }
-
-      class Foo < Padrino::Application; end
-
-      Padrino.use(test)
-      Padrino.mount(Foo).to("/")
-
-      res = Rack::MockRequest.new(Padrino.application).get("/")
-      assert_equal "yes", res["Middleware-Called"]
-    end
-  end
-end

data/lib/vendored-middleman-deps/padrino-core-0.11.4/test/test_csrf_protection.rb

@@ -1,80 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-describe "Application" do
-  before { Padrino.clear! }
-  after  { remove_views }
-
-  context 'CSRF protection' do
-    context "with CSRF protection on" do
-      before do
-        mock_app do
-          enable :sessions
-          enable :protect_from_csrf
-          post('/'){ 'HI' }
-        end
-      end
-
-      should "not allow requests without tokens" do
-        post "/"
-        assert_equal 403, status
-      end
-
-      should "allow requests with correct tokens" do
-        post "/", {"authenticity_token" => "a"}, 'rack.session' => {:csrf => "a"}
-        assert_equal 200, status
-      end
-
-      should "not allow requests with incorrect tokens" do
-        post "/", {"authenticity_token" => "a"}, 'rack.session' => {:csrf => "b"}
-        assert_equal 403, status
-      end
-    end
-
-    context "without CSRF protection on" do
-      before do
-        mock_app do
-          enable :sessions
-          disable :protect_from_csrf
-          post('/'){ 'HI' }
-        end
-      end
-
-      should "allows requests without tokens" do
-        post "/"
-        assert_equal 200, status
-      end
-
-      should "allow requests with correct tokens" do
-        post "/", {"authenticity_token" => "a"}, 'rack.session' => {:csrf => "a"}
-        assert_equal 200, status        
-      end
-
-      should "allow requests with incorrect tokens" do
-        post "/", {"authenticity_token" => "a"}, 'rack.session' => {:csrf => "b"}
-        assert_equal 200, status
-      end
-    end
-
-    context "with optional CSRF protection" do
-      before do
-        mock_app do
-          enable :sessions
-          enable :protect_from_csrf
-          set :allow_disabled_csrf, true
-          post('/on') { 'HI' }
-          post('/off', :csrf_protection => false) { 'HI' }
-        end
-      end
-
-      should "allow access to routes with csrf_protection off" do
-        post "/off"
-        assert_equal 200, status
-      end
-
-      should "not allow access to routes with csrf_protection on" do
-        post "/on"
-        assert_equal 403, status
-      end
-    end
-  end
-end

data/lib/vendored-middleman-deps/padrino-core-0.11.4/test/test_dependencies.rb

@@ -1,44 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-describe "Dependencies" do
-  context 'when we require a dependency that have another dependency' do
-
-    should 'raise an error without reloading it twice' do
-      capture_io do
-        assert_raises(RuntimeError) do
-          Padrino.require_dependencies(
-            Padrino.root("fixtures/dependencies/a.rb"),
-            Padrino.root("fixtures/dependencies/b.rb"),
-            Padrino.root("fixtures/dependencies/c.rb"),
-            Padrino.root("fixtures/dependencies/d.rb")
-          )
-        end
-      end
-      assert_equal 1, D
-    end
-
-    should 'resolve dependency problems' do
-      capture_io do
-        Padrino.require_dependencies(
-          Padrino.root("fixtures/dependencies/a.rb"),
-          Padrino.root("fixtures/dependencies/b.rb"),
-          Padrino.root("fixtures/dependencies/c.rb")
-        )
-      end
-      assert_equal ["B", "C"], A_result
-      assert_equal "C", B_result
-    end
-
-    should 'remove partially loaded constants' do
-      capture_io do
-        Padrino.require_dependencies(
-          Padrino.root("fixtures/dependencies/circular/e.rb"),
-          Padrino.root("fixtures/dependencies/circular/f.rb"),
-          Padrino.root("fixtures/dependencies/circular/g.rb")
-        )
-      end
-
-      assert_equal ["name"], F.fields
-    end
-  end
-end

data/lib/vendored-middleman-deps/padrino-core-0.11.4/test/test_filters.rb

@@ -1,348 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-describe "Filters" do
-  should "filters by accept header" do
-    mock_app do
-      get '/foo', :provides => [:xml, :js] do
-        request.env['HTTP_ACCEPT']
-      end
-    end
-
-    get '/foo', {}, { 'HTTP_ACCEPT' => 'application/xml' }
-    assert ok?
-    assert_equal 'application/xml', body
-    assert_equal 'application/xml;charset=utf-8', response.headers['Content-Type']
-
-    get '/foo.xml'
-    assert ok?
-    assert_equal 'application/xml;charset=utf-8', response.headers['Content-Type']
-
-    get '/foo', {}, { 'HTTP_ACCEPT' => 'application/javascript' }
-    assert ok?
-    assert_equal 'application/javascript', body
-    assert_equal 'application/javascript;charset=utf-8', response.headers['Content-Type']
-
-    get '/foo.js'
-    assert ok?
-    assert_equal 'application/javascript;charset=utf-8', response.headers['Content-Type']
-
-    get '/foo', {}, { "HTTP_ACCEPT" => 'text/html' }
-    assert_equal 406, status
-  end
-
-  should "allow passing & halting in before filters" do
-    mock_app do
-      controller do
-        before { env['QUERY_STRING'] == 'secret' or pass }
-        get :index do
-          "secret index"
-        end
-      end
-
-      controller do
-        before { env['QUERY_STRING'] == 'halt' and halt 401, 'go away!' }
-        get :index do
-          "index"
-        end
-      end
-    end
-
-    get "/?secret"
-    assert_equal "secret index", body
-
-    get "/?halt"
-    assert_equal "go away!", body
-    assert_equal 401, status
-
-    get "/"
-    assert_equal "index", body
-  end
-
-  should 'scope filters in the given controller' do
-    mock_app do
-      before { @global = 'global' }
-      after { @global = nil }
-
-      controller :foo do
-        before { @foo = :foo }
-        after { @foo = nil }
-        get("/") { [@foo, @bar, @global].compact.join(" ") }
-      end
-
-      get("/") { [@foo, @bar, @global].compact.join(" ") }
-
-      controller :bar do
-        before { @bar = :bar }
-        after { @bar = nil }
-        get("/") { [@foo, @bar, @global].compact.join(" ") }
-      end
-    end
-
-    get "/bar"
-    assert_equal "bar global", body
-
-    get "/foo"
-    assert_equal "foo global", body
-
-    get "/"
-    assert_equal "global", body
-  end
-
-  should 'be able to access params in a before filter' do
-    username_from_before_filter = nil
-
-    mock_app do
-      before do
-        username_from_before_filter = params[:username]
-      end
-
-      get :users, :with => :username do
-      end
-    end
-    get '/users/josh'
-    assert_equal 'josh', username_from_before_filter
-  end
-
-  should "be able to access params normally when a before filter is specified" do
-    mock_app do
-      before { }
-      get :index do
-        params.inspect
-      end
-    end
-    get '/?test=what'
-    assert_equal '{"test"=>"what"}', body
-  end
-
-  should "be able to filter based on a path" do
-    mock_app do
-      before('/') { @test = "#{@test}before"}
-      get :index do
-        @test
-      end
-      get :main do
-        @test
-      end
-    end
-    get '/'
-    assert_equal 'before', body
-    get '/main'
-    assert_equal '', body
-  end
-
-  should "be able to filter based on a symbol" do
-    mock_app do
-      before(:index) { @test = 'before'}
-      get :index do
-        @test
-      end
-      get :main do
-        @test
-      end
-    end
-    get '/'
-    assert_equal 'before', body
-    get '/main'
-    assert_equal '', body
-  end
-
-  should "be able to filter based on a symbol for a controller" do
-    mock_app do
-      controller :foo do
-        before(:test) { @test = 'foo'}
-        get :test do
-          @test.to_s + " response"
-        end
-      end
-      controller :bar do
-        before(:test) { @test = 'bar'}
-        get :test do
-          @test.to_s + " response"
-        end
-      end
-    end
-    get '/foo/test'
-    assert_equal 'foo response', body
-    get '/bar/test'
-    assert_equal 'bar response', body
-  end
-
-  should "be able to filter based on a symbol or path" do
-    mock_app do
-      before(:index, '/main') { @test = 'before'}
-      get :index do
-        @test
-      end
-      get :main do
-        @test
-      end
-    end
-    get '/'
-    assert_equal 'before', body
-    get '/main'
-    assert_equal 'before', body
-  end
-
-  should "be able to filter based on a symbol or regexp" do
-    mock_app do
-      before(:index, /main/) { @test = 'before'}
-      get :index do
-        @test
-      end
-      get :main do
-        @test
-      end
-      get :profile do
-        @test
-      end
-    end
-    get '/'
-    assert_equal 'before', body
-    get '/main'
-    assert_equal 'before', body
-    get '/profile'
-    assert_equal '', body
-  end
-
-  should "be able to filter excluding based on a symbol" do
-    mock_app do
-      before(:except => :index) { @test = 'before'}
-      get :index do
-        @test
-      end
-      get :main do
-        @test
-      end
-    end
-    get '/'
-    assert_equal '', body
-    get '/main'
-    assert_equal 'before', body
-  end
-
-  should "be able to filter based on a request param" do
-    mock_app do
-      before(:agent => /IE/) { @test = 'before'}
-      get :index do
-        @test
-      end
-    end
-    get '/'
-    assert_equal '', body
-    get "/", {}, {'HTTP_USER_AGENT' => 'This is IE'}
-    assert_equal 'before', body
-  end
-
-  should "be able to filter based on a symbol or path in multiple controller" do
-    mock_app do
-      controllers :foo do
-        before(:index, '/foo/main') { @test = 'before' }
-        get :index do
-          @test
-        end
-        get :main do
-          @test
-        end
-      end
-      controllers :bar do
-        before(:index, '/bar/main') { @test = 'also before' }
-        get :index do
-          @test
-        end
-        get :main do
-          @test
-        end
-      end
-    end
-    get '/foo'
-    assert_equal 'before', body
-    get '/bar'
-    assert_equal 'also before', body
-    get '/foo/main'
-    assert_equal 'before', body
-    get '/bar/main'
-    assert_equal 'also before', body
-  end
-
-  should "call before filters even if there was no match" do
-    test = nil
-    mock_app do
-      before(:index, '/foo') { test = 'before' }
-      get :index do
-        ''
-      end
-    end
-    get '/foo'
-    assert_equal 'before', test
-  end
-
-  should "call before filters only once" do
-    once = ''
-    mock_app do
-      error 500 do
-        'error 500'
-      end
-      before do
-        once += 'before'
-      end
-      get :index do
-        raise Exception, 'Oops'
-      end
-    end
-
-    get '/'
-    assert_equal 'before', once
-  end
-
-  should 'catch exceptions in before filters' do
-    doodle = nil
-    mock_app do
-      after do
-        doodle = 'Been after'
-      end
-      before do
-        raise StandardError, "before"
-      end
-      get :index do
-        doodle = 'Been now'
-      end
-      error 500 do
-        "We broke #{env['sinatra.error'].message}"
-      end
-    end
-
-    get '/'
-    assert_equal 'We broke before', body
-    assert_equal nil, doodle
-  end
-
-  should 'catch exceptions in after filters if no exceptions caught before' do
-    doodle = ''
-    mock_app do
-      after do
-        doodle += ' and after'
-        raise StandardError, "after"
-      end
-      get :foo do
-        doodle = 'Been now'
-        raise StandardError, "now"
-      end
-      get :index do
-        doodle = 'Been now'
-      end
-      error 500 do
-        "We broke #{env['sinatra.error'].message}"
-      end
-    end
-
-    get '/foo'
-    assert_equal 'We broke now', body
-    assert_equal 'Been now', doodle
-
-    doodle = ''
-    get '/'
-    assert_equal 'We broke after', body
-    assert_equal 'Been now and after', doodle
-  end
-
-end