files.com 1.1.785 → 1.1.787

data/spec/lib/api_client_spec.rb

@@ -400,6 +400,59 @@ RSpec.describe Files::ApiClient do
       expect { Files::Workspace.find(5, {}, api_key: "key", client: quiet_client) }.not_to output.to_stdout
       expect(global_output.string).not_to include("/workspaces/5")
     end
+
+    it "writes each request's and response's headers to a DEBUG logger with their other details" do
+      sent_markers = []
+      connection = described_class.build_default_conn
+      connection.adapter :test do |stub|
+        stub.get("/api/rest/v1/bundles/83") do |env|
+          sent_markers << env.request_headers["X-Request-Marker"]
+          json_response(200, { id: 83, code: "debug-response-body" }, "X-Response-Marker" => "debug-response-header")
+        end
+      end
+      output = StringIO.new
+      client = described_class.new(connection, logger: Logger.new(output, level: Logger::DEBUG))
+
+      bundle = Files::Bundle.find(83, {}, api_key: "key", client: client, "X-Request-Marker" => "debug-request-header")
+
+      expect([ bundle.id, bundle.attributes[:code] ]).to eq([ 83, "debug-response-body" ])
+      expect(sent_markers).to eq([ "debug-request-header" ])
+      expect(output.string.lines.grep(/message=Request details/).join).to include("debug-request-header")
+      expect(output.string.lines.grep(/message=Response details/).join).to include("debug-response-header", "debug-response-body")
+    end
+
+    it "logs each retry's attempt, reason and planned wait, and no retry once the budget is spent" do
+      original_delays = [ Files.initial_network_retry_delay, Files.max_network_retry_delay ]
+      Files.max_network_retries = 1
+      Files.initial_network_retry_delay = 0
+      Files.max_network_retry_delay = 0
+      statuses = { 1 => [ 503, 200 ], 2 => [ 503, 503 ] }
+      connection = described_class.build_default_conn
+      connection.adapter :test do |stub|
+        statuses.each_key do |id|
+          stub.get("/api/rest/v1/workspaces/#{id}") do
+            status = statuses[id].shift
+            next json_response(200, { id: id, name: "Primary" }) if status == 200
+
+            json_response(status, { error: "HTTP #{status}" })
+          end
+        end
+      end
+      output = StringIO.new
+      client = described_class.new(connection, logger: Logger.new(output, level: Logger::INFO))
+
+      workspace = Files::Workspace.find(1, {}, api_key: "key", client: client)
+      expect { Files::Workspace.find(2, {}, api_key: "key", client: client) }.to raise_error(Files::APIError)
+
+      expect([ workspace.id, workspace.attributes[:name] ]).to eq([ 1, "Primary" ])
+      expect(statuses).to eq(1 => [], 2 => [])
+      retries = output.string.lines.grep(/message=Retry /)
+      expect(retries.size).to eq(2)
+      expect(retries).to all(include("attempt=1", "max_retries=1", "status=503", "wait_seconds=0"))
+      expect(retries.map { |line| line[/path=\S+/] }).to eq([ "path=/workspaces/1", "path=/workspaces/2" ])
+    ensure
+      Files.initial_network_retry_delay, Files.max_network_retry_delay = original_delays
+    end
   end
 
   describe "client workspaces" do
@@ -441,6 +494,151 @@ RSpec.describe Files::ApiClient do
     end
   end
 
+  describe "caller containers" do
+    around do |example|
+      original = Files.api_key
+      example.run
+    ensure
+      Files.api_key = original
+    end
+
+    it "finds a workspace without changing the caller's params or options" do
+      requests = []
+      connection = Faraday.new do |builder|
+        builder.response :raise_error
+        builder.adapter :test do |stub|
+          stub.get("/api/rest/v1/workspaces/1") do |env|
+            requests << [ env.method, env.url.path, env.url.query ]
+            [ 200, { "Content-Type" => "application/json" }, { id: 1, name: "Primary" }.to_json ]
+          end
+        end
+      end
+      client = described_class.new(connection)
+      params = {}.freeze
+      options = { api_key: "key", client: client }.freeze
+
+      workspace = Files::Workspace.find(1, params, options)
+
+      expect(params).to eq({})
+      expect(options).to eq(api_key: "key", client: client)
+      expect(requests).to eq([ [ :get, "/api/rest/v1/workspaces/1", "id=1" ] ])
+      expect(workspace).to be_a(Files::Workspace)
+      expect([ workspace.id, workspace.attributes[:name] ]).to eq([ 1, "Primary" ])
+      expect(workspace.options).to include(api_key: "key", client: client, session_id: nil)
+    end
+
+    it "keeps the client and key a model's first successful request chose for its later requests" do
+      requests = { a: [], b: [] }
+      clients = requests.keys.to_h do |name|
+        connection = Faraday.new do |builder|
+          builder.response :raise_error
+          builder.adapter :test do |stub|
+            stub.delete("/api/rest/v1/bundles/7") do |env|
+              requests[name] << [ env.method, env.url.path, env.url.query, env.request_headers["X-FilesAPI-Key"] ]
+              [ 200, { "Content-Type" => "application/json" }, "{}" ]
+            end
+          end
+        end
+        [ name, described_class.new(connection) ]
+      end
+      attributes = { id: 7 }
+      constructor_options = {}.freeze
+      params = {}.freeze
+      bundle = Files::Bundle.new(attributes, constructor_options)
+
+      Files.api_key = "first-key"
+      clients[:a].request { bundle.delete(params) }
+      Files.api_key = "second-key"
+      clients[:b].request { bundle.delete(params) }
+
+      expect(requests[:a]).to eq([ [ :delete, "/api/rest/v1/bundles/7", "id=7", "first-key" ] ] * 2)
+      expect(requests[:b]).to be_empty
+      expect(bundle.options).to include(client: clients[:a], api_key: "first-key")
+      expect(bundle.attributes).to equal(attributes)
+      expect([ constructor_options, params, attributes ]).to eq([ {}, {}, { id: 7 } ])
+      expect(Files.api_key).to eq("second-key")
+    end
+
+    it "refuses a model update whose object parameter is not a Hash before sending it, leaving the model unchanged" do
+      dispatches = 0
+      client = stubbed_api_client do |stub|
+        stub.patch("/api/rest/v1/bundles/837") do
+          dispatches += 1
+          json_response(200, { id: 837 })
+        end
+      end
+      attributes = { id: 837 }
+      options = { api_key: "key", client: client }.freeze
+      params = { watermark_value: "wrong-object-type837" }.freeze
+      bundle = Files::Bundle.new(attributes, options)
+
+      expect { bundle.update(params) }.to raise_error(Files::InvalidParameterError, /watermark_value/) { |error|
+        expect(error).to be_a(Files::Error)
+      }
+      expect(dispatches).to eq(0)
+      expect(bundle.attributes).to equal(attributes)
+      expect(bundle.options).to equal(options)
+      expect([ attributes, params ]).to eq([ { id: 837 }, { watermark_value: "wrong-object-type837" } ])
+    end
+  end
+
+  describe "User-Agent" do
+    it "reports the SDK version the package declares" do
+      package_version = Gem::Specification.load(File.expand_path("../../files.com.gemspec", __dir__)).version.to_s
+      user_agent = described_class.new.send(:request_headers, nil, nil, :get, nil)["User-Agent"]
+
+      expect(user_agent).to match(/\AFiles\.com Ruby SDK v#{Regexp.escape(package_version)}(?: |\z)/)
+    end
+  end
+
+  describe "retries" do
+    around do |example|
+      original = [ Files.max_network_retries, Files.initial_network_retry_delay, Files.max_network_retry_delay ]
+      Files.max_network_retries = 3
+      Files.initial_network_retry_delay = 0
+      Files.max_network_retry_delay = 0
+      example.run
+    ensure
+      Files.max_network_retries, Files.initial_network_retry_delay, Files.max_network_retry_delay = original
+    end
+
+    it "requests again after HTTP 500, but sends HTTP 501 Not Implemented requests once" do
+      dispatches = Hash.new(0)
+      client = stubbed_api_client do |stub|
+        [ 500, 501 ].each do |status|
+          stub.get("/api/rest/v1/workspaces/#{status}") do
+            dispatches[status] += 1
+            [ status, { "Content-Type" => "application/json" }, { error: "HTTP #{status}" }.to_json ]
+          end
+        end
+      end
+
+      [ 500, 501 ].each do |status|
+        expect { Files::Workspace.find(status, {}, api_key: "key", client: client) }.to raise_error(Files::APIError)
+      end
+      expect(dispatches).to eq(500 => 4, 501 => 1)
+    end
+
+    it "requests again after HTTP 429 Too Many Requests and returns the record that follows" do
+      statuses = [ 429, 429, 200 ]
+      dispatches = 0
+      client = stubbed_api_client do |stub|
+        stub.get("/api/rest/v1/workspaces/7") do
+          dispatches += 1
+          next json_response(200, { id: 7, name: "Primary" }) if statuses.shift == 200
+
+          json_response(429, { error: "Slow down", type: "too-many-requests" })
+        end
+      end
+
+      workspace = Files::Workspace.find(7, {}, api_key: "key", client: client)
+
+      expect(dispatches).to eq(3)
+      expect(workspace).to be_a(Files::Workspace)
+      expect([ workspace.id, workspace.attributes[:name] ]).to eq([ 7, "Primary" ])
+    end
+  end
+
   describe "network timeouts" do
     around do |example|
       original = [ Files.open_timeout, Files.read_timeout ]
@@ -458,4 +656,298 @@ RSpec.describe Files::ApiClient do
       expect([ Files.open_timeout, Files.read_timeout ]).to eq([ 30, 60 ])
     end
   end
+
+  describe "base URLs" do
+    around do |example|
+      original = Files.base_url
+      example.run
+    ensure
+      Files.base_url = original
+    end
+
+    it "refuses a base URL scheme other than http or https before sending the request" do
+      dispatches = 0
+      client = stubbed_api_client do |stub|
+        stub.get("/api/rest/v1/bundles/83") do
+          dispatches += 1
+          json_response(200, { id: 83 })
+        end
+      end
+      Files.base_url = "unsupported://127.0.0.1:60548"
+
+      expect { Files::Bundle.find(83, {}, api_key: "key", client: client) }.to raise_error(Files::InvalidParameterError) { |error|
+        expect(error).to be_a(Files::Error)
+        expect(error.message).to include('"unsupported"', "https://")
+      }
+      expect(dispatches).to eq(0)
+    end
+
+    it "refuses a base URL with an invalid port before sending the request, keeping the parser's error as its cause" do
+      dispatches = 0
+      client = stubbed_api_client do |stub|
+        stub.get("/api/rest/v1/bundles/83") do
+          dispatches += 1
+          json_response(200, { id: 83 })
+        end
+      end
+      Files.base_url = "http://127.0.0.1:63121invalid-port"
+
+      expect { Files::Bundle.find(83, {}, api_key: "key", client: client) }.to raise_error(Files::InvalidParameterError) { |error|
+        expect(error).to be_a(Files::Error)
+        expect(error.message).to include("port", "https://")
+        expect(error.message).not_to include("127.0.0.1")
+        expect(error.cause).to be_a(Addressable::URI::InvalidURIError)
+      }
+      expect(dispatches).to eq(0)
+    end
+
+    it "reports a refused connection to the base URL as an APIConnectionError caused by the network error" do
+      original_retries = Files.max_network_retries
+      Files.max_network_retries = 0
+      closed_server = TCPServer.new("127.0.0.1", 0)
+      port = closed_server.addr[1]
+      closed_server.close
+      Files.base_url = "http://127.0.0.1:#{port}"
+
+      expect { Files::Bundle.find(832, {}, api_key: "key", client: described_class.new) }.to raise_error(Files::APIConnectionError) { |error|
+        expect(error).to be_a(Files::Error)
+        expect(error.message).to include("http://127.0.0.1:#{port}")
+        causes = Enumerator.produce(error.cause, &:cause).take_while(&:itself)
+        expect(causes.first).to be_a(Faraday::ConnectionFailed)
+        expect(causes.map(&:class)).to include(Errno::ECONNREFUSED)
+      }
+    ensure
+      Files.max_network_retries = original_retries
+    end
+
+    it "reports a base URL whose certificate fails verification as an APIConnectionError caused by the TLS error" do
+      original_retries = Files.max_network_retries
+      Files.max_network_retries = 1
+      key = OpenSSL::PKey::RSA.new(2048)
+      certificate = OpenSSL::X509::Certificate.new
+      certificate.version = 2
+      certificate.serial = 1
+      certificate.subject = certificate.issuer = OpenSSL::X509::Name.parse("/CN=127.0.0.1")
+      certificate.public_key = key.public_key
+      certificate.not_before = Time.now - 60
+      certificate.not_after = Time.now + 3600
+      certificate.sign(key, OpenSSL::Digest.new("SHA256"))
+      tls = OpenSSL::SSL::SSLContext.new
+      tls.cert = certificate
+      tls.key = key
+      listener = TCPServer.new("127.0.0.1", 0)
+      server = OpenSSL::SSL::SSLServer.new(listener, tls)
+      peer = Thread.new do
+        loop do
+          server.accept.close
+        rescue OpenSSL::SSL::SSLError, SystemCallError
+          next
+        end
+      rescue IOError
+        nil
+      end
+      base_url = "https://127.0.0.1:#{listener.addr[1]}"
+      Files.base_url = base_url
+
+      expect { Files::Bundle.find(839, {}, api_key: "key", client: described_class.new) }.to raise_error(Files::APIConnectionError, /certificate verify failed/) { |error|
+        expect(error).to be_a(Files::Error)
+        expect(error.message).to include(base_url)
+        causes = Enumerator.produce(error.cause, &:cause).take_while(&:itself)
+        expect(causes.first).to be_a(Faraday::SSLError)
+        expect(causes.map(&:class)).to include(OpenSSL::SSL::SSLError)
+      }
+    ensure
+      listener&.close
+      peer&.kill
+      peer&.join
+      Files.max_network_retries = original_retries
+    end
+
+    it "continues a request once at the regional origin a lockout region mismatch names, and keeps that origin for the returned model" do
+      certificate = lambda do |subject, key, issuer, issuer_key, extensions|
+        cert = OpenSSL::X509::Certificate.new
+        cert.version = 2
+        cert.serial = issuer ? 2 : 1
+        cert.subject = OpenSSL::X509::Name.parse(subject)
+        cert.issuer = issuer ? issuer.subject : cert.subject
+        cert.public_key = key.public_key
+        cert.not_before = Time.now - 60
+        cert.not_after = Time.now + 3600
+        factory = OpenSSL::X509::ExtensionFactory.new(issuer || cert, cert)
+        extensions.each { |name, value, critical| cert.add_extension(factory.create_extension(name, value, critical)) }
+        cert.sign(issuer_key, OpenSSL::Digest.new("SHA256"))
+      end
+      ca_key = OpenSSL::PKey::RSA.new(2048)
+      ca_extensions = [ [ "basicConstraints", "CA:TRUE", true ], [ "keyUsage", "keyCertSign, cRLSign", true ], [ "subjectKeyIdentifier", "hash", false ] ]
+      ca = certificate.call("/CN=Files SDK region test CA", ca_key, nil, ca_key, ca_extensions)
+      peer_key = OpenSSL::PKey::RSA.new(2048)
+      peer_extensions = [
+        [ "basicConstraints", "CA:FALSE", true ], [ "keyUsage", "digitalSignature, keyEncipherment", true ], [ "extendedKeyUsage", "serverAuth", false ],
+        [ "subjectAltName", "DNS:issuer.example.com, DNS:target.example.com", false ], [ "authorityKeyIdentifier", "keyid", false ]
+      ]
+      tls = OpenSSL::SSL::SSLContext.new
+      tls.key = peer_key
+      tls.cert = certificate.call("/CN=issuer.example.com", peer_key, ca, ca_key, peer_extensions)
+      trust = OpenSSL::X509::Store.new
+      trust.add_cert(ca)
+      # The fixture connection's proxy is this peer. It accepts the two CONNECTs the request needs and serves both
+      # origins over TLS itself: the configured issuer answers with the region mismatch, and the regional origin it
+      # names answers normally. Readiness waits are bounded at 10 seconds; reads and handshakes also rely on the
+      # client's timeouts. Cleanup below closes every accepted socket and checks that the owned peer finishes.
+      requests = []
+      accepted = []
+      listener = TCPServer.new("127.0.0.1", 0)
+      require "io/wait"
+      wait_readable = lambda do |io|
+        decrypted = io.is_a?(OpenSSL::SSL::SSLSocket) && io.pending.positive?
+        raise IOError, "the region fixture peer waited too long" unless decrypted || io.to_io.wait_readable(10)
+      end
+      peer = Thread.new do
+        2.times do
+          wait_readable.call(listener)
+          socket = listener.accept
+          accepted << socket
+          wait_readable.call(socket)
+          authority = socket.gets.to_s.split[1]
+          nil until socket.gets.to_s.chomp.empty?
+          socket.write("HTTP/1.1 200 Connection Established\r\n\r\n")
+          wait_readable.call(socket)
+          tls_socket = OpenSSL::SSL::SSLSocket.new(socket, tls)
+          tls_socket.accept
+          wait_readable.call(tls_socket)
+          request_line = tls_socket.gets.to_s.split
+          headers = {}
+          while (line = tls_socket.gets.to_s.chomp) != ""
+            name, value = line.split(":", 2)
+            headers[name.downcase] = value.to_s.strip
+          end
+          requests << [ authority, request_line[0], request_line[1], headers["x-filesapi-key"] ]
+          status, body = if authority == "issuer.example.com:443"
+                           [ "403 Forbidden", { error: "Lockout region mismatch", type: "not-authenticated/lockout-region-mismatch", data: { host: "target.example.com" } } ]
+                         else
+                           [ "200 OK", { id: 840, code: "regional" } ]
+                         end
+          json = body.to_json
+          tls_socket.write("HTTP/1.1 #{status}\r\nContent-Type: application/json\r\nContent-Length: #{json.bytesize}\r\nConnection: close\r\n\r\n#{json}")
+          tls_socket.close
+        rescue OpenSSL::SSL::SSLError, IOError, SystemCallError
+          next
+        ensure
+          socket&.close
+        end
+      end
+      # A connection this example owns, trusting only its own certificate authority and using the peer as its proxy.
+      connection = described_class.build_default_conn
+      connection.proxy = "http://127.0.0.1:#{listener.addr[1]}"
+      connection.ssl.cert_store = trust
+      Files.base_url = "https://issuer.example.com"
+
+      bundle = Files::Bundle.find(840, {}, api_key: "key", client: described_class.new(connection))
+
+      expect([ bundle.id, bundle.attributes[:code] ]).to eq([ 840, "regional" ])
+      expect(bundle.options).to include(base_url: "https://target.example.com")
+      path = "/api/rest/v1/bundles/840?id=840"
+      expect(requests).to eq([ [ "issuer.example.com:443", "GET", path, "key" ], [ "target.example.com:443", "GET", path, "key" ] ])
+      expect(Files.base_url).to eq("https://issuer.example.com")
+      expect(peer.join(10)).to equal(peer)
+    ensure
+      connection&.close
+      listener&.close
+      accepted&.each(&:close)
+      peer&.join(10)
+      raise "the region fixture peer did not finish" if peer&.alive?
+    end
+
+    it "continues a request once over plain HTTP within a library-wide development origin pair, asking the region handler, and keeps that origin and pair for the returned model" do
+      original_base_url = Files.base_url
+      original_pairs = Files.region_http_pairs
+      original_handler = Files.region_handler
+      # Two plain HTTP origins this example owns, each a listener on its own port. The issuer answers with the region
+      # mismatch, advertising the other origin as a bare host and port, and that one answers normally. Readiness waits
+      # are bounded at 10 seconds; the rest of each request is read relying on the client's timeouts. Cleanup below
+      # closes every listener and accepted socket and checks that the owned peer finishes.
+      requests = []
+      accepted = []
+      events = []
+      issuer_listener = TCPServer.new("127.0.0.1", 0)
+      target_listener = TCPServer.new("127.0.0.1", 0)
+      issuer = "http://127.0.0.1:#{issuer_listener.addr[1]}"
+      target_host = "127.0.0.1:#{target_listener.addr[1]}"
+      target = "http://#{target_host}"
+      require "io/wait"
+      wait_readable = lambda do |io|
+        raise IOError, "the HTTP region fixture peer waited too long" unless io.wait_readable(10)
+      end
+      answers = [
+        [ issuer, issuer_listener, "403 Forbidden", { error: "Lockout region mismatch", type: "not-authenticated/lockout-region-mismatch", data: { host: target_host } } ],
+        [ target, target_listener, "200 OK", { id: 841, code: "regional" } ]
+      ]
+      peer = Thread.new do
+        answers.each do |origin, listener, status, body|
+          wait_readable.call(listener)
+          socket = listener.accept
+          accepted << socket
+          wait_readable.call(socket)
+          request_line = socket.gets.to_s.split
+          headers = {}
+          while (line = socket.gets.to_s.chomp) != ""
+            name, value = line.split(":", 2)
+            headers[name.downcase] = value.to_s.strip
+          end
+          requests << [ origin, request_line[0], request_line[1], headers["x-filesapi-key"] ]
+          json = body.to_json
+          socket.write("HTTP/1.1 #{status}\r\nContent-Type: application/json\r\nContent-Length: #{json.bytesize}\r\nConnection: close\r\n\r\n#{json}")
+        rescue IOError, SystemCallError
+          next
+        ensure
+          socket&.close
+        end
+      end
+      # The library-wide pair, set from the caller's own Arrays and Strings; a region handler that records its event and
+      # approves the move by returning its own mutable copy of the target origin; and a connection and client this
+      # example owns, which use the library-wide pairs.
+      pairs = [ [ issuer.dup, target.dup ] ]
+      Files.region_http_pairs = pairs
+      approved_target = target.dup
+      Files.region_handler = lambda do |event|
+        events << event
+        approved_target
+      end
+      connection = described_class.build_default_conn
+      client = described_class.new(connection)
+      Files.base_url = issuer
+
+      bundle = Files::Bundle.find(841, {}, api_key: "key", client: client)
+
+      expect([ bundle.id, bundle.attributes[:code] ]).to eq([ 841, "regional" ])
+      expect(bundle.options).to include(base_url: target, region_http_pairs: [ [ issuer, target ] ])
+      expect(bundle.options[:client]).to equal(client)
+      path = "/api/rest/v1/bundles/841?id=841"
+      expect(requests).to eq([ [ issuer, "GET", path, "key" ], [ target, "GET", path, "key" ] ])
+      expect(events).to eq([ { reason: :lockout_region_mismatch, original_origin: issuer, target_origin: target, approval_required: false } ])
+      expect(events).to all(be_frozen)
+      expect(Files.base_url).to eq(issuer)
+      expect(peer.join(10)).to equal(peer)
+      # The returned model keeps the origin and pairs its request used: changing the handler's String, the caller's
+      # Arrays and Strings, or replacing the library-wide pairs, leaves them as they were, while the client's new
+      # requests start from the new setting.
+      approved_target << "/changed"
+      pairs.first.first << "/changed"
+      pairs << [ target, issuer ]
+      Files.region_http_pairs = []
+      expect(bundle.options[:base_url]).to eq(target)
+      expect(bundle.options[:region_http_pairs]).to eq([ [ issuer, target ] ]).and be_frozen
+      expect(client.region_http_pairs).to eq([])
+    ensure
+      connection&.close
+      issuer_listener&.close
+      target_listener&.close
+      accepted&.each(&:close)
+      peer&.join(10)
+      Files.base_url = original_base_url
+      Files.region_http_pairs = original_pairs
+      Files.region_handler = original_handler
+      raise "the HTTP region fixture peer did not finish" if peer&.alive?
+    end
+  end
 end

data/spec/list_spec.rb

@@ -75,6 +75,31 @@ RSpec.describe Files::List do
       expect(seen).to eq([ 1, 2 ])
       expect(requested_cursors).to eq([ nil, "a" ])
     end
+
+    it "follows X-Files-Cursor-Next, or X-Files-Cursor without it, and raises a later page's error after each record once" do
+      pages = {
+        nil => [ [ 1 ], { "X-Files-Cursor-Next" => "2:a+b&=opaque" } ],
+        "2:a+b&=opaque" => [ [ 2 ], { "X-Files-Cursor" => "legacy-3" } ],
+        "legacy-3" => [ [ 3 ], { "X-Files-Cursor-Next" => "next-4", "X-Files-Cursor" => "stale" } ],
+      }
+      client = stubbed_api_client do |stub|
+        stub.get("/api/rest/v1/workspaces") do |env|
+          requests << env.params
+          next json_response(404, { error: "Not Found", type: "not-found" }) if env.params["cursor"] == "next-4"
+
+          ids, headers = pages.fetch(env.params["cursor"])
+          json_response(200, ids.map { |id| { id: id } }, headers)
+        end
+      end
+      seen = []
+
+      expect {
+        Files::Workspace.list({ per_page: 1, filter: { name: "Workspace" } }, api_key: "list-key", client: client).auto_paging_each { |workspace| seen << workspace.id }
+      }.to raise_error(Files::NotFoundError)
+      expect(seen).to eq([ 1, 2, 3 ])
+      expect(requested_cursors).to eq([ nil, "2:a+b&=opaque", "legacy-3", "next-4" ])
+      expect(requests).to all(include("per_page" => "1", "filter" => { "name" => "Workspace" }))
+    end
   end
 
   describe "#each" do
@@ -132,6 +157,8 @@ RSpec.describe Files::List do
     end
 
     it "requests the same page again after a failed request" do
+      original_retries = Files.max_network_retries
+      Files.max_network_retries = 0
       failures = [ json_response(429, { error: "Slow down", type: "too-many-requests" }) ]
       client = stubbed_api_client do |stub|
         stub.get("/api/rest/v1/workspaces") do |env|
@@ -147,6 +174,8 @@ RSpec.describe Files::List do
       expect { page.next_page }.to raise_error(Files::TooManyRequestsError)
       expect(page.next_page.map(&:id)).to eq([ 2 ])
       expect(requested_cursors).to eq([ nil, "c2", "c2" ])
+    ensure
+      Files.max_network_retries = original_retries
     end
 
     {
@@ -200,7 +229,7 @@ RSpec.describe Files::List do
           json_response(200, [])
         end
       end
-      options = { api_key: "list-key" }
+      options = { api_key: "list-key" }.freeze
       list = Files::Workspace.list({}, options)
 
       expect { rejecting.request { list.to_a } }.to raise_error(Files::APIConnectionError)
@@ -209,7 +238,7 @@ RSpec.describe Files::List do
       first_ids = nil
       accepting.request { first_ids = list.map(&:id) }
       expect(first_ids).to eq([ 1 ])
-      expect(options).to include(api_key: "list-key", client: accepting)
+      expect(options).to eq(api_key: "list-key")
 
       second = nil
       other.request { second = list.next_page }

data/spec/models/persistence_spec.rb

@@ -120,7 +120,7 @@ RSpec.describe "Saving and updating models" do
       expect(Files::File.zip_list_contents("empty.zip", {}, options)).to eq([])
       expect(Files::File.begin_upload("empty-part.csv", {}, options).map { |part| [ part.class, part.attributes ] }).to eq([ [ Files::FileUploadPart, {} ] ])
     end
-    expect(options).to include(api_key: "key-a", client: client)
+    expect(options).to eq(api_key: "key-a")
   end
 
   it "refreshes each model from its own client, keeping false, zero, empty, null and decimal values" do

data/spec/models/user_spec.rb

@@ -0,0 +1,20 @@
+require "spec_helper"
+require_relative "../support/stubbed_api"
+
+RSpec.describe Files::User do
+  include StubbedApi
+
+  it "rejects an Array given as the Boolean disabled before sending the update" do
+    requests = []
+    client = stubbed_api_client do |stub|
+      stub.patch("/api/rest/v1/users/842") do |env|
+        requests << env
+        json_response(200, { id: 842 })
+      end
+    end
+    user = described_class.new({ id: 842 }, api_key: "key", client: client)
+
+    expect { user.update(disabled: [ "wrong-Boolean-container842" ]) }.to raise_error(Files::InvalidParameterError, /disabled/)
+    expect(requests).to be_empty
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: files.com
 version: !ruby/object:Gem::Version
-  version: 1.1.785
+  version: 1.1.787
 platform: ruby
 authors:
 - files.com
@@ -493,6 +493,7 @@ files:
 - spec/models/file_underscore_destinations_spec.rb
 - spec/models/folder_spec.rb
 - spec/models/persistence_spec.rb
+- spec/models/user_spec.rb
 - spec/path_util_spec.rb
 - spec/spec_helper.rb
 - spec/support/stubbed_api.rb