kithe 2.0.0.pre.alpha2 → 2.0.0.pre.beta1

data/spec/shrine/kithe_storage_location_spec.rb

@@ -4,29 +4,57 @@ require 'shrine/plugins/kithe_storage_location'
 describe Shrine::Plugins::KitheStorageLocation do
   let(:uploader) { test_uploader { plugin :kithe_storage_location } }
 
-  it "uploads with a record with id" do
-    uploaded_file = uploader.upload(fakeio, record: OpenStruct.new(id: "81060886-4f93-42e7-ace7-ab51399f4808"), name: :file)
+  describe "for main file" do
+    it "uploads with a record with id" do
+      uploaded_file = uploader.upload(fakeio, record: OpenStruct.new(id: "81060886-4f93-42e7-ace7-ab51399f4808"), name: :file)
 
-    expect(uploaded_file.id).to match %r{\Aasset/81060886-4f93-42e7-ace7-ab51399f4808/[0-9a-f]+}
-  end
+      expect(uploaded_file.id).to match %r{\Aasset/81060886-4f93-42e7-ace7-ab51399f4808/[0-9a-f]+}
+    end
 
-  it "has suffix with a record id and filename" do
-    uploaded_file = uploader.upload(fakeio(filename: "foo.jpg"), record: OpenStruct.new(id: "81060886-4f93-42e7-ace7-ab51399f4808"), name: :file)
+    it "has suffix with a record id and filename" do
+      uploaded_file = uploader.upload(fakeio(filename: "foo.jpg"), record: OpenStruct.new(id: "81060886-4f93-42e7-ace7-ab51399f4808"), name: :file)
 
-    expect(uploaded_file.id).to match %r{\Aasset/81060886-4f93-42e7-ace7-ab51399f4808/[0-9a-f]+\.jpg}
-  end
+      expect(uploaded_file.id).to match %r{\Aasset/81060886-4f93-42e7-ace7-ab51399f4808/[0-9a-f]+\.jpg}
+    end
 
-  it "uploads with no record" do
-    uploaded_file = uploader.upload(fakeio, record: OpenStruct.new(id: "81060886-4f93-42e7-ace7-ab51399f4808"), name: :file)
+    it "uploads with no record" do
+      uploaded_file = uploader.upload(fakeio, record: OpenStruct.new(id: "81060886-4f93-42e7-ace7-ab51399f4808"), name: :file)
 
-    expect(uploaded_file.id).to match %r{\Aasset/[0-9a-f]+}
-  end
+      expect(uploaded_file.id).to match %r{\Aasset/[0-9a-f]+}
+    end
 
-  it "uploads with record with no id" do
-    uploaded_file = uploader.upload(fakeio, record: OpenStruct.new(), name: :file)
+    it "uploads with record with no id" do
+      uploaded_file = uploader.upload(fakeio, record: OpenStruct.new(), name: :file)
 
-    expect(uploaded_file.id).to match %r{\Aasset/[0-9a-f]+}
+      expect(uploaded_file.id).to match %r{\Aasset/[0-9a-f]+}
+    end
   end
 
+  describe "for shrine derivatives" do
+    let(:image_path) { Kithe::Engine.root.join("spec/test_support/images/1x1_pixel.jpg") }
+
+    let(:uploader) do
+      test_uploader do
+        plugin :kithe_storage_location
+      end
+    end
 
+    it "uses good path for derivative" do
+      uploaded_file = uploader.upload(fakeio("foo.jpg"), derivative: :fixed, record: OpenStruct.new(id: "81060886-4f93-42e7-ace7-ab51399f4808"), name: :file)
+
+      expect(uploaded_file.id).to match %r{\A81060886-4f93-42e7-ace7-ab51399f4808/fixed/[0-9a-f]+}
+    end
+
+    it "raises with no record" do
+      expect {
+        uploader.upload(fakeio("foo.jpg"), record: nil, derivative: :fixed, name: :file)
+      }.to raise_error(TypeError)
+    end
+
+    it "raises with record with no id" do
+      expect {
+        uploader.upload(fakeio("foo.jpg"), record: OpenStruct.new, derivative: :fixed, name: :file)
+      }.to raise_error(TypeError)
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -132,13 +132,14 @@ end
 require 'sane_patch'
 SanePatch.patch("shrine", "< 3.2.2") do
   require 'shrine/storage/memory'
+
   class Shrine::Storage::Memory
-    def open(id, *)
-      str = store.fetch(id)
-      StringIO.new(str).set_encoding(str.encoding, str.encoding)
+    def open(id, **)
+      io = StringIO.new(store.fetch(id))
+      io.set_encoding(io.string.encoding) # Ruby 2.7.0 – https://bugs.ruby-lang.org/issues/16497
+      io
+    rescue KeyError
+      raise Shrine::FileNotFound, "file #{id.inspect} not found on storage"
     end
   end
 end
-
-
-

data/spec/test_support/shrine_spec_support.rb

@@ -59,8 +59,9 @@ require "stringio"
 class FakeIO
   attr_reader :original_filename, :content_type
 
-  def initialize(content, filename: nil, content_type: nil)
+  def initialize(content, filename: nil, content_type: nil, encoding: "BINARY")
     @io = StringIO.new(content)
+    @io.set_encoding(encoding, encoding) # weird ruby workaround
     @original_filename = filename
     @content_type = content_type
   end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kithe
 version: !ruby/object:Gem::Version
-  version: 2.0.0.pre.alpha2
+  version: 2.0.0.pre.beta1
 platform: ruby
 authors:
 - Jonathan Rochkind
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-18 00:00:00.000000000 Z
+date: 2020-05-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -272,20 +272,6 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: '0'
-- !ruby/object:Gem::Dependency
-  name: shrine-memory
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: '0'
 - !ruby/object:Gem::Dependency
   name: webmock
   requirement: !ruby/object:Gem::Requirement
@@ -341,10 +327,9 @@ files:
 - app/models/kithe/asset.rb
 - app/models/kithe/asset/derivative_creator.rb
 - app/models/kithe/asset/derivative_definition.rb
-- app/models/kithe/asset/derivative_updater.rb
+- app/models/kithe/asset/set_shrine_uploader.rb
 - app/models/kithe/collection.rb
 - app/models/kithe/config_base.rb
-- app/models/kithe/derivative.rb
 - app/models/kithe/mediainfo_analyzer.rb
 - app/models/kithe/model.rb
 - app/models/kithe/model_contains.rb
@@ -355,7 +340,6 @@ files:
 - app/simple_form_enhancements/kithe/form_builder.rb
 - app/simple_form_enhancements/kithe/repeatable_input_generator.rb
 - app/uploaders/kithe/asset_uploader.rb
-- app/uploaders/kithe/derivative_uploader.rb
 - app/validators/array_inclusion_validator.rb
 - config/locales/en.yml
 - config/routes.rb
@@ -375,7 +359,13 @@ files:
 - lib/kithe/sti_preload.rb
 - lib/kithe/version.rb
 - lib/shrine/plugins/kithe_accept_remote_url.rb
+- lib/shrine/plugins/kithe_checksum_signatures.rb
+- lib/shrine/plugins/kithe_controllable_backgrounding.rb
+- lib/shrine/plugins/kithe_derivative_definitions.rb
+- lib/shrine/plugins/kithe_derivatives.rb
+- lib/shrine/plugins/kithe_determine_mime_type.rb
 - lib/shrine/plugins/kithe_multi_cache.rb
+- lib/shrine/plugins/kithe_persisted_derivatives.rb
 - lib/shrine/plugins/kithe_promotion_callbacks.rb
 - lib/shrine/plugins/kithe_promotion_directives.rb
 - lib/shrine/plugins/kithe_storage_location.rb
@@ -448,19 +438,23 @@ files:
 - spec/indexing/indexable_spec.rb
 - spec/indexing/indexer_spec.rb
 - spec/indexing/obj_extract_spec.rb
-- spec/models/kithe/asset/asset_create_derivatives_spec.rb
+- spec/models/kithe/asset/asset_derivatives_spec.rb
 - spec/models/kithe/asset/asset_promotion_hooks_spec.rb
+- spec/models/kithe/asset/set_shrine_uploader_spec.rb
 - spec/models/kithe/asset_spec.rb
 - spec/models/kithe/collection_spec.rb
 - spec/models/kithe/config_spec.rb
-- spec/models/kithe/derivative_spec.rb
 - spec/models/kithe/mediainfo_analyzer_spec.rb
 - spec/models/kithe/model_spec.rb
 - spec/models/kithe/parameters_spec.rb
 - spec/models/kithe/representatives_spec.rb
 - spec/models/kithe/work_spec.rb
 - spec/rails_helper.rb
+- spec/shrine/kithe_accept_remote_url_spec.rb
+- spec/shrine/kithe_checksum_signatures_spec.rb
+- spec/shrine/kithe_derivative_definitions_spec.rb
 - spec/shrine/kithe_multi_cache_spec.rb
+- spec/shrine/kithe_persisted_derivatives_spec.rb
 - spec/shrine/kithe_storage_location_spec.rb
 - spec/simple_form_enhancements/repeatable_input_generator_spec.rb
 - spec/spec_helper.rb
@@ -468,6 +462,7 @@ files:
 - spec/test_support/audio/ice_cubes.mp3
 - spec/test_support/images/1x1_pixel.jpg
 - spec/test_support/images/2x2_pixel.jpg
+- spec/test_support/images/3x3_pixel.jpg
 - spec/test_support/images/photo_800x586.jpg
 - spec/test_support/shrine_spec_support.rb
 - spec/test_support/temporary_class_for_specs.rb
@@ -561,23 +556,28 @@ test_files:
 - spec/derivative_transformers/ffmpeg_transformer_spec.rb
 - spec/models/kithe/collection_spec.rb
 - spec/models/kithe/config_spec.rb
+- spec/models/kithe/asset/asset_derivatives_spec.rb
 - spec/models/kithe/asset/asset_promotion_hooks_spec.rb
-- spec/models/kithe/asset/asset_create_derivatives_spec.rb
+- spec/models/kithe/asset/set_shrine_uploader_spec.rb
 - spec/models/kithe/representatives_spec.rb
 - spec/models/kithe/work_spec.rb
 - spec/models/kithe/mediainfo_analyzer_spec.rb
 - spec/models/kithe/parameters_spec.rb
-- spec/models/kithe/derivative_spec.rb
 - spec/models/kithe/asset_spec.rb
 - spec/models/kithe/model_spec.rb
 - spec/shrine/kithe_multi_cache_spec.rb
 - spec/shrine/kithe_storage_location_spec.rb
+- spec/shrine/kithe_persisted_derivatives_spec.rb
+- spec/shrine/kithe_derivative_definitions_spec.rb
+- spec/shrine/kithe_accept_remote_url_spec.rb
+- spec/shrine/kithe_checksum_signatures_spec.rb
 - spec/factories/kithe_works.rb
 - spec/factories/kithe_collections.rb
 - spec/factories/kithe_assets.rb
 - spec/test_support/temporary_class_for_specs.rb
 - spec/test_support/shrine_spec_support.rb
 - spec/test_support/images/2x2_pixel.jpg
+- spec/test_support/images/3x3_pixel.jpg
 - spec/test_support/images/1x1_pixel.jpg
 - spec/test_support/images/photo_800x586.jpg
 - spec/test_support/audio/README.md

data/app/models/kithe/asset/derivative_updater.rb

@@ -1,119 +0,0 @@
-# A service object to add an IO stream as a derivative with a certain key, to a asset.
-# Adds a Derivative database object for such. This class is normally only used from
-# Asset#update_derivative, it's a helper object, you aren't expected to use it independently.
-#
-# This would be very straightforward if it weren't for taking account of a couple concurrency race
-# conditions involving data integrity:
-#
-# 1. There should be only one derivative for a given asset/key pair. This is enforced by
-#   a DB constraint. If the record already exists, we want to update the current record,
-#   otherwise add a new one. We want to do this in a race-condition safe way, with possibly
-#   multiple processes editing db.
-#
-# 2. The DB should at no point in time contain a derivative generated for an _old_ version
-#   of the asset. If an asset#file is changed, it's existing derivatives need to be deleted,
-#   and this needs to happen in a race-condition safe way when something may be trying to
-#   add a derivative concurrently.
-#
-# I believe we have solved those challenges, but it leads to a bit tricky code. We use
-# a kind of "optimistic" approach to (1) (try to insert, if you get a uniqueness violation
-# try to find and use the record that's already there). And a "pessimistic" approach to (2),
-# where we actually briefly take out a DB pessimistic lock to make sure the asset#file hasn't
-# changed, and can't until we're done updating.  (using sha512 as a marker, which is why you
-# can't add an asset until it has a sha512 in it's metadata, usually post-promotion).
-#
-# If we made a given Asset objects's file bytestream immutable, this would all be a lot simpler;
-# we wouldn't need to worry about (2) at all, and maybe not even (1). We might consider that, but
-# for now we're tackling the hard way.
-#
-class Kithe::Asset::DerivativeUpdater
-  attr_reader :asset, :key, :io, :storage_key, :metadata, :max_optimistic_tries
-
-  def initialize(asset, key, io, storage_key: :kithe_derivatives, metadata: {})
-    @asset = asset
-    @key = key
-    @io = io
-    @storage_key = storage_key
-    @metadata = metadata
-
-    @max_optimistic_tries = 3
-
-    unless asset_has_persisted_sha512?
-      raise ArgumentError.new("Can not safely add derivative to an asset without a persisted sha512 value")
-    end
-  end
-
-  def update
-    deriv = Kithe::Derivative.new(key: key.to_s, asset: asset)
-
-    # skip cache phase, right to specified storage, but with metadata extraction.
-    uploader = deriv.file_attacher.shrine_class.new(storage_key)
-
-    # add our derivative key to context when uploading, so Kithe::DerivativeUploader can
-    # use it if needed.
-    uploaded_file = uploader.upload(io, record: deriv, metadata: metadata, kithe_derivative_key: key)
-    optimistically_save_derivative(uploaded_file: uploaded_file, derivative: deriv)
-  end
-
-  # Attaches UploadedFile to Derivative and tries to save it -- if we get a
-  # unique constraint violation because a Derivative for that asset/key already existed,
-  # we fetch that alredy existing one from the db and update it's actual bytestream.
-  #
-  # This method calls itself recursively to do that. Gives up after max_optimistic_tries,
-  # at which point it'll just raise the constraint violation exception.
-  def optimistically_save_derivative(uploaded_file:, derivative:, tries: 0)
-    derivative.file_attacher.change(uploaded_file)
-    save_deriv_ensuring_unchanged_asset(derivative)
-  rescue ActiveRecord::RecordNotUnique => e
-    if tries < max_optimistic_tries
-      # find the one that's already there, try to attach our new file
-      # to that one
-      derivative = Kithe::Derivative.where(key: key.to_s, asset: asset).first || derivative
-      optimistically_save_derivative(uploaded_file: uploaded_file, derivative: derivative, tries: tries + 1)
-    else
-      uploaded_file.delete if uploaded_file
-      raise e
-    end
-  rescue StandardError => e
-    # aggressively clean up our file on errors!
-    uploaded_file.delete if uploaded_file
-    raise e
-  end
-
-  # Save a Derivative model with some fancy DB footwork to ensure at the time
-  # we save it, the original asset file it is based on is still in db unchanged,
-  # in a concurrency-safe way.
-  #
-  # We re-fetch to ensure asset still exists, with sha512 we expect. (kithe model ensures sha512
-  # exists in shrine metadata). With a pessmistic lock in a transaction. This ensures that at
-  # the point we save the new derivative, the db is still in a state where the original file
-  # the derivative relates to is still in the db.
-  #
-  # Can raise a ActiveRecord::RecordNotUnique, if derivative unique constraint is violated,
-  # that is handled above here.
-  def save_deriv_ensuring_unchanged_asset(deriv)
-    # fancy throw/catch keep our abort rescue from being in the transaction
-    catch(:kithe_unchanged_abort) do
-      Kithe::Asset.transaction do
-        # the file we're trying to add a derivative to doesn't exist anymore, forget it
-        unless asset.acquire_lock_on_sha
-          throw :kithe_unchanged_abort
-        end
-
-        deriv.save!
-        return deriv
-      end
-    end
-
-    # If we made it here, we've aborted
-    deriv.file.delete
-    return nil
-  end
-
-  def asset_has_persisted_sha512?
-    asset.persisted? && asset.sha512.present? &&
-    !( asset.file_data_changed? &&
-         asset.file_data_change.first.try(:dig, "metadata", "sha512") !=
-           asset.file_data_change.second.try(:dig, "metadata", "sha512"))
-  end
-end

data/app/models/kithe/derivative.rb

@@ -1,15 +0,0 @@
-module Kithe
-
-  # Derivatives by default will be stored in Shrine storage :kithe_derivatives, so
-  # that should be registered in your app.
-  #
-  # Only one deriv can exist for a given asset_id/key pair, enforced by db constraint.
-  class Derivative < ApplicationRecord
-    # the fk is to kithe_models STI table, but we only intend for assets
-    belongs_to :asset, class_name: "Kithe::Asset"
-
-    include Kithe::DerivativeUploader::Attachment.new(:file, store: :kithe_derivatives)
-
-    delegate :content_type, :size, :height, :width, :url, to: :file, allow_nil: true
-  end
-end

data/app/uploaders/kithe/derivative_uploader.rb

@@ -1,48 +0,0 @@
-require 'mini_mime'
-
-module Kithe
-  # The derivative uploader doesn't have to do too much, we don't even use
-  # promotion for derivatives, just writing directly to a storage.
-  #
-  # But it needs activerecord integration, and limited metadata automatic extraction.
-  class DerivativeUploader < Shrine
-    plugin :activerecord
-
-    plugin :determine_mime_type, analyzer: :marcel
-
-    # ignore error, often from storing a non-image file which can't have dimensions
-    # extracted. behavior consistent with shrine 2.x.
-    plugin :store_dimensions, on_error: :ignore
-
-    # Useful in case consumers want it, and doesn't harm anything to be available.
-    # https://github.com/shrinerb/shrine/blob/master/doc/plugins/rack_response.md
-    plugin :rack_response
-
-    # should this be in a plugin? location in file system based on original asset
-    # id and derivative key, as well as unique random file id from shrine.
-    def generate_location(io, context)
-      # assumes we're only used with Derivative model, that has an asset_id and key
-      asset_id = context[:record].asset_id
-      key = context[:record].key
-      original = super
-      [asset_id, key, original].compact.join("/")
-    end
-
-
-    # Override to fix "filename" metadata to be something reasonable, regardless
-    # of what if anything was the filename of the IO being attached. shrine S3 will
-    # insist on setting a default content-disposition with this filename.
-    def extract_metadata(io, context = {})
-      result = super
-
-      if context[:kithe_derivative_key] &&
-         context[:record]
-        extension = MiniMime.lookup_by_content_type(result["mime_type"] || "")&.extension
-        result["filename"] = "#{context[:record].asset.friendlier_id}_#{context[:kithe_derivative_key]}.#{extension}"
-        result["kithe_derivative_key"] = context[:kithe_derivative_key]
-      end
-
-      return result
-    end
-  end
-end

data/spec/models/kithe/asset/asset_create_derivatives_spec.rb

@@ -1,320 +0,0 @@
-# Make a new test file cause it's a buncha func
-require 'rails_helper'
-
-# Not sure how to get our
-describe "Kithe::Asset derivative definitions", queue_adapter: :test do
-  let(:a_jpg_deriv_file) { Kithe::Engine.root.join("spec/test_support/images/2x2_pixel.jpg") }
-
-  temporary_class("TestAssetSubclass") do
-    deriv_src_path = a_jpg_deriv_file
-    Class.new(Kithe::Asset) do
-      define_derivative(:some_data) do |original_file|
-        StringIO.new("some one data")
-      end
-
-      define_derivative(:a_jpg) do |original_file|
-        FileUtils.cp(deriv_src_path,
-             Kithe::Engine.root.join("spec/test_support/images/2x2_pixel-TEMP.jpg"))
-
-        File.open(Kithe::Engine.root.join("spec/test_support/images/2x2_pixel-TEMP.jpg"))
-      end
-    end
-  end
-
-  let(:asset) do
-    TestAssetSubclass.create(title: "test",
-      file: File.open(Kithe::Engine.root.join("spec/test_support/images/1x1_pixel.jpg"))
-    ).tap do |a|
-      # We want to promote without create_derivatives being automatically called
-      # as usual, so we can test create_derivatives manually.
-      a.file_attacher.set_promotion_directives(create_derivatives: false)
-      a.promote
-
-      # Precondition assumptions for our test setup to be valid
-      expect(a.file_attacher.stored?).to be(true)
-      expect(a.derivatives).to be_empty
-    end
-  end
-
-  it "builds derivatives" do
-    asset.create_derivatives
-
-    one_deriv = asset.derivatives.find { |d| d.key == "some_data" }
-    expect(one_deriv).to be_present
-    expect(one_deriv.file.read).to eq("some one data")
-
-    jpg_deriv = asset.derivatives.find {|d| d.key == "a_jpg"}
-    expect(jpg_deriv.file.read).to eq(File.read(a_jpg_deriv_file, encoding: "BINARY"))
-  end
-
-  it "sets #derivatives_created?" do
-    expect(asset.derivatives_created?).to be(false)
-    asset.create_derivatives
-    asset.reload
-    expect(asset.derivatives_created?).to be(true)
-  end
-
-
-  describe "Original deleted before derivatives can be created", queue_adapter: :inline do
-    let(:short_lived_asset) do
-      TestAssetSubclass.create!(title: "test",
-        file: File.open(Kithe::Engine.root.join("spec/test_support/images/1x1_pixel.jpg")))
-    end
-    it """catches the ActiveJob::DeserializationError
-      if the asset is no longer in the database
-      once the derivative creation job starts up.""" do
-      id_to_delete = short_lived_asset.id
-      Kithe::Derivative.where(asset_id: id_to_delete).delete_all
-      Kithe::Model.where(id: id_to_delete).delete_all
-
-      # short_lived_asset is no longer in the DB.
-      # Let's try and create derivatives for it:
-      expect do
-        Kithe::CreateDerivativesJob.perform_later(short_lived_asset)
-      end.not_to raise_error
-    end
-  end
-
-  describe "under normal operation", queue_adapter: :inline do
-    let(:asset) do
-      TestAssetSubclass.create!(title: "test",
-        file: File.open(Kithe::Engine.root.join("spec/test_support/images/1x1_pixel.jpg")))
-    end
-    it "automatically creates derivatives" do
-      expect(asset.derivatives.count).to eq(2)
-    end
-  end
-
-  it "extracts limited metadata from derivative" do
-    asset.create_derivatives
-
-    jpg_deriv = asset.derivatives.find {|d| d.key == "a_jpg"}
-    expect(jpg_deriv.size).to eq(File.size(Kithe::Engine.root.join("spec/test_support/images/2x2_pixel.jpg")))
-    expect(jpg_deriv.width).to eq(2)
-    expect(jpg_deriv.height).to eq(2)
-    expect(jpg_deriv.content_type).to eq("image/jpeg")
-  end
-
-  it "deletes derivative file returned by block" do
-    asset.create_derivatives
-
-    expect(File.exist?(Kithe::Engine.root.join("spec/test_support/images/2x2_pixel-TEMP.jpg"))).not_to be(true)
-  end
-
-  it "by default saves in :kithe_derivatives storage" do
-    asset.create_derivatives
-
-    jpg_deriv = asset.derivatives.find {|d| d.key == "a_jpg"}
-    expect(jpg_deriv.file.storage_key).to eq(:kithe_derivatives)
-  end
-
-
-  describe "block arguments" do
-    let(:monitoring_proc) do
-      proc do |original_file, record:|
-        expect(original_file.kind_of?(File) || original_file.kind_of?(Tempfile)).to be(true)
-        expect(original_file.path).to be_present
-        expect(original_file.read).to eq(asset.file.read)
-
-        expect(record).to eq(asset)
-
-        nil
-      end
-    end
-
-    temporary_class("TestAssetSubclass") do
-      our_proc = monitoring_proc
-      Class.new(Kithe::Asset) do
-        define_derivative(:some_data, &our_proc)
-      end
-    end
-
-    it "as expected" do
-      expect(monitoring_proc).to receive(:call).and_call_original
-
-      asset.create_derivatives
-      expect(asset.derivatives.length).to eq(0)
-    end
-  end
-
-  describe "custom storage_key" do
-    temporary_class("TestAssetSubclass") do
-      Class.new(Kithe::Asset) do
-        define_derivative(:some_data, storage_key: :store) do |original_file|
-          StringIO.new("some one data")
-        end
-      end
-    end
-    it "saves appropriately" do
-      asset.create_derivatives
-
-      deriv = asset.derivatives.first
-
-      expect(deriv).to be_present
-      expect(deriv.file.storage_key).to eq(:store)
-    end
-  end
-
-  describe "default_create false" do
-    let(:monitoring_proc) { proc { |asset| } }
-
-    temporary_class("TestAssetSubclass") do
-      p = monitoring_proc
-      Class.new(Kithe::Asset) do
-        define_derivative(:some_data, default_create: false, &p)
-      end
-    end
-
-    it "is not run automatically" do
-      expect(monitoring_proc).not_to receive(:call)
-      asset.create_derivatives
-    end
-  end
-
-  describe "only/except" do
-    let(:monitoring_proc1) { proc { |asset| StringIO.new("one") } }
-    let(:monitoring_proc2) { proc { |asset| StringIO.new("two") } }
-    let(:monitoring_proc3) { proc { |asset| StringIO.new("three") } }
-
-    temporary_class("TestAssetSubclass") do
-      p1, p2, p3 = monitoring_proc1, monitoring_proc2, monitoring_proc3
-      Class.new(Kithe::Asset) do
-        define_derivative(:one, default_create: false, &p1)
-        define_derivative(:two, &p2)
-        define_derivative(:three, &p3)
-      end
-    end
-
-    it "can call with only" do
-      expect(monitoring_proc1).to receive(:call).and_call_original
-      expect(monitoring_proc2).to receive(:call).and_call_original
-      expect(monitoring_proc3).not_to receive(:call)
-
-      asset.create_derivatives(only: [:one, :two])
-
-      expect(asset.derivatives.collect(&:key)).to eq(["one", "two"])
-    end
-
-    it "can call with except" do
-      expect(monitoring_proc1).not_to receive(:call)
-      expect(monitoring_proc2).to receive(:call).and_call_original
-      expect(monitoring_proc3).not_to receive(:call)
-
-      asset.create_derivatives(except: [:three])
-
-      expect(asset.derivatives.collect(&:key)).to eq(["two"])
-    end
-
-    it "can call with only and except" do
-      expect(monitoring_proc1).to receive(:call).and_call_original
-      expect(monitoring_proc2).not_to receive(:call)
-      expect(monitoring_proc3).not_to receive(:call)
-
-      asset.create_derivatives(only: [:one, :two], except: :two)
-
-      expect(asset.derivatives.collect(&:key)).to eq(["one"])
-    end
-  end
-
-  describe "content_type filters" do
-    temporary_class("TestAssetSubclass") do
-      Class.new(Kithe::Asset) do
-        define_derivative(:never_called, content_type: "nothing/nothing") { |o| StringIO.new("never") }
-        define_derivative(:gated_positive, content_type: "image/jpeg") { |o| StringIO.new("gated positive") }
-        define_derivative(:gated_positive_main_type, content_type: "image") { |o| StringIO.new("gated positive") }
-      end
-    end
-
-    it "does not call if content type does not match" do
-      asset.create_derivatives
-      expect(asset.derivatives.collect(&:key)).not_to include("never_called")
-    end
-
-    it "calls for exact content type match" do
-      asset.create_derivatives
-      expect(asset.derivatives.collect(&:key)).to include("gated_positive")
-    end
-
-    it "calls for main content type match" do
-      asset.create_derivatives
-      expect(asset.derivatives.collect(&:key)).to include("gated_positive_main_type")
-    end
-
-    describe "as array" do
-      temporary_class("TestAssetSubclass") do
-        Class.new(Kithe::Asset) do
-          define_derivative(:never_called, content_type: ["nothing/nothing", "also/nothing"]) { |o| StringIO.new("never") }
-          define_derivative(:gated_positive, content_type: ["image/jpeg", "something/else"]) { |o| StringIO.new("gated positive") }
-        end
-      end
-      it "calls for one match" do
-        asset.create_derivatives
-        expect(asset.derivatives.collect(&:key)).to eq(["gated_positive"])
-      end
-    end
-
-    describe "conflicting types" do
-      let(:unfiltered) { proc { |asset| StringIO.new("unfiltered") } }
-      let(:image) { proc { |asset| StringIO.new("image") } }
-      let(:image_jpeg) { proc { |asset| StringIO.new("image/jpeg") } }
-
-
-      temporary_class("TestAssetSubclass") do
-        u, i, ij = unfiltered, image, image_jpeg
-        Class.new(Kithe::Asset) do
-          define_derivative(:key, &u)
-          define_derivative(:key, content_type: "image/jpeg", &ij)
-          define_derivative(:key, content_type: "image", &i)
-        end
-      end
-
-      it "takes most specific" do
-        expect(unfiltered).not_to receive(:call)
-        expect(image).not_to receive(:call)
-        expect(image_jpeg).to receive(:call).and_call_original
-
-        asset.create_derivatives
-        expect(asset.derivatives.count).to eq(1)
-
-        deriv = asset.derivatives.first
-        expect(deriv.key).to eq("key")
-        expect(deriv.file.read). to eq("image/jpeg")
-      end
-    end
-  end
-
-  describe "lazy creation" do
-    before do
-      asset.class.derivative_definitions.collect(&:key).each do |key|
-        asset.update_derivative(key, StringIO.new("#{key} original"))
-      end
-    end
-
-    it "does not re-create" do
-      derivatives_pre_creation = asset.derivatives.collect(&:attributes)
-
-      asset.create_derivatives(lazy: true)
-      derivatives_post_creation = asset.derivatives.reload.collect(&:attributes)
-
-      expect(derivatives_post_creation).to eq(derivatives_pre_creation)
-    end
-  end
-
-  describe "#remove_derivative_definition!" do
-    it "can remove by string" do
-      original_keys = TestAssetSubclass.defined_derivative_keys
-      TestAssetSubclass.remove_derivative_definition!(original_keys.first.to_s)
-      expect(TestAssetSubclass.defined_derivative_keys).to eq(original_keys.slice(1..original_keys.length))
-    end
-    it "can remove by symbol" do
-      original_keys = TestAssetSubclass.defined_derivative_keys
-      TestAssetSubclass.remove_derivative_definition!(original_keys.first.to_sym)
-      expect(TestAssetSubclass.defined_derivative_keys).to eq(original_keys.slice(1..original_keys.length))
-    end
-    it "can remove multiple args" do
-      original_keys = TestAssetSubclass.defined_derivative_keys
-      TestAssetSubclass.remove_derivative_definition!(*original_keys)
-      expect(TestAssetSubclass.defined_derivative_keys).to eq([])
-    end
-  end
-end