rack-less 2.0.2 → 3.0.0

data/test/irb.rb

@@ -0,0 +1,9 @@
+require 'assert/setup'
+
+# this file is required in when the 'irb' rake test is run.
+# b/c 'assert/setup' is required above, the test helper will be
+# required in.
+
+# put any IRB setup code here
+
+require 'rack/less'

data/test/options_test.rb

@@ -1,25 +1,27 @@
-require "test/helper"
+require "assert"
 require 'rack/less/options'
-require 'fixtures/mock_options'
+require 'test/fixtures/mock_options'
 
-class OptionsTest < Test::Unit::TestCase
-  context 'Rack::Less::Options' do
+module Rack::Less
+
+  class OptionsTest < Assert::Context
+    desc 'Rack::Less::Options'
     setup { @options = MockOptions.new }
 
     should "use a namespace" do
-      assert_equal 'rack-less', Rack::Less::Options::RACK_ENV_NS
+      assert_equal 'rack-less', Options::RACK_ENV_NS
     end
 
     should "provide an option_name helper" do
-      assert_respond_to MockOptions, :option_name
+      assert_respond_to :option_name, MockOptions
     end
 
     should "provide defaults" do
-      assert_respond_to MockOptions, :defaults
+      assert_respond_to :defaults, MockOptions
     end
 
     should "allow access to the options" do
-      assert_respond_to @options, :options, 'no #options accessor'
+      assert_respond_to :options, @options, 'no #options accessor'
       assert_kind_of Hash, @options.options, '#options is not a Hash'
       assert_equal MockOptions.defaults[MockOptions.option_name(:source)], @options.options(:source)
     end
@@ -34,20 +36,20 @@ class OptionsTest < Test::Unit::TestCase
       end
     end
 
-    context '#set' do
-      should "set a Symbol option as #{Rack::Less::Options::RACK_ENV_NS}.symbol" do
-        @options.set :foo, 'bar'
-        assert_equal 'bar', @options.options[MockOptions.option_name(:foo)]
-      end
-      should 'set a String option as string' do
-        @options.set 'foo.bar', 'baz'
-        assert_equal 'baz', @options.options['foo.bar']
-      end
-      should 'set all key/value pairs when given a Hash' do
-        @options.set :foo => 'bar', 'foo.bar' => 'baz'
-        assert_equal 'bar', @options.options[MockOptions.option_name(:foo)]
-        assert_equal 'baz', @options.options['foo.bar']
-      end
+    should "set a Symbol option as #{Options::RACK_ENV_NS}.symbol" do
+      @options.set :foo, 'bar'
+      assert_equal 'bar', @options.options[MockOptions.option_name(:foo)]
+    end
+
+    should 'set a String option as string' do
+      @options.set 'foo.bar', 'baz'
+      assert_equal 'baz', @options.options['foo.bar']
+    end
+
+    should 'set all key/value pairs when given a Hash' do
+      @options.set :foo => 'bar', 'foo.bar' => 'baz'
+      assert_equal 'bar', @options.options[MockOptions.option_name(:foo)]
+      assert_equal 'baz', @options.options['foo.bar']
     end
 
     should 'allow setting multiple options via assignment' do
@@ -57,4 +59,5 @@ class OptionsTest < Test::Unit::TestCase
     end
 
   end
+
 end

data/test/request_test.rb

@@ -1,137 +1,149 @@
-require "test/helper"
+require "assert"
 require 'rack/less/request'
 
-class RequestTest < Test::Unit::TestCase
-
-  context 'Rack::Less::Request' do
-    setup do
-      @defaults = env_defaults
-    end
-
-    context "basic object" do
-      should "have some attributes" do
-        [ :options,
-          :hosted_at_option,
-          :request_method,
-          :path_info,
-          :path_info_format,
-          :path_info_resource,
-          :source,
-          :hosted_at?,
-          :cached?,
-          :for_css?,
-          :for_less?
-        ].each do |a|
-          assert_respond_to less_request("GET", "/foo.css"), a, "request does not respond to #{a.inspect}"
-        end
+module Rack::Less
+
+  class RequestTests < Assert::Context
+    desc 'Rack::Less::Request'
+    setup { @defaults = env_defaults }
+
+    should "have some attributes" do
+      [ :options,
+        :hosted_at_option,
+        :request_method,
+        :path_info,
+        :path_info_format,
+        :path_info_resource,
+        :source,
+        :hosted_at?,
+        :cached?,
+        :for_css?,
+        :for_less?
+      ].each do |a|
+        assert_respond_to a, less_request("GET", "/foo.css"), "request does not respond to #{a.inspect}"
       end
+    end
 
-      should "know it's resource format" do
-        assert_equal '.css', less_request("GET", "/foo.css").path_info_format
-        assert_equal '.css', less_request("GET", "/foo/bar.css").path_info_format
-        assert_equal '', less_request("GET", "/foo/bar").path_info_format
-      end
+    should "know it's resource format" do
+      assert_equal '.css', less_request("GET", "/foo.css").path_info_format
+      assert_equal '.css', less_request("GET", "/foo/bar.css").path_info_format
+      assert_equal '', less_request("GET", "/foo/bar").path_info_format
+    end
 
-      should "sanitize the :hosted_at options" do
-        req = less_request("GET", "/something.css")
-        req.options = {:hosted_at => "/here"}
-        assert_equal "/here", req.hosted_at_option
+    should "sanitize the :hosted_at options" do
+      req = less_request("GET", "/something.css")
+      req.options = {:hosted_at => "/here"}
+      assert_equal "/here", req.hosted_at_option
 
-        req = less_request("GET", "/something.css")
-        req.options = {:hosted_at => "//there"}
-        assert_equal "/there", req.hosted_at_option
+      req = less_request("GET", "/something.css")
+      req.options = {:hosted_at => "//there"}
+      assert_equal "/there", req.hosted_at_option
 
-        req = less_request("GET", "/something.css")
-        req.options = {:hosted_at => "/where/"}
-        assert_equal "/where", req.hosted_at_option
+      req = less_request("GET", "/something.css")
+      req.options = {:hosted_at => "/where/"}
+      assert_equal "/where", req.hosted_at_option
 
-        req = less_request("GET", "/something.css")
-        req.options = {:hosted_at => "what/"}
-        assert_equal "/what", req.hosted_at_option
+      req = less_request("GET", "/something.css")
+      req.options = {:hosted_at => "what/"}
+      assert_equal "/what", req.hosted_at_option
 
-        req = less_request("GET", "/something.css")
-        req.options = {:hosted_at => "why//"}
-        assert_equal "/why", req.hosted_at_option
-      end
+      req = less_request("GET", "/something.css")
+      req.options = {:hosted_at => "why//"}
+      assert_equal "/why", req.hosted_at_option
+    end
 
-      should "know it's resource" do
-        assert_equal '/something', less_request("GET", "/stylesheets/something.css").path_info_resource
-        assert_equal '/something.awesome', less_request("GET", "/stylesheets/something.awesome.css").path_info_resource
-        assert_equal '/nested/something', less_request("GET", "/stylesheets/nested/something.css").path_info_resource
-        assert_equal '/something/really/awesome', less_request("GET", "/stylesheets/something/really/awesome.css").path_info_resource
-        assert_equal '/something', less_request("GET", "/something.css").path_info_resource
-        assert_equal '/something', less_request("GET", "///something.css").path_info_resource
-        assert_equal '/nested/something', less_request("GET", "/nested/something.css").path_info_resource
-        assert_equal '/nested/something', less_request("GET", "/nested///something.css").path_info_resource
-      end
+    should "know it's resource" do
+      assert_equal '/something', less_request("GET", "/stylesheets/something.css").path_info_resource
+      assert_equal '/something.awesome', less_request("GET", "/stylesheets/something.awesome.css").path_info_resource
+      assert_equal '/nested/something', less_request("GET", "/stylesheets/nested/something.css").path_info_resource
+      assert_equal '/something/really/awesome', less_request("GET", "/stylesheets/something/really/awesome.css").path_info_resource
+      assert_equal '/something', less_request("GET", "/something.css").path_info_resource
+      assert_equal '/something', less_request("GET", "///something.css").path_info_resource
+      assert_equal '/nested/something', less_request("GET", "/nested/something.css").path_info_resource
+      assert_equal '/nested/something', less_request("GET", "/nested///something.css").path_info_resource
     end
 
-    context "#source " do
-      should "match :compress settings with Rack::Less:Config" do
-        req = less_request("GET", "/stylesheets/normal.css")
-        assert_equal Rack::Less.config.compress?, req.source.compress?
-      end
+    should "match source :compress settings with Rack::Less:Config" do
+      req = less_request("GET", "/stylesheets/normal.css")
+      assert_equal Rack::Less.config.compress?, req.source.compress?
+    end
 
-      should "set it's cache value to nil when Rack::Less not configured to cache" do
-        Rack::Less.config = Rack::Less::Config.new
-        req = less_request("GET", "/stylesheets/normal.css")
+    should "set it's source cache value to nil when Rack::Less not configured to cache" do
+      Rack::Less.config = Rack::Less::Config.new
+      req = less_request("GET", "/stylesheets/normal.css")
 
-        assert_equal false, req.source.cache?
-        assert_equal nil, req.source.cache
-      end
+      assert_equal false, req.source.cache?
+      assert_equal nil, req.source.cache
+    end
 
-      should "set it's cache to the appropriate path when Rack::Less configured to cache" do
-        Rack::Less.config = Rack::Less::Config.new :cache => true
-        req = less_request("GET", "/stylesheets/normal.css")
-        cache_path = File.join(req.options(:root), req.options(:public), req.hosted_at_option)
+    should "set it's source cache to the appropriate path when Rack::Less configured to cache" do
+      Rack::Less.config = Rack::Less::Config.new :cache => true
+      req = less_request("GET", "/stylesheets/normal.css")
+      cache_path = File.join(req.options(:root), req.options(:public), req.hosted_at_option)
 
-        assert_equal true, req.source.cache?
-        assert_equal cache_path, req.source.cache
-      end
+      assert_equal true, req.source.cache?
+      assert_equal cache_path, req.source.cache
     end
 
+  end
+
+  class ReqInvalidPostNonCssTests < RequestTests
     should_not_be_a_valid_rack_less_request({
       :method      => "POST",
       :resource    => "/foo.html",
       :description => "a non-css resource"
     })
+  end
 
+  class ReqInvalidPostCssTests < RequestTests
     should_not_be_a_valid_rack_less_request({
       :method      => "POST",
       :resource    => "/foo.css",
       :description => "a css resource"
     })
+  end
 
+  class ReqInvalidBadHostTests < RequestTests
     should_not_be_a_valid_rack_less_request({
       :method      => "GET",
       :resource    => "/foo.css",
       :description => "a css resource hosted somewhere other than where Rack::Less expects them"
     })
+  end
 
+  class ReqInvalidNoSourceTests < RequestTests
     should_not_be_a_valid_rack_less_request({
       :method      => "GET",
       :resource    => "/stylesheets/foo.css",
       :description => "a css resource hosted where Rack::Less expects them but does not match any source"
     })
+  end
 
+  class ReqValidHostedMatchedTests < RequestTests
     should_be_a_valid_rack_less_request({
       :method      => "GET",
       :resource    => "/stylesheets/normal.css",
       :description => "a css resource hosted where Rack::Less expects them that matches source"
     })
+  end
 
+  class ReqValidWithDashTests < RequestTests
     should_be_a_valid_rack_less_request({
       :method      => "GET",
       :resource    => "/stylesheets/some-styles.css",
       :description => "a proper css resource with a '-' in the name"
     })
+  end
 
+  class ReqValidUnderscoreTests < RequestTests
     should_be_a_valid_rack_less_request({
       :method      => "GET",
       :resource    => "/stylesheets/some_styles.css",
       :description => "a proper css resource with a '_' in the name"
     })
+  end
 
+  class ReqValidNumberedTests < RequestTests
     should_be_a_valid_rack_less_request({
       :method      => "GET",
       :resource    => "/stylesheets/styles1.css",

data/test/response_test.rb

@@ -1,9 +1,10 @@
-require "test/helper"
+require "assert"
 require 'rack/less/response'
 
-class RequestTest < Test::Unit::TestCase
+module Rack::Less
 
-  context 'Rack::Less::Response' do
+  class ResponseTests < Assert::Context
+    desc 'Rack::Less::Response'
     setup do
       @defaults = env_defaults
       @css = File.read(file_path('test','fixtures','sinatra','app','stylesheets', 'css_compiled.css'))
@@ -19,7 +20,7 @@ class RequestTest < Test::Unit::TestCase
         :content_type,
         :to_rack
       ].each do |a|
-        assert_respond_to @response, a, "request does not respond to #{a.inspect}"
+        assert_respond_to a, @response, "request does not respond to #{a.inspect}"
       end
     end
 
@@ -36,6 +37,7 @@ class RequestTest < Test::Unit::TestCase
       assert_equal Rack::Less::Response.content_length(@css), @response.content_length, 'the content_length accessor is incorrect'
       assert_equal Rack::Less::Response.content_length(@css), @response.headers['Content-Length'].to_i
     end
+
   end
 
 end

data/test/sinatra_test.rb

@@ -1,54 +1,55 @@
-require "test/helper"
+require "assert"
 require "test/app_helper"
 require 'test/fixtures/sinatra/app'
 
-class SinatraTest < Test::Unit::TestCase
+module Rack::Less
 
-  def app
-    @app ||= SinatraApp
-  end
-  def default_value(name)
-    Rack::Less::Base.defaults["#{Rack::Less::Options::RACK_ENV_NS}.#{name}"]
-  end
-
-  context "A Sinatra app using Rack::Less" do
-
-    context "requesting valid LESS" do
-      setup do
-        app.use Rack::Less,
-          :root => file_path('test','fixtures','sinatra')
-
-        @compiled = File.read(file_path('test','fixtures','sinatra','app','stylesheets', 'normal_compiled.css'))
-        @response = visit "/stylesheets/normal.css"
+  class SinatraTests < Assert::Context
+    desc "rack less hosted by a sinatra app"
+    setup do
+      Rack::Less.configure do |config|
+        config.compress = false
+        config.cache = false
       end
-
-      should_respond_with_compiled_css
+      app.use Rack::Less,
+        :root => file_path('test','fixtures','sinatra')
     end
 
-    context "requesting a nested valid LESS" do
-      setup do
-        app.use Rack::Less,
-          :root => file_path('test','fixtures','sinatra')
+    def app
+      @app ||= SinatraApp
+    end
 
-        @compiled = File.read(file_path('test','fixtures','sinatra','app','stylesheets', 'nested', 'file_compiled.css'))
-        @response = visit "/stylesheets/nested/file.css"
-      end
+  end
 
-      should_respond_with_compiled_css
+  class SinatraValidCss < SinatraTests
+    desc "requesting valid LESS"
+    setup do
+      @compiled = File.read(file_path('test','fixtures','sinatra','app','stylesheets', 'normal_compiled.css'))
+      @response = visit "/stylesheets/normal.css"
     end
 
-    context "requesting a really nested valid LESS" do
-      setup do
-        app.use Rack::Less,
-          :root => file_path('test','fixtures','sinatra')
+    should_respond_with_compiled_css
+  end
 
-        @compiled = File.read(file_path('test','fixtures','sinatra','app','stylesheets', 'nested', 'really', 'really_compiled.css'))
-        @response = visit "/stylesheets/nested/really/really.css"
-      end
+  class SinatraNestedValidCss < SinatraTests
+    desc "requesting a nested valid LESS"
+    setup do
+      @compiled = File.read(file_path('test','fixtures','sinatra','app','stylesheets', 'nested', 'file_compiled.css'))
+      @response = visit "/stylesheets/nested/file.css"
+    end
 
-      should_respond_with_compiled_css
+    should_respond_with_compiled_css
+  end
+
+  class SinatraReallyNestedValidCss < SinatraTests
+    desc "requesting a really nested valid LESS"
+    setup do
+      @compiled = File.read(file_path('test','fixtures','sinatra','app','stylesheets', 'nested', 'really', 'really_compiled.css'))
+      @response = visit "/stylesheets/nested/really/really.css"
     end
 
+    should_respond_with_compiled_css
   end
 
-end
+
+end

data/test/source_test.rb

@@ -1,158 +1,172 @@
-require "test/helper"
+require "assert"
 require 'rack/less/source'
 
-class SourceTest < Test::Unit::TestCase
-  context 'Rack::Less::Source' do
+module Rack::Less
+
+  class SourceTests < Assert::Context
+    desc 'Rack::Less::Source'
     setup do
       @source_folder = file_path('test','fixtures','sinatra','app','stylesheets')
       @cache = file_path('test','fixtures','sinatra','public','stylesheets')
     end
 
     should "require an existing :folder" do
+      assert_raise(ArgumentError) { Source.new('foo') }
       assert_raise ArgumentError do
-         Rack::Less::Source.new('foo')
-      end
-      assert_raise ArgumentError do
-        Rack::Less::Source.new('foo', :folder => file_path('does','not','exist'))
+        Source.new('foo', :folder => file_path('does','not','exist'))
       end
       assert_nothing_raised do
-        Rack::Less::Source.new('foo', :folder => @source_folder)
+        Source.new('foo', :folder => @source_folder)
       end
     end
 
     should "accept both .less and .css extensions, prefering .less over .css though" do
-      assert_equal [:less, :css], Rack::Less::Source::PREFERRED_EXTENSIONS
-    end
-
-    context "object" do
-      setup do
-        @basic = Rack::Less::Source.new('basic', :folder => @source_folder)
-        @nested = Rack::Less::Source.new('this/source/is/nested', :folder => @source_folder)
-        @ugly = Rack::Less::Source.new('//this/source/is/ugly', :folder => @source_folder)
-        @compressed = Rack::Less::Source.new('compressed', {
-          :folder => @source_folder,
-          :compress => true
-        })
-        @cached = Rack::Less::Source.new('cached', {
-          :folder => @source_folder,
-          :cache => @cache,
-          :compress => false
-        })
-      end
+      assert_equal [:less, :css], Source::PREFERRED_EXTENSIONS
+    end
 
-      should "have accessors for path and cache values" do
-        assert_respond_to @basic, :css_resource
-        assert_equal 'basic', @basic.css_resource
-        assert_respond_to @basic, :cache
-        assert_equal 'this/source/is/nested', @nested.css_resource
-        assert_equal 'this/source/is/ugly', @ugly.css_resource
-      end
+  end
 
-      should "have an option for using compression" do
-        assert_equal false, @basic.compress?, 'the basic app should not compress'
-        assert_equal true, @compressed.compress?, 'the compressed app should compress'
-        assert_equal false, @cached.compress?, 'the cached app should not compress'
-      end
+  class SourceTypesTests < SourceTests
+    setup do
+      @basic = Source.new('basic', :folder => @source_folder)
+      @nested = Source.new('this/source/is/nested', :folder => @source_folder)
+      @ugly = Source.new('//this/source/is/ugly', :folder => @source_folder)
+      @compressed = Source.new('compressed', {
+        :folder => @source_folder,
+        :compress => true
+      })
+      @cached = Source.new('cached', {
+        :folder => @source_folder,
+        :cache => @cache,
+        :compress => false
+      })
+    end
 
-      should "have an option for caching output to files" do
-        assert_equal false, @basic.cache?, 'the basic app should not cache'
-        assert_equal true, @cached.cache?, 'the cached app should cache'
-      end
+    should "have accessors for path and cache values" do
+      assert_respond_to :css_resource, @basic
+      assert_equal 'basic', @basic.css_resource
+      assert_respond_to :cache, @basic
+      assert_equal 'this/source/is/nested', @nested.css_resource
+      assert_equal 'this/source/is/ugly', @ugly.css_resource
+    end
 
-      should "have a source files list" do
-        assert_respond_to @basic, :files, 'engine does not respond to :files'
-        assert_kind_of Array, @basic.files, 'the engine files is not an Array'
-      end
+    should "have an option for using compression" do
+      assert_equal false, @basic.compress?, 'the basic app should not compress'
+      assert_equal true, @compressed.compress?, 'the compressed app should compress'
+      assert_equal false, @cached.compress?, 'the cached app should not compress'
+    end
 
-      should "have compiled css" do
-        assert_respond_to @basic, :to_css, 'engine does not respond to :to_css'
-        assert_respond_to @basic, :css, 'engine does not respond to :css'
-      end
+    should "have an option for caching output to files" do
+      assert_equal false, @basic.cache?, 'the basic app should not cache'
+      assert_equal true, @cached.cache?, 'the cached app should cache'
     end
 
-    context "with no corresponding source" do
-      setup do
-        @none = Rack::Less::Source.new('none', :folder => @source_folder)
-      end
+    should "have a source files list" do
+      assert_respond_to :files, @basic, 'engine does not respond to :files'
+      assert_kind_of Array, @basic.files, 'the engine files is not an Array'
+    end
 
-      should "have an empty file list" do
-        assert @none.files.empty?, 'engine file list is not empty'
-      end
+    should "have compiled css" do
+      assert_respond_to :to_css, @basic, 'engine does not respond to :to_css'
+      assert_respond_to :css, @basic, 'engine does not respond to :css'
+    end
+  end
 
-      should "generate no css" do
-        assert @none.to_css.empty?, 'engine generated css when it should not have'
-      end
+  class NoSourceTests < SourceTests
+    desc "with no corresponding source"
+    setup do
+      @none = Rack::Less::Source.new('none', :folder => @source_folder)
     end
 
+    should "have an empty file list" do
+      assert @none.files.empty?, 'engine file list is not empty'
+    end
+
+    should "generate no css" do
+      assert @none.to_css.empty?, 'engine generated css when it should not have'
+    end
+  end
+
+  class NormalSourceCompileTests < SourceTests
     should_compile_source('normal', "needing to be compiled")
-    should_compile_source('nested/file', "that is nested, needing to be compiled")
-    should_compile_source('css', "that is a CSS stylesheet")
+  end
 
+  class NestedSourceCompileTests < SourceTests
+    should_compile_source('nested/file', "that is nested, needing to be compiled")
+  end
 
-    context "with whitespace compression" do
-      setup do
-        @compiled = File.read(File.join(@source_folder, "normal_compiled.css"))
-        @compressed_normal = Rack::Less::Source.new('normal', {
-          :folder => @source_folder,
-          :compress => :whitespace
-        })
-      end
+  class CssSourceCompileTests < SourceTests
+    should_compile_source('css', "that is a CSS stylesheet")
+  end
 
-      should "compress the compiled css" do
-        assert_equal @compiled.strip.delete("\n"), @compressed_normal.to_css, "the compiled css is compressed incorrectly"
-      end
+  class SourceWhitespaceCompressTests < SourceTests
+    desc "with whitespace compression"
+    setup do
+      @compressed_normal = Rack::Less::Source.new('normal', {
+        :folder => @source_folder,
+        :compress => :whitespace
+      })
     end
 
-    context "with yui compression" do
-      setup do
-        @compiled = File.read(File.join(@source_folder, "normal_compiled.css"))
-        @compressed_normal = Rack::Less::Source.new('normal', {
-          :folder => @source_folder,
-          :compress => :yui
-        })
-      end
+    should "compress the compiled css" do
+      assert_equal "#header{color:#6c94be;}div{width:2;}", @compressed_normal.to_css, "the compiled css is compressed incorrectly"
+    end
+  end
 
-      should "compress the compiled css" do
-        comp = YUI::CssCompressor.new(Rack::Less::Source::YUI_OPTS).compress(@compiled.strip)
-        assert_equal comp, @compressed_normal.to_css, "the compiled css is compressed incorrectly"
-      end
+  class SourceYuiCompressTests < SourceTests
+    desc "with yui compression"
+    setup do
+      @compiled = File.read(File.join(@source_folder, "normal_compiled.css"))
+      @compressed_normal = Rack::Less::Source.new('normal', {
+        :folder => @source_folder,
+        :compress => :yui
+      })
     end
 
-    context "with caching" do
-      setup do
-        FileUtils.rm_rf(File.dirname(@cache)) if File.exists?(File.dirname(@cache))
-        @expected = Rack::Less::Source.new('normal', {
-          :folder => @source_folder,
-          :cache => @cache
-        }).to_css
-        @cached_file = File.join(@cache, "normal.css")
-      end
-      teardown do
-        FileUtils.rm_rf(File.dirname(@cache)) if File.exists?(File.dirname(@cache))
-      end
+    should "compress the compiled css" do
+      comp = YUI::CssCompressor.new(Rack::Less::Source::YUI_OPTS).compress(@compiled.strip)
+      assert_equal comp, @compressed_normal.to_css, "the compiled css is compressed incorrectly"
+    end
+  end
 
-      should "store the compiled css to a file in the cache" do
-        assert File.exists?(@cache), 'the cache folder does not exist'
-        assert File.exists?(@cached_file), 'the css was not cached to a file'
-        assert_equal @expected.strip, File.read(@cached_file).strip, "the compiled css is incorrect"
+  class SourceCachingTests < SourceTests
+    desc "with caching"
+    setup do
+      FileUtils.rm_rf(File.dirname(@cache)) if File.exists?(File.dirname(@cache))
+      @expected = Rack::Less::Source.new('normal', {
+        :folder => @source_folder,
+        :cache => @cache
+      }).to_css
+      @cached_file = File.join(@cache, "normal.css")
+    end
+    teardown do
+      if File.exists?(File.dirname(@cache))
+        FileUtils.rm_rf(File.dirname(@cache))
       end
     end
 
-    context "that is a combination of multiple files" do
-      setup do
-        @compiled = File.read(File.join(@source_folder, "all_compiled.css"))
-        @combinations_before = Rack::Less.config.combinations
-        Rack::Less.config.combinations = {'all' => ['all_one', 'all_two']}
-        @all = Rack::Less::Source.new('all', :folder => @source_folder)
-      end
-      teardown do
-        Rack::Less.config.combinations = @combinations_before
-      end
+    should "store the compiled css to a file in the cache" do
+      assert File.exists?(@cache), 'the cache folder does not exist'
+      assert File.exists?(@cached_file), 'the css was not cached to a file'
+      assert_equal @expected.strip, File.read(@cached_file).strip, "the compiled css is incorrect"
+    end
+  end
 
-      should "combine the compiled css" do
-        assert_equal @compiled.strip, @all.to_css.strip, "the compiled css is combined incorrectly"
-      end
+  class MultipleSourceTests < SourceTests
+    desc "that is a combination of multiple files"
+    setup do
+      @compiled = File.read(File.join(@source_folder, "all_compiled.css"))
+      @combinations_before = Rack::Less.config.combinations
+      Rack::Less.config.combinations = {'all' => ['all_one', 'all_two']}
+      @all = Rack::Less::Source.new('all', :folder => @source_folder)
+    end
+    teardown do
+      Rack::Less.config.combinations = @combinations_before
     end
 
+    should "combine the compiled css" do
+      assert_equal @compiled.strip, @all.to_css.strip, "the compiled css is combined incorrectly"
+    end
   end
+
 end