fsdk-2237-ruby-e2e 0.1.0

data/lib/petstore/internal/form/request.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+# Both reach the rest of the internal runtime transitively -- `URI` through `net/http`, `JSON`
+# through the serializers -- and are required explicitly here because this file uses them
+# directly: `encode_www_form` is its whole encoder, and `JSON.generate` renders non-scalar leaves.
+require 'json'
+require 'uri'
+
+module Petstore
+  module Internal
+    module Form
+      # A request whose body is a STRUCTURED value sent as `application/x-www-form-urlencoded`.
+      #
+      # FSDK-1441 routed a declared non-JSON body to `Internal::Raw::Request` only when its schema
+      # was a string or binary, because those travel verbatim. A urlencoded body's schema is an
+      # OBJECT, so it stayed on `Internal::JSON::Request` — which `JSON.generate`s it and labels it
+      # `application/json`. The server was told the wrong media type and handed a JSON document
+      # where it asked for form fields (FSDK-1668).
+      #
+      # @api private
+      class Request < ::Petstore::Internal::Http::BaseRequest
+        CONTENT_TYPE = 'application/x-www-form-urlencoded'
+
+        attr_reader :body
+
+        # @param base_url [String] The base URL for the request
+        # @param path [String] The path for the request
+        # @param method [Symbol] The HTTP method for the request (:get, :post, etc.)
+        # @param headers [Hash] Additional headers for the request (optional)
+        # @param query [Hash] Query parameters for the request (optional)
+        # @param body [Hash, nil] The request body as the model's wire hash (optional)
+        # @param content_type [String] The media type declared for the request body.
+        # @param accept [String] The media type declared for the response body.
+        # @param request_options [::Petstore::RequestOptions, Hash{Symbol=>Object}, nil]
+        def initialize(base_url:, path:, method:, headers: {}, query: {}, body: nil, content_type: CONTENT_TYPE, accept: '*/*', request_options: {})
+          super(base_url:, path:, method:, headers:, query:, request_options:)
+
+          @body = body
+          @content_type = content_type
+          @accept = accept
+        end
+
+        # @return [Hash] The encoded HTTP request headers.
+        # @param protected_keys [Array<String>] Header keys set by the SDK client (e.g. auth, metadata)
+        #   that must not be overridden by additional_headers from request_options.
+        def encode_headers(protected_keys: [])
+          sdk_headers = {
+            'Content-Type' => @content_type,
+            'Accept' => @accept,
+          }.merge(@headers)
+          merge_additional_headers(sdk_headers, protected_keys:)
+        end
+
+        # @return [String, nil] The encoded HTTP request body.
+        #
+        # MEMOISED for the same reason as the raw and multipart encoders: `RawClient#send` calls
+        # this once per attempt, so a retry must replay the bytes rather than re-derive them.
+        def encode_body
+          return nil if @body.nil?
+          # The memo is named after the METHOD rather than after the value it holds, which is the
+          # naming convention the generated .rubocop.yml enforces.
+          return @encode_body if defined?(@encode_body)
+
+          @encode_body =
+            if @body.is_a?(::Hash)
+              ::URI.encode_www_form(form_fields)
+            else
+              # A oneOf/anyOf body can resolve to a bare scalar or an array rather than an object,
+              # and a form field has no name to hang one of those on. Passed through as its own
+              # text, which is what the raw path does for a urlencoded body declared as a string.
+              # Tested with +is_a?(::Hash)+ rather than +respond_to?(:to_h)+ because +Array#to_h+
+              # EXISTS and raises TypeError on a non-pair array.
+              @body.to_s
+            end
+        end
+
+        private
+
+        # The model's wire hash flattened to the `[key, value]` pairs `URI.encode_www_form` is
+        # defined over, under the OpenAPI default for a urlencoded body (`form`, `explode: true`).
+        #
+        # An ARRAY becomes one repeated key per element, which is what `explode: true` means; it is
+        # expanded here rather than left to `encode_www_form`'s own array handling so an array of
+        # non-scalars gets the JSON leaf treatment below instead of `Array#to_s`.
+        #
+        # A nil value is OMITTED. `application/x-www-form-urlencoded` has no null, so the only
+        # alternatives are dropping the field or asserting an empty string for it, and an empty
+        # string is a different value the caller did not send.
+        def form_fields
+          @body.each_with_object([]) do |(key, value), pairs|
+            next if value.nil?
+
+            if value.is_a?(::Array)
+              value.each { |element| pairs << [key.to_s, form_value(element)] }
+            else
+              pairs << [key.to_s, form_value(value)]
+            end
+          end
+        end
+
+        # A form field is a scalar. OpenAPI says nothing about what a nested object or array leaf
+        # looks like inside a urlencoded body, so JSON is emitted for it — the caller's data
+        # survives, rather than Ruby's `Hash#to_s` / `Array#to_s` rendering reaching the wire.
+        def form_value(value)
+          value.is_a?(::Hash) || value.is_a?(::Array) ? ::JSON.generate(value) : value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/petstore/internal/http/base_request.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Internal
+    module Http
+      # @api private
+      class BaseRequest
+        attr_reader :base_url, :path, :method, :headers, :query, :request_options
+
+        # @param base_url [String] The base URL for the request
+        # @param path [String] The path for the request
+        # @param method [String] The HTTP method for the request (:get, :post, etc.)
+        # @param headers [Hash] Additional headers for the request (optional)
+        # @param query [Hash] Query parameters for the request (optional)
+        # @param request_options [::Petstore::RequestOptions, Hash{Symbol=>Object}, nil]
+        def initialize(base_url:, path:, method:, headers: {}, query: {}, request_options: {})
+          @base_url = base_url
+          @path = path
+          @method = method
+          @headers = headers
+          @query = query
+          @request_options = request_options
+        end
+
+        # The query parameters merged with additional query parameters from request options.
+        #
+        # A service passes +query+ as a Hash when every declared parameter is a default-style
+        # (form + explode) scalar or flat array, which +URI.encode_www_form+ already serializes
+        # correctly. When any parameter declares another style — spaceDelimited, pipeDelimited,
+        # deepObject, explode: false — or carries an object, the service passes an Array of
+        # already-encoded "key=value" parts instead, because those forms cannot be expressed as a
+        # Hash that +encode_www_form+ would render right. Both shapes are carried through to
+        # +RawClient#encode_query+, which joins an Array and form-encodes a Hash.
+        #
+        # @return [Hash, Array<String>] The merged query parameters.
+        def encode_query
+          additional_query = @request_options&.dig(:additional_query_parameters) || @request_options&.dig('additional_query_parameters') || {}
+          return @query.merge(additional_query) unless @query.is_a?(::Array)
+
+          # Braces, not do/end: `do` would bind to `+` rather than to `flat_map`.
+          @query + additional_query.flat_map { |key, value| ::Petstore::Serializers::Params.query_part(key.to_s, value) }
+        end
+
+        # Child classes should implement:
+        # - encode_headers: Returns the encoded HTTP request headers.
+        # - encode_body: Returns the encoded HTTP request body.
+
+        private
+
+        # Merges additional_headers from request_options into sdk_headers, filtering out
+        # any keys that collide with SDK-set or client-protected headers (case-insensitive).
+        # @param sdk_headers [Hash] Headers set by the SDK for this request type.
+        # @param protected_keys [Array<String>] Additional header keys that must not be overridden.
+        # @return [Hash] The merged headers.
+        def merge_additional_headers(sdk_headers, protected_keys: [])
+          additional_headers = @request_options&.dig(:additional_headers) || @request_options&.dig('additional_headers') || {}
+          all_protected = (sdk_headers.keys + protected_keys).to_set { |k| k.to_s.downcase }
+          filtered = additional_headers.reject { |key, _| all_protected.include?(key.to_s.downcase) }
+          sdk_headers.merge(filtered)
+        end
+      end
+    end
+  end
+end

data/lib/petstore/internal/http/event_stream.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Internal
+    module Http
+      # Decoding a `text/event-stream` body into the events it carries.
+      #
+      # An SSE body is a sequence of frames, not one document: `JSON.parse` on the whole thing
+      # raises, so a service method that returned `response.body` for an event-stream response
+      # handed the caller the literal wire text (`"data: {...}\n\n"`) with no way to reach the
+      # events inside it. This is the seam the default (non-fernMode) layout has had since it grew
+      # `HTTP::Connection#stream_execute`, expressed for the fernMode runtime.
+      #
+      # The frame grammar is the SSE spec's, which is a superset of what `stream_execute` handles.
+      # `stream_execute` treats every `data:` LINE as its own event, so the two agree exactly on
+      # the common one-line-per-frame shape; where they differ, a multi-line `data` frame joins
+      # here into the one event the spec says it is, instead of being fed to `JSON.parse` a
+      # fragment at a time.
+      #
+      # @api private
+      module EventStream
+        # The events in an event-stream body, each passed through the given block.
+        #
+        # Returns an Enumerator rather than an Array so `#first` on a long stream decodes one frame
+        # rather than all of them, and so the shape matches what the default layout's streaming
+        # methods return.
+        #
+        # The terminator is the API's own, passed from the spec rather than assumed. A nil
+        # terminator means the API declared none, so NO payload ends the stream early -- a service
+        # whose events legitimately include a `[DONE]`-shaped payload must not be truncated on it.
+        # Matched exactly when present, so a payload that merely resembles it is still delivered.
+        #
+        # @param response [Net::HTTPResponse] The HTTP response.
+        # @param terminator [String, nil] The declared end-of-stream payload, if any.
+        # @return [Enumerator] The decoded events, lazily.
+        def self.decode(response, terminator: nil)
+          # `to_s` because a 2xx is entitled to arrive with no body at all, which is an empty
+          # stream rather than an error -- the same case `ResponseBody.decode` guards.
+          body = response.body.to_s
+          ::Enumerator.new do |yielder|
+            # Frames are separated by a blank line. A CR is tolerated because SSE is CRLF on the
+            # wire, and a body split on "\n\n" alone would leave a trailing "\r" on every field.
+            body.split(/\r?\n\r?\n/).each do |frame|
+              data = data_field(frame)
+              # A frame with an empty data payload is not dispatched. That covers a comment-only
+              # keepalive (`: ping`), a frame holding only `event`/`id`/`retry`, the trailing empty
+              # segment a body ending in a blank line splits into, and an explicitly-empty `data:`
+              # frame -- all of which would otherwise reach the caller's event type as an empty
+              # payload and raise `JSON::ParserError` from inside the SDK. See `data_field` for why
+              # the last of those is dropped even though the spec would dispatch it.
+              next if data.nil?
+              break if !terminator.nil? && data == terminator
+
+              yielder << yield(data)
+            end
+          end
+        end
+
+        # The frame's `data` value: its `data:` lines joined with a newline, or nil when the frame
+        # has no data to dispatch. Multiple `data:` lines in one frame are ONE value per the spec,
+        # which is why this collects them instead of returning the first.
+        #
+        # The join IS the spec's data buffer: the spec appends each `data` field's value followed by
+        # a newline, then drops one trailing newline when it dispatches, which is what joining the
+        # values on a newline produces directly.
+        #
+        # @param frame [String] A single SSE event frame.
+        # @return [String, nil] The frame's data value, or nil when it carries none.
+        def self.data_field(frame)
+          values = []
+          frame.split(/\r?\n/).each do |line|
+            # Strip the CR before anything else: a bare `data\r` line carries no colon, and
+            # `partition` would otherwise read the field name as `data\r` and miss it.
+            line = line.chomp("\r")
+            # A blank line is not a field, and a leading colon is a comment.
+            next if line.empty? || line.start_with?(':')
+
+            name, colon, value = line.partition(':')
+            next unless name == 'data'
+
+            # A field with no colon has an empty value; otherwise a single leading space after the
+            # colon is part of the framing rather than the payload.
+            values << (colon.empty? ? '' : value.delete_prefix(' '))
+          end
+          data = values.join("\n")
+          # An EMPTY payload is dropped DELIBERATELY, and this is the one place the decoder departs
+          # from the spec: the spec checks its buffer for emptiness BEFORE dropping the trailing
+          # newline, so a lone `data:` frame is dispatchable there with an empty payload. It is not
+          # dispatchable here, because an empty string is not a document any event type can load --
+          # `JSON.parse('')` raises `JSON::ParserError` from inside the SDK, which is the failure
+          # this seam exists to prevent -- and in practice an empty `data:` frame is a keepalive,
+          # the same intent as the `:` comment form. The test is on the JOINED payload rather than
+          # on `values`, so "no data field at all" and "an explicitly empty data field" collapse to
+          # the same nil on purpose: for this decoder both mean nothing to dispatch. Anything
+          # non-empty is passed through untouched, so a two-line `data:`/`data:` frame still
+          # reaches the caller as the "\n" the spec says it is.
+          data.empty? ? nil : data
+        end
+
+        # Private because `decode` is the documented seam; the frame grammar is an implementation
+        # detail that callers must not be able to reach for.
+        private_class_method :data_field
+      end
+    end
+  end
+end