digital_femsa 1.0.0 → 1.1.1

data/spec/api/webhooks_api_spec.rb

@@ -13,106 +13,137 @@ Generator version: 7.5.0
 require 'spec_helper'
 require 'json'
 
-# Unit tests for DigitalFemsa::WebhooksApi
-# Automatically generated by openapi-generator (https://openapi-generator.tech)
-# Please update as you see appropriate
-describe 'WebhooksApi' do
-  before do
-    # run before each test
-    @api_instance = DigitalFemsa::WebhooksApi.new
-  end
+RSpec.describe DigitalFemsa::WebhooksApi do
+  let(:config) { DigitalFemsa::Configuration.new }
+  let(:api_client) { instance_double(DigitalFemsa::ApiClient) }
+  let(:api_instance) { described_class.new(api_client) }
 
-  after do
-    # run after each test
+  before do
+    allow(api_client).to receive(:config).and_return(config)
+    allow(api_client).to receive(:select_header_accept).and_return('application/vnd.app-v2.1.0+json')
+    allow(api_client).to receive(:select_header_content_type).and_return('application/json')
+    allow(api_client).to receive(:object_to_http_body) { |value| value.to_json }
   end
 
   describe 'test an instance of WebhooksApi' do
-    it 'should create an instance of WebhooksApi' do
-      expect(@api_instance).to be_instance_of(DigitalFemsa::WebhooksApi)
+    it 'creates an instance of WebhooksApi' do
+      expect(api_instance).to be_instance_of(DigitalFemsa::WebhooksApi)
     end
   end
 
-  # unit tests for create_webhook
-  # Create Webhook
-  # What we do at Femsa translates into events. For example, an event of interest to us occurs at the time a payment is successfully processed. At that moment we will be interested in doing several things: Send an email to the buyer, generate an invoice, start the process of shipping the product, etc.
-  # @param webhook_request requested field for webhook
-  # @param [Hash] opts the optional parameters
-  # @option opts [String] :accept_language Use for knowing which language to use
-  # @return [WebhookResponse]
-  describe 'create_webhook test' do
-    it 'should work' do
-      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+  describe '#create_webhook_with_http_info' do
+    it 'raises when webhook_request is missing' do
+      expect do
+        api_instance.create_webhook_with_http_info(nil)
+      end.to raise_error(ArgumentError, /Missing the required parameter 'webhook_request'/)
     end
-  end
 
-  # unit tests for delete_webhook
-  # Delete Webhook
-  # @param id Identifier of the resource
-  # @param [Hash] opts the optional parameters
-  # @option opts [String] :accept_language Use for knowing which language to use
-  # @return [WebhookResponse]
-  describe 'delete_webhook test' do
-    it 'should work' do
-      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    it 'sends POST request with serialized payload' do
+      payload = { url: 'https://example.com/hook', synchronous: false }
+
+      expect(api_client).to receive(:call_api).with(:POST, '/webhooks', hash_including(
+        operation: :'WebhooksApi.create_webhook',
+        body: payload.to_json,
+        return_type: 'WebhookResponse'
+      )).and_return([:created, 201, {}])
+
+      data = api_instance.create_webhook(payload)
+      expect(data).to eq(:created)
     end
   end
 
-  # unit tests for get_webhook
-  # Get Webhook
-  # @param id Identifier of the resource
-  # @param [Hash] opts the optional parameters
-  # @option opts [String] :accept_language Use for knowing which language to use
-  # @option opts [String] :x_child_company_id In the case of a holding company, the company id of the child company to which will process the request.
-  # @return [WebhookResponse]
-  describe 'get_webhook test' do
-    it 'should work' do
-      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+  describe '#delete_webhook_with_http_info' do
+    it 'raises when id is missing' do
+      expect do
+        api_instance.delete_webhook_with_http_info(nil)
+      end.to raise_error(ArgumentError, /Missing the required parameter 'id'/)
     end
-  end
 
-  # unit tests for get_webhooks
-  # Get List of Webhooks
-  # Consume the list of webhooks you have, each environment supports 10 webhooks (For production and testing)
-  # @param [Hash] opts the optional parameters
-  # @option opts [String] :accept_language Use for knowing which language to use
-  # @option opts [String] :x_child_company_id In the case of a holding company, the company id of the child company to which will process the request.
-  # @option opts [Integer] :limit The numbers of items to return, the maximum value is 250
-  # @option opts [String] :search General order search, e.g. by mail, reference etc.
-  # @option opts [String] :_next next page
-  # @option opts [String] :previous previous page
-  # @return [GetWebhooksResponse]
-  describe 'get_webhooks test' do
-    it 'should work' do
-      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+    it 'sends DELETE request with escaped id path' do
+      expect(api_client).to receive(:call_api).with(:DELETE, '/webhooks/whk%2F123', hash_including(
+        operation: :'WebhooksApi.delete_webhook',
+        return_type: 'WebhookResponse'
+      )).and_return([:deleted, 200, {}])
+
+      data = api_instance.delete_webhook('whk/123')
+      expect(data).to eq(:deleted)
     end
   end
 
-  # unit tests for test_webhook
-  # Test Webhook
-  # Send a webhook.ping event
-  # @param id Identifier of the resource
-  # @param [Hash] opts the optional parameters
-  # @option opts [String] :accept_language Use for knowing which language to use
-  # @return [WebhookResponse]
-  describe 'test_webhook test' do
-    it 'should work' do
-      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+  describe '#get_webhooks_with_http_info' do
+    it 'raises for limit higher than 250' do
+      expect do
+        api_instance.get_webhooks_with_http_info(limit: 251)
+      end.to raise_error(ArgumentError, /must be smaller than or equal to 250/)
+    end
+
+    it 'raises for limit lower than 1' do
+      expect do
+        api_instance.get_webhooks_with_http_info(limit: 0)
+      end.to raise_error(ArgumentError, /must be greater than or equal to 1/)
+    end
+
+    it 'maps filters into query params' do
+      expect(api_client).to receive(:call_api).with(:GET, '/webhooks', hash_including(
+        operation: :'WebhooksApi.get_webhooks',
+        query_params: {
+          limit: 25,
+          search: 'order',
+          url: 'https://example.com/hook',
+          next: 'next_token',
+          previous: 'prev_token'
+        },
+        return_type: 'GetWebhooksResponse'
+      )).and_return([:list, 200, {}])
+
+      data = api_instance.get_webhooks(
+        limit: 25,
+        search: 'order',
+        url: 'https://example.com/hook',
+        _next: 'next_token',
+        previous: 'prev_token'
+      )
+
+      expect(data).to eq(:list)
     end
   end
 
-  # unit tests for update_webhook
-  # Update Webhook
-  # updates an existing webhook
-  # @param id Identifier of the resource
-  # @param webhook_update_request requested fields in order to update a webhook
-  # @param [Hash] opts the optional parameters
-  # @option opts [String] :accept_language Use for knowing which language to use
-  # @option opts [String] :x_child_company_id In the case of a holding company, the company id of the child company to which will process the request.
-  # @return [WebhookResponse]
-  describe 'update_webhook test' do
-    it 'should work' do
-      # assertion here. ref: https://rspec.info/features/3-12/rspec-expectations/built-in-matchers/
+  describe '#test_webhook_with_http_info' do
+    it 'raises when id is missing' do
+      expect do
+        api_instance.test_webhook_with_http_info(nil)
+      end.to raise_error(ArgumentError, /Missing the required parameter 'id'/)
+    end
+
+    it 'sends POST request to test endpoint' do
+      expect(api_client).to receive(:call_api).with(:POST, '/webhooks/whk_123/test', hash_including(
+        operation: :'WebhooksApi.test_webhook',
+        return_type: 'WebhookResponse'
+      )).and_return([:tested, 200, {}])
+
+      data = api_instance.test_webhook('whk_123')
+      expect(data).to eq(:tested)
     end
   end
 
+  describe '#update_webhook_with_http_info' do
+    it 'raises when webhook_update_request is missing' do
+      expect do
+        api_instance.update_webhook_with_http_info('whk_123', nil)
+      end.to raise_error(ArgumentError, /Missing the required parameter 'webhook_update_request'/)
+    end
+
+    it 'sends PUT request with serialized payload' do
+      payload = { url: 'https://example.com/new-hook', disabled: false }
+
+      expect(api_client).to receive(:call_api).with(:PUT, '/webhooks/whk_123', hash_including(
+        operation: :'WebhooksApi.update_webhook',
+        body: payload.to_json,
+        return_type: 'WebhookResponse'
+      )).and_return([:updated, 200, {}])
+
+      data = api_instance.update_webhook('whk_123', payload)
+      expect(data).to eq(:updated)
+    end
+  end
 end

data/spec/api_client_spec.rb

@@ -0,0 +1,259 @@
+require 'spec_helper'
+require 'tempfile'
+
+RSpec.describe DigitalFemsa::ApiClient do
+  RequestOptionsStub = Struct.new(:params_encoder, :timeout)
+  RequestStub = Struct.new(:headers, :body, :params, :options, :requested_url) do
+    def url(value)
+      self.requested_url = value
+    end
+  end
+
+  let(:config) { DigitalFemsa::Configuration.new }
+  let(:api_client) { described_class.new(config) }
+
+  describe '#initialize' do
+    it 'sets default headers' do
+      expect(api_client.default_headers['Content-Type']).to eq('application/json')
+      expect(api_client.default_headers['User-Agent']).to include('RubyBindings')
+      expect(api_client.default_headers['Spin-Client-User-Agent']).to include('sdk_version=')
+    end
+  end
+
+  describe '#json_mime?' do
+    it 'returns true for json mime types and wildcard' do
+      expect(api_client.json_mime?('application/json')).to be(true)
+      expect(api_client.json_mime?('application/json; charset=UTF-8')).to be(true)
+      expect(api_client.json_mime?('*/*')).to be(true)
+    end
+
+    it 'returns false for non-json mime types' do
+      expect(api_client.json_mime?('text/plain')).to be(false)
+    end
+  end
+
+  describe '#select_header_accept' do
+    it 'returns nil when accepts are empty' do
+      expect(api_client.select_header_accept([])).to be_nil
+    end
+
+    it 'prefers json accept when present' do
+      expect(api_client.select_header_accept(%w[text/plain application/json])).to eq('application/json')
+    end
+
+    it 'joins values when json is not present' do
+      expect(api_client.select_header_accept(%w[text/plain text/html])).to eq('text/plain,text/html')
+    end
+  end
+
+  describe '#select_header_content_type' do
+    it 'returns nil when content types are empty' do
+      expect(api_client.select_header_content_type([])).to be_nil
+    end
+
+    it 'prefers json content type when present' do
+      expect(api_client.select_header_content_type(%w[text/plain application/json])).to eq('application/json')
+    end
+
+    it 'returns the first content type when json is not present' do
+      expect(api_client.select_header_content_type(%w[text/plain text/html])).to eq('text/plain')
+    end
+  end
+
+  describe '#build_request_body' do
+    it 'encodes urlencoded form body' do
+      result = api_client.build_request_body(
+        { 'Content-Type' => 'application/x-www-form-urlencoded' },
+        { 'a' => '1', 'b' => '2' },
+        nil
+      )
+
+      expect(result).to eq('a=1&b=2')
+    end
+
+    it 'builds multipart form body preserving arrays and nil values' do
+      Tempfile.create('upload') do |file|
+        file.write('content')
+        file.flush
+
+        result = api_client.build_request_body(
+          { 'Content-Type' => 'multipart/form-data' },
+          { file: file, amount: 100, tags: %w[a b], optional: nil },
+          nil
+        )
+
+        expect(result[:file]).to be_a(Faraday::FilePart)
+        expect(result[:amount]).to eq('100')
+        expect(result[:tags]).to eq(%w[a b])
+        expect(result[:optional]).to be_nil
+      end
+    end
+
+    it 'serializes hash body as json' do
+      result = api_client.build_request_body(
+        { 'Content-Type' => 'application/json' },
+        {},
+        { order: 'ord_123' }
+      )
+
+      expect(result).to eq('{"order":"ord_123"}')
+    end
+
+    it 'returns body as-is when already string' do
+      result = api_client.build_request_body(
+        { 'Content-Type' => 'application/json' },
+        {},
+        '{"raw":true}'
+      )
+
+      expect(result).to eq('{"raw":true}')
+    end
+  end
+
+  describe '#build_request' do
+    it 'builds request with auth, query params, body and url' do
+      config.access_token = 'token-123'
+      config.timeout = 45
+
+      request = RequestStub.new(nil, nil, nil, RequestOptionsStub.new(nil, nil), nil)
+
+      api_client.build_request(
+        :post,
+        'charges',
+        request,
+        header_params: { 'Content-Type' => 'application/json' },
+        query_params: { limit: 10 },
+        form_params: {},
+        body: { amount: 1000 },
+        auth_names: ['bearerAuth']
+      )
+
+      expect(request.headers['Authorization']).to eq('Bearer token-123')
+      expect(request.params).to eq(limit: 10)
+      expect(request.body).to eq('{"amount":1000}')
+      expect(request.requested_url).to eq('https://api.digitalfemsa.io/charges')
+      expect(request.options.timeout).to eq(45)
+    end
+  end
+
+  describe '#update_params_for_auth!' do
+    it 'supports query auth settings' do
+      allow(config).to receive(:auth_settings).and_return(
+        'queryAuth' => {
+          in: 'query',
+          key: 'api_key',
+          value: 'secret'
+        }
+      )
+
+      headers = {}
+      query = {}
+
+      api_client.update_params_for_auth!(headers, query, ['queryAuth'])
+
+      expect(query['api_key']).to eq('secret')
+    end
+
+    it 'raises error for unsupported auth location' do
+      allow(config).to receive(:auth_settings).and_return(
+        'badAuth' => {
+          in: 'cookie',
+          key: 'session',
+          value: 'abc'
+        }
+      )
+
+      expect do
+        api_client.update_params_for_auth!({}, {}, ['badAuth'])
+      end.to raise_error(ArgumentError, /Authentication token must be in `query` or `header`/)
+    end
+  end
+
+  describe '#sanitize_filename' do
+    it 'removes directory traversal from filename' do
+      expect(api_client.sanitize_filename('../../tmp/file.txt')).to eq('file.txt')
+      expect(api_client.sanitize_filename('C:\\tmp\\file.txt')).to eq('file.txt')
+    end
+  end
+
+  describe '#build_collection_param' do
+    it 'supports csv and multi formats' do
+      expect(api_client.build_collection_param(%w[a b], :csv)).to eq('a,b')
+      expect(api_client.build_collection_param(%w[a b], :multi)).to eq(%w[a b])
+    end
+
+    it 'raises for unknown collection format' do
+      expect do
+        api_client.build_collection_param(%w[a b], :unknown)
+      end.to raise_error(RuntimeError, /unknown collection format/)
+    end
+  end
+
+  describe '#call_api' do
+    let(:opts) do
+      {
+        header_params: { 'Content-Type' => 'application/json' },
+        query_params: {},
+        form_params: {},
+        auth_names: []
+      }
+    end
+
+    it 'raises ApiError on timeout' do
+      allow(api_client).to receive(:connection).and_raise(Faraday::TimeoutError)
+
+      expect do
+        api_client.call_api(:get, '/charges', opts)
+      end.to raise_error(DigitalFemsa::ApiError, /Connection timed out/)
+    end
+
+    it 'raises ApiError on connection failed' do
+      allow(api_client).to receive(:connection).and_raise(Faraday::ConnectionFailed)
+
+      expect do
+        api_client.call_api(:get, '/charges', opts)
+      end.to raise_error(DigitalFemsa::ApiError, /Connection failed/)
+    end
+
+    it 'raises ApiError for non-successful responses' do
+      response = instance_double(
+        'FaradayResponse',
+        success?: false,
+        status: 401,
+        headers: { 'Content-Type' => 'application/json' },
+        body: '{"error":"unauthorized"}',
+        reason_phrase: 'Unauthorized'
+      )
+
+      connection = instance_double('FaradayConnection')
+      allow(connection).to receive(:get).and_yield(double('request')).and_return(response)
+      allow(api_client).to receive(:connection).and_return(connection)
+      allow(api_client).to receive(:build_request)
+
+      expect do
+        api_client.call_api(:get, '/charges', opts)
+      end.to raise_error(DigitalFemsa::ApiError) { |error| expect(error.code).to eq(401) }
+    end
+
+    it 'returns status and headers on successful responses' do
+      response = instance_double(
+        'FaradayResponse',
+        success?: true,
+        status: 200,
+        headers: { 'X-Request-Id' => 'req_123' },
+        body: '{"ok":true}'
+      )
+
+      connection = instance_double('FaradayConnection')
+      allow(connection).to receive(:get).and_yield(double('request')).and_return(response)
+      allow(api_client).to receive(:connection).and_return(connection)
+      allow(api_client).to receive(:build_request)
+
+      data, status, headers = api_client.call_api(:get, '/charges', opts)
+
+      expect(data).to be_nil
+      expect(status).to eq(200)
+      expect(headers).to eq('X-Request-Id' => 'req_123')
+    end
+  end
+end

data/spec/models/generated_models_coverage_spec.rb

@@ -0,0 +1,152 @@
+require 'spec_helper'
+
+RSpec.describe 'Generated models coverage smoke tests' do
+  model_classes = DigitalFemsa.constants.filter_map do |const_name|
+    constant = DigitalFemsa.const_get(const_name)
+    next unless constant.is_a?(Class)
+    next unless constant.respond_to?(:attribute_map)
+    next unless constant.respond_to?(:openapi_types)
+    next unless constant.respond_to?(:build_from_hash)
+    next unless constant.respond_to?(:_deserialize)
+
+    constant
+  rescue NameError
+    nil
+  end.sort_by(&:name)
+
+  sample_value_for = lambda do |type, attr_name: nil, depth: 0|
+    return nil if depth > 2
+
+    type_name = type.to_s
+
+    return 'https://example.com/webhook' if attr_name.to_s.include?('url')
+
+    case type_name
+    when 'String'
+      attr_name.to_s.include?('email') ? 'test@example.com' : 'sample'
+    when 'Integer'
+      1
+    when 'Float'
+      1.5
+    when 'Boolean'
+      true
+    when 'Date'
+      '2024-01-01'
+    when 'Time'
+      '2024-01-01T00:00:00Z'
+    when 'Object'
+      { 'key' => 'value' }
+    when /\AArray<(?<inner_type>.+)>\z/
+      [sample_value_for.call(Regexp.last_match[:inner_type], attr_name: attr_name, depth: depth + 1)]
+    when /\AHash<(?<k_type>.+?), (?<v_type>.+)>\z/
+      {
+        sample_value_for.call(Regexp.last_match[:k_type], depth: depth + 1) =>
+          sample_value_for.call(Regexp.last_match[:v_type], depth: depth + 1)
+      }
+    else
+      {}
+    end
+  end
+
+  candidate_values_for = lambda do |type, attr_name|
+    type_name = type.to_s
+    attr_name_str = attr_name.to_s
+
+    candidates = [sample_value_for.call(type, attr_name: attr_name)]
+
+    if type_name == 'String'
+      candidates.concat(
+        %w[private public MXN USD es en active inactive pending completed card cash transfer bank_transfer charge order customer webhook]
+      )
+      candidates << 'https://example.com/webhook' if attr_name_str.include?('url')
+      candidates << 'test@example.com' if attr_name_str.include?('email')
+      candidates << 'mx' if attr_name_str.include?('country')
+    elsif type_name == 'Integer'
+      candidates.concat([0, 20, 100, 1_700_000_000])
+    elsif type_name == 'Float'
+      candidates.concat([0.0, 2.5, 10.0])
+    elsif type_name == 'Boolean'
+      candidates << false
+    elsif type_name.match?(/\AArray<.+>\z/)
+      candidates << []
+    elsif type_name.match?(/\AHash<.+>\z/)
+      candidates << {}
+    end
+
+    candidates.compact.uniq
+  end
+
+  attributes_for = lambda do |klass|
+    klass.openapi_types.each_with_object({}) do |(attr, type), attrs|
+      assigned = false
+
+      candidate_values_for.call(type, attr).each do |value|
+        begin
+          klass.new(attrs.merge(attr => value))
+          attrs[attr] = value
+          assigned = true
+          break
+        rescue StandardError
+          next
+        end
+      end
+
+      next if assigned
+
+      begin
+        klass.new(attrs.merge(attr => nil))
+        attrs[attr] = nil
+      rescue StandardError
+        # Skip attributes that require highly specific values in custom setters.
+      end
+    end
+  end
+
+  model_classes.each do |klass|
+    it "smoke-tests #{klass.name}" do
+      attrs = attributes_for.call(klass)
+
+      begin
+        instance = klass.new(attrs)
+        another_instance = klass.new(attrs)
+      rescue StandardError => e
+        skip("Skipped strict model initialization: #{e.message}")
+      end
+
+      expect(klass.acceptable_attributes).to be_a(Array)
+      expect(klass.openapi_nullable).to be_a(Set)
+
+      expect { klass.new('invalid') }.to raise_error(ArgumentError)
+      expect { klass.new('__invalid_attribute__' => 'x') }.to raise_error(ArgumentError)
+
+      expect(instance.send(:==, another_instance)).to be(true)
+      expect(instance.send(:eql?, another_instance)).to be(true)
+      expect(instance.send(:hash)).to be_a(Integer)
+      expect { instance.send(:list_invalid_properties) }.not_to raise_error
+      expect { instance.send(:valid?) }.not_to raise_error
+
+      serialized_hash = instance.send(:to_hash)
+      expect(serialized_hash).to be_a(Hash)
+      expect(instance.send(:to_body)).to eq(serialized_hash)
+      expect(instance.send(:to_s)).to be_a(String)
+      expect(instance.send(:_to_hash, [1, nil, 2])).to eq([1, 2])
+      expect(instance.send(:_to_hash, { 'a' => 1 })).to eq('a' => 1)
+
+      rebuilt = klass.build_from_hash(serialized_hash) rescue nil
+      expect(rebuilt).to be_a(klass).or be_nil
+
+      expect(klass._deserialize('String', 1)).to eq('1')
+      expect(klass._deserialize('Integer', '1')).to eq(1)
+      expect(klass._deserialize('Float', '1.2')).to eq(1.2)
+      expect(klass._deserialize('Boolean', 'true')).to be(true)
+      expect(klass._deserialize('Boolean', 'false')).to be(false)
+      expect(klass._deserialize('Object', { 'a' => 1 })).to eq('a' => 1)
+      expect(klass._deserialize('Array<String>', [1, 2])).to eq(%w[1 2])
+      expect(klass._deserialize('Hash<String, Integer>', { 'a' => '1' })).to eq('a' => 1)
+      expect(klass._deserialize('Date', '2024-01-01')).to be_a(Date)
+      expect(klass._deserialize('Time', '2024-01-01T00:00:00Z')).to be_a(Time)
+      expect { klass._deserialize(klass.name.split('::').last, {}) rescue nil }.not_to raise_error
+
+    end
+  end
+end