wire4_auth 1.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 4fd2430cb43f273cdee5c8af44d37da774c6c6b30d9ea219f19ed5eeb34475b1
+  data.tar.gz: 9408b9d5f8a8ed9121dbbb841e51fc8cbe1fbf1c0d7817168eadbb0ade5b3516
+SHA512:
+  metadata.gz: 5d143702786369d5217e53f2dfa9d0bee468477b940f3e02cc915bdc4c83a6c9f770465f87de471491c85ccee302901708ff3db33cad05ae5e7504c7901cff8d
+  data.tar.gz: 2cd2d6d6ef043213af030b574ed6bd977236572cb5941e7aca6b1883a79fbe8b8e2ddb2b2f6c94d6e78536155d1ddf2e780c9a5cdfd69678316e455a533d5a9b

data/Gemfile

@@ -0,0 +1,8 @@
+source 'https://rubygems.org'
+
+gemspec
+
+group :development, :test do
+  gem 'oauth2', '~> 1.4.3'
+  gem 'wire4_client', '~> 1.0.3'
+end

data/Gemfile.lock

@@ -0,0 +1,51 @@
+PATH
+  remote: .
+  specs:
+    wire4_auth (1.0.3)
+      oauth2 (~> 1.4, >= 1.4.3)
+      wire4_client (~> 1.0, >= 1.0.3)
+
+PATH
+  remote: /Users/saintiago/tcpip/git-repositories/speiok/wire4-api-sdk-ruby/sdk-client
+  specs:
+    wire4_client (1.0.3)
+      json (~> 2.1, >= 2.1.0)
+      typhoeus (~> 1.0, >= 1.0.1)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    ethon (0.12.0)
+      ffi (>= 1.3.0)
+    faraday (1.0.0)
+      multipart-post (>= 1.2, < 3)
+    ffi (1.12.1)
+    json (2.3.0)
+    jwt (2.2.1)
+    multi_json (1.14.1)
+    multi_xml (0.6.0)
+    multipart-post (2.1.1)
+    oauth2 (1.4.3)
+      faraday (>= 0.8, < 2.0)
+      jwt (>= 1.0, < 3.0)
+      multi_json (~> 1.3)
+      multi_xml (~> 0.5)
+      rack (>= 1.2, < 3)
+    power_assert (1.1.3)
+    rack (2.1.2)
+    test-unit (3.3.5)
+      power_assert
+    typhoeus (1.3.1)
+      ethon (>= 0.9.0)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  oauth2 (~> 1.4.3)
+  test-unit (~> 3.3, >= 3.3.5)
+  wire4_auth!
+  wire4_client (~> 1.0.3)!
+
+BUNDLED WITH
+   1.17.3

data/lib/wire4_auth.rb

@@ -0,0 +1,32 @@
+# -*- encoding: utf-8 -*-
+
+#    COPYRIGHT © 2017. TCPIP.
+#    PATENT PENDING. ALL RIGHTS RESERVED.
+#    SPEI GATEWAY IS REGISTERED TRADEMARKS OF TCPIP.
+#
+#    This software is confidential and proprietary information of TCPIP.
+#    You shall not disclose such Confidential Information and shall use it only
+#    in accordance with the company policy.
+
+=begin
+#Wire4Auth
+
+Fecha de creación: 11 de diciembre, 2019
+author: Saintiago García
+version: 1.0
+=end
+
+require 'wire4_auth/version'
+
+require 'wire4_auth/auth/oauth_wire4'
+
+require 'wire4_auth/core/cached_token'
+require 'wire4_auth/core/environment_enum'
+
+require 'wire4_auth/webhook_verification_signature/utils_compute'
+
+module Wire4Auth
+  class << self
+    # Nothing more to do now
+  end
+end

data/lib/wire4_auth/auth/oauth_wire4.rb

@@ -0,0 +1,169 @@
+# -*- encoding: utf-8 -*-
+
+#    COPYRIGHT © 2017. TCPIP.
+#    PATENT PENDING. ALL RIGHTS RESERVED.
+#    SPEI GATEWAY IS REGISTERED TRADEMARKS OF TCPIP.
+#
+#    This software is confidential and proprietary information of TCPIP.
+#    You shall not disclose such Confidential Information and shall use it only
+#    in accordance with the company policy.
+
+=begin
+#Wire4Auth
+
+Fecha de creación: 11 de diciembre, 2019
+author: Saintiago García
+version: 1.0
+=end
+
+require 'oauth2'
+require 'wire4_client'
+require 'wire4_auth/core/cached_token'
+require 'wire4_auth/core/environment_enum'
+
+module Wire4Auth
+  class OAuthWire4
+
+    MAX_APP_USER_SIZE_CACHED = 100
+
+    # accessor get method
+    attr_reader :client_id
+
+    # accessor get method
+    attr_reader :client_secret
+
+    # accessor get method
+    attr_reader :environment
+
+    def initialize(client_id, client_secret, environment)
+
+      raise 'Not EnvironmentEnum class instance' unless environment.is_a? Wire4Auth::EnvironmentEnum
+
+      @client_id = client_id
+      @client_secret = client_secret
+      @environment = environment
+
+      @token_cached_app = Wire4Auth::CachedToken.new(nil, nil, nil)
+      @tokens_cached_app_user = {}
+    end
+
+    def obtain_access_token_app(scope = "general")
+
+      if !@token_cached_app.access_token.nil? and !@token_cached_app.access_token.params.nil? and
+          !@token_cached_app.access_token.params['scope'].nil? and
+          @token_cached_app.access_token.params['scope'].include? scope and
+          !@token_cached_app.access_token.expires_at.nil? and @token_cached_app.access_token.expires_at.is_a? Integer and
+          is_expire(@token_cached_app.access_token.expires_at) and !@token_cached_app.access_token.token.nil?
+
+        return format_to_header(@token_cached_app.access_token.token)
+      end
+
+      begin
+        client = OAuth2::Client.new(@client_id, @client_secret, :token_url => @environment.token_url)
+        access_token = client.get_token({:grant_type => "client_credentials", :scope => scope})
+        @token_cached_app.access_token = access_token
+
+        return format_to_header(access_token.token)
+      rescue OAuth2::Error => e
+        raise Wire4Client::ApiError.new(:code => e.code,
+                           :message => e.description)
+      end
+    end
+
+    def obtain_access_token_app_user(user_key, secret_key, scope = "spei_admin")
+
+      key_search = user_key + scope
+      token_cached = @tokens_cached_app_user[key_search]
+      if !token_cached.nil? and !token_cached.access_token.nil? and !token_cached.access_token.params.nil? and
+          !token_cached.access_token.params['scope'].nil? and token_cached.access_token.params['scope'].include? scope and
+          !token_cached.access_token.expires_at.nil? and token_cached.access_token.expires_at.is_a? Integer and
+          is_expire(token_cached.access_token.expires_at) and !token_cached.access_token.token.nil?
+
+        return format_to_header(token_cached.access_token.token)
+      end
+
+      begin
+        client = OAuth2::Client.new(@client_id, @client_secret, :token_url => @environment.token_url)
+        access_token = client.get_token({ :grant_type => "password", :scope => scope,
+                                                  :username => user_key, :password => secret_key })
+
+        if @tokens_cached_app_user.length + 1 > MAX_APP_USER_SIZE_CACHED
+          @tokens_cached_app_user.each_key do |key|
+            @tokens_cached_app_user.delete(key)
+            break
+          end
+        end
+
+        @tokens_cached_app_user[key_search] = Wire4Auth::CachedToken.new(user_key, secret_key, access_token)
+
+        return format_to_header(access_token.token)
+      rescue OAuth2::Error => e
+        raise Wire4Client::ApiError.new(:code => e.code,
+                           :message => e.description)
+      end
+    end
+
+    def regenerate_access_token_app(scope = "general")
+
+      begin
+        client = OAuth2::Client.new(@client_id, @client_secret, :token_url => @environment.token_url)
+        access_token = client.get_token({:grant_type => "client_credentials", :scope => scope})
+        @token_cached_app.access_token = access_token
+
+        return format_to_header(access_token.token)
+      rescue OAuth2::Error => e
+        raise Wire4Client::ApiError.new(:code => e.code,
+                                        :message => e.description)
+      end
+    end
+
+    def regenerate_access_token_app_user(user_key, secret_key, scope = "spei_admin")
+
+      begin
+        client = OAuth2::Client.new(@client_id, @client_secret, :token_url => @environment.token_url)
+        access_token = client.get_token({ :grant_type => "password", :scope => scope,
+                                          :username => user_key, :password => secret_key })
+
+        key_search = user_key + scope
+        token_cached = @tokens_cached_app_user[key_search]
+        if token_cached.nil? and @tokens_cached_app_user.length + 1 > MAX_APP_USER_SIZE_CACHED
+          @tokens_cached_app_user.each_key do |key|
+            @tokens_cached_app_user.delete(key)
+            break
+          end
+        end
+
+        @tokens_cached_app_user[key_search] = Wire4Auth::CachedToken.new(user_key, secret_key, access_token)
+
+        return format_to_header(access_token.token)
+      rescue OAuth2::Error => e
+        raise Wire4Client::ApiError.new(:code => e.code,
+                                        :message => e.description)
+      end
+    end
+
+    def config_default_api_client
+      # Setup authorization
+      Wire4Client.configure do |config|
+        # Configure OAuth2 access token for authorization
+        config.host = @environment.service_url
+      end
+    end
+
+    private
+
+    def is_expire(expires_at)
+
+      time = Time.at(expires_at)
+      # Get current time using the time zone
+      now = Time.now - 5 * 60 # minus 5 minutes
+
+      time > now
+    end
+
+    def format_to_header(token)
+
+      "Bearer " + token
+    end
+  end
+end

data/lib/wire4_auth/core/cached_token.rb

@@ -0,0 +1,38 @@
+# -*- encoding: utf-8 -*-
+
+#    COPYRIGHT © 2017. TCPIP.
+#    PATENT PENDING. ALL RIGHTS RESERVED.
+#    SPEI GATEWAY IS REGISTERED TRADEMARKS OF TCPIP.
+#
+#    This software is confidential and proprietary information of TCPIP.
+#    You shall not disclose such Confidential Information and shall use it only
+#    in accordance with the company policy.
+
+=begin
+#Wire4Auth
+
+Fecha de creación: 13 de diciembre, 2019
+author: Saintiago García
+version: 1.0
+=end
+
+require 'oauth2'
+
+module Wire4Auth
+  class CachedToken
+    attr_reader :user_key
+
+    attr_reader :user_secret
+
+    attr_accessor :access_token
+
+    def initialize(user_key, user_secret, access_token)
+
+      raise 'Not OAuth2::AccessToken class instance' unless access_token.nil? or access_token.is_a? OAuth2::AccessToken
+
+      @user_key = user_key
+      @user_secret = user_secret
+      @access_token = access_token
+    end
+  end
+end

data/lib/wire4_auth/core/environment_enum.rb

@@ -0,0 +1,42 @@
+# -*- encoding: utf-8 -*-
+
+#    COPYRIGHT © 2017. TCPIP.
+#    PATENT PENDING. ALL RIGHTS RESERVED.
+#    SPEI GATEWAY IS REGISTERED TRADEMARKS OF TCPIP.
+#
+#    This software is confidential and proprietary information of TCPIP.
+#    You shall not disclose such Confidential Information and shall use it only
+#    in accordance with the company policy.
+
+=begin
+#Wire4Auth
+
+Fecha de creación: 11 de diciembre, 2019
+author: Saintiago García
+version: 1.0
+=end
+
+module Wire4Auth
+  class EnvironmentEnum
+
+    attr_reader :token_url
+
+    attr_reader :service_url
+
+    def initialize(token_url, service_url)
+      @token_url = token_url
+      @service_url = service_url
+    end
+
+    SANDBOX = new("https://sandbox-api.wire4.mx/token", "sandbox-api.wire4.mx")
+
+    DEVELOPMENT  = new('https://development-api.wire4.mx/token', 'development-api.wire4.mx')
+
+    PRODUCTION = new("https://api.wire4.mx/token", "api.wire4.mx")
+
+    class << self
+      private :new
+    end
+  end
+end
+

data/lib/wire4_auth/testing.rb

@@ -0,0 +1,1176 @@
+#!/usr/bin/env ruby
+# -*- encoding: utf-8 -*-
+
+#    COPYRIGHT © 2017. TCPIP.
+#    PATENT PENDING. ALL RIGHTS RESERVED.
+#    SPEI GATEWAY IS REGISTERED TRADEMARKS OF TCPIP.
+#
+#    This software is confidential and proprietary information of TCPIP.
+#    You shall not disclose such Confidential Information and shall use it only
+#    in accordance with the company policy.
+
+=begin
+#Wire4Auth
+
+Fecha de creación: 11 de diciembre, 2019
+author: Saintiago García
+version: 1.0
+=end
+
+require 'test/unit'
+require 'wire4_auth/auth/oauth_wire4'
+require 'wire4_auth/webhook_verification_signature/utils_compute'
+require 'wire4_client'
+
+#noinspection RubyTooManyMethodsInspection
+class Wire4ExamplesTest < Test::Unit::TestCase
+
+  CLIENT_ID = "FxUWmqYGZuv8O1qjxstvIyJothMa"
+
+  CLIENT_SECRET = "kjwbkrPVgXsnaUGzthj55dsFhx4a"
+
+  USER_KEY = "071e2b59b354186b3a0158de493536@sandbox.wire4.mx"
+
+  SECRET_KEY = "0d1e33e94604f01b4e00d2fcb6b48f"
+
+  SUBSCRIPTION = "f1504fea-3a8f-475a-a50a-90d3c40efc59"
+
+  def test_send_contact
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "general" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app('general')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::ContactoApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    body = Wire4Client::ContactRequest.new
+    body.address = "Calle Falsa 123, Col Fantasía"
+    body.company = "Compu Mundo Hiper Mega Red"
+    body.contact_person = "Homer J Simpson"
+    body.email = "homer.simpson@compumundohipermegared.com"
+    body.phone_number = "4422102030"
+
+    begin
+      # Call the API
+      response = api_instance.send_contact_using_post_with_http_info(authorization, body)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+  end
+
+  def test_obtain_cep
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "general" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app('general')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::ComprobanteElectrnicoDePagoCEPApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    cep_data = Wire4Client::CepSearchBanxico.new # CepSearchBanxico | Información para buscar un CEP
+    cep_data.amount = 8963.25
+    cep_data.beneficiary_account = '072680004657656853'
+    cep_data.beneficiary_bank_key = '40072'
+    cep_data.clave_rastreo = '58735618'
+    cep_data.operation_date = '05-12-2018'
+    cep_data.reference = '1122334'
+    cep_data.sender_account = '112680000156896531'
+    cep_data.sender_bank_key = '40112'
+
+    begin
+      # Call the API
+      response = api_instance.obtain_transaction_cep_using_post(authorization, cep_data)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_make_pre_subscription
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "general" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app('general')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::SuscripcionesApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    body = Wire4Client::PreEnrollmentData.new
+    body.cancel_return_url = "https://your-app-url.mx/return"
+    body.return_url = "https://your-app-url.mx/cancel"
+
+    begin
+      # Call the API
+      response = api_instance.pre_enrollment_monex_user_using_post(authorization, body)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_delete_pre_subscription
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "general" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app('general')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::SuscripcionesApi.new
+
+    # build body with info (check references for more info, types, required fields)
+    subscription = "55af515a-43ec-4537-96a4-489d1deef127"
+
+    begin
+      # Call the API
+      response = api_instance.remove_subscription_pending_status_using_delete_with_http_info(authorization, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  #noinspection RubyLocalVariableNamingConvention
+  def test_delete_subscription
+    omit('Reason')
+    subscription_to_remove_user_key = "e7446202e95421dbb3c1b914e15c74@sandbox.wire4.mx"
+    subscription_to_remove_user_secret = "8617fa525ca4140b545b66c5adcbb1"
+
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(subscription_to_remove_user_key,
+                                                               subscription_to_remove_user_secret, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::SuscripcionesApi.new
+
+    # build body with info (check references for more info, types, required fields)
+    subscription = "5873240b-cf69-456a-ab5a-88f5e79ab4b8"
+
+    begin
+      # Call the API
+      response = api_instance.remove_enrollment_user_using_delete_with_http_info(authorization, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_obtain_relationships
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::CuentasDeBeneficiariosSPEIApi.new
+
+    # build body with info (check references for more info, types, required fields)
+    subscription = SUBSCRIPTION
+
+    begin
+      # Call the API
+      response = api_instance.get_available_relationships_monex_using_get(authorization, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  #noinspection RubyInstanceMethodNamingConvention
+  def test_pre_register_beneficiaries
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::CuentasDeBeneficiariosSPEIApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+    body = Wire4Client::AccountRequest.new
+    body.return_url = "https://your-app-url.mx/return"
+    body.cancel_return_url = "https://your-app-url.mx/cancel"
+    account = Wire4Client::Account.new
+    account.amount_limit = 10000.00
+    account.beneficiary_account = "112680000156896531"
+    account.email = ["beneficiary@wire4.mx"]
+    account.kind_of_relationship = "RECURRENTE"
+    account.numeric_reference_spei = "1234567"
+    account.payment_concept_spei = "concept spei"
+    person = Wire4Client::Person.new
+    person.last_name = "Simpson"
+    person.middle_name = "Jay"
+    person.name = "Bartolomeo"
+    account.person = person
+    account.relationship = "ACREEDOR"
+    account.rfc = "SJBA920125AB1"
+    body.accounts = [account]
+
+    begin
+      # Call the API
+      response = api_instance.pre_register_accounts_using_post(authorization, body, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  #noinspection RubyInstanceMethodNamingConvention
+  def test_remove_beneficiaries_pending
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::CuentasDeBeneficiariosSPEIApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+    request_id = "b782a20b-d92c-4fd9-a5cc-33a88e9b0a79"
+
+    begin
+      # Call the API
+      response = api_instance.remove_beneficiaries_pending_using_delete_with_http_info(authorization, request_id, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_obtain_beneficiaries
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::CuentasDeBeneficiariosSPEIApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+
+    begin
+      # Call the API
+      # response = api_instance.get_beneficiaries_for_account_using_get(subscription, rfc: "RFCE010980AR3")
+      # response = api_instance.get_beneficiaries_for_account_using_get(subscription, account: "RFCE010980AR3")
+      # response = api_instance.get_beneficiaries_for_account_using_get(subscription, rfc: "RFCE010980AR3, account: "RFCE010980AR3")
+      response = api_instance.get_beneficiaries_for_account_using_get(authorization, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_obtain_beneficiaries_by_request_id
+    #omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new("kIinyEIYWUIF3pflFxhRdKft2_ga", "A_ffMFosMhm5j7l0L7Ptvbfrp9Ma", Wire4Auth::EnvironmentEnum::DEVELOPMENT)
+        #CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user("0bb13bfb99d461a8a0e18746b25e7d@develop.wire4.mx", "0b6ea839f33467a81631b380d37472", 'spei_admin')
+          # USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::CuentasDeBeneficiariosSPEIApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+    request_id = ""
+
+    begin
+      # Call the API
+      response = api_instance.get_beneficiaries_by_request_id(authorization, request_id, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  #noinspection RubyInstanceMethodNamingConvention
+  def test_change_amount_limit_beneficiary
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::CuentasDeBeneficiariosSPEIApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+    account = "112680000156896531"
+    body = Wire4Client::AmountRequest.new
+    body.amount_limit = 20000.00
+    body.currency_code = "MXP"
+    body.previous_amount_limit = 10000.00
+
+    begin
+      # Call the API
+      response = api_instance.update_amount_limit_account_using_put_with_http_info(authorization, account, body, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_delete_beneficiary
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::CuentasDeBeneficiariosSPEIApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+    account = "112680000156896531"
+
+    begin
+      # Call the API
+      response = api_instance.delete_account_using_delete_with_http_info(authorization, account, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_obtain_institutions
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "general" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app('general')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::InstitucionesApi.new
+
+    begin
+      # Call the API
+      response = api_instance.get_all_institutions_using_get(authorization)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_obtain_balance
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::SaldoApi.new
+
+    # build body with info (check references for more info, types, required fields)
+    subscription = SUBSCRIPTION
+
+    begin
+      # Call the API
+      response = api_instance.get_balance_using_get(authorization, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  #noinspection RubyInstanceMethodNamingConvention
+  def test_obtain_SPID_classifications
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spid_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spid_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::TransferenciasSPIDApi.new
+
+    # build body with info (check references for more info, types, required fields)
+    subscription = SUBSCRIPTION
+
+    begin
+      # Call the API
+      response = api_instance.get_spid_classifications_using_get(authorization, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  #noinspection RubyInstanceMethodNamingConvention
+  def test_pre_register_beneficiaries_SPID
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spid_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spid_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::CuentasDeBeneficiariosSPIDApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+    body = Wire4Client::AccountSpid.new
+    body.return_url = "https://your-app-url.mx/return"
+    body.cancel_return_url = "https://your-app-url.mx/cancel"
+    body.amount_limit = 10000.00
+    body.beneficiary_account = "112680000156896531"
+    body.email = ["beneficiary.spid@wire4.mx"]
+    body.institution = Wire4Client::BeneficiaryInstitution.new(name: "BMONEX")
+    body.kind_of_relationship = "RECURRENTE"
+    body.numeric_reference = "1234567"
+    body.payment_concept = "concept spei"
+    body.relationship = "ACREEDOR"
+    body.rfc = "SJBA920125AB1"
+
+    begin
+      # Call the API
+      response = api_instance.pre_register_accounts_using_post1(authorization, body, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_obtain_beneficiaries_spid
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spid_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::CuentasDeBeneficiariosSPIDApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+
+    begin
+      # Call the API
+      # response = api_instance.get_beneficiaries_for_account_using_get(subscription, rfc: "RFCE010980AR3")
+      # response = api_instance.get_beneficiaries_for_account_using_get(subscription, account: "RFCE010980AR3")
+      # response = api_instance.get_beneficiaries_for_account_using_get(subscription, rfc: "RFCE010980AR3, account: "RFCE010980AR3")
+      response = api_instance.get_spid_beneficiaries_for_account(authorization, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_get_depositants
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::DepositantesApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+
+    begin
+      # Call the API
+      response = api_instance.get_depositants_using_get(authorization, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_register_depositants
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::DepositantesApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+    body = Wire4Client::DepositantsRegister.new
+    body._alias = "Depositant 0292921"
+    body.currency_code = "MXP"
+    body.email = ["depositant@wire4.mx"]
+    body.name = "Marge Bouvier"
+
+    begin
+      # Call the API
+      response = api_instance.register_depositants_using_post(authorization, body, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  #noinspection RubyInstanceMethodNamingConvention
+  def test_incoming_SPEI_transactions_report
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::TransferenciasSPEIApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+
+    begin
+      # Call the API
+      response = api_instance.incoming_spei_transactions_report_using_get(authorization, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  #noinspection RubyInstanceMethodNamingConvention
+  def test_outgoing_SPEI_transactions_report
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::TransferenciasSPEIApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+
+    begin
+      # Call the API
+      response = api_instance.outgoing_spei_transactions_report_using_get(authorization, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  #noinspection RubyInstanceMethodNamingConvention
+  def test_out_comming_spei_request_id_transactions_report_using_get
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::TransferenciasSPEIApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+    request_id = '6a9efe39-a795-4e09-8f7f-197e647a0f8b'
+
+    begin
+      # Call the API
+      response = api_instance.out_comming_spei_request_id_transactions_report_using_get(authorization, request_id, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling TransferenciasSPEIApi->out_comming_spei_request_id_transactions_report_using_get: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  #noinspection RubyInstanceMethodNamingConvention
+  def test_register_outgoing_SPEI_transaction
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::TransferenciasSPEIApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+    body = Wire4Client::TransactionsOutgoingRegister.new
+    body.return_url = "https://your-app-url.mx/return"
+    body.cancel_return_url = "https://your-app-url.mx/cancel"
+    transaction = Wire4Client::TransactionOutgoing.new
+    transaction.order_id = "137f14a4-9e12-4a98-bbd1-ab347753e68a"
+    transaction.amount = 1259.69
+    transaction.beneficiary_account = "112680000156896531"
+    transaction.currency_code = "MXP"
+    transaction.email = ["notificar@wire4.mx"]
+    transaction.reference = 1234567
+    transaction.concept = "Transfer out test 1"
+    body.transactions = [transaction]
+
+    begin
+      # Call the API
+      response = api_instance.register_outgoing_spei_transaction_using_post(authorization, subscription, body)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  #noinspection RubyInstanceMethodNamingConvention
+  def test_delete_outgoing_pending_SPEI_transaction
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spei_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spei_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::TransferenciasSPEIApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+    request_id = "8abc184f-c3ac-4abd-9045-a9b4a501f007"
+
+    begin
+      # Call the API
+      response = api_instance.drop_transactions_pending_using_delete_with_http_info(authorization, request_id, subscription)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  #noinspection RubyInstanceMethodNamingConvention
+  def test_register_outgoing_SPID_transaction
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "spid_admin" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app_user(USER_KEY, SECRET_KEY, 'spid_admin')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::TransferenciasSPIDApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    subscription = SUBSCRIPTION
+    body = Wire4Client::TransactionOutgoingSpid.new
+    body.return_url = "https://your-app-url.mx/return"
+    body.cancel_return_url = "https://your-app-url.mx/cancel"
+    body.amount = 1259.69
+    body.beneficiary_account = "112680000156896531"
+    body.classification_id = "01"
+    body.currency_code = "USD"
+    body.email = ["notificar@wire4.mx"]
+    body.numeric_reference_spid = 1234567
+    body.order_id = "77baa78f-be22-4f6a-b79e-60b20a198324"
+    body.payment_concept_spid = "Transfer out test 1"
+
+    begin
+      # Call the API
+      response = api_instance.register_outgoing_spid_transaction_using_post(authorization, subscription, body)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_register_web_hook
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "general" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app('general')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::WebhooksApi.new
+
+    # build body with info (check references for more info: types, required fields, etc.)
+    body = Wire4Client::WebhookRequest.new # CepSearchBanxico | Información para buscar un CEP
+    body.events = %w(ACCOUNT.CREATED TRANSACTION.OUTGOING.RECEIVED ENROLLMENT.CREATED)
+    body.name = "RUBY TEST SDK WEBHOOK-REGISTER"
+    body.url = "https://www.webhook.site/39034a03-8faf-424e-bb4a-7c3fee2bbfd3"
+
+    begin
+      # Call the API
+      response = api_instance.register_webhook(authorization, body)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_get_web_hooks
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "general" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app('general')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::WebhooksApi.new
+
+    begin
+      # Call the API
+      response = api_instance.get_webhooks(authorization)
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_get_web_hook_by_id
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+
+    begin
+      # Obtain an access token use application flow and scope "general" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app('general')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::WebhooksApi.new
+
+    begin
+      # Call the API
+      response = api_instance.get_webhook(authorization, "wh_3fe3e5f4849f4cabb147804fd55c86fc")
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_get_facturas
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+
+    #oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+    oauth_wire4 = Wire4Auth::OAuthWire4.new("kIinyEIYWUIF3pflFxhRdKft2_ga",
+                                            "gca6FwUE_9Dk23UhWoM81pZkNgEa", Wire4Auth::EnvironmentEnum::DEVELOPMENT)
+
+    begin
+      # Obtain an access token use application flow and scope "general" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app('general')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::FacturasApi.new
+
+    begin
+      # Call the API
+      response = api_instance.billings_report_using_get(authorization, period: "2019-10")
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_get_facturas_by_id
+    omit('Reason')
+    # Create the authenticator to obtain access token
+    # The token URL and Service URL are defined for this environment enum value.
+    # e.g. for Sandbox environment: Wire4Auth::EnvironmentEnum::SANDBOX
+
+    oauth_wire4 = Wire4Auth::OAuthWire4.new(CLIENT_ID, CLIENT_SECRET, Wire4Auth::EnvironmentEnum::SANDBOX)
+    #oauth_wire4 = Wire4Auth::OAuthWire4.new("kIinyEIYWUIF3pflFxhRdKft2_ga",
+    #                                        "gca6FwUE_9Dk23UhWoM81pZkNgEa", Wire4Auth::EnvironmentEnum::DEVELOPMENT)
+
+    begin
+      # Obtain an access token use application flow and scope "general" and add to request
+      oauth_wire4.config_default_api_client
+      authorization = oauth_wire4.obtain_access_token_app('general')
+    rescue Wire4Client::ApiError => e
+      puts "Exception to obtain access token #{e}"
+      # Optional manage exception in access token flow
+      return
+    end
+
+    # create an instance of the API class
+    api_instance = Wire4Client::FacturasApi.new
+
+    begin
+      # Call the API
+      response = api_instance.billings_report_by_id_using_get(authorization, "834BA74A-BBBB-43C4-8400-A4528153C2BD")
+      p response
+    rescue Wire4Client::ApiError => e
+      puts "Exception when calling the API: #{e}"
+      # Optional manage exception in call API
+      return
+    end
+  end
+
+  def test_check_web_hook_sign
+
+    omit('Reason')
+    puts `cd .. && cd .. && find *`.split("\n").uniq.sort.select { |f| !f.empty? }
+
+    payload = "{ \"responseCode\":0, \n" + \
+              "  \"message\":\"Ya existe este beneficiario de pago a ctas nacionales en el contrato\",\n" + \
+              "  \"statusCode\":\"ERROR\",\n" + \
+              "  \"externalReference\":\"8939TR\"\n" + \
+              "}"
+    expected_key = "8e63e88434679473bdb28546d7d91537601f4588e801972376d5c5addcb8fd706e6c92421b73151de3c1945ce000a8a" + \
+                 +"5aa1d5cc3cdd73f2769ee9980db420db9"
+
+    result = Wire4Auth::UtilsCompute.compare_webhook_msg_signatures(payload, "9ie93030?=", expected_key)
+    puts "WebHook signature verification, correct:  #{result}"
+
+    assert result
+  end
+end