Fix review feedback, improve multi-account config, and harden VCR scrubbing

- Fix auth/header handling, pagination, upload behavior, and README examples
- Add multi-account spec coverage for per-client configuration
- Scrub VCR cassettes and harden VCR filters to avoid leaking credentials

Author: vipulnsward

README.md

@@ -799,7 +799,7 @@ puts stored_file.datetime_stored
 # Batch store files using their UUIDs
 ``` ruby
 uuids = ['uuid1', 'uuid2', 'uuid3']
-batch_result = Uploadcare::File.batch_store(uuids)
+batch_result = Uploadcare::File.batch_store(uuids: uuids)
 ```
 
 # Check the status of the operation
@@ -823,7 +823,7 @@ unless batch_result.problems.empty?
 end
 ```
 
-## Deleting Files
+#### Deleting Files
 
 # Delete a single file
 ```ruby
@@ -836,12 +836,11 @@ puts deleted_file.datetime_removed
 # Batch delete multiple files
 ```ruby
 uuids = ['FILE_UUID_1', 'FILE_UUID_2']
-result = Uploadcare::File.batch_delete(uuids)
 result = Uploadcare::File.batch_delete(uuids: uuids)
 puts result.result
 ```
 
-## Copying Files
+#### Copying Files
 
 # Copy a file to local storage
 ```ruby

api_examples/upload_api/post_base.rb

@@ -25,7 +25,8 @@
 end
 
 payload = result.success
-file_name, file_uuid = payload.first
+file_uuid = payload['uuid']
+file_name = payload['original_filename']
 
 puts 'File uploaded successfully!'
 puts "UUID: #{file_uuid}"

lib/uploadcare/authenticator.rb

@@ -40,12 +40,10 @@ def initialize(config:)
   # @param body [String] Request body content (default: '')
   # @param content_type [String] Content-Type header value (default: 'application/json')
   # @return [Hash] Headers hash including authentication
-  # @raise [Uploadcare::Exception::AuthError] if public key is blank when using secure auth
+  # @raise [Uploadcare::Exception::AuthError] if public or secret key is blank when using secure auth
   def headers(http_method, uri, body = '', content_type = 'application/json')
     return simple_auth_headers(content_type) if @config.auth_type == 'Uploadcare.Simple'
-    if @config.secret_key.nil? || @config.secret_key.empty?
-      return @default_headers.merge({ 'Content-Type' => content_type })
-    end
+    raise Uploadcare::Exception::AuthError, 'Secret Key is blank.' if @config.secret_key.to_s.empty?
 
     validate_public_key
     secure_auth_headers(http_method, uri, body, content_type)

lib/uploadcare/clients/file_client.rb

@@ -5,7 +5,7 @@ class Uploadcare::FileClient < Uploadcare::RestClient
   # Gets list of files without pagination fields
   # @see https://uploadcare.com/api-refs/rest-api/v0.7.0/#tag/File/operation/filesList
   def list(params: {}, request_options: {})
-    get(path: 'files/', params: params, headers: {}, request_options: request_options)
+    get(path: '/files/', params: params, headers: {}, request_options: request_options)
   end
 
   # Stores a file by UUID

lib/uploadcare/clients/file_metadata_client.rb

@@ -39,7 +39,7 @@ def update(uuid:, key:, value:, request_options: {})
     encoded_key = URI.encode_www_form_component(key)
     put(
       path: "/files/#{encoded_uuid}/metadata/#{encoded_key}/",
-      params: value,
+      params: value.to_json,
       headers: {},
       request_options: request_options
     )

lib/uploadcare/clients/multipart_uploader_client.rb

@@ -60,7 +60,8 @@ def upload_chunks(file, links, &block)
   # @param link_index [Integer] Index of the current chunk
   def process_chunk(file, links, link_index, &chunk_block)
     offset = link_index * CHUNK_SIZE
-    chunk = ::File.read(file, CHUNK_SIZE, offset)
+    file.seek(offset)
+    chunk = file.read(CHUNK_SIZE)
     Uploadcare::Result.unwrap(put(links[link_index], chunk))
 
     return unless chunk_block

lib/uploadcare/clients/rest_client.rb

@@ -74,7 +74,7 @@ def make_request(method:, path:, params: {}, headers: {}, request_options: {})
   # @param path [String] API endpoint path
   # @param params [Hash] Request body parameters
   # @param headers [Hash] Additional request headers
-  # @return [Hash] Parsed JSON response body
+  # @return [Uploadcare::Result] Result wrapper
   def post(path:, params: {}, headers: {}, request_options: {})
     request(method: :post, path: path, params: params, headers: headers, request_options: request_options)
   end
@@ -84,7 +84,7 @@ def post(path:, params: {}, headers: {}, request_options: {})
   # @param path [String] API endpoint path
   # @param params [Hash] Query parameters
   # @param headers [Hash] Additional request headers
-  # @return [Hash] Parsed JSON response body
+  # @return [Uploadcare::Result] Result wrapper
   def get(path:, params: {}, headers: {}, request_options: {})
     request(method: :get, path: path, params: params, headers: headers, request_options: request_options)
   end
@@ -94,7 +94,7 @@ def get(path:, params: {}, headers: {}, request_options: {})
   # @param path [String] API endpoint path
   # @param params [Hash] Request body parameters
   # @param headers [Hash] Additional request headers
-  # @return [Hash] Parsed JSON response body
+  # @return [Uploadcare::Result] Result wrapper
   def put(path:, params: {}, headers: {}, request_options: {})
     request(method: :put, path: path, params: params, headers: headers, request_options: request_options)
   end
@@ -104,7 +104,7 @@ def put(path:, params: {}, headers: {}, request_options: {})
   # @param path [String] API endpoint path
   # @param params [Hash] Request body parameters
   # @param headers [Hash] Additional request headers
-  # @return [Hash] Parsed JSON response body
+  # @return [Uploadcare::Result] Result wrapper
   def delete(path:, params: {}, headers: {}, request_options: {})
     request(method: :delete, path: path, params: params, headers: headers, request_options: request_options)
   end
@@ -148,7 +148,13 @@ def prepare_headers(req, method, uri, params, headers)
     body_content = if method == HTTP_GET
                      ''
                    else
-                     params.nil? || params.empty? ? '' : params.to_json
+                     if params.nil? || (params.respond_to?(:empty?) && params.empty?)
+                       ''
+                     elsif params.is_a?(String)
+                       params
+                     else
+                       params.to_json
+                     end
                    end
 
     content_type = headers['Content-Type'] || authenticator.default_headers['Content-Type']
@@ -163,7 +169,7 @@ def prepare_body_or_params(req, method, params)
     else
       return if params.nil? || params.empty?
 
-      req.body = params.is_a?(String) ? params.to_json : params
+      req.body = params
     end
   end
 

lib/uploadcare/clients/upload_client.rb

@@ -82,7 +82,9 @@ def post(path:, params: {}, headers: {}, request_options: {})
   # @see https://uploadcare.com/api-refs/upload-api/#operation/baseUpload
   def upload_file(file:, request_options: {}, **options)
     Uploadcare::Result.capture do
-      raise ArgumentError, 'file must be a File or IO object' unless file.respond_to?(:read)
+      unless file.respond_to?(:read) && file.respond_to?(:path)
+        raise ArgumentError, 'file must be a File or IO object with #read and #path'
+      end
 
       params = build_upload_params(file, options)
       Uploadcare::Result.unwrap(post(path: 'base/', params: params, request_options: request_options))
@@ -302,7 +304,9 @@ def multipart_complete(uuid:, request_options: {})
   #   end
   def multipart_upload(file:, request_options: {}, **options, &)
     Uploadcare::Result.capture do
-      raise ArgumentError, 'file must be a File or IO object' unless file.respond_to?(:read)
+      unless file.respond_to?(:read) && file.respond_to?(:path)
+        raise ArgumentError, 'file must be a File or IO object with #read and #path'
+      end
 
       file_size = file.respond_to?(:size) ? file.size : ::File.size(file.path)
       filename = file.respond_to?(:original_filename) ? file.original_filename : ::File.basename(file.path)
@@ -621,64 +625,49 @@ def upload_parts_parallel(file, presigned_urls, part_size, threads, &block)
     mutex = Mutex.new
     queue = Queue.new
 
-    # Read all parts into memory (for thread safety)
-    parts = []
-    presigned_urls.each_with_index do |presigned_url, index|
-      file.seek(index * part_size)
-      part_data = file.read(part_size)
-
-      break if part_data.nil? || part_data.empty?
-
-      parts << { url: presigned_url, data: part_data, index: index }
-    end
-
-    # Add parts to queue
-    parts.each { |part| queue << part }
-
-    # Add sentinel values (nil) to signal workers to stop
+    presigned_urls.each_with_index { |url, index| queue << [url, index] }
     threads.times { queue << nil }
 
-    # Track errors from threads
     errors = []
+    file_path = file.path
 
-    # Create worker threads
     workers = threads.times.map do
       Thread.new do
-        loop do
-          part = begin
-            queue.pop(true)
-          rescue ThreadError
-            # Queue is empty, exit cleanly
-            break
-          end
+        worker_file = ::File.open(file_path, 'rb')
+        begin
+          loop do
+            job = begin
+              queue.pop
+            rescue ThreadError
+              break
+            end
+            break if job.nil?
+
+            presigned_url, index = job
+            offset = index * part_size
+            break if offset >= total_size
 
-          # Sentinel value signals termination
-          break if part.nil?
+            worker_file.seek(offset)
+            part_data = worker_file.read(part_size)
+            break if part_data.nil? || part_data.empty?
 
-          begin
-            Uploadcare::Result.unwrap(multipart_upload_part(presigned_url: part[:url], part_data: part[:data]))
+            Uploadcare::Result.unwrap(multipart_upload_part(presigned_url: presigned_url, part_data: part_data))
 
             mutex.synchronize do
-              uploaded += part[:data].bytesize
-              block&.call({ uploaded: uploaded, total: total_size, part: part[:index] + 1,
-                            total_parts: parts.length })
+              uploaded += part_data.bytesize
+              block&.call({ uploaded: uploaded, total: total_size, part: index + 1,
+                            total_parts: presigned_urls.length })
             end
-          rescue StandardError => e
-            mutex.synchronize { errors << e }
-            raise # Re-raise to terminate thread
           end
+        rescue StandardError => e
+          mutex.synchronize { errors << e }
+        ensure
+          worker_file.close
         end
       end
     end
 
-    # Wait for all threads to complete and collect any uncaught exceptions
-    workers.each do |worker|
-      worker.join
-    rescue StandardError => e
-      mutex.synchronize { errors << e unless errors.include?(e) }
-    end
-
-    # Check for errors and raise the first one
+    workers.each(&:join)
     raise errors.first if errors.any?
   end
 

lib/uploadcare/clients/upload_group_client.rb

@@ -10,6 +10,9 @@ class Uploadcare::UploadGroupClient < Uploadcare::UploadClient
   # @return [Hash] The response containing group information
   # @see https://uploadcare.com/api-refs/upload-api/#operation/createFilesGroup
   def create_group(uuids:, request_options: {}, **options)
+    raise ArgumentError, 'uuids must be an array' unless uuids.is_a?(Array)
+    raise ArgumentError, 'uuids cannot be empty' if uuids.empty?
+
     body_hash = group_body_hash(uuids, options)
     post(path: 'group/', params: body_hash, headers: {}, request_options: request_options)
   end

lib/uploadcare/clients/uploader_client.rb

@@ -120,7 +120,10 @@ def build_upload_params(files, options = {})
   # Convert upload options to API parameters
   def upload_options_to_params(options)
     params = { 'UPLOADCARE_PUB_KEY' => @config.public_key }
-    params['UPLOADCARE_STORE'] = store_value(options[:store]) if options[:store]
+    if options.key?(:store)
+      store = store_value(options[:store])
+      params['UPLOADCARE_STORE'] = store unless store.nil?
+    end
     params.merge!(generate_metadata_params(options[:metadata]))
     params
   end