asset_hat 0.2.1 → 0.3.0

data/lib/asset_hat/vcs.rb

@@ -69,4 +69,23 @@ module AssetHat
     @last_commit_ids
   end
 
+  # Precomputes and caches the last commit ID for all bundles. Your web server
+  # process(es) should run this at boot to avoid overhead during user runtime.
+  def self.cache_last_commit_ids
+    AssetHat::TYPES.each do |type|
+      next if AssetHat.config[type.to_s].blank? ||
+              AssetHat.config[type.to_s]['bundles'].blank?
+
+      AssetHat.config[type.to_s]['bundles'].keys.each do |bundle|
+        # Memoize commit ID for this bundle
+        AssetHat.last_bundle_commit_id(bundle, type) if AssetHat.cache?
+
+        # Memoize commit IDs for each file in this bundle
+        AssetHat.bundle_filepaths(bundle, type).each do |filepath|
+          AssetHat.last_commit_id(filepath)
+        end
+      end
+    end
+  end
+
 end

data/public/stylesheets/bundles/ssl/css-bundle-1.min.css

@@ -0,0 +1,3 @@
+/* [placeholder] */
+/* [placeholder] */
+/* [placeholder] */

data/public/stylesheets/bundles/ssl/css-bundle-2.min.css

@@ -0,0 +1,3 @@
+/* [placeholder] */
+/* [placeholder] */
+/* [placeholder] */

data/public/stylesheets/bundles/ssl/css-bundle-3.min.css

@@ -0,0 +1,3 @@
+/* [placeholder] */
+/* [placeholder] */
+/* [placeholder] */

data/rails/init.rb

@@ -1,17 +1,2 @@
 ::ActionView::Base.send(:include, AssetHatHelper)
-
-# Precalculate (and memoize) asset commit IDs
-AssetHat::TYPES.each do |type|
-  next if AssetHat.config[type.to_s].blank? ||
-          AssetHat.config[type.to_s]['bundles'].blank?
-
-  AssetHat.config[type.to_s]['bundles'].keys.each do |bundle|
-    # Memoize commit ID for this bundle
-    AssetHat.last_bundle_commit_id(bundle, type) if AssetHat.cache?
-
-    # Memoize commit IDs for each file in this bundle
-    AssetHat.bundle_filepaths(bundle, type).each do |filepath|
-      AssetHat.last_commit_id(filepath)
-    end
-  end
-end
+AssetHat.cache_last_commit_ids unless defined?(::IRB)

data/test/asset_hat_helper_test.rb

@@ -8,11 +8,12 @@ class AssetHatHelperTest < ActionView::TestCase
       context 'with minified versions' do
         setup do
           @commit_id = '111'
-          flexmock(AssetHat).should_receive(:last_commit_id => @commit_id)
+          flexmock(AssetHat, :last_commit_id => @commit_id)
         end
 
-        should 'include one file by name, and automatically use minified version' do
-          flexmock(AssetHat).should_receive(:asset_exists?).and_return(true)
+        should 'include one file by name, and ' +
+               'automatically use minified version' do
+          flexmock(AssetHat, :asset_exists? => true)
           output = include_css('foo', :cache => true)
           assert_equal css_tag("foo.min.css?#{@commit_id}"), output
         end
@@ -28,7 +29,7 @@ class AssetHatHelperTest < ActionView::TestCase
         end
 
         should 'include multiple files by name' do
-          flexmock(AssetHat).should_receive(:asset_exists?).and_return(true)
+          flexmock(AssetHat, :asset_exists? => true)
           expected = %w[foo bar].map do |source|
             css_tag("#{source}.min.css?#{@commit_id}")
           end.join("\n")
@@ -39,12 +40,43 @@ class AssetHatHelperTest < ActionView::TestCase
         should 'include multiple files as a bundle' do
           bundle = 'css-bundle-1'
           output = include_css(:bundle => bundle, :cache => true)
-          assert_equal css_tag("bundles/#{bundle}.min.css?#{@commit_id}"), output
+          assert_equal(
+            css_tag("bundles/#{bundle}.min.css?#{@commit_id}"), output)
         end
+
+        context 'via SSL' do
+          setup do
+            @request = ActionController::TestRequest.new
+            flexmock(@controller, :request => @request)
+            flexmock(@controller.request, :ssl? => true)
+            assert @controller.request.ssl?,
+              'Precondition: Request should use SSL'
+          end
+
+          should 'include multiple files as a SSL bundle' do
+            flexmock(AssetHat, :ssl_asset_host_differs? => true)
+
+            bundle = 'css-bundle-1'
+            output = include_css(:bundle => bundle, :cache => true)
+            assert_equal(
+              css_tag("bundles/ssl/#{bundle}.min.css?#{@commit_id}"), output)
+          end
+
+          should 'use non-SSL CSS if SSL/non-SSL asset hosts are the same' do
+            flexmock(AssetHat, :ssl_asset_host_differs? => false)
+
+            bundle = 'css-bundle-1'
+            output = include_css(:bundle => bundle, :cache => true)
+            assert_equal(
+              css_tag("bundles/#{bundle}.min.css?#{@commit_id}"), output)
+          end
+        end # context 'via SSL'
+
       end # context 'with minified versions'
 
       context 'without minified versions' do
-        should 'include one file by name, and automatically use original version' do
+        should 'include one file by name, and ' +
+               'automatically use original version' do
           output = include_css('foo')
           assert_equal css_tag('foo.css'), output
         end
@@ -52,7 +84,8 @@ class AssetHatHelperTest < ActionView::TestCase
     end # context 'with caching enabled'
 
     context 'with caching disabled' do
-      should 'include one file by name, and automatically use original version' do
+      should 'include one file by name, and ' +
+             'automatically use original version' do
         output = include_css('foo', :cache => false)
         assert_equal css_tag('foo.css'), output
       end
@@ -63,7 +96,8 @@ class AssetHatHelperTest < ActionView::TestCase
       end
 
       should 'include multiple files by name' do
-        expected = %w[foo bar.min].map { |src| css_tag("#{src}.css") }.join("\n")
+        expected = %w[foo bar.min].
+          map { |src| css_tag("#{src}.css") }.join("\n")
         output = include_css('foo', 'bar.min', :cache => false)
         assert_equal expected, output
       end
@@ -98,20 +132,27 @@ class AssetHatHelperTest < ActionView::TestCase
   end # context 'include_css'
 
   context 'include_js' do
+    setup do
+      @request = ActionController::TestRequest.new
+      flexmock(@controller, :request => @request)
+    end
+
     context 'with caching enabled' do
       context 'with minified versions' do
         setup do
           @commit_id = '111'
-          flexmock(AssetHat).should_receive(
+          flexmock(AssetHat,
             :last_commit_id => @commit_id,
             :last_bundle_commit_id => @commit_id
           )
         end
 
-        should 'include one file by name, and automatically use minified version' do
-          flexmock(AssetHat).should_receive(:asset_exists?).and_return(true)
+        should 'include one file by name, and ' +
+               'automatically use minified version' do
+          flexmock(AssetHat, :asset_exists? => true)
           output = include_js('jquery.some-plugin', :cache => true)
-          assert_equal js_tag("jquery.some-plugin.min.js?#{@commit_id}"), output
+          assert_equal js_tag("jquery.some-plugin.min.js?#{@commit_id}"),
+            output
         end
 
         should 'include one unminified file by name and extension' do
@@ -121,7 +162,8 @@ class AssetHatHelperTest < ActionView::TestCase
 
         should 'include one minified file by name and extension' do
           output = include_js('jquery.some-plugin.min.js', :cache => true)
-          assert_equal js_tag("jquery.some-plugin.min.js?#{@commit_id}"), output
+          assert_equal(
+            js_tag("jquery.some-plugin.min.js?#{@commit_id}"), output)
         end
 
         context 'with vendors' do
@@ -132,10 +174,12 @@ class AssetHatHelperTest < ActionView::TestCase
           end
 
           should 'include jQuery and jQuery UI' do
-            flexmock(AssetHat).should_receive(:config => @original_config)
+            flexmock(AssetHat, :config => @original_config)
             [:jquery, :jquery_ui].each do |vendor|
               output = include_js(vendor, :cache => true)
-              assert_equal js_tag("#{vendor.to_s.dasherize}.min.js?#{@commit_id}"), output
+              assert_equal(
+                js_tag("#{vendor.to_s.dasherize}.min.js?#{@commit_id}"),
+                output)
             end
           end
 
@@ -146,6 +190,58 @@ class AssetHatHelperTest < ActionView::TestCase
                 # N.B.: Including only the regular, not minified, version
             end
           end
+
+          context 'with remote requests via SSL' do
+            should 'include vendor JS via Google CDN' do
+              AssetHat::JS::VENDORS.each do |vendor|
+                AssetHat.html_cache[:js] = {}
+                helper_opts = {:version => '1', :cache => true}
+
+                flexmock_teardown
+                flexmock(AssetHat, :cache? => true)
+                flexmock(ActionController::Base,
+                  :consider_all_requests_local => false)
+                flexmock(@controller.request, :ssl? => true)
+                assert @controller.request.ssl?,
+                  'Precondition: Request should use SSL'
+
+                https_html = include_js(vendor, helper_opts.dup)
+                assert_match(
+                  %r{src="https://ajax\.googleapis\.com/}, https_html)
+                assert_equal 1, AssetHat.html_cache[:js].size
+                assert_equal https_html,
+                  AssetHat.html_cache[:js].to_a.first[1],
+                  'SSL HTML should be cached'
+
+                http_cache_key = AssetHat.html_cache[:js].to_a.first[0]
+                flexmock_teardown
+                flexmock(AssetHat, :cache? => true)
+                flexmock(ActionController::Base,
+                  :consider_all_requests_local => false)
+                flexmock(@controller.request, :ssl? => false)
+                assert !@controller.request.ssl?,
+                  'Precondition: Request should not use SSL'
+                assert_equal 1, AssetHat.html_cache[:js].size
+                assert_equal https_html,
+                  AssetHat.html_cache[:js][http_cache_key],
+                  'SSL HTML should be still be cached'
+
+                http_html = include_js(vendor, helper_opts)
+                assert_match(
+                  %r{src="http://ajax\.googleapis\.com/},
+                  http_html,
+                  'Should not use same cached HTML for SSL and non-SSL')
+                assert_equal 2, AssetHat.html_cache[:js].size
+                assert_equal https_html,
+                  AssetHat.html_cache[:js][http_cache_key],
+                  'SSH HTML should still be cached'
+                assert_equal http_html,
+                  AssetHat.html_cache[:js].except(http_cache_key).
+                    to_a.first[1],
+                  'Non-SSL HTML should be cached'
+              end
+            end
+          end # context 'with remote requests via SSL'
         end # context 'with vendor JS'
 
         should 'include jQuery by version via helper option' do
@@ -162,10 +258,11 @@ class AssetHatHelperTest < ActionView::TestCase
             config['js']['vendors'] = {
               'jquery' => {
                 'version' => version,
-                'remote_url' => 'http://example.com/cdn/jquery.min.js'
+                'remote_url' => 'http://example.com/cdn/jquery.min.js',
+                'remote_ssl_url' => 'https://secure.example.com/cdn/jquery.min.js'
               }
             }
-            flexmock(AssetHat).should_receive(:config => config)
+            flexmock(AssetHat, :config => config)
           end
 
           should 'include jQuery by version via config file' do
@@ -178,14 +275,25 @@ class AssetHatHelperTest < ActionView::TestCase
 
           context 'with remote requests' do
             setup do
-              flexmock(ActionController::Base).should_receive(
+              flexmock(ActionController::Base,
                 :consider_all_requests_local => false)
             end
 
             should 'use specified remote URL for jQuery' do
               src = AssetHat.config['js']['vendors']['jquery']['remote_url']
               assert_equal(
-                %Q{<script src="#{src}" type="text/javascript"></script>},
+                %{<script src="#{src}" type="text/javascript"></script>},
+                include_js(:jquery, :cache => true)
+              )
+            end
+
+            should 'use specified remote SSL URL for jQuery' do
+              flexmock(@controller.request, :ssl? => true)
+              src =
+                AssetHat.config['js']['vendors']['jquery']['remote_ssl_url']
+
+              assert_equal(
+                %{<script src="#{src}" type="text/javascript"></script>},
                 include_js(:jquery, :cache => true)
               )
             end
@@ -193,7 +301,7 @@ class AssetHatHelperTest < ActionView::TestCase
         end # context 'with a mock config'
 
         should 'include multiple files by name' do
-          flexmock(AssetHat).should_receive(:asset_exists?).and_return(true)
+          flexmock(AssetHat, :asset_exists? => true)
           expected = %w[foo jquery.bar].map do |source|
             js_tag("#{source}.min.js?#{@commit_id}")
           end.join("\n")
@@ -204,21 +312,51 @@ class AssetHatHelperTest < ActionView::TestCase
         should 'include multiple files as a bundle' do
           bundle = 'js-bundle-1'
           output = include_js(:bundle => bundle, :cache => true)
-          assert_equal js_tag("bundles/#{bundle}.min.js?#{@commit_id}"), output
+          assert_equal(
+            js_tag("bundles/#{bundle}.min.js?#{@commit_id}"), output)
         end
 
         should 'include multiple bundles' do
-          flexmock(AssetHat).should_receive(:asset_exists?).and_return(true)
+          flexmock(AssetHat, :asset_exists? => true)
           expected = %w[foo bar].map do |bundle|
             js_tag("bundles/#{bundle}.min.js?#{@commit_id}")
           end.join("\n")
           output = include_js(:bundles => %w[foo bar], :cache => true)
           assert_equal expected, output
         end
+
+        context 'via SSL' do
+          setup do
+            @request = ActionController::TestRequest.new
+            flexmock(@controller, :request => @request)
+            flexmock(@controller.request, :ssl? => true)
+            assert @controller.request.ssl?,
+              'Precondition: Request should use SSL'
+          end
+
+          should 'use non-SSL JS if SSL/non-SSL asset hosts differ' do
+            flexmock(AssetHat, :ssl_asset_host_differs? => true)
+
+            bundle = 'js-bundle-1'
+            output = include_js(:bundle => bundle, :cache => true)
+            assert_equal(
+              js_tag("bundles/#{bundle}.min.js?#{@commit_id}"), output)
+          end
+
+          should 'use non-SSL JS if SSL/non-SSL asset hosts are the same' do
+            flexmock(AssetHat, :ssl_asset_host_differs? => false)
+
+            bundle = 'js-bundle-1'
+            output = include_js(:bundle => bundle, :cache => true)
+            assert_equal(
+              js_tag("bundles/#{bundle}.min.js?#{@commit_id}"), output)
+          end
+        end # context 'via SSL'
       end # context 'with minified versions'
 
       context 'without minified versions' do
-        should 'include one file by name, and automatically use original version' do
+        should 'include one file by name, and ' +
+               'automatically use original version' do
           output = include_js('jquery.some-plugin', :cache => true)
           assert_equal js_tag('jquery.some-plugin.js'), output
         end
@@ -226,7 +364,8 @@ class AssetHatHelperTest < ActionView::TestCase
     end # context 'with caching enabled'
 
     context 'with caching disabled' do
-      should 'include one file by name, and automatically use original version' do
+      should 'include one file by name, and ' +
+             'automatically use original version' do
         output = include_js('foo', :cache => false)
         assert_equal js_tag('foo.js'), output
       end
@@ -242,7 +381,8 @@ class AssetHatHelperTest < ActionView::TestCase
       end
 
       should 'include multiple files by name' do
-        expected = %w[foo bar.min].map { |src| js_tag("#{src}.js") }.join("\n")
+        expected = %w[foo bar.min].
+          map { |src| js_tag("#{src}.js") }.join("\n")
         output = include_js('foo', 'bar.min', :cache => false)
         assert_equal expected, output
       end
@@ -257,7 +397,8 @@ class AssetHatHelperTest < ActionView::TestCase
         should 'include a bundle as separate files' do
           bundle = 'js-bundle-1'
           sources = @config['js']['bundles'][bundle]
-          expected = sources.map { |src| js_tag("#{src}.js?#{@asset_id}") }.join("\n")
+          expected = sources.
+            map { |src| js_tag("#{src}.js?#{@asset_id}") }.join("\n")
           output = include_js(:bundle => bundle, :cache => false)
           assert_equal expected, output
         end
@@ -281,11 +422,14 @@ class AssetHatHelperTest < ActionView::TestCase
   private
 
   def css_tag(filename)
-    %Q{<link href="/stylesheets/#{filename}" media="screen,projection" rel="stylesheet" type="text/css" />}
+    %{
+      <link href="/stylesheets/#{filename}"
+            media="screen,projection" rel="stylesheet" type="text/css" />
+    }.strip.gsub(/\s+/, ' ')
   end
 
   def js_tag(filename)
-    %Q{<script src="/javascripts/#{filename}" type="text/javascript"></script>}
+    %{<script src="/javascripts/#{filename}" type="text/javascript"></script>}
   end
 
 end

data/test/asset_hat_test.rb

@@ -2,9 +2,23 @@ require 'test_helper'
 
 class AssetHatTest < ActiveSupport::TestCase
   context 'AssetHat' do
+    should 'know where to store assets' do
+      assert_equal 'public/stylesheets', AssetHat.assets_dir(:css)
+      assert_equal 'public/javascripts', AssetHat.assets_dir(:js)
+
+      assert_equal 'bundles', AssetHat.bundles_dir
+      assert_equal 'bundles/ssl', AssetHat.bundles_dir(:ssl => true)
+      assert_equal 'public/stylesheets/bundles', AssetHat.bundles_dir(:css)
+      assert_equal 'public/javascripts/bundles', AssetHat.bundles_dir(:js)
+      assert_equal 'public/stylesheets/bundles/ssl',
+        AssetHat.bundles_dir(:css, :ssl => true)
+      assert_equal 'public/javascripts/bundles/ssl',
+        AssetHat.bundles_dir(:js, :ssl => true)
+    end
+
     context 'with caching enabled' do
       setup do
-        flexmock(AssetHat).should_receive(:cache? => true)
+        flexmock(AssetHat, :cache? => true)
       end
 
       should 'memoize config' do
@@ -16,7 +30,7 @@ class AssetHatTest < ActiveSupport::TestCase
 
     context 'with caching disabled' do
       setup do
-        flexmock(AssetHat).should_receive(:cache? => false)
+        flexmock(AssetHat, :cache? => false)
       end
 
       should 'not memoize config' do
@@ -25,6 +39,66 @@ class AssetHatTest < ActiveSupport::TestCase
         3.times { AssetHat.config }
       end
     end # context 'with caching disabled'
+
+    should 'recognize existing assets' do
+      assert  AssetHat.asset_exists?('css-file-1-1.css', :css)
+      assert !AssetHat.asset_exists?('non-existent-css', :css)
+      assert  AssetHat.asset_exists?('js-file-1-1.js',   :js)
+      assert !AssetHat.asset_exists?('non-existent-js',  :js)
+    end
+
+    should "return a bundle's filenames" do
+      assert_equal  %w[css-file-1-1 css-file-1-2 css-file-1-3],
+                    AssetHat.bundle_filenames('css-bundle-1', :css)
+    end
+
+    should "return a bundle's filepaths" do
+      expected = [1,2,3].map { |i| "public/stylesheets/css-file-1-#{i}.css" }
+      assert_equal expected, AssetHat.bundle_filepaths('css-bundle-1', :css)
+    end
+
+    context 'with asset host' do
+      should 'compute asset host from a String' do
+        asset_host = 'http://cdn%d.example.com'
+        flexmock(ActionController::Base, :asset_host => asset_host)
+        assert_match /http:\/\/cdn\d\.example\.com/,
+          AssetHat.compute_asset_host(asset_host, 'x.png')
+      end
+
+      should 'compute asset host from a Proc' do
+        asset_host = Proc.new do |source, request|
+          if request.ssl?
+            "#{request.protocol}ssl.cdn#{source.hash % 4}.example.com"
+          else
+            "#{request.protocol}cdn#{source.hash % 4}.example.com"
+          end
+        end
+        flexmock(ActionController::Base, :asset_host => asset_host)
+
+        assert_match /http:\/\/cdn\d\.example\.com/,
+          AssetHat.compute_asset_host(asset_host, 'x.png')
+        assert_match /https:\/\/ssl\.cdn\d\.example\.com/,
+          AssetHat.compute_asset_host(asset_host, 'x.png', :ssl => true)
+      end
+
+      should 'know that asset host is same between SSL and non-SSL URLs' do
+        asset_host = 'http://cdn%d.example.com'
+        flexmock(ActionController::Base, :asset_host => asset_host)
+        assert !AssetHat.ssl_asset_host_differs?
+      end
+
+      should 'know that asset host differs between SSL and non-SSL URLs' do
+        asset_host = Proc.new do |source, request|
+          if request.ssl?
+            "#{request.protocol}ssl.cdn#{source.hash % 4}.example.com"
+          else
+            "#{request.protocol}cdn#{source.hash % 4}.example.com"
+          end
+        end
+        flexmock(ActionController::Base, :asset_host => asset_host)
+        assert AssetHat.ssl_asset_host_differs?
+      end
+    end # context 'with asset host'
   end # context 'AssetHat'
 
   context 'AssetHat::CSS' do
@@ -35,31 +109,87 @@ class AssetHatTest < ActiveSupport::TestCase
 
     should 'add image asset commit IDs' do
       commit_id = 111
-      flexmock(AssetHat).should_receive(:last_commit_id => commit_id)
-      flexmock(Rails).should_receive(:public_path => '')
+      flexmock(AssetHat, :last_commit_id => commit_id)
+      flexmock(Rails, :public_path => '')
 
-      assert_equal  "p{background:url(/images/foo.png?#{commit_id})}",
-                    AssetHat::CSS.add_asset_commit_ids(
-                      'p{background:url(/images/foo.png)}')
+      # No/single/double quotes:
+      ['', "'", '"'].each do |quote|
+        img = '/images/foo.png'
+        assert_equal(
+          "p{background:url(#{quote}#{img}?#{commit_id}#{quote})}",
+          AssetHat::CSS.add_asset_commit_ids(
+            "p{background:url(#{quote}#{img}#{quote})}")
+        )
+
+        img = '/images/?id=foo.png'
+        assert_equal(
+          "p{background:url(#{quote}#{img}&#{commit_id}#{quote})}",
+          AssetHat::CSS.add_asset_commit_ids(
+            "p{background:url(#{quote}#{img}#{quote})}")
+        )
+      end
+
+      # Mismatched quotes (should remain untouched):
+      %w[
+        '/images/foo.png
+        '/images/?id=foo.png
+        /images/foo.png'
+        /images/?id=foo.png'
+        "/images/foo.png
+        "/images/?id=foo.png
+        /images/foo.png"
+        /images/?id=foo.png"
+        '/images/foo.png"
+        '/images/?id=foo.png"
+        "/images/foo.png'
+        "/images/?id=foo.png'
+      ].each do |bad_url|
+        assert_equal "p{background:url(#{bad_url})}",
+          AssetHat::CSS.add_asset_commit_ids("p{background:url(#{bad_url})}")
+      end
     end
 
     should 'add .htc asset commit IDs' do
       commit_id = 111
-      flexmock(AssetHat).should_receive(:last_commit_id => commit_id)
-      flexmock(Rails).should_receive(:public_path => '')
+      flexmock(AssetHat, :last_commit_id => commit_id)
+      flexmock(Rails, :public_path => '')
 
       assert_equal  "p{background:url(/htc/iepngfix.htc?#{commit_id})}",
                     AssetHat::CSS.add_asset_commit_ids(
-                      'p{background:url(/htc/iepngfix.htc)}')
+                      "p{background:url(/htc/iepngfix.htc)}")
+      assert_equal  "p{background:url(/htc/?id=iepngfix&#{commit_id})}",
+                    AssetHat::CSS.add_asset_commit_ids(
+                      "p{background:url(/htc/?id=iepngfix)}")
     end
 
     should 'add image asset hosts' do
-      asset_host = 'http://media%d.example.com'
-      assert_match(
-        /^p\{background:url\(http:\/\/media[\d]\.example\.com\/images\/foo.png\)\}$/,
-        AssetHat::CSS.add_asset_hosts(
-          'p{background:url(/images/foo.png)}', asset_host)
-      )
+      asset_host       = 'http://cdn%d.example.com'
+      asset_host_regex = 'http://cdn\d\.example\.com'
+
+      # No/single/double quotes:
+      ['', "'", '"'].each do |quote|
+        img = '/images/foo.png'
+        assert_match(
+          Regexp.new("^p\\{background:url\\(#{quote}" +
+            "#{asset_host_regex}#{Regexp.escape(img)}#{quote}\\)\\}$"),
+          AssetHat::CSS.add_asset_hosts(
+            "p{background:url(#{quote}#{img}#{quote})}", asset_host)
+        )
+      end
+
+      # Mismatched quotes (should remain untouched):
+      %w[
+        '/images/foo.png
+        /images/foo.png'
+        "/images/foo.png
+        /images/foo.png"
+        '/images/foo.png"
+        "/images/foo.png'
+      ].each do |bad_url|
+        assert_equal "p{background:url(#{bad_url})}",
+          AssetHat::CSS.add_asset_hosts("p{background:url(#{bad_url})}",
+                                        asset_host)
+      end
     end
 
     should 'not add .htc asset hosts' do
@@ -70,6 +200,27 @@ class AssetHatTest < ActiveSupport::TestCase
           'p{background:url(/htc/iepngfix.htc)}', asset_host)
       )
     end
+
+    context 'when minifying' do
+      setup do
+        @input = %{
+          .foo { width: 1px; }
+          .bar {}
+          .baz{  width  :  2px;  }
+          .qux {}
+          .quux { }
+          .corge {/* ! */}
+        }
+      end
+
+      context 'with cssmin engine' do
+        should 'remove rules that have empty declaration blocks' do
+          assert_equal '.foo{width:1px;}.baz{width:2px;}',
+            AssetHat::CSS.minify(@input, :engine => :cssmin)
+        end
+      end
+    end # context 'when minifying'
+
   end # context 'AssetHat::CSS'
 
   context 'AssetHat::JS' do
@@ -79,13 +230,4 @@ class AssetHatTest < ActiveSupport::TestCase
     end
   end # context 'AssetHat::JS'
 
-  should "return a bundle's filenames" do
-    assert_equal  %w[css-file-1-1 css-file-1-2 css-file-1-3],
-                  AssetHat.bundle_filenames('css-bundle-1', :css)
-  end
-
-  should "return a bundle's filepaths" do
-    expected = [1,2,3].map { |i| "public/stylesheets/css-file-1-#{i}.css" }
-    assert_equal expected, AssetHat.bundle_filepaths('css-bundle-1', :css)
-  end
 end