onfido 2.9.0 → 3.0.0

data/spec/integrations/check_spec.rb

@@ -1,64 +1,83 @@
 # frozen_string_literal: true
 
-describe Onfido::Check do
-  include_context 'fake onfido api'
-
-  subject(:check) { onfido.check }
+require_relative '../shared_contexts/with_check'
 
-  let(:applicant_id) { '61f659cb-c90b-4067-808a-6136b5c01351' }
-  let(:check_id) { '8546921-123123-123123' }
+describe Onfido::Check do
+  describe 'Checks' do
+    include_context 'with check'
 
-  describe '#create' do
-    it 'creates a new check for an applicant' do
-      response = check.create(
-        applicant_id: applicant_id,
-        report_names: ['identity_enhanced']
-      )
-      expect(response['id']).not_to be_nil
+    it 'creates a check' do
+      expect(check).not_to be_nil
+      expect(check).to be_an_instance_of Onfido::Check
+      expect(check.applicant_id).to eq applicant_id
+      expect(check.report_ids.size).to eq 2
+      expect(check.status).to eq 'in_progress'
     end
-  end
 
-  describe '#find' do
-    it 'returns an existing check for the applicant' do
-      response = check.find(check_id)
+    context 'consider check' do
+      let(:check_builder) do
+        check_builder = Onfido::CheckBuilder.new({
+          applicant_id: applicant_id,
+          document_ids: [document_id],
+          report_names: [Onfido::ReportName::DOCUMENT],
+          consider: [Onfido::ReportName::DOCUMENT],
+        })
+      end
 
-      expect(response['id']).to eq(check_id)
+      it 'creates a consider check' do
+        expect(check).not_to be_nil
+        expect(check).to be_an_instance_of Onfido::Check
+        expect(check.applicant_id).to eq applicant_id
+      end
     end
 
-    it 'returns report_ids' do
-      response = check.find(check_id)
+    context 'US driving licence check' do
+      let(:us_driving_licence_builder) do
+        Onfido::UsDrivingLicenceBuilder.new({
+          id_number: '12345',
+          issue_state: 'GA',
+        })
+      end
 
-      expect(response['report_ids'].first).to be_a(String)
+      let(:check_builder) do
+        Onfido::CheckBuilder.new({
+          applicant_id: applicant_id,
+          document_ids: [document_id],
+          report_names: [Onfido::ReportName::DOCUMENT],
+          us_driving_licence: us_driving_licence_builder,
+        })
+      end
+    
+      it 'creates a driving licence check' do
+        expect(check).not_to be_nil
+        expect(check).to be_an_instance_of Onfido::Check
+        expect(check.applicant_id).to eq applicant_id
+      end
     end
-  end
 
-  describe '#all' do
-    context 'with the default page and per page params' do
-      it 'returns all existing checks for the applicant' do
-        response = check.all(applicant_id)
+    it 'lists checks' do
+      list_of_checks = onfido_api.list_checks(applicant_id)
 
-        expect(response['checks'].size).to eq(1)
-      end
+      expect(list_of_checks).not_to be_nil
+      expect(list_of_checks).to be_an_instance_of Onfido::ChecksList
+      expect(list_of_checks.checks.size).to be > 0
     end
 
-    it 'returns report_ids' do
-      response = check.all(applicant_id)
-
-      expect(response['checks'].first['report_ids'].first).to be_a(String)
+    it 'finds a check' do
+      get_check = onfido_api.find_check(check_id)
+      
+      expect(get_check).to be_an_instance_of(Onfido::Check)
+      expect(get_check.id).to eq check_id      
     end
-  end
 
-  describe '#resume' do
-    it 'returns success response' do
-      expect { check.resume(check_id) }.not_to raise_error
+    it 'restarts a check' do
+      onfido_api.resume_check(check_id)
     end
-  end
 
-  describe '#download' do
-    it 'returns the file data' do
-      response = check.download(check_id)
+    it 'downloads a check' do
+      file = onfido_api.download_check(check_id)
 
-      expect(response).not_to be_nil
+      expect(file.size).to be > 0
     end
   end
 end

data/spec/integrations/document_spec.rb

@@ -1,75 +1,46 @@
 # frozen_string_literal: true
 
-require 'tempfile'
+require_relative '../shared_contexts/with_document'
 
 describe Onfido::Document do
-  include_context 'fake onfido api'
-
-  subject(:document) { onfido.document }
-
-  describe '#create' do
-    let(:params) do
-      {
-        applicant_id: '1030303-123123-123123',
-        type: 'driving_licence',
-        file: file,
-        side: 'front',
-        location: {
-          ip_address: '127.0.0.1',
-          country_of_residence: 'GBR'
-        }
-      }
+  describe 'Documents' do
+    include_context 'with document'
+
+    it 'uploads a document' do
+      expect(document).not_to be_nil
+      expect(document.id).not_to be_empty
+      expect(document.file_name).to eq('sample_driving_licence.png')
+      expect(document).to be_an_instance_of(Onfido::Document)
     end
 
-    context 'with a File-like object to upload' do
-      let(:file) { Tempfile.new(['driving_licence', '.jpg']) }
-
-      after do
-        file.close
-        file.unlink
-      end
+    it 'lists documents' do
+      list_of_documents = onfido_api.list_documents(applicant_id)
 
-      it 'creates a new document' do
-        response = document.create(**params)
-
-        expect(response['id']).not_to be_nil
-      end
+      expect(list_of_documents).to be_an_instance_of(Onfido::DocumentsList)
+      expect(list_of_documents.documents.size).to be > 0
     end
 
-    context 'passing in a non-File-like file to upload' do
-      let(:file) { 'https://onfido.com/images/logo.png' }
+    it 'finds a document' do
+      get_document = onfido_api.find_document(document_id)
 
-      it 'raises an ArgumentError' do
-        expect { document.create(**params) }
-          .to raise_error(ArgumentError, /must be a `File`-like object/)
-      end
+      expect(get_document).to be_an_instance_of(Onfido::Document)
+      expect(get_document.id).to eq document_id
     end
-  end
 
-  describe '#find' do
-    it 'returns the expected document' do
-      document_id = '7568415-123123-123123'
-      response = document.find(document_id)
+    it 'downloads a document' do
+      file = onfido_api.download_document(document_id)
 
-      expect(response['id']).to eq(document_id)
+      expect(file.size).to be > 0
     end
-  end
 
-  describe '#all' do
-    it 'returns list of documents' do
-      applicant_id = '1030303-123123-123123'
-      response = document.all(applicant_id)
-
-      expect(response['documents']).not_to be_empty
-    end
-  end
-
-  describe '#download' do
-    it 'returns the file data' do
-      document_id = '1212121-123123-123123'
-      response = document.download(document_id)
-
-      expect(response).not_to be_nil
+    it 'cannot download an inexistent document' do
+      inexistent_document_id = '00000000-0000-0000-0000-000000000000'
+      
+      expect {
+        onfido_api.download_document(inexistent_document_id)
+      }.to raise_error(Onfido::ApiError) { |e|
+        expect(e.code).to eq(404)
+      }
     end
   end
 end

data/spec/integrations/extraction_spec.rb

@@ -1,23 +1,38 @@
 # frozen_string_literal: true
 
-require 'tempfile'
+require_relative '../shared_contexts/with_document'
 
 describe Onfido::Extraction do
-  include_context 'fake onfido api'
+  describe 'Extraction' do
+    include_context 'with document'
 
-  subject(:extraction) { onfido.extraction }
+    it 'performs extraction on a document' do
+      extraction = onfido_api.extract(
+        Onfido::ExtractRequest.new({
+          'document_id': document_id
+        })
+      )
 
-  describe '#create' do
-    let(:params) do
-      {
-        document_id: '7568415-123123-123123'
-      }
-    end
+      expect(extraction).not_to be_nil
+      expect(extraction).to be_an_instance_of Onfido::Extraction
+      expect(extraction.document_id).to eq document_id
+
+      document_classification = extraction.document_classification
+      extracted_data = extraction.extracted_data
 
-    it 'creates a new extraction' do
-      response = extraction.create(**params)
+      # Check response body: document classification
+      expect(document_classification).not_to be_nil
+      expect(document_classification.document_type).to eq Onfido::DocumentTypes::DRIVING_LICENCE
+      expect(document_classification.issuing_country).to eq Onfido::CountryCodes::GBR
 
-      expect(response['document_id']).to eq('7568415-123123-123123')
+      # Check response body: extracted data
+      expect(extracted_data).not_to be_nil
+      expect(extracted_data.date_of_birth).to eq Date.parse('1976-03-11')
+      expect(extracted_data.date_of_expiry).to eq Date.parse('2031-05-28')
+      expect(extracted_data.document_number).to eq '200407512345'
+      expect(extracted_data.first_name).to eq 'SARAH'
+      expect(extracted_data.last_name).to eq 'MORGAN'
+      expect(extracted_data.gender).to eq 'Female'
     end
   end
 end

data/spec/integrations/id_photo_spec.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+require_relative '../shared_contexts/with_applicant'
+
+describe Onfido::IdPhoto do
+  describe 'Id Photo' do
+    include_context 'with applicant'
+
+    let(:id_photo) do
+      onfido_api.upload_id_photo(
+        applicant_id: applicant_id,
+        file: File.new('spec/integrations/media/sample_photo.png')
+      )
+    end
+    let!(:id_photo_id) { id_photo.id }
+
+    it 'uploads a Id photo' do
+      expect(id_photo).not_to be_nil
+      expect(id_photo_id).not_to be_empty
+      expect(id_photo).to be_an_instance_of Onfido::IdPhoto
+      expect(id_photo.file_name).to eq "#{id_photo_id}.png"
+    end
+
+    it 'lists id photos' do
+      id_photos = onfido_api.list_id_photos(applicant_id)
+
+      expect(id_photos.id_photos.length).to be > 0
+      expect(id_photos).to be_an_instance_of Onfido::IdPhotosList
+    end
+
+    it 'retrieves id photo' do
+      get_id_photo = onfido_api.find_id_photo(id_photo_id)
+
+      expect(get_id_photo).to be_an_instance_of Onfido::IdPhoto
+      expect(get_id_photo.id).to eq id_photo_id
+    end
+
+    it 'downloads id photo' do
+      file = onfido_api.download_id_photo(id_photo_id)
+
+      expect(file.length).to be > 0
+    end
+
+    it 'raises an error with the correct status code when trying to download an inexistent id photo' do
+      inexistent_id_photo_id = '00000000-0000-0000-0000-000000000000'
+
+      expect {
+        onfido_api.download_id_photo(inexistent_id_photo_id)
+      }.to raise_error(Onfido::ApiError) { |e|
+        expect(e.message).to match(/the server returns an error/)
+        expect(e.code).to eq(404)
+      }
+    end
+  end
+end

data/spec/integrations/live_photo_spec.rb

@@ -1,64 +1,47 @@
 # frozen_string_literal: true
 
-require 'tempfile'
+require_relative '../shared_contexts/with_live_photo'
 
 describe Onfido::LivePhoto do
-  include_context 'fake onfido api'
-
-  subject(:live_photo) { onfido.live_photo }
-
-  describe '#create' do
-    let(:params) { { applicant_id: '123456', file: file } }
-
-    context 'with a File-like object to upload' do
-      let(:file) { Tempfile.new(['passport', '.jpg']) }
-
-      after do
-        file.close
-        file.unlink
-      end
-
-      it 'creates a new photo' do
-        response = live_photo.create(**params)
-
-        expect(response['id']).not_to be_nil
-      end
+  describe 'Live Photo' do
+    include_context 'with live photo'
+
+    it 'uploads a live photo' do
+      expect(live_photo).not_to be_nil
+      expect(live_photo_id).not_to be_empty
+      expect(live_photo.file_name).to eq('sample_photo.png')
+      expect(live_photo).to be_an_instance_of Onfido::LivePhoto
     end
 
-    context 'passing in a non-File-like file to upload' do
-      let(:file) { 'https://onfido.com/images/photo.jpg' }
+    it 'lists live photos' do
+      live_photos = onfido_api.list_live_photos(applicant_id)
 
-      it 'raises an ArgumentError' do
-        expect { live_photo.create(**params) }
-          .to raise_error(ArgumentError, /must be a `File`-like object/)
-      end
+      expect(live_photos.live_photos.length).to be > 0
+      expect(live_photos).to be_an_instance_of Onfido::LivePhotosList
     end
-  end
 
-  describe '#find' do
-    it 'returns the expected live photo' do
-      live_photo_id = '3538c8f6-fdce-4745-9d34-fc246bc05aa1'
-      response = live_photo.find(live_photo_id)
+    it 'retrieves live photo' do
+      live_photo = onfido_api.find_live_photo(live_photo_id)
 
-      expect(response['id']).to eq(live_photo_id)
+      expect(live_photo_id).to eq(live_photo_id)
+      expect(live_photo).to be_an_instance_of Onfido::LivePhoto
     end
-  end
 
-  describe '#all' do
-    it 'returns list of documents' do
-      applicant_id = '1030303-123123-123123'
-      response = live_photo.all(applicant_id)
+    it 'downloads live photo' do
+      file = onfido_api.download_live_photo(live_photo_id)
 
-      expect(response['live_photos']).not_to be_empty
+      expect(file.length).to be > 0
     end
-  end
 
-  describe '#download' do
-    it 'returns the file data' do
-      live_photo_id = '3538c8f6-fdce-4745-9d34-fc246bc05aa1'
-      response = live_photo.download(live_photo_id)
+    it 'raises an error with the correct status code when trying to download an inexistent live photo' do
+      inexistent_live_photo_id = '00000000-0000-0000-0000-000000000000'
 
-      expect(response).not_to be_nil
+      expect {
+        onfido_api.download_live_photo(inexistent_live_photo_id)
+      }.to raise_error(Onfido::ApiError) { |e|
+        expect(e.message).to match(/the server returns an error/)
+        expect(e.code).to eq(404)
+      }
     end
   end
 end

data/spec/integrations/live_video_spec.rb

@@ -1,36 +1,50 @@
 # frozen_string_literal: true
 
-require 'tempfile'
+require_relative '../shared_contexts/with_onfido'
 
 describe Onfido::LiveVideo do
-  include_context 'fake onfido api'
+  describe 'Live Video' do
+    include_context 'with onfido'
 
-  subject(:live_video) { onfido.live_video }
+    let(:applicant_id) { ENV['ONFIDO_SAMPLE_APPLICANT_ID'] }
+    let(:live_video_id) { ENV['ONFIDO_SAMPLE_VIDEO_ID_1'] }
 
-  let(:live_video_id) { 'c9701e9b-83aa-442f-995b-20320ee8fb01' }
+    it 'lists live videos' do
+      live_videos = onfido_api.list_live_videos(applicant_id)
 
-  describe '#find' do
-    it 'returns the expected live photo' do
-      response = live_video.find(live_video_id)
+      expect(live_videos.live_videos.length).to be > 0
+      expect(live_videos).to be_an_instance_of Onfido::LiveVideosList
+      expect(live_videos.live_videos.first).to be_an_instance_of Onfido::LiveVideo
+    end
+
+    it 'retrieves live videos' do
+      get_live_video = onfido_api.find_live_video(live_video_id)
 
-      expect(response['id']).to eq(live_video_id)
+      expect(get_live_video.id).to eq(live_video_id)
+      expect(get_live_video).to be_an_instance_of Onfido::LiveVideo
     end
-  end
 
-  describe '#all' do
-    it 'returns list of documents' do
-      applicant_id = '1030303-123123-123123'
-      response = live_video.all(applicant_id)
+    it 'downloads live video' do
+      file = onfido_api.download_live_video(live_video_id)
 
-      expect(response['live_videos']).not_to be_empty
+      expect(file.length).to be > 0
+    end
+
+    it 'downloads live video frame' do
+      file = onfido_api.download_live_video_frame(live_video_id)
+
+      expect(file.length).to be > 0
     end
-  end
 
-  describe '#download' do
-    it 'returns the file data' do
-      response = live_video.download(live_video_id)
+    it 'raises an error with the correct status code when trying to download an inexistent live video' do
+      inexistent_live_video_id = '00000000-0000-0000-0000-000000000000'
 
-      expect(response).not_to be_nil
+      expect {
+        onfido_api.download_live_video(inexistent_live_video_id)
+      }.to raise_error(Onfido::ApiError) { |e|
+        expect(e.message).to match(/the server returns an error/)
+        expect(e.code).to eq(404)
+      }
     end
   end
 end

data/spec/integrations/motion_capture_spec.rb

@@ -1,44 +1,50 @@
 # frozen_string_literal: true
 
-require 'tempfile'
+require_relative '../shared_contexts/with_onfido'
 
 describe Onfido::MotionCapture do
-  include_context 'fake onfido api'
+  describe 'Motion Capture' do
+    include_context 'with onfido'
 
-  subject(:motion_capture) { onfido.motion_capture }
+    let(:applicant_id) { ENV['ONFIDO_SAMPLE_APPLICANT_ID'] }
+    let(:motion_id) { ENV['ONFIDO_SAMPLE_MOTION_ID_1'] }
 
-  let(:motion_capture_id) { 'b1ae05b7-fb12-47c3-971c-311b56fc8de6' }
+    it 'lists motion captures' do
+      motion_captures = onfido_api.list_motion_captures(applicant_id)
 
-  describe '#find' do
-    it 'returns the expected motion capture' do
-      response = motion_capture.find(motion_capture_id)
+      expect(motion_captures.motion_captures.length).to be > 0
+      expect(motion_captures).to be_an_instance_of Onfido::MotionCapturesList
+      expect(motion_captures.motion_captures.first).to be_an_instance_of Onfido::MotionCapture
+    end
+
+    it 'retrieves motion capture' do
+      get_motion_capture = onfido_api.find_motion_capture(motion_id)
 
-      expect(response['id']).to eq(motion_capture_id)
+      expect(get_motion_capture.id).to eq(motion_id)
+      expect(get_motion_capture).to be_an_instance_of Onfido::MotionCapture
     end
-  end
 
-  describe '#all' do
-    it 'returns list of motion captures' do
-      applicant_id = '1030303-123123-123123'
-      response = motion_capture.all(applicant_id)
+    it 'downloads motion capture' do
+      file = onfido_api.download_motion_capture(motion_id)
 
-      expect(response['motion_captures']).not_to be_empty
+      expect(file.length).to be > 0
     end
-  end
 
-  describe '#download' do
-    it 'returns the file data' do
-      response = motion_capture.download(motion_capture_id)
+    it 'downloads motion capture frame' do
+      file = onfido_api.download_motion_capture_frame(motion_id)
 
-      expect(response).not_to be_nil
+      expect(file.length).to be > 0
     end
-  end
 
-  describe '#frame' do
-    it 'returns the frame data' do
-      response = motion_capture.frame(motion_capture_id)
+    it 'raises an error with the correct status code when trying to download an inexistent motion capture' do
+      inexistent_motion_id = '00000000-0000-0000-0000-000000000000'
 
-      expect(response).not_to be_nil
+      expect {
+        onfido_api.download_motion_capture(inexistent_motion_id)
+      }.to raise_error(Onfido::ApiError) { |e|
+        expect(e.message).to match(/the server returns an error/)
+        expect(e.code).to eq(404)
+      }
     end
   end
 end

data/spec/integrations/report_schema_spec.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+require_relative '../shared_contexts/with_document'
+require_relative '../shared_contexts/with_live_photo'
+
+describe Onfido::Report do
+  describe 'Report schemas' do
+    include_context 'with document'
+    include_context 'with live photo'
+
+    it 'schema of Document report is valid' do
+      document_report_id = onfido_api.create_check(
+        Onfido::CheckBuilder.new(
+          applicant_id: applicant_id,
+          document_ids: [document_id],
+          report_names: [Onfido::ReportName::DOCUMENT],
+      )).report_ids[0]
+
+      document_report = repeat_request_until_status_changes(
+        Onfido::ReportStatus::COMPLETE
+      ) { onfido_api.find_report(document_report_id) }
+
+      expect(document_report).to be_an_instance_of Onfido::DocumentReport
+
+      expect(document_report.name).to eq("document")
+      expect(document_report.breakdown.data_comparison.breakdown.issuing_country.result).to eq("clear")
+      expect(document_report.properties.date_of_birth).to eq(Date.parse("1990-01-01"))
+    end
+
+    it 'schema of Facial Similarity report is valid' do
+      facial_similarity_report_id = onfido_api.create_check(
+        Onfido::CheckBuilder.new(
+          applicant_id: applicant_id,
+          document_ids: [document_id],
+          report_names: [Onfido::ReportName::FACIAL_SIMILARITY_PHOTO],
+      )).report_ids[0]
+
+      facial_similarity_report = repeat_request_until_status_changes(
+        Onfido::ReportStatus::COMPLETE
+      ) { onfido_api.find_report(facial_similarity_report_id) }
+
+      expect(facial_similarity_report).to be_an_instance_of Onfido::FacialSimilarityPhotoReport
+    end
+  end
+end