middleman-core 3.2.2 → 3.3.0

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

@@ -1,168 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-describe Padrino::Flash do
-  context 'storage' do
-    before do
-      @storage = Padrino::Flash::Storage.new(
-        :success => 'Success msg',
-        :error   => 'Error msg',
-        :notice  => 'Notice msg',
-        :custom  => 'Custom msg'
-      )
-      @storage[:one] = 'One msg'
-      @storage[:two] = 'Two msg'
-    end
-
-    should 'acts like hash' do
-      assert_respond_to @storage, :[]
-    end
-
-    should 'know its size' do
-      assert_equal 4, @storage.length
-      assert_equal @storage.length, @storage.size
-    end
-
-    should 'sweep its content' do
-      assert_equal 2, @storage.sweep.size
-      assert_empty @storage.sweep
-    end
-
-    should 'discard everything' do
-      assert_empty @storage.discard.sweep
-    end
-
-    should 'discard specified key' do
-      assert_equal 1, @storage.discard(:one).sweep.size
-    end
-
-    should 'keep everything' do
-      assert_equal 2, @storage.sweep.keep.sweep.size
-    end
-
-    should 'keep only specified key' do
-      assert_equal 1, @storage.sweep.keep(:one).sweep.size
-    end
-
-    should 'not know the values you set right away' do
-      @storage[:foo] = 'bar'
-      assert_nil @storage[:foo]
-    end
-
-    should 'knows the values you set next time' do
-      @storage[:foo] = 'bar'
-      @storage.sweep
-      assert_equal 'bar', @storage[:foo]
-    end
-
-    should 'set values for now' do
-      @storage.now[:foo] = 'bar'
-      assert_equal 'bar', @storage[:foo]
-    end
-
-    should 'forgets values you set only for now next time' do
-      @storage.now[:foo] = 'bar'
-      @storage.sweep
-      assert_nil @storage[:foo]
-    end
-  end
-
-  routes = Proc.new do
-    get :index do
-      params[:key] ? flash[params[:key].to_sym].to_s : flash.now.inspect
-    end
-
-    post :index do
-      params.each { |k,v| flash[k.to_sym] = v.to_s }
-      flash.next.inspect
-    end
-
-    get :session do
-      settings.sessions?.inspect
-    end
-
-    get :redirect do
-      redirect url(:index, :key => :foo), 301, :foo => 'redirected!'
-    end
-
-    get :success do
-      flash.success = 'Yup'
-    end
-
-    get :error do
-      flash.error = 'Arg'
-    end
-
-    get :notice do
-      flash.notice = 'Mmm'
-    end
-  end
-
-  context 'padrino application without sessions' do
-    before { mock_app(&routes) }
-
-    should 'show nothing' do
-      get '/'
-      assert_equal '{}', body
-    end
-
-    should 'set a flash' do
-      post '/', :foo => :bar
-      assert_equal '{:foo=>"bar"}', body
-    end
-  end
-
-  context 'padrino application with sessions' do
-    before do
-      mock_app { enable :sessions; class_eval(&routes) }
-    end
-
-    should 'be sure have sessions enabled' do
-      assert @app.sessions
-      get '/session'
-      assert_equal 'true', body
-    end
-
-    should 'show nothing' do
-      get '/'
-      assert_equal '{}', body
-    end
-
-    should 'set a flash' do
-      post '/', :foo => :bar
-      assert_equal '{:foo=>"bar"}', body
-    end
-
-    should 'get a flash' do
-      post '/', :foo => :bar
-      get  '/', :key => :foo
-      assert_equal 'bar', body
-      post '/'
-      assert_equal '{}', body
-    end
-
-    should 'follow redirects with flash' do
-      get '/redirect'
-      follow_redirect!
-      assert_equal 'redirected!', body
-      assert 301, status
-    end
-
-    should 'set success' do
-      get '/success'
-      get '/', :key => :success
-      assert_equal 'Yup', body
-    end
-
-    should 'set error' do
-      get '/error'
-      get '/', :key => :error
-      assert_equal 'Arg', body
-    end
-
-    should 'set notice' do
-      get '/notice'
-      get '/', :key => :notice
-      assert_equal 'Mmm', body
-    end
-  end
-end

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

@@ -1,21 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-describe "Locales" do
-  Dir[File.expand_path("../../lib/padrino-core/locale/*.yml", __FILE__)].each do |file|
-    base_original = YAML.load_file(file)
-    name = File.basename(file, '.yml')
-    should "should have correct locale for #{name}" do
-      base = base_original[name]['date']['formats']
-      assert base['default'].present?
-      assert base['short'].present?
-      assert base['long'].present?
-      assert base['only_day'].present?
-      base = base_original[name]['date']
-      assert base['day_names'].present?
-      assert base['abbr_day_names'].present?
-      assert base['month_names'].present?
-      assert base['abbr_month_names'].present?
-      assert base['order'].present?
-    end
-  end
-end

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

@@ -1,210 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-require 'lumberjack'
-require 'logger'
-
-describe "PadrinoLogger" do
-
-  def setup
-    Padrino::Logger::Config[:test][:stream] = :null # The default
-    Padrino::Logger.setup!
-  end
-
-  def setup_logger(options={})
-    @log    = StringIO.new
-    @logger = Padrino::Logger.new(options.merge(:stream => @log))
-  end
-
-  context 'for logger functionality' do
-
-    context 'check stream config' do
-
-      should 'use stdout if stream is nil' do
-        Padrino::Logger::Config[:test][:stream] = nil
-        Padrino::Logger.setup!
-        assert_equal $stdout, Padrino.logger.log
-      end
-
-      should 'use StringIO as default for test' do
-        assert_instance_of StringIO, Padrino.logger.log
-      end
-
-      should 'use a custom stream' do
-        my_stream = StringIO.new
-        Padrino::Logger::Config[:test][:stream] = my_stream
-        Padrino::Logger.setup!
-        assert_equal my_stream, Padrino.logger.log
-      end
-    end
-
-    should 'log something' do
-      setup_logger(:log_level => :error)
-      @logger.error "You log this error?"
-      assert_match(/You log this error?/, @log.string)
-      @logger.debug "You don't log this error!"
-      assert_no_match(/You don't log this error!/, @log.string)
-      @logger << "Yep this can be logged"
-      assert_match(/Yep this can be logged/, @log.string)
-    end
-
-    should 'respond to #write for Rack::CommonLogger' do
-      setup_logger(:log_level => :error)
-      @logger.error "Error message"
-      assert_match /Error message/, @log.string
-      @logger << "logged anyways"
-      assert_match /logged anyways/, @log.string
-      @logger.write "log via alias"
-      assert_match /log via alias/, @log.string
-    end
-
-    should 'log an application' do
-      mock_app do
-        enable :logging
-        get("/"){ "Foo" }
-      end
-      get "/"
-      assert_equal "Foo", body
-      assert_match /GET/, Padrino.logger.log.string
-    end
-
-    should 'log an application\'s status code' do
-      mock_app do
-        enable :logging
-        get("/"){ "Foo" }
-      end
-      get "/"
-      assert_match /\e\[1m200\e\[0m OK/, Padrino.logger.log.string
-    end
-
-    context "static asset logging" do
-      should 'not log static assets by default' do
-        mock_app do
-          enable :logging
-          get("/images/something.png"){ env["sinatra.static_file"] = '/public/images/something.png'; "Foo" }
-        end
-        get "/images/something.png"
-        assert_equal "Foo", body
-        assert_match "", Padrino.logger.log.string
-      end
-
-      should 'allow turning on static assets logging' do
-        Padrino.logger.instance_eval{ @log_static = true }
-        mock_app do
-          enable :logging
-          get("/images/something.png"){ env["sinatra.static_file"] = '/public/images/something.png'; "Foo" }
-        end
-        get "/images/something.png"
-        assert_equal "Foo", body
-        assert_match /GET/, Padrino.logger.log.string
-        Padrino.logger.instance_eval{ @log_static = false }
-      end
-    end
-
-    context "health-check requests logging" do
-      def access_to_mock_app
-        mock_app do
-          enable :logging
-          get("/"){ "Foo" }
-        end
-        get "/"
-      end
-
-      should 'output under debug level' do
-        Padrino.logger.instance_eval{ @level = Padrino::Logger::Levels[:debug] }
-        access_to_mock_app
-        assert_match /\e\[36m  DEBUG\e\[0m/, Padrino.logger.log.string
-
-        Padrino.logger.instance_eval{ @level = Padrino::Logger::Levels[:devel] }
-        access_to_mock_app
-        assert_match /\e\[36m  DEBUG\e\[0m/, Padrino.logger.log.string
-      end
-      should 'not output over debug level' do
-        Padrino.logger.instance_eval{ @level = Padrino::Logger::Levels[:info] }
-        access_to_mock_app
-        assert_equal '', Padrino.logger.log.string
-
-        Padrino.logger.instance_eval{ @level = Padrino::Logger::Levels[:error] }
-        access_to_mock_app
-        assert_equal '', Padrino.logger.log.string
-      end
-    end
-  end
-end
-
-describe "alternate logger: Lumberjack" do
-  def setup_logger
-    @log = StringIO.new
-    Padrino.logger = Lumberjack::Logger.new(@log, :level => :debug)
-  end
-
-  should "annotate the logger to support additional Padrino fancyness" do
-    setup_logger
-    Padrino.logger.debug("Debug message")
-    assert_match(/Debug message/, @log.string)
-  end
-
-  should "colorize log output after colorize! is called" do
-    setup_logger
-    Padrino.logger.colorize!
-
-    mock_app do
-      enable :logging
-      get("/"){ "Foo" }
-    end
-    get "/"
-
-    assert_match /\e\[1m200\e\[0m OK/, @log.string
-  end
-end
-
-describe "alternate logger: stdlib logger" do
-  def setup_logger
-    @log = StringIO.new
-    Padrino.logger = Logger.new(@log)
-  end
-
-  should "annotate the logger to support additional Padrino fancyness" do
-    setup_logger
-    Padrino.logger.debug("Debug message")
-    assert_match(/Debug message/, @log.string)
-  end
-
-  should "colorize log output after colorize! is called" do
-    setup_logger
-    Padrino.logger.colorize!
-
-    mock_app do
-      enable :logging
-      get("/"){ "Foo" }
-    end
-    get "/"
-
-    assert_match /\e\[1m200\e\[0m OK/, @log.string
-  end
-end
-
-describe "options :colorize_logging" do
-  def access_to_mock_app
-    mock_app do
-      enable :logging
-      get("/"){ "Foo" }
-    end
-    get "/"
-  end
-  context 'default' do
-    should 'use colorize logging' do
-      Padrino::Logger.setup!
-
-      access_to_mock_app
-      assert_match /\e\[1m200\e\[0m OK/, Padrino.logger.log.string
-    end
-  end
-  context 'set value is false' do
-    should 'not use colorize logging' do
-      Padrino::Logger::Config[:test][:colorize_logging] = false
-      Padrino::Logger.setup!
-
-      access_to_mock_app
-      assert_match /200 OK/, Padrino.logger.log.string
-    end
-  end
-end

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

@@ -1,199 +0,0 @@
-require File.expand_path(File.dirname(__FILE__) + '/helper')
-
-describe "Mounter" do
-  class ::TestApp < Padrino::Application; end
-
-  def setup
-    $VERBOSE, @_verbose_was = nil, $VERBOSE
-    Padrino.clear!
-  end
-
-  def teardown
-    $VERBOSE = @_verbose_was
-  end
-
-  context 'for mounter functionality' do
-    should 'check methods' do
-      mounter = Padrino::Mounter.new("test_app", :app_file => "/path/to/test.rb")
-      mounter.to("/test_app")
-      assert_kind_of Padrino::Mounter, mounter
-      assert_respond_to Padrino::Mounter, :new
-      assert_respond_to mounter, :to
-      assert_respond_to mounter, :map_onto
-      assert_equal "test_app", mounter.name
-      assert_equal "TestApp", mounter.app_class
-      assert_equal "/path/to/test.rb", mounter.app_file
-      assert_equal "/test_app", mounter.uri_root
-      assert_equal File.dirname(mounter.app_file), mounter.app_root
-    end
-
-    should 'check locate_app_file with __FILE__' do
-      mounter = Padrino::Mounter.new("test_app", :app_file => __FILE__)
-      mounter.to("/test_app")
-      assert_equal "test_app", mounter.name
-      assert_equal "TestApp", mounter.app_class
-      assert_equal __FILE__, mounter.app_file
-      assert_equal "/test_app", mounter.uri_root
-      assert_equal File.dirname(mounter.app_file), mounter.app_root
-    end
-
-    should 'mount an app' do
-      class ::AnApp < Padrino::Application; end
-      Padrino.mount("an_app").to("/")
-      assert_equal AnApp, Padrino.mounted_apps.first.app_obj
-      assert_equal ["an_app"], Padrino.mounted_apps.map(&:name)
-    end
-
-    should 'correctly mount an app in a namespace' do
-      module ::SomeNamespace
-        class AnApp < Padrino::Application; end
-      end
-      Padrino.mount("some_namespace/an_app").to("/")
-      assert_equal SomeNamespace::AnApp, Padrino.mounted_apps.first.app_obj
-      assert_equal ["some_namespace/an_app"], Padrino.mounted_apps.map(&:name)
-    end
-
-    should 'mount a primary app to root uri' do
-      mounter = Padrino.mount("test_app", :app_file => __FILE__).to("/")
-      assert_equal "test_app", mounter.name
-      assert_equal "TestApp", mounter.app_class
-      assert_equal TestApp, mounter.app_obj
-      assert_equal __FILE__, mounter.app_file
-      assert_equal "/", mounter.uri_root
-      assert_equal File.dirname(mounter.app_file), mounter.app_root
-    end
-
-    should 'mount a primary app to sub_uri' do
-      mounter = Padrino.mount("test_app", :app_file => __FILE__).to('/me')
-      assert_equal "test_app", mounter.name
-      assert_equal "TestApp", mounter.app_class
-      assert_equal TestApp, mounter.app_obj
-      assert_equal __FILE__, mounter.app_file
-      assert_equal "/me", mounter.uri_root
-      assert_equal File.dirname(mounter.app_file), mounter.app_root
-    end
-
-    should "raise error when app has no located file" do
-      # TODO enabling this screws minitest
-      # assert_raises(Padrino::Mounter::MounterException) { Padrino.mount("tester_app").to('/test') }
-      assert_equal 0, Padrino.mounted_apps.size
-    end
-
-    should "raise error when app has no located object" do
-      assert_raises(Padrino::Mounter::MounterException) { Padrino.mount("tester_app", :app_file => "/path/to/file.rb").to('/test') }
-      assert_equal 0, Padrino.mounted_apps.size
-    end
-
-    should 'mount multiple apps' do
-      class ::OneApp < Padrino::Application; end
-      class ::TwoApp < Padrino::Application; end
-
-      Padrino.mount("one_app").to("/one_app")
-      Padrino.mount("two_app").to("/two_app")
-      # And testing no duplicates
-      Padrino.mount("one_app").to("/one_app")
-      Padrino.mount("two_app").to("/two_app")
-
-      assert_equal OneApp, Padrino.mounted_apps[0].app_obj
-      assert_equal TwoApp, Padrino.mounted_apps[1].app_obj
-      assert_equal 2, Padrino.mounted_apps.size, "should not mount duplicate apps"
-      assert_equal ["one_app", "two_app"], Padrino.mounted_apps.map(&:name)
-    end
-
-    should 'change mounted_root' do
-      Padrino.mounted_root = "fixtures"
-      assert_equal Padrino.root("fixtures", "test", "app.rb"), Padrino.mounted_root("test", "app.rb")
-      Padrino.mounted_root = "apps"
-      assert_equal Padrino.root("apps", "test", "app.rb"), Padrino.mounted_root("test", "app.rb")
-      Padrino.mounted_root = nil
-      assert_equal Padrino.root("test", "app.rb"), Padrino.mounted_root("test", "app.rb")
-    end
-
-    should "be able to access routes data for mounted apps" do
-      class ::OneApp < Padrino::Application
-        get("/test") { "test" }
-        get(:index, :provides => [:js, :json]) { "index" }
-        get(%r{/foo|/baz}) { "regexp" }
-        controllers :posts do
-          get(:index) { "index" }
-          get(:new, :provides => :js) { "new" }
-          get(:show, :provides => [:js, :html], :with => :id) { "show" }
-          post(:create, :provides => :js, :with => :id) { "create" }
-          get(:regexp, :map => %r{/foo|/baz}) { "regexp" }
-        end
-      end
-      class ::TwoApp < Padrino::Application
-        controllers :users do
-          get(:index) { "users" }
-          get(:new) { "users new" }
-          post(:create) { "users create" }
-          put(:update) { "users update" }
-          delete(:destroy) { "users delete" }
-        end
-      end
-
-      Padrino.mount("one_app").to("/")
-      Padrino.mount("two_app").to("/two_app")
-
-      assert_equal 15, Padrino.mounted_apps[0].routes.size
-      assert_equal 7, Padrino.mounted_apps[1].routes.size
-      assert_equal 6, Padrino.mounted_apps[0].named_routes.size
-      assert_equal 5, Padrino.mounted_apps[1].named_routes.size
-
-      first_route = Padrino.mounted_apps[0].named_routes[3]
-      assert_equal "posts_show", first_route.identifier.to_s
-      assert_equal "(:posts, :show)", first_route.name
-      assert_equal "GET", first_route.verb
-      assert_equal "/posts/show/:id(.:format)", first_route.path
-      another_route = Padrino.mounted_apps[1].named_routes[2]
-      assert_equal "users_create", another_route.identifier.to_s
-      assert_equal "(:users, :create)", another_route.name
-      assert_equal "POST", another_route.verb
-      assert_equal "/two_app/users/create", another_route.path
-      regexp_route = Padrino.mounted_apps[0].named_routes[5]
-      assert_equal "posts_regexp", regexp_route.identifier.to_s
-      assert_equal "(:posts, :regexp)", regexp_route.name
-      assert_equal "/\\/foo|\\/baz/", regexp_route.path
-    end
-
-    should 'correctly instantiate a new padrino application' do
-      mock_app do
-        get("/demo_1"){ "Im Demo 1" }
-        get("/demo_2"){ "Im Demo 2" }
-      end
-
-      get '/demo_1'
-      assert_equal "Im Demo 1", response.body
-      get '/demo_2'
-      assert_equal "Im Demo 2", response.body
-    end
-
-    should "not clobber the public setting when mounting an app" do
-      class ::PublicApp < Padrino::Application
-        set :root, "/root"
-        set :public_folder, File.expand_path(File.dirname(__FILE__))
-      end
-
-      Padrino.mount("public_app").to("/public")
-      res = Rack::MockRequest.new(Padrino.application).get("/public/test_mounter.rb")
-      assert res.ok?
-      assert_equal File.read(__FILE__), res.body
-    end
-
-    should "load apps from gems" do
-      spec_file = Padrino.root("fixtures", "app_gem", "app_gem.gemspec")
-      spec = Gem::Specification.load(spec_file)
-      spec.activate
-      def spec.full_gem_path
-        Padrino.root("fixtures", "app_gem")
-      end
-
-      require Padrino.root("fixtures", "app_gem", "lib", "app_gem")
-
-      Padrino.mount("AppGem::App").to("/from_gem")
-      mounter = Padrino.mounted_apps[0]
-      assert_equal AppGem::App, mounter.app_obj
-      assert_equal Padrino.root('public'), mounter.app_obj.public_folder
-    end
-  end
-end