dassets 0.14.2 → 0.15.1

data/test/unit/cache_tests.rb

@@ -1,53 +1,34 @@
-require 'assert'
-require 'dassets/cache'
+# frozen_string_literal: true
 
-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,17 +1,19 @@
-require 'assert'
-require 'dassets/config'
+# frozen_string_literal: true
 
-require 'dassets/cache'
-require 'dassets/file_store'
+require "assert"
+require "dassets/config"
 
-class Dassets::Config
+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
@@ -20,119 +22,124 @@ class Dassets::Config
     should have_imeths :source, :combination, :combination?
 
     should "reset its sources and combination on `reset`" do
-      assert_empty subject.sources
-      assert_empty subject.combinations
+      assert_that(subject.sources).is_empty
+      assert_that(subject.combinations).is_empty
 
       path = Factory.path
       subject.source(path)
       subject.combination path, [Factory.path]
-      assert_equal 1, subject.sources.size
-      assert_equal 1, subject.combinations.size
+      assert_that(subject.sources.size).equals(1)
+      assert_that(subject.combinations.size).equals(1)
 
       subject.reset
-      assert_empty subject.sources
-      assert_empty subject.combinations
+      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 = Factory.path
-      filter = proc{ |paths| [] }
+      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']
+    should "know its combinations and return the keyed digest path by "\
+           "default" do
+      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

data/test/unit/dassets_tests.rb

@@ -1,60 +1,67 @@
-require 'assert'
-require 'dassets'
+# frozen_string_literal: true
 
-require 'fileutils'
-require 'dassets/asset_file'
+require "assert"
+require "dassets"
 
-module Dassets
+require "fileutils"
+require "dassets/asset_file"
 
+module Dassets
   class UnitTests < Assert::Context
     desc "Dassets"
     subject{ Dassets }
 
     should have_imeths :config, :configure, :init, :reset
-    should have_imeths :[], :source_files
+    should have_imeths :asset_file, :[], :source_files, :combinations
 
     should "return a `Config` instance with the `config` method" do
-      assert_kind_of Config, subject.config
+      assert_that(subject.config).is_kind_of(Dassets::Config)
     end
 
     should "know how to reset itself" do
       config_reset_called = false
       Assert.stub(subject.config, :reset){ config_reset_called = true }
 
-      file1 = subject['nested/file3.txt']
+      file1 = subject["nested/file3.txt"]
 
       subject.reset
 
-      file2 = subject['nested/file3.txt']
-      assert_not_same file2, file1
-      assert_true config_reset_called
+      file2 = subject["nested/file3.txt"]
+      assert_that(file2).is_not(file1)
+      assert_that(config_reset_called).is_true
     end
 
-    should "return asset files given a their digest path using the index operator" do
-      file = subject['nested/file3.txt']
+    should "return asset files given their digest path " do
+      file = subject.asset_file("nested/file3.txt")
 
-      assert_kind_of subject::AssetFile, file
-      assert_equal 'nested/file3.txt', file.digest_path
-      assert_equal 'd41d8cd98f00b204e9800998ecf8427e', file.fingerprint
+      assert_that(file).is_kind_of(subject::AssetFile)
+      assert_that(file.digest_path).equals("nested/file3.txt")
+      assert_that(file.fingerprint).equals("d41d8cd98f00b204e9800998ecf8427e")
     end
 
     should "cache asset files" do
-      file1 = subject['nested/file3.txt']
-      file2 = subject['nested/file3.txt']
+      file1 = subject.asset_file("nested/file3.txt")
+      file2 = subject.asset_file("nested/file3.txt")
 
-      assert_same file2, file1
+      assert_that(file2).is(file1)
     end
 
-    should "return an asset file that doesn't exist if digest path not found" do
-      file = subject['path/not/found.txt']
-      assert_not file.exists?
+    should "complain if digest path is not found using the index operator" do
+      assert_that(->{
+        subject.asset_file("path/not/found.txt")
+      }).does_not_raise
+
+      assert_that{ subject["path/not/found.txt"] }.raises(AssetFileError)
     end
 
     should "know its list of configured source files" do
       exp = Dassets::SourceFiles.new(subject.config.sources)
-      assert_equal exp, subject.source_files
+      assert_that(subject.source_files).equals(exp)
     end
 
+    should "know its configured combinations" do
+      exp = subject.config.combinations
+      assert_that(subject.combinations).equals(exp)
+    end
   end
-
 end

data/test/unit/engine_tests.rb

@@ -1,59 +1,25 @@
-require 'assert'
-require 'dassets/engine'
+# frozen_string_literal: true
 
-class Dassets::Engine
+require "assert"
+require "dassets/engine"
 
+class Dassets::Engine
   class UnitTests < Assert::Context
     desc "Dassets::Engine"
-    setup do
-      @engine = Dassets::Engine.new
-    end
-    subject{ @engine }
+    subject{ Dassets::Engine.new }
 
     should have_reader :opts
     should have_imeths :ext, :compile
 
     should "default the opts if none given" do
       exp_opts = {}
-      assert_equal exp_opts, subject.opts
+      assert_that(subject.opts).equals(exp_opts)
     end
 
     should "raise NotImplementedError on `ext` and `compile`" do
-      assert_raises NotImplementedError do
-        subject.ext('foo')
-      end
-
-      assert_raises NotImplementedError do
-        subject.compile('some content')
-      end
-    end
-
-  end
-
-  class NullEngineTests < Assert::Context
-    desc "Dassets::NullEngine"
-    setup do
-      @engine = Dassets::NullEngine.new('some' => 'opts')
-    end
-    subject{ @engine }
-
-    should "be a Engine" do
-      assert_kind_of Dassets::Engine, subject
-    end
-
-    should "know its opts" do
-      exp_opts = {'some' => 'opts'}
-      assert_equal exp_opts, subject.opts
-    end
-
-    should "return the given extension on `ext`" do
-      assert_equal 'foo', subject.ext('foo')
+      assert_that{ subject.ext("foo") }.raises(NotImplementedError)
+      assert_that{ subject.compile("some content") }
+        .raises(NotImplementedError)
     end
-
-    should "return the given input on `compile" do
-      assert_equal 'some content', subject.compile('some content')
-    end
-
   end
-
 end

data/test/unit/file_store_tests.rb

@@ -1,62 +1,75 @@
-require 'assert'
-require 'dassets/file_store'
+# frozen_string_literal: true
 
-class Dassets::FileStore
+require "assert"
+require "dassets/file_store"
 
+class Dassets::FileStore
   class UnitTests < Assert::Context
     desc "Dassets::FileStore"
-    setup do
-      @root = TEST_SUPPORT_PATH.join('public')
-      @url = 'some/url'
-      @url_path = @root.join(@url).to_s
-      FileUtils.rm_f(@url_path)
+    subject{ Dassets::FileStore.new(@root.to_s) }
 
-      @store = Dassets::FileStore.new(@root.to_s)
+    setup do
+      @root      = TEST_SUPPORT_PATH.join("public")
+      @url_path  = Factory.url
+      @root_path = File.join(@root, @url_path).to_s
+      FileUtils.rm_f(@root_path)
     end
+
     teardown do
-      FileUtils.rm_f(@url_path)
+      FileUtils.rm_rf(@root.to_s)
     end
-    subject{ @store }
 
     should have_readers :root
     should have_imeths :save, :store_path
 
-    should "know its root path" do
-      assert_equal @root.to_s, subject.root
+    should "know its root" do
+      assert_that(subject.root).equals(@root.to_s)
     end
 
-    should "build the store path based on a given url" do
-      assert_equal @url_path, subject.store_path(@url)
+    should "build the store path based on a given url path" do
+      assert_that(subject.store_path(@url_path)).equals(@root_path)
     end
 
-    should "return write a file and return the store path on save" do
-      assert_not_file_exists @url_path
-      path = subject.save(@url){ 'some contents' }
+    should "write a file and return the store path on save" do
+      content = Factory.text
+      assert_that(@root_path).is_not_a_file
 
-      assert_equal @url_path, path
-      assert_file_exists @url_path
-    end
+      path = subject.save(@url_path){ content }
 
+      assert_that(path).equals(@root_path)
+      assert_that(@root_path).is_a_file
+      assert_that(File.read(@root_path)).equals(content)
+    end
   end
+end
+
+class Dassets::NullFileStore
+  class UnitTests < Assert::Context
+    desc "Dassets::NullFileStore"
+    subject{ Dassets::NullFileStore.new }
 
-  class NullStoreTests < UnitTests
-    desc "NullStore"
     setup do
-      @store = Dassets::FileStore::NullStore.new
+      @root      = TEST_SUPPORT_PATH.join("public")
+      @url_path  = Factory.url
+      @root_path = File.join(@root, @url_path).to_s
+      FileUtils.rm_f(@root_path)
     end
 
-    should "be a kind of FileStore" do
-      assert_kind_of Dassets::FileStore, subject
+    teardown do
+      FileUtils.rm_rf(@root.to_s)
     end
 
-    should "know its root path" do
-      assert_equal '', subject.root
+    should "be a kind of Dassets::FileStore" do
+      assert_that(subject).is_kind_of(Dassets::FileStore)
     end
 
-    should "return the store path on save" do
-      assert_equal "/#{@url}", subject.save(@url)
+    should "know its root" do
+      assert_that(subject.root).equals("")
     end
 
+    should "return the store path on save but not save a file" do
+      assert_that(subject.save(@url_path)).equals(File.join("", @url_path))
+      assert_that(@root_path).is_not_a_file
+    end
   end
-
 end