digital_femsa 1.1.0 → 1.1.2

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/checkout_request_redirection_time_spec.rb

@@ -0,0 +1,61 @@
+require 'spec_helper'
+
+RSpec.describe DigitalFemsa::CheckoutRequest, type: :model do
+  describe 'redirection_time field' do
+    let(:valid_attributes) do
+      {
+        allowed_payment_methods: %w[card cash],
+        expires_at: 1_700_000_000,
+        name: 'Test checkout',
+        type: 'HostedPayment',
+        redirection_time: 30
+      }
+    end
+
+    it 'declares the attribute via attr_accessor' do
+      expect(DigitalFemsa::CheckoutRequest.instance_methods).to include(:redirection_time, :redirection_time=)
+    end
+
+    it 'maps the attribute in attribute_map' do
+      expect(DigitalFemsa::CheckoutRequest.attribute_map).to have_key(:redirection_time)
+    end
+
+    it 'declares the attribute type in openapi_types' do
+      expect(DigitalFemsa::CheckoutRequest.openapi_types).to have_key(:redirection_time)
+    end
+
+    it 'accepts redirection_time in the constructor' do
+      instance = DigitalFemsa::CheckoutRequest.new(valid_attributes)
+      expect(instance.redirection_time).to eq(30)
+    end
+
+    it 'serializes redirection_time in to_hash' do
+      instance = DigitalFemsa::CheckoutRequest.new(valid_attributes)
+      expect(instance.to_hash[:redirection_time]).to eq(30)
+    end
+
+    it 'round-trips redirection_time through build_from_hash' do
+      instance = DigitalFemsa::CheckoutRequest.new(valid_attributes)
+      rebuilt = DigitalFemsa::CheckoutRequest.build_from_hash(instance.to_hash)
+      expect(rebuilt.redirection_time).to eq(30)
+    end
+
+    it 'includes redirection_time in equality comparison' do
+      instance = DigitalFemsa::CheckoutRequest.new(valid_attributes)
+      other = DigitalFemsa::CheckoutRequest.new(valid_attributes)
+      expect(instance).to eq(other)
+
+      other.redirection_time = 60
+      expect(instance).not_to eq(other)
+    end
+
+    it 'includes redirection_time in hash' do
+      instance = DigitalFemsa::CheckoutRequest.new(valid_attributes)
+      other = DigitalFemsa::CheckoutRequest.new(valid_attributes)
+      expect(instance.hash).to eq(other.hash)
+
+      other.redirection_time = 60
+      expect(instance.hash).not_to eq(other.hash)
+    end
+  end
+end