deas 0.0.2 → 0.1.0

data/test/unit/server_tests.rb

@@ -0,0 +1,203 @@
+require 'assert'
+require 'deas/logger'
+require 'deas/route'
+require 'deas/server'
+require 'logger'
+
+class Deas::Server
+
+  class BaseTests < Assert::Context
+    desc "Deas::Server"
+    setup do
+      @old_configuration = Deas::Server.configuration.dup
+      new_configuration = Deas::Server::Configuration.new
+      Deas::Server.instance.tap do |s|
+        s.instance_variable_set("@configuration", new_configuration)
+      end
+    end
+    teardown do
+      Deas::Server.instance.tap do |s|
+        s.instance_variable_set("@configuration", @old_configuration)
+      end
+    end
+    subject{ Deas::Server }
+
+    should have_instance_methods :configuration, :init, :view_handler_ns,
+      :get, :post, :put, :patch, :delete, :route
+
+    should "be a singleton" do
+      assert_includes Singleton, subject.included_modules
+    end
+
+    should "allow setting it's configuration options" do
+      config = subject.configuration
+
+      subject.env 'staging'
+      assert_equal 'staging', config.env
+
+      subject.root '/path/to/root'
+      assert_equal '/path/to/root', config.root.to_s
+
+      subject.public_folder '/path/to/public'
+      assert_equal '/path/to/public', config.public_folder.to_s
+
+      subject.views_folder '/path/to/views'
+      assert_equal '/path/to/views', config.views_folder.to_s
+
+      subject.dump_errors true
+      assert_equal true, config.dump_errors
+
+      subject.method_override false
+      assert_equal false, config.method_override
+
+      subject.sessions false
+      assert_equal false, config.sessions
+
+      subject.show_exceptions true
+      assert_equal true, config.show_exceptions
+
+      subject.static_files false
+      assert_equal false, config.static_files
+
+      stdout_logger = Logger.new(STDOUT)
+      subject.logger stdout_logger
+      assert_equal stdout_logger, config.logger
+
+      init_proc = proc{ }
+      subject.init(&init_proc)
+      assert_equal init_proc, config.init_proc
+    end
+
+    should "add a GET route using #get" do
+      subject.get('/assets', 'ListAssets')
+
+      route = subject.configuration.routes[0]
+      assert_instance_of Deas::Route, route
+      assert_equal :get,         route.method
+      assert_equal '/assets',    route.path
+      assert_equal 'ListAssets', route.handler_class_name
+    end
+
+    should "add a POST route using #post" do
+      subject.post('/assets', 'CreateAsset')
+
+      route = subject.configuration.routes[0]
+      assert_instance_of Deas::Route, route
+      assert_equal :post,         route.method
+      assert_equal '/assets',     route.path
+      assert_equal 'CreateAsset', route.handler_class_name
+    end
+
+    should "add a PUT route using #put" do
+      subject.put('/assets/:id', 'UpdateAsset')
+
+      route = subject.configuration.routes[0]
+      assert_instance_of Deas::Route, route
+      assert_equal :put,          route.method
+      assert_equal '/assets/:id', route.path
+      assert_equal 'UpdateAsset', route.handler_class_name
+    end
+
+    should "add a PATCH route using #patch" do
+      subject.patch('/assets/:id', 'UpdateAsset')
+
+      route = subject.configuration.routes[0]
+      assert_instance_of Deas::Route, route
+      assert_equal :patch,        route.method
+      assert_equal '/assets/:id', route.path
+      assert_equal 'UpdateAsset', route.handler_class_name
+    end
+
+    should "add a DELETE route using #delete" do
+      subject.delete('/assets/:id', 'DeleteAsset')
+
+      route = subject.configuration.routes[0]
+      assert_instance_of Deas::Route, route
+      assert_equal :delete,       route.method
+      assert_equal '/assets/:id', route.path
+      assert_equal 'DeleteAsset', route.handler_class_name
+    end
+
+    should "allow defining any kind of route using #route" do
+      subject.route(:options, '/get_info', 'GetInfo')
+
+      route = subject.configuration.routes[0]
+      assert_instance_of Deas::Route, route
+      assert_equal :options,    route.method
+      assert_equal '/get_info', route.path
+      assert_equal 'GetInfo',   route.handler_class_name
+    end
+
+    should "set a namespace with #view_handler_ns and " \
+           "use it when defining routes" do
+      subject.view_handler_ns 'MyStuff'
+      assert_equal 'MyStuff', subject.configuration.view_handler_ns
+
+      # should use the ns
+      subject.route(:get, '/ns_test',     'NsTest')
+      route = subject.configuration.routes.last
+      assert_equal 'MyStuff::NsTest', route.handler_class_name
+
+      # should ignore the ns when the leading colons are present
+      subject.route(:post, '/no_ns_test', '::NoNsTest')
+      route = subject.configuration.routes.last
+      assert_equal '::NoNsTest', route.handler_class_name
+    end
+
+  end
+
+  class ConfigurationTests < BaseTests
+    desc "Configuration"
+    setup do
+      @configuration = Deas::Server::Configuration.new
+    end
+    subject{ @configuration }
+
+    should have_instance_methods :env, :root, :app_file, :public_folder,
+      :views_folder, :dump_errors, :method_override, :sessions, :static_files,
+      :init_proc, :logger, :routes, :view_handler_ns, :show_exceptions
+
+    should "default the env to 'development'" do
+      assert_equal 'development', subject.env
+    end
+
+    should "default the root to the routes file's folder" do
+      expected_root = File.expand_path('..', Deas.config.routes_file)
+      assert_equal expected_root, subject.root.to_s
+    end
+
+    should "default the app file to the routes file" do
+      assert_equal Deas.config.routes_file.to_s, subject.app_file.to_s
+    end
+
+    should "default the public folder based on the root" do
+      expected_root = File.expand_path('..', Deas.config.routes_file)
+      expected_public_folder = File.join(expected_root, 'public')
+      assert_equal expected_public_folder, subject.public_folder.to_s
+    end
+
+    should "default the views folder based on the root" do
+      expected_root = File.expand_path('..', Deas.config.routes_file)
+      expected_views_folder = File.join(expected_root, 'views')
+      assert_equal expected_views_folder, subject.views_folder.to_s
+    end
+
+    should "default the Sinatra flags" do
+      assert_equal false, subject.dump_errors
+      assert_equal true,  subject.method_override
+      assert_equal false, subject.show_exceptions
+      assert_equal true,  subject.sessions
+      assert_equal true,  subject.static_files
+    end
+
+    should "default the logger to a NullLogger" do
+      assert_instance_of Deas::NullLogger, subject.logger
+    end
+
+    should "default routes to an empty array" do
+      assert_equal [], subject.routes
+    end
+
+  end
+
+end

data/test/unit/sinatra_app_tests.rb

@@ -0,0 +1,70 @@
+require 'assert'
+require 'deas/route'
+require 'deas/server'
+require 'deas/sinatra_app'
+require 'sinatra/base'
+require 'test/support/view_handlers'
+
+module Deas::SinatraApp
+
+  class BaseTests < Assert::Context
+    desc "Deas::SinatraApp"
+    setup do
+      @route = Deas::Route.new(:get, '/something', 'TestViewHandler')
+      @configuration = Deas::Server::Configuration.new.tap do |c|
+        c.env             = 'staging'
+        c.root            = 'path/to/somewhere'
+        c.dump_errors     = true
+        c.method_override = false
+        c.sessions        = false
+        c.show_exceptions = true
+        c.static          = true
+        c.routes          = [ @route ]
+      end
+      @sinatra_app = Deas::SinatraApp.new(@configuration)
+    end
+    subject{ @sinatra_app }
+
+    should "be a kind of Sinatra::Base" do
+      assert_equal Sinatra::Base, subject.superclass
+    end
+
+    should "call init procs when initialized" do
+      initialized = false
+      @configuration.init_proc = proc{ initialized = true }
+      @sinatra_app = Deas::SinatraApp.new(@configuration)
+
+      assert_equal true, initialized
+    end
+
+    should "call constantize! on all routes" do
+      assert_equal TestViewHandler, @route.handler_class
+    end
+
+    should "have it's configuration set based on the server configuration" do
+      subject.settings do |settings|
+        assert_equal 'staging',                  settings.env
+        assert_equal 'path/to/somewhere',        settings.root
+        assert_equal @configuration.app_file,    settings.app_file
+        assert_equal 'path/to/somewhere/public', settings.public_folder
+        assert_equal 'path/to/somewhere/views',  settings.views
+        assert_equal true,                       settings.dump_errors
+        assert_equal false,                      settings.logging
+        assert_equal false,                      settings.method_override
+        assert_equal false,                      settings.sessions
+        assert_equal true,                       settings.show_exceptions
+        assert_equal true,                       settings.static_files
+        assert_equal @configuration.logger,      settings.deas_logger
+      end
+    end
+
+    should "define Sinatra routes for every route in the configuration" do
+      get_routes = subject.routes[@route.method.to_s.upcase] || []
+      sinatra_route = get_routes.detect{|route| route[0].match(@route.path) }
+
+      assert_not_nil sinatra_route
+    end
+
+  end
+
+end

data/test/unit/sinatra_runner_tests.rb

@@ -0,0 +1,103 @@
+require 'assert'
+require 'deas/sinatra_runner'
+require 'deas/template'
+require 'test/support/fake_app'
+require 'test/support/view_handlers'
+
+class Deas::SinatraRunner
+
+  class BaseTests < Assert::Context
+    desc "Deas::SinatraRunner"
+    setup do
+      @fake_sinatra_call = FakeApp.new
+      @runner = Deas::SinatraRunner.new(FlagViewHandler, @fake_sinatra_call)
+    end
+    subject{ @runner }
+
+    should have_instance_methods :run, :request, :response, :params, :logger,
+      :halt, :render, :session, :redirect, :redirect_to
+
+    should "return the sinatra_call's request with #request" do
+      assert_equal @fake_sinatra_call.request, subject.request
+    end
+
+    should "return the sinatra_call's response with #response" do
+      assert_equal @fake_sinatra_call.response, subject.response
+    end
+
+    should "return the sinatra_call's params with #params" do
+      assert_equal @fake_sinatra_call.params, subject.params
+    end
+
+    should "return the sinatra_call's session with #session" do
+      assert_equal @fake_sinatra_call.session, subject.session
+    end
+
+    should "return the sinatra_call's settings logger with #logger" do
+      assert_equal @fake_sinatra_call.settings.deas_logger, subject.logger
+    end
+
+    should "call the sinatra_call's halt with #halt" do
+      return_value = catch(:halt){ subject.halt('test') }
+      assert_equal [ 'test' ], return_value
+    end
+
+    should "call the sinatra_call's erb method with #render" do
+      return_value = subject.render('index')
+
+      assert_equal :web,   return_value[0]
+      assert_equal :index, return_value[2]
+
+      options = return_value[3]
+      assert_instance_of Deas::Template::RenderScope, options[:scope]
+
+      expected_locals = { :view => subject.instance_variable_get("@handler") }
+      assert_equal(expected_locals, options[:locals])
+    end
+
+    should "call the sinatra_call's redirect method with #redirect" do
+      return_value = catch(:halt){ subject.redirect('http://google.com') }
+      expected = [ 302, { 'Location' => 'http://google.com' } ]
+
+      assert_equal expected, return_value
+    end
+
+    should "call the sinatra_call's redirect and to methods with #redirect_to" do
+      return_value = catch(:halt){ subject.redirect_to('/somewhere') }
+      expected = [ 302, { 'Location' => "http://test.local/somewhere" } ]
+
+      assert_equal expected, return_value
+    end
+
+    should "not throw an exception with the setup or teardown methods" do
+      assert_nothing_raised{ subject.setup }
+      assert_nothing_raised{ subject.teardown }
+    end
+
+  end
+
+  class RunTests < BaseTests
+    desc "run"
+    setup do
+      @return_value = @runner.run
+      @handler = @runner.instance_variable_get("@handler")
+    end
+    subject{ @handler }
+
+    should "run the before and after hooks" do
+      assert_equal true, subject.before_hook_called
+      assert_equal true, subject.after_hook_called
+    end
+
+    should "run the handler's init and run" do
+      assert_equal true, subject.init_bang_called
+      assert_equal true, subject.run_bang_called
+    end
+
+    should "return the handler's run! return value" do
+      assert_equal true, @return_value
+    end
+
+  end
+
+end

data/test/unit/template_tests.rb

@@ -0,0 +1,150 @@
+require 'assert'
+require 'deas/template'
+require 'test/support/fake_app'
+
+class Deas::Template
+
+  class BaseTests < Assert::Context
+    desc "Deas::Template"
+    setup do
+      @fake_sinatra_call = FakeApp.new
+      @template = Deas::Template.new(@fake_sinatra_call, 'users/index')
+    end
+    subject{ @template }
+
+    should have_instance_methods :name, :options, :render
+    should have_class_methods :helpers
+
+    should "symbolize it's name" do
+      assert_equal :"users/index", subject.name
+    end
+
+    should "set it's scope option to a empty Module" do
+      assert_instance_of Deas::Template::RenderScope, subject.options[:scope]
+    end
+
+    should "call the sinatra_call's `erb` method with #render" do
+      return_value = subject.render
+
+      assert_equal subject.name,    return_value[0]
+      assert_equal subject.options, return_value[1]
+    end
+
+    should "include modules on the RenderScope using helpers class method" do
+      helper_module = Module.new
+      Deas::Template.helpers(helper_module)
+
+      included_modules = Deas::Template::RenderScope.included_modules
+      assert_includes helper_module, included_modules
+    end
+
+  end
+
+  class WithLayoutsTests < BaseTests
+    desc "with layouts"
+    setup do
+      @template = Deas::Template.new(@fake_sinatra_call, 'users/index', {
+        :layout => [ 'layouts/web', 'layouts/search' ]
+      })
+    end
+
+    should "call the engine's `erb` method for each layout, " \
+           "in the `layout` option" do
+      return_value = subject.render
+
+      # the return_value is a one-dimensional array of all the render args
+      # used in order. Thus the, 0, 2, 4 nature of the indexes.
+      assert_equal :"layouts/web",    return_value[0]
+      assert_equal :"layouts/search", return_value[2]
+      assert_equal :"users/index",    return_value[4]
+    end
+
+  end
+
+  class RenderScopeTests < Assert::Context
+    desc "Deas::Template::RenderScope"
+    setup do
+      @fake_sinatra_call = FakeApp.new
+      @render_scope = Deas::Template::RenderScope.new(@fake_sinatra_call)
+    end
+    subject{ @render_scope }
+
+    should have_instance_methods :partial, :escape_html, :h, :escape_url, :u,
+      :render
+
+    should "call the sinatra_call's erb method with #partial" do
+      return_value = subject.partial('part', :something => true)
+
+      assert_equal :_part, return_value[0]
+
+      expected_options = return_value[1]
+      assert_instance_of Deas::Template::RenderScope, expected_options[:scope]
+
+      expected_locals = { :something => true }
+      assert_equal(expected_locals, expected_options[:locals])
+    end
+
+    should "call the sinatra_call's erb method with #render" do
+      return_value = subject.render('my_template', {
+        :views  => '/path/to/templates',
+        :locals => {
+          :something => true
+        }
+      })
+
+      assert_equal :my_template, return_value[0]
+
+      expected_options = return_value[1]
+      assert_instance_of Deas::Template::RenderScope, expected_options[:scope]
+
+      expected_locals = { :something => true }
+      assert_equal(expected_locals, expected_options[:locals])
+    end
+
+    should "escape html with #h or #escape_html" do
+      return_value = subject.escape_html("<strong></strong>")
+      assert_equal "&lt;strong&gt;&lt;&#x2F;strong&gt;", return_value
+
+      return_value = subject.h("<strong></strong>")
+      assert_equal "&lt;strong&gt;&lt;&#x2F;strong&gt;", return_value
+    end
+
+    should "escape urls with #u or #escape_url" do
+      return_value = subject.escape_url("/path/to/somewhere")
+      assert_equal "%2Fpath%2Fto%2Fsomewhere", return_value
+
+      return_value = subject.u("/path/to/somewhere")
+      assert_equal "%2Fpath%2Fto%2Fsomewhere", return_value
+    end
+
+  end
+
+end
+
+class Deas::Partial
+
+  class BaseTests < Assert::Context
+    desc "Deas::Partial"
+    setup do
+      @fake_sinatra_call = FakeApp.new
+      @partial = Deas::Partial.new(@fake_sinatra_call, 'users/index/listing', {
+        :user => 'Joe Test'
+      })
+    end
+    subject{ @partial }
+
+    should "be a kind of Deas::Template" do
+      assert_kind_of Deas::Template, subject
+    end
+
+    should "add an underscore to it's template's basename" do
+      assert_equal :"users/index/_listing", subject.name
+    end
+
+    should "set it's locals option" do
+      assert_equal({ :user => 'Joe Test' }, subject.options[:locals])
+    end
+
+  end
+
+end

data/test/unit/view_handler_tests.rb

@@ -0,0 +1,96 @@
+require 'assert'
+require 'deas/test_helpers'
+require 'deas/view_handler'
+require 'test/support/view_handlers'
+
+module Deas::ViewHandler
+
+  class BaseTests < Assert::Context
+    include Deas::TestHelpers
+
+    desc "Deas::ViewHandler"
+    setup do
+      @handler = test_runner(TestViewHandler).handler
+    end
+    subject{ @handler }
+
+    should have_instance_methods :init, :init!, :run, :run!
+    should have_class_methods :before, :before_callbacks, :after,
+      :after_callbacks, :layout, :layouts
+
+    should "raise a NotImplementedError if run! is not overwritten" do
+      assert_raises(NotImplementedError){ subject.run! }
+    end
+
+    should "store procs in #before_callbacks with #before" do
+      before_proc = proc{ }
+      TestViewHandler.before(&before_proc)
+
+      assert_includes before_proc, TestViewHandler.before_callbacks
+    end
+
+    should "store procs in #after_callbacks with #after" do
+      after_proc = proc{ }
+      TestViewHandler.after(&after_proc)
+
+      assert_includes after_proc, TestViewHandler.after_callbacks
+    end
+
+    should "allow specifying the layouts using #layout or #layouts" do
+      handler_class = Class.new{ include Deas::ViewHandler }
+
+      handler_class.layout 'layouts/app'
+      assert_equal [ 'layouts/app' ], handler_class.layouts
+
+      handler_class.layouts 'layouts/web', 'layouts/search'
+      assert_equal [ 'layouts/web', 'layouts/search' ], handler_class.layouts
+    end
+
+  end
+
+  class WithMethodFlagsTests < BaseTests
+    setup do
+      @handler = test_runner(FlagViewHandler).handler
+    end
+
+    should "have called `init!` and it's callbacks" do
+      assert_equal true, subject.before_init_called
+      assert_equal true, subject.init_bang_called
+      assert_equal true, subject.after_init_called
+    end
+
+    should "not have called `run!` or it's callbacks when initialized" do
+      assert_nil subject.before_run_called
+      assert_nil subject.run_bang_called
+      assert_nil subject.after_run_called
+    end
+
+    should "call `run!` and it's callbacks when it's `run`" do
+      subject.run
+
+      assert_equal true, subject.before_run_called
+      assert_equal true, subject.run_bang_called
+      assert_equal true, subject.after_run_called
+    end
+
+  end
+
+  class HaltTests < BaseTests
+    desc "halt"
+
+    should "return a response with the status code and the passed data" do
+      runner = test_runner(HaltViewHandler, :params => {
+        'code'    => 200,
+        'headers' => { 'Content-Type' => 'text/plain' },
+        'body'    => 'test halting'
+      })
+      runner.run
+
+      assert_equal 200,                                runner.return_value[0]
+      assert_equal({ 'Content-Type' => 'text/plain' }, runner.return_value[1])
+      assert_equal 'test halting',                     runner.return_value[2]
+    end
+
+  end
+
+end