pcp-server-ruby-sdk 1.12.0 → 1.14.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/queries/get_checkouts_query.rb

@@ -15,7 +15,8 @@ module PCPServerSDK
                     :include_payment_product_id, :include_checkout_status,
                     :include_extended_checkout_status, :include_payment_channel,
                     :payment_reference, :payment_id, :first_name, :surname,
-                    :email, :phone_number, :date_of_birth, :company_information, :terminal_id, :reporting_token
+                    :email, :phone_number, :date_of_birth, :company_information, :terminal_id, :reporting_token,
+                    :card_authorization_id, :receipt_number, :trace_number
     
       def initialize
         @include_payment_product_id = []
@@ -60,6 +61,9 @@ module PCPServerSDK
         query['companyInformation'] = @company_information if @company_information
         query['terminalId'] = @terminal_id if @terminal_id
         query['reportingToken'] = @reporting_token if @reporting_token
+        query['cardAuthorizationId'] = @card_authorization_id if @card_authorization_id
+        query['receiptNumber'] = @receipt_number if @receipt_number
+        query['traceNumber'] = @trace_number if @trace_number
     
         query
       end

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

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

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

@@ -6,6 +6,8 @@ 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'
+require_relative 'PCP-server-Ruby-SDK/endpoints/pay_by_link_api_client'
 
 # Errors
 require_relative 'PCP-server-Ruby-SDK/errors/api_error_response_exception'
@@ -37,6 +39,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 +69,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 +116,20 @@ 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/create_pay_by_link_request'
+require_relative 'PCP-server-Ruby-SDK/models/create_pay_by_link_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_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'
@@ -121,10 +139,15 @@ require_relative 'PCP-server-Ruby-SDK/models/payment_product3392_specific_input'
 require_relative 'PCP-server-Ruby-SDK/models/payment_product5002_specific_input'
 require_relative 'PCP-server-Ruby-SDK/models/payment_product771_specific_output'
 require_relative 'PCP-server-Ruby-SDK/models/payment_product840_customer_account'
+require_relative 'PCP-server-Ruby-SDK/models/payment_product840_customer_account_for_intent'
 require_relative 'PCP-server-Ruby-SDK/models/payment_product840_specific_output'
 require_relative 'PCP-server-Ruby-SDK/models/payment_references'
+require_relative 'PCP-server-Ruby-SDK/models/payment_references_for_payment_intent'
 require_relative 'PCP-server-Ruby-SDK/models/payment_references_for_refund'
 require_relative 'PCP-server-Ruby-SDK/models/payment_response'
+require_relative 'PCP-server-Ruby-SDK/models/payment_link_order'
+require_relative 'PCP-server-Ruby-SDK/models/payment_link_specific_input'
+require_relative 'PCP-server-Ruby-SDK/models/pay_link_status_value'
 require_relative 'PCP-server-Ruby-SDK/models/payment_status_output'
 require_relative 'PCP-server-Ruby-SDK/models/payment_type'
 require_relative 'PCP-server-Ruby-SDK/models/payout_output'
@@ -159,7 +182,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.14.0",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "pcp-serversdk-ruby",
-      "version": "1.12.0",
+      "version": "1.14.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.14.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/pay_by_link_api_client_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+require 'net/http'
+require 'json'
+require_relative '../../lib/PCP-server-Ruby-SDK.rb'
+
+RSpec.describe PCPServerSDK::Endpoints::PayByLinkApiClient do
+  let(:config) { mock_communicator_config }
+  let(:client) { described_class.new(config) }
+  let(:payload) { double('PCPServerSDK::Models::CreatePayByLinkRequest') }
+  let(:response) do
+    double(
+      'Response',
+      body: '{"status":"ACTIVE","paymentLinkId":"707ef15b-7a0a-48f2-b7d8-c95103418a9c"}',
+      code: 201
+    )
+  end
+
+  before do
+    allow(client).to receive(:get_response).and_return(response)
+  end
+
+  describe '#create_pay_by_link_request' do
+    it 'posts to the pay-by-link endpoint and deserializes its response' do
+      result = client.create_pay_by_link_request('1', '2', '3', payload)
+
+      expect(result).to be_a(PCPServerSDK::Models::CreatePayByLinkResponse)
+      expect(result.status).to eq('ACTIVE')
+      expect(result.payment_link_id).to eq('707ef15b-7a0a-48f2-b7d8-c95103418a9c')
+    end
+
+    it 'requires all path parameters and the payload' do
+      expect { client.create_pay_by_link_request(nil, '2', '3', payload) }.to raise_error(TypeError, 'Merchant ID is required')
+      expect { client.create_pay_by_link_request('1', nil, '3', payload) }.to raise_error(TypeError, 'Commerce Case ID is required')
+      expect { client.create_pay_by_link_request('1', '2', nil, payload) }.to raise_error(TypeError, 'Checkout ID is required')
+      expect { client.create_pay_by_link_request('1', '2', '3', nil) }.to raise_error(TypeError, 'Payload is required')
+    end
+  end
+end

data/spec/endpoints/payment_information_api_client_spec.rb

@@ -17,8 +17,13 @@ RSpec.describe PCPServerSDK::Endpoints::PaymentInformationApiClient do
     let(:payload) { double('PCPServerSDK::Models::PaymentInformationRequest') }
 
     context 'when request is successful' do
-      let(:response) { double('Response', body: '{}', code: '200') }
-      let(:expected_response) { PCPServerSDK::Models::PaymentInformationResponse.new }
+      let(:response) { double('Response', body: '{"traceNumber":"trace-123","receiptNumber":"receipt-123"}', code: '200') }
+      let(:expected_response) do
+        PCPServerSDK::Models::PaymentInformationResponse.new(
+          trace_number: 'trace-123',
+          receipt_number: 'receipt-123'
+        )
+      end
 
       before do
         allow(client).to receive(:get_response).and_return(response)
@@ -27,6 +32,8 @@ RSpec.describe PCPServerSDK::Endpoints::PaymentInformationApiClient do
       it 'returns a successful response' do
         result = client.create_payment_information('1', '2', '3', payload)
         expect(result).to eq(expected_response)
+        expect(result.trace_number).to eq('trace-123')
+        expect(result.receipt_number).to eq('receipt-123')
       end
     end
 

data/spec/endpoints/payment_intent_api_client_spec.rb

@@ -0,0 +1,45 @@
+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(
+        references: PCPServerSDK::Models::PaymentReferencesForPaymentIntent.new(merchant_reference: 'order-123')
+      )
+      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