xhash_client 0.3.0 → 0.3.1

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,95 @@
+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 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

data/spec/xhash/ocr_spec.rb

@@ -0,0 +1,365 @@
+require 'spec_helper'
+
+describe Xhash::OCR do
+  describe '.generic' do
+    it 'successfully serialize INE to document by url' do
+      stub_request(:post, 'https://xhash.dev/api/ocr').to_return(
+        body:
+          JSON.dump(
+            {
+              payload: {
+                name: 'MARGARITA',
+                last_name: 'GOMEZ',
+                mothers_last_name: 'VELAZQUEZ',
+                expiration_date: '2024-12-31',
+                street: 'C',
+                neighborhood: 'NACIO PITAGORAS 1253',
+                zip_code: 'INT 4',
+                city: 'COL. MORELOS 04800',
+                type: 'INE'
+              }
+            }
+          ),
+        status: 200
+      )
+
+      ine =
+        Xhash::OCR.generic(
+          document_url:
+            'https://kyc-xhash.s3-us-west-2.amazonaws.com/documents/7cd6994d9ad52e8943be1ae00bac60c461430cdf2af6159afa4b9be749706472.png'
+        )
+
+      expect(ine).to be_a(Xhash::Identification)
+      expect(ine.name).to eq('MARGARITA')
+      expect(ine.last_name).to eq('GOMEZ')
+      expect(ine.mothers_last_name).to eq('VELAZQUEZ')
+      expect(ine.expiration_date).to eq('2024-12-31')
+      expect(ine.street).to eq('C')
+      expect(ine.neighborhood).to eq('NACIO PITAGORAS 1253')
+      expect(ine.zip_code).to eq('INT 4')
+      expect(ine.city).to eq('COL. MORELOS 04800')
+      expect(ine.type).to eq('INE')
+    end
+
+    it 'successfully serialize INE to document by file' do
+      stub_request(:post, 'https://xhash.dev/api/ocr').to_return(
+        body:
+          JSON.dump(
+            {
+              payload: {
+                name: 'MARGARITA',
+                last_name: 'GOMEZ',
+                mothers_last_name: 'VELAZQUEZ',
+                expiration_date: '2024-12-31',
+                street: 'C',
+                neighborhood: 'NACIO PITAGORAS 1253',
+                zip_code: 'INT 4',
+                city: 'COL. MORELOS 04800',
+                type: 'INE'
+              }
+            }
+          ),
+        status: 200
+      )
+
+      document = File.open('spec/files/ife_front.png')
+
+      ine = Xhash::OCR.generic(document_file: document)
+
+      document.close
+
+      expect(ine).to be_a(Xhash::Identification)
+      expect(ine.name).to eq('MARGARITA')
+      expect(ine.last_name).to eq('GOMEZ')
+      expect(ine.mothers_last_name).to eq('VELAZQUEZ')
+      expect(ine.expiration_date).to eq('2024-12-31')
+      expect(ine.street).to eq('C')
+      expect(ine.neighborhood).to eq('NACIO PITAGORAS 1253')
+      expect(ine.zip_code).to eq('INT 4')
+      expect(ine.city).to eq('COL. MORELOS 04800')
+      expect(ine.type).to eq('INE')
+    end
+
+    it 'successfully serialize proof of address to document by url' do
+      stub_request(:post, 'https://xhash.dev/api/ocr').to_return(
+        body:
+          JSON.dump(
+            {
+              payload: {
+                full_name: 'Prof Francesco Reichert',
+                neighborhood: 'Parkerchester',
+                full_address: 'CLL 59 E DIAGONAL 623\n76 Y 74 A Y RED CANALIZA\nLAS AMERICAS\nMERIDA, MERIDA YU\nC.P. 97302-CR -97111',
+                zip_code: '97302',
+                province: 'Port Rosemarieview,VT',
+                date: '2019-09-01',
+                type: 'TELMEX'
+              }
+            }
+          ),
+        status: 200
+      )
+
+      proof_of_address =
+        Xhash::OCR.generic(
+          document_url:
+            'https://kyc-xhash.s3-us-west-2.amazonaws.com/documents/c7d40899ab9ed7aa689837e39b64a6eb07117353f88ce3f8b9d1ca73bea3d80e.png'
+        )
+
+      expect(proof_of_address).to be_a(Xhash::ProofOfAddress)
+      expect(proof_of_address.full_name).to eq('Prof Francesco Reichert')
+      expect(proof_of_address.neighborhood).to eq('Parkerchester')
+      expect(proof_of_address.province).to eq('Port Rosemarieview,VT')
+      expect(proof_of_address.type).to eq('TELMEX')
+      expect(proof_of_address.date).to eq('2019-09-01')
+      expect(proof_of_address.zip_code).to eq('97302')
+      expect(proof_of_address.full_address).to eq('CLL 59 E DIAGONAL 623\n76 Y 74 A Y RED CANALIZA\nLAS AMERICAS\nMERIDA, MERIDA YU\nC.P. 97302-CR -97111')
+    end
+
+    it 'successfully serialize proof of address to document by file' do
+      stub_request(:post, 'https://xhash.dev/api/ocr').to_return(
+        body:
+          JSON.dump(
+            {
+              payload: {
+                full_name: 'Prof Francesco Reichert',
+                neighborhood: 'Parkerchester',
+                province: 'Port Rosemarieview,VT',
+                type: 'TELMEX'
+              }
+            }
+          ),
+        status: 200
+      )
+
+      document = File.open('spec/files/telmex.png')
+
+      proof_of_address = Xhash::OCR.generic(document_file: document)
+
+      document.close
+
+      expect(proof_of_address).to be_a(Xhash::ProofOfAddress)
+      expect(proof_of_address.full_name).to eq('Prof Francesco Reichert')
+      expect(proof_of_address.neighborhood).to eq('Parkerchester')
+      expect(proof_of_address.province).to eq('Port Rosemarieview,VT')
+      expect(proof_of_address.type).to eq('TELMEX')
+    end
+
+    it 'fails to serialize INE to document with html error' do
+      stub_request(:post, 'https://xhash.dev/api/ocr').to_return(
+        body: '<p>error</p>',
+        status: 200,
+        headers: { 'Content-Type' => 'text/html; charset=UTF-8' }
+      )
+
+      begin
+        ine =
+          Xhash::OCR.generic(
+            document_url:
+              'https://kyc-xhash.s3-us-west-2.amazonaws.com/documents/7cd6994d9ad52e8943be1ae00bac60c461430cdf2af6159afa4b9be749706472.png'
+          )
+      rescue => exception
+        expect(exception).to be_a(JSON::ParserError)
+      end
+    end
+
+    it 'fails with missing file or url' do
+      begin
+        ine = Xhash::OCR.generic
+      rescue => exception
+        expect(exception).to be_a(Xhash::MissingRequiredFieldError)
+        expect(exception.message).to eq(Xhash::ErrorMessage::MISSING_FILE)
+      end
+    end
+  end
+
+  describe '.identification' do
+    it 'successfully serialize INE to document' do
+      stub_request(:post, 'https://xhash.dev/api/ocr/identification').to_return(
+        body:
+          JSON.dump(
+            {
+              payload: {
+                name: 'MARGARITA',
+                last_name: 'GOMEZ',
+                mothers_last_name: 'VELAZQUEZ',
+                expiration_date: '2024-12-31',
+                street: 'C',
+                neighborhood: 'NACIO PITAGORAS 1253',
+                zip_code: 'INT 4',
+                city: 'COL. MORELOS 04800',
+                type: 'INE'
+              }
+            }
+          ),
+        status: 200
+      )
+
+      ine_anverse =
+        Xhash::OCR.identification(
+          document_url:
+            'https://kyc-xhash.s3-us-west-2.amazonaws.com/documents/7cd6994d9ad52e8943be1ae00bac60c461430cdf2af6159afa4b9be749706472.png'
+        )
+
+      expect(ine_anverse).to be_a(Xhash::Identification)
+      expect(ine_anverse.name).to eq('MARGARITA')
+      expect(ine_anverse.last_name).to eq('GOMEZ')
+      expect(ine_anverse.mothers_last_name).to eq('VELAZQUEZ')
+      expect(ine_anverse.expiration_date).to eq('2024-12-31')
+      expect(ine_anverse.street).to eq('C')
+      expect(ine_anverse.neighborhood).to eq('NACIO PITAGORAS 1253')
+      expect(ine_anverse.zip_code).to eq('INT 4')
+      expect(ine_anverse.city).to eq('COL. MORELOS 04800')
+      expect(ine_anverse.type).to eq('INE')
+    end
+
+    it 'fails with missing file or url' do
+      begin
+        ine = Xhash::OCR.identification
+      rescue => exception
+        expect(exception).to be_a(Xhash::MissingRequiredFieldError)
+      end
+    end
+
+    it 'fails with invalid INE document' do
+      stub_request(:post, 'https://xhash.dev/api/ocr').to_return(
+        body: JSON.dump({ result: false, payload: nil }), status: 200
+      )
+
+      begin
+        ine =
+          Xhash::OCR.generic(
+            document_url:
+              'https://kyc-xhash.s3-us-west-2.amazonaws.com/documents/7cd6994d9ad52e8943be1ae00bac60c461430cdf2af6159afa4b9be749706472.png'
+          )
+      rescue => exception
+        expect(exception).to be_a(Xhash::InvalidFieldError)
+      end
+    end
+  end
+
+  describe '.proof_of_address' do
+    it 'successfully serialize proof of address to document' do
+      stub_request(:post, 'https://xhash.dev/api/ocr/proof-of-address')
+        .to_return(
+        body:
+          JSON.dump(
+            {
+              payload: {
+                full_name: 'Prof Francesco Reichert',
+                neighborhood: 'Parkerchester',
+                province: 'Port Rosemarieview,VT',
+                type: 'TELMEX'
+              }
+            }
+          ),
+        status: 200
+      )
+
+      proof_of_address =
+        Xhash::OCR.proof_of_address(
+          document_url:
+            'https://kyc-xhash.s3-us-west-2.amazonaws.com/documents/c7d40899ab9ed7aa689837e39b64a6eb07117353f88ce3f8b9d1ca73bea3d80e.png'
+        )
+
+      expect(proof_of_address).to be_a(Xhash::ProofOfAddress)
+      expect(proof_of_address.full_name).to eq('Prof Francesco Reichert')
+      expect(proof_of_address.neighborhood).to eq('Parkerchester')
+      expect(proof_of_address.province).to eq('Port Rosemarieview,VT')
+      expect(proof_of_address.type).to eq('TELMEX')
+    end
+
+    it 'fails with missing file or url' do
+      begin
+        proof_of_address = Xhash::OCR.proof_of_address
+      rescue => exception
+        expect(exception).to be_a(Xhash::MissingRequiredFieldError)
+      end
+    end
+
+    it 'fails with invalid proof of address document' do
+      stub_request(:post, 'https://xhash.dev/api/ocr/proof-of-address')
+        .to_return(
+        body: JSON.dump({ result: false, payload: nil }), status: 200
+      )
+
+      begin
+        ine =
+          Xhash::OCR.proof_of_address(
+            document_url:
+              'https://kyc-xhash.s3-us-west-2.amazonaws.com/documents/7cd6994d9ad52e8943be1ae00bac60c461430cdf2af6159afa4b9be749706472.png'
+          )
+      rescue => exception
+        expect(exception).to be_a(Xhash::InvalidFieldError)
+      end
+    end
+  end
+
+  describe '.ine_reverse' do
+    it 'successfully serialize INE (reverse) to document' do
+      stub_request(:post, 'https://xhash.dev/api/ocr/ine-reverse').to_return(
+        body:
+          JSON.dump(
+            {
+              is_consistentent: false,
+              payload: {
+                lines: [
+                  'IDMEX1836577170<<0747116375842',
+                  '8007057M1812315MEX<02<<12345<7',
+                  'GOMEZ<VELAZzQUEZ<<MARGARITA<',
+                  ''
+                ],
+                cic: '183657717',
+                cic_digit_check: '0',
+                is_cic_digit_check_consistent: false,
+                section_and_consecutive: '0747116375842',
+                date: '800705',
+                date_check_digit: '7',
+                gender: 'M',
+                expiration_date: '181231',
+                expiration_date_digit: '5',
+                nationality: 'MEX',
+                emission_and_fuar: '02-12345',
+                name: 'MARGARITA ',
+                mothers_last_name: 'VELAZzQUEZ',
+                last_name: 'GOMEZ',
+                last_names: 'GOMEZ VELAZzQUEZ'
+              }
+            }
+          ),
+        status: 200
+      )
+
+      ine_reverse =
+        Xhash::OCR.ine_reverse(
+          document_url:
+            'https://kyc-xhash.s3-us-west-2.amazonaws.com/documents/b3f43a31929437c35b8fb22580119fe389d2e758bad8718387701ee8363caee7.jpg'
+        )
+
+      expect(ine_reverse).to be_a(Xhash::Identification)
+    end
+
+    it 'fails with missing file or url' do
+      begin
+        ine_reverse = Xhash::OCR.ine_reverse
+      rescue => exception
+        expect(exception).to be_a(Xhash::MissingRequiredFieldError)
+      end
+    end
+
+    it 'fails with invalid INE reverse document' do
+      stub_request(:post, 'https://xhash.dev/api/ocr/ine-reverse').to_return(
+        body: JSON.dump({ result: false, payload: nil }), status: 200
+      )
+
+      begin
+        ine =
+          Xhash::OCR.ine_reverse(
+            document_url:
+              'https://kyc-xhash.s3-us-west-2.amazonaws.com/documents/7cd6994d9ad52e8943be1ae00bac60c461430cdf2af6159afa4b9be749706472.png'
+          )
+      rescue => exception
+        expect(exception).to be_a(Xhash::InvalidFieldError)
+      end
+    end
+  end
+end