aliddle-sass 1.0

data/test/sass/importer_test.rb

@@ -0,0 +1,192 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/test_helper'
+
+require 'sass/plugin'
+
+class ImporterTest < Test::Unit::TestCase
+  
+  class FruitImporter < Sass::Importers::Base
+    def find(name, context = nil)
+      if name =~ %r{fruits/(\w+)(\.s[ac]ss)?}
+        fruit = $1
+        color = case $1
+        when "apple"
+          "red"
+        when "orange"
+          "orange"
+        else
+          "blue"
+        end
+        contents = %Q{
+          $#{fruit}-color: #{color} !default;
+          @mixin #{fruit} {
+            color: $#{fruit}-color;
+          }
+        }
+        Sass::Engine.new(contents, :filename => name, :syntax => :scss, :importer => self)
+      end
+    end
+
+    def key(name, context)
+      [self.class.name, name]
+    end
+  end
+
+  # This class proves that you can override the extension scheme for importers
+  class ReversedExtImporter < Sass::Importers::Filesystem
+    def extensions
+      {"sscs" => :scss, "ssas" => :sass}
+    end
+  end
+
+  # This importer maps one import to another import
+  # based on the mappings passed to importer's constructor.
+  class IndirectImporter < Sass::Importers::Base
+    def initialize(mappings, mtimes)
+      @mappings = mappings
+      @mtimes = mtimes
+    end
+    def find_relative(uri, base, options)
+      nil
+    end
+    def find(name, options)
+      if @mappings.has_key?(name)
+        Sass::Engine.new(
+          %Q[@import "#{@mappings[name]}";],
+          options.merge(
+            :filename => name,
+            :syntax => :scss,
+            :importer => self
+          )
+        )
+      end
+    end
+    def mtime(uri, options)
+      @mtimes.fetch(uri, @mtimes.has_key?(uri) ? Time.now : nil)
+    end
+    def key(uri, options)
+      [self.class.name, uri]
+    end
+    def to_s
+      "IndirectImporter(#{@mappings.keys.join(", ")})"
+    end
+  end
+
+  # This importer maps the import to single class
+  # based on the mappings passed to importer's constructor.
+  class ClassImporter < Sass::Importers::Base
+    def initialize(mappings, mtimes)
+      @mappings = mappings
+      @mtimes = mtimes
+    end
+    def find_relative(uri, base, options)
+      nil
+    end
+    def find(name, options)
+      if @mappings.has_key?(name)
+        Sass::Engine.new(
+          %Q[.#{name}{#{@mappings[name]}}],
+          options.merge(
+            :filename => name,
+            :syntax => :scss,
+            :importer => self
+          )
+        )
+      end
+    end
+    def mtime(uri, options)
+      @mtimes.fetch(uri, @mtimes.has_key?(uri) ? Time.now : nil)
+    end
+    def key(uri, options)
+      [self.class.name, uri]
+    end
+    def to_s
+      "ClassImporter(#{@mappings.keys.join(", ")})"
+    end
+  end
+
+  def test_can_resolve_generated_imports
+    scss_file = %Q{
+      $pear-color: green;
+      @import "fruits/apple"; @import "fruits/orange"; @import "fruits/pear";
+      .apple { @include apple; }
+      .orange { @include orange; }
+      .pear { @include pear; }
+    }
+    css_file = <<CSS
+.apple { color: red; }
+
+.orange { color: orange; }
+
+.pear { color: green; }
+CSS
+    options = {:style => :compact, :load_paths => [FruitImporter.new], :syntax => :scss}
+    assert_equal css_file, Sass::Engine.new(scss_file, options).render
+  end
+
+  def test_extension_overrides
+    FileUtils.mkdir_p(absolutize("tmp"))
+    open(absolutize("tmp/foo.ssas"), "w") {|f| f.write(".foo\n  reversed: true\n")}
+    open(absolutize("tmp/bar.sscs"), "w") {|f| f.write(".bar {reversed: true}\n")}
+    scss_file = %Q{
+      @import "foo", "bar";
+      @import "foo.ssas", "bar.sscs";
+    }
+    css_file = <<CSS
+.foo { reversed: true; }
+
+.bar { reversed: true; }
+
+.foo { reversed: true; }
+
+.bar { reversed: true; }
+CSS
+    options = {:style => :compact, :load_paths => [ReversedExtImporter.new(absolutize("tmp"))], :syntax => :scss}
+    assert_equal css_file, Sass::Engine.new(scss_file, options).render
+  ensure
+    FileUtils.rm_rf(absolutize("tmp"))
+  end
+
+  def test_staleness_check_across_importers
+    file_system_importer = Sass::Importers::Filesystem.new(fixture_dir)
+    # Make sure the first import is older
+    indirect_importer = IndirectImporter.new({"apple" => "pear"}, {"apple" => Time.now - 1})
+    # Make css file is newer so the dependencies are the only way for the css file to be out of date.
+    FileUtils.touch(fixture_file("test_staleness_check_across_importers.css"))
+    # Make sure the first import is older
+    class_importer = ClassImporter.new({"pear" => %Q{color: green;}}, {"pear" => Time.now + 1})
+
+    options = {
+      :style => :compact,
+      :filename => fixture_file("test_staleness_check_across_importers.scss"),
+      :importer => file_system_importer,
+      :load_paths => [file_system_importer, indirect_importer, class_importer],
+      :syntax => :scss
+    }
+
+    assert_equal File.read(fixture_file("test_staleness_check_across_importers.css")),
+                 Sass::Engine.new(File.read(fixture_file("test_staleness_check_across_importers.scss")), options).render
+
+    checker = Sass::Plugin::StalenessChecker.new(options)
+
+    assert checker.stylesheet_needs_update?(
+      fixture_file("test_staleness_check_across_importers.css"),
+      fixture_file("test_staleness_check_across_importers.scss"),
+      file_system_importer
+    )
+  end
+
+  def fixture_dir
+    File.join(File.dirname(__FILE__), "fixtures")
+  end
+
+  def fixture_file(path)
+    File.join(fixture_dir, path)
+  end
+
+  def test_absolute_files_across_template_locations
+    importer = Sass::Importers::Filesystem.new(absolutize 'templates')
+    assert_not_nil importer.mtime(absolutize('more_templates/more1.sass'), {})
+  end
+end

data/test/sass/logger_test.rb

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+require 'pathname'
+
+class LoggerTest < Test::Unit::TestCase
+
+  class InterceptedLogger < Sass::Logger::Base
+
+    attr_accessor :messages
+
+    def initialize(*args)
+      super
+      self.messages = []
+    end
+
+    def reset!
+      self.messages = []
+    end
+
+    def _log(*args)
+      messages << [args]
+    end
+
+  end
+
+  def test_global_sass_logger_instance_exists
+    assert Sass.logger.respond_to?(:warn)
+  end
+
+  def test_log_level_orders
+    logged_levels = {
+      :trace => [ [], [:trace, :debug, :info, :warn, :error]],
+      :debug => [ [:trace],   [:debug, :info, :warn, :error]],
+      :info  => [ [:trace, :debug],   [:info, :warn, :error]],
+      :warn  => [ [:trace, :debug, :info],   [:warn, :error]],
+      :error => [ [:trace, :debug, :info, :warn],   [:error]]
+    }
+    logged_levels.each do |level, (should_not_be_logged, should_be_logged)|
+      logger = Sass::Logger::Base.new(level)
+      should_not_be_logged.each do |should_level|
+        assert !logger.logging_level?(should_level)
+      end
+      should_be_logged.each do |should_level|
+        assert logger.logging_level?(should_level)
+      end
+    end
+  end
+
+  def test_logging_can_be_disabled
+    logger = InterceptedLogger.new
+    logger.error("message #1")
+    assert_equal 1, logger.messages.size
+    logger.reset!
+    logger.disabled = true
+    logger.error("message #2")
+    assert_equal 0, logger.messages.size
+  end
+end

data/test/sass/mock_importer.rb

@@ -0,0 +1,49 @@
+class MockImporter < Sass::Importers::Base
+  def initialize(name = "mock")
+    @name = name
+    @imports = Hash.new({})
+  end
+
+  def find_relative(uri, base, options)
+    nil
+  end
+
+  def find(uri, options)
+    contents = @imports[uri][:contents]
+    return unless contents
+    options[:syntax] = @imports[uri][:syntax]
+    options[:filename] = uri
+    options[:importer] = self
+    @imports[uri][:engine] = Sass::Engine.new(contents, options)
+  end
+
+  def mtime(uri, options)
+    @imports[uri][:mtime]
+  end
+
+  def key(uri, options)
+    ["mock", uri]
+  end
+
+  def to_s
+    @name
+  end
+
+  # Methods for testing
+
+  def add_import(uri, contents, syntax = :scss, mtime = Time.now - 10)
+    @imports[uri] = {
+      :contents => contents,
+      :mtime => mtime,
+      :syntax => syntax
+    }
+  end
+
+  def touch(uri)
+    @imports[uri][:mtime] = Time.now
+  end
+
+  def engine(uri)
+    @imports[uri][:engine]
+  end
+end

data/test/sass/more_results/more1.css

@@ -0,0 +1,9 @@
+body { font: Arial; background: blue; }
+
+#page { width: 700px; height: 100; }
+#page #header { height: 300px; }
+#page #header h1 { font-size: 50px; color: blue; }
+
+#content.user.show #container.top #column.left { width: 100px; }
+#content.user.show #container.top #column.right { width: 600px; }
+#content.user.show #container.bottom { background: brown; }

data/test/sass/more_results/more1_with_line_comments.css

@@ -0,0 +1,26 @@
+/* line 3, ../more_templates/more1.sass */
+body {
+  font: Arial;
+  background: blue; }
+
+/* line 7, ../more_templates/more1.sass */
+#page {
+  width: 700px;
+  height: 100; }
+  /* line 10, ../more_templates/more1.sass */
+  #page #header {
+    height: 300px; }
+    /* line 12, ../more_templates/more1.sass */
+    #page #header h1 {
+      font-size: 50px;
+      color: blue; }
+
+/* line 18, ../more_templates/more1.sass */
+#content.user.show #container.top #column.left {
+  width: 100px; }
+/* line 20, ../more_templates/more1.sass */
+#content.user.show #container.top #column.right {
+  width: 600px; }
+/* line 22, ../more_templates/more1.sass */
+#content.user.show #container.bottom {
+  background: brown; }

data/test/sass/more_results/more_import.css

@@ -0,0 +1,29 @@
+@import url(basic.css);
+@import url(../results/complex.css);
+imported { otherconst: hello; myconst: goodbye; pre-mixin: here; }
+
+body { font: Arial; background: blue; }
+
+#page { width: 700px; height: 100; }
+#page #header { height: 300px; }
+#page #header h1 { font-size: 50px; color: blue; }
+
+#content.user.show #container.top #column.left { width: 100px; }
+#content.user.show #container.top #column.right { width: 600px; }
+#content.user.show #container.bottom { background: brown; }
+
+midrule { inthe: middle; }
+
+body { font: Arial; background: blue; }
+
+#page { width: 700px; height: 100; }
+#page #header { height: 300px; }
+#page #header h1 { font-size: 50px; color: blue; }
+
+#content.user.show #container.top #column.left { width: 100px; }
+#content.user.show #container.top #column.right { width: 600px; }
+#content.user.show #container.bottom { background: brown; }
+
+#foo { background-color: #bbaaff; }
+
+nonimported { myconst: hello; otherconst: goodbye; post-mixin: here; }

data/test/sass/more_templates/_more_partial.sass

@@ -0,0 +1,2 @@
+#foo
+  :background-color #baf

data/test/sass/more_templates/more1.sass

@@ -0,0 +1,23 @@
+
+
+body  
+  :font Arial
+  :background blue
+
+#page
+  :width 700px
+  :height 100
+  #header
+    :height 300px
+    h1
+      :font-size 50px
+      :color     blue
+
+#content.user.show
+  #container.top
+    #column.left
+      :width 100px
+    #column.right
+      :width 600px
+  #container.bottom
+    :background brown

data/test/sass/more_templates/more_import.sass

@@ -0,0 +1,11 @@
+$preconst: hello
+
+=premixin
+  pre-mixin: here
+
+@import importee, basic, basic.css, ../results/complex.css, more_partial
+
+nonimported
+  :myconst $preconst
+  :otherconst $postconst
+  +postmixin

data/test/sass/plugin_test.rb

@@ -0,0 +1,550 @@
+#!/usr/bin/env ruby
+require File.dirname(__FILE__) + '/../test_helper'
+require File.dirname(__FILE__) + '/test_helper'
+require 'sass/plugin'
+require 'fileutils'
+
+module Sass::Script::Functions
+  def filename
+    filename = options[:filename].gsub(%r{.*((/[^/]+){4})}, '\1')
+    Sass::Script::String.new(filename)
+  end
+
+  def whatever
+    custom = options[:custom]
+    whatever = custom && custom[:whatever]
+    Sass::Script::String.new(whatever || "incorrect")
+  end
+end
+
+class SassPluginTest < Test::Unit::TestCase
+  @@templates = %w{
+    complex script parent_ref import scss_import alt
+    subdir/subdir subdir/nested_subdir/nested_subdir
+    options import_content filename_fn
+  }
+  @@templates += %w[import_charset import_charset_ibm866] unless Sass::Util.ruby1_8?
+  @@templates << 'import_charset_1_8' if Sass::Util.ruby1_8?
+
+  @@cache_store = Sass::CacheStores::Memory.new
+
+  def setup
+    FileUtils.mkdir_p tempfile_loc
+    FileUtils.mkdir_p tempfile_loc(nil,"more_")
+    set_plugin_opts
+    check_for_updates!
+    reset_mtimes
+  end
+
+  def teardown
+    clean_up_sassc
+    Sass::Plugin.reset!
+    FileUtils.rm_r tempfile_loc
+    FileUtils.rm_r tempfile_loc(nil,"more_")
+  end
+
+  @@templates.each do |name|
+    define_method("test_template_renders_correctly (#{name})") do
+      assert_renders_correctly(name)
+    end
+  end
+
+  def test_no_update
+    File.delete(tempfile_loc('basic'))
+    assert_needs_update 'basic'
+    check_for_updates!
+    assert_stylesheet_updated 'basic'
+  end
+
+  def test_update_needed_when_modified
+    touch 'basic'
+    assert_needs_update 'basic'
+    check_for_updates!
+    assert_stylesheet_updated 'basic'
+  end
+
+  def test_update_needed_when_dependency_modified
+    touch 'basic'
+    assert_needs_update 'import'
+    check_for_updates!
+    assert_stylesheet_updated 'basic'
+    assert_stylesheet_updated 'import'
+  end
+
+  def test_update_needed_when_scss_dependency_modified
+    touch 'scss_importee'
+    assert_needs_update 'import'
+    check_for_updates!
+    assert_stylesheet_updated 'scss_importee'
+    assert_stylesheet_updated 'import'
+  end
+
+  def test_scss_update_needed_when_dependency_modified
+    touch 'basic'
+    assert_needs_update 'scss_import'
+    check_for_updates!
+    assert_stylesheet_updated 'basic'
+    assert_stylesheet_updated 'scss_import'
+  end
+
+  def test_update_needed_when_nested_import_dependency_modified
+    touch 'basic'
+    assert_needs_update 'nested_import'
+    check_for_updates!
+    assert_stylesheet_updated 'basic'
+    assert_stylesheet_updated 'scss_import'
+  end
+
+  def test_no_updates_when_always_check_and_always_update_both_false
+    Sass::Plugin.options[:always_update] = false
+    Sass::Plugin.options[:always_check] = false
+
+    touch 'basic'
+    assert_needs_update 'basic'
+    check_for_updates!
+
+    # Check it's still stale
+    assert_needs_update 'basic'
+  end
+
+  def test_full_exception_handling
+    File.delete(tempfile_loc('bork1'))
+    check_for_updates!
+    File.open(tempfile_loc('bork1')) do |file|
+      assert_equal(<<CSS.strip, file.read.split("\n")[0...6].join("\n"))
+/*
+Syntax error: Undefined variable: "$bork".
+        on line 2 of #{template_loc('bork1')}
+
+1: bork
+2:   :bork $bork
+CSS
+    end
+    File.delete(tempfile_loc('bork1'))
+  end
+
+  def test_full_exception_with_block_comment
+    File.delete(tempfile_loc('bork5'))
+    check_for_updates!
+    File.open(tempfile_loc('bork5')) do |file|
+      assert_equal(<<CSS.strip, file.read.split("\n")[0...7].join("\n"))
+/*
+Syntax error: Undefined variable: "$bork".
+        on line 3 of #{template_loc('bork5')}
+
+1: bork
+2:   /* foo *\\/
+3:   :bork $bork
+CSS
+    end
+    File.delete(tempfile_loc('bork1'))
+  end
+
+  def test_single_level_import_loop
+    File.delete(tempfile_loc('single_import_loop'))
+    check_for_updates!
+    File.open(tempfile_loc('single_import_loop')) do |file|
+      assert_equal(<<CSS.strip, file.read.split("\n")[0...2].join("\n"))
+/*
+Syntax error: An @import loop has been found: #{template_loc('single_import_loop')} imports itself
+CSS
+    end
+  end
+
+  def test_double_level_import_loop
+    File.delete(tempfile_loc('double_import_loop1'))
+    check_for_updates!
+    File.open(tempfile_loc('double_import_loop1')) do |file|
+      assert_equal(<<CSS.strip, file.read.split("\n")[0...4].join("\n"))
+/*
+Syntax error: An @import loop has been found:
+                  #{template_loc('double_import_loop1')} imports #{template_loc('_double_import_loop2')}
+                  #{template_loc('_double_import_loop2')} imports #{template_loc('double_import_loop1')}
+CSS
+    end
+  end
+
+  def test_nonfull_exception_handling
+    old_full_exception = Sass::Plugin.options[:full_exception]
+    Sass::Plugin.options[:full_exception] = false
+
+    File.delete(tempfile_loc('bork1'))
+    assert_raise(Sass::SyntaxError) {check_for_updates!}
+  ensure
+    Sass::Plugin.options[:full_exception] = old_full_exception
+  end
+
+  def test_two_template_directories
+    set_plugin_opts :template_location => {
+      template_loc => tempfile_loc,
+      template_loc(nil,'more_') => tempfile_loc(nil,'more_')
+    }
+    check_for_updates!
+    ['more1', 'more_import'].each { |name| assert_renders_correctly(name, :prefix => 'more_') }
+  end
+
+  def test_two_template_directories_with_line_annotations
+    set_plugin_opts :line_comments => true,
+                    :style => :nested,
+                    :template_location => {
+                      template_loc => tempfile_loc,
+                      template_loc(nil,'more_') => tempfile_loc(nil,'more_')
+                    }
+    check_for_updates!
+    assert_renders_correctly('more1_with_line_comments', 'more1', :prefix => 'more_')
+  end
+
+  def test_doesnt_render_partials
+    assert !File.exists?(tempfile_loc('_partial'))
+  end
+
+  def test_template_location_array
+    assert_equal [[template_loc, tempfile_loc]], Sass::Plugin.template_location_array
+  end
+
+  def test_add_template_location
+    Sass::Plugin.add_template_location(template_loc(nil, "more_"), tempfile_loc(nil, "more_"))
+    assert_equal(
+      [[template_loc, tempfile_loc], [template_loc(nil, "more_"), tempfile_loc(nil, "more_")]],
+      Sass::Plugin.template_location_array)
+
+    touch 'more1', 'more_'
+    touch 'basic'
+    assert_needs_update "more1", "more_"
+    assert_needs_update "basic"
+    check_for_updates!
+    assert_doesnt_need_update "more1", "more_"
+    assert_doesnt_need_update "basic"
+  end
+
+  def test_remove_template_location
+    Sass::Plugin.add_template_location(template_loc(nil, "more_"), tempfile_loc(nil, "more_"))
+    Sass::Plugin.remove_template_location(template_loc, tempfile_loc)
+    assert_equal(
+      [[template_loc(nil, "more_"), tempfile_loc(nil, "more_")]],
+      Sass::Plugin.template_location_array)
+
+    touch 'more1', 'more_'
+    touch 'basic'
+    assert_needs_update "more1", "more_"
+    assert_needs_update "basic"
+    check_for_updates!
+    assert_doesnt_need_update "more1", "more_"
+    assert_needs_update "basic"
+  end
+
+  def test_import_same_name
+    assert_warning <<WARNING do
+WARNING: In #{template_loc}:
+  There are multiple files that match the name "same_name_different_partiality.scss":
+    _same_name_different_partiality.scss
+    same_name_different_partiality.scss
+WARNING
+      touch "_same_name_different_partiality"
+      assert_needs_update "same_name_different_partiality"
+    end
+  end
+
+  # Callbacks
+
+  def test_updating_stylesheets_callback
+    # Should run even when there's nothing to update
+    Sass::Plugin.options[:template_location] = nil
+    assert_callback :updating_stylesheets, []
+  end
+
+  def test_updating_stylesheets_callback_with_never_update
+    Sass::Plugin.options[:never_update] = true
+    assert_no_callback :updating_stylesheets
+  end
+
+  def test_updated_stylesheet_callback_for_updated_template
+    Sass::Plugin.options[:always_update] = false
+    touch 'basic'
+    assert_no_callback :updated_stylesheet, template_loc("complex"), tempfile_loc("complex") do
+      assert_callbacks(
+        [:updated_stylesheet, template_loc("basic"), tempfile_loc("basic")],
+        [:updated_stylesheet, template_loc("import"), tempfile_loc("import")])
+    end
+  end
+
+  def test_updated_stylesheet_callback_for_fresh_template
+    Sass::Plugin.options[:always_update] = false
+    assert_no_callback :updated_stylesheet
+  end
+
+  def test_updated_stylesheet_callback_for_error_template
+    Sass::Plugin.options[:always_update] = false
+    touch 'bork1'
+    assert_no_callback :updated_stylesheet
+  end
+
+  def test_not_updating_stylesheet_callback_for_fresh_template
+    Sass::Plugin.options[:always_update] = false
+    assert_callback :not_updating_stylesheet, template_loc("basic"), tempfile_loc("basic")
+  end
+
+  def test_not_updating_stylesheet_callback_for_updated_template
+    Sass::Plugin.options[:always_update] = false
+    assert_callback :not_updating_stylesheet, template_loc("complex"), tempfile_loc("complex") do
+      assert_no_callbacks(
+        [:updated_stylesheet, template_loc("basic"), tempfile_loc("basic")],
+        [:updated_stylesheet, template_loc("import"), tempfile_loc("import")])
+    end
+  end
+
+  def test_not_updating_stylesheet_callback_with_never_update
+    Sass::Plugin.options[:never_update] = true
+    assert_no_callback :not_updating_stylesheet
+  end
+
+  def test_not_updating_stylesheet_callback_for_partial
+    Sass::Plugin.options[:always_update] = false
+    assert_no_callback :not_updating_stylesheet, template_loc("_partial"), tempfile_loc("_partial")
+  end
+
+  def test_not_updating_stylesheet_callback_for_error
+    Sass::Plugin.options[:always_update] = false
+    touch 'bork1'
+    assert_no_callback :not_updating_stylesheet, template_loc("bork1"), tempfile_loc("bork1")
+  end
+
+  def test_compilation_error_callback
+    Sass::Plugin.options[:always_update] = false
+    touch 'bork1'
+    assert_callback(:compilation_error,
+      lambda {|e| e.message == 'Undefined variable: "$bork".'},
+      template_loc("bork1"), tempfile_loc("bork1"))
+  end
+
+  def test_compilation_error_callback_for_file_access
+    Sass::Plugin.options[:always_update] = false
+    assert_callback(:compilation_error,
+      lambda {|e| e.is_a?(Errno::ENOENT)},
+      template_loc("nonexistent"), tempfile_loc("nonexistent")) do
+      Sass::Plugin.update_stylesheets([[template_loc("nonexistent"), tempfile_loc("nonexistent")]])
+    end
+  end
+
+  def test_creating_directory_callback
+    Sass::Plugin.options[:always_update] = false
+    dir = File.join(tempfile_loc, "subdir", "nested_subdir")
+    FileUtils.rm_r dir
+    assert_callback :creating_directory, dir
+  end
+
+  ## Regression
+
+  def test_cached_dependencies_update
+    FileUtils.mv(template_loc("basic"), template_loc("basic", "more_"))
+    set_plugin_opts :load_paths => [template_loc(nil, "more_")]
+
+    touch 'basic', 'more_'
+    assert_needs_update "import"
+    check_for_updates!
+    assert_renders_correctly("import")
+  ensure
+    FileUtils.mv(template_loc("basic", "more_"), template_loc("basic"))
+  end
+
+  def test_cached_relative_import
+    old_always_update = Sass::Plugin.options[:always_update]
+    Sass::Plugin.options[:always_update] = true
+    check_for_updates!
+    assert_renders_correctly('subdir/subdir')
+  ensure
+    Sass::Plugin.options[:always_update] = old_always_update
+  end
+
+  def test_cached_if
+    set_plugin_opts :cache_store => Sass::CacheStores::Filesystem.new(tempfile_loc + '/cache')
+    check_for_updates!
+    assert_renders_correctly 'if'
+    check_for_updates!
+    assert_renders_correctly 'if'
+  ensure
+    set_plugin_opts
+  end
+
+  def test_cached_import_option
+    set_plugin_opts :custom => {:whatever => "correct"}
+    check_for_updates!
+    assert_renders_correctly "cached_import_option"
+
+    @@cache_store.reset!
+    set_plugin_opts :custom => nil, :always_update => false
+    check_for_updates!
+    assert_renders_correctly "cached_import_option"
+
+    set_plugin_opts :custom => {:whatever => "correct"}, :always_update => true
+    check_for_updates!
+    assert_renders_correctly "cached_import_option"
+  ensure
+    set_plugin_opts :custom => nil
+  end
+
+ private
+
+  def assert_renders_correctly(*arguments)
+    options = arguments.last.is_a?(Hash) ? arguments.pop : {}
+    prefix = options[:prefix]
+    result_name = arguments.shift
+    tempfile_name = arguments.shift || result_name
+
+    expected_str = File.read(result_loc(result_name, prefix))
+    actual_str = File.read(tempfile_loc(tempfile_name, prefix))
+    unless Sass::Util.ruby1_8?
+      expected_str = expected_str.force_encoding('IBM866') if result_name == 'import_charset_ibm866'
+      actual_str = actual_str.force_encoding('IBM866') if tempfile_name == 'import_charset_ibm866'
+    end
+    expected_lines = expected_str.split("\n")
+    actual_lines = actual_str.split("\n")
+
+    if actual_lines.first == "/*" && expected_lines.first != "/*"
+      assert(false, actual_lines[0..Sass::Util.enum_with_index(actual_lines).find {|l, i| l == "*/"}.last].join("\n"))
+    end
+
+    expected_lines.zip(actual_lines).each_with_index do |pair, line|
+      message = "template: #{result_name}\nline:     #{line + 1}"
+      assert_equal(pair.first, pair.last, message)
+    end
+    if expected_lines.size < actual_lines.size
+      assert(false, "#{actual_lines.size - expected_lines.size} Trailing lines found in #{tempfile_name}.css: #{actual_lines[expected_lines.size..-1].join('\n')}")
+    end
+  end
+
+  def assert_stylesheet_updated(name)
+    assert_doesnt_need_update name
+
+    # Make sure it isn't an exception
+    expected_lines = File.read(result_loc(name)).split("\n")
+    actual_lines = File.read(tempfile_loc(name)).split("\n")
+    if actual_lines.first == "/*" && expected_lines.first != "/*"
+      assert(false, actual_lines[0..actual_lines.enum_with_index.find {|l, i| l == "*/"}.last].join("\n"))
+    end
+  end
+
+  def assert_callback(name, *expected_args)
+    run = false
+    received_args = nil
+    Sass::Plugin.send("on_#{name}") do |*args|
+      received_args = args
+      run ||= expected_args.zip(received_args).all? do |ea, ra|
+        ea.respond_to?(:call) ? ea.call(ra) : ea == ra
+      end
+    end
+
+    if block_given?
+      Sass::Util.silence_sass_warnings {yield}
+    else
+      check_for_updates!
+    end
+
+    assert run, "Expected #{name} callback to be run with arguments:\n  #{expected_args.inspect}\nHowever, it got:\n  #{received_args.inspect}"
+  end
+
+  def assert_no_callback(name, *unexpected_args)
+    Sass::Plugin.send("on_#{name}") do |*a|
+      next unless unexpected_args.empty? || a == unexpected_args
+
+      msg = "Expected #{name} callback not to be run"
+      if !unexpected_args.empty?
+        msg << " with arguments #{unexpected_args.inspect}"
+      elsif !a.empty?
+        msg << ",\n  was run with arguments #{a.inspect}"
+      end
+
+      flunk msg
+    end
+
+    if block_given?
+      yield
+    else
+      check_for_updates!
+    end
+  end
+
+  def assert_callbacks(*args)
+    return check_for_updates! if args.empty?
+    assert_callback(*args.pop) {assert_callbacks(*args)}
+  end
+
+  def assert_no_callbacks(*args)
+    return check_for_updates! if args.empty?
+    assert_no_callback(*args.pop) {assert_no_callbacks(*args)}
+  end
+
+  def check_for_updates!
+    Sass::Util.silence_sass_warnings do
+      Sass::Plugin.check_for_updates
+    end
+  end
+
+  def assert_needs_update(*args)
+    assert(Sass::Plugin::StalenessChecker.stylesheet_needs_update?(tempfile_loc(*args), template_loc(*args)),
+      "Expected #{template_loc(*args)} to need an update.")
+  end
+
+  def assert_doesnt_need_update(*args)
+    assert(!Sass::Plugin::StalenessChecker.stylesheet_needs_update?(tempfile_loc(*args), template_loc(*args)),
+      "Expected #{template_loc(*args)} not to need an update.")
+  end
+
+  def touch(*args)
+    FileUtils.touch(template_loc(*args))
+  end
+
+  def reset_mtimes
+    Sass::Plugin::StalenessChecker.dependencies_cache = {}
+    atime = Time.now
+    mtime = Time.now - 5
+    Dir["{#{template_loc},#{tempfile_loc}}/**/*.{css,sass,scss}"].each {|f| File.utime(atime, mtime, f)}
+  end
+
+  def template_loc(name = nil, prefix = nil)
+    if name
+      scss = absolutize "#{prefix}templates/#{name}.scss"
+      File.exists?(scss) ? scss : absolutize("#{prefix}templates/#{name}.sass")
+    else
+      absolutize "#{prefix}templates"
+    end
+  end
+
+  def tempfile_loc(name = nil, prefix = nil)
+    if name
+      absolutize "#{prefix}tmp/#{name}.css"
+    else
+      absolutize "#{prefix}tmp"
+    end
+  end
+
+  def result_loc(name = nil, prefix = nil)
+    if name
+      absolutize "#{prefix}results/#{name}.css"
+    else
+      absolutize "#{prefix}results"
+    end
+  end
+
+  def set_plugin_opts(overrides = {})
+    Sass::Plugin.options.merge!(
+      :template_location => template_loc,
+      :css_location => tempfile_loc,
+      :style => :compact,
+      :always_update => true,
+      :never_update => false,
+      :full_exception => true,
+      :cache_store => @@cache_store
+    )
+    Sass::Plugin.options.merge!(overrides)
+  end
+end
+
+class Sass::Engine
+  alias_method :old_render, :render
+
+  def render
+    raise "bork bork bork!" if @template[0] == "{bork now!}"
+    old_render
+  end
+end