fsdk-2237-ruby-e2e 0.1.0

data/lib/petstore/serializers/xml_serializer.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'rexml/document'
+
+module Petstore
+  module Serializers
+    # Serializes models to XML strings and deserializes XML strings back to models.
+    # Uses Ruby's stdlib REXML.
+    module Xml
+      # Converts a model or primitive to an XML string.
+      # root: the name of the wrapping XML element (defaults to 'root').
+      def self.serialize(value, root: 'root')
+        doc = REXML::Document.new
+        doc << REXML::XMLDecl.new('1.0', 'UTF-8')
+        build_element(doc.add_element(root.to_s), value)
+        doc.to_s
+      end
+
+      # Builds a model instance from an XML string.
+      # Returns the raw string unchanged when no model class is provided.
+      def self.deserialize(xml_string, model_class = nil, root: nil)
+        return xml_string unless model_class
+        return unless xml_string
+
+        doc  = REXML::Document.new(xml_string)
+        el   = root ? (doc.root.elements[root.to_s] || doc.root) : doc.root
+        hash = element_to_hash(el, model_class)
+        model_class.from_hash(hash)
+      end
+
+      private_class_method def self.build_element(parent, value)
+        case value
+        when Models::UnionType
+          build_element(parent, value.value)
+        when Models::Serializable
+          value.class.wire_keys.each do |attr, key|
+            build_element(parent.add_element(key.to_s), value.attributes[attr])
+          end
+        when Array
+          value.each { |item| build_element(parent.add_element('item'), item) }
+        when nil
+          nil
+        else
+          parent.text = value.to_s
+        end
+      end
+
+      private_class_method def self.element_to_hash(element, model_class)
+        model_class.wire_keys.each_with_object({}) do |(_attr, key), hash|
+          child      = element.elements[key.to_s]
+          hash[key]  = child&.text
+        end
+      end
+    end
+  end
+end

data/lib/petstore/store/client.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Petstore
+  module Store
+    class Client
+      def initialize(client:)
+        @client = client
+      end
+
+      def get_inventory(request_options: {}, **params)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'GET',
+          path: 'store/inventory',
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::Petstore::Internal::Types::Hash[String, Integer].coerce(::JSON.parse(body, symbolize_names: false)) }
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      def place_order(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        request_body = ::Petstore::Store::Types::Order.new(params)
+        request_body.validate! if request_body.respond_to?(:validate!)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'POST',
+          path: 'store/order',
+          body: request_body.to_h,
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          result = ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::Petstore::Store::Types::Order.load(body) }
+          result.validate! if result.respond_to?(:validate!)
+          result
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      def get_order_by_id(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'GET',
+          path: "store/order/#{URI.encode_uri_component(params[:order_id].to_s)}",
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          result = ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::Petstore::Store::Types::Order.load(body) }
+          result.validate! if result.respond_to?(:validate!)
+          result
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      def delete_order(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'DELETE',
+          path: "store/order/#{URI.encode_uri_component(params[:order_id].to_s)}",
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        return if code.between?(200, 299)
+
+        error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+        raise error_class.new(response.body, code: code)
+      end
+    end
+  end
+end

data/lib/petstore/store/types/delete_order_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Store
+    module Types
+      class DeleteOrderRequest < ::Petstore::Internal::Types::Model
+        field :order_id, -> { Integer }, optional: false, nullable: false, api_name: 'orderId'
+      end
+    end
+  end
+end

data/lib/petstore/store/types/get_order_by_id_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Store
+    module Types
+      class GetOrderByIDRequest < ::Petstore::Internal::Types::Model
+        field :order_id, -> { Integer }, optional: false, nullable: false, api_name: 'orderId'
+      end
+    end
+  end
+end

data/lib/petstore/store/types/order.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Store
+    module Types
+      class Order < ::Petstore::Internal::Types::Model
+        field :id, -> { Integer }, optional: true, nullable: false
+        field :pet_id, -> { Integer }, optional: true, nullable: false, api_name: 'petId'
+        field :quantity, -> { Integer }, optional: true, nullable: false
+        field :ship_date, -> { String }, optional: true, nullable: false, api_name: 'shipDate'
+        field :status, -> { ::Petstore::Types::OrderStatus }, optional: true, nullable: false
+        field :complete, -> { ::Petstore::Internal::Types::Boolean }, optional: true, nullable: false
+
+        def self.load(str)
+          coerce(::JSON.parse(str, symbolize_names: true))
+        end
+
+        def self.dump(value)
+          coerced = coerce(value)
+          ::JSON.generate(coerced.nil? || !coerced.respond_to?(:to_h) ? coerced : coerced.to_h)
+        end
+      end
+    end
+  end
+end

data/lib/petstore/types/api_response.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Types
+    class APIResponse < ::Petstore::Internal::Types::Model
+      field :code, -> { Integer }, optional: true, nullable: false
+      field :type, -> { String }, optional: true, nullable: false
+      field :message, -> { String }, optional: true, nullable: false
+
+      def self.load(str)
+        coerce(::JSON.parse(str, symbolize_names: true))
+      end
+
+      def self.dump(value)
+        coerced = coerce(value)
+        ::JSON.generate(coerced.nil? || !coerced.respond_to?(:to_h) ? coerced : coerced.to_h)
+      end
+    end
+  end
+end

data/lib/petstore/types/category.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Types
+    class Category < ::Petstore::Internal::Types::Model
+      field :id, -> { Integer }, optional: true, nullable: false
+      field :name, -> { String }, optional: true, nullable: false
+
+      def self.load(str)
+        coerce(::JSON.parse(str, symbolize_names: true))
+      end
+
+      def self.dump(value)
+        coerced = coerce(value)
+        ::JSON.generate(coerced.nil? || !coerced.respond_to?(:to_h) ? coerced : coerced.to_h)
+      end
+    end
+  end
+end

data/lib/petstore/types/order_status.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Types
+    module OrderStatus
+      extend ::Petstore::Internal::Types::Enum
+
+      PLACED = :placed
+      APPROVED = :approved
+      DELIVERED = :delivered
+
+      def self.load(str)
+        coerce(::JSON.parse(str, symbolize_names: true))
+      end
+
+      def self.dump(value)
+        coerced = coerce(value)
+        ::JSON.generate(coerced.nil? || !coerced.respond_to?(:to_h) ? coerced : coerced.to_h)
+      end
+    end
+  end
+end

data/lib/petstore/types/pet_status.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Types
+    module PetStatus
+      extend ::Petstore::Internal::Types::Enum
+
+      AVAILABLE = :available
+      PENDING = :pending
+      SOLD = :sold
+
+      def self.load(str)
+        coerce(::JSON.parse(str, symbolize_names: true))
+      end
+
+      def self.dump(value)
+        coerced = coerce(value)
+        ::JSON.generate(coerced.nil? || !coerced.respond_to?(:to_h) ? coerced : coerced.to_h)
+      end
+    end
+  end
+end

data/lib/petstore/types/tag.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Types
+    class Tag < ::Petstore::Internal::Types::Model
+      field :id, -> { Integer }, optional: true, nullable: false
+      field :name, -> { String }, optional: true, nullable: false
+
+      def self.load(str)
+        coerce(::JSON.parse(str, symbolize_names: true))
+      end
+
+      def self.dump(value)
+        coerced = coerce(value)
+        ::JSON.generate(coerced.nil? || !coerced.respond_to?(:to_h) ? coerced : coerced.to_h)
+      end
+    end
+  end
+end

data/lib/petstore/user/client.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+require 'uri'
+
+module Petstore
+  module User
+    class Client
+      def initialize(client:)
+        @client = client
+      end
+
+      def create_user(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        request_body = ::Petstore::User::Types::User.new(params)
+        request_body.validate! if request_body.respond_to?(:validate!)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'POST',
+          path: 'user',
+          body: request_body.to_h,
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          result = ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::Petstore::User::Types::User.load(body) }
+          result.validate! if result.respond_to?(:validate!)
+          result
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      def create_users_with_list_input(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'POST',
+          path: 'user/createWithList',
+          body: params,
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          result = ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::Petstore::User::Types::User.load(body) }
+          result.validate! if result.respond_to?(:validate!)
+          result
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      def login_user(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        query_params = {}
+        query_params['username'] = params[:username] if params.key?(:username)
+        query_params['password'] = params[:password] if params.key?(:password)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'GET',
+          path: 'user/login',
+          query: query_params,
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::JSON.parse(body) }
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      def logout_user(request_options: {}, **params)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'GET',
+          path: 'user/logout',
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        return if code.between?(200, 299)
+
+        error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+        raise error_class.new(response.body, code: code)
+      end
+
+      def get_user_by_name(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'GET',
+          path: "user/#{URI.encode_uri_component(params[:username].to_s)}",
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        if code.between?(200, 299)
+          result = ::Petstore::Internal::Http::ResponseBody.decode(response) { |body| ::Petstore::User::Types::User.load(body) }
+          result.validate! if result.respond_to?(:validate!)
+          result
+        else
+          error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+          raise error_class.new(response.body, code: code)
+        end
+      end
+
+      def update_user(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        request_body = ::Petstore::User::Types::User.new(params.except(:username))
+        request_body.validate! if request_body.respond_to?(:validate!)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'PUT',
+          path: "user/#{URI.encode_uri_component(params[:username].to_s)}",
+          body: request_body.to_h,
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        return if code.between?(200, 299)
+
+        error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+        raise error_class.new(response.body, code: code)
+      end
+
+      def delete_user(request_options: {}, **params)
+        params = ::Petstore::Internal::Types::Utils.normalize_keys(params)
+        request = ::Petstore::Internal::JSON::Request.new(
+          base_url: request_options[:base_url],
+          method: 'DELETE',
+          path: "user/#{URI.encode_uri_component(params[:username].to_s)}",
+          request_options: request_options,
+        )
+        response = @client.send(request)
+        code = response.code.to_i
+        return if code.between?(200, 299)
+
+        error_class = ::Petstore::Errors::ResponseError.subclass_for_code(code)
+        raise error_class.new(response.body, code: code)
+      end
+    end
+  end
+end

data/lib/petstore/user/types/delete_user_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Petstore
+  module User
+    module Types
+      class DeleteUserRequest < ::Petstore::Internal::Types::Model
+        field :username, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/petstore/user/types/get_user_by_name_request.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Petstore
+  module User
+    module Types
+      class GetUserByNameRequest < ::Petstore::Internal::Types::Model
+        field :username, -> { String }, optional: false, nullable: false
+      end
+    end
+  end
+end

data/lib/petstore/user/types/login_user_request.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Petstore
+  module User
+    module Types
+      class LoginUserRequest < ::Petstore::Internal::Types::Model
+        field :username, -> { String }, optional: true, nullable: false
+
+        field :password, -> { String }, optional: true, nullable: false
+      end
+    end
+  end
+end

data/lib/petstore/user/types/user.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Petstore
+  module User
+    module Types
+      class User < ::Petstore::Internal::Types::Model
+        field :id, -> { Integer }, optional: true, nullable: false
+        field :username, -> { String }, optional: true, nullable: false
+        field :first_name, -> { String }, optional: true, nullable: false, api_name: 'firstName'
+        field :last_name, -> { String }, optional: true, nullable: false, api_name: 'lastName'
+        field :email, -> { String }, optional: true, nullable: false
+        field :password, -> { String }, optional: true, nullable: false
+        field :phone, -> { String }, optional: true, nullable: false
+        field :user_status, -> { Integer }, optional: true, nullable: false, api_name: 'userStatus'
+
+        def self.load(str)
+          coerce(::JSON.parse(str, symbolize_names: true))
+        end
+
+        def self.dump(value)
+          coerced = coerce(value)
+          ::JSON.generate(coerced.nil? || !coerced.respond_to?(:to_h) ? coerced : coerced.to_h)
+        end
+      end
+    end
+  end
+end

data/lib/petstore/validator.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Petstore
+  module Validator
+    class << self
+      def validate_string!(value, field, min_length: nil, max_length: nil, pattern: nil)
+        return if value.nil?
+
+        raise ValidationError.new(field, "must be at least #{min_length} characters long") if min_length && value.to_s.length < min_length
+        raise ValidationError.new(field, "must be at most #{max_length} characters long") if max_length && value.to_s.length > max_length
+        return unless pattern && !value.to_s.match?(pattern)
+
+        raise ValidationError.new(field, "must match pattern #{pattern.source}")
+      end
+
+      def validate_number!(value, field, min: nil, min_exclusive: nil, max: nil, max_exclusive: nil,
+                           multiple_of: nil)
+        return if value.nil?
+
+        raise ValidationError.new(field, "must be >= #{min}") if min && value < min
+        raise ValidationError.new(field, "must be > #{min_exclusive}") if min_exclusive && value <= min_exclusive
+        raise ValidationError.new(field, "must be <= #{max}") if max && value > max
+        raise ValidationError.new(field, "must be < #{max_exclusive}") if max_exclusive && value >= max_exclusive
+        return unless multiple_of && (value % multiple_of).abs > Float::EPSILON * multiple_of.abs
+
+        raise ValidationError.new(field, "must be a multiple of #{multiple_of}")
+      end
+
+      alias validate_integer! validate_number!
+
+      def validate_array!(value, field, min_items: nil, max_items: nil, unique_items: false)
+        return if value.nil?
+
+        raise ValidationError.new(field, "must have at least #{min_items} items") if min_items && value.length < min_items
+        raise ValidationError.new(field, "must have at most #{max_items} items") if max_items && value.length > max_items
+        return unless unique_items && value.length != value.uniq.length
+
+        raise ValidationError.new(field, 'must contain unique items')
+      end
+    end
+  end
+end

data/lib/petstore/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Petstore
+  VERSION = '0.1.0'
+end

data/lib/petstore.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require_relative 'petstore/version'
+require 'json'
+require_relative 'petstore/internal/json/serializable'
+require_relative 'petstore/internal/types/type'
+require_relative 'petstore/internal/types/utils'
+require_relative 'petstore/internal/types/union'
+require_relative 'petstore/internal/errors/constraint_error'
+require_relative 'petstore/internal/errors/type_error'
+require_relative 'petstore/internal/http/base_request'
+require_relative 'petstore/internal/json/request'
+require_relative 'petstore/internal/raw/request'
+require_relative 'petstore/internal/form/request'
+require_relative 'petstore/internal/http/raw_client'
+require_relative 'petstore/internal/http/response_body'
+require_relative 'petstore/internal/http/event_stream'
+require_relative 'petstore/internal/multipart/multipart_encoder'
+require_relative 'petstore/internal/multipart/multipart_form_data_part'
+require_relative 'petstore/internal/multipart/multipart_form_data'
+require_relative 'petstore/internal/multipart/multipart_request'
+require_relative 'petstore/internal/types/model/field'
+require_relative 'petstore/internal/types/model'
+require_relative 'petstore/internal/types/array'
+require_relative 'petstore/internal/types/boolean'
+require_relative 'petstore/internal/types/enum'
+require_relative 'petstore/internal/types/hash'
+require_relative 'petstore/internal/types/unknown'
+require_relative 'petstore/internal/iterators/item_iterator'
+require_relative 'petstore/internal/iterators/cursor_item_iterator'
+require_relative 'petstore/internal/iterators/offset_item_iterator'
+require_relative 'petstore/internal/iterators/cursor_page_iterator'
+require_relative 'petstore/internal/iterators/offset_page_iterator'
+require_relative 'petstore/errors/api_error'
+require_relative 'petstore/errors/response_error'
+require_relative 'petstore/errors/client_error'
+require_relative 'petstore/errors/redirect_error'
+require_relative 'petstore/errors/server_error'
+require_relative 'petstore/errors/timeout_error'
+require_relative 'petstore/errors/connection_error'
+require_relative 'petstore/error'
+require_relative 'petstore/models/serializable'
+require_relative 'petstore/models/union_type'
+require_relative 'petstore/models/open_model'
+require_relative 'petstore/serializers/json_serializer'
+require_relative 'petstore/serializers/xml_serializer'
+require_relative 'petstore/serializers/form_serializer'
+require_relative 'petstore/http/auth'
+require_relative 'petstore/http/oauth_token_manager'
+require_relative 'petstore/environment'
+require_relative 'petstore/config'
+require_relative 'petstore/validator'
+require_relative 'petstore/pet/types/pet'
+require_relative 'petstore/types/category'
+require_relative 'petstore/types/tag'
+require_relative 'petstore/types/pet_status'
+require_relative 'petstore/pet/types/find_pets_by_status_request_status'
+require_relative 'petstore/types/api_response'
+require_relative 'petstore/store/types/order'
+require_relative 'petstore/types/order_status'
+require_relative 'petstore/user/types/user'
+require_relative 'petstore/pet/types/find_pets_by_status_request'
+require_relative 'petstore/pet/types/find_pets_by_tags_request'
+require_relative 'petstore/pet/types/get_pet_by_id_request'
+require_relative 'petstore/pet/types/update_pet_with_form_request'
+require_relative 'petstore/pet/types/delete_pet_request'
+require_relative 'petstore/store/types/get_order_by_id_request'
+require_relative 'petstore/store/types/delete_order_request'
+require_relative 'petstore/user/types/login_user_request'
+require_relative 'petstore/user/types/get_user_by_name_request'
+require_relative 'petstore/user/types/delete_user_request'
+require_relative 'petstore/pet/client'
+require_relative 'petstore/store/client'
+require_relative 'petstore/user/client'
+require_relative 'petstore/client'
+
+module Petstore
+end