deas 0.40.0 → 0.41.0

data/lib/deas/server_data.rb

@@ -2,19 +2,19 @@ module Deas
 
   class ServerData
 
-    # The server uses this to "compile" its configuration for speed. NsOptions
-    # is relatively slow everytime an option is read. To avoid this, we read the
-    # options one time here and memoize their values. This way, we don't pay the
-    # NsOptions overhead when reading them while handling a request.
+    # The server uses this to "compile" the common configuration data used
+    # by the server instances, error handlers and routes. The goal here is
+    # to provide these with a simplified interface with the minimal data needed
+    # and to decouple the configuration from each thing that needs its data.
 
-    attr_reader :error_procs, :logger, :router, :template_source
+    attr_reader :error_procs, :template_source, :logger, :router
 
     def initialize(args = nil)
       args ||= {}
       @error_procs     = args[:error_procs] || []
+      @template_source = args[:template_source]
       @logger          = args[:logger]
       @router          = args[:router]
-      @template_source = args[:template_source]
     end
 
   end

data/lib/deas/sinatra_app.rb

@@ -11,23 +11,27 @@ module Deas
       # This is generic server initialization stuff.  Eventually do this in the
       # server's initialization logic more like Sanford does.
       server_config.validate!
-      server_data = ServerData.new(server_config.to_hash)
+      server_data = ServerData.new({
+        :error_procs     => server_config.error_procs,
+        :logger          => server_config.logger,
+        :router          => server_config.router,
+        :template_source => server_config.template_source
+      })
 
       Sinatra.new do
         # built-in settings
         set :environment,      server_config.env
         set :root,             server_config.root
-        set :public_folder,    server_config.public_root
         set :views,            server_config.views_root
+        set :public_folder,    server_config.public_root
+        set :default_encoding, server_config.default_encoding
         set :dump_errors,      server_config.dump_errors
         set :method_override,  server_config.method_override
+        set :reload_templates, server_config.reload_templates
         set :sessions,         server_config.sessions
         set :static,           server_config.static_files
-        set :reload_templates, server_config.reload_templates
-        set :default_encoding, server_config.default_encoding
-        set :logging,          false
 
-        # TODO: sucks to have to do this but b/c or Rack there is no better way
+        # TODO: sucks to have to do this but b/c of Rack there is no better way
         # to make the server data available to middleware.  We should remove this
         # once we remove Sinatra.  Whatever rack app implemenation will needs to
         # provide the server data or maybe the server data *will be* the rack app.
@@ -39,6 +43,9 @@ module Deas
         set :raise_errors,     false
         set :show_exceptions,  false
 
+        # turn off logging b/c Deas handles its own logging logic
+        set :logging,          false
+
         # TODO: rework with `server_config.default_encoding` once we move off of using Sinatra
         # TODO: could maybe move into a deas-json mixin once off of Sinatra
         # Add charset to json content type responses - by default only added to these:

data/lib/deas/test_runner.rb

@@ -87,7 +87,7 @@ module Deas
         super(*[
           a.first.instance_of?(::Fixnum) ? a.shift : nil,
           a.first.kind_of?(::Hash)       ? a.shift : nil,
-          a.first.respond_to?(:each)     ? a.shift : nil
+          a.shift
         ])
       end
     end

data/lib/deas/url.rb

@@ -1,4 +1,5 @@
 module Deas
+
   class Url
 
     def self.http_query(hash, &escape_value_proc)
@@ -17,56 +18,55 @@ module Deas
       @escape_query_value_proc = options[:escape_query_value]
     end
 
-    def path_for(*args)
-      hashed, ordered = [
-        args.last.kind_of?(::Hash) ? args.pop : {},
-        args
-      ]
-      apply_ordered(apply_hashed(@path, hashed), ordered)
-    end
+    def path_for(params = {})
+      raise NonHashParamsError if !params.kind_of?(::Hash)
 
-    private
+      h = params.dup # don't alter the given params
+      c = h.delete(:captures) || h.delete('captures') || []
+      s = h.delete(:splat)    || h.delete('splat')    || []
+      a = h.delete(:'#')      || h.delete('#')        || nil
 
-    def apply_ordered(path, params)
-      params.inject(path){ |p, v| p.sub(/\*+|\:\w+/i, v.to_s) }.gsub(/\/\/+/, '/')
+      # ignore captures when setting params
+      # remove duplicate forward slashes
+      set_anchor(set_extra(set_named(set_splat(@path, s), h), h), a).gsub(/\/\/+/, '/')
     end
 
-    def apply_hashed(path, params)
-      # don't alter the given params
-      h = params.dup
-
-      # ignore captures in applying params
-      captures = h.delete(:captures) || h.delete('captures') || []
-      splat    = h.delete(:splat)    || h.delete('splat')    || []
-      anchor   = h.delete(:'#')      || h.delete('#')        || nil
-
-      apply_anchor(apply_extra(apply_named(apply_splat(path, splat), h), h), anchor)
-    end
+    private
 
-    def apply_splat(path, params)
-      params.inject(path){ |p, v| p.sub(/\*+/, v.to_s) }
+    def set_splat(path, params)
+      params.inject(path) do |path_string, value|
+        path_string.sub(/\*+/, value.to_s)
+      end
     end
 
-    def apply_named(path, params)
-      params.inject(path) do |p, (k, v)|
-        if p.include?(":#{k}")
-          params.delete(k)
-          p.gsub(":#{k}", v.to_s)
+    def set_named(path, params)
+      params.inject(path) do |path_string, (name, value)|
+        if path_string.include?(":#{name}")
+          if (v = value.to_s).empty?
+            raise EmptyNamedValueError , "an empty value (`#{value.inspect}`) " \
+                                         "was given for the `#{name}` url param"
+          end
+          params.delete(name)
+          path_string.gsub(":#{name}", v)
         else
-          p
+          path_string
         end
       end
     end
 
-    def apply_extra(path, params)
+    def set_extra(path, params)
       return path if params.empty?
       query_string = Deas::Url.http_query(params, &self.escape_query_value_proc)
       "#{path}?#{query_string}"
     end
 
-    def apply_anchor(path, anchor)
+    def set_anchor(path, anchor)
       anchor.to_s.empty? ? path : "#{path}##{anchor}"
     end
 
+    NonHashParamsError   = Class.new(ArgumentError)
+    EmptyNamedValueError = Class.new(ArgumentError)
+
   end
+
 end

data/lib/deas/version.rb

@@ -1,3 +1,3 @@
 module Deas
-  VERSION = "0.40.0"
+  VERSION = "0.41.0"
 end

data/test/helper.rb

@@ -12,6 +12,15 @@ require 'pry'
 
 require 'test/support/factory'
 
+# 1.8.7 backfills
+
+# Array#sample
+if !(a = Array.new).respond_to?(:sample) && a.respond_to?(:choice)
+  class Array
+    alias_method :sample, :choice
+  end
+end
+
 require 'fileutils'
 require 'logger'
 log_file_path = ROOT.join("log/test.log")

data/test/support/routes.rb

@@ -19,30 +19,32 @@ class DeasTestServer
     end
   end
 
-  default_request_type_name 'desktop'
-  add_request_type('regular'){ |r| r.path_info =~ /regular/ }
-  add_request_type('mobile'){ |r| r.path_info =~ /mobile/ }
+  router do
+    default_request_type_name 'desktop'
+    add_request_type('regular'){ |r| r.path_info =~ /regular/ }
+    add_request_type('mobile'){ |r| r.path_info =~ /mobile/ }
 
-  get  '/show',              'ShowHandler'
-  get  '/show.html',         'ShowHtmlHandler'
-  get  '/show.json',         'ShowJsonHandler'
-  get  '/show-latin1-json',  'ShowLatinJsonHandler'
-  get  '/show-text',         'ShowTextHandler'
-  get  '/show-headers-text', 'ShowHeadersTextHandler'
+    get  '/show',              'ShowHandler'
+    get  '/show.html',         'ShowHtmlHandler'
+    get  '/show.json',         'ShowJsonHandler'
+    get  '/show-latin1-json',  'ShowLatinJsonHandler'
+    get  '/show-text',         'ShowTextHandler'
+    get  '/show-headers-text', 'ShowHeadersTextHandler'
 
-  get '/req-type-show/:type', 'regular' => 'ShowHandler',
-                              'mobile'  => 'ShowMobileHandler'
+    get '/req-type-show/:type', 'regular' => 'ShowHandler',
+                                'mobile'  => 'ShowMobileHandler'
 
-  get  '/halt',     'HaltHandler'
-  get  '/error',    'ErrorHandler'
-  get  '/redirect', 'RedirectHandler'
-  post '/session',  'SetSessionHandler'
-  get  '/session',  'UseSessionHandler'
+    get  '/halt',     'HaltHandler'
+    get  '/error',    'ErrorHandler'
+    get  '/redirect', 'RedirectHandler'
+    post '/session',  'SetSessionHandler'
+    get  '/session',  'UseSessionHandler'
 
-  get '/handler/tests', 'HandlerTestsHandler'
+    get '/handler/tests', 'HandlerTestsHandler'
 
-  redirect '/route_redirect',   '/somewhere'
-  redirect('/:prefix/redirect'){ "/#{params['prefix']}/somewhere" }
+    redirect '/route_redirect',   '/somewhere'
+    redirect('/:prefix/redirect'){ "/#{params['prefix']}/somewhere" }
+  end
 
 end
 
@@ -59,7 +61,9 @@ class DeasDevServer
 
   show_exceptions true
 
-  get '/error', 'ErrorHandler'
+  router do
+    get '/error', 'ErrorHandler'
+  end
 
 end
 

data/test/unit/logging_tests.rb

@@ -128,7 +128,7 @@ module Deas::Logging
   class VerboseLoggingInitTests < VerboseLoggingTests
     desc "when init"
     setup do
-      @resp_status = @middleware_class::RESPONSE_STATUS_NAMES.keys.choice
+      @resp_status = @middleware_class::RESPONSE_STATUS_NAMES.keys.sample
       @app_response[0] = @resp_status
 
       @middleware = Deas::VerboseLogging.new(@app)

data/test/unit/respond_with_proxy_tests.rb

@@ -12,7 +12,7 @@ class Deas::RespondWithProxy
     setup do
       @status  = Factory.integer
       @headers = { Factory.string => Factory.string }
-      @body    = Factory.string
+      @body    = [Factory.string]
       @proxy    = Deas::RespondWithProxy.new([@status, @headers, @body])
     end
     subject{ @proxy }

data/test/unit/router_tests.rb

@@ -26,7 +26,7 @@ class Deas::Router
 
     desc "when init"
     setup do
-      @base_url = a_base_url = [Factory.url, nil].choice
+      @base_url = a_base_url = [Factory.url, nil].sample
       @router = @router_class.new{ base_url a_base_url }
     end
     subject{ @router }
@@ -405,18 +405,28 @@ class Deas::Router
     should "build a path for a url given params" do
       exp_path = subject.prepend_base_url("/info/now")
       assert_equal exp_path, subject.url_for(:get_info, :for => 'now')
-      assert_equal exp_path, subject.url_for(:get_info, 'now')
     end
 
     should "'squash' duplicate forward-slashes when building urls" do
       exp_path = subject.prepend_base_url("/info/now")
       assert_equal exp_path, subject.url_for(:get_info, :for => '/now')
-      assert_equal exp_path, subject.url_for(:get_info, '/now')
+    end
+
+    should "complain if buiding a named url with non-hash params" do
+      assert_raises ArgumentError do
+        subject.url_for(:get_info, ['now', :now, nil].sample)
+      end
+    end
+
+    should "complain if given an empty named param value" do
+      assert_raises ArgumentError do
+        subject.url_for(:get_info, :for => [nil, ''].sample)
+      end
     end
 
     should "complain if building a named url that hasn't been defined" do
       assert_raises ArgumentError do
-        subject.url_for(:get_all_info, 'now')
+        subject.url_for(:not_defined_url)
       end
     end
 

data/test/unit/runner_tests.rb

@@ -139,13 +139,12 @@ class Deas::Runner
     should "know and set its response body" do
       assert_nil subject.body
 
-      exp = Factory.string
+      exp = [Factory.string]
       subject.body exp
       assert_equal exp, subject.body
 
-      assert_raises(ArgumentError) do
-        subject.body Factory.integer
-      end
+      subject.body exp.first
+      assert_equal exp, subject.body
     end
 
     should "know and set its response content type header" do
@@ -463,7 +462,7 @@ class Deas::Runner
   class SourceRenderTests < RenderSetupTests
     desc "source render method"
     setup do
-      body = @body = Factory.text
+      body = @body = [Factory.text]
       @render_called_with = nil
       @source = Deas::TemplateSource.new(Factory.path)
       Assert.stub(@source, :render){ |*args| @render_called_with = args; body }
@@ -672,7 +671,7 @@ class Deas::Runner
   class NonPartialSendFileBodyTests < SendFileBodyIOTests
     desc "for non/multi/invalid partial content requests"
     setup do
-      range = [nil, 'bytes=', 'bytes=0-1,2-3', 'bytes=3-2', 'bytes=abc'].choice
+      range = [nil, 'bytes=', 'bytes=0-1,2-3', 'bytes=3-2', 'bytes=abc'].sample
       env = range.nil? ? {} : { 'HTTP_RANGE' => range }
       @body = SendFileBody.new(env, @path_name)
     end

data/test/unit/server_tests.rb

@@ -18,221 +18,262 @@ module Deas::Server
     end
     subject{ @server_class }
 
-    should have_imeths :new, :configuration
-
-    # DSL for sinatra-based settings
-    should have_imeths :env, :root, :public_root, :views_root
-    should have_imeths :dump_errors, :method_override, :sessions, :show_exceptions
-    should have_imeths :static_files, :reload_templates
-
-    # DSL for server handling settings
-    should have_imeths :init, :error, :template_helpers, :template_helper?
-    should have_imeths :use, :set, :verbose_logging, :logger, :default_encoding
-    should have_imeths :template_source
-
-    # DSL for server routing settings
-    should have_imeths :router, :view_handler_ns, :base_url
-    should have_imeths :url, :url_for
-    should have_imeths :default_request_type_name, :add_request_type
-    should have_imeths :request_type_name
-    should have_imeths :get, :post, :put, :patch, :delete
-    should have_imeths :route, :redirect
+    should have_imeths :new, :config
+
+    should have_imeths :env, :root, :views_path, :views_root
+    should have_imeths :public_path, :public_root, :default_encoding
+    should have_imeths :set, :settings, :template_helpers, :template_helper?
+    should have_imeths :use, :middlewares, :init, :init_procs, :error, :error_procs
+    should have_imeths :template_source, :logger, :router, :url_for
+
+    should have_imeths :dump_errors, :method_override, :reload_templates
+    should have_imeths :sessions, :show_exceptions, :static_files
+    should have_imeths :verbose_logging
 
     should "use much-plugin" do
       assert_includes MuchPlugin, Deas::Server
     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
+    should "allow setting its config values" do
+      config = subject.config
 
-      subject.public_root '/path/to/public'
-      assert_equal '/path/to/public', config.public_root.to_s
+      exp = Factory.string
+      subject.env exp
+      assert_equal exp, config.env
 
-      subject.views_root '/path/to/views'
-      assert_equal '/path/to/views', config.views_root.to_s
+      exp = Factory.path
+      subject.root exp
+      assert_equal exp, config.root
 
-      subject.dump_errors true
-      assert_equal true, config.dump_errors
+      exp = Factory.path
+      subject.views_path exp
+      assert_equal exp, config.views_path
 
-      subject.method_override false
-      assert_equal false, config.method_override
+      exp = Factory.path
+      subject.public_path exp
+      assert_equal exp, config.public_path
 
-      subject.sessions false
-      assert_equal false, config.sessions
+      exp = Factory.string
+      subject.default_encoding exp
+      assert_equal exp, config.default_encoding
 
-      subject.show_exceptions true
-      assert_equal true, config.show_exceptions
+      exp = { Factory.string.to_sym => Factory.string }
+      subject.set exp.keys.first, exp.values.first
+      assert_equal exp, config.settings
 
-      subject.static_files false
-      assert_equal false, config.static_files
-
-      subject.reload_templates true
-      assert_equal true, config.reload_templates
+      exp = ['MyMiddleware', Factory.string]
+      subject.use *exp
+      assert_equal [exp], config.middlewares
 
+      exp = proc{ }
       assert_equal 0, config.init_procs.size
-      init_proc = proc{ }
-      subject.init(&init_proc)
+      subject.init(&exp)
       assert_equal 1, config.init_procs.size
-      assert_equal init_proc, config.init_procs.first
+      assert_equal exp, config.init_procs.first
 
+      exp = proc{ }
       assert_equal 0, config.error_procs.size
-      error_proc = proc{ }
-      subject.error(&error_proc)
+      subject.error(&exp)
       assert_equal 1, config.error_procs.size
-      assert_equal error_proc, config.error_procs.first
+      assert_equal exp, config.error_procs.first
+
+      exp = Deas::TemplateSource.new(Factory.path)
+      subject.template_source exp
+      assert_equal exp, config.template_source
+
+      exp = Logger.new(STDOUT)
+      subject.logger exp
+      assert_equal exp, config.logger
 
-      subject.use 'MyMiddleware'
-      assert_equal [ ['MyMiddleware'] ], config.middlewares
+      exp = Factory.boolean
+      subject.dump_errors exp
+      assert_equal exp, config.dump_errors
 
-      subject.set :testing_set_meth, 'it works!'
-      assert_equal({ :testing_set_meth => 'it works!'}, config.settings)
+      exp = Factory.boolean
+      subject.method_override exp
+      assert_equal exp, config.method_override
 
-      stdout_logger = Logger.new(STDOUT)
-      subject.logger stdout_logger
-      assert_equal stdout_logger, config.logger
+      exp = Factory.boolean
+      subject.reload_templates exp
+      assert_equal exp, config.reload_templates
 
-      a_source = Deas::TemplateSource.new(Factory.path)
-      subject.template_source a_source
-      assert_equal a_source, config.template_source
+      exp = Factory.boolean
+      subject.sessions exp
+      assert_equal exp, config.sessions
 
-      subject.default_encoding 'latin1'
-      assert_equal 'latin1', config.default_encoding
+      exp = Factory.boolean
+      subject.show_exceptions exp
+      assert_equal exp, config.show_exceptions
+
+      exp = Factory.boolean
+      subject.static_files exp
+      assert_equal exp, config.static_files
+
+      exp = Factory.boolean
+      subject.verbose_logging exp
+      assert_equal exp, config.verbose_logging
+    end
+
+    should "demeter its config values that aren't directly set" do
+      assert_equal subject.config.views_root,  subject.views_root
+      assert_equal subject.config.public_root, subject.public_root
+      assert_equal subject.config.settings,    subject.settings
+      assert_equal subject.config.middlewares, subject.middlewares
+      assert_equal subject.config.init_procs,  subject.init_procs
+      assert_equal subject.config.error_procs, subject.error_procs
     end
 
     should "add and query helper modules" do
       subject.template_helpers(helper_module = Module.new)
-      assert subject.template_helper?(helper_module)
+      assert_true subject.template_helper?(helper_module)
     end
 
     should "have a router by default and allow overriding it" do
       assert_kind_of Deas::Router, subject.router
-      assert_equal subject.router.view_handler_ns, subject.view_handler_ns
-      assert_equal subject.router.base_url, subject.base_url
 
       new_router = Deas::Router.new
       subject.router new_router
+      assert_same new_router, subject.config.router
       assert_same new_router, subject.router
     end
 
+    should "allow configuring the router by passing a block to `router`" do
+      block_scope = nil
+      subject.router{ block_scope = self }
+      assert_equal subject.router, block_scope
+    end
+
+    should "call the router's `url_for` method" do
+      url_for_called_args = nil
+      url_for_called_proc = nil
+      Assert.stub(subject.router, :url_for) do |*args, &block|
+        url_for_called_args = args
+        url_for_called_proc = block
+      end
+
+      exp_args = [Factory.string]
+      exp_proc = proc{ }
+      subject.url_for(*exp_args, &exp_proc)
+      assert_equal exp_args, url_for_called_args
+      assert_equal exp_proc, url_for_called_proc
+    end
+
   end
 
-  class ConfigurationTests < UnitTests
-    desc "Configuration"
+  class ConfigTests < UnitTests
+    desc "Config"
     setup do
-      @configuration = Configuration.new
-      @configuration.root = TEST_SUPPORT_ROOT
+      @config_class = Config
+      @config = @config_class.new
     end
-    subject{ @configuration }
+    subject{ @config }
 
-    # sinatra-based options
+    should have_accessors :env, :root, :views_path, :public_path, :default_encoding
+    should have_accessors :settings, :template_helpers, :middlewares
+    should have_accessors :init_procs, :error_procs, :template_source, :logger, :router
 
-    should have_imeths :env, :root, :public_root, :views_root
-    should have_imeths :dump_errors, :method_override, :sessions, :show_exceptions
-    should have_imeths :static_files, :reload_templates, :default_encoding
+    should have_accessors :dump_errors, :method_override, :reload_templates
+    should have_accessors :sessions, :show_exceptions, :static_files
+    should have_accessors :verbose_logging
 
-    # server handling options
+    should have_imeths :views_root, :public_root, :urls, :routes
+    should have_imeths :valid?, :validate!
 
-    should have_imeths :verbose_logging, :logger, :template_source
+    should "know its default attr values" do
+      assert_equal 'development', @config_class::DEFAULT_ENV
+      assert_equal 'views',       @config_class::DEFAULT_VIEWS_PATH
+      assert_equal 'public',      @config_class::DEFAULT_PUBLIC_PATH
+      assert_equal 'utf-8',       @config_class::DEFAULT_ENCODING
+    end
 
-    should have_accessors :settings, :init_procs, :error_procs, :template_helpers
-    should have_accessors :middlewares, :router
-    should have_imeths :valid?, :validate!, :urls, :routes
-    should have_imeths :to_hash
+    should "default its attrs" do
+      exp = @config_class::DEFAULT_ENV
+      assert_equal exp, subject.env
 
-    should "default the env to 'development'" do
-      assert_equal 'development', subject.env
-    end
+      exp = ENV['PWD']
+      assert_equal exp, subject.root
 
-    should "default the public and views folders based off the root" do
-      assert_equal subject.root.join('public'), subject.public_root
-      assert_equal subject.root.join('views'), subject.views_root
-    end
+      exp = @config_class::DEFAULT_VIEWS_PATH
+      assert_equal exp, subject.views_path
+
+      exp = @config_class::DEFAULT_PUBLIC_PATH
+      assert_equal exp, subject.public_path
+
+      exp = @config_class::DEFAULT_ENCODING
+      assert_equal exp, subject.default_encoding
+
+      assert_equal Hash.new, subject.settings
+      assert_equal [],       subject.template_helpers
+      assert_equal [],       subject.middlewares
+      assert_equal [],       subject.init_procs
+      assert_equal [],       subject.error_procs
+
+      assert_instance_of Deas::NullTemplateSource, subject.template_source
+      assert_equal subject.root, subject.template_source.path
+
+      assert_instance_of Deas::NullLogger, subject.logger
+      assert_instance_of Deas::Router,     subject.router
 
-    should "default the Sinatra flags" do
       assert_equal false, subject.dump_errors
       assert_equal true,  subject.method_override
+      assert_equal false, subject.reload_templates
       assert_equal false, subject.sessions
       assert_equal false, subject.show_exceptions
       assert_equal true,  subject.static_files
-      assert_equal false, subject.reload_templates
+      assert_equal true,  subject.verbose_logging
     end
 
-    should "default the handling options" do
-      assert_equal true, subject.verbose_logging
-      assert_instance_of Deas::NullLogger, subject.logger
-      assert_instance_of Deas::NullTemplateSource, subject.template_source
+    should "know its views root and public root" do
+      exp = File.expand_path(subject.views_path.to_s, subject.root.to_s)
+      assert_equal exp, subject.views_root
+
+      exp = File.expand_path(subject.public_path.to_s, subject.root.to_s)
+      assert_equal exp, subject.public_root
     end
 
-    should "default its stored configuration" do
-      assert_empty subject.settings
-      assert_empty subject.error_procs
-      assert_empty subject.init_procs
-      assert_empty subject.template_helpers
-      assert_empty subject.middlewares
-      assert_empty subject.routes
-      assert_empty subject.urls
-      assert_kind_of Deas::Router, subject.router
+    should "demeter its router" do
+      assert_equal subject.router.urls,   subject.urls
+      assert_equal subject.router.routes, subject.routes
     end
 
     should "not be valid until validate! has been run" do
-      assert_not subject.valid?
+      assert_false subject.valid?
 
       subject.validate!
-      assert subject.valid?
+      assert_true subject.valid?
     end
 
-    should "complain if validating and `root` isn't set" do
-      config = Configuration.new
+    should "complain if validating and its root value is nil" do
+      config = Config.new
+      config.root = nil
       assert_raises(Deas::ServerRootError){ config.validate! }
-      assert_nothing_raised{ config.root '/path/to/root'; config.validate! }
-    end
-
-    should "use `utf-8` as the default encoding by default" do
-      assert_equal 'utf-8', subject.default_encoding
-    end
-
-    should "include its error procs and router in its `to_hash`" do
-      config_hash = subject.to_hash
-
-      assert_equal subject.error_procs, config_hash[:error_procs]
-      assert_equal subject.router,      config_hash[:router]
     end
 
   end
 
-  class ValidationTests < ConfigurationTests
+  class ValidationTests < ConfigTests
     desc "when successfully validated"
     setup do
-      @initialized = false
-      @other_initialized = false
       @router = Deas::Router.new
-
       @router_validate_called = false
       Assert.stub(@router, :validate!){ @router_validate_called = true }
 
-      @configuration = Configuration.new.tap do |c|
-        c.env              = 'staging'
-        c.root             = 'path/to/somewhere'
-        c.dump_errors      = true
-        c.method_override  = false
-        c.sessions         = false
+      @config = Config.new.tap do |c|
+        c.root             = Factory.path
         c.show_exceptions  = true
-        c.static           = true
-        c.reload_templates = true
-        c.middlewares      = [ ['MyMiddleware'] ]
+        c.verbose_logging  = true
+        c.middlewares      = Factory.integer(3).times.map{ [Factory.string] }
         c.router           = @router
       end
-      @configuration.init_procs << proc{ @initialized = true }
-      @configuration.init_procs << proc{ @other_initialized = true }
+
+      @initialized = false
+      @config.init_procs << proc{ @initialized = true }
+
+      @other_initialized = false
+      @config.init_procs << proc{ @other_initialized = true }
     end
 
-    should "call init procs" do
+    should "call its init procs" do
       assert_equal false, @initialized
       assert_equal false, @other_initialized
 
@@ -250,8 +291,10 @@ module Deas::Server
     end
 
     should "add the Logging and ShowExceptions middleware to the end" do
+      assert_true subject.show_exceptions
+      assert_true subject.verbose_logging
+
       num_middlewares = subject.middlewares.size
-      assert subject.verbose_logging
       assert_not_equal [Deas::ShowExceptions], subject.middlewares[-2]
       assert_not_equal [Deas::VerboseLogging], subject.middlewares[-1]
 
@@ -262,6 +305,15 @@ module Deas::Server
       assert_equal [Deas::VerboseLogging], subject.middlewares[-1]
     end
 
+    should "only be able to be validated once" do
+      called = 0
+      subject.init_procs << proc{ called += 1 }
+      subject.validate!
+      assert_equal 1, called
+      subject.validate!
+      assert_equal 1, called
+    end
+
   end
 
 end