Initial commit

spec/workers/address_worker_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+describe 'KYC::Kycaid::AddressWorker' do
+  before { allow(Barong::App.config).to receive_messages(kyc_provider: 'kycaid') }
+
+  include_context 'bearer authentication'
+  let!(:create_member_permission) do
+    create :permission,
+           role: 'member'
+  end
+  let(:user) { create(:user) }
+  let!(:profile) { create(:profile, country: 'UA', state: 'submitted', applicant_id: '84e51f8a0677a646fd185fc741717ad9a8b3', user_id: user.id) }
+  let!(:document) { create(:document, identificator: '84e51f8a06', user_id: user.id, doc_type: 'Address') }
+  let!(:label) { create(:label, key: 'address', user_id: user.id, value: 'pending', scope: 'private') }
+  let(:address_params) { { "identificator": '84e51f8a06', 'user_id': document.user.id, "country": 'UA', "city": 'Kiev', "postcode": '101010' } }
+
+  describe 'successful verification' do
+    let(:successful_docs_response) { OpenStruct.new(address_id: '84e51f8a0677a646fd185fc741717ad9a8b3') }
+    let(:successful_verification_response) { OpenStruct.new(verification_id: '84e51f8a0677a646fd185fc741717ad9a8b3') }
+
+    before { allow(KYCAID::Address).to receive(:create).and_return(successful_docs_response) }
+    before { allow(KYCAID::Verification).to receive(:create).and_return(successful_verification_response) }
+
+    before { allow_any_instance_of(KYC::Kycaid::AddressWorker).to receive(:address_params).and_return({}) }
+
+    context 'perform' do
+      before { allow(KYCAID::Address).to receive(:create).and_return(successful_docs_response) }
+      before { allow(KYCAID::Verification).to receive(:create).and_return(successful_verification_response) }
+
+      it 'creates a document record' do
+        expect(document.metadata).to eq(nil)
+        expect(KYCAID::Address).to receive(:create)
+
+        KYC::Kycaid::AddressWorker.new.perform(address_params)
+        expect(document.reload.metadata).not_to eq(nil)
+      end
+
+      it 'creates a verification request' do
+        expect(document.metadata).to eq(nil)
+        expect(KYCAID::Address).to receive(:create)
+        expect(KYCAID::Verification).to receive(:create)
+
+        KYC::Kycaid::AddressWorker.new.perform(address_params)
+        expect(document.reload.metadata).not_to eq(nil)
+      end
+    end
+  end
+
+  describe 'failed verification' do
+    before { allow_any_instance_of(KYC::Kycaid::AddressWorker).to receive(:address_params).and_return({}) }
+    let(:unauthorized_response) { OpenStruct.new(error: { "type": 'unauthorized' }) }
+    let(:unsuccessful_response) do
+      OpenStruct.new(type: 'validation', errors: [{ "parameter": 'front_file', "message": 'Image is blured' }])
+    end
+    context 'unathorized' do
+      before { allow(KYCAID::Address).to receive(:create).and_return(unauthorized_response) }
+
+      it 'does not create a address because of error' do
+        expect(document.metadata).to eq(nil)
+        expect(KYCAID::Address).to receive(:create)
+        expect(KYCAID::Verification).not_to receive(:create)
+
+        KYC::Kycaid::AddressWorker.new.perform(address_params)
+        expect(document.reload.metadata).to eq(nil)
+      end
+    end
+
+    context 'validation failed' do
+      before { allow(KYCAID::Address).to receive(:create).and_return(unsuccessful_response) }
+
+      it 'does not create a address' do
+        expect(document.metadata).to eq(nil)
+        expect(KYCAID::Address).to receive(:create)
+
+        KYC::Kycaid::AddressWorker.new.perform(address_params)
+        expect(document.metadata).to eq(nil)
+      end
+
+      it 'gets a rejected label' do
+        expect(document.metadata).to eq(nil)
+        expect(document.user.labels.count).to eq(2)
+        expect(document.user.labels.find_by(key: :address).value).to eq('pending')
+
+        expect(KYCAID::Address).to receive(:create)
+
+        KYC::Kycaid::AddressWorker.new.perform(address_params)
+        expect(document.metadata).to eq(nil)
+        expect(document.user.labels.count).to eq(2)
+        expect(document.user.labels.find_by(key: :address).value).to eq('rejected')
+      end
+    end
+  end
+end

spec/workers/applicant_worker_spec.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+describe 'KYC::ApplicantWorker' do
+  include_context 'bearer authentication'
+  before { allow(Barong::App.config).to receive_messages(kyc_provider: 'kycaid') }
+
+  let!(:create_member_permission) do
+    create :permission,
+           role: 'member'
+  end
+  let(:profile) { create(:profile, country: "UA", state: 'submitted') }
+
+  describe 'successful verification' do
+    let(:successful_response) { OpenStruct.new(applicant_id: "84e51f8a0677a646fd185fc741717ad9a8b3") }
+    let(:params) {{ type: 'PERSON', first_name: profile.first_name, last_name: profile.last_name, dob: profile.dob,
+                    residence_country: profile.country, email: profile.user.email, phone: profile.user.phones&.last&.number }}
+
+    before { allow(KYCAID::Applicant).to receive(:create).with(params).and_return(successful_response)}
+
+    context 'perform' do
+      it 'creates an applicant' do
+        expect(profile.applicant_id).to eq(nil)
+        expect(KYCAID::Applicant).to receive(:create)
+
+        KYC::Kycaid::ApplicantWorker.new.perform(profile.id)
+        expect(profile.reload.applicant_id).not_to eq(nil)
+      end
+
+      it 'changes a label to verified' do
+        expect(profile.applicant_id).to eq(nil)
+        expect(profile.user.labels.count).to eq(1)
+        expect(profile.user.labels.first.key).to eq('profile')
+        expect(profile.user.labels.first.value).to eq('submitted')
+
+        expect(KYCAID::Applicant).to receive(:create)
+        KYC::Kycaid::ApplicantWorker.new.perform(profile.id)
+
+        expect(profile.reload.applicant_id).not_to eq(nil)
+        expect(profile.user.labels.count).to eq(1)
+        expect(profile.user.labels.first.key).to eq('profile')
+        expect(profile.user.labels.first.value).to eq('verified')
+      end
+    end
+  end
+
+  describe 'failed verification' do
+    let(:unauthorized_response) { OpenStruct.new(error: { "type": "unauthorized"}) }
+    let(:unsuccessful_response) { 
+      OpenStruct.new(type: "validation", errors: [{"parameter": "residence_country", "message": "Country of residence is not valid"}])
+    }
+
+    let(:params) {{ type: 'PERSON', first_name: profile.first_name, last_name: profile.last_name, dob: profile.dob,
+                    residence_country: profile.country, email: profile.user.email, phone: profile.user.phones&.last&.number }}
+
+    context 'unathorized' do
+      before { allow(KYCAID::Applicant).to receive(:create).with(params).and_return(unauthorized_response)}
+
+      it 'does not create an applicant' do
+        expect(profile.applicant_id).to eq(nil)
+        expect(KYCAID::Applicant).to receive(:create)
+
+        KYC::Kycaid::ApplicantWorker.new.perform(profile.id)
+        expect(profile.reload.applicant_id).to eq(nil)
+      end
+    end
+
+    context 'validation failed' do
+      before { allow(KYCAID::Applicant).to receive(:create).with(params).and_return(unsuccessful_response)}
+
+      it 'does not create an applicant' do
+        expect(profile.applicant_id).to eq(nil)
+        expect(KYCAID::Applicant).to receive(:create)
+
+        KYC::Kycaid::ApplicantWorker.new.perform(profile.id)
+        expect(profile.reload.applicant_id).to eq(nil)
+      end
+
+      it 'gets a rejected label' do
+        expect(profile.applicant_id).to eq(nil)
+        expect(KYCAID::Applicant).to receive(:create)
+
+        KYC::Kycaid::ApplicantWorker.new.perform(profile.id)
+        expect(profile.reload.applicant_id).to eq(nil)
+        expect(profile.user.labels.count).to eq(1)
+        expect(profile.user.labels.first.key).to eq('profile')
+        expect(profile.user.labels.first.value).to eq('rejected')
+      end
+    end
+  end
+end

spec/workers/document_worker_spec.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+describe 'KYC::Kycaid::DocumentWorker' do
+  before { allow(Barong::App.config).to receive_messages(kyc_provider: 'kycaid') }
+
+  include_context 'bearer authentication'
+  let!(:create_member_permission) do
+    create :permission,
+           role: 'member'
+  end
+  let(:user) { create(:user) }
+  let!(:profile) { create(:profile, country: 'UA', state: 'submitted', applicant_id: '84e51f8a0677a646fd185fc741717ad9a8b3', user_id: user.id) }
+  let!(:document) { create(:document, identificator: '84e51f8a06', doc_type: 'Passport', doc_category: 'front_side', user_id: user.id) }
+  let!(:document_second) { create(:document, identificator: '84e51f8a06', doc_type: 'Passport', doc_category: 'selfie', user_id: user.id) }
+
+  describe 'successful verification' do
+    let(:successful_docs_response) { OpenStruct.new(document_id: '84e51f8a0677a646fd185fc741717ad9a8b3') }
+    let(:successful_verification_response) { OpenStruct.new(verification_id: '84e51f8a0677a646fd185fc741717ad9a8b3') }
+
+    before { allow(KYCAID::Document).to receive(:create).and_return(successful_docs_response) }
+    before { allow(KYCAID::Verification).to receive(:create).and_return(successful_verification_response) }
+
+    before { allow_any_instance_of(KYC::Kycaid::DocumentWorker).to receive(:document_params).and_return({}) }
+    before { allow_any_instance_of(KYC::Kycaid::DocumentWorker).to receive(:selfie_image_params).and_return({}) }
+
+    context 'perform' do
+      it 'creates a document record' do
+        expect(document.metadata).to eq(nil)
+        expect(KYCAID::Document).to receive(:create)
+
+        KYC::Kycaid::DocumentWorker.new.perform(document.user.id, '84e51f8a06')
+        expect(document.reload.metadata).not_to eq(nil)
+      end
+
+      it 'creates a verification request' do
+        expect(document.metadata).to eq(nil)
+        expect(KYCAID::Document).to receive(:create)
+        expect(KYCAID::Verification).to receive(:create)
+
+        KYC::Kycaid::DocumentWorker.new.perform(document.user.id, '84e51f8a06')
+        expect(document.reload.metadata).not_to eq(nil)
+      end
+    end
+  end
+
+  describe 'failed verification' do
+    before { allow_any_instance_of(KYC::Kycaid::DocumentWorker).to receive(:document_params).and_return({}) }
+    before { allow_any_instance_of(KYC::Kycaid::DocumentWorker).to receive(:selfie_image_params).and_return({}) }
+
+    let(:unauthorized_response) { OpenStruct.new(error: { "type": 'unauthorized' }) }
+    let(:unsuccessful_response) do
+      OpenStruct.new(type: 'validation', errors: [{ "parameter": 'front_file', "message": 'Image is blured' }])
+    end
+
+    context 'unathorized' do
+      before { allow(KYCAID::Document).to receive(:create).and_return(unauthorized_response) }
+
+      it 'does not create a document because of error' do
+        expect(document.metadata).to eq(nil)
+        expect(KYCAID::Document).to receive(:create)
+        expect(KYCAID::Verification).not_to receive(:create)
+
+        KYC::Kycaid::DocumentWorker.new.perform(document.user.id, '84e51f8a06')
+        expect(document.reload.metadata).to eq(nil)
+      end
+    end
+
+    context 'validation failed' do
+      before { allow(KYCAID::Document).to receive(:create).and_return(unsuccessful_response) }
+
+      it 'does not create a document' do
+        expect(document.metadata).to eq(nil)
+        expect(KYCAID::Document).to receive(:create)
+
+        KYC::Kycaid::DocumentWorker.new.perform(document.user.id, '84e51f8a06')
+        expect(document.metadata).to eq(nil)
+      end
+
+      it 'gets a rejected label' do
+        expect(document.metadata).to eq(nil)
+        expect(document.user.labels.count).to eq(2)
+        expect(document.user.labels.find_by(key: :document).value).to eq('pending')
+
+        expect(KYCAID::Document).to receive(:create)
+
+        KYC::Kycaid::DocumentWorker.new.perform(document.user.id, '84e51f8a06')
+        expect(document.metadata).to eq(nil)
+        expect(document.user.labels.count).to eq(2)
+        expect(document.user.labels.find_by(key: :document).value).to eq('rejected')
+      end
+    end
+  end
+end

spec/workers/verification_worker_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+describe 'KYC::Kycaid::VerificationWorker' do
+  before { allow(Barong::App.config).to receive_messages(kyc_provider: 'kycaid') }
+
+  include_context 'bearer authentication'
+  let!(:create_member_permission) do
+    create :permission,
+           role: 'member'
+  end
+  let(:user) { create(:user) }
+  let!(:profile) { create(:profile, country: 'UA', state: 'submitted', applicant_id: '84e51f8a0677a646fd185fc741717ad9a8b3', user_id: user.id) }
+  let!(:document) { create(:document, identificator: '84e51f8a06', doc_type: 'Passport', doc_category: 'front_side', user_id: user.id) }
+  let!(:document_second) { create(:document, identificator: '84e51f8a06', doc_type: 'Passport', doc_category: 'selfie', user_id: user.id) }
+
+  describe 'successful verifications' do
+    let(:successful_verification_response) { OpenStruct.new(status: 'completed', verifications: { document: { verified: true } }) }
+    before { allow(KYCAID::Verification).to receive(:fetch).and_return(successful_verification_response) }
+
+    context 'perform' do
+      it 'fetches verification data' do
+        expect(user.labels.count).to eq(2)
+        expect(user.labels.find_by(key: :document, scope: :private).value).to eq('pending')
+
+        expect(KYCAID::Verification).to receive(:fetch)
+
+        KYC::Kycaid::VerificationsWorker.new.perform({ applicant_id: profile.applicant_id, verification_id: '84e51f8a' })
+      end
+
+      it 'changes label accordingly to verification' do
+        expect(user.labels.count).to eq(2)
+        expect(user.labels.find_by(key: :document, scope: :private).value).to eq('pending')
+
+        expect(KYCAID::Verification).to receive(:fetch)
+
+        KYC::Kycaid::VerificationsWorker.new.perform({ applicant_id: profile.applicant_id, verification_id: '84e51f8a' })
+
+        expect(user.labels.count).to eq(2)
+        expect(user.labels.reload.find_by(key: :document, scope: :private).value).to eq('verified')
+      end
+    end
+  end
+
+  describe 'failed verification' do
+    let(:unsuccessful_response) { OpenStruct.new(status: 'completed', verifications: { document: { verified: false } }) }
+    before { allow(KYCAID::Verification).to receive(:fetch).and_return(unsuccessful_response) }
+
+    let(:unauthorized_response) { OpenStruct.new(error: { "type": 'unauthorized' }) }
+
+    context 'unathorized' do
+      before { allow(KYCAID::Verification).to receive(:fetch).and_return(unauthorized_response) }
+
+      it 'does not create a document because of error' do
+        expect(user.labels.count).to eq(2)
+        expect(user.labels.find_by(key: :document, scope: :private).value).to eq('pending')
+
+        expect(KYCAID::Verification).to receive(:fetch)
+
+        KYC::Kycaid::VerificationsWorker.new.perform({ applicant_id: profile.applicant_id, verification_id: '84e51f8a' })
+        expect(user.labels.reload.find_by(key: :document, scope: :private).value).to eq('pending')
+      end
+    end
+
+    context 'verification declined' do
+      it 'fetches verification data' do
+        expect(user.labels.count).to eq(2)
+        expect(user.labels.find_by(key: :document, scope: :private).value).to eq('pending')
+
+        expect(KYCAID::Verification).to receive(:fetch)
+
+        KYC::Kycaid::VerificationsWorker.new.perform({ applicant_id: profile.applicant_id, verification_id: '84e51f8a' })
+      end
+
+      it 'changes label accordingly to verification' do
+        expect(user.labels.count).to eq(2)
+        expect(user.labels.find_by(key: :document, scope: :private).value).to eq('pending')
+
+        expect(KYCAID::Verification).to receive(:fetch)
+
+        KYC::Kycaid::VerificationsWorker.new.perform({ applicant_id: profile.applicant_id, verification_id: '84e51f8a' })
+
+        expect(user.labels.count).to eq(2)
+        expect(user.labels.reload.find_by(key: :document, scope: :private).value).to eq('rejected')
+      end
+    end
+  end
+end