middleman 2.0.4 → 2.0.5

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

@@ -0,0 +1,83 @@
+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

@@ -0,0 +1,79 @@
+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

@@ -0,0 +1,44 @@
+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

@@ -0,0 +1,266 @@
+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