padrino-core 0.10.7 → 0.11.0

data/test/test_flash.rb

@@ -0,0 +1,168 @@
+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/test/test_logger.rb

@@ -152,3 +152,30 @@ describe "alternate logger: stdlib logger" do
     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/test/test_mounter.rb

@@ -113,11 +113,13 @@ describe "Mounter" 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
@@ -133,9 +135,9 @@ describe "Mounter" do
       Padrino.mount("one_app").to("/")
       Padrino.mount("two_app").to("/two_app")
 
-      assert_equal 11, Padrino.mounted_apps[0].routes.size
+      assert_equal 15, Padrino.mounted_apps[0].routes.size
       assert_equal 7, Padrino.mounted_apps[1].routes.size
-      assert_equal 5, Padrino.mounted_apps[0].named_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]
@@ -148,6 +150,10 @@ describe "Mounter" do
       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
@@ -173,5 +179,21 @@ describe "Mounter" do
       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

data/test/test_reloader_simple.rb

@@ -78,20 +78,20 @@ describe "SimpleReloader" do
       last_body = body
       assert_equal 2, @app.filters[:before].size # one is ours the other is default_filter for content type
       assert_equal 1, @app.errors.size
-      assert_equal 1, @app.filters[:after].size
+      assert_equal 2, @app.filters[:after].size # app + content-type + padrino-flash
       assert_equal 0, @app.middleware.size
       assert_equal 4, @app.routes.size # GET+HEAD of "/" + GET+HEAD of "/rand" = 4
-      assert_equal 2, @app.extensions.size # [Padrino::Routing, Padrino::Rendering]
+      assert_equal 3, @app.extensions.size # [Padrino::Routing, Padrino::Rendering, Padrino::Flash]
       assert_equal 0, @app.templates.size
       @app.reload!
       get "/rand"
       assert_not_equal last_body, body
       assert_equal 2, @app.filters[:before].size # one is ours the other is default_filter for content type
       assert_equal 1, @app.errors.size
-      assert_equal 1, @app.filters[:after].size
+      assert_equal 2, @app.filters[:after].size
       assert_equal 0, @app.middleware.size
       assert_equal 4, @app.routes.size # GET+HEAD of "/" = 2
-      assert_equal 2, @app.extensions.size # [Padrino::Routing, Padrino::Rendering]
+      assert_equal 3, @app.extensions.size # [Padrino::Routing, Padrino::Rendering, Padrino::Flash]
       assert_equal 0, @app.templates.size
     end
   end

data/test/test_rendering.rb

@@ -1,5 +1,6 @@
 require File.expand_path(File.dirname(__FILE__) + '/helper')
 require 'i18n'
+require 'slim'
 
 describe "Rendering" do
   def setup
@@ -28,7 +29,7 @@ describe "Rendering" do
           "this is a <%= yield %>"
         end
 
-        get("/"){ render :erb, "sinatra layout" }
+        get("/"){ render :erb, "sinatra layout", :layout => true }
       end
 
       get "/"
@@ -137,6 +138,7 @@ describe "Rendering" do
     should 'use correct layout with each controller' do
       create_layout :foo, "foo layout at <%= yield %>"
       create_layout :bar, "bar layout at <%= yield %>"
+      create_layout :baz, "baz layout at <%= yield %>"
       create_layout :application, "default layout at <%= yield %>"
       mock_app do
         get("/"){ render :erb, "application" }
@@ -148,6 +150,10 @@ describe "Rendering" do
           layout :bar
           get("/"){ render :erb, "bar" }
         end
+        controller :baz do
+          layout :baz
+          get("/"){ render :erb, "baz", :layout => true }
+        end
         controller :none do
           get("/") { render :erb, "none" }
           get("/with_foo_layout")  { render :erb, "none with layout", :layout => :foo }
@@ -157,6 +163,8 @@ describe "Rendering" do
       assert_equal "foo layout at foo", body
       get "/bar"
       assert_equal "bar layout at bar", body
+      get "/baz"
+      assert_equal "baz layout at baz", body
       get "/none"
       assert_equal "default layout at none", body
       get "/none/with_foo_layout"
@@ -207,7 +215,7 @@ describe "Rendering" do
       create_view :index, "<%= foo %>"
       mock_app do
         enable :logging
-        get("/") { render "index", { :layout => true }, { :foo => "bar" } }
+        get("/") { render "index", { :layout => nil }, { :foo => "bar" } }
       end
       get "/"
       assert_equal "bar", body
@@ -396,7 +404,7 @@ describe "Rendering" do
       assert_equal "Im Italian Js", body
       I18n.locale = :en
       get "/foo.pk"
-      assert_equal 405, status
+      assert_equal 404, status
     end
 
     should 'resolve template content_type and locale with layout' do
@@ -438,7 +446,7 @@ describe "Rendering" do
       get "/bar.json"
       assert_equal "Im a json", body
       get "/bar.pk"
-      assert_equal 405, status
+      assert_equal 404, status
     end
 
     should 'renders erb with blocks' do
@@ -457,5 +465,68 @@ describe "Rendering" do
       assert ok?
       assert_equal 'THIS. IS. SPARTA!', body
     end
+
+    should 'render erb to a SafeBuffer' do
+      mock_app do
+        layout do
+          "this is a <%= yield %>"
+        end
+        get '/' do
+          render :erb, '<p><%= %q{<script lang="ronin">alert("https://github.com/ronin-ruby/ronin")</script>} %></p>', :layout => false
+        end
+        get '/with_layout' do
+          render :erb, '<span>span</span>', :layout => true
+        end
+      end
+      get '/'
+      assert ok?
+      assert_equal '<p>&lt;script lang=&quot;ronin&quot;&gt;alert(&quot;https://github.com/ronin-ruby/ronin&quot;)&lt;/script&gt;</p>', body
+
+      get '/with_layout'
+      assert ok?
+      assert_equal 'this is a <span>span</span>', body
+    end
+
+    should 'render haml to a SafeBuffer' do
+      mock_app do
+        layout do
+          "%p= yield"
+        end
+        get '/' do
+          render :haml, '%p= %s{<script lang="ronin">alert("https://github.com/ronin-ruby/ronin")</script>}', :layout => false
+        end
+        get '/with_layout' do
+          render :haml, "%div\n  foo", :layout => true
+        end
+      end
+      get '/'
+      assert ok?
+      assert_equal '<p>&lt;script lang=&quot;ronin&quot;&gt;alert(&quot;https://github.com/ronin-ruby/ronin&quot;)&lt;/script&gt;</p>', body.strip
+
+      get 'with_layout'
+      assert ok?
+      assert_equal '<p><div>foo</div></p>', body.gsub(/\s+/, "")
+    end
+
+    should 'render slim to a SafeBuffer' do
+      mock_app do
+        layout do
+          "p= yield"
+        end
+        get '/' do
+          render :slim, 'p = %q{<script lang="ronin">alert("https://github.com/ronin-ruby/ronin")</script>}', :layout => false
+        end
+        get "/with_layout" do
+          render :slim, 'div foo', :layout => true
+        end
+      end
+      get '/'
+      assert ok?
+      assert_equal '<p>&lt;script lang=&quot;ronin&quot;&gt;alert(&quot;https://github.com/ronin-ruby/ronin&quot;)&lt;/script&gt;</p>', body.strip
+
+      get '/with_layout'
+      assert ok?
+      assert_equal '<p><div>foo</div></p>', body.strip
+    end
   end
 end

data/test/test_routing.rb

@@ -57,12 +57,12 @@ describe "Routing" do
 
   should 'accept regexp routes' do
     mock_app do
-      get(%r{/fob|/baz}) { "regexp" }
+      get(%r./fob|/baz.) { "regexp" }
       get("/foo")        { "str" }
-      get %r{/([0-9]+)/} do |num|
-       "Your lucky number: #{num} #{params[:captures].first}"
+      get %r./([0-9]+)/. do |num|
+        "Your lucky number: #{num} #{params[:captures].first}"
       end
-      get /\/page\/([0-9]+)|\// do |num|
+      get %r./page/([0-9]+)|/. do |num|
         "My lucky number: #{num} #{params[:captures].first}"
       end
     end
@@ -72,8 +72,8 @@ describe "Routing" do
     assert_equal "regexp", body
     get "/baz"
     assert_equal "regexp", body
-    get "/1234/"
-    assert_equal "Your lucky number: 1234 1234", body
+    get "/321/"
+    assert_equal "Your lucky number: 321 321", body
     get "/page/99"
     assert_equal "My lucky number: 99 99", body
   end
@@ -138,9 +138,9 @@ describe "Routing" do
       post("/main"){ "hello" }
     end
     assert_equal 3, app.routes.size, "should generate GET, HEAD and PUT"
-    assert_equal ["GET"],  app.routes[0].conditions[:request_method]
-    assert_equal ["HEAD"], app.routes[1].conditions[:request_method]
-    assert_equal ["POST"], app.routes[2].conditions[:request_method]
+    assert_equal "GET",  app.routes[0].request_methods.first
+    assert_equal "HEAD", app.routes[1].request_methods.first
+    assert_equal "POST", app.routes[2].request_methods.first
   end
 
   should 'generate basic urls' do
@@ -192,13 +192,13 @@ describe "Routing" do
     get "/b.js"
     assert_equal "/b.js", body
     get "/b.ru"
-    assert_equal 405, status
+    assert_equal 404, status
     get "/c.js"
     assert_equal "/c.json", body
     get "/c.json"
     assert_equal "/c.json", body
     get "/c.ru"
-    assert_equal 405, status
+    assert_equal 404, status
     get "/d"
     assert_equal "/d.js?foo=bar", body
     get "/d.js"
@@ -255,7 +255,7 @@ describe "Routing" do
     end
 
     get "/a.xml", {}, {}
-    assert_equal 405, status
+    assert_equal 404, status
   end
 
   should "not set content_type to :html if Accept */* and html not in provides" do
@@ -276,15 +276,6 @@ describe "Routing" do
     assert_equal 'json', body
   end
 
-  should "set content_type to :json if render => :json" do
-    mock_app do
-      get("/foo"){ render :foo => :bar }
-    end
-
-    get '/foo'
-    assert_equal 'application/json;charset=utf-8', content_type
-  end
-
   should 'set and get content_type' do
     mock_app do
       get("/foo"){ content_type(:json); content_type.to_s }
@@ -303,6 +294,7 @@ describe "Routing" do
   end
 
   should "allow .'s in param values" do
+    skip
     mock_app do
       get('/id/:email', :provides => [:json]) { |email, format| [email, format] * '/' }
     end
@@ -343,7 +335,7 @@ describe "Routing" do
     end
 
     get "/a.xml", {}, {"HTTP_ACCEPT" => "text/html"}
-    assert_equal 405, status
+    assert_equal 404, status
   end
 
   should "generate routes for format simple" do
@@ -371,20 +363,32 @@ describe "Routing" do
     assert_equal "mini", body
   end
 
-  should "support not_found" do
+  should "should inject the action name into the request" do
     mock_app do
-      not_found do
-        response.status = 404
-        'whatever'
+      controller :posts do
+        get('/omnomnom(/:id)') { request.action.inspect }
+        controller :mini do
+          get([:a, :b, :c]) { request.action.inspect }
+        end
       end
+    end
+    get "/posts/omnomnom"
+    assert_equal "\"/omnomnom(/:id)\"", body
+    get "/mini/a/b/c"
+    assert_equal ":a", body
+  end
+
+  should "support not_found" do
+    mock_app do
+      not_found { 'whatever' }
 
       get :index, :map => "/" do
         'index'
       end
     end
-    get '/something'
-    assert_equal 'whatever', body
+    get '/wrong'
     assert_equal 404, status
+    assert_equal 'whatever', body
     get '/'
     assert_equal 'index', body
     assert_equal 200, status
@@ -393,7 +397,7 @@ describe "Routing" do
   should "should inject the route into the request" do
     mock_app do
       controller :posts do
-        get(:index) { request.route_obj.named.to_s }
+        get(:index) { request.route_obj.name.to_s }
       end
     end
     get "/posts"
@@ -741,7 +745,27 @@ describe "Routing" do
     assert_equal 404, status
   end
 
+  should "match params and format" do
+    app = mock_app do
+      get '/:id', :provides => [:json, :html] do |id, _|
+        id
+      end
+
+      get 'format/:id', :provides => [:json, :html] do |id, format|
+        format
+      end
+    end
+
+    get '/123.html'
+    assert_equal '123', body
+
+    get 'format/123.html'
+    assert_equal 'html', body
+  end
+
+
   should 'respect priorities' do
+    skip
     route_order = []
     mock_app do
       get(:index, :priority => :normal) { route_order << :normal; pass }
@@ -815,6 +839,55 @@ describe "Routing" do
     assert_equal "show 3 1 2", body
   end
 
+  should "respect parent precedence: controllers parents go before route parents" do
+    mock_app do
+      controllers :project do
+        get(:index, :parent => :user) { "index #{params[:user_id]}" }
+      end
+
+      controllers :bar, :parent => :foo do
+        get(:index) { "index on foo #{params[:foo_id]} @ bar" }
+        get(:index, :parent => :baz) { "index on foo #{params[:foo_id]} @ baz #{params[:baz_id]} @ bar" }
+      end
+    end
+
+    get "/user/1/project"
+    assert_equal "index 1", body
+    get "/foo/1/bar"
+    assert_equal "index on foo 1 @ bar", body
+    get "/foo/1/baz/2/bar"
+    assert_equal "index on foo 1 @ baz 2 @ bar", body
+  end
+
+  should "keep a reference to the parent on the route" do
+    mock_app do
+      controllers :project do
+        get(:index, :parent => :user) { "index #{params[:user_id]}" }
+        get(:index, :parent => [:user, :section]) { "index #{params[:user_id]} #{params[:section_id]}" }
+        get(:edit, :with => :id, :parent => :user) { "edit #{params[:id]} #{params[:user_id]}"}
+        get(:show, :with => :id, :parent => [:user, :product]) { "show #{params[:id]} #{params[:user_id]} #{params[:product_id]}"}
+      end
+
+      controllers :bar, :parent => :foo do
+        get(:index) { "index on foo/bar" }
+        get(:index, :parent => :baz) { "index on foo/baz/bar" }
+      end
+    end
+
+    # get "/user/1/project"
+    assert_equal :user, @app.routes[0].parent
+    # get "/user/1/section/3/project"
+    assert_equal [:user, :section], @app.routes[2].parent
+    # get "/user/1/project/edit/2"
+    assert_equal :user, @app.routes[4].parent
+    # get "/user/1/product/2/project/show/3"
+    assert_equal [:user, :product], @app.routes[6].parent
+    # get "/foo/1/bar"
+    assert_equal :foo, @app.routes[8].parent
+    # get "/foo/1/baz/2/bar"
+    assert_equal [:foo, :baz], @app.routes[10].parent
+  end
+
   should "apply parent to controller" do
     mock_app do
       controller :project, :parent => :user do
@@ -1323,11 +1396,11 @@ describe "Routing" do
     get "/.json"
     assert_equal "This is the get index.json", body
     get "/.js"
-    assert_equal 405, status
+    assert_equal 404, status
     post "/.json"
     assert_equal "This is the post index.json", body
     post "/.js"
-    assert_equal 405, status
+    assert_equal 404, status
   end
 
   should "allow controller level mapping" do
@@ -1349,6 +1422,33 @@ describe "Routing" do
     assert_equal "1, 2", body
   end
 
+  should "replace name of named controller with mapping path" do
+    mock_app do
+      controller :ugly, :map => "/pretty/:id" do
+        get(:url3) { "#{params[:id]}" }
+        get(:url4, :map => 'test-:id2') { "#{params[:id]}, #{params[:id2]}" }
+      end
+      controller :voldemort, :map => "" do
+        get(:url5) { "okay" }
+      end
+    end
+
+    url = @app.url(:ugly, :url3, :id => 1)
+    assert_equal "/pretty/1/url3", url
+    get url
+    assert_equal "1", body
+
+    url = @app.url(:ugly, :url4, 3, 5)
+    assert_equal "/pretty/3/test-5", url
+    get url
+    assert_equal "3, 5", body
+
+    url = @app.url(:voldemort, :url5)
+    assert_equal "/url5", url
+    get url
+    assert_equal 'okay', body
+  end
+
   should 'use absolute and relative maps' do
     mock_app do
       controller :one do
@@ -1544,8 +1644,8 @@ describe "Routing" do
   end
 
   should "have overideable format" do
+    ::Rack::Mime::MIME_TYPES[".other"] = "text/html"
     mock_app do
-      ::Rack::Mime::MIME_TYPES[".other"] = "text/html"
       before do
         params[:format] ||= :other
       end
@@ -1553,6 +1653,7 @@ describe "Routing" do
     end
     get "/format_test"
     assert_equal "other", body
+    ::Rack::Mime::MIME_TYPES.delete('.other')
   end
 
   should 'invokes handlers registered with ::error when raised' do
@@ -1626,13 +1727,33 @@ describe "Routing" do
     assert_match /not found/, body
   end
 
-  should 'render a custom 404 page' do
+  should 'render a custom 404 page using not_found' do
     mock_app do
-      error(404) { "not found" }
+      not_found { "custom 404 not found" }
     end
     get "/"
     assert_equal 404, status
-    assert_match /not found/, body
+    assert_equal "custom 404 not found", body
+  end
+
+  should 'render a custom error page using error method' do
+    skip
+    mock_app do
+      error(404) { "custom 404 error" }
+    end
+    get "/"
+    assert_equal 404, status
+    assert_equal "custom 404 error", body
+  end
+
+  should 'render a custom 403 page' do
+    mock_app do
+      error(403) { "custom 403 not found" }
+      get("/") { status 403 }
+    end
+    get "/"
+    assert_equal 403, status
+    assert_equal "custom 403 not found", body
   end
 
   should 'recognize paths' do
@@ -1692,4 +1813,12 @@ describe "Routing" do
     get @app.url(:index, :page => 10)
     assert_equal "/paginate/66", body
   end
+
+  should 'not route get :users, :with => :id to /users//' do
+    mock_app do
+      get(:users, :with => :id) { 'boo' }
+    end
+    get '/users//'
+    assert_equal 404, status
+  end
 end