files.com 1.1.768 → 1.1.769

data/lib/files.com.rb

@@ -7,6 +7,7 @@ require "json"
 require "logger"
 require "openssl"
 require "rbconfig"
+require "rbconfig/sizeof"
 require "securerandom"
 require "set"
 require "socket"
@@ -201,7 +202,8 @@ module Files
   @read_timeout = 60
 
   class << self
-    attr_accessor :api_key, :base_url, :default_headers, :initial_network_retry_delay, :language, :max_network_retry_delay, :open_timeout, :read_timeout, :proxy, :session_id, :workspace_id
+    attr_accessor :api_key, :base_url, :default_headers, :initial_network_retry_delay, :language, :max_network_retry_delay, :proxy, :session_id, :workspace_id
+    attr_reader :open_timeout, :read_timeout
   end
 
   # map to the same values as the standard library's logger
@@ -259,6 +261,26 @@ module Files
     @max_network_retries = val.to_i
   end
 
+  # Net::HTTP hands each timeout to Ruby to wait on. CRuby converts it to the
+  # platform's time_t and raises RangeError for more seconds than that holds,
+  # partway through a request it may already have sent. JRuby takes any number.
+  MAX_TIMEOUT = RUBY_PLATFORM == "java" ? Float::INFINITY : (2**((8 * RbConfig::SIZEOF["time_t"]) - 1)) - 1
+  private_constant :MAX_TIMEOUT
+
+  def self.open_timeout=(seconds)
+    @open_timeout = checked_timeout("open_timeout", seconds)
+  end
+
+  def self.read_timeout=(seconds)
+    @read_timeout = checked_timeout("read_timeout", seconds)
+  end
+
+  private_class_method def self.checked_timeout(name, seconds)
+    return seconds if seconds.nil? || (seconds.is_a?(Numeric) && seconds.real? && seconds >= 0 && seconds <= MAX_TIMEOUT)
+
+    raise ArgumentError, "#{name} should be nil or a number of seconds from 0 to #{MAX_TIMEOUT}"
+  end
+
   def self.session=(session)
     session.save unless session.id
     self.session_id = session.id

data/spec/language_spec.rb

@@ -9,20 +9,30 @@ RSpec.describe "Language setting" do
     Files.language = old_language
   end
 
-  let(:client) { Files::ApiClient.new }
+  describe "request headers" do
+    let(:client) { Files::ApiClient.new }
 
-  it "sends the configured language as the Accept-Language header" do
-    Files.language = "es"
+    it "sends the configured language as the Accept-Language header" do
+      Files.language = "es"
 
-    headers = client.send(:request_headers, "api-key", nil, :get, nil)
+      headers = client.send(:request_headers, "api-key", nil, :get, nil)
 
-    expect(Files.language).to eq("es")
-    expect(headers["Accept-Language"]).to eq("es")
-  end
+      expect(Files.language).to eq("es")
+      expect(headers["Accept-Language"]).to eq("es")
+    end
+
+    it "omits the Accept-Language header when unset" do
+      headers = client.send(:request_headers, "api-key", nil, :get, nil)
 
-  it "omits the Accept-Language header when unset" do
-    headers = client.send(:request_headers, "api-key", nil, :get, nil)
+      expect(headers).not_to have_key("Accept-Language")
+    end
+  end
 
-    expect(headers).not_to have_key("Accept-Language")
+  describe "API errors", :with_test_folder do
+    it "gets API errors in the language it sets" do
+      Files.language = "es"
+      expect(Files.language).to eq("es")
+      expect { Files::File.find(test_folder.join("read.txt").to_s, {}, options) }.to raise_error(Files::NotFoundError, a_string_including("No se ha encontrado"))
+    end
   end
 end

data/spec/lib/api_client_spec.rb

@@ -1,26 +1,32 @@
 require "spec_helper"
+require_relative "../support/stubbed_api"
 
 RSpec.describe Files::ApiClient do
+  include StubbedApi
+
   let(:subject) { described_class.new }
 
   describe "signed transfer privacy" do
     it "keeps API error types without echoing a transfer URL" do
       url = "https://transfer.example.test/private-part?signature=secret"
-      output = StringIO.new
       original_logger = Files.logger
-      Files.logger = Logger.new(output, level: Logger::INFO)
-      connection = Faraday.new do |builder|
-        builder.response :raise_error
-        builder.adapter :test do |stub|
-          stub.put(url) { [ 404, {}, { type: "not-found", error: url }.to_json ] }
+
+      { { type: "not-found", error: url } => Files::NotFoundError, { error: url } => Files::APIError }.each do |body, error_class|
+        output = StringIO.new
+        Files.logger = Logger.new(output, level: Logger::INFO)
+        connection = Faraday.new do |builder|
+          builder.response :raise_error
+          builder.adapter :test do |stub|
+            stub.put(url) { [ 404, {}, body.to_json ] }
+          end
         end
-      end
 
-      expect { described_class.new(connection).remote_request(:put, url, {}, "part") }.to raise_error(Files::NotFoundError) { |error|
-        expect(error.http_status).to eq(404)
-        expect(error.full_message).not_to include(url, "private-part", "secret")
-      }
-      expect(output.string).not_to include(url, "private-part", "secret")
+        expect { described_class.new(connection).remote_request(:put, url, {}, "part") }.to raise_error(error_class) { |error|
+          expect(error.http_status).to eq(404)
+          expect(error.full_message).not_to include(url, "private-part", "secret")
+        }
+        expect(output.string).not_to include(url, "private-part", "secret")
+      end
     ensure
       Files.logger = original_logger
     end
@@ -64,6 +70,69 @@ RSpec.describe Files::ApiClient do
     end
   end
 
+  describe "signed URLs quoted by API responses" do
+    signed_url = "https://transfer.example.test/object?X-Amz-Signature=PRIVATE-SENTINEL"
+    password_url = "https://user:private'PRIVATE-SENTINEL@bucket.example/key.txt?token=PRIVATE-SENTINEL#PRIVATE-SENTINEL"
+    path_url = "https://bucket.example/O'Brien/key.txt?token=PRIVATE-SENTINEL#PRIVATE-SENTINEL"
+    long_scheme = "a" * 32
+
+    around do |example|
+      original = [ Files.logger, Files.max_network_retries ]
+      Files.max_network_retries = 0
+      example.run
+    ensure
+      Files.logger, Files.max_network_retries = original
+    end
+
+    # The error File.find raises for this response, and what the logger wrote.
+    def find_file_answering(status, body, log_level)
+      output = StringIO.new
+      Files.logger = Logger.new(output, level: log_level)
+      client = stubbed_api_client do |stub|
+        stub.get("/api/rest/v1/file_actions/metadata/object") { [ status, { "Content-Type" => "application/json", "X-Request-Id" => "request-1" }, body ] }
+      end
+      Files::File.find("object", {}, api_key: "key", client: client)
+      raise "the request succeeded"
+    rescue Files::Error => e
+      [ e, output.string ]
+    end
+
+    {
+      "an error object without a type" => [ 422, { error: "Could not reach #{signed_url}" }.to_json, Files::APIError, "Could not reach https://transfer.example.test/object?[redacted]" ],
+      "a typed error object" => [ 422, { type: "not-found", error: "Could not reach #{signed_url}" }.to_json, Files::NotFoundError, "Could not reach https://transfer.example.test/object?[redacted]" ],
+      "a successful response that is not JSON" => [ 200, "{\"download_uri\":\"#{signed_url}", Files::APIConnectionError, /not valid JSON \(HTTP response code was 200\)/ ],
+      "a URL with an apostrophe in its password" => [ 422, { error: "Could not reach #{password_url}" }.to_json, Files::APIError, "Could not reach https://[redacted]@bucket.example/key.txt?[redacted]" ],
+      "a URL with an apostrophe in its path" => [ 422, { type: "not-found", error: "Could not reach #{path_url}" }.to_json, Files::NotFoundError, "Could not reach https://bucket.example/O'Brien/key.txt?[redacted]" ],
+      "a URL quoted with apostrophes" => [ 422, { error: "Could not reach '#{path_url}'." }.to_json, Files::APIError, "Could not reach 'https://bucket.example/O'Brien/key.txt?[redacted]'." ],
+      "a URL with a 32-character scheme" => [ 422, { error: "Could not reach #{long_scheme}://user:PRIVATE-SENTINEL@bucket.example/key?token=PRIVATE-SENTINEL#PRIVATE-SENTINEL" }.to_json, Files::APIError, "Could not reach #{long_scheme}://[redacted]@bucket.example/key?[redacted]" ],
+      "a URL with an empty authority and a query" => [ 422, { type: "not-found", error: "Could not reach custom://?token=PRIVATE-SENTINEL#PRIVATE-SENTINEL" }.to_json, Files::NotFoundError, "Could not reach custom://?[redacted]" ],
+      "a URL with an empty authority and only a fragment" => [ 422, { error: "Could not reach custom://#PRIVATE-SENTINEL" }.to_json, Files::APIError, "Could not reach custom://?[redacted]" ],
+      "a quoted URL with nothing after its scheme" => [ 422, { type: "not-found", error: "Could not open 'file://'." }.to_json, Files::NotFoundError, "Could not open 'file://'." ],
+      "a URL with an empty authority and an @ in its path" => [ 422, { error: "Could not open file:///tmp@part" }.to_json, Files::APIError, "Could not open file:///tmp@part" ],
+      "adjacent quoted URLs" => [ 422, { type: "not-found", error: "Tried 'https://a.example/x','https://user:PRIVATE-SENTINEL@b.example/y';'https://user:PRIVATE-SENTINEL@c.example/z?next=https://d.example/PRIVATE-SENTINEL'." }.to_json, Files::NotFoundError, "Tried 'https://a.example/x','https://[redacted]@b.example/y';'https://[redacted]@c.example/z?[redacted]'." ],
+    }.each do |description, (status, body, error_class, message)|
+      it "keeps the credentials out of the error text, its causes and INFO logs for #{description}" do
+        error, info_log = find_file_answering(status, body, Logger::INFO)
+
+        expect(error).to be_an_instance_of(error_class)
+        expect(error.message).to(message.is_a?(Regexp) ? match(message) : eq(message))
+        expect(error.http_status).to eq(status)
+        expect(error.http_headers["x-request-id"]).to eq("request-1")
+        expect(error.http_body).to eq(body)
+        chain = [ error ]
+        chain << chain.last.cause while chain.last.cause
+        expect(chain.map { |raised| raised.full_message(highlight: false) }.join).not_to include("PRIVATE-SENTINEL")
+        expect(info_log).not_to include("PRIVATE-SENTINEL")
+      end
+    end
+
+    it "still writes the unredacted response to the DEBUG log" do
+      _error, debug_log = find_file_answering(422, { error: "Could not reach #{signed_url}" }.to_json, Logger::DEBUG)
+
+      expect(debug_log).to include(signed_url)
+    end
+  end
+
   describe "#execute_request_with_rescues" do
     let(:context) { double('context', method: 'some method', path: 'some path') }
 
@@ -72,25 +141,27 @@ RSpec.describe Files::ApiClient do
         allow(subject).to receive(:log_request).and_raise(Faraday::ServerError.new('', mock_response))
       end
 
-      it 'retries with sleeps and raises general api connection error' do
+      it 'retries with sleeps and then raises' do
         expect(subject).to receive(:sleep).with(0.5).ordered
         expect(subject).to receive(:sleep).with(be_between(0.5, 1)).ordered
         expect(subject).to receive(:sleep).with(be_between(1, 2)).ordered
         expect {
           subject.execute_request_with_rescues(1, context) { 'empty block' }
-        }.to raise_error(Files::APIConnectionError, error_message)
+        }.to raise_error(error_class, error_message)
       end
     end
 
-    context 'when response is a valid json' do
+    context 'when response is a Files.com error object' do
       it_behaves_like 'a server error handler' do
-        let(:error_message) { "Could not connect to Files.com at URL 1. Please check your internet connection and try again. If this problem persists, you should check Files.com's service status at https://status.files.com, or contact your primary account representative. Request was retried 3 times.\n\n(Network error: {\"error\":\"Server Error\"})" }
+        let(:error_class) { Files::APIError }
+        let(:error_message) { "Server Error" }
         let(:mock_response) { { status: 502, headers: {}, body: { error: "Server Error" }.to_json } }
       end
     end
 
     context 'when response is html' do
       it_behaves_like 'a server error handler' do
+        let(:error_class) { Files::APIConnectionError }
         let(:mock_response) {
           {
             status: 502,
@@ -149,11 +220,11 @@ RSpec.describe Files::ApiClient do
       end
     end
 
-    it "throws generic bad request error when no type" do
+    it "throws generic api error when no type" do
       allow(subject).to receive(:log_request).and_raise(Faraday::BadRequestError.new('', mock_response_without_type))
       expect {
         subject.execute_request_with_rescues(1, context) { 'empty block' }
-      }.to raise_error(Files::APIConnectionError)
+      }.to raise_error(Files::APIError, "Bad Request")
     end
 
     it "throws generic bad request error when no body at all" do
@@ -178,4 +249,88 @@ RSpec.describe Files::ApiClient do
       end
     end
   end
+
+  describe "failed API responses" do
+    around do |example|
+      original = [ Files.logger, Files.max_network_retries ]
+      Files.logger = Logger.new(IO::NULL)
+      Files.max_network_retries = 0
+      example.run
+    ensure
+      Files.logger, Files.max_network_retries = original
+    end
+
+    def find_workspace_failing_with(status, body)
+      client = stubbed_api_client do |stub|
+        stub.get("/api/rest/v1/workspaces/1") { [ status, { "Content-Type" => "application/json", "X-Request-Id" => "request-1" }, body ] }
+      end
+      Files::Workspace.find(1, {}, api_key: "key", client: client)
+    end
+
+    # Each error object and the error it raises, whatever the status.
+    error_objects = {
+      "a known type" => [ { error: "sentinel", type: "not-found" }, Files::NotFoundError ],
+      "an unknown type" => [ { error: "sentinel", type: "made-up-type" }, Files::APIError ],
+      "a blank type" => [ { error: "sentinel", type: "" }, Files::APIError ],
+      "a non-string type" => [ { error: "sentinel", type: 7 }, Files::APIError ],
+      "a null type" => [ { error: "sentinel", type: nil }, Files::APIError ],
+      "no type" => [ { error: "sentinel" }, Files::APIError ],
+      "an errors list" => [ { errors: [ "sentinel" ] }, Files::APIError ],
+      "a type naming an SDK usage error" => [ { error: "sentinel", type: "invalid-parameter" }, Files::APIError ],
+      "a type naming a Ruby exception" => [ { error: "sentinel", type: "standard" }, Files::APIError ],
+      "a known type without a message" => [ { error: 5, type: "not-found" }, Files::NotFoundError, /without a message/ ],
+    }
+
+    # Bodies that are not error objects, so the API gave no usable answer.
+    other_bodies = {
+      "JSON null" => "null",
+      "a JSON array" => [ { error: "sentinel" } ].to_json,
+      "a JSON scalar" => "\"sentinel\"",
+      "a JSON object without an error" => { status: "sentinel" }.to_json,
+    }
+
+    [ 404, 500 ].each do |status|
+      context "with HTTP #{status}" do
+        error_objects.each do |description, (body, error_class, message)|
+          it "raises #{error_class} for an error object with #{description}" do
+            expect { find_workspace_failing_with(status, body.to_json) }.to raise_error(error_class) { |error|
+              expect(error).to be_an_instance_of(error_class)
+              expect(error.message).to match(message || /\Asentinel\z/)
+              expect(error.http_status).to eq(status)
+              expect(error.http_headers["x-request-id"]).to eq("request-1")
+              expect(error.json_body).to eq(body)
+              expect(error.response).to be_a(Files::Response)
+            }
+          end
+        end
+
+        other_bodies.each do |description, body|
+          it "raises APIConnectionError for #{description}, without repeating the body" do
+            expect { find_workspace_failing_with(status, body) }.to raise_error(Files::APIConnectionError) { |error|
+              expect(error).to be_an_instance_of(Files::APIConnectionError)
+              expect(error.message).not_to include("sentinel")
+            }
+          end
+        end
+      end
+    end
+  end
+
+  describe "network timeouts" do
+    around do |example|
+      original = [ Files.open_timeout, Files.read_timeout ]
+      example.run
+    ensure
+      Files.open_timeout, Files.read_timeout = original
+    end
+
+    # Net::HTTP would raise RangeError for them partway through a request, after sending it.
+    it "refuses timeouts longer than Ruby can wait for when they are set" do
+      skip "JRuby can wait that long" if RUBY_PLATFORM == "java"
+
+      expect { Files.open_timeout = 2**63 }.to raise_error(ArgumentError, /open_timeout/)
+      expect { Files.read_timeout = 1e19 }.to raise_error(ArgumentError, /read_timeout/)
+      expect([ Files.open_timeout, Files.read_timeout ]).to eq([ 30, 60 ])
+    end
+  end
 end