onfido 2.9.0 → 3.0.0

data/spec/integrations/report_spec.rb

@@ -1,41 +1,50 @@
 # frozen_string_literal: true
 
-describe Onfido::Report do
-  include_context 'fake onfido api'
-
-  subject(:report) { onfido.report }
+require_relative '../shared_contexts/with_check'
 
-  describe '#find' do
-    it 'returns a report for an existing check' do
-      report_id = '6951786-123123-422221'
-      response = report.find(report_id)
+describe Onfido::Report do
+  describe 'Report' do
+    include_context 'with check'
 
-      expect(response['id']).to eq(report_id)
+    let(:sorted_reports) do
+      sort_reports(onfido_api.list_reports(check.id).reports)
     end
-  end
+    let(:document_report_id) { sorted_reports[0].id }
+    let(:identity_report_id) { sorted_reports[1].id }
 
-  describe '#all' do
-    it 'lists all reports for an existing check' do
-      check_id = '8546921-123123-123123'
-      response = report.all(check_id)
 
-      expect(response['reports'].count).to eq(2)
+    def sort_reports(reports_list)
+      reports_list.sort_by { |report| report.name }
     end
-  end
 
-  describe '#resume' do
-    it 'returns a success response' do
-      report_id = '6951786-123123-422221'
+    it 'lists reports' do
+      expect(sorted_reports[0].name).to eq Onfido::ReportName::DOCUMENT
+      expect(sorted_reports[1].name).to eq Onfido::ReportName::IDENTITY_ENHANCED
+    end
 
-      expect { report.resume(report_id) }.not_to raise_error
+    it 'finds a report' do
+      get_document_report = onfido_api.find_report(document_report_id)
+      get_identity_report = onfido_api.find_report(identity_report_id)
+
+      expect(get_document_report).to be_an_instance_of Onfido::DocumentReport
+      expect(get_document_report.id).to eq document_report_id
+      expect(get_document_report.name).to eq Onfido::ReportName::DOCUMENT
+      expect(get_document_report.status).to eq Onfido::ReportStatus::AWAITING_DATA
+
+      expect(get_identity_report).to be_an_instance_of Onfido::IdentityEnhancedReport
+      expect(get_identity_report.id).to eq identity_report_id
+      expect(get_identity_report.name).to eq Onfido::ReportName::IDENTITY_ENHANCED
+      expect(get_identity_report.status).to eq Onfido::ReportStatus::COMPLETE
+      expect(get_identity_report.breakdown.date_of_birth).to be_nil
+      expect(get_identity_report.breakdown.address).to be_nil
     end
-  end
 
-  describe '#cancel' do
-    it 'returns a success response' do
-      report_id = '6951786-123123-422221'
+    it 'resumes a report' do
+      onfido_api.resume_report(document_report_id)
+    end
 
-      expect { report.cancel(report_id) }.not_to raise_error
+    it 'cancels a report' do
+      onfido_api.cancel_report(document_report_id)
     end
   end
 end

data/spec/integrations/sdk_token_spec.rb

@@ -1,18 +1,20 @@
 # frozen_string_literal: true
 
-describe Onfido::SdkToken do
-  include_context 'fake onfido api'
-
-  subject(:sdk_token) { onfido.sdk_token }
+require_relative '../shared_contexts/with_applicant'
 
-  describe '#create' do
-    it 'creates a new SDK token for the applicant' do
-      applicant_id = '61f659cb-c90b-4067-808a-6136b5c01351'
-      referrer = 'http://*.mywebsite.com/*'
+describe Onfido::SdkToken do
+  describe 'SDK token' do
+    include_context 'with applicant'
 
-      response = sdk_token.create(applicant_id: applicant_id, referrer: referrer)
+    it 'generates a SDK token' do
+      token_builder = Onfido::SdkTokenBuilder.new({
+        applicant_id: applicant_id,
+        referrer: 'https://*.example.com/example_page/*',
+      })
+      token = onfido_api.generate_sdk_token(token_builder)
 
-      expect(response['token']).not_to be_nil
+      expect(token).to be_an_instance_of Onfido::SdkToken
+      expect(token.token.size).to be > 0
     end
   end
 end

data/spec/integrations/tasks_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../shared_contexts/with_workflow_run'
+
+describe Onfido::Task do
+  describe 'Tasks' do
+    include_context 'with workflow run'
+
+    it 'lists tasks' do
+      list_of_tasks = onfido_api.list_tasks(workflow_run_id)
+
+      expect(list_of_tasks).to_not be_nil
+      expect(list_of_tasks[0]).to be_an_instance_of Onfido::TaskItem
+      expect(list_of_tasks.size).to eq 2
+    end
+
+    it 'finds a task' do
+      task = onfido_api.list_tasks(workflow_run_id)[0]
+      get_task = onfido_api.find_task(workflow_run_id, task.id)
+
+      expect(get_task).to_not be_nil
+      expect(get_task).to be_an_instance_of Onfido::Task
+      expect(get_task.id).to eq task.id
+      expect(get_task.task_def_id).to eq task.task_def_id
+    end
+
+    it 'completes a task' do
+      tasks = onfido_api.list_tasks(workflow_run_id)
+      profile_data_task_id = (tasks.select { |task| task.id.include? 'profile' })[0].id
+
+      complete_task_builder = Onfido::CompleteTaskBuilder.new({
+        data: Onfido::CompleteTaskDataBuilder.build({
+          first_name: 'Jane',
+          last_name: 'Doe',
+        })
+      })
+
+      onfido_api.complete_task(workflow_run_id, profile_data_task_id, complete_task_builder)
+      task_outputs = onfido_api.find_task(workflow_run_id, profile_data_task_id).output
+
+      expect(task_outputs[:first_name]).to eq 'Jane'
+      expect(task_outputs[:last_name]).to eq 'Doe'
+    end
+  end
+end

data/spec/integrations/watchlist_monitor_spec.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+require_relative '../shared_contexts/with_applicant'
+
+describe Onfido::WatchlistMonitor do
+  describe 'Watchlist monitor' do
+    include_context 'with applicant'
+
+    let(:watchlist_monitor_builder) do
+      Onfido::WatchlistMonitorBuilder.new({
+        applicant_id: applicant_id,
+        report_name: Onfido::ReportName::WATCHLIST_STANDARD
+      })
+    end
+    let(:watchlist_monitor) do
+      onfido_api.create_watchlist_monitor(watchlist_monitor_builder)
+    end
+    let!(:watchlist_monitor_id) { watchlist_monitor.id }
+    
+
+    it 'creates a watchlist standard monitor' do
+      expect(watchlist_monitor).to be_an_instance_of Onfido::WatchlistMonitor
+      expect(watchlist_monitor.applicant_id).to eq applicant_id
+      expect(watchlist_monitor.report_name).to eq Onfido::ReportName::WATCHLIST_STANDARD
+    end
+
+    context 'AML monitor' do
+      let(:watchlist_monitor_builder) do
+        Onfido::WatchlistMonitorBuilder.new({
+          applicant_id: applicant_id,
+          report_name: Onfido::ReportName::WATCHLIST_AML
+        })
+      end
+
+      it 'creates a watchlist AML monitor' do
+        expect(watchlist_monitor).to be_an_instance_of Onfido::WatchlistMonitor
+        expect(watchlist_monitor.applicant_id).to eq applicant_id
+        expect(watchlist_monitor.report_name).to eq Onfido::ReportName::WATCHLIST_AML
+      end
+    end
+
+    it 'lists watchlist monitors' do
+      list_of_monitors = onfido_api.list_watchlist_monitors(applicant_id)
+
+      expect(list_of_monitors).to be_an_instance_of Onfido::WatchlistMonitorsList
+      expect(list_of_monitors.monitors.size).to be > 0
+    end
+
+    it 'finds a watchlist monitor' do
+      get_watchlist_monitor = onfido_api.find_watchlist_monitor(watchlist_monitor_id)
+
+      expect(get_watchlist_monitor.id).to eq watchlist_monitor_id
+    end
+
+    it 'deletes a watchlist monitor' do
+      onfido_api.delete_watchlist_monitor(watchlist_monitor_id)
+    end
+
+    it 'lists watchlist monitor matches' do
+      matches_list = onfido_api.list_watchlist_monitor_matches(watchlist_monitor_id)
+      
+      expect(matches_list).to be_an_instance_of Onfido::WatchlistMonitorMatchesList
+      expect(matches_list.matches.size).to eq 0
+    end
+
+    it 'forces report creation' do
+      onfido_api.force_report_creation_from_watchlist_monitor(watchlist_monitor_id)
+
+      checks = onfido_api.list_checks(applicant_id).checks
+      expect(checks.size).to eq 2
+    end
+  end
+end

data/spec/integrations/webhook_spec.rb

@@ -1,110 +1,62 @@
 # frozen_string_literal: true
 
-describe Onfido::Webhook do
-  include_context 'fake onfido api'
-
-  subject(:webhook) { onfido.webhook }
-
-  describe '#create' do
-    let(:params) do
-      {
-        url: 'https://webhookendpoint.url',
-        enabled: true,
-        events: [
-          'report.completed',
-          'check.completed'
-        ]
-      }
-    end
-
-    it 'creates the webhook' do
-      response = webhook.create(**params)
-
-      expect(response['id']).to_not be_nil
-    end
-
-    it 'responds with the right url' do
-      response = webhook.create(**params)
-
-      expect(response['url']).to eq params[:url]
-    end
-  end
-
-  describe '#find' do
-    it 'returns the webhook' do
-      webhook_id = 'fcb73186-0733-4f6f-9c57-d9d5ef979443'
-
-      response = webhook.find(webhook_id)
+require_relative '../shared_contexts/with_onfido'
 
-      expect(response['id']).to eq(webhook_id)
-    end
-  end
-
-  describe '#destroy' do
-    it 'removes the webhook' do
-      webhook_id = 'fcb73186-0733-4f6f-9c57-d9d5ef979443'
-      expect { webhook.destroy(webhook_id) }.not_to raise_error
-    end
-  end
-
-  describe '#all' do
-    it 'returns all the registered webhooks' do
-      response = webhook.all
+describe Onfido::Webhook do
+  describe 'Webhook' do
+    include_context 'with onfido'
 
-      expect(response['webhooks'].count).to eq 2
+    let(:webhook_builder) do
+      Onfido::WebhookBuilder.new({
+        url: 'https://example.com',
+        events: ['check.completed', 'report.completed'],
+      })
     end
 
-    it 'returns with id' do
-      response = webhook.all
+    let(:webhook) { onfido_api.create_webhook(webhook_builder) }
+    let(:webhook_id) { webhook.id }
 
-      expect(response['webhooks'][0]['id']).to_not be_nil
-      expect(response['webhooks'][1]['id']).to_not be_nil
+    it 'creates a webhook' do
+      expect(webhook).to be_an_instance_of Onfido::Webhook
+      expect(webhook_id).to_not be_nil
+      expect(webhook.url).to eq 'https://example.com'
+      expect(webhook.events).to eq ['check.completed', 'report.completed']
     end
-  end
 
-  describe '.valid?' do
-    subject(:valid?) do
-      described_class.valid?(request_body, request_signature, token)
-    end
+    it 'updates a webhook' do
+      webhook_updater = Onfido::WebhookUpdater.new({
+        url: 'https://example.co.uk',
+        events: ['check.completed'],
+      })
 
-    let(:request_body) { '{"foo":"bar"}' }
-    let(:request_signature) do
-      '89e60408fec20bfb26bb0f993d5e88307818982f50f23b361a00d679bae8b1dc'
+      updated_webhook = onfido_api.update_webhook(webhook_id, webhook_updater)
+      expect(updated_webhook.id).to eq webhook_id
+      expect(updated_webhook.url).to eq 'https://example.co.uk'
+      expect(updated_webhook.events).to eq ['check.completed']
     end
-    let(:token) { 'very_secret_token' }
 
-    it { is_expected.to be(true) }
+    it 'lists webhooks' do
+      list_of_webhooks = onfido_api.list_webhooks()
 
-    context 'with an invalid signature' do
-      let(:request_signature) do
-        's21fd54ew2w1f5d15642132f3d7727ff9a32a7c87072ce514df1f6d3228bec'
-      end
-      it { is_expected.to be(false) }
+      expect(list_of_webhooks).to be_an_instance_of Onfido::WebhooksList
+      expect(list_of_webhooks.webhooks.size).to be > 0
     end
 
-    context 'with a nil request signature' do
-      let(:request_signature) { nil }
-      specify { expect { valid? }.to raise_error(ArgumentError) }
-    end
+    it 'finds a webhook' do
+      get_webhook = onfido_api.find_webhook(webhook_id)
 
-    context 'with a token other than the one used to sign the request' do
-      let(:token) { 'quite_secret_token' }
-      it { is_expected.to be(false) }
+      expect(get_webhook).to be_an_instance_of(Onfido::Webhook)
+      expect(get_webhook.id).to eq webhook_id
     end
 
-    context 'with a nil token' do
-      let(:token) { nil }
-      specify { expect { valid? }.to raise_error(ArgumentError) }
-    end
+    it 'deletes a webhook' do
+      onfido_api.delete_webhook(webhook_id)
 
-    context 'with a modified request body' do
-      let(:request_body) { '{"bar":"baz"}' }
-      it { is_expected.to be(false) }
-    end
-
-    context 'with a nil request body' do
-      let(:request_body) { nil }
-      specify { expect { valid? }.to raise_error(ArgumentError) }
+      expect {
+        onfido_api.find_webhook(webhook_id)
+      }.to raise_error(Onfido::ApiError) { |e|
+        expect(e.code).to eq(404)
+      }
     end
   end
 end

data/spec/integrations/workflow_run_output_spec.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+require_relative '../shared_contexts/with_document'
+require_relative '../shared_contexts/with_live_photo'
+require_relative '../shared_contexts/with_workflow_run'
+
+describe Onfido::WorkflowRun do
+  describe 'Workflow run outputs' do
+    include_context 'with workflow run'
+
+    context 'workflow with profile data as output' do
+      let(:workflow_id) { 'd27e510b-27a8-44c3-a3cc-bf4c0648a4ba' }
+
+      let(:profile_data) do
+        {
+          country_residence: 'GBR',
+          first_name: 'First',
+          last_name: 'Last',
+          dob: '2000-01-01',
+          email: 'first.last@gmail.com',
+          phone_number: '+351911111111',
+          nationality: 'GBR',
+          phone_number_consent_granted: true,
+          address: {
+              country: 'GBR',
+              line1: '123rd Street',
+              line2: '2nd Floor',
+              line3: '23',
+              town: 'London',
+              postcode: 'S2 2DF',
+          }
+        }
+      end  
+    
+      it 'returns profile data as output' do
+        tasks = onfido_api.list_tasks(workflow_run_id)
+        profile_data_task_id = (tasks.select { |task| task.id.include? 'profile' })[0].id
+
+        complete_task_builder = Onfido::CompleteTaskBuilder.new({
+          data: Onfido::CompleteTaskDataBuilder.build(profile_data)
+        })
+        onfido_api.complete_task(workflow_run_id, profile_data_task_id, complete_task_builder)
+
+        workflow_run_outputs = onfido_api.find_workflow_run(workflow_run_id).output
+
+        expect(workflow_run_outputs[:profile_capture_data]).to eq profile_data
+      end
+    end
+
+    context 'workflow run with document and facial similarity reports as output' do
+      include_context 'with document'
+      include_context 'with live photo'
+
+      let(:workflow_id) { '5025d9fd-7842-4805-bce1-a7bfd7131b4e' }
+      let(:profile_data) { { first_name: 'Jane', last_name: 'Doe' } }
+
+      it 'returns document and facial similarity reports' do
+        tasks = onfido_api.list_tasks(workflow_run_id)
+        profile_data_task_id = (tasks.select { |task| task.id.include? 'profile' })[0].id
+
+        complete_profile_task_builder = Onfido::CompleteTaskBuilder.new({
+          data: Onfido::CompleteTaskDataBuilder.build(profile_data)
+        })
+        onfido_api.complete_task(
+          workflow_run_id,
+          profile_data_task_id,
+          complete_profile_task_builder,
+        )
+
+        tasks = onfido_api.list_tasks(workflow_run_id)
+        document_capture_task_id = (tasks.select { |task| task.id.include? 'document_photo' })[0].id
+
+        complete_document_capture_task_builder = Onfido::CompleteTaskBuilder.new(
+          data: Onfido::CompleteTaskDataBuilder.build([{ id: document_id }])
+        )
+        onfido_api.complete_task(
+          workflow_run_id,
+          document_capture_task_id,
+          complete_document_capture_task_builder,
+        )
+
+        tasks = onfido_api.list_tasks(workflow_run_id)
+        live_photo_capture_task_id = (tasks.select { |task| task.id.include? 'face_photo' })[0].id
+
+        complete_live_photo_capture_task_request = Onfido::CompleteTaskBuilder.new(
+          data: Onfido::CompleteTaskDataBuilder.build([{ id: live_photo_id }])
+        )
+        onfido_api.complete_task(
+          workflow_run_id,
+          live_photo_capture_task_id,
+          complete_live_photo_capture_task_request,
+        )
+
+        workflow_run = repeat_request_until_status_changes('approved') do
+          onfido_api.find_workflow_run(workflow_run_id)
+        end
+
+        document_report_output = workflow_run.output[:doc]
+        facial_similarity_report_output = workflow_run.output[:selfie]
+
+        expect(document_report_output[:breakdown]).to_not be_nil
+        expect(document_report_output[:properties]).to_not be_nil
+        expect(document_report_output[:repeat_attempts]).to_not be_nil
+        expect(document_report_output[:result]).to_not be_nil
+        expect(document_report_output[:status]).to_not be_nil
+        expect(document_report_output[:sub_result]).to_not be_nil
+        expect(document_report_output[:uuid]).to_not be_nil
+
+        expect(facial_similarity_report_output[:breakdown]).to_not be_nil
+        expect(facial_similarity_report_output[:properties]).to_not be_nil
+        expect(facial_similarity_report_output[:result]).to_not be_nil
+        expect(facial_similarity_report_output[:status]).to_not be_nil
+        expect(facial_similarity_report_output[:uuid]).to_not be_nil
+      end
+    end
+  end
+end

data/spec/integrations/workflow_run_spec.rb

@@ -1,54 +1,84 @@
 # frozen_string_literal: true
 
-describe Onfido::WorkflowRun do
-  include_context 'fake onfido api'
+require_relative '../shared_contexts/with_workflow_run'
 
-  subject(:workflow_run) { onfido.workflow_run }
+describe Onfido::WorkflowRun do
+  describe 'Workflow run' do
+    include_context 'with workflow run'
 
-  let(:workflow_run_id) { 'fcb73186-0733-4f6f-9c57-d9d5ef979443' }
-  let(:params) do
-    {
-      'a' => 'b'
-    }
-  end
+    it 'creates a workflow run' do
+      expect(workflow_run).to be_an_instance_of Onfido::WorkflowRun
+      expect(workflow_run.applicant_id).to eq applicant_id
+      expect(workflow_run.status).to eq 'awaiting_input'
+    end
 
-  describe '#create' do
-    it 'serializes the payload correctly' do
-      WebMock.after_request do |request_signature, _response|
-        if request_signature.uri.path == 'v3.6/workflow_run'
-          expect(Rack::Utils.parse_nested_query(request_signature.body))
-            .to eq(params)
-        end
+    context 'workflow run with custom inputs' do
+      let(:workflow_id) { '45092b29-f220-479e-aa6f-a6f989baac4c' }
+      let(:workflow_run_builder) do
+        Onfido::WorkflowRunBuilder.new({
+          applicant_id: applicant_id,
+          workflow_id: workflow_id,
+          custom_data: {
+            age: 18,
+            is_employed: false
+          }
+        })
+      end
+      
+      it 'creates a workflow run with custom inputs' do
+        expect(workflow_run).to be_an_instance_of Onfido::WorkflowRun
+        expect(workflow_run.workflow_id).to eq workflow_id
+        expect(workflow_run.status).to eq 'approved'
       end
     end
 
-    it 'creates a workflow run' do
-      response = workflow_run.create(params)
-      expect(response['id']).not_to be_nil
+    it 'lists workflow runs' do
+      list_of_workflow_runs = onfido_api.list_workflow_runs()
+
+      expect(list_of_workflow_runs[0]).to be_an_instance_of Onfido::WorkflowRun
+      expect(list_of_workflow_runs.size).to be > 0
     end
-  end
 
-  describe '#find' do
-    it 'returns the workflow run' do
-      response = workflow_run.find(workflow_run_id)
+    it 'finds a workflow run' do
+      get_workflow_run = onfido_api.find_workflow_run(workflow_run_id)
 
-      expect(response['id']).to eq(workflow_run_id)
+      expect(get_workflow_run).to be_an_instance_of Onfido::WorkflowRun
+      expect(get_workflow_run.id).to eq workflow_run_id
     end
-  end
 
-  describe '#all' do
-    it 'returns the workflow runs' do
-      response = workflow_run.all({ page: 1, sort: 'asc' })
+    it 'downloads evidence file' do
+      file = onfido_api.download_signed_evidence_file(workflow_run_id)
 
-      expect(response.count).to eq(2)
+      expect(file.size).to be > 0
     end
-  end
 
-  describe '#evidence' do
-    it 'returns the signed PDF' do
-      response = workflow_run.evidence(workflow_run_id)
+    context 'with start -> approved workflow' do
+      let(:workflow_id) { '221f9d24-cf72-4762-ac4a-01bf3ccc09dd' }
+
+      it 'generates a timeline file' do
+        repeat_request_until_status_changes('approved') do
+          onfido_api.find_workflow_run(workflow_run_id)
+        end
+
+        workflow_timeline_file_data = onfido_api.create_timeline_file(workflow_run_id)
+
+        expect(workflow_timeline_file_data).to be_an_instance_of Onfido::TimelineFileReference
+        expect(workflow_timeline_file_data.workflow_timeline_file_id).to_not be_nil
+        expect(workflow_timeline_file_data.href).to_not be_nil
+      end
 
-      expect(response[0..4]).to eq('%PDF-')
+      it 'finds a timeline file' do
+        repeat_request_until_status_changes('approved') do
+          onfido_api.find_workflow_run(workflow_run_id)
+        end
+
+        timeline_file_id = onfido_api.create_timeline_file(workflow_run_id).workflow_timeline_file_id
+        file = repeat_request_unti_http_code_changes do
+          onfido_api.find_timeline_file(workflow_run_id, timeline_file_id)
+        end
+
+        expect(file.size).to be > 0
+      end
     end
   end
 end

data/spec/shared_contexts/with_applicant.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require_relative '../shared_contexts/with_onfido'
+
+RSpec.shared_context 'with applicant', shared_context: :metadata do
+  include_context 'with onfido'
+
+  let(:applicant_id) do
+    applicant = onfido_api.create_applicant(default_applicant_body)
+
+    applicant.id
+  end
+
+  let(:default_applicant_body) do
+    {
+      'first_name' => 'Test',
+      'last_name' => 'Applicant',
+      'location' => {
+        'ip_address' => '127.0.0.1',
+        'country_of_residence' => 'GBR'
+      }
+    }
+  end
+end

data/spec/shared_contexts/with_check.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require_relative '../shared_contexts/with_document'
+
+RSpec.shared_context 'with check', shared_context: :metadata do
+  include_context 'with document'
+
+  let(:check_builder) do
+    Onfido::CheckBuilder.new({
+      applicant_id: applicant_id,
+      document_ids: [document_id],
+      report_names: [Onfido::ReportName::DOCUMENT, Onfido::ReportName::IDENTITY_ENHANCED],
+    })
+  end
+
+  let(:check) { onfido_api.create_check(check_builder) }
+  let!(:check_id) { check.id }
+end

data/spec/shared_contexts/with_document.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require_relative '../shared_contexts/with_applicant'
+
+RSpec.shared_context 'with document', shared_context: :metadata do
+  include_context 'with applicant'
+
+  let(:document_file_name) { 'sample_driving_licence.png' }
+  let(:document_file) { File.open("spec/integrations/media/#{document_file_name}") }
+
+  let(:document) { onfido_api.upload_document('passport', applicant_id, document_file) }
+  let!(:document_id) { document.id }
+end