xhash_client 0.3.0 → 0.3.5

data/lib/xhash/sat.rb

@@ -0,0 +1,18 @@
+module Xhash
+  class SAT < ApiClient
+    def self.get_rfc(
+      name: nil, last_name: nil, mothers_last_name: nil, birth_date: nil
+    )
+      url = 'sat/get-rfc'
+      body = {
+        name: name,
+        last_name: last_name,
+        mothers_last_name: mothers_last_name,
+        birth_date: birth_date
+      }
+      response = api_post(url: url, body: body)
+      raise Xhash::MissingRequiredFieldError.new(response) unless response[:rfc]
+      Xhash::RFC.new(*response.values_at(*Xhash::RFC.members))
+    end
+  end
+end

data/lib/xhash/structs/curp.rb

@@ -0,0 +1,16 @@
+module Xhash
+  CURP =
+    Struct.new(
+      :country_of_birth,
+      :created_at,
+      :curp,
+      :day_of_birth,
+      :gender,
+      :id,
+      :last_name,
+      :mothers_last_name,
+      :name,
+      :province_of_birth,
+      :updated_at
+    )
+end

data/lib/xhash/structs/customer.rb

@@ -0,0 +1,49 @@
+module Xhash
+  Customer =
+    Struct.new(
+      :id,
+      :name,
+      :last_name,
+      :mothers_last_name,
+      :gender,
+      :birth_date,
+      :birth_city,
+      :birth_country,
+      :curp,
+      :renapo_match,
+      :rfc,
+      :rfc_match,
+      :rfc_is_cancelled,
+      :zip_code,
+      :neighborhood,
+      :province,
+      :city,
+      :country,
+      :address,
+      :activity,
+      :electoral_key,
+      :clabe,
+      :ext_address,
+      :email,
+      :phone_number,
+      :in_black_list,
+      :black_list_name,
+      :liveness_video,
+      :liveness_check,
+      :document_id,
+      :client_id,
+      :external_customer_id,
+      :update_key,
+      :device_fingerprint_id,
+      :token_email,
+      :email_verified_at,
+      :token_sm,
+      :sms_verified_at,
+      :deleted_at,
+      :created_at,
+      :updated_at,
+      :ip_uniqueness,
+      :fingerprint_uniqueness,
+      :documents
+    )
+end

data/lib/xhash/structs/identification.rb

@@ -0,0 +1,30 @@
+module Xhash
+  Identification =
+    Struct.new(
+      :lines,
+      :cic,
+      :cic_digit_check,
+      :is_cic_digit_check_consistent,
+      :section_and_consecutive,
+      :date,
+      :date_check_digit,
+      :expiration_date,
+      :expiration_date_digit,
+      :nationality,
+      :emission_and_fuar,
+      :name,
+      :mothers_last_name,
+      :last_name,
+      :last_names,
+      :birth_date,
+      :gender,
+      :elector_key,
+      :curp,
+      :street,
+      :neighborhood,
+      :zip_code,
+      :city,
+      :province,
+      :type
+    )
+end

data/lib/xhash/structs/proof_of_address.rb

@@ -0,0 +1,15 @@
+module Xhash
+  ProofOfAddress =
+    Struct.new(
+      :full_name,
+      :full_address,
+      :street,
+      :neighborhood,
+      :zip_code,
+      :city,
+      :province,
+      :type,
+      :date,
+      :exception
+    )
+end

data/lib/xhash/structs/rfc.rb

@@ -0,0 +1,3 @@
+module Xhash
+  RFC = Struct.new(:name, :last_name, :mothers_last_name, :birth_date, :rfc)
+end

data/lib/xhash/version.rb

@@ -0,0 +1,3 @@
+module Xhash
+  VERSION = '0.3.5'
+end

data/spec/spec_helper.rb

@@ -0,0 +1,9 @@
+require 'webmock/rspec'
+require 'rspec'
+require 'simplecov'
+
+require 'xhash'
+
+SimpleCov.start { add_filter '/spec/' }
+
+RSpec.configure { |config| config.before(:all) { Xhash.api_key = 'api_key' } }

data/spec/xhash/database_lookup_spec.rb

@@ -0,0 +1,108 @@
+require 'spec_helper'
+
+describe Xhash::SAT do
+  describe '.renapo' do
+    it 'successfully with valid CURP' do
+      curp = 'OESJ980828HDFLNR04'
+
+      stub_request(:post, 'https://xhash.dev/api/database-lookup/renapo')
+        .to_return(
+        body:
+          JSON.dump(
+            {
+              result: true,
+              payload: {
+                curp: curp,
+                name: 'JERONIMO',
+                last_name: 'OLIVA',
+                mothers_last_name: 'SANCHEZ',
+                gender: 'H',
+                province_of_birth: 'DF',
+                day_of_birth: '1999-08-28 00:00:00',
+                updated_at: '2019-10-03 13:12:32',
+                created_at: '2019-10-03 13:12:32',
+                id: 76
+              }
+            }
+          ),
+        status: 200
+      )
+
+      curp_data = Xhash::DatabaseLookup.renapo(curp)
+
+      expect(curp_data).to be_a(Xhash::CURP)
+      expect(curp_data.name).to eq('JERONIMO')
+      expect(curp_data.last_name).to eq('OLIVA')
+      expect(curp_data.mothers_last_name).to eq('SANCHEZ')
+      expect(curp_data.day_of_birth).to eq('1999-08-28 00:00:00')
+      expect(curp_data.gender).to eq('H')
+      expect(curp_data.curp).to eq(curp)
+    end
+
+    it 'fails with invalid CURP' do
+      curp = 'JIQJ890611HDFXNN04'
+
+      stub_request(:post, 'https://xhash.dev/api/database-lookup/renapo')
+        .to_return(
+        body:
+          JSON.dump(
+            {
+              result: true,
+              payload: {
+                id: 65,
+                curp: curp,
+                name: 'CURP INVALIDO',
+                last_name: '',
+                mothers_last_name: nil,
+                gender: 'H',
+                day_of_birth: nil,
+                country_of_birth: nil,
+                province_of_birth: nil,
+                proof_document_payload: nil,
+                proof_document_name: nil,
+                created_at: '2019-09-02 16:09:07',
+                updated_at: '2019-09-02 16:09:07'
+              }
+            }
+          ),
+        status: 200
+      )
+
+      begin
+        Xhash::DatabaseLookup.renapo(curp)
+      rescue => exception
+        expect(exception).to be_a(Xhash::InvalidFieldError)
+        expect(exception.message).to eq(Xhash::ErrorMessage::INVALID_CURP)
+      end
+    end
+
+    it 'fails with html error' do
+      curp = 'JIQJ890611HDFXNN04'
+
+      stub_request(:post, 'https://xhash.dev/api/database-lookup/renapo')
+        .to_return(body: '<p>bad</p>', status: 200)
+
+      begin
+        Xhash::DatabaseLookup.renapo(curp)
+      rescue => exception
+        expect(exception).to be_a(Xhash::MalformedResponse)
+      end
+    end
+
+    it 'fails with malformed CURP' do
+      curp = 'asdf'
+
+      stub_request(:post, 'https://xhash.dev/api/database-lookup/renapo')
+        .to_return(
+        body: JSON.dump({ result: false, payload: nil }), status: 200
+      )
+
+      begin
+        Xhash::DatabaseLookup.renapo(curp)
+      rescue => exception
+        expect(exception).to be_a(Xhash::MissingRequiredFieldError)
+        expect(exception.message).to eq(Xhash::ErrorMessage::MISSING_CURP)
+      end
+    end
+  end
+end

data/spec/xhash/general_spec.rb

@@ -0,0 +1,208 @@
+require 'spec_helper'
+
+describe Xhash::General do
+  describe '.store_data' do
+    it 'successfully creates a customer' do
+      stub_request(:post, 'https://xhash.dev/api/store-data').to_return(
+        body:
+          JSON.dump(
+            {
+              id: 1,
+              name: 'pedro',
+              last_name: 'can',
+              mothers_last_name: 'quintal',
+              birth_date: '1997-03-18 00:00:00',
+              rfc: 'JIQJ890611FC9',
+              curp: 'JIQJ890611HDFXNN04',
+              address: 'calle',
+              ext_address: 'asdfasdf',
+              gender: 'MALE',
+              clabe: '032180000118359719',
+              activity: '7129019',
+              email: 'emilio@xhash.tech',
+              phone_number: '9999503059',
+              zip_code: '97400',
+              external_customer_id: 'my-customer-id-1'
+            }
+          ),
+        status: 200
+      )
+
+      customer =
+        Xhash::General.store_data(
+          name: 'pedro',
+          last_name: 'can',
+          mothers_last_name: 'quintal',
+          birth_date: '1997-03-18',
+          rfc: 'JIQJ890611FC9',
+          curp: 'JIQJ890611HDFXNN04',
+          address: 'calle',
+          ext_address: 'asdfasdf',
+          gender: 'MALE',
+          clabe: '032180000118359719',
+          activity: '7129019',
+          email: 'emilio@xhash.tech',
+          phone_number: '9999503059',
+          zip_code: '97400',
+          external_customer_id: 'my-customer-id-1'
+        )
+
+      expect(customer).to be_a(Xhash::Customer)
+      expect(customer.id).to be_truthy
+      expect(customer.name).to eq('pedro')
+      expect(customer.last_name).to eq('can')
+      expect(customer.mothers_last_name).to eq('quintal')
+      expect(customer.birth_date).to eq('1997-03-18 00:00:00')
+      expect(customer.gender).to eq('MALE')
+      expect(customer.curp).to eq('JIQJ890611HDFXNN04')
+      expect(customer.rfc).to eq('JIQJ890611FC9')
+      expect(customer.email).to eq('emilio@xhash.tech')
+      expect(customer.external_customer_id).to eq('my-customer-id-1')
+    end
+
+    it 'fails to creates a customer by missing data' do
+      stub_request(:post, 'https://xhash.dev/api/store-data').to_return(
+        body:
+          JSON.dump(
+            {
+              curp: ['The curp field is required.'],
+              gender: ['The gender field is required.']
+            }
+          ),
+        status: 200
+      )
+
+      begin
+        customer =
+          Xhash::General.store_data(
+            name: 'pedro',
+            last_name: 'can',
+            mothers_last_name: 'quintal',
+            birth_date: '1997-03-18',
+            rfc: 'JIQJ890611FC9',
+            address: 'calle',
+            ext_address: 'asdfasdf',
+            clabe: '032180000118359719',
+            activity: '7129019',
+            email: 'emilio@xhash.tech',
+            phone_number: '9999503059',
+            zip_code: '97400',
+            external_customer_id: 'my-customer-id-1'
+          )
+      rescue => exception
+        expect(exception).to be_a(Xhash::MissingRequiredFieldError)
+        expect(exception.message).to eq(
+          'The curp field is required. The gender field is required.'
+        )
+        expect(exception.response[:curp]).to eq(['The curp field is required.'])
+        expect(exception.response[:gender]).to eq(
+          ['The gender field is required.']
+        )
+      end
+    end
+  end
+
+  describe '.get_customer' do
+    it 'successfully fetch customer data' do
+      stub_request(:get, 'https://xhash.dev/api/get-customer/my-customer-id-1')
+        .to_return(
+        body:
+          JSON.dump(
+            {
+              payload: {
+                id: 1,
+                name: 'pedro',
+                last_name: 'can',
+                mothers_last_name: 'quintal',
+                birth_date: '1997-03-18 00:00:00',
+                rfc: 'JIQJ890611FC9',
+                curp: 'JIQJ890611HDFXNN04',
+                address: 'calle',
+                ext_address: 'asdfasdf',
+                gender: 'MALE',
+                clabe: '032180000118359719',
+                activity: '7129019',
+                email: 'emilio@xhash.tech',
+                phone_number: '9999503059',
+                zip_code: '97400',
+                external_customer_id: 'my-customer-id-1'
+              }
+            }
+          ),
+        status: 200
+      )
+
+      customer = Xhash::General.get_customer(customer_id: 'my-customer-id-1')
+
+      expect(customer).to be_a(Xhash::Customer)
+      expect(customer.id).to be_truthy
+      expect(customer.name).to eq('pedro')
+      expect(customer.external_customer_id).to eq('my-customer-id-1')
+    end
+
+    it 'fails to fetch a customer data with bad id' do
+      stub_request(:get, 'https://xhash.dev/api/get-customer/my-customer-id-2')
+        .to_return(
+        body:
+          JSON.dump({ customer_id: ['The selected customer id is invalid.'] }),
+        status: 200
+      )
+
+      begin
+        customer = Xhash::General.get_customer(customer_id: 'my-customer-id-2')
+      rescue => exception
+        expect(exception).to be_a(Xhash::MissingRequiredFieldError)
+        expect(exception.message).to eq('The selected customer id is invalid.')
+        expect(exception.response[:customer_id]).to eq(
+          ['The selected customer id is invalid.']
+        )
+      end
+    end
+  end
+
+  describe '.store_file' do
+    it 'successfully store file to a customer' do
+      stub_request(:post, 'https://xhash.dev/api/store-file').to_return(
+        body: 'Image stored', status: 200
+      )
+
+      document = File.open('spec/files/ife_front.png')
+
+      response =
+        Xhash::General.store_file(
+          customer_id: 'my-customer-id-1',
+          document_type: Xhash::DocumentType::ID::INE_FRONT,
+          document: document
+        )
+
+      document.close
+      expect(response).to eq('Image stored')
+    end
+
+    it 'fails store file to unexisting user' do
+      stub_request(:post, 'https://xhash.dev/api/store-file').to_return(
+        body:
+          JSON.dump({ customer_id: ['The selected customer id is invalid.'] }),
+        status: 200
+      )
+
+      document = File.open('spec/files/ife_front.png')
+
+      begin
+        response =
+          Xhash::General.store_file(
+            customer_id: 'my-customer-id-1',
+            document_type: Xhash::DocumentType::ID::INE_FRONT,
+            document: document
+          )
+      rescue => exception
+        document.close
+        expect(exception).to be_a(Xhash::MissingRequiredFieldError)
+        expect(exception.message).to eq('The selected customer id is invalid.')
+        expect(exception.response[:customer_id]).to eq(
+          ['The selected customer id is invalid.']
+        )
+      end
+    end
+  end
+end