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

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

@@ -0,0 +1,137 @@
+require 'rails_helper'
+
+# our configuration, customization, and added value on top of shrine derivatives.
+# https://shrinerb.com/docs/plugins/derivatives
+describe "customized shrine derivatives", queue_adapter: :inline do
+  let(:derivative_file_path) { Kithe::Engine.root.join("spec/test_support/images/2x2_pixel.jpg") }
+  let(:original_file_path) { Kithe::Engine.root.join("spec/test_support/images/1x1_pixel.jpg") }
+
+  describe "kithe derivative definitions" do
+    temporary_class("CustomUploader") do
+      call_fakeio = method(:fakeio) # weird closure issue
+      deriv_path = derivative_file_path
+      Class.new(Kithe::AssetUploader) do
+        self::Attacher.define_derivative(:fixed) do |io|
+          call_fakeio.(File.binread(deriv_path))
+        end
+      end
+    end
+
+    temporary_class("CustomAsset") do
+      Class.new(Kithe::Asset) do
+        set_shrine_uploader(CustomUploader)
+      end
+    end
+
+    it "automatically sets up derivative properly" do
+      asset = CustomAsset.create!(title: "test", file: File.open(original_file_path))
+      # happened in BG job, so have to reload to see it.
+      asset.reload
+
+      derivative = asset.file_derivatives[:fixed]
+      expect(derivative).to be_present
+
+      expect(derivative.exists?).to be(true)
+      expect(derivative.read).to eq(File.binread(derivative_file_path))
+      derivative.rewind
+
+      expect(derivative.storage_key).to eq(:kithe_derivatives)
+
+      # have some expected metadata, including good constructed 'filename'
+      expect(derivative.metadata["size"]).to eq(File.binread(derivative_file_path).length)
+      expect(derivative.metadata["mime_type"]).to eq("image/jpeg")
+      expect(derivative.metadata["height"]).to eq(2)
+      expect(derivative.metadata["width"]).to eq(2)
+      expect(derivative.metadata["filename"]).to eq("#{asset.friendlier_id}_fixed.jpeg")
+
+      # path on storage is nice and pretty
+      expect(derivative.id).to match %r{\A#{asset.id}/fixed/[a-f0-9]+\.jpeg\Z}
+    end
+
+
+    it "can manually #create_derivatives" do
+      asset = CustomAsset.create!(title: "test", file: File.open(original_file_path))
+      asset.reload
+
+      asset.file_attacher.set_derivatives({})
+      asset.save!
+      asset.reload
+      expect(asset.file_derivatives).to be_empty
+
+      asset.create_derivatives
+      asset.reload
+      derivative = asset.file_derivatives[:fixed]
+      expect(derivative).to be_present
+
+      expect(derivative.exists?).to be(true)
+    end
+
+
+    it "can remove derivatives" do
+      asset = CustomAsset.create!(title: "test", file: File.open(original_file_path))
+      asset.reload
+
+      asset.remove_derivatives(:fixed)
+      expect(asset.file_derivatives.keys).to be_empty
+      asset.reload
+      expect(asset.file_derivatives.keys).to be_empty
+    end
+
+    describe "with existing derivative", queue_adapter: :inline do
+      let(:asset) do
+        asset = CustomAsset.create!(title: "test", file: File.open(original_file_path))
+        asset.reload
+        asset.create_derivatives
+        asset.reload
+      end
+
+      it "deletes stored derivative file when model is deleted" do
+        derivatives = asset.file_derivatives.values
+        expect(derivatives).to be_present
+
+        asset.destroy!
+        expect(derivatives.none? {|d| d.exists? }).to be(true)
+      end
+
+      it "deletes stored derivatives on new file assignment" do
+        derivatives = asset.file_derivatives.values
+        expect(derivatives).to be_present
+
+        asset.file = File.open(original_file_path)
+        asset.save!
+        asset.reload
+
+        expect(derivatives.none? {|d| d.exists? }).to be(true)
+      end
+
+      it "lazy create does not even read original" do
+        pre_existing = asset.file_derivatives[:fixed]
+
+        expect(asset.file).not_to receive(:read)
+        expect(asset.file).not_to receive(:download)
+
+        asset.create_derivatives(lazy: true)
+
+        expect(asset.file_derivatives[:fixed]).to eq(pre_existing)
+      end
+
+      describe "#update_derivative" do
+        it "can add a derivative" do
+          result = asset.update_derivative(:fixed, StringIO.new("test updated"))
+
+          expect(result).to be_kind_of(Shrine::UploadedFile)
+          expect(asset.file_derivatives[:fixed].read).to eq("test updated")
+          expect(asset.file_derivatives[:fixed].storage_key).to eq(:kithe_derivatives)
+        end
+
+        it "can add a derivative with meadata" do
+          result = asset.update_derivative("test", StringIO.new("test"), metadata: { "manual" => "value"} )
+
+          expect(result).to be_kind_of(Shrine::UploadedFile)
+          expect(asset.file_derivatives[:test].metadata["manual"]).to eq("value")
+          expect(asset.file_derivatives[:test].metadata["size"]).to be_present
+        end
+      end
+    end
+  end
+end

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

@@ -3,9 +3,6 @@ require 'rails_helper'
 describe "Kithe::Asset promotion hooks", queue_adapter: :inline do
   temporary_class("TestAsset") do
     Class.new(Kithe::Asset) do
-      define_derivative :test do
-        # no-op, but we need a definition so will be scheduled
-      end
     end
   end
 
@@ -33,7 +30,6 @@ describe "Kithe::Asset promotion hooks", queue_adapter: :inline do
     it "has access to automatic metadata extraction" do
       unsaved_asset.save!
       expect($metadata_in_before_promotion).to be_present
-      expect($metadata_in_before_promotion['sha512']).to be_present
     end
   end
 
@@ -216,7 +212,6 @@ describe "Kithe::Asset promotion hooks", queue_adapter: :inline do
           asset.reload
 
           expect(asset.stored?).to be(true)
-          expect(asset.sha512).to be_present
         end
       end
 
@@ -259,6 +254,20 @@ describe "Kithe::Asset promotion hooks", queue_adapter: :inline do
   end
 
   describe "promotion_directive :promote", queue_adapter: :test do
+    temporary_class("TestUploader") do
+      Class.new(Kithe::AssetUploader) do
+        self::Attacher.define_derivative :test do
+          # no-op, but we need a definition so will be scheduled
+        end
+      end
+    end
+
+    temporary_class("TestAsset") do
+      Class.new(Kithe::Asset) do
+        set_shrine_uploader(TestUploader)
+      end
+    end
+
     it "can cancel promotion" do
       expect_any_instance_of(Kithe::AssetUploader::Attacher).not_to receive(:promote)
 
@@ -383,6 +392,7 @@ describe "Kithe::Asset promotion hooks", queue_adapter: :inline do
       asset = Kithe::Asset.new
       asset.set_promotion_directives(promote: :inline)
       expect(asset.file_attacher.promotion_directives).to eq("promote" => "inline")
+      expect(asset.promotion_directives).to eq("promote" => "inline")
     end
 
     it "setting from instance writer is aggregative" do
@@ -391,5 +401,16 @@ describe "Kithe::Asset promotion hooks", queue_adapter: :inline do
       asset.set_promotion_directives(create_derivatives: false)
       expect(asset.file_attacher.promotion_directives).to eq("promote" => "inline", "create_derivatives" => "false")
     end
+
+    it "setting from instance writer survives reload" do
+      asset = Kithe::Asset.create(title: "test")
+      asset.set_promotion_directives(create_derivatives: false)
+      expect(asset.file_attacher.promotion_directives).to eq("create_derivatives" => "false")
+
+      asset.reload
+
+      expect(asset.file_attacher.promotion_directives).to eq("create_derivatives" => "false")
+    end
+
   end
 end

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

@@ -0,0 +1,39 @@
+require 'rails_helper'
+
+describe Kithe::Asset::SetShrineUploader do
+  temporary_class("MyUploaderSubclass") do
+    Class.new(Kithe::AssetUploader) do
+      add_metadata :uploader_class_name do |io|
+        self.class.name
+      end
+    end
+  end
+
+  temporary_class("AssetSubclass") do
+    Class.new(Kithe::Asset) do
+      set_shrine_uploader(MyUploaderSubclass)
+    end
+  end
+
+  let(:asset) { AssetSubclass.create!(title: "test") }
+  let(:image_path) { Kithe::Engine.root.join("spec/test_support/images/1x1_pixel.jpg") }
+
+  it "has proper class attacher" do
+    expect(AssetSubclass.file_attacher.class).to eq(MyUploaderSubclass::Attacher)
+  end
+
+  it "has proper instance attacher" do
+    expect(asset.file_attacher.class).to eq(MyUploaderSubclass::Attacher)
+  end
+
+  it "can attach file using custom subclass" do
+    asset.set_promotion_directives(promote: :inline)
+    asset.file = File.open(image_path)
+    asset.save!
+    asset.reload
+
+    expect(asset.stored?).to eq(true)
+    expect(asset.file).to be_present
+    expect(asset.file.metadata["uploader_class_name"]).to eq("MyUploaderSubclass")
+  end
+end

data/spec/models/kithe/asset_spec.rb

@@ -51,11 +51,6 @@ RSpec.describe Kithe::Asset, type: :model do
 
       # This is the file location/storage path, currently under UUID pk.
       expect(asset.file.id).to match %r{\Aasset/#{asset.id}/.*\.jpg}
-
-      # checksums
-      expect(asset.sha1).to eq(Digest::SHA1.hexdigest(File.open(source_path).read))
-      expect(asset.md5).to eq(Digest::MD5.hexdigest(File.open(source_path).read))
-      expect(asset.sha512).to eq(Digest::SHA512.hexdigest(File.open(source_path).read))
     end
 
     describe "pdf file" do
@@ -90,46 +85,9 @@ RSpec.describe Kithe::Asset, type: :model do
 
       # This is the file location/storage path, currently under UUID pk.
       expect(asset.file.id).to match %r{\Aasset/#{asset.id}/.*\.jpg}
-
-      # checksums
-      expect(asset.sha1).to eq(Digest::SHA1.hexdigest(File.open(sample_file_path).read))
-      expect(asset.md5).to eq(Digest::MD5.hexdigest(File.open(sample_file_path).read))
-      expect(asset.sha512).to eq(Digest::SHA512.hexdigest(File.open(sample_file_path).read))
     end
   end
 
-  describe "remote urls", queue_adapter: :inline do
-    it "can assign and promote" do
-      stub_request(:any, "www.example.com/bar.html?foo=bar").
-        to_return(body: "Example Response" )
-
-      asset.file = {"id" => "http://www.example.com/bar.html?foo=bar", "storage" => "remote_url"}
-      asset.save!
-      asset.reload
-
-      expect(asset.file.storage_key).to eq(asset.file_attacher.store.storage_key.to_sym)
-      expect(asset.stored?).to be true
-      expect(asset.file.read).to include("Example Response")
-      expect(asset.file.id).to end_with(".html") # no query params
-    end
-
-    it "will fetch headers" do
-      stubbed = stub_request(:any, "www.example.com/bar.html?foo=bar").
-                  to_return(body: "Example Response" )
-
-      asset.file = {"id" => "http://www.example.com/bar.html?foo=bar",
-                    "storage" => "remote_url",
-                    "headers" => {"Authorization" => "Bearer TestToken"}}
-
-      asset.save!
-
-      expect(
-        a_request(:get, "www.example.com/bar.html?foo=bar").with(
-          headers: {'Authorization'=>'Bearer TestToken', 'User-Agent' => /.+/}
-        )
-      ).to have_been_made.times(1)
-    end
-  end
 
   describe "#promote", queue_adapter: :test do
     let(:asset) { FactoryBot.create(:kithe_asset, :with_file) }
@@ -144,7 +102,7 @@ RSpec.describe Kithe::Asset, type: :model do
       expect(asset.stored?).to be(true)
       expect(asset.file_attacher.stored?).to be(true)
       expect(asset.file.exists?).to be(true)
-      expect(asset.file.metadata.keys).to include("filename", "size", "mime_type", "width", "height", "md5", "sha1", "sha512")
+      expect(asset.file.metadata.keys).to include("filename", "size", "mime_type", "width", "height")
     end
 
     it "does not do anything for already promoted file", queue_adapter: :inline do
@@ -158,15 +116,6 @@ RSpec.describe Kithe::Asset, type: :model do
     end
   end
 
-  describe "#derivative_for" do
-    let!(:derivative) do
-      asset.derivatives.create!(key: "foo", file: StringIO.new("whatever"))
-    end
-    it "returns thing" do
-      expect(asset.derivative_for(:foo)).to eq(derivative)
-    end
-  end
-
   describe "removes derivatives", queue_adapter: :inline do
     let(:asset_with_derivatives) do
       Kithe::Asset.create(title: "test",
@@ -178,19 +127,17 @@ RSpec.describe Kithe::Asset, type: :model do
         a.update_derivative(:existing, StringIO.new("content"))
       end
     end
-    let!(:existing_derivative) { asset_with_derivatives.derivatives.first }
-    let!(:existing_stored_file) { existing_derivative.file }
+
+    let!(:existing_stored_file) { asset_with_derivatives.file_derivatives.values.first }
 
     it "deletes derivatives on delete" do
       asset_with_derivatives.destroy
-      expect{ existing_derivative.reload }.to raise_error(ActiveRecord::RecordNotFound)
       expect(existing_stored_file.exists?).to be(false)
     end
 
     it "deletes derivatives on new asset assigned" do
       asset_with_derivatives.file = StringIO.new("some new thing")
       asset_with_derivatives.save!
-      expect{ existing_derivative.reload }.to raise_error(ActiveRecord::RecordNotFound)
       expect(existing_stored_file.exists?).to be(false)
     end
 
@@ -198,12 +145,15 @@ RSpec.describe Kithe::Asset, type: :model do
       # mostly needed for testing scenarios, not otherwise expected.
       filepath = Kithe::Engine.root.join("spec/test_support/images/1x1_pixel.jpg")
       asset = Kithe::Asset.new(file: File.open(filepath), title: "test").tap do |a|
-        a.file_attacher.set_promotion_directives(skip_callbacks: true)
+        a.file_attacher.set_promotion_directives(promote: false, skip_callbacks: true)
       end
-      asset.derivatives << Kithe::Derivative.new(file: File.open(filepath), key: "test")
       asset.save!
       asset.reload
-      expect(asset.derivatives.count).to eq 1
+
+      expect(asset.stored?).to eq(false)
+      asset.update_derivative("test", File.open(filepath), delete: false)
+
+      expect(asset.file_derivatives.count).to eq 1
     end
   end
 end

data/spec/models/kithe/model_spec.rb

@@ -32,18 +32,6 @@ module Kithe
       end
     end
 
-    describe "eager-loading derivatives" do
-      let!(:work) { FactoryBot.create(:kithe_work) }
-      let!(:collection) { FactoryBot.create(:kithe_collection) }
-      let!(:asset) { FactoryBot.create(:kithe_asset) }
-
-      it "work from hetereogeous collections" do
-        results = Kithe::Model.all.includes(:derivatives)
-        asset = results.to_a.find { |a| a.kind_of? Kithe::Asset }
-        expect(asset.derivatives.loaded?).to be(true)
-      end
-    end
-
     describe "contains association" do
       let(:collection1) { FactoryBot.create(:kithe_collection)}
       let(:collection2) { FactoryBot.create(:kithe_collection)}
@@ -72,25 +60,5 @@ module Kithe
         expect(work2.contained_by.count).to eq(0)
       end
     end
-
-    describe "with_representative_derivatives scope" do
-      let(:work) {
-        FactoryBot.create(:kithe_work, title: "test for preload",
-          members: [
-            FactoryBot.create(:kithe_work, representative: FactoryBot.create(:kithe_asset, :faked_derivatives)),
-            FactoryBot.create(:kithe_asset, :faked_derivatives),
-            FactoryBot.create(:kithe_asset, :faked_derivatives)
-          ])
-      }
-      it "pre-loads all representatives and derivatives" do
-        members = work.members.with_representative_derivatives.to_a
-
-        members.each do |member|
-          expect(member.association(:leaf_representative)).to be_loaded
-          expect(member.leaf_representative.association(:derivatives)).to be_loaded
-        end
-      end
-    end
-
   end
 end

data/spec/shrine/kithe_accept_remote_url_spec.rb

@@ -0,0 +1,49 @@
+require 'rails_helper'
+require 'shrine/plugins/kithe_accept_remote_url'
+
+describe Shrine::Plugins::KitheAcceptRemoteUrl, queue_adapter: :inline do
+  temporary_class("RemoteUrlUploader") do
+    Class.new(Kithe::AssetUploader) do
+      plugin :kithe_accept_remote_url
+    end
+  end
+
+  temporary_class("MyAsset") do
+    Class.new(Kithe::Asset) do
+      set_shrine_uploader(RemoteUrlUploader)
+    end
+  end
+
+  let(:asset) { MyAsset.create!(title: "test") }
+
+  it "can assign and promote" do
+    stub_request(:any, "www.example.com/bar.html?foo=bar").
+      to_return(body: "Example Response" )
+
+    asset.file = {"id" => "http://www.example.com/bar.html?foo=bar", "storage" => "remote_url"}
+    asset.save!
+    asset.reload
+
+    expect(asset.file.storage_key).to eq(asset.file_attacher.store.storage_key.to_sym)
+    expect(asset.stored?).to be true
+    expect(asset.file.read).to include("Example Response")
+    expect(asset.file.id).to end_with(".html") # no query params
+  end
+
+  it "will fetch headers" do
+    stubbed = stub_request(:any, "www.example.com/bar.html?foo=bar").
+                to_return(body: "Example Response" )
+
+    asset.file = {"id" => "http://www.example.com/bar.html?foo=bar",
+                  "storage" => "remote_url",
+                  "headers" => {"Authorization" => "Bearer TestToken"}}
+
+    asset.save!
+
+    expect(
+      a_request(:get, "www.example.com/bar.html?foo=bar").with(
+        headers: {'Authorization'=>'Bearer TestToken', 'User-Agent' => /.+/}
+      )
+    ).to have_been_made.times(1)
+  end
+end