Expand ActiveStorage and config parity test coverage

Author: vipulnsward

spec/uploadcare/rails/active_storage/uploadcare_service_spec.rb

@@ -5,16 +5,19 @@
 require 'logger'
 require 'base64'
 require 'digest'
+require 'active_storage/errors'
 require 'active_storage/service/uploadcare_service'
 
 RSpec.describe ActiveStorage::Service::UploadcareService do
   let(:service) { described_class.new(public_key: 'demopublickey', secret_key: 'demosecretkey') }
+  let(:public_service) { described_class.new(public_key: 'demopublickey', secret_key: 'demosecretkey', public: true) }
   let(:uuid) { '2d33999d-c74a-4ff9-99ea-abc23496b052' }
 
   before do
     stub_const('ActiveStorage::Blob', Class.new)
     allow(ActiveStorage).to receive(:logger).and_return(Logger.new(nil))
     allow(ActiveStorage::Blob).to receive(:where).and_return(double(pluck: []))
+    allow(ActiveStorage::Blob).to receive(:find_by).and_return(nil)
   end
 
   it 'uploads a file and persists uploadcare uuid into blob metadata' do
@@ -32,6 +35,108 @@
     service.upload('blob-key', io, checksum: checksum)
   end
 
+  it 'raises integrity error for invalid checksum' do
+    io = StringIO.new('test payload')
+    bad_checksum = Base64.strict_encode64(Digest::MD5.digest('different payload'))
+
+    uploadcare_file = double(uuid: uuid)
+    allow(Uploadcare::Uploader).to receive(:upload_file).and_return(uploadcare_file)
+
+    expect { service.upload('blob-key', io, checksum: bad_checksum) }.to raise_error(ActiveStorage::IntegrityError)
+  end
+
+  it 'downloads file body for mapped key' do
+    blob = double(metadata: { 'uploadcare_uuid' => uuid })
+    allow(ActiveStorage::Blob).to receive(:find_by).with(key: 'blob-key').and_return(blob)
+    allow(Uploadcare::File).to receive(:info).with(uuid: uuid, config: kind_of(Uploadcare::Configuration))
+      .and_return(double(original_file_url: 'https://ucarecdn.com/file.bin', cdn_url: nil))
+    allow(service).to receive(:request).with('https://ucarecdn.com/file.bin').and_return('file-body')
+
+    expect(service.download('blob-key')).to eq('file-body')
+  end
+
+  it 'streams download when block is given' do
+    blob = double(metadata: { 'uploadcare_uuid' => uuid })
+    allow(ActiveStorage::Blob).to receive(:find_by).with(key: 'blob-key').and_return(blob)
+    allow(Uploadcare::File).to receive(:info).with(uuid: uuid, config: kind_of(Uploadcare::Configuration))
+      .and_return(double(original_file_url: nil, cdn_url: 'https://ucarecdn.com/file.bin'))
+    response = double
+    allow(response).to receive(:read_body).and_yield('ab').and_yield('cd')
+    allow(service).to receive(:request).with('https://ucarecdn.com/file.bin').and_yield(response)
+
+    chunks = []
+    service.download('blob-key') { |chunk| chunks << chunk }
+
+    expect(chunks).to eq(%w[ab cd])
+  end
+
+  it 'raises file not found on download for missing blob mapping' do
+    expect { service.download('missing-key') }.to raise_error(ActiveStorage::FileNotFoundError)
+  end
+
+  it 'raises file not found on download when uploadcare does not know uuid' do
+    blob = double(metadata: { 'uploadcare_uuid' => uuid })
+    allow(ActiveStorage::Blob).to receive(:find_by).with(key: 'blob-key').and_return(blob)
+    allow(Uploadcare::File).to receive(:info).with(uuid: uuid, config: kind_of(Uploadcare::Configuration))
+      .and_raise(Uploadcare::Exception::NotFoundError)
+
+    expect { service.download('blob-key') }.to raise_error(ActiveStorage::FileNotFoundError)
+  end
+
+  it 'downloads chunk with requested range' do
+    blob = double(metadata: { 'uploadcare_uuid' => uuid })
+    allow(ActiveStorage::Blob).to receive(:find_by).with(key: 'blob-key').and_return(blob)
+    allow(Uploadcare::File).to receive(:info).with(uuid: uuid, config: kind_of(Uploadcare::Configuration))
+      .and_return(double(original_file_url: nil, cdn_url: 'https://ucarecdn.com/file.bin'))
+    allow(service).to receive(:request).with('https://ucarecdn.com/file.bin', range: 0..3).and_return('data')
+
+    expect(service.download_chunk('blob-key', 0..3)).to eq('data')
+  end
+
+  it 'raises file not found on download_chunk when uploadcare does not know uuid' do
+    blob = double(metadata: { 'uploadcare_uuid' => uuid })
+    allow(ActiveStorage::Blob).to receive(:find_by).with(key: 'blob-key').and_return(blob)
+    allow(Uploadcare::File).to receive(:info).with(uuid: uuid, config: kind_of(Uploadcare::Configuration))
+      .and_raise(Uploadcare::Exception::NotFoundError)
+
+    expect { service.download_chunk('blob-key', 0..3) }.to raise_error(ActiveStorage::FileNotFoundError)
+  end
+
+  it 'deletes a mapped file' do
+    blob = double(metadata: { 'uploadcare_uuid' => uuid })
+    uploadcare_file = double(delete: true)
+    allow(ActiveStorage::Blob).to receive(:find_by).with(key: 'blob-key').and_return(blob)
+    expect(Uploadcare::File).to receive(:new).with({ uuid: uuid }, kind_of(Uploadcare::Configuration)).and_return(uploadcare_file)
+
+    service.delete('blob-key')
+  end
+
+  it 'does not delete when mapping is missing' do
+    expect(Uploadcare::File).not_to receive(:new)
+
+    service.delete('missing-key')
+  end
+
+  it 'returns nil when delete gets not found error' do
+    blob = double(metadata: { 'uploadcare_uuid' => uuid })
+    uploadcare_file = double
+    allow(ActiveStorage::Blob).to receive(:find_by).with(key: 'blob-key').and_return(blob)
+    allow(Uploadcare::File).to receive(:new).with({ uuid: uuid }, kind_of(Uploadcare::Configuration)).and_return(uploadcare_file)
+    allow(uploadcare_file).to receive(:delete).and_raise(Uploadcare::Exception::NotFoundError)
+
+    expect(service.delete('blob-key')).to be_nil
+  end
+
+  it 'deletes all keys with prefix' do
+    allow(ActiveStorage::Blob).to receive(:where).with('key LIKE ?', 'prefix%').and_return(double(pluck: %w[prefix-1 prefix-2]))
+    allow(service).to receive(:delete)
+
+    service.delete_prefixed('prefix')
+
+    expect(service).to have_received(:delete).with('prefix-1')
+    expect(service).to have_received(:delete).with('prefix-2')
+  end
+
   it 'supports existence check using mapped uuid' do
     blob = double(metadata: { 'uploadcare_uuid' => uuid }, update!: true)
     allow(ActiveStorage::Blob).to receive(:find_by).with(key: 'blob-key').and_return(blob)
@@ -40,8 +145,81 @@
     expect(service.exist?('blob-key')).to eq(true)
   end
 
+  it 'returns false from exist? when file is not found in uploadcare' do
+    blob = double(metadata: { 'uploadcare_uuid' => uuid }, update!: true)
+    allow(ActiveStorage::Blob).to receive(:find_by).with(key: 'blob-key').and_return(blob)
+    allow(Uploadcare::File).to receive(:info).with(uuid: uuid, config: kind_of(Uploadcare::Configuration))
+      .and_raise(Uploadcare::Exception::NotFoundError)
+
+    expect(service.exist?('blob-key')).to eq(false)
+  end
+
+  it 'returns false from exist? when key is unknown' do
+    expect(service.exist?('missing-key')).to eq(false)
+  end
+
+  it 'uses instrumentation payload for exist? true path' do
+    blob = double(metadata: { 'uploadcare_uuid' => uuid }, update!: true)
+    allow(ActiveStorage::Blob).to receive(:find_by).with(key: 'blob-key').and_return(blob)
+    allow(Uploadcare::File).to receive(:info).with(uuid: uuid, config: kind_of(Uploadcare::Configuration)).and_return(double)
+
+    payload = {}
+    expect(service).to receive(:instrument).with(:exist, key: 'blob-key').and_yield(payload)
+
+    expect(service.exist?('blob-key')).to eq(true)
+    expect(payload[:exist]).to eq(true)
+  end
+
+  it 'uses instrumentation payload for exist? false path' do
+    payload = {}
+    expect(service).to receive(:instrument).with(:exist, key: 'missing-key').and_yield(payload)
+
+    expect(service.exist?('missing-key')).to eq(false)
+    expect(payload[:exist]).to eq(false)
+  end
+
+  it 'uses uuid key directly when key is a uuid' do
+    allow(Uploadcare::File).to receive(:info).with(uuid: uuid, config: kind_of(Uploadcare::Configuration)).and_return(double)
+
+    expect(service.exist?(uuid)).to eq(true)
+  end
+
+  it 'returns empty headers for direct upload' do
+    expect(service.headers_for_direct_upload('key', checksum: 'x')).to eq({})
+  end
+
   it 'raises for direct upload support' do
     expect { service.url_for_direct_upload('key', expires_in: 10, content_type: 'text/plain', content_length: 1, checksum: 'x') }
       .to raise_error(NotImplementedError)
   end
+
+  it 'generates url for private service' do
+    blob = double(metadata: { 'uploadcare_uuid' => uuid })
+    file = double(cdn_url: 'https://ucarecdn.com/private')
+    allow(ActiveStorage::Blob).to receive(:find_by).with(key: 'blob-key').and_return(blob)
+    allow(Uploadcare::File).to receive(:new).with({ uuid: uuid }, kind_of(Uploadcare::Configuration)).and_return(file)
+
+    expect(service.url('blob-key', expires_in: 60, filename: 'a.txt', disposition: :inline, content_type: 'text/plain'))
+      .to eq('https://ucarecdn.com/private')
+  end
+
+  it 'generates url for public service' do
+    blob = double(metadata: { 'uploadcare_uuid' => uuid })
+    file = double(cdn_url: 'https://ucarecdn.com/public')
+    allow(ActiveStorage::Blob).to receive(:find_by).with(key: 'blob-key').and_return(blob)
+    allow(Uploadcare::File).to receive(:new).with({ uuid: uuid }, kind_of(Uploadcare::Configuration)).and_return(file)
+
+    expect(public_service.url('blob-key', expires_in: 60, filename: 'a.txt', disposition: :inline, content_type: 'text/plain'))
+      .to eq('https://ucarecdn.com/public')
+  end
+
+  it 'uses blob metadata mapping for download after upload mapping persisted' do
+    blob = double(metadata: { 'uploadcare_uuid' => uuid }, update!: true)
+    allow(ActiveStorage::Blob).to receive(:find_by).with(key: 'blob-key').and_return(blob)
+    allow(Uploadcare::File).to receive(:info).with(uuid: uuid, config: kind_of(Uploadcare::Configuration))
+      .and_return(double(original_file_url: 'https://ucarecdn.com/file.bin', cdn_url: nil))
+    allow(service).to receive(:request).with('https://ucarecdn.com/file.bin').and_return('file-body')
+
+    expect(service.download('blob-key')).to eq('file-body')
+  end
 end

spec/uploadcare/rails/api/rest/file_api_spec.rb

@@ -12,12 +12,41 @@ module Rest
 
           context 'when checking methods' do
             it 'responds to expected REST methods' do
-              %i[get_files get_file delete_file store_file].each do |method|
+              %i[get_files get_file delete_file store_file local_copy_file remote_copy_file store_files delete_files].each do |method|
                 expect(subject).to respond_to(method)
               end
             end
           end
 
+          context 'when passing custom config' do
+            let(:custom_config) { Uploadcare::Configuration.new(public_key: 'pk', secret_key: 'sk') }
+
+            it 'forwards config to get_file' do
+              expect(Uploadcare::File).to receive(:info).with(uuid: 'uuid', config: custom_config)
+
+              subject.get_file('uuid', config: custom_config)
+            end
+
+            it 'forwards config to get_files' do
+              expect(Uploadcare::File).to receive(:list).with(options: { limit: 10 }, config: custom_config)
+
+              subject.get_files({ limit: 10 }, config: custom_config)
+            end
+
+            it 'forwards config to local_copy_file' do
+              expect(Uploadcare::File).to receive(:local_copy).with(source: 'source', options: { store: true }, config: custom_config)
+
+              subject.local_copy_file('source', { store: true }, config: custom_config)
+            end
+
+            it 'forwards config to remote_copy_file' do
+              expect(Uploadcare::File).to receive(:remote_copy)
+                .with(source: 'source', target: 'target', options: { make_public: true }, config: custom_config)
+
+              subject.remote_copy_file('source', 'target', { make_public: true }, config: custom_config)
+            end
+          end
+
           context 'when sending requests' do
             it 'gets file info' do
               VCR.use_cassette('file_api_get_file') do

spec/uploadcare/rails/api/upload/upload_api_spec.rb

@@ -20,6 +20,24 @@ module Upload
             end
           end
 
+          context 'when passing custom config' do
+            let(:custom_config) { Uploadcare::Configuration.new(public_key: 'pk', secret_key: 'sk') }
+
+            it 'forwards config for upload_file' do
+              file = ::File.open('spec/fixtures/kitten.jpeg')
+              expect(Uploadcare::Uploader).to receive(:upload).with(object: file, config: custom_config, store: true)
+
+              subject.upload_file(file, { store: true }, config: custom_config)
+            end
+
+            it 'forwards config for upload_files' do
+              file = ::File.open('spec/fixtures/kitten.jpeg')
+              expect(Uploadcare::Uploader).to receive(:upload).with(object: [file], config: custom_config, store: true)
+
+              subject.upload_files([file], { store: true }, config: custom_config)
+            end
+          end
+
           context 'when sending requests' do
             context 'and when uploading a single file' do
               context 'and when uploading is successful' do

spec/uploadcare/rails/jobs/delete_file_job_spec.rb

@@ -12,4 +12,29 @@
       end.to change(ActiveJob::Base.queue_adapter.enqueued_jobs, :size).by(1)
     end
   end
+
+  describe '#perform' do
+    it 'deletes a file with default config' do
+      expect(Uploadcare::FileApi).to receive(:delete_file).with('file-uuid', config: Uploadcare.configuration)
+
+      described_class.new.perform('file-uuid')
+    end
+
+    it 'deletes a file with provided config options' do
+      expect(Uploadcare::FileApi).to receive(:delete_file) do |uuid, config:|
+        expect(uuid).to eq('file-uuid')
+        expect(config).to be_a(Uploadcare::Configuration)
+        expect(config.public_key).to eq('pk')
+        expect(config.secret_key).to eq('sk')
+      end
+
+      described_class.new.perform('file-uuid', { public_key: 'pk', secret_key: 'sk' })
+    end
+
+    it 'does nothing when uuid is nil' do
+      expect(Uploadcare::FileApi).not_to receive(:delete_file)
+
+      described_class.new.perform(nil)
+    end
+  end
 end

spec/uploadcare/rails/jobs/store_file_job_spec.rb

@@ -12,4 +12,29 @@
       end.to change(ActiveJob::Base.queue_adapter.enqueued_jobs, :size).by(1)
     end
   end
+
+  describe '#perform' do
+    it 'stores a file with default config' do
+      expect(Uploadcare::FileApi).to receive(:store_file).with('file-uuid', config: Uploadcare.configuration)
+
+      described_class.new.perform('file-uuid')
+    end
+
+    it 'stores a file with provided config options' do
+      expect(Uploadcare::FileApi).to receive(:store_file) do |uuid, config:|
+        expect(uuid).to eq('file-uuid')
+        expect(config).to be_a(Uploadcare::Configuration)
+        expect(config.public_key).to eq('pk')
+        expect(config.secret_key).to eq('sk')
+      end
+
+      described_class.new.perform('file-uuid', { public_key: 'pk', secret_key: 'sk' })
+    end
+
+    it 'does nothing when uuid is nil' do
+      expect(Uploadcare::FileApi).not_to receive(:store_file)
+
+      described_class.new.perform(nil)
+    end
+  end
 end

spec/uploadcare/rails/jobs/store_group_job_spec.rb

@@ -12,4 +12,29 @@
       end.to change(ActiveJob::Base.queue_adapter.enqueued_jobs, :size).by(1)
     end
   end
+
+  describe '#perform' do
+    it 'stores a group with default config' do
+      expect(Uploadcare::GroupApi).to receive(:store_group).with('group-id', config: Uploadcare.configuration)
+
+      described_class.new.perform('group-id')
+    end
+
+    it 'stores a group with provided config options' do
+      expect(Uploadcare::GroupApi).to receive(:store_group) do |group_id, config:|
+        expect(group_id).to eq('group-id')
+        expect(config).to be_a(Uploadcare::Configuration)
+        expect(config.public_key).to eq('pk')
+        expect(config.secret_key).to eq('sk')
+      end
+
+      described_class.new.perform('group-id', { public_key: 'pk', secret_key: 'sk' })
+    end
+
+    it 'does nothing when group id is nil' do
+      expect(Uploadcare::GroupApi).not_to receive(:store_group)
+
+      described_class.new.perform(nil)
+    end
+  end
 end