transloadit 3.1.2 → 4.1.0

data/test/unit/transloadit/test_assembly_uploads.rb

@@ -0,0 +1,272 @@
+require "test_helper"
+require "stringio"
+require "tempfile"
+
+describe "Assembly uploads and custom fields" do
+  include WebMock::API
+
+  before do
+    WebMock.reset!
+    @transloadit = Transloadit.new(key: "key", secret: "secret")
+    @requests = []
+    stub_request(:post, "https://api2.transloadit.com/assemblies").to_return do |request|
+      @requests << request
+      {body: '{"ok":"ASSEMBLY_COMPLETED"}'}
+    end
+    @fields = {
+      "count" => 2,
+      "enabled" => false,
+      "ratio" => 1.5,
+      "empty" => nil,
+      "tags" => ["hello & goodbye", 3, true, nil],
+      "details" => {"caption" => "café + 猫", "visible" => true}
+    }
+  end
+
+  after do
+    WebMock.reset!
+  end
+
+  it "sends typed custom fields only in signed JSON without uploads" do
+    @transloadit.assembly(fields: @fields).create!
+
+    _(body_parts.map(&:first)).must_equal %w[params signature]
+    _(signed_params.fetch("fields")).must_equal @fields
+  end
+
+  it "sends named File parts separately from typed fields with the same name" do
+    Tempfile.create(["assembly-upload", ".bin"]) do |file|
+      file.binmode
+      file.write("named\x00\xff upload".b)
+      file.flush
+      fields = @fields.merge("hero" => "metadata for the hero")
+      uploads = {hero: file}.freeze
+      assembly = @transloadit.assembly(uploads: uploads, fields: fields.freeze)
+
+      _, warning = capture_io { assembly.create! }
+
+      _(warning).wont_include "Passing upload IOs in fields"
+      _(body_parts.map(&:first)).must_equal %w[params signature hero]
+      _(body_parts.to_h.fetch("hero")).must_equal "named\x00\xff upload".b
+      _(signed_params.fetch("fields")).must_equal fields
+      _(signed_params).wont_include "uploads"
+      _(assembly.to_hash).wont_include :uploads
+      _(file.closed?).must_equal false
+      _(uploads[:hero]).must_equal file
+    end
+  end
+
+  it "allows per-call uploads and fields to override constructor defaults" do
+    defaults = {unused: StringIO.new("unused upload")}
+    assembly = @transloadit.assembly(uploads: defaults, fields: {unused: true})
+    upload = StringIO.new("named upload")
+    positional = StringIO.new("positional upload")
+
+    assembly.create!(positional, uploads: {"hero" => upload}, fields: @fields)
+
+    _(body_parts.map(&:first)).must_equal %w[params signature hero file_0]
+    _(body_parts.to_h.fetch("hero")).must_equal "named upload"
+    _(body_parts.to_h.fetch("file_0")).must_equal "positional upload"
+    _(signed_params.fetch("fields")).must_equal @fields
+    _(signed_params).wont_include "uploads"
+    _(upload.closed?).must_equal false
+    _(positional.closed?).must_equal false
+    _(defaults.keys).must_equal [:unused]
+  end
+
+  it "preserves legacy mixed fields while deprecating only their upload entries" do
+    upload = StringIO.new("legacy upload")
+    fields = @fields.merge("hero" => upload).freeze
+    assembly = @transloadit.assembly(fields: fields)
+
+    _, warning = capture_io { assembly.create! }
+
+    _(warning).must_match(/fields.*deprecated.*uploads/)
+    _(body_parts.map(&:first)).must_equal %w[params signature hero]
+    _(body_parts.to_h.fetch("hero")).must_equal "legacy upload"
+    _(signed_params.fetch("fields")).must_equal @fields
+    _(assembly.to_hash[:fields]).must_equal @fields
+    _(JSON.parse(assembly.to_json).fetch("fields")).must_equal @fields
+    _(fields.fetch("hero")).must_equal upload
+  end
+
+  it "preserves content's create! fields override for legacy named Files" do
+    File.open("lib/transloadit/version.rb", "rb") do |file|
+      assembly = @transloadit.assembly(fields: {file: file})
+
+      _, warning = capture_io { assembly.create!(fields: @fields) }
+
+      _(warning).must_include "Passing upload IOs in fields is deprecated"
+      _(body_parts.map(&:first)).must_equal %w[params signature file]
+      _(body_parts.to_h.fetch("file")).must_equal File.binread(file.path)
+      _(signed_params.fetch("fields")).must_equal @fields
+      _(file.closed?).must_equal false
+    end
+  end
+
+  it "separates deprecated uploads in per-call fields from custom fields" do
+    fields = @fields.merge("hero" => StringIO.new("per-call legacy upload"))
+
+    _, warning = capture_io { @transloadit.assembly.create!(fields: fields) }
+
+    _(warning).must_include "Passing upload IOs in fields is deprecated"
+    _(body_parts.map(&:first)).must_equal %w[params signature hero]
+    _(body_parts.to_h.fetch("hero")).must_equal "per-call legacy upload"
+    _(signed_params.fetch("fields")).must_equal @fields
+  end
+
+  it "keeps positional file_N names and priority over legacy upload names" do
+    assembly = @transloadit.assembly(fields: {"file_0" => StringIO.new("legacy")})
+
+    capture_io { assembly.create!(StringIO.new("first"), StringIO.new("second")) }
+
+    _(body_parts.map(&:first)).must_equal %w[params signature file_0 file_1]
+    _(body_parts.to_h.fetch("file_0")).must_equal "first"
+    _(body_parts.to_h.fetch("file_1")).must_equal "second"
+    _(signed_params.fetch("fields")).must_equal({})
+  end
+
+  it "lets explicit uploads replace deprecated entries with the same wire name" do
+    assembly = @transloadit.assembly(fields: {hero: StringIO.new("legacy")})
+
+    capture_io { assembly.create!(uploads: {"hero" => StringIO.new("explicit")}) }
+
+    _(body_parts.map(&:first)).must_equal %w[params signature hero]
+    _(body_parts.to_h.fetch("hero")).must_equal "explicit"
+    _(signed_params.fetch("fields")).must_equal({})
+  end
+
+  it "supports typed per-call fields and an explicitly empty upload override" do
+    assembly = @transloadit.assembly(uploads: {hero: StringIO.new("unused")})
+
+    assembly.create!(uploads: {}, fields: @fields)
+
+    _(body_parts.map(&:first)).must_equal %w[params signature]
+    _(signed_params.fetch("fields")).must_equal @fields
+    _(signed_params).wont_include "uploads"
+  end
+
+  it "preserves deprecated fields uploads when only the uploads option is cleared" do
+    assembly = @transloadit.assembly(
+      uploads: {unused: StringIO.new("unused")},
+      fields: {hero: StringIO.new("legacy upload")}
+    )
+
+    capture_io { assembly.create!(uploads: {}) }
+
+    _(body_parts.map(&:first)).must_equal %w[params signature hero]
+    _(body_parts.to_h.fetch("hero")).must_equal "legacy upload"
+    _(signed_params.fetch("fields")).must_equal({})
+  end
+
+  it "rejects non-IO named uploads before making a request" do
+    error = assert_raises ArgumentError do
+      @transloadit.assembly(uploads: {hero: "path/to/file.jpg"}).create!
+    end
+
+    _(error.message).must_include "IO"
+    _(@requests).must_be_empty
+  end
+
+  it "rejects upload names reserved for params and signature" do
+    [:params, "signature"].each do |name|
+      error = assert_raises ArgumentError do
+        @transloadit.assembly.create!(uploads: {name => StringIO.new("upload")})
+      end
+
+      _(error.message).must_include "reserved"
+    end
+    _(@requests).must_be_empty
+  end
+
+  it "keeps reserved names safe when they are custom fields" do
+    fields = {"params" => {"count" => 2}, "signature" => false}
+
+    @transloadit.assembly(fields: fields).create!
+
+    _(body_parts.map(&:first)).must_equal %w[params signature]
+    _(signed_params.fetch("fields")).must_equal fields
+  end
+
+  it "retries named uploads with the same bytes and signed custom fields" do
+    rate_limit_first_request
+    upload = StringIO.new("retry upload")
+
+    capture_io do
+      response = @transloadit.assembly(uploads: {hero: upload}, fields: @fields).create!
+      _(response.completed?).must_equal true
+    end
+
+    _(@requests.length).must_equal 2
+    @requests.each do |request|
+      _(body_parts(request).map(&:first)).must_equal %w[params signature hero]
+      _(body_parts(request).to_h.fetch("hero")).must_equal "retry upload"
+      _(signed_params(request).fetch("fields")).must_equal @fields
+    end
+    _(upload.closed?).must_equal false
+  end
+
+  it "retries in-memory uploads from their original position" do
+    rate_limit_first_request
+    upload = StringIO.new("header:retry upload")
+    upload.pos = "header:".length
+
+    capture_io { @transloadit.assembly(uploads: {hero: upload}, fields: @fields).create! }
+
+    _(@requests.length).must_equal 2
+    @requests.each do |request|
+      _(body_parts(request).to_h.fetch("hero")).must_equal "retry upload"
+      _(signed_params(request).fetch("fields")).must_equal @fields
+    end
+  end
+
+  it "fails clearly instead of retrying a consumed non-seekable upload" do
+    rate_limit_first_request
+    upload = StringIO.new("streamed upload")
+    [:pos, :seek, :rewind].each do |method|
+      upload.define_singleton_method(method) { |*| raise Errno::ESPIPE }
+    end
+
+    error = assert_raises IOError do
+      capture_io { @transloadit.assembly(uploads: {hero: upload}).create! }
+    end
+
+    _(error.message).must_include "Cannot retry"
+    _(@requests.length).must_equal 1
+    _(body_parts.to_h.fetch("hero")).must_equal "streamed upload"
+    _(upload.closed?).must_equal false
+  end
+
+  def rate_limit_first_request
+    stub_request(:post, "https://api2.transloadit.com/assemblies").to_return do |request|
+      @requests << request
+      body = if @requests.length == 1
+        '{"error":"RATE_LIMIT_REACHED","info":{"retryIn":0}}'
+      else
+        '{"ok":"ASSEMBLY_COMPLETED"}'
+      end
+      {body: body}
+    end
+  end
+
+  def body_parts(request = @requests.last)
+    content_type = request.headers.fetch("Content-Type")
+    return URI.decode_www_form(request.body) unless content_type.start_with?("multipart/form-data")
+
+    boundary = content_type.split("boundary=", 2).last
+    request.body.b.split("--#{boundary}".b).filter_map do |part|
+      headers, value = part.split("\r\n\r\n", 2)
+      next unless value
+
+      [headers[/name="([^"]+)"/, 1], value.delete_suffix("\r\n")]
+    end
+  end
+
+  def signed_params(request = @requests.last)
+    parts = body_parts(request).to_h
+    json = parts.fetch("params")
+    signature = OpenSSL::HMAC.hexdigest("sha384", "secret", json)
+    _(parts.fetch("signature")).must_equal "sha384:#{signature}"
+    JSON.parse(json)
+  end
+end

data/test/unit/transloadit/test_request.rb

@@ -83,25 +83,6 @@ describe Transloadit::Request do
     lib_path = File.expand_path("../../../lib", __dir__)
 
     Dir.mktmpdir do |stub_dir|
-      File.write(File.join(stub_dir, "rest-client.rb"), <<~RUBY)
-        module RestClient
-          class Response; end
-
-          class Resource
-            def initialize(*); end
-            def [](*); self; end
-            def get(*); Response.new; end
-            def post(*); Response.new; end
-            def put(*); Response.new; end
-            def delete(*); Response.new; end
-          end
-
-          module Exceptions
-            class OpenTimeout < StandardError; end
-          end
-        end
-      RUBY
-
       File.write(File.join(stub_dir, "multi_json.rb"), <<~RUBY)
         require "json"
 
@@ -123,6 +104,7 @@ describe Transloadit::Request do
         begin
           require "transloadit/request"
           Transloadit::Request.new("/")
+          raise "RestClient was loaded" if defined?(RestClient)
         rescue StandardError => e
           warn e.full_message
           exit 1

data/test/unit/transloadit/test_response.rb

@@ -3,17 +3,36 @@ require "test_helper"
 describe Transloadit::Response do
   request_uri = "https://api2.jane.transloadit.com/assemblies/76fe5df1c93a0a530f3e583805cf98b4"
 
-  it "must allow delegate initialization" do
-    response = Transloadit::Response.new("test")
+  it "must allow initialization" do
+    response = Transloadit::Response.new(body: "{}", headers: {}, status: 200)
     _(response.class).must_equal Transloadit::Response
   end
 
+  it "must replace body, headers, and status together" do
+    response = Transloadit::Response.new(
+      body: '{"ok":"ASSEMBLY_EXECUTING"}',
+      headers: {"X-Request-Id" => "old-request"},
+      status: 202
+    )
+    replacement = Transloadit::Response.new(
+      body: '{"ok":"ASSEMBLY_COMPLETED"}',
+      headers: {"X-Request-Id" => "new-request"},
+      status: 200
+    )
+
+    returned = response.replace(replacement)
+
+    _(returned).must_be_same_as response
+    _(response["ok"]).must_equal "ASSEMBLY_COMPLETED"
+    _(response.headers).must_equal x_request_id: "new-request"
+    _(response.code).must_equal 200
+    _(response.status).must_equal 200
+  end
+
   describe "when initialized" do
     before do
       VCR.use_cassette "fetch_assembly_ok" do
-        @response = Transloadit::Response.new(
-          RestClient::Resource.new(request_uri).get
-        )
+        @response = Transloadit::Request.new(request_uri).get
       end
     end
 
@@ -41,9 +60,7 @@ describe Transloadit::Response do
   describe "when extended as an assembly" do
     before do
       VCR.use_cassette "fetch_assembly_ok" do
-        @response = Transloadit::Response.new(
-          RestClient::Resource.new(request_uri).get
-        ).extend!(Transloadit::Response::Assembly)
+        @response = Transloadit::Request.new(request_uri).get.extend!(Transloadit::Response::Assembly)
       end
     end
 
@@ -56,9 +73,6 @@ describe Transloadit::Response do
     # TODO: can this be tested better?
     it "must allow reloading the assembly" do
       VCR.use_cassette "fetch_assembly_ok", allow_playback_repeats: true do
-        _(@response.send(:__getobj__))
-          .wont_be_same_as @response.reload!.send(:__getobj__)
-
         _(@response.object_id)
           .must_equal @response.reload!.object_id
       end
@@ -79,9 +93,7 @@ describe Transloadit::Response do
   describe "long-running assembly" do
     before do
       VCR.use_cassette "fetch_assembly_executing" do
-        @response = Transloadit::Response.new(
-          RestClient::Resource.new(request_uri).get
-        ).extend!(Transloadit::Response::Assembly)
+        @response = Transloadit::Request.new(request_uri).get.extend!(Transloadit::Response::Assembly)
       end
     end
 
@@ -109,9 +121,7 @@ describe Transloadit::Response do
   describe "statuses" do
     it "must allow checking for upload" do
       VCR.use_cassette "fetch_assembly_uploading" do
-        @response = Transloadit::Response.new(
-          RestClient::Resource.new(request_uri).get
-        ).extend!(Transloadit::Response::Assembly)
+        @response = Transloadit::Request.new(request_uri).get.extend!(Transloadit::Response::Assembly)
       end
 
       _(@response.finished?).must_equal false
@@ -121,9 +131,7 @@ describe Transloadit::Response do
 
     it "must allow to check for executing" do
       VCR.use_cassette "fetch_assembly_executing" do
-        @response = Transloadit::Response.new(
-          RestClient::Resource.new(request_uri).get
-        ).extend!(Transloadit::Response::Assembly)
+        @response = Transloadit::Request.new(request_uri).get.extend!(Transloadit::Response::Assembly)
       end
 
       _(@response.finished?).must_equal false
@@ -133,11 +141,9 @@ describe Transloadit::Response do
 
     it "must allow to check for replaying" do
       VCR.use_cassette "replay_assembly" do
-        @response = Transloadit::Response.new(
-          RestClient::Resource.new(
-            "https://api2.transloadit.com/assemblies/55c965a063a311e6ba2d379ef10b28f7/replay"
-          ).post({})
-        ).extend!(Transloadit::Response::Assembly)
+        @response = Transloadit::Request.new(
+          "https://api2.transloadit.com/assemblies/55c965a063a311e6ba2d379ef10b28f7/replay"
+        ).post.extend!(Transloadit::Response::Assembly)
       end
 
       _(@response.finished?).must_equal false
@@ -147,9 +153,7 @@ describe Transloadit::Response do
 
     it "must allow to check for aborted" do
       VCR.use_cassette "fetch_assembly_aborted" do
-        @response = Transloadit::Response.new(
-          RestClient::Resource.new(request_uri).get
-        ).extend!(Transloadit::Response::Assembly)
+        @response = Transloadit::Request.new(request_uri).get.extend!(Transloadit::Response::Assembly)
       end
 
       _(@response.finished?).must_equal true
@@ -158,9 +162,7 @@ describe Transloadit::Response do
 
     it "must allow to check for errors" do
       VCR.use_cassette "fetch_assembly_errors" do
-        @response = Transloadit::Response.new(
-          RestClient::Resource.new(request_uri).get
-        ).extend!(Transloadit::Response::Assembly)
+        @response = Transloadit::Request.new(request_uri).get.extend!(Transloadit::Response::Assembly)
       end
 
       _(@response.error?).must_equal true

data/test/unit/transloadit/test_transport_compatibility.rb

@@ -0,0 +1,222 @@
+require "test_helper"
+require "stringio"
+require "tempfile"
+
+describe "Faraday transport compatibility" do
+  include WebMock::API
+
+  before do
+    WebMock.reset!
+  end
+
+  after do
+    WebMock.reset!
+  end
+
+  it "sends signed GET parameters and the client header to a selected host" do
+    endpoint = "https://api2.example.test/assemblies/assembly-id"
+    stub_request(:get, /\A#{Regexp.escape(endpoint)}/)
+      .to_return(status: 200, body: '{"ok":"ASSEMBLY_COMPLETED"}')
+
+    response = Transloadit::Request.new(endpoint, "secret").get(wait: true)
+
+    _(response["ok"]).must_equal "ASSEMBLY_COMPLETED"
+    assert_requested(:get, /\A#{Regexp.escape(endpoint)}/) do |request|
+      query = Addressable::URI.parse(request.uri.to_s).query_values
+      _(MultiJson.load(query.fetch("params"))).must_equal "wait" => true
+      _(query.fetch("signature")).must_match(/\Asha384:[0-9a-f]{96}\z/)
+      _(request.headers.fetch("Transloadit-Client")).must_equal "ruby-sdk:#{Transloadit::VERSION}"
+    end
+  end
+
+  it "form-encodes signed POST payloads" do
+    endpoint = "https://api2.transloadit.com/assemblies"
+    stub_request(:post, endpoint)
+      .to_return(status: 200, body: '{"ok":"ASSEMBLY_COMPLETED"}')
+
+    Transloadit::Request.new("/assemblies", "secret").post(params: {template_id: "template-id"})
+
+    assert_requested(:post, endpoint) do |request|
+      form = URI.decode_www_form(request.body).to_h
+      _(MultiJson.load(form.fetch("params"))).must_equal "template_id" => "template-id"
+      _(form.fetch("signature")).must_match(/\Asha384:[0-9a-f]{96}\z/)
+      _(request.headers.fetch("Content-Type")).must_match(/\Aapplication\/x-www-form-urlencoded/)
+    end
+  end
+
+  it "form-encodes signed PUT payloads" do
+    endpoint = "https://api2.transloadit.com/templates/template-id"
+    stub_request(:put, endpoint)
+      .to_return(status: 200, body: '{"ok":"TEMPLATE_UPDATED"}')
+
+    Transloadit::Request.new("/templates/template-id", "secret").put(params: {name: "Updated"})
+
+    assert_requested(:put, endpoint) do |request|
+      form = URI.decode_www_form(request.body).to_h
+      _(MultiJson.load(form.fetch("params"))).must_equal "name" => "Updated"
+      _(form.fetch("signature")).must_match(/\Asha384:[0-9a-f]{96}\z/)
+    end
+  end
+
+  it "form-encodes signed DELETE payloads" do
+    endpoint = "https://api2.transloadit.com/templates/template-id"
+    stub_request(:delete, endpoint)
+      .to_return(status: 200, body: '{"ok":"TEMPLATE_DELETED"}')
+
+    Transloadit::Request.new("/templates/template-id", "secret").delete(params: {reason: "cleanup"})
+
+    assert_requested(:delete, endpoint) do |request|
+      form = URI.decode_www_form(request.body).to_h
+      _(MultiJson.load(form.fetch("params"))).must_equal "reason" => "cleanup"
+      _(form.fetch("signature")).must_match(/\Asha384:[0-9a-f]{96}\z/)
+    end
+  end
+
+  it "returns non-success responses with SDK-owned status, headers, and body access" do
+    endpoint = "https://api2.example.test/assemblies/missing"
+    stub_request(:get, endpoint).to_return(
+      status: 422,
+      headers: {"Retry-After" => "5", "X-Request-Id" => "request-id"},
+      body: '{"error":"ASSEMBLY_NOT_FOUND"}'
+    )
+
+    response = Transloadit::Request.new(endpoint).get
+
+    _(response).must_be_kind_of Transloadit::Response
+    _(response).wont_be_kind_of Faraday::Response
+    _(response.code).must_equal 422
+    _(response.status).must_equal 422
+    _(response.headers).must_equal retry_after: "5", x_request_id: "request-id"
+    _(response["error"]).must_equal "ASSEMBLY_NOT_FOUND"
+  end
+
+  it "returns redirects without following them" do
+    endpoint = "https://api2.example.test/assemblies"
+    redirect = "https://uploads.example.test/assemblies"
+    stub_request(:post, endpoint).to_return(
+      status: 302,
+      headers: {"Location" => redirect},
+      body: "{}"
+    )
+
+    response = Transloadit::Request.new(endpoint).post
+
+    _(response.code).must_equal 302
+    _(response.headers[:location]).must_equal redirect
+    assert_not_requested(:post, redirect)
+  end
+
+  it "uploads multiple files after params and signature without closing caller-owned files" do
+    endpoint = "https://api2.transloadit.com/assemblies"
+    stub_request(:post, endpoint)
+      .to_return(status: 200, body: '{"ok":"ASSEMBLY_COMPLETED"}')
+
+    Tempfile.create(["first", ".txt"]) do |first|
+      Tempfile.create(["second", ".json"]) do |second|
+        first.write("first upload")
+        first.flush
+        second.write('{"second":"upload"}')
+        second.flush
+
+        Transloadit::Request.new("/assemblies", "secret").post(
+          params: {steps: {}},
+          file_0: first,
+          file_1: second
+        )
+
+        _(first.closed?).must_equal false
+        _(second.closed?).must_equal false
+      end
+    end
+
+    assert_requested(:post, endpoint) do |request|
+      params_position = request.body.index('name="params"')
+      signature_position = request.body.index('name="signature"')
+      first_position = request.body.index('name="file_0"')
+      second_position = request.body.index('name="file_1"')
+
+      _(request.headers.fetch("Content-Type")).must_match(/\Amultipart\/form-data; boundary=/)
+      _(params_position).wont_be_nil
+      _(signature_position).wont_be_nil
+      _(first_position).wont_be_nil
+      _(second_position).wont_be_nil
+      _(params_position < signature_position).must_equal true
+      _(signature_position < first_position).must_equal true
+      _(first_position < second_position).must_equal true
+      _(request.body).must_include "Content-Type: text/plain"
+      _(request.body).must_include "Content-Type: application/json"
+      _(request.body).must_include "first upload"
+      _(request.body).must_include '{"second":"upload"}'
+    end
+  end
+
+  it "preserves filename and content type from Rails-style uploaded files" do
+    endpoint = "https://api2.transloadit.com/assemblies"
+    stub_request(:post, endpoint)
+      .to_return(status: 200, body: '{"ok":"ASSEMBLY_COMPLETED"}')
+
+    Tempfile.create(["rails-upload", ".bin"]) do |file|
+      file.write("csv contents")
+      file.flush
+      upload = Object.new
+      upload.define_singleton_method(:read) { |*arguments| file.read(*arguments) }
+      upload.define_singleton_method(:path) { file.path }
+      upload.define_singleton_method(:original_filename) { "report.csv" }
+      upload.define_singleton_method(:content_type) { "text/csv" }
+
+      Transloadit::Request.new("/assemblies").post(params: {steps: {}}, file_0: upload)
+    end
+
+    assert_requested(:post, endpoint) do |request|
+      _(request.body).must_include 'filename="report.csv"'
+      _(request.body).must_include "Content-Type: text/csv"
+      _(request.body).must_include "csv contents"
+    end
+  end
+
+  it "uses safe metadata defaults for in-memory uploads" do
+    endpoint = "https://api2.transloadit.com/assemblies"
+    stub_request(:post, endpoint)
+      .to_return(status: 200, body: '{"ok":"ASSEMBLY_COMPLETED"}')
+    upload = StringIO.new("memory upload")
+
+    Transloadit::Request.new("/assemblies").post(params: {steps: {}}, file_0: upload)
+
+    _(upload.closed?).must_equal false
+    assert_requested(:post, endpoint) do |request|
+      _(request.body).must_include 'filename="upload"'
+      _(request.body).must_include "Content-Type: application/octet-stream"
+      _(request.body).must_include "memory upload"
+    end
+  end
+
+  it "uses the binary content type when a file extension is unknown" do
+    endpoint = "https://api2.transloadit.com/assemblies"
+    stub_request(:post, endpoint)
+      .to_return(status: 200, body: '{"ok":"ASSEMBLY_COMPLETED"}')
+
+    Tempfile.create(["upload", ".transloadit-unknown"]) do |upload|
+      upload.write("unknown upload")
+      upload.flush
+
+      Transloadit::Request.new("/assemblies").post(params: {steps: {}}, file_0: upload)
+    end
+
+    assert_requested(:post, endpoint) do |request|
+      _(request.body).must_include "Content-Type: application/octet-stream"
+      _(request.body).must_include "unknown upload"
+    end
+  end
+
+  it "wraps adapter failures and retains the original error as the cause" do
+    endpoint = "https://api2.example.test/assemblies/assembly-id"
+    stub_request(:get, endpoint).to_timeout
+
+    error = assert_raises Transloadit::Exception::RequestFailed do
+      Transloadit::Request.new(endpoint).get
+    end
+
+    _(error.message).must_equal "Transloadit request failed"
+    _(error.cause).must_be_kind_of Faraday::ConnectionFailed
+  end
+end

data/transloadit.gemspec

@@ -16,21 +16,22 @@ Gem::Specification.new do |gem|
   gem.description = "The transloadit gem allows you to automate uploading files through the Transloadit REST API"
 
   gem.required_rubygems_version = ">= 2.2.0"
-  gem.required_ruby_version = ">= 3.0.0"
+  gem.required_ruby_version = ">= 3.1.0"
 
   gem.files = `git ls-files`.split("\n")
   gem.require_paths = %w[lib]
 
-  gem.add_dependency "rest-client"
+  gem.add_dependency "faraday", ">= 2.0", "< 3.0"
+  gem.add_dependency "faraday-multipart", "~> 1.0"
   gem.add_dependency "multi_json"
   gem.add_dependency "mime-types"
 
   gem.add_development_dependency "rake"
   gem.add_development_dependency "minitest"
   gem.add_development_dependency "simplecov"
-  gem.add_development_dependency "standard"
+  gem.add_development_dependency "standard", ">= 1.54"
 
-  gem.add_development_dependency "vcr"
+  gem.add_development_dependency "vcr", ">= 6.4"
   gem.add_development_dependency "webmock"
 
   gem.add_development_dependency "yard"