racket-mvc 0.4.0 → 0.5.0

data/spec/_custom.rb

@@ -6,17 +6,36 @@ describe 'A custom Racket test application' do
       logger: nil,
       my_custom_secret: 42,
       mode: :dev,
-      view_dir: 'templates'
+      view_dir: 'templates',
+      warmup_urls: ['/sub1', '/sub2', '/sub3']
     )
   end
 
+  it 'should be able to locate a resource' do
+    get '/' # Ensures that app is loaded, otherwise Racket.resource_path may pick up settings from previously run test suites.
+    resource_path = Racket.resource_path('files', 'stuff.rb')
+    resource_path.should.equal(Pathname.new("files/stuff.rb").cleanpath.expand_path)
+  end
+
+  it 'should be able to require a resource' do
+    get '/' # Ensures that app is loaded, otherwise Racket.resource_path may pick up settings from previously run test suites.
+    Racket.require('files', 'stuff.rb')
+    stuff.should.equal('Stuff That Dreams Are Made of')
+  end
+
+  it 'should run in dev mode when requested' do
+    app.dev_mode?.should.equal(true)
+  end
+
   it 'should set requested settings' do
-    app.settings.default_layout.should.equal('zebra.*')
-    app.settings.view_dir.should.equal(Racket::Utils.build_path('templates'))
+    settings = app.instance_variable_get(:@registry).application_settings
+    settings.default_layout.should.equal('zebra.*')
+    view_dir = Pathname.new('templates').cleanpath.expand_path
+    settings.view_dir.should.equal(view_dir)
   end
 
   it 'should get the correct middleware' do
-    middleware = app.settings.middleware
+    middleware = app.instance_variable_get(:@registry).application_settings.middleware
     middleware.length.should.equal(3)
     middleware[0].class.should.equal(Array)
     middleware[0].length.should.equal(1)
@@ -55,10 +74,10 @@ describe 'A custom Racket test application' do
 
   it 'should be able to require custom files' do
     Module.constants.should.not.include(:Blob)
-    Racket.require 'extra/blob'
+    app.require 'extra/blob'
     Module.constants.should.include(:Blob)
     Module.constants.should.not.include(:InnerBlob)
-    Racket.require 'extra', 'blob', 'inner_blob'
+    app.require 'extra', 'blob', 'inner_blob'
     Module.constants.should.include(:InnerBlob)
   end
 
@@ -84,6 +103,20 @@ describe 'A custom Racket test application' do
     last_response.body.should.equal("The secret is 42!\n")
   end
 
+  it 'should be able to render custom files with controller' do
+    get '/sub3/render_a_file_with_controller'
+    last_response.status.should.equal(200)
+    last_response.headers['Content-Type'].should.equal('text/html')
+    last_response.body.should.equal("123")
+  end
+  
+  it 'should be able to render custom files with settings' do
+    get '/sub3/render_a_file_with_settings'
+    last_response.status.should.equal(200)
+    last_response.headers['Content-Type'].should.equal('text/html')
+    last_response.body.should.equal("\n1\n2\n3\n")
+  end
+
   it 'should be able to send files with auto mime type' do
     get '/sub1/send_existing_file_auto_mime'
     last_response.status.should.equal(200)
@@ -136,19 +169,36 @@ describe 'A custom Racket test application' do
     last_response.body.should.equal("LAYOUT: default: BAZ\n\n")
   end
 
+  it 'should be able to set template settings' do
+    get '/sub5/text'
+    last_response.status.should.equal(200)
+    last_response.body.should.equal("Hello World!")
+  end
+
   it 'should handle changes to global settings' do
-    app.settings.fetch(:my_custom_secret).should.equal(42)
-    app.settings.store(:my_custom_secret, '9Lazy9')
-    app.settings.fetch(:my_custom_secret).should.equal('9Lazy9')
-    app.settings.delete(:my_custom_secret)
-    app.settings.fetch(:my_custom_secret).should.equal(nil)
-    app.settings.default_content_type.should.equal('text/html')
-    app.settings.fetch(:default_content_type).should.equal('text/html')
-    app.settings.default_content_type = 'text/plain'
-    app.settings.default_content_type.should.equal('text/plain')
-    app.settings.fetch(:default_content_type).should.equal('text/plain')
-    app.settings.default_content_type = 'text/html'
-    app.settings.default_content_type.should.equal('text/html')
-    app.settings.fetch(:default_content_type).should.equal('text/html')
+    settings = app.instance_variable_get(:@registry).application_settings
+    settings.fetch(:my_custom_secret).should.equal(42)
+    settings.store(:my_custom_secret, '9Lazy9')
+    settings.fetch(:my_custom_secret).should.equal('9Lazy9')
+    settings.delete(:my_custom_secret)
+    settings.fetch(:my_custom_secret).should.equal(nil)
+    settings.default_content_type.should.equal('text/html')
+    settings.fetch(:default_content_type).should.equal('text/html')
+    settings.default_content_type = 'text/plain'
+    settings.default_content_type.should.equal('text/plain')
+    settings.fetch(:default_content_type).should.equal('text/plain')
+    settings.default_content_type = 'text/html'
+    settings.default_content_type.should.equal('text/html')
+    settings.fetch(:default_content_type).should.equal('text/html')
+  end
+  
+  it 'should return nil on settings without a default' do
+    settings = app.instance_variable_get(:@registry).application_settings
+    Racket::Settings::Application.setting(:nonexisting)
+    settings.nonexisting.should.equal(nil)
+    Racket::Settings::Application.instance_eval do
+      remove_method(:nonexisting)
+      remove_method(:nonexisting=)
+    end
   end
 end

data/spec/_default.rb

@@ -10,31 +10,36 @@ describe 'A default Racket test application' do
   end
 
   it 'has mapped controllers correctly' do
-    app.router.routes.length.should.equal(5)
-    app.router.routes[DefaultRootController].should.equal('/')
-    app.router.routes[DefaultSubController1].should.equal('/sub1')
-    app.router.routes[DefaultSubController2].should.equal('/sub2')
-    app.router.routes[DefaultSubController3].should.equal('/sub3')
-    app.router.routes[DefaultInheritedController].should.equal('/sub3/inherited')
-
-    app.router.action_cache.items[DefaultRootController].length.should.equal(5)
-    app.router.action_cache.items[DefaultRootController].include?(:index).should.equal(true)
-    app.router.action_cache.items[DefaultRootController].include?(:my_first_route)
-      .should.equal(true)
-    app.router.action_cache.items[DefaultRootController].include?(:my_second_route)
-      .should.equal(true)
-    app.router.action_cache.items[DefaultSubController1].length.should.equal(4)
-    app.router.action_cache.items[DefaultSubController1].include?(:route_to_root).should.equal(true)
-    app.router.action_cache.items[DefaultSubController1].include?(:route_to_nonexisting)
-      .should.equal(true)
-    app.router.action_cache.items[DefaultSubController2].length.should.equal(5)
-    app.router.action_cache.items[DefaultSubController2].include?(:index).should.equal(true)
-    app.router.action_cache.items[DefaultSubController2].include?(:current_action)
-      .should.equal(true)
-    app.router.action_cache.items[DefaultSubController2].include?(:current_params)
-      .should.equal(true)
-    app.router.action_cache.items[DefaultSubController3].should.equal([:index])
-    app.router.action_cache.items[DefaultInheritedController].should.equal([:index])
+    router = app.instance_variable_get(:@registry).router
+    router.routes.length.should.equal(5)
+    router.routes[DefaultRootController].should.equal('/')
+    router.routes[DefaultSubController1].should.equal('/sub1')
+    router.routes[DefaultSubController2].should.equal('/sub2')
+    router.routes[DefaultSubController3].should.equal('/sub3')
+    router.routes[DefaultInheritedController].should.equal('/sub3/inherited')
+
+    router.action_cache.items[DefaultRootController].length.should.equal(6)
+    router.action_cache.items[DefaultRootController].include?(:index).should.equal(true)
+    router.action_cache.items[DefaultRootController].include?(:my_first_route)
+       .should.equal(true)
+    router.action_cache.items[DefaultRootController].include?(:my_second_route)
+       .should.equal(true)
+    router.action_cache.items[DefaultSubController1].length.should.equal(4)
+    router.action_cache.items[DefaultSubController1].include?(:route_to_root).should.equal(true)
+    router.action_cache.items[DefaultSubController1].include?(:route_to_nonexisting)
+       .should.equal(true)
+    router.action_cache.items[DefaultSubController2].length.should.equal(5)
+    router.action_cache.items[DefaultSubController2].include?(:index).should.equal(true)
+    router.action_cache.items[DefaultSubController2].include?(:current_action)
+       .should.equal(true)
+    router.action_cache.items[DefaultSubController2].include?(:current_params)
+       .should.equal(true)
+    router.action_cache.items[DefaultSubController3].should.equal([:index])
+    router.action_cache.items[DefaultInheritedController].should.equal([:index])
+  end
+
+  it 'should run in live mode by default' do
+    app.dev_mode?.should.equal(false)
   end
 
   it 'should set rack variables correctly' do
@@ -48,7 +53,7 @@ describe 'A default Racket test application' do
   end
 
   it 'should get the correct middleware' do
-    middleware = app.settings.middleware
+    middleware = app.instance_variable_get(:@registry).application_settings.middleware
     middleware.length.should.equal(2)
     middleware[0].class.should.equal(Array)
     middleware[0].length.should.equal(2)
@@ -59,7 +64,7 @@ describe 'A default Racket test application' do
     true.should.equal(true)
   end
 
-  it 'returns the correct respnse when calling index action' do
+  it 'returns the correct response when calling index action' do
     # RootController
     get '/'
     last_response.status.should.equal(200)
@@ -96,6 +101,12 @@ describe 'A default Racket test application' do
     last_response.body.should.equal('404 Not Found')
   end
 
+  it 'should return a valid response on empty action' do
+    get '/empty'
+    last_response.status.should.equal(200)
+    last_response.body.should.equal('')
+  end
+
   it 'should be able to find routes within the same controller' do
     get '/my_first_route'
     last_response.status.should.equal(200)
@@ -117,27 +128,34 @@ describe 'A default Racket test application' do
   end
 
   it 'should be able to log messages to everybody' do
-    original_logger = app.settings.logger
+    registry = app.registry
+    original_logger = registry.application_logger
     sio = StringIO.new
-    app.settings.logger = Logger.new(sio)
+    new_logger = Racket::Utils::Application::Logger.new(Logger.new(sio), :live)
+    registry.forget(:application_logger)
+    registry.singleton(:application_logger) { new_logger }
     app.inform_all('Informational message')
     sio.string.should.match(/Informational message/)
-    app.settings.logger = original_logger
+    registry.forget(:application_logger)
+    registry.singleton(:application_logger) { original_logger }
   end
 
   it 'should be able to log messages to developer' do
-    original_logger = app.settings.logger
-    original_mode = app.settings.mode
+    registry = app.registry
+    original_logger = registry.application_logger
     sio = StringIO.new
-    app.settings.logger = Logger.new(sio)
-    app.settings.mode = :live
+    live_logger = Racket::Utils::Application::Logger.new(Logger.new(sio), :live)
+    registry.forget(:application_logger)
+    registry.singleton(:application_logger) { live_logger }
     app.inform_dev('Development message')
     sio.string.should.be.empty
-    app.settings.mode = :dev
+    dev_logger = Racket::Utils::Application::Logger.new(Logger.new(sio), :dev)
+    registry.forget(:application_logger)
+    registry.singleton(:application_logger) { dev_logger }
     app.inform_dev('Hey, listen up!')
     sio.string.should.match(/Hey, listen up!/)
-    app.settings.mode = original_mode
-    app.settings.logger = original_logger
+    registry.forget(:application_logger)
+    registry.singleton(:application_logger) { original_logger }
   end
 
   it 'should be able to set and clear session variables' do
@@ -175,13 +193,6 @@ describe 'A default Racket test application' do
     response.each { |elem| elem.should.match(/Racket::Session/) }
   end
 
-  it 'should be able to build paths correctly' do
-    Racket::Utils.build_path.should.equal(Pathname.pwd)
-    Racket::Utils.build_path('foo', 'bar', 'baz').should.equal(
-      Pathname.pwd.join('foo').join('bar').join('baz')
-    )
-  end
-
   it 'should handle GET parameters correctly' do
     get '/sub2/some_get_data/?data1=foo&data3=bar'
     last_response.status.should.equal(200)
@@ -217,4 +228,9 @@ describe 'A default Racket test application' do
     last_response.headers['Content-Type'].should.equal('text/plain')
     last_response.body.should.equal('500 Internal Server Error')
   end
+  
+  it 'should be able to resolve paths using the file system utilities' do
+    utils = app.instance_variable_get(:@registry).utils
+    utils.build_path.should.equal(Pathname.pwd)
+  end
 end

data/spec/_plugin.rb

@@ -26,19 +26,17 @@ describe 'A Racket application with plugins' do
     last_response.body.should.equal('/css/sub/bar.css')
   end
 
-=begin
-  it 'should render a SASS based stylesheet for the default controller' do
-    get '/css/test.css'
-    last_response.status.should.equal(200)
-    last_response.headers['Content-Type'].should.equal('text/css')
-    last_response.body.should.equal("body{background-color:snow;color:black}\n")
-  end
+  # it 'should render a SASS based stylesheet for the default controller' do
+  #   get '/css/test.css'
+  #   last_response.status.should.equal(200)
+  #   last_response.headers['Content-Type'].should.equal('text/css')
+  #   last_response.body.should.equal("body{background-color:snow;color:black}\n")
+  # end
 
-  it 'should render a SASS based stylesheet for a subcontroller' do
-    get '/css/sub/test.css'
-    last_response.status.should.equal(200)
-    last_response.headers['Content-Type'].should.equal('text/css')
-    last_response.body.should.equal("body{background-color:steelblue;color:gray}\n")
-  end
-=end
+  # it 'should render a SASS based stylesheet for a subcontroller' do
+  #   get '/css/sub/test.css'
+  #   last_response.status.should.equal(200)
+  #   last_response.headers['Content-Type'].should.equal('text/css')
+  #   last_response.body.should.equal("body{background-color:steelblue;color:gray}\n")
+  # end
 end

data/spec/_template_cache.rb

@@ -0,0 +1,176 @@
+describe 'Racket::Utils::Vievs::TemplateCache should adhere to Moneta::Cache interface' do
+  templates = {
+    'template_1' => nil,
+    'template_2' => 'template.haml',
+    'template_3' => :template,
+    'template_4' => ->(action) { action.to_s }
+  }.freeze
+
+  describe 'API compliance' do
+    cache = Racket::Utils::Views::TemplateCache.new({})
+    it 'should respond to all methods in the Moneta API' do
+      [:[], :load, :fetch, :[]=, :store, :delete, :key?, :increment, :decrement, :create, :clear,
+       :close, :features, :supports?].each do |meth|
+        cache.should.respond_to?(meth)
+      end
+    end
+
+    it 'should raise NotImplementedError on call to create' do
+      cache.supports?(:create).should.equal(false)
+      -> { cache.create('foo', 'bar') }
+        .should.raise(NotImplementedError)
+    end
+
+    it 'should raise NotImplementedError on call to decrement' do
+      cache.supports?(:decrement).should.equal(false)
+      -> { cache.decrement('foo') }
+        .should.raise(NotImplementedError)
+    end
+
+    it 'should raise NotImplementedError on call to increment' do
+      cache.supports?(:increment).should.equal(false)
+      -> { cache.increment('foo') }
+        .should.raise(NotImplementedError)
+    end
+
+    it 'should return an empty list of features' do
+      cache.features.length.should.equal(0)
+    end
+  end
+
+  describe 'Cache without default expiration' do
+    it 'should not expire items set with []= by default' do
+      cache = Racket::Utils::Views::TemplateCache.new({})
+      templates.each_pair do |key, val|
+        cache[key] = val
+      end
+      sleep(2)
+      templates.each_pair do |key, val|
+        cache[key].should.equal(val)
+      end
+    end
+    it 'should not expire items set with store by default' do
+      cache = Racket::Utils::Views::TemplateCache.new({})
+      templates.each_pair do |key, val|
+        cache.store(key, val)
+      end
+      sleep(2)
+      templates.each_pair do |key, val|
+        cache.fetch(key).should.equal(val)
+      end
+    end
+    it 'should expire items set with store and an explicit expire time' do
+      cache = Racket::Utils::Views::TemplateCache.new({})
+      templates.each_pair do |key, val|
+        cache.store(key, val, expires: 3)
+      end
+      sleep(2)
+      templates.each_pair do |key, val|
+        cache.fetch(key).should.equal(val)
+      end
+      templates.each_pair do |key, val|
+        cache.fetch(key, :foobar).should.equal(val)
+      end
+      templates.each_pair do |key, val|
+        cache.fetch(key) { 'out of space' }.should.equal(val)
+      end
+      sleep(2)
+      templates.each_key do |key|
+        cache.fetch(key).should.equal(nil)
+      end
+      templates.each_key do |key|
+        cache.fetch(key, :foobar).should.equal(:foobar)
+      end
+      templates.each_key do |key|
+        cache.fetch(key) { 'out of space' }.should.equal('out of space')
+      end
+    end
+    it 'should handle deletes correctly' do
+      cache = Racket::Utils::Views::TemplateCache.new({})
+      cache['number'] = 'one'
+      cache['number'].should.equal('one')
+      cache.delete('number')
+      cache['number'].should.equal(nil)
+      cache['number'] = 'two'
+      cache['number'].should.equal('two')
+      cache.clear
+      cache['number'].should.equal(nil)
+      cache['number'] = 'three'
+      cache['number'].should.equal('three')
+      cache.close
+      cache['number'].should.equal(nil)
+    end
+  end
+
+  describe 'Cache with default expiration' do
+    it 'should expire items set with []= by default' do
+      cache = Racket::Utils::Views::TemplateCache.new(expires: 3)
+      templates.each_pair do |key, val|
+        cache[key] = val
+      end
+      sleep(2)
+      templates.each_pair do |key, val|
+        cache[key].should.equal(val)
+      end
+      sleep(2)
+      templates.each_key do |key|
+        cache[key].should.equal(nil)
+      end
+    end
+    it 'should expire items set with store by default' do
+      cache = Racket::Utils::Views::TemplateCache.new(expires: 3)
+      templates.each_pair do |key, val|
+        cache.store(key, val)
+      end
+      sleep(2)
+      templates.each_pair do |key, val|
+        cache.fetch(key).should.equal(val)
+      end
+      sleep(2)
+      templates.each_key do |key|
+        cache.fetch(key).should.equal(nil)
+      end
+    end
+    it 'should not expire items set with a longer expire time' do
+      cache = Racket::Utils::Views::TemplateCache.new(expires: 3)
+      templates.each_pair do |key, val|
+        cache.store(key, val, expires: 5)
+      end
+      sleep(4)
+      templates.each_pair do |key, val|
+        cache.fetch(key).should.equal(val)
+      end
+      templates.each_pair do |key, val|
+        cache.fetch(key, :foobar).should.equal(val)
+      end
+      templates.each_pair do |key, val|
+        cache.fetch(key) { 'out of space' }.should.equal(val)
+      end
+      sleep(2)
+      templates.each_key do |key|
+        cache.fetch(key).should.equal(nil)
+      end
+      templates.each_key do |key|
+        cache.fetch(key, :foobar).should.equal(:foobar)
+      end
+      templates.each_key do |key|
+        cache.fetch(key) { 'out of space' }.should.equal('out of space')
+      end
+    end
+    it 'should handle deletes correctly' do
+      cache = Racket::Utils::Views::TemplateCache.new(expires: 60)
+      cache['number'] = 'one'
+      cache['number'].should.equal('one')
+      cache.delete('number')
+      cache['number'].should.equal(nil)
+      cache['number'] = 'two'
+      cache['number'].should.equal('two')
+      cache.clear
+      cache['number'].should.equal(nil)
+      cache['number'] = 'three'
+      cache['number'].should.equal('three')
+      cache.close
+      cache['number'].should.equal(nil)
+    end
+  end
+end