dassets 0.14.3 → 0.15.2

data/test/unit/server_tests.rb

@@ -1,17 +1,13 @@
-require 'assert'
-require 'dassets/server'
+# frozen_string_literal: true
 
-class Dassets::Server
+require "assert"
+require "dassets/server"
 
+class Dassets::Server
   class UnitTests < Assert::Context
     desc "Dassets::Server"
-    setup do
-      @server = Dassets::Server.new('a rack app goes here')
-    end
-    subject{ @server }
+    subject{ Dassets::Server.new("test rack app") }
 
     should have_imeths :call, :call!
-
   end
-
 end

data/test/unit/source_file_tests.rb

@@ -1,94 +1,124 @@
-require 'assert'
-require 'dassets/source_file'
+# frozen_string_literal: true
 
-require 'dassets/asset_file'
-require 'dassets/cache'
-require 'dassets/source_proxy'
+require "assert"
+require "dassets/source_file"
 
-class Dassets::SourceFile
+require "dassets/asset_file"
+require "dassets/cache"
+require "dassets/source_proxy"
 
+class Dassets::SourceFile
   class UnitTests < Assert::Context
     desc "Dassets::SourceFile"
+    subject{ Dassets::SourceFile.new(@file_path) }
+
     setup do
-      @file_path = TEST_SUPPORT_PATH.join('app/assets/file1.txt').to_s
-      @source_file = Dassets::SourceFile.new(@file_path)
+      @file_path = TEST_SUPPORT_PATH.join("app/assets/file1.txt").to_s
     end
-    subject{ @source_file }
 
     should have_readers :file_path
     should have_imeths :source, :asset_file, :digest_path
-    should have_imeths :compiled, :exists?, :mtime, :response_headers
+    should have_imeths :compiled, :exists?, :mtime
+    should have_imeths :base_path, :response_headers
     should have_cmeth :find_by_digest_path
 
     should "know its file path" do
-      assert_equal @file_path.to_s, subject.file_path
+      assert_that(subject.file_path).equals(@file_path.to_s)
     end
 
     should "know its configured source" do
-      exp_source = Dassets.config.sources.select{ |s| @file_path.include?(s.path) }.last
-      assert_equal exp_source, subject.source
+      exp_source =
+        Dassets.config.sources.select{ |s| @file_path.include?(s.path) }.last
+      assert_that(subject.source).equals(exp_source)
     end
 
     should "know its asset file" do
-      assert_kind_of Dassets::AssetFile, subject.asset_file
-      assert_equal Dassets::AssetFile.new(subject.digest_path), subject.asset_file
+      assert_that(subject.asset_file).is_kind_of(Dassets::AssetFile)
+      assert_that(subject.asset_file)
+        .equals(Dassets::AssetFile.new(subject.digest_path))
     end
 
     should "know its digest path" do
-      assert_equal 'file1.txt', subject.digest_path
+      assert_that(subject.digest_path).equals("file1.txt")
     end
 
     should "not memoize its compiled source" do
       compiled1 = subject.compiled
       compiled2 = subject.compiled
-      assert_not_same compiled2, compiled1
+      assert_that(compiled2).is_not(compiled1)
     end
 
     should "know if it exists" do
-      assert subject.exists?
+      assert_that(subject.exists?).is_true
     end
 
     should "use the mtime of its file as its mtime" do
-      assert_equal File.mtime(subject.file_path), subject.mtime
+      assert_that(subject.mtime).equals(File.mtime(subject.file_path))
     end
 
     should "use the response headers of its source as its response headers" do
-      assert_same subject.source.response_headers, subject.response_headers
+      assert_that(subject.response_headers).is(subject.source.response_headers)
+    end
+
+    should "use the base path of its source as its base path" do
+      assert_that(subject.base_path).equals(subject.source.base_path.to_s)
     end
 
     should "be findable by its digest path" do
       found = Dassets::SourceFile.find_by_digest_path(subject.digest_path)
 
-      assert_equal subject, found
-      assert_not_same subject, found
+      assert_that(found).equals(subject)
+      assert_that(found).is_not(subject)
     end
+  end
 
+  class EngineTests < UnitTests
+    desc "compiled against engines"
+
+    setup do
+      @file_path =
+        TEST_SUPPORT_PATH.join("app/assets/nested/a-thing.txt.useless.dumb")
+    end
+
+    should "build the digest path appropriately" do
+      assert_that(subject.digest_path).equals("nested/a-thing.txt.no-use")
+    end
+
+    should "compile the source content appropriately" do
+      file_content = File.read(@file_path)
+      exp_compiled_content = [file_content, "DUMB", "USELESS"].join("\n")
+      assert_that(subject.compiled).equals(exp_compiled_content)
+    end
   end
+end
 
-  class NullSourceTests < UnitTests
+class Dassets::NullSourceFile
+  class UnitTests < Assert::Context
     setup do
-      Dassets.config.combination 'file3.txt', ['file1.txt', 'file2.txt']
+      Dassets.config.combination "file3.txt", ["file1.txt", "file2.txt"]
     end
+
     teardown do
-      Dassets.config.combinations.delete('file3.txt')
+      Dassets.config.combinations.delete("file3.txt")
     end
 
     should "find a null src file if finding by an unknown digest path" do
-      null_src = Dassets::NullSourceFile.new('not/found/digest/path')
-      found = Dassets::SourceFile.find_by_digest_path('not/found/digest/path')
+      null_src = Dassets::NullSourceFile.new("not/found/digest/path")
+      found = Dassets::SourceFile.find_by_digest_path("not/found/digest/path")
 
-      assert_equal    null_src, found
-      assert_not_same null_src, found
+      assert_that(found).equals(null_src)
+      assert_that(found).is_not(null_src)
 
-      assert_equal '',    null_src.file_path
-      assert_equal false, null_src.exists?
-      assert_nil null_src.compiled
-      assert_nil null_src.mtime
-      assert_equal Hash.new, null_src.response_headers
+      assert_that(null_src.file_path).equals("")
+      assert_that(null_src.exists?).equals(false)
+      assert_that(null_src.compiled).is_nil
+      assert_that(null_src.mtime).is_nil
+      assert_that(null_src.response_headers).equals({})
     end
 
-    should "pass options to a null src when finding by an unknown digest path" do
-      null_src = Dassets::NullSourceFile.new('not/found/digest/path')
+    should "pass options to a null src when finding by an unknown digest "\
+           "path" do
+      null_src = Dassets::NullSourceFile.new("not/found/digest/path")
       null_src_new_called_with = []
       Assert.stub(Dassets::NullSourceFile, :new) do |*args|
         null_src_new_called_with = args
@@ -96,26 +126,29 @@ class Dassets::SourceFile
       end
 
       options = {
-        :content_cache     => Dassets::Cache::NoCache.new,
-        :fingerprint_cache => Dassets::Cache::NoCache.new
+        content_cache: Dassets::NoCache.new,
+        fingerprint_cache: Dassets::NoCache.new,
       }
-      Dassets::SourceFile.find_by_digest_path('not/found/digest/path', options)
+      Dassets::SourceFile.find_by_digest_path(
+        "not/found/digest/path",
+        **options,
+      )
 
-      exp = ['not/found/digest/path', options]
-      assert_equal exp, null_src_new_called_with
+      exp = ["not/found/digest/path", options]
+      assert_that(null_src_new_called_with).equals(exp)
     end
 
-    should "'proxy' the digest path if the path is a combination" do
-      src_proxy      = Dassets::SourceProxy.new('file3.txt')
-      null_combo_src = Dassets::NullSourceFile.new('file3.txt')
+    should "proxy the digest path if the path is a combination" do
+      src_proxy      = Dassets::SourceProxy.new("file3.txt")
+      null_combo_src = Dassets::NullSourceFile.new("file3.txt")
 
-      assert_equal src_proxy.exists?, null_combo_src.exists?
-      assert_equal src_proxy.content, null_combo_src.compiled
-      assert_equal src_proxy.mtime,   null_combo_src.mtime
+      assert_that(null_combo_src.exists?).equals(src_proxy.exists?)
+      assert_that(null_combo_src.compiled).equals(src_proxy.content)
+      assert_that(null_combo_src.mtime).equals(src_proxy.mtime)
     end
 
     should "pass options to its source proxy when the path is a combination" do
-      src_proxy = Dassets::SourceProxy.new('file3.txt')
+      src_proxy = Dassets::SourceProxy.new("file3.txt")
       src_proxy_new_called_with = []
       Assert.stub(Dassets::SourceProxy, :new) do |*args|
         src_proxy_new_called_with = args
@@ -123,34 +156,13 @@ class Dassets::SourceFile
       end
 
       options = {
-        :content_cache     => Dassets::Cache::NoCache.new,
-        :fingerprint_cache => Dassets::Cache::NoCache.new
+        content_cache: Dassets::NoCache.new,
+        fingerprint_cache: Dassets::NoCache.new,
       }
-      Dassets::NullSourceFile.new('file3.txt', options)
-
-      exp = ['file3.txt', options]
-      assert_equal exp, src_proxy_new_called_with
-    end
-
-  end
-
-  class EngineTests < UnitTests
-    desc "compiled against engines"
-    setup do
-      @file_path = TEST_SUPPORT_PATH.join('app/assets/nested/a-thing.txt.useless.dumb')
-      @source_file = Dassets::SourceFile.new(@file_path)
-    end
+      Dassets::NullSourceFile.new("file3.txt", **options)
 
-    should "build the digest path appropriately" do
-      assert_equal 'nested/a-thing.txt.no-use', subject.digest_path
+      exp = ["file3.txt", options]
+      assert_that(src_proxy_new_called_with).equals(exp)
     end
-
-    should "compile the source content appropriately" do
-      file_content = File.read(@file_path)
-      exp_compiled_content = [ file_content, 'DUMB', 'USELESS' ].join("\n")
-      assert_equal exp_compiled_content, subject.compiled
-    end
-
   end
-
 end

data/test/unit/source_proxy_tests.rb

@@ -1,213 +1,207 @@
-require 'assert'
-require 'dassets/source_proxy'
+# frozen_string_literal: true
 
-require 'digest/md5'
-require 'dassets/cache'
-require 'dassets/source_file'
-require 'dassets/source_proxy'
+require "assert"
+require "dassets/source_proxy"
 
-class Dassets::SourceProxy
+require "digest/md5"
+require "dassets/cache"
+require "dassets/source_file"
+require "dassets/source_proxy"
 
+class Dassets::SourceProxy
   class UnitTests < Assert::Context
     desc "Dassets::SourceProxy"
-    setup do
-      @source_proxy = Dassets::SourceProxy.new(Factory.string)
-    end
-    subject{ @source_proxy }
+    subject{ Dassets::SourceProxy.new(Factory.string) }
 
     should have_readers :digest_path, :content_cache, :fingerprint_cache
     should have_readers :source_files
     should have_imeths :key, :content, :fingerprint, :mtime, :response_headers
     should have_imeths :exists?
-
   end
 
   class NotComboTests < UnitTests
     desc "when the digest path is not a combination"
-    setup do
-      @source_proxy = Dassets::SourceProxy.new('file1.txt')
-    end
+    subject{ Dassets::SourceProxy.new("file1.txt") }
 
     should "know its digest path" do
-      assert_equal 'file1.txt', subject.digest_path
+      assert_that(subject.digest_path).equals("file1.txt")
     end
 
     should "use no cache by default" do
-      assert_kind_of Dassets::Cache::NoCache, subject.content_cache
-      assert_kind_of Dassets::Cache::NoCache, subject.fingerprint_cache
+      assert_that(subject.content_cache).is_kind_of(Dassets::NoCache)
+      assert_that(subject.fingerprint_cache).is_kind_of(Dassets::NoCache)
     end
 
     should "have a single source file" do
-      assert_equal 1, subject.source_files.size
-      exp = Dassets::SourceFile.find_by_digest_path('file1.txt')
-      assert_equal exp, subject.source_files.first
+      assert_that(subject.source_files.size).equals(1)
+      exp = Dassets::SourceFile.find_by_digest_path("file1.txt")
+      assert_that(subject.source_files.first).equals(exp)
     end
 
     should "use its digest path and mtime as its key" do
       exp = "#{subject.digest_path} -- #{subject.mtime}"
-      assert_equal exp, subject.key
+      assert_that(subject.key).equals(exp)
     end
 
-    should "get its content from the compiled source of the single source file" do
-      assert_equal subject.source_files.first.compiled, subject.content
+    should "get its content from the compiled source of the single "\
+           "source file" do
+      assert_that(subject.content).equals(subject.source_files.first.compiled)
     end
 
     should "get its fingerprint by MD5 hashing the content" do
       exp = Digest::MD5.new.hexdigest(subject.content)
-      assert_equal exp, subject.fingerprint
+      assert_that(subject.fingerprint).equals(exp)
     end
 
     should "use its single source file's max mtime as its mtime" do
-      assert_equal subject.source_files.first.mtime, subject.mtime
+      assert_that(subject.mtime).equals(subject.source_files.first.mtime)
     end
 
-    should "use its single source file's response headers as its resonse headers" do
-      assert_equal subject.source_files.first.response_headers, subject.response_headers
+    should "use its single source file's response headers as its resonse "\
+           "headers" do
+      assert_that(subject.response_headers)
+        .equals(subject.source_files.first.response_headers)
     end
 
     should "exist if its single source file exists" do
-      assert_equal subject.source_files.first.exists?, subject.exists?
+      assert_that(subject.exists?).equals(subject.source_files.first.exists?)
     end
-
   end
 
   class ComboSetupTests < UnitTests
     setup do
-      Dassets.config.combination 'file3.txt', ['file1.txt', 'file2.txt']
-      Dassets.config.combination 'file4.txt', []
-      Dassets.config.combination 'file5.txt', ['file3.txt', 'file4.txt']
+      Dassets.config.combination "file3.txt", ["file1.txt", "file2.txt"]
+      Dassets.config.combination "file4.txt", []
+      Dassets.config.combination "file5.txt", ["file3.txt", "file4.txt"]
     end
+
     teardown do
-      Dassets.config.combinations.delete('file5.txt')
-      Dassets.config.combinations.delete('file4.txt')
-      Dassets.config.combinations.delete('file3.txt')
+      Dassets.config.combinations.delete("file5.txt")
+      Dassets.config.combinations.delete("file4.txt")
+      Dassets.config.combinations.delete("file3.txt")
     end
-
   end
 
   class ComboTests < ComboSetupTests
     desc "when the digest path is a combination to multiple source files"
+    subject{ Dassets::SourceProxy.new("file3.txt") }
+
     setup do
       @exp_source_files = [
-        Dassets::SourceFile.find_by_digest_path('file1.txt'),
-        Dassets::SourceFile.find_by_digest_path('file2.txt')
+        Dassets::SourceFile.find_by_digest_path("file1.txt"),
+        Dassets::SourceFile.find_by_digest_path("file2.txt"),
       ]
-      @source_proxy = Dassets::SourceProxy.new('file3.txt')
     end
 
     should "know its digest path" do
-      assert_equal 'file3.txt', subject.digest_path
+      assert_that(subject.digest_path).equals("file3.txt")
     end
 
     should "know its source files" do
-      assert_equal 2, subject.source_files.size
-      assert_equal @exp_source_files, subject.source_files
+      assert_that(subject.source_files.size).equals(2)
+      assert_that(subject.source_files).equals(@exp_source_files)
     end
 
     should "get its content from the compiled source of its source files" do
-      exp = subject.source_files.map{ |f| f.compiled }.join("\n")
-      assert_equal exp, subject.content
+      exp = subject.source_files.map(&:compiled).join("\n")
+      assert_that(subject.content).equals(exp)
     end
 
     should "use its source files' max mtime as its mtime" do
-      exp = subject.source_files.map{ |f| f.mtime }.max
-      assert_equal exp, subject.mtime
+      exp = subject.source_files.map(&:mtime).max
+      assert_that(subject.mtime).equals(exp)
     end
 
-    should "use its source files' merged response headers as its response headers" do
-      exp = subject.source_files.inject(Hash.new) do |hash, file|
-        hash.merge!(file.response_headers)
-      end
-      assert_equal exp, subject.response_headers
+    should "use its source files' merged response headers as its response "\
+           "headers" do
+      exp =
+        subject.source_files.reduce({}) do |hash, file|
+          hash.merge!(file.response_headers)
+        end
+      assert_that(subject.response_headers).equals(exp)
     end
 
     should "exist if its all its source files exist" do
-      exp = subject.source_files.inject(true){ |res, f| res && f.exists? }
-      assert_equal exp, subject.exists?
+      exp = subject.source_files.reduce(true){ |res, f| res && f.exists? }
+      assert_that(subject.exists?).equals(exp)
     end
-
   end
 
   class EmptyComboTests < ComboSetupTests
     desc "when the digest path is an empty combination"
-    setup do
-      @source_proxy = Dassets::SourceProxy.new('file4.txt')
-    end
+    subject{ Dassets::SourceProxy.new("file4.txt") }
 
     should "not have any source files" do
-      assert_equal 0, subject.source_files.size
+      assert_that(subject.source_files.size).equals(0)
     end
 
     should "have empty content" do
-      assert_equal '', subject.content
+      assert_that(subject.content).equals("")
     end
 
     should "have no mtime" do
-      assert_nil subject.mtime
+      assert_that(subject.mtime).is_nil
     end
 
     should "exist" do
-      assert_true subject.exists?
+      assert_that(subject.exists?).is_true
     end
-
   end
 
   class ComboWithEmptyComboTests < ComboSetupTests
-    desc "when the digest path is a combination that includes an empty combination"
-    setup do
-      @source_proxy = Dassets::SourceProxy.new('file5.txt')
-    end
+    desc "when the digest path is a combination that includes an empty "\
+         "combination"
+    subject{ Dassets::SourceProxy.new("file5.txt") }
 
     should "ignore the mtime of the empty combination" do
-      exp_mtime = subject.source_files.map{ |f| f.mtime }.compact.max
-      assert_equal exp_mtime, subject.mtime
+      exp_mtime = subject.source_files.map(&:mtime).compact.max
+      assert_that(subject.mtime).equals(exp_mtime)
     end
-
   end
 
   class NoCacheTests < UnitTests
     desc "with a `NoCache` cache handler"
-    setup do
-      @cache = Dassets::Cache::NoCache.new
-      @source_proxy = Dassets::SourceProxy.new('file1.txt', {
-        :content_cache     => @cache,
-        :fingerprint_cache => @cache
-      })
+    subject do
+      cache = Dassets::NoCache.new
+      Dassets::SourceProxy.new(
+        "file1.txt",
+        content_cache:     cache,
+        fingerprint_cache: cache,
+      )
     end
 
     should "not cache its source content/fingerprint" do
       content1 = subject.content
       content2 = subject.content
-      assert_not_same content2, content1
+      assert_that(content2).is_not(content1)
 
       finger1 = subject.fingerprint
       finger2 = subject.fingerprint
-      assert_not_same finger2, finger1
+      assert_that(finger2).is_not(finger1)
     end
-
   end
 
   class MemCacheTests < UnitTests
     desc "with a `MemCache` cache handler"
-    setup do
-      @content_cache     = Dassets::Cache::MemCache.new
-      @fingerprint_cache = Dassets::Cache::MemCache.new
-      @source_proxy = Dassets::SourceProxy.new('file1.txt', {
-        :content_cache     => @content_cache,
-        :fingerprint_cache => @fingerprint_cache
-      })
+    subject do
+      content_cache     = Dassets::MemCache.new
+      fingerprint_cache = Dassets::MemCache.new
+
+      Dassets::SourceProxy.new(
+        "file1.txt",
+        content_cache:     content_cache,
+        fingerprint_cache: fingerprint_cache,
+      )
     end
 
     should "cache its source content/fingerprint in memory" do
       content1 = subject.content
       content2 = subject.content
-      assert_same content2, content1
+      assert_that(content2).is(content1)
 
       finger1 = subject.fingerprint
       finger2 = subject.fingerprint
-      assert_same finger2, finger1
+      assert_that(finger2).is(finger1)
     end
-
   end
-
 end