dassets 0.14.1 → 0.15.0

data/test/unit/asset_file_tests.rb

@@ -1,140 +1,144 @@
-require 'assert'
-require 'dassets/asset_file'
+require "assert"
+require "dassets/asset_file"
 
-require 'fileutils'
-require 'dassets/file_store'
-require 'dassets/source_proxy'
+require "fileutils"
+require "dassets/file_store"
+require "dassets/source_proxy"
 
 class Dassets::AssetFile
-
   class UnitTests < Assert::Context
     desc "Dassets::AssetFile"
+    subject { @asset_file }
+
     setup do
-      @asset_file = Dassets::AssetFile.new('file1.txt')
+      @asset_file = Dassets::AssetFile.new("file1.txt")
     end
-    subject{ @asset_file }
 
     should have_readers :digest_path, :dirname, :extname, :basename, :source_proxy
     should have_imeths  :digest!, :url, :href, :fingerprint, :content
     should have_imeths  :mtime, :size, :mime_type, :exists?, :==
 
     should "know its digest path, dirname, extname, and basename" do
-      assert_equal 'file1.txt', subject.digest_path
-      assert_equal '.',     subject.dirname
-      assert_equal '.txt',  subject.extname
-      assert_equal 'file1', subject.basename
+      assert_that(subject.digest_path).equals("file1.txt")
+      assert_that(subject.dirname).equals(".")
+      assert_that(subject.extname).equals(".txt")
+      assert_that(subject.basename).equals("file1")
     end
 
     should "use its source proxy attrs as its own" do
-      assert_equal subject.source_proxy.mtime.httpdate, subject.mtime
-      assert_equal Rack::Utils.bytesize(subject.content), subject.size
-      assert_equal "text/plain", subject.mime_type
-      assert_equal subject.source_proxy.response_headers, subject.response_headers
-      assert subject.exists?
-
-      null_file = Dassets::AssetFile.new('')
-      assert_nil null_file.mtime
-      assert_nil null_file.size
-      assert_nil null_file.mime_type
-      assert_not null_file.exists?
-      assert_equal null_file.source_proxy.response_headers, null_file.response_headers
+      assert_that(subject.mtime).equals(subject.source_proxy.mtime.httpdate)
+      assert_that(subject.size).equals(subject.content.bytesize)
+      assert_that(subject.mime_type).equals("text/plain")
+      assert_that(subject.response_headers)
+      .equals(subject.source_proxy.response_headers)
+      assert_that(subject.exists?).is_true
+
+      null_file = Dassets::AssetFile.new("")
+      assert_that(null_file.mtime).is_nil
+      assert_that(null_file.size).is_nil
+      assert_that(null_file.mime_type).is_nil
+      assert_that(null_file.exists?).is_false
+      assert_that(null_file.response_headers)
+        .equals(null_file.source_proxy.response_headers)
     end
 
     should "know its source proxy" do
       source_proxy = subject.source_proxy
-      assert_not_nil source_proxy
-      assert_kind_of Dassets::SourceProxy, source_proxy
-      assert_equal subject.digest_path, source_proxy.digest_path
-      assert_equal Dassets.config.content_cache, source_proxy.content_cache
-      assert_equal Dassets.config.fingerprint_cache, source_proxy.fingerprint_cache
+      assert_that(source_proxy).is_not_nil
+      assert_that(source_proxy).is_kind_of(Dassets::SourceProxy)
+      assert_that(source_proxy.digest_path).equals(subject.digest_path)
+      assert_that(source_proxy.content_cache)
+        .equals(Dassets.config.content_cache)
+      assert_that(source_proxy.fingerprint_cache)
+        .equals(Dassets.config.fingerprint_cache)
     end
 
     should "have a fingerprint" do
-      assert_not_nil subject.fingerprint
+      assert_that(subject.fingerprint).is_not_nil
     end
 
     should "get its fingerprint from its source proxy if none is given" do
-      af = Dassets::AssetFile.new('file1.txt')
-      assert_equal af.source_proxy.fingerprint, af.fingerprint
+      af = Dassets::AssetFile.new("file1.txt")
+      assert_that(af.fingerprint).equals(af.source_proxy.fingerprint)
     end
 
     should "know it's content" do
-      assert_equal "file1.txt\n", subject.content
+      assert_that(subject.content).equals("file1.txt\n")
 
-      null_file = Dassets::AssetFile.new('')
-      assert_nil null_file.content
+      null_file = Dassets::AssetFile.new("")
+      assert_that(null_file.content).is_nil
     end
 
     should "get its content from its source proxy if no output file" do
-      digest_path = 'nested/a-thing.txt.no-use'
+      digest_path = "nested/a-thing.txt.no-use"
       exp_content = "thing\n\nDUMB\nUSELESS"
 
       without_output = Dassets::AssetFile.new(digest_path)
-      assert_equal exp_content, without_output.content
+      assert_that(without_output.content).equals(exp_content)
     end
 
-    should "build it's url/href from the file, fingerpint and any configured base url" do
-      assert_match /^\/file1-[a-f0-9]{32}\.txt$/, subject.url
-      assert_match subject.url, subject.href
+    should "build it's url/href from the file, fingerpint, and "\
+           "any configured base url" do
+      assert_that(subject.url).matches(/^\/file1-[a-f0-9]{32}\.txt$/)
+      assert_that(subject.href).matches(subject.url)
 
-      nested = Dassets::AssetFile.new('nested/file1.txt')
-      assert_equal "/nested/file1-.txt", nested.url
-      assert_equal nested.url, nested.href
+      nested = Dassets::AssetFile.new("nested/file1.txt")
+      assert_that(nested.url).equals("/nested/file1-.txt")
+      assert_that(nested.href).equals(nested.url)
 
       base_url = Factory.url
       Assert.stub(Dassets.config, :base_url){ base_url }
 
-      assert_match /^#{base_url}\/file1-[a-f0-9]{32}\.txt$/, subject.url
-      assert_match subject.url, subject.href
+      assert_that(subject.url).matches(/^#{base_url}\/file1-[a-f0-9]{32}\.txt$/)
+      assert_that(subject.href).matches(subject.url)
 
-      assert_equal "#{base_url}/nested/file1-.txt", nested.url
-      assert_equal nested.url, nested.href
+      assert_that(nested.url).equals("#{base_url}/nested/file1-.txt")
+      assert_that(nested.href).equals(nested.url)
     end
 
     should "not memoize its attributes" do
       url1 = subject.url
       url2 = subject.url
-      assert_not_same url2, url1
+      assert_that(url1).is_not(url2)
 
       fingerprint1 = subject.fingerprint
       fingerprint2 = subject.fingerprint
-      assert_not_same fingerprint2, fingerprint1
+      assert_that(fingerprint1).is_not(fingerprint2)
 
       content1 = subject.content
       content2 = subject.content
-      assert_not_same content2, content1
+      assert_that(content1).is_not(content2)
 
       mtime1 = subject.mtime
       mtime2 = subject.mtime
-      assert_not_same mtime2, mtime1
+      assert_that(mtime1).is_not(mtime2)
     end
-
   end
 
   class DigestTests < UnitTests
     desc "being digested with an output path configured"
+
     setup do
       base_url = Factory.base_url
       Assert.stub(Dassets.config, :base_url){ base_url }
-      Dassets.config.file_store TEST_SUPPORT_PATH.join('public').to_s
+      Dassets.config.file_store TEST_SUPPORT_PATH.join("public").to_s
 
       @save_path = @asset_file.digest!
       @outfile = Dassets.config.file_store.store_path(@asset_file.url)
     end
+
     teardown do
-      FileUtils.rm(@outfile)
-      Dassets.config.file_store Dassets::FileStore::NullStore.new
+      FileUtils.rm_rf(Dassets.config.file_store.root.to_s)
+      Dassets.config.file_store Dassets::NullFileStore.new
     end
 
     should "return the asset file url" do
-      assert_equal @outfile, @save_path
+      assert_that(@save_path).equals(@outfile)
     end
 
     should "compile and write an asset file to the output path" do
-      assert_file_exists @outfile
-      assert_equal subject.content, File.read(@outfile)
+      assert_that(@outfile).is_a_file
+      assert_that(File.read(@outfile)).equals(subject.content)
     end
-
   end
-
 end

data/test/unit/cache_tests.rb

@@ -1,53 +1,32 @@
-require 'assert'
-require 'dassets/cache'
-
-module Dassets::Cache
+require "assert"
+require "dassets/cache"
 
+class Dassets::MemCache
   class UnitTests < Assert::Context
-    desc "Dassets::Cache"
-
-    should "define an in-memory cache handler" do
-      assert MemCache
-    end
-
-    should "define a no-op cache handler" do
-      assert NoCache
-    end
-
-  end
-
-  class MemCacheTests < UnitTests
-    desc "MemCache"
-    setup do
-      @cache = MemCache.new
-    end
-    subject{ @cache }
+    desc "Dassets::MemCache"
+    subject { Dassets::MemCache.new }
 
     should have_imeths :keys, :[], :[]=
 
     should "cache given key/value pairs in memory" do
       val = []
-      subject['something'] = val
-      assert_same val, subject['something']
+      subject["something"] = val
+      assert_that(subject["something"]).is(val)
     end
-
   end
+end
 
-  class NoCacheTests < UnitTests
-    desc "NoCache"
-    setup do
-      @cache = NoCache.new
-    end
-    subject{ @cache }
+class Dassets::NoCache
+  class UnitTests < Assert::Context
+    desc "Dassets::NoCache"
+    subject { Dassets::NoCache.new }
 
     should have_imeths :keys, :[], :[]=
 
     should "not cache given key/value pairs in memory" do
       val = []
-      subject['something'] = val
-      assert_not_same val, subject['something']
+      subject["something"] = val
+      assert_that(subject["something"]).is_not(val)
     end
-
   end
-
 end

data/test/unit/config_tests.rb

@@ -1,122 +1,142 @@
-require 'assert'
-require 'dassets/config'
+require "assert"
+require "dassets/config"
 
-require 'dassets/cache'
-require 'dassets/file_store'
+require "dassets/cache"
+require "dassets/file_store"
 
 class Dassets::Config
-
   class UnitTests < Assert::Context
     desc "Dassets::Config"
+    subject { @config }
+
     setup do
       @config = Dassets::Config.new
     end
-    subject{ @config }
 
     should have_readers :combinations
+    should have_imeths :reset
     should have_imeths :base_url, :set_base_url
     should have_imeths :file_store, :content_cache, :fingerprint_cache
     should have_imeths :source, :combination, :combination?
 
+    should "reset its sources and combination on `reset`" do
+      assert_that(subject.sources).is_empty
+      assert_that(subject.combinations).is_empty
+
+      path = Factory.path
+      subject.source(path)
+      subject.combination path, [Factory.path]
+      assert_that(subject.sources.size).equals(1)
+      assert_that(subject.combinations.size).equals(1)
+
+      subject.reset
+      assert_that(subject.sources).is_empty
+      assert_that(subject.combinations).is_empty
+    end
+
     should "have no base url by default" do
-      assert_nil subject.base_url
+      assert_that(subject.base_url).is_nil
     end
 
     should "set non-nil base urls" do
       url = Factory.url
       subject.base_url url
-      assert_equal url, subject.base_url
+      assert_that(subject.base_url).equals(url)
 
       subject.base_url(nil)
-      assert_equal url, subject.base_url
+      assert_that(subject.base_url).equals(url)
     end
 
     should "force set any base urls" do
       url = Factory.url
       subject.set_base_url url
-      assert_equal url, subject.base_url
+      assert_that(subject.base_url).equals(url)
 
       subject.set_base_url(nil)
-      assert_nil subject.base_url
+      assert_that(subject.base_url).is_nil
     end
 
     should "default the file store option to a null file store" do
-      assert_kind_of Dassets::FileStore::NullStore, subject.file_store
+      assert_that(subject.file_store).is_kind_of(Dassets::NullFileStore)
     end
 
     should "configure non-nil file stores" do
       store_root = Factory.path
       subject.file_store(store_root)
-      assert_equal store_root, subject.file_store.root
+      assert_that(subject.file_store.root).equals(store_root)
 
       store = Dassets::FileStore.new(Factory.path)
       subject.file_store(store)
-      assert_equal store, subject.file_store
+      assert_that(subject.file_store).equals(store)
 
-      subject.content_cache(nil)
-      assert_equal store, subject.file_store
+      subject.file_store(nil)
+      assert_that(subject.file_store).equals(store)
     end
 
     should "default its content cache" do
-      assert_instance_of Dassets::Cache::NoCache, subject.content_cache
+      assert_that(subject.content_cache).is_instance_of(Dassets::NoCache)
     end
 
     should "configure non-nil content caches" do
-      cache = Dassets::Cache::MemCache.new
+      cache = Dassets::MemCache.new
       subject.content_cache(cache)
-      assert_equal cache, subject.content_cache
+      assert_that(subject.content_cache).equals(cache)
 
       subject.content_cache(nil)
-      assert_equal cache, subject.content_cache
+      assert_that(subject.content_cache).equals(cache)
     end
 
     should "default its fingerprint cache" do
-      assert_instance_of Dassets::Cache::NoCache, subject.fingerprint_cache
+      assert_instance_of Dassets::NoCache, subject.fingerprint_cache
     end
 
     should "configure non-nil fingerprint caches" do
-      cache = Dassets::Cache::MemCache.new
+      cache = Dassets::MemCache.new
       subject.fingerprint_cache(cache)
-      assert_equal cache, subject.fingerprint_cache
+      assert_that(subject.fingerprint_cache).equals(cache)
 
       subject.fingerprint_cache(nil)
-      assert_equal cache, subject.fingerprint_cache
+      assert_that(subject.fingerprint_cache).equals(cache)
     end
 
     should "register new sources with the `source` method" do
-      path = '/path/to/app/assets'
+      path = Factory.path
       filter = proc{ |paths| [] }
       subject.source(path){ |s| s.filter(&filter) }
 
-      assert_equal 1, subject.sources.size
-      assert_kind_of Dassets::Source, subject.sources.first
-      assert_equal path, subject.sources.first.path
-      assert_equal filter, subject.sources.first.filter
+      assert_that(subject.sources.size).equals(1)
+      assert_that(subject.sources.first).is_kind_of(Dassets::Source)
+      assert_that(subject.sources.first.path).equals(path)
+      assert_that(subject.sources.first.filter).equals(filter)
     end
 
     should "know its combinations and return the keyed digest path by default" do
-      assert_kind_of ::Hash, subject.combinations
-      assert_equal ['some/digest.path'], subject.combinations['some/digest.path']
+      assert_that(subject.combinations).is_kind_of(::Hash)
+      assert_that(subject.combinations["some/digest.path"])
+        .equals(["some/digest.path"])
     end
 
     should "allow registering new combinations" do
-      assert_equal ['some/digest.path'], subject.combinations['some/digest.path']
-      exp_combination = ['some/other.path', 'and/another.path']
-      subject.combination 'some/digest.path', exp_combination
-      assert_equal exp_combination, subject.combinations['some/digest.path']
-
-      assert_equal ['test/digest.path'], subject.combinations['test/digest.path']
-      subject.combination 'test/digest.path', ['some/other.path']
-      assert_equal ['some/other.path'], subject.combinations['test/digest.path']
+      assert_that(subject.combinations["some/digest.path"])
+        .equals(["some/digest.path"])
+      exp_combination = ["some/other.path", "and/another.path"]
+      subject.combination "some/digest.path", exp_combination
+      assert_that(subject.combinations["some/digest.path"])
+        .equals(exp_combination)
+
+      assert_that(subject.combinations["test/digest.path"])
+        .equals(["test/digest.path"])
+      subject.combination "test/digest.path", ["some/other.path"]
+      assert_that(subject.combinations["test/digest.path"])
+        .equals(["some/other.path"])
     end
 
-    should "know which digest paths are actual combinations and which are just pass-thrus" do
-      subject.combination 'some/combination.path', ['some.path', 'another.path']
+    should "know which digest paths are actual combinations and which are "\
+           "just pass-thrus" do
+      subject.combination "some/combination.path", ["some.path", "another.path"]
 
-      assert     subject.combination? 'some/combination.path'
-      assert_not subject.combination? 'some/non-combo.path'
+      assert_that(subject.combination?("some/combination.path")).is_true
+      assert_that(subject.combination?("some/non-combo.path")).is_false
     end
-
   end
-
 end