dassets 0.14.2 → 0.15.1

data/test/support/app.rb

@@ -1,10 +1,10 @@
-require 'sinatra/base'
+# frozen_string_literal: true
 
-class SinatraApp < Sinatra::Base
+require "sinatra/base"
 
+class SinatraApp < Sinatra::Base
   configure do
-    set :root, File.expand_path('..', __FILE__)
-    set :public_dir, File.expand_path('./app_public', __FILE__)
+    set :root,       File.expand_path("..", __FILE__)
+    set :public_dir, File.expand_path("./app_public", __FILE__)
   end
-
 end

data/test/support/factory.rb

@@ -1,4 +1,6 @@
-require 'assert/factory'
+# frozen_string_literal: true
+
+require "assert/factory"
 
 module Factory
   extend Assert::Factory
@@ -6,5 +8,4 @@ module Factory
   def self.base_url
     Factory.boolean ? Factory.url : nil
   end
-
 end

data/test/support/source_files/linked

@@ -0,0 +1 @@
+../linked_source_files/

data/test/support/source_files/linked_file2.txt

@@ -0,0 +1 @@
+../linked_source_files/linked_file.txt

data/test/system/rack_tests.rb

@@ -1,13 +1,14 @@
-require 'assert'
-require 'dassets'
+# frozen_string_literal: true
 
-require 'assert-rack-test'
-require 'fileutils'
-require 'dassets/server'
-require 'test/support/app'
+require "assert"
+require "dassets"
 
-module Dassets
+require "assert-rack-test"
+require "fileutils"
+require "dassets/server"
+require "test/support/app"
 
+module Dassets
   class RackTests < Assert::Context
     include Assert::Rack::Test
 
@@ -19,121 +20,124 @@ module Dassets
     def app
       @app ||= SinatraApp
     end
-
   end
 
   class SuccessTests < RackTests
     desc "requesting an existing asset file"
 
     should "return a successful response" do
-      resp = get '/file1-daa05c683a4913b268653f7a7e36a5b4.txt'
-      assert_equal 200, resp.status
-      assert_equal Dassets['file1.txt'].content, resp.body
+      resp = get "/file1-daa05c683a4913b268653f7a7e36a5b4.txt"
+
+      assert_that(resp.status).equals(200)
+      assert_that(resp.body).equals(Dassets["file1.txt"].content)
     end
 
     should "return a successful response with no body on HEAD requests" do
-      resp = head '/file2-9bbe1047cffbb590f59e0e5aeff46ae4.txt'
-      assert_equal 200, resp.status
-      assert_equal Dassets['file2.txt'].size.to_s, resp.headers['Content-Length']
-      assert_empty resp.body
+      resp = head "/file2-9bbe1047cffbb590f59e0e5aeff46ae4.txt"
+
+      assert_that(resp.status).equals(200)
+      assert_that(resp.headers["Content-Length"])
+        .equals(Dassets["file2.txt"].size.to_s)
+      assert_that(resp.body).is_empty
     end
 
-    should "return a partial content response on valid partial content requests" do
-      content = Dassets['file1.txt'].content
+    should "return a partial content response on valid partial content "\
+           "requests" do
+      content = Dassets["file1.txt"].content
       size    = Factory.integer(content.length)
-
       # see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35
-      env = { 'HTTP_RANGE' => "bytes=0-#{size}" }
+      env = { "HTTP_RANGE" => "bytes=0-#{size}" }
+      resp = get "/file1-daa05c683a4913b268653f7a7e36a5b4.txt", {}, env
 
-      resp = get '/file1-daa05c683a4913b268653f7a7e36a5b4.txt', {}, env
-      assert_equal 206, resp.status
-      assert_equal content[0..size], resp.body
+      assert_that(resp.status).equals(206)
+      assert_that(resp.body).equals(content[0..size])
     end
 
     should "return a full response on no-range partial content requests" do
       # see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35
-      env = { 'HTTP_RANGE' => 'bytes=' }
+      env = { "HTTP_RANGE" => "bytes=" }
+      resp = get "/file1-daa05c683a4913b268653f7a7e36a5b4.txt", {}, env
 
-      resp = get '/file1-daa05c683a4913b268653f7a7e36a5b4.txt', {}, env
-      assert_equal 200, resp.status
-      assert_equal Dassets['file1.txt'].content, resp.body
+      assert_that(resp.status).equals(200)
+      assert_that(resp.body).equals(Dassets["file1.txt"].content)
     end
 
-    should "return a full response on multiple-range partial content requests" do
+    should "return a full response on multiple-range partial content "\
+           "requests" do
       # see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35
-      env = { 'HTTP_RANGE' => 'bytes=0-1,2-3' }
+      env = { "HTTP_RANGE" => "bytes=0-1,2-3" }
+      resp = get "/file1-daa05c683a4913b268653f7a7e36a5b4.txt", {}, env
 
-      resp = get '/file1-daa05c683a4913b268653f7a7e36a5b4.txt', {}, env
-      assert_equal 200, resp.status
-      assert_equal Dassets['file1.txt'].content, resp.body
+      assert_that(resp.status).equals(200)
+      assert_that(resp.body).equals(Dassets["file1.txt"].content)
     end
 
     should "return a full response on invalid-range partial content requests" do
       # see http://www.w3.org/Protocols/rfc2616/rfc2616-sec14.html#sec14.35
-      env = { 'HTTP_RANGE' => ['bytes=3-2', 'bytes=abc'].sample }
+      env = { "HTTP_RANGE" => ["bytes=3-2", "bytes=abc"].sample }
+      resp = get "/file1-daa05c683a4913b268653f7a7e36a5b4.txt", {}, env
 
-      resp = get '/file1-daa05c683a4913b268653f7a7e36a5b4.txt', {}, env
-      assert_equal 200, resp.status
-      assert_equal Dassets['file1.txt'].content, resp.body
+      assert_that(resp.status).equals(200)
+      assert_that(resp.body).equals(Dassets["file1.txt"].content)
     end
-
   end
 
   class DigestTests < SuccessTests
     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
-      @url = Dassets['file1.txt'].url
+      Dassets.config.file_store TEST_SUPPORT_PATH.join("public").to_s
+      @url = Dassets["file1.txt"].url
       @url_file = Dassets.config.file_store.store_path(@url)
     end
+
     teardown do
       FileUtils.rm(@url_file)
-      Dassets.config.file_store FileStore::NullStore.new
+      Dassets.config.file_store Dassets::NullFileStore.new
     end
 
     should "digest the asset" do
-      assert_not_file_exists @url_file
+      assert_that(@url_file).is_not_a_file
 
       resp = get @url
-      assert_equal 200, resp.status
-      assert_file_exists @url_file
+      assert_that(resp.status).equals(200)
+      assert_that(@url_file).is_a_file
     end
-
   end
 
   class NotModifiedTests < RackTests
     desc "requesting an existing asset file that has not been modified"
-    setup do
-      @resp = get('/file1-daa05c683a4913b268653f7a7e36a5b4.txt', {}, {
-        'HTTP_IF_MODIFIED_SINCE' => Dassets['file1.txt'].mtime.to_s
-      })
-    end
 
     should "return a successful response" do
-      assert_equal 304, @resp.status
-      assert_empty @resp.body
+      resp =
+        get(
+          "/file1-daa05c683a4913b268653f7a7e36a5b4.txt",
+          {},
+          {
+            "HTTP_IF_MODIFIED_SINCE" => Dassets["file1.txt"].mtime.to_s,
+          },
+        )
+
+      assert_that(resp.status).equals(304)
+      assert_that(resp.body).is_empty
     end
-
   end
 
   class NotFoundTests < RackTests
     desc "requesting an non-existing asset file"
 
     should "return a not found response" do
-      resp = get '/file1-daa05c683a4913b268.txt'
-      assert_equal 404, resp.status
+      resp = get "/file1-daa05c683a4913b268.txt"
+      assert_that(resp.status).equals(404)
 
-      get '/file1-.txt'
-      assert_equal 404, resp.status
+      resp = get "/file1-.txt"
+      assert_that(resp.status).equals(404)
 
-      get '/file1.txt'
-      assert_equal 404, resp.status
+      resp = get "/file1.txt"
+      assert_that(resp.status).equals(404)
 
-      get '/something-not-found'
-      assert_equal 404, resp.status
+      resp = get "/something-not-found"
+      assert_that(resp.status).equals(404)
     end
-
   end
-
 end

data/test/unit/asset_file_tests.rb

@@ -1,140 +1,148 @@
-require 'assert'
-require 'dassets/asset_file'
+# frozen_string_literal: true
 
-require 'fileutils'
-require 'dassets/file_store'
-require 'dassets/source_proxy'
+require "assert"
+require "dassets/asset_file"
 
-class Dassets::AssetFile
+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_readers :digest_path, :dirname, :extname, :basename
+    should have_readers :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(%r{^/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(%r{^#{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