middleman 2.0.7 → 2.0.8

data/lib/middleman/vendor/padrino-core-0.10.0/test/test_application.rb

@@ -1,83 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-class PadrinoTestApp < Padrino::Application; end
-class PadrinoTestApp2 < Padrino::Application; end
-
-class TestApplication < Test::Unit::TestCase
-  def setup
-    Padrino.clear!
-  end
-
-  def teardown
-    remove_views
-  end
-
-  context 'for application functionality' do
-
-    should 'check default options' do
-      assert File.identical?(__FILE__, PadrinoTestApp.app_file)
-      assert_equal :padrino_test_app, PadrinoTestApp.app_name
-      assert_equal :test, PadrinoTestApp.environment
-      assert_equal Padrino.root("views"), PadrinoTestApp.views
-      assert PadrinoTestApp.raise_errors
-      assert !PadrinoTestApp.logging
-      assert !PadrinoTestApp.sessions
-      assert !PadrinoTestApp.dump_errors
-      assert !PadrinoTestApp.show_exceptions
-      assert PadrinoTestApp.raise_errors
-      assert !Padrino.configure_apps
-    end
-
-    should 'check padrino specific options' do
-      assert !PadrinoTestApp.instance_variable_get(:@_configured)
-      PadrinoTestApp.send(:setup_application!)
-      assert_equal :padrino_test_app, PadrinoTestApp.app_name
-      assert_equal 'StandardFormBuilder', PadrinoTestApp.default_builder
-      assert PadrinoTestApp.instance_variable_get(:@_configured)
-      assert !PadrinoTestApp.reload?
-      assert !PadrinoTestApp.flash
-    end
-
-    should 'set global project settings' do
-      Padrino.configure_apps { enable :sessions; set :foo, "bar" }
-      PadrinoTestApp.send(:default_configuration!)
-      PadrinoTestApp2.send(:default_configuration!)
-      assert PadrinoTestApp.sessions, "should have sessions enabled"
-      assert_equal "bar", PadrinoTestApp.settings.foo, "should have foo assigned"
-      assert_equal PadrinoTestApp.session_secret, PadrinoTestApp2.session_secret
-    end
-
-    should "have shared sessions accessible in project" do
-      Padrino.configure_apps { enable :sessions; set :session_secret, 'secret' }
-      Padrino.mount("PadrinoTestApp").to("/write")
-      Padrino.mount("PadrinoTestApp2").to("/read")
-      PadrinoTestApp.tap { |app| app.send(:default_configuration!)
-        app.get("/") { session[:foo] = "shared" } }
-      PadrinoTestApp2.tap { |app| app.send(:default_configuration!)
-        app.get("/") { session[:foo] } }
-      browser = Rack::Test::Session.new(Rack::MockSession.new(Padrino.application))
-      browser.get '/write'
-      browser.get '/read'
-      assert_equal 'shared', browser.last_response.body
-    end
-
-    # compare to: test_routing: allow global provides
-    should "set content_type to :html if none can be determined" do
-      mock_app do
-        provides :xml
-
-        get("/foo"){ "Foo in #{content_type}" }
-        get("/bar"){ "Foo in #{content_type}" }
-      end
-
-      get '/foo', {}, { 'HTTP_ACCEPT' => 'application/xml' }
-      assert_equal 'Foo in xml', body
-      get '/foo'
-      assert_equal 'Foo in xml', body
-
-      get '/bar', {}, { 'HTTP_ACCEPT' => 'application/xml' }
-      assert_equal "Foo in html", body
-    end # content_type to :html
-  end # application functionality
-
-end

data/lib/middleman/vendor/padrino-core-0.10.0/test/test_core.rb

@@ -1,79 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-class TestCore < Test::Unit::TestCase
-  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, :bundle
-      assert_respond_to Padrino, :configure_apps
-    end
-
-
-    should 'validate global helpers' do
-      assert_equal :test, Padrino.env
-      assert_match /\/test/, Padrino.root
-      assert_equal nil, Padrino.bundle
-      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, nil # 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_raise(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/middleman/vendor/padrino-core-0.10.0/test/test_dependencies.rb

@@ -1,44 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-class TestDependencies < Test::Unit::TestCase
-  context 'when we require a dependency that have another dependency' do
-
-    should 'raise an error without reloading it twice' do
-      silence_warnings do
-        assert_raise(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
-      silence_warnings 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
-      silence_warnings 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/middleman/vendor/padrino-core-0.10.0/test/test_filters.rb

@@ -1,266 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-class TestFilters < Test::Unit::TestCase
-  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
-end