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

data/spec/shrine/kithe_checksum_signatures_spec.rb

@@ -0,0 +1,63 @@
+require 'rails_helper'
+require 'shrine/plugins/kithe_checksum_signatures'
+
+# This kithe plugin is optional, let's make sure it works how we expect
+describe Shrine::Plugins::KitheChecksumSignatures, queue_adpater: :inline do
+  temporary_class("ChecksumUploader") do
+    Class.new(Kithe::AssetUploader) do
+      plugin :kithe_checksum_signatures
+    end
+  end
+
+  temporary_class("ChecksumAsset") do
+    Class.new(Kithe::Asset) do
+      set_shrine_uploader(ChecksumUploader)
+    end
+  end
+
+  around do |example|
+    original = Kithe::Asset.promotion_directives
+    Kithe::Asset.promotion_directives = { promote: :inline }
+
+    example.run
+
+    Kithe::Asset.promotion_directives = original
+  end
+
+  it "provides checksum metadata after promotion" do
+    asset = ChecksumAsset.create!(title: "test", file: StringIO.new("test"))
+    asset.reload
+
+    expect(asset).to be_stored
+    expect(asset.file.metadata.slice("md5", "sha1", "sha512")).to all(be_present)
+  end
+
+  describe "without promotion" do
+    around do |example|
+      original = Kithe::Asset.promotion_directives
+      Kithe::Asset.promotion_directives = { promote: false }
+
+      example.run
+
+      Kithe::Asset.promotion_directives = original
+    end
+
+    it "does not extract checksum metadata on cache" do
+      asset = ChecksumAsset.create!(title: "test", file: StringIO.new("test"))
+      asset.reload
+
+      expect(asset).not_to be_stored
+      expect(asset.file.metadata.slice("md5", "sha1", "sha512")).not_to include(be_present)
+    end
+  end
+
+  describe "derivatives" do
+    it "do not get checksum metadata" do
+      asset = ChecksumAsset.create!(title: "test", file: StringIO.new("test"))
+      asset.update_derivative("test", StringIO.new("test deriv"))
+
+      expect(asset.file_derivatives[:test]).to be_present
+      expect(asset.file_derivatives[:test].metadata.slice("md5", "sha1", "sha512")).not_to include(be_present)
+    end
+  end
+end

data/spec/shrine/kithe_derivative_definitions_spec.rb

@@ -0,0 +1,303 @@
+require 'rails_helper'
+
+# We just test with a Kithe::Asset class, too much trouble to try to isolate, not
+# worth it I think.
+describe "Shrine::Plugins::KitheDerivativeDefinitions", queue_adapter: :test do
+  # promotion inline, disable auto derivatives
+  around do |example|
+    original = Kithe::Asset.promotion_directives
+    Kithe::Asset.promotion_directives = { promote: :inline, create_derivatives: false }
+
+    example.run
+    Kithe::Asset.promotion_directives = original
+  end
+
+  let(:a_jpg_deriv_file) { Kithe::Engine.root.join("spec/test_support/images/2x2_pixel.jpg") }
+
+  temporary_class("CustomUploader") do
+    deriv_src_path = a_jpg_deriv_file
+
+    Class.new(Kithe::AssetUploader) do
+      self::Attacher.define_derivative(:some_data) do |original_file|
+        StringIO.new("some one data")
+      end
+
+      self::Attacher.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
+
+  temporary_class("CustomAsset") do
+    Class.new(Kithe::Asset) do
+      set_shrine_uploader(CustomUploader)
+    end
+  end
+
+  let(:asset) do
+    CustomAsset.create(title: "test",
+      file: File.open(Kithe::Engine.root.join("spec/test_support/images/1x1_pixel.jpg"))
+    )
+  end
+
+  it "normalizes string key to symbol" do
+    CustomUploader::Attacher.define_derivative("started_string") { |io| }
+    expect(CustomUploader::Attacher.kithe_derivative_definitions.collect(&:key)).to include(:started_string)
+  end
+
+  it "builds derivatives" do
+    asset.file_attacher.create_derivatives(:kithe_derivatives)
+
+    one_deriv = asset.file_derivatives[:some_data]
+    expect(one_deriv).to be_present
+    expect(one_deriv.read).to eq("some one data")
+
+    jpg_deriv = asset.file_derivatives[:a_jpg]
+    expect(jpg_deriv.read).to eq(File.binread(a_jpg_deriv_file))
+    expect(jpg_deriv.storage_key).to eq(:kithe_derivatives)
+  end
+
+  describe "attacher argument to block" do
+    let(:monitoring_proc) do
+      proc do |original_file, attacher:|
+        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(attacher).to be_present
+        expect(attacher).to be_kind_of(Shrine::Attacher)
+        expect(attacher.record).to eq(asset)
+        expect(attacher.file).to be_kind_of(Shrine::UploadedFile)
+        nil
+      end
+    end
+
+    before do
+      # hacky confusing way to set this up for testing, sorry.
+      CustomUploader::Attacher.kithe_derivative_definitions = []
+      CustomUploader::Attacher.define_derivative(:some_data, &monitoring_proc)
+    end
+
+    it "as expected" do
+      expect(monitoring_proc).to receive(:call).and_call_original
+
+      asset.file_attacher.create_derivatives(:kithe_derivatives)
+      expect(asset.file_derivatives.length).to eq(0)
+    end
+
+    describe "as **kwargs" do
+      let(:monitoring_proc) do
+        proc do |original_file, **kwargs|
+          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)
+
+          # It really has to be a local file with a path, not just an IO.
+          # Kithe wants to guarantee this, whether or not shrine does.
+          expect(original_file).to respond_to(:path)
+
+          expect(kwargs[:attacher]).to be_present
+          expect(kwargs[:attacher]).to eq(asset.file_attacher)
+
+          nil
+        end
+      end
+
+      it "as expected" do
+        expect(monitoring_proc).to receive(:call).and_call_original
+
+        asset.file_attacher.create_derivatives(:kithe_derivatives)
+        expect(asset.file_derivatives.length).to eq(0)
+      end
+    end
+  end
+
+
+  describe "default_create false" do
+    let(:monitoring_proc) { proc { |asset| } }
+
+    before do
+      # hacky confusing way to set this up for testing, sorry.
+      CustomUploader::Attacher.kithe_derivative_definitions = []
+      CustomUploader::Attacher.define_derivative(:some_data, default_create: false, &monitoring_proc)
+    end
+
+    it "is not run automatically" do
+      expect(monitoring_proc).not_to receive(:call)
+      asset.file_attacher.create_derivatives(:kithe_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") } }
+
+    before do
+      # hacky confusing way to set this up for testing, sorry.
+      CustomUploader::Attacher.kithe_derivative_definitions = []
+      CustomUploader::Attacher.define_derivative(:one, default_create: false, &monitoring_proc1)
+      CustomUploader::Attacher.define_derivative(:two, &monitoring_proc2)
+      CustomUploader::Attacher.define_derivative(:three, &monitoring_proc2)
+    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)
+
+      # except string or symbol
+      asset.file_attacher.create_derivatives(:kithe_derivatives, only: [:one, "two"])
+
+      expect(asset.file_derivatives.keys).to match([: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.file_attacher.create_derivatives(:kithe_derivatives, except: [:three])
+
+      # :one was default_create:false, and we said  except: :three
+      expect(asset.file_derivatives.keys).to eq([:two])
+    end
+
+    it "can call with except as string" 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.file_attacher.create_derivatives(:kithe_derivatives, except: ["three"])
+
+      # :one was default_create:false, and we said  except: :three
+      expect(asset.file_derivatives.keys).to eq([:two])
+    end
+
+    it "can call with only and except" 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)
+
+      # string version of except why not
+      asset.file_attacher.create_derivatives(:kithe_derivatives, only: [:one, :two], except: :three)
+
+      expect(asset.file_derivatives.keys).to eq([:one, :two])
+    end
+  end
+
+
+  describe "content_type filters" do
+    before do
+      # hacky confusing way to set this up for testing, sorry.
+      CustomUploader::Attacher.kithe_derivative_definitions = []
+      CustomUploader::Attacher.define_derivative(:never_called, content_type: "nothing/nothing") { |o| StringIO.new("never") }
+      CustomUploader::Attacher.define_derivative(:gated_positive, content_type: "image/jpeg") { |o| StringIO.new("gated positive") }
+      CustomUploader::Attacher.define_derivative(:gated_positive_main_type, content_type: "image") { |o| StringIO.new("gated positive") }
+    end
+
+    it "does not call if content type does not match" do
+      asset.file_attacher.create_derivatives(:kithe_derivatives)
+      expect(asset.file_derivatives.keys).not_to include(:never_called)
+    end
+
+    it "calls for exact content type match" do
+      asset.file_attacher.create_derivatives(:kithe_derivatives)
+      expect(asset.file_derivatives.keys).to include(:gated_positive)
+    end
+
+    it "calls for main content type match" do
+      asset.file_attacher.create_derivatives(:kithe_derivatives)
+      expect(asset.file_derivatives.keys).to include(:gated_positive_main_type)
+    end
+
+    describe "as array" do
+      before do
+        # hacky confusing way to set this up for testing, sorry.
+        CustomUploader::Attacher.kithe_derivative_definitions = []
+        CustomUploader::Attacher.define_derivative(:never_called, content_type: ["nothing/nothing", "also/nothing"]) { |o| StringIO.new("never") }
+        CustomUploader::Attacher.define_derivative(:gated_positive, content_type: ["image/jpeg", "something/else"]) { |o| StringIO.new("gated positive") }
+      end
+
+      it "calls for one match" do
+        asset.file_attacher.create_derivatives(:kithe_derivatives)
+        expect(asset.file_derivatives.keys).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") } }
+
+      before do
+        # hacky confusing way to set this up for testing, sorry.
+        CustomUploader::Attacher.kithe_derivative_definitions = []
+        CustomUploader::Attacher.define_derivative(:key, &unfiltered)
+        CustomUploader::Attacher.define_derivative(:key, content_type: "image/jpeg", &image_jpeg)
+        CustomUploader::Attacher.define_derivative(:key, content_type: "image", &image)
+      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.file_attacher.create_derivatives(:kithe_derivatives)
+        expect(asset.file_derivatives.count).to eq(1)
+
+
+        expect(asset.file_derivatives.keys).to eq([:key])
+        expect(asset.file_derivatives[:key].read). to eq("image/jpeg")
+      end
+    end
+  end
+
+  describe "lazy creation" do
+    before do
+      # Create existing derivatives for existing definitions, which we assume exist
+      expect(CustomUploader::Attacher.kithe_derivative_definitions).to be_present
+
+      CustomUploader::Attacher.kithe_derivative_definitions.collect(&:key).each do |key|
+        asset.file_attacher.add_persisted_derivatives({key => StringIO.new("#{key} original")})
+      end
+    end
+
+    it "does not re-create" do
+      derivatives_pre_creation = asset.file_derivatives
+
+      asset.file_attacher.create_derivatives(:kithe_derivatives, lazy: true)
+      derivatives_post_creation = asset.file_derivatives
+
+      expect(derivatives_post_creation).to eq(derivatives_pre_creation)
+    end
+  end
+
+  describe "#remove_derivative_definition!" do
+    let(:defined_derivative_key) do
+      CustomUploader::Attacher.defined_derivative_keys.first.tap do |key|
+        expect(key).to be_present
+      end
+    end
+
+    it "can remove by string" do
+      expect {
+        CustomUploader::Attacher.remove_derivative_definition!(defined_derivative_key.to_s)
+      }.to change { CustomUploader::Attacher.defined_derivative_keys.count }.from(2).to(1)
+    end
+
+    it "can remove by symbol" do
+      expect {
+        CustomUploader::Attacher.remove_derivative_definition!(defined_derivative_key.to_sym)
+      }.to change { CustomUploader::Attacher.defined_derivative_keys.count }.from(2).to(1)
+    end
+
+    it "can remove multiple args" do
+      CustomUploader::Attacher.remove_derivative_definition!(*CustomUploader::Attacher.defined_derivative_keys)
+      expect(CustomUploader::Attacher.defined_derivative_keys).to eq([])
+    end
+  end
+end

data/spec/shrine/kithe_persisted_derivatives_spec.rb

@@ -0,0 +1,424 @@
+require 'rails_helper'
+require 'shrine/plugins/kithe_persisted_derivatives'
+
+# We just test with a Kithe::Asset class, too much trouble to try to isolate, not
+# worth it I think.
+describe Shrine::Plugins::KithePersistedDerivatives, queue_adapter: :test do
+  # promotion inline, disable auto derivatives
+  around do |example|
+    original = Kithe::Asset.promotion_directives
+    Kithe::Asset.promotion_directives = { promote: :inline, create_derivatives: false }
+
+    example.run
+    Kithe::Asset.promotion_directives = original
+  end
+
+  # Need to make a new copy, because shrine likes deleting derivatives!
+  def sample_deriv_file!(path = Kithe::Engine.root.join("spec/test_support/images/1x1_pixel.jpg"))
+    tempfile = Tempfile.new
+    IO.copy_stream(File.open(path), tempfile)
+
+    tempfile
+  end
+
+  let(:sample_orig_path) { Kithe::Engine.root.join("spec/test_support/images/2x2_pixel.jpg") }
+  let(:another_sample_orig_path) { Kithe::Engine.root.join("spec/test_support/images/1x1_pixel.jpg") }
+
+  let(:asset) { Kithe::Asset.create!(title: "test", file: File.open(sample_orig_path))}
+
+  describe "#add_persisted_derivatives" do
+    it "can add and persist" do
+      asset.file_attacher.add_persisted_derivatives(sample: sample_deriv_file!)
+
+      expect(asset.changed?).to be(false)
+      expect(asset.file_derivatives[:sample]).to be_present
+      expect(asset.file_derivatives[:sample].storage_key).to eq(:kithe_derivatives)
+      expect(asset.file_derivatives[:sample].exists?).to be(true)
+
+      # sanity check
+      asset.reload
+      expect(asset.file_derivatives[:sample]).to be_present
+    end
+
+    it "can avoid deleting deriv file" do
+      file = sample_deriv_file!
+      asset.file_attacher.add_persisted_derivatives({sample: file}, delete: false)
+
+      expect(File.exists?(file.path)).to eq(true)
+    end
+
+    it "can use custom storage" do
+      file = sample_deriv_file!
+      asset.file_attacher.add_persisted_derivatives({sample: file}, storage: :cache)
+
+      asset.reload
+      expect(asset.file_derivatives[:sample]).to be_present
+      expect(asset.file_derivatives[:sample].storage_key).to eq(:cache)
+    end
+
+    it "can supply custom metadata" do
+      file = sample_deriv_file!
+      asset.file_attacher.add_persisted_derivatives({sample: file}, metadata: { extra: "value" })
+
+      asset.reload
+
+      expect(asset.file_derivatives[:sample].metadata["extra"]).to eq("value")
+      # and still has default metadata
+      expect(asset.file_derivatives[:sample].metadata["size"]).to be_present
+    end
+
+    describe "model with unsaved changes" do
+      before do
+        asset.title = "changed title"
+      end
+
+      it "will refuse" do
+        expect {
+          asset.file_attacher.add_persisted_derivatives(sample: sample_deriv_file!)
+        }.to raise_error(TypeError)
+      end
+
+      it "can be forced" do
+        asset.file_attacher.add_persisted_derivatives({sample: sample_deriv_file!}, allow_other_changes: true)
+
+        expect(asset.changed?).to be(false)
+        asset.reload
+        expect(asset.title).to eq("changed title")
+        expect(asset.file_derivatives[:sample]).to be_present
+      end
+    end
+
+    describe "unsaved model" do
+      let(:asset) { Kithe::Asset.new(title: "test", file: File.open(sample_orig_path)) }
+
+      it "refuses even with other_changes: true" do
+        expect {
+          asset.file_attacher.add_persisted_derivatives({sample: sample_deriv_file!}, allow_other_changes: true)
+        }.to raise_error(TypeError)
+      end
+
+      describe "with an existing derivative" do
+        before do
+          asset.save!
+          asset.file_attacher.add_derivative("key", StringIO.new("existing"))
+          asset.save!
+        end
+
+        it "replaces" do
+          existing_storage = asset.file_derivatives[:key]
+          expect(existing_storage.exists?).to be(true)
+
+          asset.file_attacher.add_persisted_derivatives({"key" => StringIO.new("new")})
+          expect(asset.file_derivatives[:key].read).to eq("new")
+          expect(existing_storage.exists?).to be(false)
+        end
+      end
+    end
+
+    describe "Original deleted before derivatives can be created" do
+      before do
+        # delete it out from under us
+        Kithe::Model.where(id: asset.id).delete_all
+      end
+
+      it "doesn't complain and cleans up file" do
+
+        # asset is no longer in the DB.
+        # Let's try and create derivatives for it:
+        file = sample_deriv_file!
+        local_file_path = file.path
+
+        expect(asset.file_attacher.add_persisted_derivatives(sample: file)).to be(false)
+
+        expect(File.exist?(local_file_path)).to be(false)
+      end
+    end
+
+    describe "Original changed before derivatives can be created" do
+      before do
+        asset # load
+
+        # Change what's in the db for this asset, without changing the in-memory
+        # asset
+        another_copy = Kithe::Asset.find(asset.id)
+        another_copy.file = File.open(another_sample_orig_path)
+        another_copy.save!
+      end
+
+      it "doesn't add derivative and cleans up file" do
+        # asset in DB has different file attachment
+        # Let's try and create derivatives for it:
+        file = sample_deriv_file!
+        local_file_path = file.path
+
+        expect(asset.file_attacher.add_persisted_derivatives(new_try: file)).to be(false)
+
+
+        expect(asset.changed?).to be(false)
+        expect(asset.file_derivatives[:new_try]).to be_nil
+        asset.reload
+        expect(asset.file_derivatives[:new_try]).to be_nil
+
+        expect(File.exist?(local_file_path)).to be(false)
+      end
+    end
+
+    describe "concurrent derivative changes" do
+      let(:original_one) { sample_deriv_file!(Kithe::Engine.root.join("spec/test_support/images/1x1_pixel.jpg")) }
+      let(:original_two) { sample_deriv_file!(Kithe::Engine.root.join("spec/test_support/images/2x2_pixel.jpg")) }
+
+      let(:new_two) { sample_deriv_file!(Kithe::Engine.root.join("spec/test_support/images/3x3_pixel.jpg")) }
+      let(:new_three) { sample_deriv_file!(Kithe::Engine.root.join("spec/test_support/images/3x3_pixel.jpg")) }
+
+      before do
+        # make sure our test is setup to test what we want
+        original_two.rewind; new_two.rewind
+        expect(original_two.read).not_to eq(new_two.read)
+        original_two.rewind; new_two.rewind
+
+        asset # load
+
+        # change what derivatives are in db for this asset, without changing
+        # the in-memory asset
+        another_copy = Kithe::Asset.find(asset.id)
+        another_copy.file_attacher.add_derivatives({
+          one: original_one,
+          two: original_two
+        }, delete: false)
+        another_copy.save!
+
+        # Make sure we set up what we expected
+        another_copy.reload
+        expect(another_copy.file_derivatives[:one]).to be_present
+        expect(another_copy.file_derivatives[:two]).to be_present
+      end
+
+      it "merges changes in safely" do
+        expect(asset.file_derivatives.keys).to be_empty
+
+        asset.file_attacher.add_persisted_derivatives({two: new_two, three: new_three}, delete: false)
+
+        expect(asset.changed?).to be(false)
+        expect(asset.file_derivatives.keys).to match([:one, :two, :three])
+        expect(asset.file_derivatives[:two].read).to eq(File.binread(new_two.path))
+        expect(asset.file_derivatives[:three].read).to eq(File.binread(new_three.path))
+      end
+    end
+  end
+
+  describe "#create_persisted_derivatives" do
+    temporary_class("AssetSubclassUploader") do
+      call_fakeio = method(:fakeio) # weird closure issue
+
+      Class.new(Kithe::AssetUploader) do
+        self::Attacher.derivatives do |original, **options|
+          {
+            one: call_fakeio.("one"),
+            original_reflected: call_fakeio.(original.read)
+          }
+        end
+
+        self::Attacher.derivatives(:options) do |original, **options|
+          {
+            options_one: call_fakeio.("one"),
+            options_reflected: call_fakeio.(options.to_s)
+          }
+        end
+      end
+    end
+
+    temporary_class("AssetSubclass") do
+      Class.new(Kithe::Asset) do
+        set_shrine_uploader(AssetSubclassUploader)
+      end
+    end
+
+    let(:asset) { AssetSubclass.create!(title: "test", file: File.open(sample_orig_path))}
+
+    it "creates derivatives" do
+      # we're not gonna test concurrency safety, counting on add_persisted_derivatives
+      # for that, but let's make sure
+      expect(asset.file_attacher).to receive(:add_persisted_derivatives).and_call_original
+
+      asset.file_attacher.create_persisted_derivatives
+
+      expect(asset.changed?).to be(false)
+      expect(asset.file_derivatives.keys).to match([:one, :original_reflected])
+      asset.reload
+      expect(asset.file_derivatives[:one].read).to eq("one")
+      expect(asset.file_derivatives[:one].storage_key).to eq(:kithe_derivatives)
+      expect(asset.file_derivatives[:original_reflected].read).to eq(File.binread(sample_orig_path))
+      expect(asset.file_derivatives[:original_reflected].storage_key).to eq(:kithe_derivatives)
+    end
+
+    describe "with custom source" do
+      let(:string_io_source) { StringIO.new("pretend data") }
+
+      it "works with custom source as StringIO" do
+        asset.file_attacher.create_persisted_derivatives(:options, string_io_source)
+        expect(asset.file_derivatives).to be_present
+      end
+
+      it "works with custom source StringIO as only arg" do
+        asset.file_attacher.create_persisted_derivatives(string_io_source)
+
+        string_io_source.rewind
+        expect(asset.file_derivatives[:original_reflected].read).to eq(string_io_source.read)
+      end
+    end
+
+    describe "for an asset with nil file_data" do
+      let(:asset) { AssetSubclass.create!(title: "blank") }
+
+      it "no-ops" do
+        expect(asset.file_attacher.create_persisted_derivatives).to be(false)
+      end
+    end
+
+    describe "for an asset with missing original" do
+      let(:asset) { AssetSubclass.create!(title: "blank", file_data: { storage: "cache", id: "not_found"}) }
+
+      it "raises" do
+        expect(asset.file.exists?).to be(false)
+
+        # Not necessarily what kithe 1.x did, but this seems better...
+        expect {
+          asset.file_attacher.create_persisted_derivatives
+        }.to raise_error(Shrine::FileNotFound)
+      end
+    end
+
+    it "can call custom processor" do
+      asset.file_attacher.create_persisted_derivatives(:options)
+
+      expect(asset.file_derivatives.keys).to match([:options_one, :options_reflected])
+    end
+
+    it "can pass processor options" do
+      asset.file_attacher.create_persisted_derivatives(:options, arg1: "value1", arg2: "value2")
+
+      expect(asset.file_derivatives[:options_reflected].read).to eq({arg1: "value1", arg2: "value2"}.to_s)
+    end
+
+    it "can customize :storage" do
+      asset.file_attacher.create_persisted_derivatives(:options, storage: :cache, arg1: "value1", arg2: "value2")
+
+      expect(asset.file_derivatives[:options_reflected].read).to eq({arg1: "value1", arg2: "value2"}.to_s)
+      expect(asset.file_derivatives[:options_reflected].storage_key).to eq(:cache)
+    end
+
+    describe "model with unsaved changes" do
+      before do
+        asset.title = "changed title"
+      end
+
+      it "will refuse" do
+        expect {
+          asset.file_attacher.create_persisted_derivatives
+        }.to raise_error(TypeError)
+      end
+
+      it "can be forced" do
+        asset.file_attacher.create_persisted_derivatives(allow_other_changes: true)
+
+        expect(asset.changed?).to be(false)
+        asset.reload
+        expect(asset.title).to eq("changed title")
+        expect(asset.file_derivatives.keys).to match([:one, :original_reflected])
+      end
+    end
+  end
+
+  describe "#remove_persisted_derivatives" do
+    before do
+      asset.file_attacher.add_persisted_derivatives(
+        sample1: fakeio("sample 1"),
+        sample2: fakeio("sample 2")
+      )
+    end
+
+    it "can remove" do
+      removed = asset.file_attacher.remove_persisted_derivatives(:sample1)
+
+      expect(asset.changed?).to eq(false)
+      expect(asset.file_derivatives.keys).to eq([:sample2])
+      asset.reload
+      expect(asset.file_derivatives.keys).to eq([:sample2])
+
+      expect(removed).to be_kind_of(Array)
+      expect(removed.length).to eq(1)
+      expect(removed.first).to be_kind_of(Shrine::UploadedFile)
+      expect(removed.first.exists?).to be(false)
+    end
+
+    describe "if someone else removed first" do
+      before do
+        another_copy = asset.class.find(asset.id)
+        another_copy.file_attacher.remove_derivative(:sample1)
+        another_copy.save!
+        another_copy.reload
+        expect(another_copy.file_derivatives.keys).to eq([:sample2])
+
+        expect(asset.file_derivatives.keys).to match([:sample1, :sample2])
+      end
+
+      it "doesn't complain" do
+        asset.file_attacher.remove_persisted_derivatives(:sample1)
+        expect(asset.changed?).to eq(false)
+        expect(asset.file_derivatives.keys).to eq([:sample2])
+      end
+    end
+
+    describe "someone else added another derivative" do
+      before do
+        another_copy = asset.class.find(asset.id)
+        another_copy.file_attacher.add_persisted_derivatives({:sample3 => fakeio("sample 3")})
+        another_copy.reload
+        expect(another_copy.file_derivatives.keys).to match([:sample1, :sample2, :sample3])
+
+        expect(asset.file_derivatives.keys).to match([:sample1, :sample2])
+      end
+
+      it "deletes without deleting newly added" do
+        asset.file_attacher.remove_persisted_derivatives(:sample1)
+
+        expect(asset.changed?).to eq(false)
+        expect(asset.file_derivatives.keys).to eq([:sample2, :sample3])
+      end
+    end
+
+    describe "model deleted from under us" do
+      before do
+        another_copy = asset.class.find(asset.id)
+        another_copy.destroy!
+      end
+
+      it "silently no-ops" do
+        result = asset.file_attacher.remove_persisted_derivatives(:sample1)
+        expect(result).to eq(false)
+      end
+    end
+
+    describe "model with unsaved changes" do
+      before do
+        asset.title = "changed title"
+      end
+
+      it "will refuse" do
+        expect {
+          asset.file_attacher.remove_persisted_derivatives(:sample1)
+        }.to raise_error(TypeError)
+      end
+
+      it "can be forced" do
+        asset.file_attacher.remove_persisted_derivatives(:sample1, allow_other_changes: true)
+
+        expect(asset.changed?).to be(false)
+        asset.reload
+        expect(asset.title).to eq("changed title")
+        expect(asset.file_derivatives.keys).to eq([:sample2])
+      end
+    end
+
+  end
+end