checkr-official 1.0.0

data/test/checkr/api_list_test.rb

@@ -0,0 +1,27 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Checkr
+  class ApiListTest < Test::Unit::TestCase
+
+    should 'have an object attribute' do
+      assert(APIList.method_defined?(:object))
+      assert(APIList.method_defined?(:object=))
+    end
+
+    should 'have an data attribute' do
+      assert(APIList.method_defined?(:data))
+      assert(APIList.method_defined?(:data=))
+    end
+
+    should 'be refreshable' do
+      lambda = APIList.constructor(:MockResource)
+      list = lambda.call({})
+      list.construct(test_mock_resource_list)
+      assert(list.length > 0)
+      list.each do |mr|
+        assert(mr.is_a?(MockResource))
+      end
+    end
+
+  end
+end

data/test/checkr/api_resource_test.rb

@@ -0,0 +1,28 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Checkr
+  class ApiResourceTest < Test::Unit::TestCase
+
+    should 'have an id attribute' do
+      assert(APIResource.method_defined?(:id))
+      assert(APIResource.method_defined?(:id=))
+    end
+
+    should 'have an object attribute' do
+      assert(APIResource.method_defined?(:object))
+      assert(APIResource.method_defined?(:object=))
+    end
+
+    should 'have a default path' do
+      mr = MockResource.new('fake_id')
+      assert_equal("#{MockResource.path}/fake_id", mr.path)
+    end
+
+    should 'raise an InvalidRequestError when no ID is present for instance path' do
+      @mock.expects(:get).never
+      c = MockResource.new
+      assert_raises(InvalidRequestError) { c.refresh }
+    end
+
+  end
+end

data/test/checkr/api_singleton_test.rb

@@ -0,0 +1,12 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Checkr
+  class ApiSingletonTest < Test::Unit::TestCase
+
+    should 'have an object attribute' do
+      assert(APISingleton.method_defined?(:object))
+      assert(APISingleton.method_defined?(:object=))
+    end
+
+  end
+end

data/test/checkr/authentication_test.rb

@@ -0,0 +1,50 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Checkr
+  class StatusCodesTest < Test::Unit::TestCase
+
+    context 'AuthenticationError' do
+      should 'be raised with no API credentials' do
+        Checkr.api_key = nil
+        assert_raises(AuthenticationError) do
+          MockResource.retrieve('fake_id')
+        end
+      end
+
+      should 'be raised with invalid credentials' do
+        Checkr.api_key = 'invalid api key' # spaces aren't valid
+        assert_raises(AuthenticationError) do
+          MockResource.new('fake_id').refresh
+        end
+      end
+
+      context 'that has been raised' do
+        setup do
+          Checkr.api_key = 'invalid'
+          response = test_response(test_invalid_api_key_error, 401)
+          begin
+            @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+            MockResource.retrieve('failing')
+          rescue AuthenticationError => e
+            @error = e
+          end
+        end
+
+        should 'have an http status of 401' do
+          assert_equal(401, @error.http_status)
+        end
+
+        should 'have an http body' do
+          assert(!!@error.http_body)
+        end
+
+        should 'have a JSON body with an error message' do
+          assert(!!@error.json_body[:error][:message])
+          assert_equal(test_invalid_api_key_error[:error][:message], @error.json_body[:error][:message])
+        end
+      end
+    end
+
+  end
+end

data/test/checkr/candidate_test.rb

@@ -0,0 +1,164 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Checkr
+  class CandidateTest < Test::Unit::TestCase
+    setup do
+      @candidate_url = "#{Checkr.api_base}/v1/candidates"
+    end
+
+    context 'Candidate class' do
+      should 'be retrieveable' do
+        id = "candidate_id"
+        @mock.expects(:get).once.with("#{@candidate_url}/#{id}", anything, anything).returns(test_response(test_candidate))
+        candidate = Candidate.retrieve(id)
+        assert(candidate.is_a?(Candidate))
+      end
+
+      should 'be createable' do
+        @mock.expects(:post).once.with(@candidate_url, anything, test_candidate).returns(test_response(test_candidate))
+        candidate = Candidate.create(test_candidate)
+        assert(candidate.is_a?(Candidate))
+        assert_equal(test_candidate[:id], candidate.id)
+      end
+
+      should 'be listable' do
+        @mock.expects(:get).once.returns(test_response(test_candidate_list))
+
+        candidates = Candidate.all
+
+        assert(candidates.is_a?(APIList))
+        candidates.each do |candidate|
+          assert(candidate.is_a?(Candidate))
+        end
+      end
+    end
+
+    context 'Candidate instance' do
+      should 'be refreshable' do
+        @mock.expects(:get).once.with("#{@candidate_url}/#{test_candidate[:id]}", anything, anything).returns(test_response(test_candidate))
+        candidate = Candidate.new(test_candidate[:id])
+        candidate.refresh
+        assert_equal(test_candidate[:email], candidate.email)
+      end
+
+      should 'include an empty documents list' do
+        # TODO(joncalhoun): Implement this when test docs are available.
+
+        # candidate = Candidate.new(test_candidate)
+        # @mock.expects(:get).once.with("#{Checkr.api_base}#{Transaction.path}?candidate=#{candidate.id}", anything, anything).returns(test_response(test_transaction_list))
+
+        # transactions = candidate.transactions
+        # assert(transactions.is_a?(APIList))
+        # transactions.each do |transaction|
+        #   assert(transaction.is_a?(Transaction))
+        # end
+      end
+
+      should 'include a filled documents list' do
+
+      end
+    end
+
+
+    context 'Retrieved Candidate instance' do
+      setup do
+        @mock.expects(:get).once.returns(test_response(test_candidate))
+        @candidate = Candidate.retrieve('candidate_id')
+      end
+
+      should 'have the id attribute' do
+        assert_equal(test_candidate[:id], @candidate.id)
+      end
+
+      should 'have the object attribute' do
+        assert_equal(test_candidate[:object], @candidate.object)
+      end
+
+      should 'have the uri attribute' do
+        assert_equal(test_candidate[:uri], @candidate.uri)
+      end
+
+      should 'have the created_at attribute' do
+        assert_equal(test_candidate[:created_at], @candidate.created_at)
+      end
+
+      should 'have the middle_name attribute' do
+        assert_equal(test_candidate[:middle_name], @candidate.middle_name)
+      end
+
+      should 'have the last_name attribute' do
+        assert_equal(test_candidate[:last_name], @candidate.last_name)
+      end
+
+      should 'have the email attribute' do
+        assert_equal(test_candidate[:email], @candidate.email)
+      end
+
+      should 'have the phone attribute' do
+        assert_equal(test_candidate[:phone], @candidate.phone)
+      end
+
+      should 'have the zipcode attribute' do
+        assert_equal(test_candidate[:zipcode], @candidate.zipcode)
+      end
+
+      should 'have the dob attribute' do
+        assert_equal(test_candidate[:dob], @candidate.dob)
+      end
+
+      should 'have the ssn attribute' do
+        assert_equal(test_candidate[:ssn], @candidate.ssn)
+      end
+
+      should 'have the driver_license_number attribute' do
+        assert_equal(test_candidate[:driver_license_number], @candidate.driver_license_number)
+      end
+
+      should 'have the driver_license_state attribute' do
+        assert_equal(test_candidate[:driver_license_state], @candidate.driver_license_state)
+      end
+
+      should 'have the previous_driver_license_number attribute' do
+        assert_equal(test_candidate[:previous_driver_license_number], @candidate.previous_driver_license_number)
+      end
+
+      should 'have the previous_driver_license_state attribute' do
+        assert_equal(test_candidate[:previous_driver_license_state], @candidate.previous_driver_license_state)
+      end
+
+      should 'have the copy_requested attribute' do
+        assert_equal(test_candidate[:copy_requested], @candidate.copy_requested)
+      end
+
+      should 'have the adjudication attribute' do
+        assert_equal(test_candidate[:adjudication], @candidate.adjudication)
+      end
+
+      should 'have the custom_id attribute' do
+        assert_equal(test_candidate[:custom_id], @candidate.custom_id)
+      end
+
+      should 'have the reports attribute' do
+        assert_equal(test_candidate[:report_ids], @candidate.reports.json)
+        assert(@candidate.reports.is_a?(APIList))
+      end
+
+      should 'have the geos attribute' do
+        assert_equal(test_candidate[:geo_ids], @candidate.geos.json)
+        assert(@candidate.geos.is_a?(APIList))
+      end
+
+      should 'have the documents attribute' do
+        assert(!@candidate.documents.any?)
+        assert(@candidate.documents.is_a?(DocumentList))
+      end
+
+    end
+
+    should 'be registered' do
+      assert(APIClass.subclasses.include?(Candidate))
+      assert_equal(Candidate, APIClass.subclass_fetch("candidate"))
+    end
+
+  end
+end

data/test/checkr/county_criminal_search_test.rb

@@ -0,0 +1,82 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Checkr
+  class CountyCriminalSearchTest < Test::Unit::TestCase
+    setup do
+      @county_criminal_search_url = "#{Checkr.api_base}/v1/county_criminal_searches"
+    end
+
+    context 'CountyCriminalSearch class' do
+      should 'be retrieveable' do
+        id = "county_criminal_search_id"
+        @mock.expects(:get).once.with("#{@county_criminal_search_url}/#{id}", anything, anything).returns(test_response(test_county_criminal_search))
+        county_criminal_search = CountyCriminalSearch.retrieve(id)
+        assert(county_criminal_search.is_a?(CountyCriminalSearch))
+      end
+    end
+
+    context 'CountyCriminalSearch instance' do
+      should 'be refreshable' do
+        @mock.expects(:get).once.with("#{@county_criminal_search_url}/#{test_county_criminal_search[:id]}", anything, anything).returns(test_response(test_county_criminal_search))
+        county_criminal_search = CountyCriminalSearch.new(test_county_criminal_search[:id])
+        county_criminal_search.refresh
+        assert_equal(test_county_criminal_search[:status], county_criminal_search.status)
+      end
+    end
+
+
+    context 'Retrieved CountyCriminalSearch instance' do
+      setup do
+        @mock.expects(:get).once.returns(test_response(test_county_criminal_search))
+        @county_criminal_search = CountyCriminalSearch.retrieve('county_criminal_search_id')
+      end
+
+      should 'have the id attribute' do
+        assert_equal(test_county_criminal_search[:id], @county_criminal_search.id)
+      end
+
+      should 'have the object attribute' do
+        assert_equal(test_county_criminal_search[:object], @county_criminal_search.object)
+      end
+
+      should 'have the uri attribute' do
+        assert_equal(test_county_criminal_search[:uri], @county_criminal_search.uri)
+      end
+
+      should 'have the status attribute' do
+        assert_equal(test_county_criminal_search[:status], @county_criminal_search.status)
+      end
+
+      should 'have the created_at attribute' do
+        assert_equal(test_county_criminal_search[:created_at], @county_criminal_search.created_at)
+      end
+
+      should 'have the completed_at attribute' do
+        assert_equal(test_county_criminal_search[:completed_at], @county_criminal_search.completed_at)
+      end
+
+      should 'have the turnaround_time attribute' do
+        assert_equal(test_county_criminal_search[:turnaround_time], @county_criminal_search.turnaround_time)
+      end
+
+      should 'have the county attribute' do
+        assert_equal(test_county_criminal_search[:county], @county_criminal_search.county)
+      end
+
+      should 'have the state attribute' do
+        assert_equal(test_county_criminal_search[:state], @county_criminal_search.state)
+      end
+
+      should 'have the records attribute' do
+        assert_equal(test_county_criminal_search[:records], @county_criminal_search.records)
+      end
+
+    end
+
+    should 'be registered' do
+      assert(APIClass.subclasses.include?(CountyCriminalSearch))
+      assert_equal(CountyCriminalSearch, APIClass.subclass_fetch("county_criminal_search"))
+    end
+
+  end
+end

data/test/checkr/document_test.rb

@@ -0,0 +1,90 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Checkr
+  class DocumentTest < Test::Unit::TestCase
+    setup do
+      @candidate = Candidate.construct(test_candidate)
+      @document_url = "#{Checkr.api_base}#{@candidate.path}/documents"
+    end
+
+    context 'Document class' do
+      should 'be createable' do
+        new_doc = {
+          :type => "driver_license",
+          :file => "fake_file"
+        }
+        @mock.expects(:post).once.with(@document_url, anything, new_doc).returns(test_response(test_document))
+        document = @candidate.documents.create(new_doc)
+        assert(document.is_a?(Document))
+        assert_equal(test_document[:id], document.id)
+      end
+
+      should 'be listable' do
+        @mock.expects(:get).once.with(@document_url, anything, anything).returns(test_response(test_document_list))
+
+        documents = @candidate.documents.all
+
+        assert(documents.is_a?(DocumentList))
+        documents.each do |document|
+          assert(document.is_a?(Document))
+        end
+        assert(documents.length > 0)
+      end
+    end
+
+    context 'Document instance' do
+      # should 'be refreshable' do
+      #   @mock.expects(:get).once.with("#{@document_url}/#{test_document[:id]}", anything, anything).returns(test_response(test_document))
+      #   document = Document.new(test_document[:id])
+      #   document.refresh
+      #   assert_equal(test_document[:filename], document.filename)
+      # end
+    end
+
+
+    context 'Constructed Document instance' do
+      setup do
+        @document = Document.construct(test_document)
+      end
+
+      should 'have the id attribute' do
+        assert_equal(test_document[:id], @document.id)
+      end
+
+      should 'have the object attribute' do
+        assert_equal(test_document[:object], @document.object)
+      end
+
+      should 'have the uri attribute' do
+        assert_equal(test_document[:uri], @document.uri)
+      end
+
+      should 'have the created_at attribute' do
+        assert_equal(test_document[:created_at], @document.created_at)
+      end
+
+      should 'have the download_uri attribute' do
+        assert_equal(test_document[:download_uri], @document.download_uri)
+      end
+
+      should 'have the filesize attribute' do
+        assert_equal(test_document[:filesize], @document.filesize)
+      end
+
+      should 'have the filename attribute' do
+        assert_equal(test_document[:filename], @document.filename)
+      end
+
+      should 'have the content_type attribute' do
+        assert_equal(test_document[:content_type], @document.content_type)
+      end
+
+    end
+
+    should 'be registered' do
+      assert(APIClass.subclasses.include?(Document))
+      assert_equal(Document, APIClass.subclass_fetch("document"))
+    end
+
+  end
+end