pcp-server-ruby-sdk 1.12.0 → 1.13.0

data/lib/PCP-server-Ruby-SDK/models/three_d_secure_results.rb

@@ -1,234 +1,14 @@
+require_relative 'model_base'
 
-require 'date'
-require 'time'
-
-# 3D Secure results object
 module PCPServerSDK
   module Models
-    class ThreeDSecureResults
+    class ThreeDSecureResults < ModelBase
       # 3D Secure Protocol version used during this transaction.
-      attr_accessor :version
-
+      attribute :version, :version, :String
       # 3D Secure ECI (Electronic Commerce Indicator) depending on the Scheme. Returned by DS.
-      attr_accessor :scheme_eci
-
-      # Exemption requested and applied in the authorization. 
-      attr_accessor :applied_exemption
-
-
-
-      class EnumAttributeValidator
-        attr_reader :datatype
-        attr_reader :allowable_values
-
-        def initialize(datatype, allowable_values)
-          @allowable_values = allowable_values.map do |value|
-            case datatype.to_s
-            when /Integer/i
-              value.to_i
-            when /Float/i
-              value.to_f
-            else
-              value
-            end
-          end
-        end
-
-        def valid?(value)
-          !value || allowable_values.include?(value)
-        end
-      end
-
-      # Attribute mapping from ruby-style variable name to JSON key.
-      def self.attribute_map
-        {
-          :'version' => :'version',
-          :'scheme_eci' => :'schemeEci',
-          :'applied_exemption' => :'appliedExemption'
-        }
-      end
-
-      # Returns all the JSON keys this model knows about
-      def self.acceptable_attributes
-        attribute_map.values
-      end
-
-      # Attribute type mapping.
-      def self.openapi_types
-        {
-          :'version' => :'String',
-          :'scheme_eci' => :'String',
-          :'applied_exemption' => :'String'
-        }
-      end
-
-      # List of attributes with nullable: true
-      def self.openapi_nullable
-        Set.new([
-        ])
-      end
-
-      # Initializes the object
-      # @param [Hash] attributes Model attributes in the form of hash
-      def initialize(attributes = {})
-        if (!attributes.is_a?(Hash))
-          fail ArgumentError, "The input argument (attributes) must be a hash in `ThreeDSecureResults` initialize method"
-        end
-
-        # check to see if the attribute exists and convert string to symbol for hash key
-        attributes = attributes.each_with_object({}) { |(k, v), h|
-          if (!self.class.attribute_map.key?(k.to_sym))
-            fail ArgumentError, "`#{k}` is not a valid attribute in `ThreeDSecureResults`. Please check the name to make sure it's valid. List of attributes: " + self.class.attribute_map.keys.inspect
-          end
-          h[k.to_sym] = v
-        }
-
-        if attributes.key?(:'version')
-          self.version = attributes[:'version']
-        end
-
-        if attributes.key?(:'scheme_eci')
-          self.scheme_eci = attributes[:'scheme_eci']
-        end
-
-        if attributes.key?(:'applied_exemption')
-          self.applied_exemption = attributes[:'applied_exemption']
-        end
-      end
-
-      # Checks equality by comparing each attribute.
-      # @param [Object] Object to be compared
-      def ==(o)
-        return true if self.equal?(o)
-        self.class == o.class &&
-            version == o.version &&
-            scheme_eci == o.scheme_eci &&
-            applied_exemption == o.applied_exemption
-      end
-
-      # @see the `==` method
-      # @param [Object] Object to be compared
-      def eql?(o)
-        self == o
-      end
-
-      # Calculates hash code according to all attributes.
-      # @return [Integer] Hash code
-      def hash
-        [version, scheme_eci, applied_exemption].hash
-      end
-
-      # Builds the object from hash
-      # @param [Hash] attributes Model attributes in the form of hash
-      # @return [Object] Returns the model itself
-      def self.build_from_hash(attributes)
-        return nil unless attributes.is_a?(Hash)
-        attributes = attributes.transform_keys(&:to_sym)
-        transformed_hash = {}
-        openapi_types.each_pair do |key, type|
-          if attributes.key?(attribute_map[key]) && attributes[attribute_map[key]].nil?
-            transformed_hash["#{key}"] = nil
-          elsif type =~ /\AArray<(.*)>/i
-            # check to ensure the input is an array given that the attribute
-            # is documented as an array but the input is not
-            if attributes[attribute_map[key]].is_a?(Array)
-              transformed_hash["#{key}"] = attributes[attribute_map[key]].map { |v| _deserialize($1, v) }
-            end
-          elsif !attributes[attribute_map[key]].nil?
-            transformed_hash["#{key}"] = _deserialize(type, attributes[attribute_map[key]])
-          end
-        end
-        new(transformed_hash)
-      end
-
-      # Deserializes the data based on type
-      # @param string type Data type
-      # @param string value Value to be deserialized
-      # @return [Object] Deserialized data
-      def self._deserialize(type, value)
-        case type.to_sym
-        when :Time
-          Time.parse(value)
-        when :Date
-          Date.parse(value)
-        when :String
-          value.to_s
-        when :Integer
-          value.to_i
-        when :Float
-          value.to_f
-        when :Boolean
-          if value.to_s =~ /\A(true|t|yes|y|1)\z/i
-            true
-          else
-            false
-          end
-        when :Object
-          # generic object (usually a Hash), return directly
-          value
-        when /\AArray<(?<inner_type>.+)>\z/
-          inner_type = Regexp.last_match[:inner_type]
-          value.map { |v| _deserialize(inner_type, v) }
-        when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
-          k_type = Regexp.last_match[:k_type]
-          v_type = Regexp.last_match[:v_type]
-          {}.tap do |hash|
-            value.each do |k, v|
-              hash[_deserialize(k_type, k)] = _deserialize(v_type, v)
-            end
-          end
-        else # model
-          # models (e.g. Pet) or oneOf
-          klass = PCPServerSDK::Models.const_get(type)
-          klass.respond_to?(:openapi_any_of) || klass.respond_to?(:openapi_one_of) ? klass.build(value) : klass.build_from_hash(value)
-        end
-      end
-
-      # Returns the string representation of the object
-      # @return [String] String presentation of the object
-      def to_s
-        to_hash.to_s
-      end
-
-      # to_body is an alias to to_hash (backward compatibility)
-      # @return [Hash] Returns the object in the form of hash
-      def to_body
-        to_hash
-      end
-
-      # Returns the object in the form of hash
-      # @return [Hash] Returns the object in the form of hash
-      def to_hash
-        hash = {}
-        self.class.attribute_map.each_pair do |attr, param|
-          value = self.send(attr)
-          if value.nil?
-            is_nullable = self.class.openapi_nullable.include?(attr)
-            next if !is_nullable || (is_nullable && !instance_variable_defined?(:"@#{attr}"))
-          end
-
-          hash[param] = _to_hash(value)
-        end
-        hash
-      end
-
-      # Outputs non-array value in the form of hash
-      # For object, use to_hash. Otherwise, just return the value
-      # @param [Object] value Any valid value
-      # @return [Hash] Returns the value in the form of hash
-      def _to_hash(value)
-        if value.is_a?(Array)
-          value.compact.map { |v| _to_hash(v) }
-        elsif value.is_a?(Hash)
-          {}.tap do |hash|
-            value.each { |k, v| hash[k] = _to_hash(v) }
-          end
-        elsif value.respond_to? :to_hash
-          value.to_hash
-        else
-          value
-        end
-      end
+      attribute :scheme_eci, :schemeEci, :String
+      # Exemption requested and applied in the authorization.
+      attribute :applied_exemption, :appliedExemption, :String, enum: ["low-value", "merchant-acquirer-transaction-risk-analysis"]
     end
   end
 end

data/lib/PCP-server-Ruby-SDK/version.rb

@@ -1,4 +1,4 @@
 
 module PCPServerSDK
-  VERSION = '1.12.0'
+  VERSION = '1.13.0'
 end

data/lib/PCP-server-Ruby-SDK.rb

@@ -6,6 +6,7 @@ require_relative 'PCP-server-Ruby-SDK/endpoints/commerce_case_api_client'
 require_relative 'PCP-server-Ruby-SDK/endpoints/order_management_checkout_actions_api_client'
 require_relative 'PCP-server-Ruby-SDK/endpoints/payment_execution_api_client'
 require_relative 'PCP-server-Ruby-SDK/endpoints/payment_information_api_client'
+require_relative 'PCP-server-Ruby-SDK/endpoints/payment_intent_api_client'
 
 # Errors
 require_relative 'PCP-server-Ruby-SDK/errors/api_error_response_exception'
@@ -37,6 +38,7 @@ require_relative 'PCP-server-Ruby-SDK/models/capture_payment_request'
 require_relative 'PCP-server-Ruby-SDK/models/capture_payment_response'
 require_relative 'PCP-server-Ruby-SDK/models/card_fraud_results'
 require_relative 'PCP-server-Ruby-SDK/models/card_info'
+require_relative 'PCP-server-Ruby-SDK/models/cart_item_data'
 require_relative 'PCP-server-Ruby-SDK/models/card_payment_details'
 require_relative 'PCP-server-Ruby-SDK/models/card_payment_method_specific_input'
 require_relative 'PCP-server-Ruby-SDK/models/card_payment_method_specific_output'
@@ -66,6 +68,7 @@ require_relative 'PCP-server-Ruby-SDK/models/create_commerce_case_request'
 require_relative 'PCP-server-Ruby-SDK/models/create_commerce_case_response'
 require_relative 'PCP-server-Ruby-SDK/models/create_payment_response'
 require_relative 'PCP-server-Ruby-SDK/models/customer'
+require_relative 'PCP-server-Ruby-SDK/models/customer_account'
 require_relative 'PCP-server-Ruby-SDK/models/customer_device'
 require_relative 'PCP-server-Ruby-SDK/models/deliver_item'
 require_relative 'PCP-server-Ruby-SDK/models/deliver_request'
@@ -112,6 +115,19 @@ require_relative 'PCP-server-Ruby-SDK/models/payment_information_refund_response
 require_relative 'PCP-server-Ruby-SDK/models/payment_information_request'
 require_relative 'PCP-server-Ruby-SDK/models/payment_information_response'
 require_relative 'PCP-server-Ruby-SDK/models/payment_instructions'
+require_relative 'PCP-server-Ruby-SDK/models/create_payment_intent'
+require_relative 'PCP-server-Ruby-SDK/models/create_payment_intent_request'
+require_relative 'PCP-server-Ruby-SDK/models/create_payment_intent_response'
+require_relative 'PCP-server-Ruby-SDK/models/payment_intent_response_data'
+require_relative 'PCP-server-Ruby-SDK/models/payment_intent_output'
+require_relative 'PCP-server-Ruby-SDK/models/payment_intent_response'
+require_relative 'PCP-server-Ruby-SDK/models/payment_method_specific_input_for_intent'
+require_relative 'PCP-server-Ruby-SDK/models/payment_product840_specific_output_data'
+require_relative 'PCP-server-Ruby-SDK/models/payment_product840_specific_output_for_intent'
+require_relative 'PCP-server-Ruby-SDK/models/redirect_payment_method_specific_input_for_intent'
+require_relative 'PCP-server-Ruby-SDK/models/redirect_payment_method_specific_output_for_create_intent'
+require_relative 'PCP-server-Ruby-SDK/models/redirect_payment_method_specific_output_for_intent'
+require_relative 'PCP-server-Ruby-SDK/models/redirect_payment_product840_specific_input_data'
 require_relative 'PCP-server-Ruby-SDK/models/payment_method_specific_input'
 require_relative 'PCP-server-Ruby-SDK/models/payment_output'
 require_relative 'PCP-server-Ruby-SDK/models/payment_product302_specific_input'
@@ -159,7 +175,9 @@ require_relative 'PCP-server-Ruby-SDK/models/sepa_direct_debit_payment_method_sp
 require_relative 'PCP-server-Ruby-SDK/models/sepa_direct_debit_payment_product771_specific_input'
 require_relative 'PCP-server-Ruby-SDK/models/sepa_transfer_payment_product_772_specific_input'
 require_relative 'PCP-server-Ruby-SDK/models/shipping'
+require_relative 'PCP-server-Ruby-SDK/models/shipping_address'
 require_relative 'PCP-server-Ruby-SDK/models/shopping_cart_input'
+require_relative 'PCP-server-Ruby-SDK/models/shopping_cart_data'
 require_relative 'PCP-server-Ruby-SDK/models/shopping_cart_patch'
 require_relative 'PCP-server-Ruby-SDK/models/shopping_cart_result'
 require_relative 'PCP-server-Ruby-SDK/models/status_category_value'

data/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "pcp-serversdk-ruby",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pcp-serversdk-ruby",
-      "version": "1.12.0",
+      "version": "1.13.0",
       "devDependencies": {
         "@commitlint/cli": "19.4.0",
         "@commitlint/config-conventional": "19.2.2",

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pcp-serversdk-ruby",
-  "version": "1.12.0",
+  "version": "1.13.0",
   "type": "commonjs",
   "scripts": {
     "changelog": "conventional-changelog -i CHANGELOG.md -s --config ./changelog.config.js"

data/scripts/convert_models_to_model_base.rb

@@ -0,0 +1,128 @@
+# Regenerates eligible object model files from `api-definition.yaml` as concise
+# `ModelBase` subclasses. Use this after an API-definition update or when the
+# generated model layer needs to be brought back to the shared ModelBase style.
+#
+# The script rewrites eligible files in `lib/PCP-server-Ruby-SDK/models`; it is
+# not a read-only audit. It intentionally excludes `oneOf`/`anyOf` schemas and
+# keeps direct Ruby inheritance for single-parent `allOf` schemas. Attribute
+# names, types, defaults, enums, and inheritance are derived from the API
+# definition, making it the source of truth. Output filenames follow the Ruby
+# naming convention, with documented exceptions for legacy filenames.
+# Referenced object, composed, and enum schemas remain model types; only plain
+# primitive aliases are converted to their Ruby primitive type.
+#
+# Running it can overwrite manual edits to eligible model files. Run it from a
+# clean or understood worktree, then inspect `git diff` and run the full test
+# suite before committing. Do not use it to regenerate endpoint clients or
+# special composed models; those require manual implementation and review.
+
+require 'pathname'
+require 'set'
+require 'yaml'
+
+ROOT = Pathname.new(__dir__).parent
+MODELS_DIRECTORY = ROOT.join('lib/PCP-server-Ruby-SDK/models')
+SCHEMAS = YAML.unsafe_load_file(ROOT.join('api-definition.yaml')).fetch('components').fetch('schemas')
+PRIMITIVE_TYPES = {
+  'string' => :String,
+  'integer' => :Integer,
+  'number' => :Float,
+  'boolean' => :Boolean
+}.freeze
+MODEL_FILE_OVERRIDES = {
+  # These existing filenames do not follow the class-name conversion convention.
+  'MobilePaymentThreeDSecure' => 'mobile_payment_three_dsecure.rb',
+  'SepaTransferPaymentProduct772SpecificInput' => 'sepa_transfer_payment_product_772_specific_input.rb'
+}.freeze
+
+def direct_parent_name(schema)
+  parents = Array(schema['allOf']).filter_map { |item| item['$ref']&.split('/')&.last }
+  parents.first if parents.size == 1
+end
+
+def local_properties(schema)
+  schema.fetch('properties', {}).merge(Array(schema['allOf']).each_with_object({}) do |item, properties|
+    properties.merge!(item.fetch('properties', {})) unless item.key?('$ref')
+  end)
+end
+
+def snake_case(value)
+  value.gsub(/([A-Z\d]+)([A-Z][a-z])/, '\\1_\\2')
+       .gsub(/([a-z\d])([A-Z])/, '\\1_\\2')
+       .tr('-', '_')
+       .downcase
+end
+
+def model_file(class_name)
+  MODELS_DIRECTORY.join(MODEL_FILE_OVERRIDES.fetch(class_name, "#{snake_case(class_name)}.rb"))
+end
+
+def ruby_type(schema, resolving = Set.new)
+  if schema['$ref']
+    name = schema['$ref'].split('/').last
+    return name.to_sym if resolving.include?(name)
+
+    referenced_schema = SCHEMAS.fetch(name)
+    # Enum references have generated model classes that validate deserialized values.
+    return name.to_sym if referenced_schema['type'] == 'object' || referenced_schema.key?('oneOf') || referenced_schema.key?('anyOf') || referenced_schema.key?('enum')
+
+    return ruby_type(referenced_schema, resolving | [name])
+  end
+
+  return ruby_type(schema.fetch('allOf').first, resolving) if schema['allOf']&.size == 1
+  return "Array<#{ruby_type(schema.fetch('items'), resolving)}>" if schema['type'] == 'array'
+
+  if schema['type'] == 'object' && schema['additionalProperties']
+    return "Hash<String, #{ruby_type(schema.fetch('additionalProperties'), resolving)}>"
+  end
+
+  return :Date if schema['format'] == 'date'
+  return :Time if schema['format'] == 'date-time'
+
+  PRIMITIVE_TYPES.fetch(schema['type'], :Object)
+end
+
+def description_lines(description)
+  description.to_s.lines.map do |line|
+    line.strip.empty? ? '      #' : "      # #{line.strip}"
+  end
+end
+
+def render_model(class_name, attributes, parent_name)
+  superclass = parent_name || 'ModelBase'
+  dependency = parent_name ? snake_case(parent_name) : 'model_base'
+  output = ["require_relative '#{dependency}'", '', 'module PCPServerSDK', '  module Models', "    class #{class_name} < #{superclass}"]
+
+  attributes.each do |name, json_name, type, property|
+    options = []
+    options << "default: #{property['default'].inspect}" if property.key?('default')
+    options << "enum: #{property['enum'].inspect}" if property.key?('enum')
+    output.concat(description_lines(property['description'])) if property.key?('description')
+    output << "      attribute #{name.inspect}, #{json_name.inspect}, #{type.inspect}#{", #{options.join(', ')}" unless options.empty?}"
+  end
+
+  if parent_name
+    output << '' unless attributes.empty?
+    output << '      def self.openapi_all_of'
+    output << "        [#{parent_name.to_sym.inspect}]"
+    output << '      end'
+  end
+
+  output.concat(['    end', '  end', 'end', ''])
+  output.join("\n")
+end
+
+eligible = SCHEMAS.select do |_name, schema|
+  schema['type'] == 'object' && !schema.key?('oneOf') && !schema.key?('anyOf')
+end
+
+metadata = eligible.transform_values do |schema|
+  attributes = local_properties(schema).map do |json_name, property|
+    [snake_case(json_name).to_sym, json_name.to_sym, ruby_type(property), property]
+  end
+  { attributes: attributes, parent_name: direct_parent_name(schema) }
+end
+
+metadata.sort.each do |class_name, model_metadata|
+  model_file(class_name).write(render_model(class_name, model_metadata.fetch(:attributes), model_metadata.fetch(:parent_name)))
+end

data/spec/endpoints/payment_intent_api_client_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper'
+require 'json'
+require_relative '../../lib/PCP-server-Ruby-SDK'
+
+RSpec.describe PCPServerSDK::Endpoints::PaymentIntentApiClient do
+  let(:config) { mock_communicator_config }
+  let(:client) { described_class.new(config) }
+
+  describe '#create_payment_intent' do
+    it 'posts the payload and deserializes the response' do
+      payload = PCPServerSDK::Models::CreatePaymentIntentRequest.new
+      response = double('Response', body: '{"paymentIntentOutput":{"paymentIntentId":"intent-1"}}', code: '201')
+      allow(client).to receive(:get_response).and_return(response)
+
+      result = client.create_payment_intent('merchant-1', payload)
+
+      expect(result).to be_a(PCPServerSDK::Models::CreatePaymentIntentResponse)
+      expect(result.payment_intent_output.payment_intent_id).to eq('intent-1')
+    end
+
+    it 'validates the merchant ID and payload' do
+      expect { client.create_payment_intent(nil, {}) }.to raise_error(TypeError, 'Merchant ID is required')
+      expect { client.create_payment_intent('merchant-1', nil) }.to raise_error(TypeError, 'Payload is required')
+    end
+  end
+
+  describe '#get_payment_intent' do
+    it 'deserializes the response' do
+      response = double('Response', body: '{"paymentIntentId":"intent-1"}', code: '200')
+      allow(client).to receive(:get_response).and_return(response)
+
+      result = client.get_payment_intent('merchant-1', 'intent-1')
+
+      expect(result).to be_a(PCPServerSDK::Models::PaymentIntentResponse)
+      expect(result.payment_intent_id).to eq('intent-1')
+    end
+
+    it 'validates the merchant ID and payment intent ID' do
+      expect { client.get_payment_intent(nil, 'intent-1') }.to raise_error(TypeError, 'Merchant ID is required')
+      expect { client.get_payment_intent('merchant-1', nil) }.to raise_error(TypeError, 'Payment Intent ID is required')
+    end
+  end
+end

data/spec/models/api_definition_conformance_spec.rb

@@ -0,0 +1,88 @@
+require 'spec_helper'
+require 'yaml'
+require_relative '../../lib/PCP-server-Ruby-SDK'
+
+RSpec.describe 'OpenAPI model conformance' do
+  let(:schemas) { YAML.unsafe_load_file(File.expand_path('../../api-definition.yaml', __dir__))['components']['schemas'] }
+
+  def schema_properties(name)
+    schema_properties_from(schemas.fetch(name))
+  end
+
+  def schema_properties_from(schema)
+    inherited = Array(schema['allOf']).flat_map do |parent|
+      parent['$ref'] ? schema_properties(parent['$ref'].split('/').last) : schema_properties_from(parent)
+    end
+    inherited + schema.fetch('properties', {}).keys
+  end
+
+  it 'provides a model for every object schema' do
+    object_schemas = schemas.select { |_name, schema| schema['type'] == 'object' }.keys
+    missing = object_schemas.reject { |name| PCPServerSDK::Models.const_defined?(name, false) }
+
+    expect(missing).to be_empty
+  end
+
+  it 'uses ModelBase for every non-composed object schema' do
+    ineligible = schemas.select { |_name, schema| schema.key?('oneOf') || schema.key?('anyOf') }.keys
+    eligible = schemas.select { |name, schema| schema['type'] == 'object' && !ineligible.include?(name) }.keys
+    mismatches = eligible.reject { |name| PCPServerSDK::Models.const_get(name) <= PCPServerSDK::Models::ModelBase }
+
+    expect(mismatches).to be_empty
+  end
+
+  it 'maps every flattened schema property' do
+    mismatches = schemas.filter_map do |name, schema|
+      next unless schema['type'] == 'object'
+
+      model = PCPServerSDK::Models.const_get(name)
+      expected = schema_properties(name).sort
+      actual = model.attribute_map.values.map(&:to_s).sort
+      "#{name}: expected #{expected}, got #{actual}" unless actual == expected
+    end
+
+    expect(mismatches).to be_empty
+  end
+
+  it 'declares each direct allOf parent' do
+    mismatches = schemas.filter_map do |name, schema|
+      expected = Array(schema['allOf']).filter_map { |parent| parent['$ref']&.split('/')&.last }.sort
+      next if expected.empty?
+
+      model = PCPServerSDK::Models.const_get(name)
+      actual = model.respond_to?(:openapi_all_of) ? model.openapi_all_of.map(&:to_s).sort : []
+      "#{name}: expected #{expected}, got #{actual}" unless actual == expected
+    end
+
+    expect(mismatches).to be_empty
+  end
+
+  it 'uses each direct allOf parent as its Ruby superclass' do
+    mismatches = schemas.filter_map do |name, schema|
+      parents = Array(schema['allOf']).filter_map { |parent| parent['$ref']&.split('/')&.last }
+      next unless parents.size == 1
+
+      model = PCPServerSDK::Models.const_get(name)
+      parent = PCPServerSDK::Models.const_get(parents.first)
+      "#{name}: expected #{parent}, got #{model.superclass}" unless model.superclass == parent
+    end
+
+    expect(mismatches).to be_empty
+  end
+
+  it 'inherits parent attribute accessors instead of redeclaring them' do
+    mismatches = schemas.filter_map do |name, schema|
+      parents = Array(schema['allOf']).filter_map { |parent| parent['$ref']&.split('/')&.last }
+      next unless parents.size == 1
+
+      model = PCPServerSDK::Models.const_get(name)
+      parent = PCPServerSDK::Models.const_get(parents.first)
+      redeclared = parent.attribute_map.keys.select do |attribute|
+        model.instance_method(attribute).owner == model
+      end
+      "#{name}: redeclares #{redeclared}" unless redeclared.empty?
+    end
+
+    expect(mismatches).to be_empty
+  end
+end

data/spec/models/model_base_spec.rb

@@ -0,0 +1,87 @@
+require 'spec_helper'
+require_relative '../../lib/PCP-server-Ruby-SDK'
+
+module PCPServerSDK
+  module Models
+    class ModelBaseSpecNestedModel < ModelBase
+      attribute :name, :name, :String
+    end
+
+    class ModelBaseSpecModel < ModelBase
+      attribute :name, :name, :String
+      attribute :enabled, :enabled, :Boolean
+      attribute :count, :count, :Integer
+      attribute :items, :items, 'Array<ModelBaseSpecNestedModel>'
+      attribute :metadata, :metadata, 'Hash<String, ModelBaseSpecNestedModel>'
+      attribute :nested, :nested, :ModelBaseSpecNestedModel
+    end
+
+    class ModelBaseSpecParentModel < ModelBase
+      attribute :enabled, :enabled, :Boolean, default: false
+      attribute :state, :state, :String, enum: ['ACTIVE']
+    end
+
+    class ModelBaseSpecChildModel < ModelBaseSpecParentModel
+      attribute :name, :name, :String
+    end
+  end
+end
+
+RSpec.describe PCPServerSDK::Models::ModelBase do
+  let(:model_class) { PCPServerSDK::Models::ModelBaseSpecModel }
+
+  it 'deserializes primitives, arrays, hashes, and nested models from JSON hashes' do
+    model = model_class.build_from_hash(
+      'name' => 'model',
+      'enabled' => 'false',
+      'count' => '12',
+      'items' => [{ 'name' => 'one' }],
+      'metadata' => { 'first' => { 'name' => 'two' } },
+      'nested' => { 'name' => 'three' }
+    )
+
+    expect(model.name).to eq('model')
+    expect(model.enabled).to be(false)
+    expect(model.count).to eq(12)
+    expect(model.items.first.name).to eq('one')
+    expect(model.metadata['first'].name).to eq('two')
+    expect(model.nested.name).to eq('three')
+    expect(model.to_hash).to eq(
+      name: 'model', enabled: false, count: 12,
+      items: [{ name: 'one' }], metadata: { 'first' => { name: 'two' } }, nested: { name: 'three' }
+    )
+  end
+
+  it 'preserves nil values from JSON hashes without serializing them' do
+    model = model_class.build_from_hash(
+      'name' => nil,
+      'items' => nil,
+      'metadata' => nil,
+      'nested' => nil
+    )
+
+    expect(model.name).to be_nil
+    expect(model.items).to be_nil
+    expect(model.metadata).to be_nil
+    expect(model.nested).to be_nil
+    expect(model.to_hash).to be_empty
+  end
+
+  it 'rejects unknown attributes and serializes only assigned values' do
+    expect { model_class.new(unknown: true) }.to raise_error(ArgumentError, '`unknown` is not a valid attribute')
+    expect(model_class.new(name: 'one').to_hash).to eq(name: 'one')
+  end
+
+  it 'drops nil entries from arrays during serialization' do
+    model = model_class.new(items: [nil, PCPServerSDK::Models::ModelBaseSpecNestedModel.new(name: 'one')])
+
+    expect(model.to_hash).to eq(items: [{ name: 'one' }])
+  end
+
+  it 'inherits defaults and enum validation' do
+    model = PCPServerSDK::Models::ModelBaseSpecChildModel.new(name: 'child')
+
+    expect(model.enabled).to be(false)
+    expect { model.state = 'INACTIVE' }.to raise_error(ArgumentError, 'invalid value for "state", must be one of ["ACTIVE"].')
+  end
+end