ktheory-juicer 1.0.0.ktheory1

data/test/data/Changelog.txt

@@ -0,0 +1,10 @@
+2008.02.09 | stb-base 1.29
+
+FEATURE: Core  | Bla bla bla bla bla
+FEATURE: UI: | Bla bla bla bla bla
+
+
+2008.02.09 | stb-base 1.29
+
+FEATURE: Core  | Bla bla bla bla bla
+FEATURE: UI: | Bla bla bla bla bla

data/test/data/a.css

@@ -0,0 +1,3 @@
+@import 'b.css';
+
+/* Dette er a.css */

data/test/data/a.js

@@ -0,0 +1,5 @@
+/**
+ * @depend b.js
+ */
+
+/* Dette er a.js */

data/test/data/a1.css

@@ -0,0 +1,5 @@
+@import 'b1.css';
+@import 'c1.css';
+body {
+    width: 800px;
+}

data/test/data/b.css

@@ -0,0 +1 @@
+/* Dette er b.css */

data/test/data/b.js

@@ -0,0 +1,5 @@
+/**
+ * @depends a.js
+ */
+
+/* Dette er b.css */

data/test/data/b1.css

@@ -0,0 +1,5 @@
+@import 'd1.css';
+
+html {
+    background: red;
+}

data/test/data/c1.css

@@ -0,0 +1,3 @@
+h1 {
+    font-size: 12px;
+}

data/test/data/css/2.gif

@@ -0,0 +1 @@
+

data/test/data/css/test.css

@@ -0,0 +1,11 @@
+body {
+    background: url(../images/1.png);
+}
+
+h1 {
+    background: url(../a1.css) 0 0 no-repeat;
+}
+
+h2 {
+   background: url(2.gif) no-repeat;
+}

data/test/data/css/test2.css

@@ -0,0 +1 @@
+body { background: url(/images/1.png); }

data/test/data/d1.css

@@ -0,0 +1,3 @@
+h2 {
+    font-size: 10px;
+}

data/test/data/images/1.png

@@ -0,0 +1 @@
+

data/test/data/my_app.js

@@ -0,0 +1,2 @@
+// @depend pkg
+ var myApp = pkg.a;

data/test/data/not-ok.js

@@ -0,0 +1,2 @@
+var a = 34
+b = 78;

data/test/data/ok.js

@@ -0,0 +1,3 @@
+function hey() {
+    return "Hey";
+}

data/test/data/path_test.css

@@ -0,0 +1,5 @@
+@import 'css/test.css';
+
+body {
+    background: url(css/2.gif) no-repeat;
+}

data/test/data/path_test2.css

@@ -0,0 +1,14 @@
+body {
+    background: url(/images/1.png);
+}
+
+h1 {
+    background: url(/css/2.gif);
+    background: url(/a1.css) 0 0 no-repeat;
+}
+
+h2 {
+   background: url(/css/2.gif) no-repeat;
+}
+
+p { background: url(/a2.css); }

data/test/data/pkg/module/moda.js

@@ -0,0 +1,2 @@
+// @depend ../pkg.js
+pkg.a = '';

data/test/data/pkg/module/modb.js

@@ -0,0 +1,3 @@
+// @depend ../pkg.js
+// @depend moda.js
+pkg.b = '';

data/test/data/pkg/pkg.js

@@ -0,0 +1 @@
+var pkg = {};

data/test/test_helper.rb

@@ -0,0 +1,169 @@
+require 'fileutils'
+require 'test/unit'
+require 'shoulda'
+require 'mocha'
+require 'open-uri'
+require 'juicer'
+
+if RUBY_VERSION < "1.9"
+  require 'redgreen' if ENV['TM_DIRECTORY'].nil?
+end
+
+$data_dir = File.join(File.expand_path(File.dirname(__FILE__)), "data")
+Juicer.send(:remove_const, :LOGGER)
+Juicer::LOGGER = Logger.new(StringIO.new)
+
+# Prefixes paths with the data dir
+def path(path)
+  File.join($data_dir, path)
+end
+
+# Allow for testing of private methods inside a block:
+#
+#  MyClass.publicize_methods do
+#    assert MyClass.some_private_method
+#  end
+class Class
+  def publicize_methods
+    saved_private_instance_methods = self.private_instance_methods
+    self.class_eval { public(*saved_private_instance_methods) }
+    yield
+    self.class_eval { private(*saved_private_instance_methods) }
+  end
+end
+
+#
+# Intercept calls to open, and return local files
+#
+module Kernel
+ private
+  alias juicer_original_open open # :nodoc:
+
+  def open(name, *rest, &block)
+    if name =~ /http.+yuicompressor-(\d\.\d\.\d)\.zip$/
+      name = File.join($data_dir, "..", "bin", "yuicompressor-#{$1}.zip")
+    elsif name =~ /http:\/\/yuilibrary\.com\/download/
+      name = File.join($data_dir, "yui-download.html")
+    elsif name =~ /http.+yuicompressor/
+      name = File.join($data_dir, "..", "bin", "yuicompressor")
+    elsif name =~ /http.+jslint/
+      name = File.join($data_dir, "..", "bin", "jslint.js")
+    elsif name =~ /ftp.+rhino(.+)\.zip/
+      name = File.join($data_dir, "..", "bin", "rhino#{$1}.zip")
+    end
+
+    juicer_original_open(File.expand_path(name), *rest, &block)
+  end
+
+  module_function :open
+end
+
+module Juicer
+  module Test
+
+    # Alot of Juicer functionality are filesystem operations. This class sets up files
+    # to work on
+    class FileSetup
+      attr_reader :file_count
+
+      def initialize(dir = $data_dir)
+        @dir = dir
+        @file_count = 0
+      end
+
+      # Recursively deletes the data directory
+      def delete
+        res = FileUtils.rm_rf(@dir) if File.exist?(@dir)
+      end
+
+      # Set up files for unit tests
+      def create(force = false)
+        return if File.exist?(@dir) && !force
+
+        delete if File.exist?(@dir)
+        mkdir @dir
+        mkfile(@dir, 'a.css', "@import 'b.css';\n\n/* Dette er a.css */")
+        mkfile(@dir, 'a.js', "/**\n * @depend b.js\n */\n\n/* Dette er a.js */")
+        mkfile(@dir, 'b.css', "/* Dette er b.css */")
+        mkfile(@dir, 'b.js', "/**\n * @depends a.js\n */\n\n/* Dette er b.css */")
+        mkfile(@dir, 'a1.css', "@import 'b1.css';\n@import 'c1.css';\nbody {\n    width: 800px;\n}\n")
+        mkfile(@dir, 'b1.css', "@import 'd1.css';\n\nhtml {\n    background: red;\n}\n")
+        mkfile(@dir, 'c1.css', "h1 {\n    font-size: 12px;\n}\n")
+        mkfile(@dir, 'd1.css', "h2 {\n    font-size: 10px;\n}\n")
+        mkfile(@dir, 'ok.js', "function hey() {\n    return \"Hey\";\n}\n")
+        mkfile(@dir, 'not-ok.js', "var a = 34\nb = 78;\n")
+        
+        images = mkdir File.join(@dir, "images")
+        mkfile(images, '1.png', "")
+
+        css_dir = mkdir File.join(@dir, "css")
+        mkfile(css_dir, '2.gif', "")
+
+        css = <<-CSS
+body {
+    background: url(../images/1.png);
+}
+
+h1 {
+    background: url(../a1.css) 0 0 no-repeat;
+}
+
+h2 {
+   background: url(2.gif) no-repeat;
+}
+        CSS
+
+        mkfile(css_dir, 'test.css', css)
+        mkfile(css_dir, 'test2.css', "body { background: url(/images/1.png); }")
+        mkfile(@dir, 'path_test.css', "@import 'css/test.css';\n\nbody {\n    background: url(css/2.gif) no-repeat;\n}\n")
+
+        css = <<-CSS
+body {
+    background: url(/images/1.png);
+}
+
+h1 {
+    background: url(/css/2.gif);
+    background: url(/a1.css) 0 0 no-repeat;
+}
+
+h2 {
+   background: url(/css/2.gif) no-repeat;
+}
+
+p { background: url(/a2.css); }
+        CSS
+
+        mkfile(@dir, 'path_test2.css', css)
+
+        mkfile(@dir, 'Changelog.txt', "2008.02.09 | stb-base 1.29\n\nFEATURE: Core  | Bla bla bla bla bla\nFEATURE: UI: | Bla bla bla bla bla\n\n\n2008.02.09 | stb-base 1.29\n\nFEATURE: Core  | Bla bla bla bla bla\nFEATURE: UI: | Bla bla bla bla bla\n")
+
+        # my_app.js depends on the pkg directory
+        mkfile(@dir, "my_app.js", "// @depend pkg\n var myApp = pkg.a;")
+
+        # package directory contains pkg.js, module/moda.js, and module/modb.js
+        # moda.js depends on ../pkg.js
+        # modb.js depends on moda.js and ../pkg.js
+        pkg_dir = mkdir File.join(@dir, "pkg")
+        module_dir = mkdir File.join(pkg_dir, "module")
+        mkfile(pkg_dir, "pkg.js", "var pkg = {};")
+        mkfile(module_dir, "moda.js", "// @depend ../pkg.js\npkg.a = '';")
+        mkfile(module_dir, "modb.js", "// @depend ../pkg.js\n// @depend moda.js\npkg.b = '';")
+
+      end
+
+      private
+      # Create a file
+      def mkfile(parent, name, content)
+        file = File.open(File.join(parent, name), 'w+') { |f| f.puts content }
+        @file_count += 1
+      end
+
+      def mkdir(dir)
+        FileUtils.mkdir(dir)
+        @file_count += 1
+        dir
+      end
+    end
+  end
+end

data/test/unit/juicer/asset/path_resolver_test.rb

@@ -0,0 +1,76 @@
+# -*- coding: utf-8 -*-
+
+require "test_helper"
+require "juicer/asset/path_resolver"
+
+class AssetPathResolverTest < Test::Unit::TestCase
+  context "initializing path resolver" do
+    should "use current directory as base" do
+      resolver = Juicer::Asset::PathResolver.new
+
+      assert_equal Dir.pwd, resolver.base
+    end
+
+    should "ensure all hosts are complete with scheme" do
+      resolver = Juicer::Asset::PathResolver.new :hosts => %w[localhost my.project]
+
+      assert_equal %w[http://localhost http://my.project], resolver.hosts
+    end
+
+    should "set document root" do
+      resolver = Juicer::Asset::PathResolver.new :document_root => Dir.pwd
+
+      assert_equal Dir.pwd, resolver.document_root
+    end
+  end
+
+  context "resolving path" do
+    should "return asset object with the same options as the resolver" do
+      resolver = Juicer::Asset::PathResolver.new :document_root => "/var/www", :hosts => ["localhost", "mysite.com"]
+      asset = resolver.resolve("../images/logo.png")
+
+      assert_equal resolver.base, asset.base
+      assert_equal resolver.document_root, asset.document_root
+      assert_equal resolver.hosts, asset.hosts
+    end
+  end
+
+  context "cycling hosts" do
+    should "return one host at a time" do
+      resolver = Juicer::Asset::PathResolver.new :hosts => %w[localhost my.project]
+
+      assert_equal "http://localhost", resolver.cycle_hosts
+      assert_equal "http://my.project", resolver.cycle_hosts
+      assert_equal "http://localhost", resolver.cycle_hosts
+    end
+
+    should "be aliased through host" do
+      resolver = Juicer::Asset::PathResolver.new :hosts => %w[localhost my.project]
+
+      assert_equal "http://localhost", resolver.host
+      assert_equal "http://my.project", resolver.host
+      assert_equal "http://localhost", resolver.host
+    end
+  end
+
+  context "setting base" do
+    should "update property" do
+      resolver = Juicer::Asset::PathResolver.new
+      new_base = "/var/www/test"
+      resolver.base = new_base
+
+      assert_equal new_base, resolver.base
+    end
+
+    should "update base option for new assets" do
+      resolver = Juicer::Asset::PathResolver.new
+      asset1 = resolver.resolve "css/1.css"
+      resolver.base = "/var/www/test"
+      asset2 = resolver.resolve "css/1.css"
+
+      assert_not_equal asset1.base, asset2.base
+      assert_not_equal asset1.base, resolver.base
+      assert_equal asset2.base, resolver.base
+    end
+  end
+end

data/test/unit/juicer/asset/path_test.rb

@@ -0,0 +1,370 @@
+# -*- coding: utf-8 -*-
+
+require "test_helper"
+require "juicer/asset/path"
+
+class AssetPathTest < Test::Unit::TestCase
+  context "initializing asset" do
+    should "use default options" do
+      asset = Juicer::Asset::Path.new "../images/logo.png"
+
+      assert_equal Dir.pwd, asset.base
+      assert_equal [], asset.hosts
+      assert_nil asset.document_root
+    end
+
+    should "override options" do
+      base = "/home/me/project/awesome-site/public/stylesheets"
+      asset = Juicer::Asset::Path.new "../images/logo.png", :base => base
+
+      assert_equal base, asset.base
+    end
+
+    should "not nil base option" do
+      asset = Juicer::Asset::Path.new "../images/logo.png", :base => nil
+
+      assert_equal Dir.pwd, asset.base
+    end
+
+    should "accept a single host" do
+      asset = Juicer::Asset::Path.new "../images/logo.png", :hosts => "http://localhost"
+
+      assert_equal ["http://localhost"], asset.hosts
+    end
+
+    should "accept array of hosts" do
+      asset = Juicer::Asset::Path.new "../images/logo.png", :hosts => ["http://localhost", "http://dev.server"]
+
+      assert_equal ["http://localhost", "http://dev.server"], asset.hosts
+    end
+
+    should "strip trailing slash in hosts" do
+      asset = Juicer::Asset::Path.new "../images/logo.png", :hosts => ["http://localhost/", "http://dev.server"]
+
+      assert_equal ["http://localhost", "http://dev.server"], asset.hosts
+    end
+
+    should "strip add scheme for hosts if missing" do
+      asset = Juicer::Asset::Path.new "../images/logo.png", :hosts => ["localhost", "http://dev.server"]
+
+      assert_equal ["http://localhost", "http://dev.server"], asset.hosts
+    end
+
+    should "strip trailing slash and add scheme in hosts" do
+      asset = Juicer::Asset::Path.new "../images/logo.png", :hosts => ["localhost/", "http://dev.server", "some.server/"]
+
+      assert_equal ["http://localhost", "http://dev.server", "http://some.server"], asset.hosts
+    end
+  end
+
+  context "asset absolute path" do
+    should "raise exception without document root" do
+      asset = Juicer::Asset::Path.new "../images/logo.png"
+
+      assert_raise ArgumentError do
+        asset.absolute_path
+      end
+    end
+
+    should "return absolute path from relative path and document root" do
+      base = "/var/www/public/stylesheets"
+      document_root = "/var/www/public"
+      asset = Juicer::Asset::Path.new "../images/logo.png", :base => base, :document_root => document_root
+
+      assert_equal "/images/logo.png", asset.absolute_path
+    end
+
+    should "return absolute path from absolute path" do
+      base = "/var/www/public/stylesheets"
+      document_root = "/var/www/public"
+      path = "/images/logo.png"
+      asset = Juicer::Asset::Path.new path, { :base => base, :document_root => document_root }
+
+      assert_equal path, asset.absolute_path
+    end
+
+    context "with host" do
+      setup do
+        base = "/var/www/public/stylesheets"
+        document_root = "/var/www/public"
+        options = { :base => base, :document_root => document_root }
+        @asset = Juicer::Asset::Path.new "../images/logo.png", options
+      end
+
+      should "return absolute path with host" do
+        assert_equal "http://localhost/images/logo.png", @asset.absolute_path(:host => "http://localhost")
+      end
+
+      should "strip trailing slash from absolute path host" do
+        assert_equal "http://localhost/images/logo.png", @asset.absolute_path(:host => "http://localhost/")
+      end
+
+      should "ensure scheme in absolute path host" do
+        assert_equal "http://localhost/images/logo.png", @asset.absolute_path(:host => "localhost")
+      end
+
+      should "strip trailing slash and ensure scheme in absolute path host" do
+        assert_equal "http://localhost/images/logo.png", @asset.absolute_path(:host => "localhost/")
+      end
+    end
+
+    context "with cache buster" do
+      setup do
+        @filename = "tmp.asset.txt"
+        file = File.open(@filename, "w") { |f| f.puts "Testing" }
+        @asset = Juicer::Asset::Path.new @filename, :document_root => Dir.pwd
+      end
+
+      teardown do
+        File.delete(@filename)
+      end
+
+      should "return URL with mtime query parameter and default parameter name" do
+        mtime = File.mtime(@filename).to_i
+        assert_equal "/#@filename?jcb=#{mtime}", @asset.absolute_path(:cache_buster_type => :soft)
+      end
+
+      should "return URL with mtime query parameter" do
+        mtime = File.mtime(@filename).to_i
+        assert_equal "/#@filename?#{mtime}", @asset.absolute_path(:cache_buster => nil)
+      end
+
+      should "return URL with mtime embedded" do
+        mtime = File.mtime(@filename).to_i
+        assert_equal "/#{@filename.sub(/\.txt/, '')}-jcb#{mtime}.txt", @asset.absolute_path(:cache_buster => :jcb, :cache_buster_type => :hard)
+      end
+    end
+  end
+
+  context "relative path" do
+    should "return relative path from relative path" do
+      path = "../images/logo.png"
+      asset = Juicer::Asset::Path.new path, :base => "/var/www/public/stylesheets"
+
+      assert_equal path, asset.relative_path
+    end
+
+    should "return relative path from absolute path" do
+      path = "/images/logo.png"
+      asset = Juicer::Asset::Path.new path, :document_root => "/var/www/public", :base => "/var/www/public/stylesheets"
+
+      assert_equal "..#{path}", asset.relative_path
+    end
+
+    context "with cache buster" do
+      setup do
+        @filename = "tmp.asset.txt"
+        file = File.open(@filename, "w") { |f| f.puts "Testing" }
+        @asset = Juicer::Asset::Path.new @filename, :document_root => Dir.pwd
+      end
+
+      teardown do
+        File.delete(@filename)
+      end
+
+      should "return URL with mtime query parameter and default parameter name" do
+        mtime = File.mtime(@filename).to_i
+        result = "#@filename?jcb=#{mtime}"
+        Juicer::CacheBuster.stubs(:soft).with(File.expand_path(@filename)).returns(result)
+
+        assert_equal result, @asset.relative_path(:cache_buster_type => :soft)
+      end
+
+      should "return URL with mtime query parameter" do
+        mtime = File.mtime(@filename).to_i
+        assert_equal "#@filename?#{mtime}", @asset.relative_path(:cache_buster => nil)
+      end
+
+      should "return URL with mtime embedded" do
+        mtime = File.mtime(@filename).to_i
+        assert_equal "#{@filename.sub(/\.txt/, '')}-jcb#{mtime}.txt", @asset.relative_path(:cache_buster => :jcb, :cache_buster_type => :hard)
+      end
+    end
+  end
+
+  context "original path" do
+    should "preserve relative path" do
+      path = "../images/logo.png"
+      asset = Juicer::Asset::Path.new path
+
+      assert_equal path, asset.path
+    end
+
+    should "preserve absolute path" do
+      path = "/images/logo.png"
+      asset = Juicer::Asset::Path.new path
+
+      assert_equal path, asset.path
+    end
+
+    should "preserve absolute path with host" do
+      path = "http://localhost/images/logo.png"
+      asset = Juicer::Asset::Path.new path
+
+      assert_equal path, asset.path
+    end
+
+    context "with cache buster" do
+      setup do
+        @filename = "tmp.asset.txt"
+        file = File.open(@filename, "w") { |f| f.puts "Testing" }
+      end
+
+      teardown do
+        File.delete(@filename)
+      end
+
+      should "return original relative path with mtime query parameter and default parameter name" do
+        asset = Juicer::Asset::Path.new @filename, :document_root => Dir.pwd
+        mtime = File.mtime(@filename).to_i
+        assert_equal "#@filename?jcb=#{mtime}", asset.path(:cache_buster_type => :soft)
+      end
+
+      should "return original absolute path with mtime query parameter and default parameter name" do
+        asset = Juicer::Asset::Path.new "/#@filename", :document_root => Dir.pwd
+        mtime = File.mtime(@filename).to_i
+        assert_equal "/#@filename?jcb=#{mtime}", asset.path(:cache_buster_type => :soft)
+      end
+    end
+  end
+
+  context "asset filename" do
+    should "raise exception with absolute path without document root" do
+      asset = Juicer::Asset::Path.new "/images/logo.png", :document_root => nil
+
+      assert_raise ArgumentError do
+        asset.filename
+      end
+    end
+
+    should "raise exception with absolute path with host without document root" do
+      asset = Juicer::Asset::Path.new "http://localhost/images/logo.png", :document_root => nil
+
+      assert_raise ArgumentError do
+        asset.filename
+      end
+    end
+
+    should "raise exception with absolute path with host without hosts" do
+      options = { :document_root => "/var/project" }
+      asset = Juicer::Asset::Path.new "http://localhost/images/logo.png", options
+
+      assert_raise ArgumentError do
+        begin
+          asset.filename
+        rescue ArgumentError => err
+          assert_match /No hosts served/, err.message
+          raise err
+        end
+      end
+    end
+
+    should "raise exception with mismatching hosts" do
+      options = { :document_root => "/var/project", :hosts => %w[example.com site.com] }
+      asset = Juicer::Asset::Path.new "http://localhost/images/logo.png", options
+
+      assert_raise ArgumentError do
+        begin
+          asset.filename
+        rescue ArgumentError => err
+          assert_match /No matching host/, err.message
+          raise err
+        end
+      end
+    end
+
+    should "return filename from relative path and base" do
+      asset = Juicer::Asset::Path.new "../images/logo.png", :base => "/var/www/public/stylesheets"
+
+      assert_equal "/var/www/public/images/logo.png", asset.filename
+    end
+
+    should "return filename from absolute path and document root" do
+      asset = Juicer::Asset::Path.new "/images/logo.png", :document_root => "/var/www/public"
+
+      assert_equal "/var/www/public/images/logo.png", asset.filename
+    end
+
+    should "return filename from absolute path with host and document root" do
+      asset = Juicer::Asset::Path.new "http://localhost/images/logo.png", :document_root => "/var/www/public", :hosts => "localhost"
+
+      assert_equal "/var/www/public/images/logo.png", asset.filename
+    end
+
+    should "raise exception when hosts match but schemes don't" do
+      options = { :document_root => "/var/www/public", :hosts => "http://localhost" }
+      asset = Juicer::Asset::Path.new "https://localhost/images/logo.png", options
+
+      assert_raise(ArgumentError) { asset.filename }
+    end
+
+    should "return filename from absolute path with hosts and document root" do
+      options = { :document_root => "/var/www/public", :hosts => %w[example.com localhost https://localhost] }
+      asset = Juicer::Asset::Path.new "https://localhost/images/logo.png", options
+
+      assert_equal "/var/www/public/images/logo.png", asset.filename
+    end
+  end
+
+  context "file helpers" do
+    should "return file basename" do
+      base = "/var/www/public/"
+      asset = Juicer::Asset::Path.new "images/logo.png", :base => base
+
+      assert_equal "logo.png", asset.basename
+    end
+
+    should "return file dirname" do
+      base = "/var/www/public/"
+      asset = Juicer::Asset::Path.new "images/logo.png", :base => base
+
+      assert_equal "#{base}images", asset.dirname
+    end
+
+    should "verify that file does not exist" do
+      base = "/var/www/public/"
+      asset = Juicer::Asset::Path.new "images/logo.png", :base => base
+
+      assert !asset.exists?
+    end
+
+    context "existing file" do
+      setup { File.open("somefile.css", "w") { |f| f.puts "/* Test */" } }
+      teardown { File.delete("somefile.css") }
+
+      should "verify that file exists" do
+        asset = Juicer::Asset::Path.new "somefile.css"
+
+        assert asset.exists?
+      end
+    end
+  end
+
+  context "rebase path" do
+    should "return new asset with shifted base" do
+      base = "/var/www/project/public"
+      asset = Juicer::Asset::Path.new "../images/logo.png", :base => "#{base}/stylesheets"
+      rebased_asset = asset.rebase(base)
+
+      assert_equal "images/logo.png", rebased_asset.relative_path
+    end
+
+    should "preserve all options but base context" do
+      base = "/var/www/project/public"
+      options = { :base => "#{base}/stylesheets", :hosts => ["localhost"], :document_root => base }
+      asset = Juicer::Asset::Path.new "../images/logo.png", options
+      rebased_asset = asset.rebase(base)
+
+      assert_equal asset.document_root, rebased_asset.document_root
+      assert_equal asset.hosts, rebased_asset.hosts
+    end
+
+    should "return same absolute path" do
+      base = "/var/www/project/public"
+      asset = Juicer::Asset::Path.new "../images/logo.png", :base => "#{base}/stylesheets", :document_root => base
+      rebased_asset = asset.rebase(base)
+
+      assert_equal asset.absolute_path, rebased_asset.absolute_path
+    end
+  end
+end