juicer 1.0.16 → 1.0.17

data/test/unit/juicer/command/util_test.rb

@@ -1,58 +0,0 @@
-require "test_helper"
-
-class Dummy
-  include Juicer::Command::Util
-end
-
-class TestCommandUtil < Test::Unit::TestCase
-
-  CSS_FILES = %w{a.css a1.css b.css b1.css b2.css c1.css d1.css path_test.css path_test2.css}
-  JS_FILES = %w{a.js}
-  ALL_FILES = (CSS_FILES + JS_FILES).sort
-
-  def setup
-    @impl = Dummy.new
-    Juicer::Test::FileSetup.new.create
-    Dir.glob("test/data/*.min.css").each { |file| File.delete(file) }
-  end
-
-  def test_files_from_single_file
-    files = @impl.files("test/data/a.css")
-    assert files.is_a?(Array)
-    assert_equal "test/data/a.css", files.sort.join
-  end
-
-  def test_files_from_single_glob_pattern
-    files = @impl.files("test/data/*.css")
-    assert files.is_a?(Array)
-    assert_equal CSS_FILES.collect { |f| "test/data/#{f}" }.join, files.sort.join
-  end
-
-  def test_files_from_mixed_arguments
-    files = @impl.files("test/data/*.css", "test/data/a.js")
-    assert files.is_a?(Array)
-    assert_equal ALL_FILES.collect { |f| "test/data/#{f}" }.join, files.sort.join
-  end
-
-  def test_files_from_array
-    files = @impl.files(["test/data/*.css", "test/data/a.js"])
-    assert files.is_a?(Array)
-    assert_equal ALL_FILES.collect { |f| "test/data/#{f}" }.join, files.sort.join
-  end
-
-  def test_relative_path_single_file
-    assert_equal "test/data/a.css", @impl.relative("test/data/a.css")
-  end
-
-  def test_relative_path_many_files
-    files = @impl.relative(Dir.glob("test/data/*.css"))
-    assert files.is_a?(Array)
-    assert_equal CSS_FILES.collect { |f| "test/data/#{f}" }.join, files.sort.join
-  end
-
-  def test_relative_path_many_files_explicit_reference
-    files = @impl.relative(Dir.glob("test/data/*.css"), "lib")
-    assert files.is_a?(Array)
-    assert_equal CSS_FILES.collect { |f| "../test/data/#{f}" }.join, files.sort.join
-  end
-end

data/test/unit/juicer/command/verify_test.rb

@@ -1,48 +0,0 @@
-require "test_helper"
-
-class TestVerifyCommand < Test::Unit::TestCase
-  def setup
-    @io = StringIO.new
-    @command = Juicer::Command::Verify.new(Logger.new(@io))
-    @path = Dir.pwd
-    @juicer = Juicer.home
-  end
-
-  def teardown
-    Dir.chdir(@path)
-    Juicer.home = @juicer
-  end
-
-  context "executing command" do
-    should "fail with no files" do
-      assert_raise ArgumentError do
-        @command.execute []
-      end
-    end
-
-    should "fail if installer is not found" do
-      Juicer.home = path("somewhere")
-      Dir.chdir("lib")
-      command = Juicer::Command::Verify.new(Logger.new(@io))
-
-      assert_raise FileNotFoundError do
-        command.execute path("a.js")
-      end
-    end
-
-    should "verify several files" do
-      files = %w[file1.js file2.js file3.js]
-      ok = "OK!\njslint: No problems"
-
-      Juicer::Command::Verify.any_instance.expects(:files).with(files).returns(files)
-      Juicer::JsLint.any_instance.expects(:check).with(files[0]).returns(Juicer::JsLint::Report.new)
-      Juicer::JsLint.any_instance.expects(:check).with(files[1]).returns(Juicer::JsLint::Report.new(["Oops"]))
-      Juicer::JsLint.any_instance.expects(:check).with(files[2]).returns(Juicer::JsLint::Report.new)
-
-      @command.execute(files)
-
-      assert_match(/OK!/, @io.string)
-      assert_match(/Problems detected/, @io.string)
-    end
-  end
-end

data/test/unit/juicer/css_cache_buster_test.rb

@@ -1,122 +0,0 @@
-require "test_helper"
-
-class TestCssCacheBuster < Test::Unit::TestCase
-  def setup
-    Juicer::Test::FileSetup.new.create
-    @buster = Juicer::CssCacheBuster.new
-  end
-
-  def teardown
-    Juicer::Test::FileSetup.new.delete
-    Juicer::Test::FileSetup.new.create
-  end
-
-  context "finding urls" do
-    should "find all urls" do
-      urls = @buster.urls(path("css/test.css"))
-      assert_equal 4, urls.length
-      assert_equal "../a1.css../images/1.png2.gif2.gif", urls.collect { |a| a.path }.sort.join.gsub(path("/"), "")
-    end
-  end
-
-  context "image references" do
-    should "update image urls" do
-      file = path("css/test.css")
-      buster = Juicer::CssCacheBuster.new
-      buster.save file
-
-      File.read(file).scan(/url\(([^\)]*)\)/m).each do |path|
-        assert_match(/[^\?]*\?jcb=\d+/, path.first)
-      end
-    end
-
-    should "not add multiple cache busters" do
-      file = path("css/test.css")
-      buster = Juicer::CssCacheBuster.new
-      buster.save file
-
-      assert_no_match /2\.gif\?jcb=\d+\?jcb=/, File.read(file)
-    end
-
-    should "not add multiple cache busters when asset host cycling is used" do
-      file = path("css/test3.css")
-      buster = Juicer::CssCacheBuster.new( { :hosts => [ 'http://assets1', 'http://assets2', 'http://assets3' ], :document_root => './test/data' } )
-      buster.save file
-
-      assert_no_match /2\.gif\?jcb=\d+\?jcb=/, File.read(file)
-    end
-
-  end
-
-  context "absolute paths" do
-    # should "fail without document root" do
-    #   file = path("css/test2.css")
-    #   buster = Juicer::CssCacheBuster.new
-
-    #   assert_raise FileNotFoundError do
-    #     buster.save file
-    #   end
-    # end
-
-    should "resolve with document root" do
-      file = path("css/test.css")
-      buster = Juicer::CssCacheBuster.new :document_root => path("")
-
-      assert_nothing_raised do
-        buster.save file
-      end
-
-      File.read(file).scan(/url\(([^\)]*)\)/m).each do |path|
-        assert_match(/[^\?]*\?jcb=\d+/, path.first)
-      end
-    end
-  end
-
-  context "cache busters" do
-    should "add mtime to urls" do
-      File.open(path("a2.css"), "w") { |f| f.puts "" }
-      file = path("path_test2.css")
-      output = path("path_test3.css")
-      buster = Juicer::CssCacheBuster.new :document_root => path("")
-      buster.save file, output
-
-      buster.urls(output).each { |url| assert url !~ /(jcb=\d+).*(jcb=\d+)/, url }
-    end
-  end
-
-  context "rails cache busters" do
-    should "should append mtime to urls" do
-      File.open(path("a2.css"), "w") { |f| f.puts "" }
-      file = path("path_test2.css")
-      output = path("path_test3.css")
-      buster = Juicer::CssCacheBuster.new :document_root => path(""), :type => :rails
-      buster.save file, output
-
-      buster.urls(output).each { |asset| assert_match /\?\d+$/, asset.path }
-    end
-  end
-
-  context "hard cache busters" do
-    should "should alter file name" do
-      File.open(path("a2.css"), "w") { |f| f.puts "" }
-      file = path("path_test2.css")
-      output = path("path_test3.css")
-      buster = Juicer::CssCacheBuster.new :document_root => path(""), :type => :hard
-      buster.save file, output
-
-      buster.urls(output).each { |asset| assert_match /-jcb\d+\.[a-z]{3}$/, asset.path }
-    end
-  end
-
-  context "non-existent urls" do
-    should "not raise" do
-      File.open(path("a2.css"), "w") { |f| f.puts "a { background: url(i/dont/exist.fck); }" }
-      file = path("a2.css")
-      buster = Juicer::CssCacheBuster.new :document_root => path("")
-
-      assert_nothing_raised do
-        buster.save file
-      end
-    end
-  end
-end

data/test/unit/juicer/datafy_test.rb

@@ -1,37 +0,0 @@
-require 'test/unit'
-require "test_helper"
-
-class TC_Datafy < Test::Unit::TestCase
-
-  def test_make_data_uri_text_plain
-    assert_equal(SHORT_TEXT_PLAIN_URI, Datafy::make_data_uri(SHORT_STRING, TEXT_PLAIN))
-    assert_equal(LONG_TEXT_PLAIN_URI, Datafy::make_data_uri(LONG_STRING, TEXT_PLAIN))
-  end
-
-  def test_make_data_uri_octet_stream
-    assert_equal(SHORT_APPLICATION_OCTET_STREAM_URI, Datafy::make_data_uri(SHORT_STRING, APPLICATION_OCTET_STREAM))
-    assert_equal(LONG_APPLICATION_OCTET_STREAM_URI, Datafy::make_data_uri(LONG_STRING, APPLICATION_OCTET_STREAM))
-  end
-
-  # mime types
-  TEXT_PLAIN = 'text/plain'
-  APPLICATION_OCTET_STREAM = 'application/octet-stream'
-
-  # string versions
-  SHORT_STRING = 'this is some text'
-  SHORT_BASE64 = 'dGhpcyBpcyBzb21lIHRleHQ='
-  SHORT_URLENCODED = 'this+is+some+text'
-
-  LONG_STRING = 'this is a really long string. this is a really long string. this is a really long string. this is a really long string. this is a really long string. this is a really long string. this is a really long string. this is a really long string.'
-  LONG_BASE64 = 'dGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4gdGhpcyBpcyBhIHJlYWxseSBsb25nIHN0cmluZy4='
-  LONG_URLENCODED = 'this+is+a+really+long+string.+this+is+a+really+long+string.+this+is+a+really+long+string.+this+is+a+really+long+string.+this+is+a+really+long+string.+this+is+a+really+long+string.+this+is+a+really+long+string.+this+is+a+really+long+string.'
-
-  # data: uris
-  SHORT_APPLICATION_OCTET_STREAM_URI = "data:#{APPLICATION_OCTET_STREAM};base64,#{SHORT_BASE64}"
-  SHORT_TEXT_PLAIN_URI = "data:#{TEXT_PLAIN},#{SHORT_URLENCODED}"
-
-  LONG_APPLICATION_OCTET_STREAM_URI = "data:#{APPLICATION_OCTET_STREAM};base64,#{LONG_BASE64}"
-  LONG_TEXT_PLAIN_URI = "data:#{TEXT_PLAIN},#{LONG_URLENCODED}"
-
-
-end

data/test/unit/juicer/dependency_resolver/css_dependency_resolver_test.rb

@@ -1,36 +0,0 @@
-require "test_helper"
-
-class TestCssDependencyResolver < Test::Unit::TestCase
-  def setup
-    @resolver = Juicer::CssDependencyResolver.new
-    Juicer::Test::FileSetup.new.create
-  end
-
-  def test_init
-    assert_equal [], @resolver.files
-  end
-
-  def test_resolve
-    b_file = path('b.css')
-    a_file = path('a.css')
-
-    files = @resolver.resolve(path('a.css')) do |file|
-      assert b_file == file || a_file == file
-      b_file != file
-    end
-
-    assert_equal [a_file], files
-
-    files = @resolver.resolve(path('a.css')) do |file|
-      assert b_file == file || a_file == file
-      true
-    end
-
-    assert_equal [a_file, b_file], files.sort
-  end
-
-  def test_load_order
-    files = @resolver.resolve(path("a1.css")).collect { |file| file.split("/").pop }
-    assert_equal "d1.cssb1.cssc1.cssa1.css", files.join
-  end
-end

data/test/unit/juicer/dependency_resolver/javascript_dependency_resolver_test.rb

@@ -1,50 +0,0 @@
-require "test_helper"
-
-class TestJavaScriptDependencyResolver < Test::Unit::TestCase
-
-  def setup
-    @resolver = Juicer::JavaScriptDependencyResolver.new
-    Juicer::Test::FileSetup.new.create
-  end
-
-  def test_init
-    assert_equal [], @resolver.files
-  end
-
-  def test_resolve
-    b_file = path('b.js')
-    a_file = path('a.js')
-
-    files = @resolver.resolve(a_file) do |file|
-      assert b_file == file || a_file == file, file
-      b_file != file
-    end
-
-    assert_equal [a_file], files
-
-    files = @resolver.resolve(a_file) do |file|
-      assert b_file == file || a_file == file
-      true
-    end
-
-    assert_equal [a_file, b_file], files.sort
-
-    files = @resolver.resolve(b_file) do |file|
-      assert b_file == file || a_file == file
-      true
-    end
-
-    assert_equal [a_file, b_file], files.sort
-  end
-
-  def test_directory_resolve
-    my_app = path("my_app.js")
-    expected_files = %w(pkg/pkg.js
-    pkg/module/moda.js
-    pkg/module/modb.js
-    my_app.js).map{|file| path(file)}
-
-    actual_files = @resolver.resolve(my_app)
-    assert_equal expected_files, actual_files
-  end
-end

data/test/unit/juicer/ext/string_test.rb

@@ -1,59 +0,0 @@
-require "test_helper"
-
-class TestStringExtensions < Test::Unit::TestCase
-  context "camel case method" do
-    should "convert underscored string" do
-      assert_equal "CamelCase", "camel_case".camel_case
-    end
-
-    should "convert spaced string" do
-      assert_equal "Camel case", "camel case".camel_case
-    end
-
-    should "convert upper-case underscored string" do
-      assert_equal "CamelCase", "CAMEL_CASE".camel_case
-    end
-
-    should "convert 'camel cased' underscored string" do
-      assert_equal "CamelCase", "Camel_Case".camel_case
-    end
-  end
-
-  context "to_class method" do
-    should "return String class" do
-      assert_equal String, "String".to_class
-    end
-
-    should "return String class from Object" do
-      assert_equal String, "String".to_class(Object)
-    end
-
-    should "return nested class" do
-      assert_equal Juicer::DependencyResolver, "Juicer::DependencyResolver".to_class
-    end
-
-    should "return class from module" do
-      assert_equal Juicer::DependencyResolver, "DependencyResolver".to_class(Juicer)
-    end
-
-    should "return class from nested module" do
-      assert_equal Juicer::Install::YuiCompressorInstaller, "YuiCompressorInstaller".to_class(Juicer::Install)
-    end
-  end
-
-  context "classify method" do
-    should "return class from underscored string" do
-      assert_equal Juicer::DependencyResolver, "dependency_resolver".classify(Juicer)
-    end
-
-    should "return top level class from underscored string" do
-      assert_equal FileUtils, "file_utils".classify
-    end
-  end
-
-  context "underscore method" do
-    should "return underscored string from camel cased string" do
-      assert_equal "stylesheet_merger", "StylesheetMerger".underscore
-    end
-  end
-end

data/test/unit/juicer/ext/symbol_test.rb

@@ -1,27 +0,0 @@
-require "test_helper"
-
-class TestSymbolExtensions < Test::Unit::TestCase
-  context "camel case method" do
-    should "return camel cased string from underscored symbol" do
-      assert_equal "CamelCase", :camel_case.camel_case
-    end
-
-    should "return camel cased string from upper cased underscored symbol" do
-      assert_equal "CamelCase", :CAMEL_CASE.camel_case
-    end
-
-    should "return camel cased string from 'camel cased' underscored symbol" do
-      assert_equal "CamelCase", :Camel_Case.camel_case
-    end
-  end
-
-  context "classify method" do
-    should "return nested class" do
-      assert_equal Juicer::DependencyResolver, :dependency_resolver.classify(Juicer)
-    end
-
-    should "return top level class from underscored symbol" do
-      assert_equal FileUtils, :file_utils.classify
-    end
-  end
-end

data/test/unit/juicer/image_embed_test.rb

@@ -1,339 +0,0 @@
-require "test_helper"
-require 'fakefs/safe'
-
-class TestImageEmbed < Test::Unit::TestCase
-  include FakeFS
-
-  context "ImageEmbed instance using data_uri," do
-    setup do
-      FakeFS.activate!
-      FileSystem.clear
-      FileUtils.mkdir_p("/stylesheets")
-      FileUtils.mkdir_p("/images")
-
-      @supported_assets = [
-                           { :path => '/images/test.png', :content => 'hello png!' },
-                           { :path => '/images/test.gif', :content => 'hello gif!' },
-                           {  :path => '/images/test.jpg', :content => 'hello jpg!' },
-                           { :path => '/images/test.jpeg', :content => 'hello jpeg!' },
-                          ]
-      create_files(@supported_assets)
-
-      @unsupported_assets = [
-                             { :path => '/images/test.bmp', :content => 'hello bmp!' },
-                             { :path => '/images/test.js', :content => 'hello js!' },
-                             { :path => '/images/test.txt', :content => 'hello txt!' },
-                             { :path => '/images/test.swf', :content => 'hello swf!' },
-                             { :path => '/images/test.swf', :content => 'hello swf!' },
-                             { :path => '/images/test.ico', :content => 'hello ico!' },
-                             { :path => '/images/test.tif', :content => 'hello tif!' },
-                             { :path => '/images/test.tiff', :content => 'hello tiff!' },
-                             { :path => '/images/test.applet', :content => 'hello applet!' },
-                             { :path => '/images/test.jar', :content => 'hello jar!' }
-                            ]
-      create_files(@unsupported_assets)
-      @embedder = Juicer::ImageEmbed.new(:type => :data_uri, :document_root => '')
-    end
-
-    teardown do
-      FakeFS.deactivate!
-    end
-
-    context "save method" do
-      context "with files exceeding SIZE_LIMIT" do
-        setup do
-          @large_files = [{ :path => '/images/large-file.png',
-                            :content => "hello png!" + (" " * @embedder.size_limit) }]
-          create_files(@large_files)
-
-          @stylesheets = [{
-                            :path => '/stylesheets/test_embed_duplicates.css',
-                            :content => "body: { background: url(#{@large_files.first[:path]}?embed=true); }"
-                          }]
-          create_files(@stylesheets)
-        end
-
-        should "not embed images that exceeds size limit" do
-          # make sure there are no errors
-          assert_nothing_raised do
-            @embedder.save @stylesheets.first[:path]
-          end
-
-          css_contents = File.read(@stylesheets.first[:path])
-
-          # encode the image
-          image_contents = File.read( @large_files.first[:path] )
-          data_uri = Datafy::make_data_uri(image_contents, 'image/png')
-
-          # make sure the encoded data_uri is not present in the stylesheet
-          assert !css_contents.include?(data_uri)
-
-          # make sure the original url still exist in the stylesheet
-          assert_match Regexp.new(@large_files.first[:path]), css_contents
-        end
-      end
-
-      context "non empty document root" do
-        setup do
-          @document_root = '/path/to/public/dir'
-          @another_embedder = Juicer::ImageEmbed.new(:type => :data_uri, :document_root => @document_root)
-          @files = [{ :path => "#{@document_root}/images/custom-file.png", :filename => '/images/custom-file.png', :content => "hello png!" }]
-          create_files(@files)
-        end
-
-        should "embed urls with embedder" do
-          stylesheets = [{ :path => "#{@document_root}/stylesheets/test_absolute_path.css", :content => "body: { background: url(#{@files.first[:filename]}?embed=true); }" }]
-          create_files(stylesheets)
-
-          @another_embedder.save stylesheets.first[:path]
-          css_contents = File.read(stylesheets.first[:path])
-
-          # encode the image
-          image_contents = File.read(@files.first[:path])
-          data_uri = Datafy::make_data_uri(image_contents, 'image/png')
-
-          # make sure the encoded data_uri is present in the stylesheet
-          assert css_contents.include?(data_uri)
-        end
-
-        should "not embed urls with embedder" do
-          stylesheets = [{ :path => "#{@document_root}/stylesheets/test_absolute_path.css", :content => "body: { background: url(#{@files.first[:filename]}?embed=false); }" }]
-          create_files(stylesheets)
-
-          @another_embedder.save stylesheets.first[:path]
-          css_contents = File.read(stylesheets.first[:path])
-
-          # encode the image
-          assert css_contents.include?(@files.first[:filename])
-        end
-      end
-
-      context "with duplicated urls" do
-        setup do
-          @stylesheets = [{
-                            :path => '/stylesheets/test_embed_duplicates.css',
-                            :content => <<-EOF
-         body: { background: url(#{@supported_assets.first[:path]}?embed=true); }
-         div.section: { background: url(#{@supported_assets.first[:path]}?embed=true); }
-         div.article: { background: url(#{@supported_assets.last[:path]}?embed=true); }
-                            EOF
-                          }]
-          create_files(@stylesheets)
-        end
-
-        should_eventually "provide warnings for duplicate urls"
-
-        should "not embed duplicates" do
-          # make sure there are no errors
-          assert_nothing_raised do
-            @embedder.save @stylesheets.first[:path]
-          end
-
-          css_contents = File.read(@stylesheets.first[:path])
-
-          # encode the image
-          image_contents = File.read(@supported_assets.first[:path])
-          data_uri = Datafy::make_data_uri(image_contents, 'image/png')
-
-          # make sure the encoded data_uri is not present in the stylesheet
-          assert !css_contents.include?(data_uri)
-        end
-
-        should "embed distinct urls" do
-          # make sure there are no errors
-          assert_nothing_raised do
-            @embedder.save @stylesheets.first[:path]
-          end
-
-          css_contents = File.read(@stylesheets.first[:path])
-
-          # encode the image
-          image_contents = File.read(@supported_assets.last[:path])
-          data_uri = Datafy::make_data_uri(image_contents, 'image/jpeg')
-
-          # make sure the encoded data_uri is not present in the stylesheet
-          assert css_contents.include?(data_uri)
-
-          assert_no_match Regexp.new(@supported_assets.last[:path]), css_contents
-        end
-
-      end
-
-      should "embed images into css file" do
-        @stylesheets = [
-                        {
-                          :path => '/stylesheets/test_embed_true.css',
-                          :content => "body: { background: url(#{@supported_assets.first[:path]}?embed=true); }"
-                        }
-                       ]
-        create_files( @stylesheets )
-
-        @stylesheets.each do |stylesheet|
-          old_contents = File.read( stylesheet[:path] )
-
-          # make sure there are no errors
-          assert_nothing_raised do
-            @embedder.save stylesheet[:path]
-          end
-
-          css_contents = File.read( stylesheet[:path] )
-
-          # make sure the original url does not exist anymore
-          assert_no_match( Regexp.new( @supported_assets.first[:path] ), css_contents )
-
-          # make sure the url has been converted into a data uri
-          image_contents = File.read( @supported_assets.first[:path] )
-
-          # # create the data uri from the image contents
-          data_uri = Datafy::make_data_uri( image_contents, 'image/png' )
-
-          # let's see if the data uri exists in the file
-          assert css_contents.include?( data_uri )
-        end
-      end
-
-      should "force embedding images into css file" do
-        @embedder = Juicer::ImageEmbed.new(:type => :data_uri, :document_root => '', :force => true)
-        @stylesheets = [
-                        {
-                          :path => '/stylesheets/test_embed_true.css',
-                          :content => "body: { background: url(#{@supported_assets.first[:path]}); }"
-                        }
-                       ]
-        create_files( @stylesheets )
-
-        @stylesheets.each do |stylesheet|
-          old_contents = File.read( stylesheet[:path] )
-
-          # make sure there are no errors
-          assert_nothing_raised do
-            @embedder.save stylesheet[:path]
-          end
-
-          css_contents = File.read( stylesheet[:path] )
-
-          # make sure the original url does not exist anymore
-          assert_no_match( Regexp.new( @supported_assets.first[:path] ), css_contents )
-
-          # make sure the url has been converted into a data uri
-          image_contents = File.read( @supported_assets.first[:path] )
-
-          # # create the data uri from the image contents
-          data_uri = Datafy::make_data_uri( image_contents, 'image/png' )
-
-          # let's see if the data uri exists in the file
-          assert css_contents.include?( data_uri )
-        end
-      end
-
-      should "not embed unflagged images" do
-        @stylesheets = [
-                        {
-                          :path => '/stylesheets/test_embed_true.css',
-                          :content => "
-        body: { background: url(#{@supported_assets.first[:path]}); }
-        h1: { background: url(#{@supported_assets.last[:path]}?embed=false); }
-      "
-                        }
-                       ]
-        create_files( @stylesheets )
-
-        @stylesheets.each do |stylesheet|
-          old_contents = File.read( stylesheet[:path] )
-
-          # make sure there are no errors
-          assert_nothing_raised do
-            @embedder.save stylesheet[:path]
-          end
-
-          css_contents = File.read( stylesheet[:path] )
-
-          # make sure the original url still exists
-          assert_match( Regexp.new( @supported_assets.first[:path] ), css_contents )
-          assert_match( Regexp.new( @supported_assets.last[:path] ), css_contents )
-        end
-      end
-
-
-      should "not embed unsupported images" do
-        @stylesheets = [
-                        {
-                          :path => '/stylesheets/test_embed_true.css',
-                          :content => "
-        body: { background: url(#{@unsupported_assets.first[:path]}?embed=true); }
-        h1: { background: url(#{@unsupported_assets.last[:path]}?embed=true); }
-      "
-                        }
-                       ]
-        create_files( @stylesheets )
-
-        @stylesheets.each do |stylesheet|
-          old_contents = File.read( stylesheet[:path] )
-
-          # make sure there are no errors
-          assert_nothing_raised do
-            @embedder.save stylesheet[:path]
-          end
-
-          css_contents = File.read( stylesheet[:path] )
-
-          # make sure the original url still exists
-          assert_match( Regexp.new( @unsupported_assets.first[:path] ), css_contents )
-          assert_match( Regexp.new( @unsupported_assets.last[:path] ), css_contents )
-        end
-      end
-
-    end # context
-
-    context "embed method" do
-      should "not modify regular paths" do
-        path = @supported_assets.first[:path]
-        assert_equal( path, @embedder.embed_data_uri( path ) )
-      end
-
-      should "not modify paths flagged as not embeddable" do
-        path = "#{@supported_assets.first[:path]}?embed=false"
-        assert_equal( path, @embedder.embed_data_uri( path ) )
-      end
-
-      should "embed image when path flagged as embeddable" do
-        path = "#{@supported_assets.first[:path]}?embed=true"
-        assert_not_equal( path, @embedder.embed_data_uri( path ) )
-      end
-
-      should "encode all supported asset types" do
-        @supported_assets.each do |asset|
-          path = "#{asset[:path]}?embed=true"
-          assert_not_equal( path, @embedder.embed_data_uri( path ) )
-        end
-      end
-
-      should "not encode unsupported asset types" do
-        @unsupported_assets.each do |asset|
-          path = "#{asset[:path]}?embed=true"
-          assert_equal( path, @embedder.embed_data_uri( path ) )
-        end
-      end
-
-      should "set correct mimetype for supported extensions" do
-        @supported_assets.each do |asset|
-          path = "#{asset[:path]}?embed=true"
-          extension = /(png|gif|jpg|jpeg)/.match( asset[:path] )
-          assert_match(/image\/#{extension}/, @embedder.embed_data_uri( path ) )
-        end
-      end
-    end  # context
-  end
-
-  private
-  # expects the containing path to have been created already
-  def create_files( files = [] )
-    files.each do |file|
-      path = file[:path]
-      File.open(path, 'w') do |f|
-        f.write file[:content]
-        assert File.exists?( file[:path] )
-      end
-    end
-  end
-end