checkr-official 1.0.0

data/test/checkr/ssn_trace_test.rb

@@ -0,0 +1,78 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Checkr
+  class SSNTraceTest < Test::Unit::TestCase
+    setup do
+      @ssn_trace_url = "#{Checkr.api_base}/v1/ssn_traces"
+    end
+
+    context 'SSNTrace class' do
+      should 'be retrieveable' do
+        id = "ssn_trace_id"
+        @mock.expects(:get).once.with("#{@ssn_trace_url}/#{id}", anything, anything).returns(test_response(test_ssn_trace))
+        ssn_trace = SSNTrace.retrieve(id)
+        assert(ssn_trace.is_a?(SSNTrace))
+      end
+    end
+
+    context 'SSNTrace instance' do
+      should 'be refreshable' do
+        @mock.expects(:get).once.with("#{@ssn_trace_url}/#{test_ssn_trace[:id]}", anything, anything).returns(test_response(test_ssn_trace))
+        ssn_trace = SSNTrace.new(test_ssn_trace[:id])
+        ssn_trace.refresh
+        assert_equal(test_ssn_trace[:status], ssn_trace.status)
+      end
+    end
+
+
+    context 'Retrieved SSNTrace instance' do
+      setup do
+        @mock.expects(:get).once.returns(test_response(test_ssn_trace))
+        @ssn_trace = SSNTrace.retrieve('ssn_trace_id')
+      end
+
+      should 'have the id attribute' do
+        assert_equal(test_ssn_trace[:id], @ssn_trace.id)
+      end
+
+      should 'have the object attribute' do
+        assert_equal(test_ssn_trace[:object], @ssn_trace.object)
+      end
+
+      should 'have the uri attribute' do
+        assert_equal(test_ssn_trace[:uri], @ssn_trace.uri)
+      end
+
+      should 'have the status attribute' do
+        assert_equal(test_ssn_trace[:status], @ssn_trace.status)
+      end
+
+      should 'have the created_at attribute' do
+        assert_equal(test_ssn_trace[:created_at], @ssn_trace.created_at)
+      end
+
+      should 'have the completed_at attribute' do
+        assert_equal(test_ssn_trace[:completed_at], @ssn_trace.completed_at)
+      end
+
+      should 'have the turnaround_time attribute' do
+        assert_equal(test_ssn_trace[:turnaround_time], @ssn_trace.turnaround_time)
+      end
+
+      should 'have the ssn attribute' do
+        assert_equal(test_ssn_trace[:ssn], @ssn_trace.ssn)
+      end
+
+      should 'have the addresses attribute' do
+        assert_equal(test_ssn_trace[:addresses], @ssn_trace.addresses)
+      end
+
+    end
+
+    should 'be registered' do
+      assert(APIClass.subclasses.include?(SSNTrace))
+      assert_equal(SSNTrace, APIClass.subclass_fetch("ssn_trace"))
+    end
+
+  end
+end

data/test/checkr/status_codes_test.rb

@@ -0,0 +1,63 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Checkr
+  class StatusCodesTest < Test::Unit::TestCase
+
+    context 'InvalidRequestError' do
+      should 'be raised when HTTP status code is 400' do
+        response = test_response(test_missing_id_error, 400)
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+        begin
+          MockResource.retrieve('bad_id')
+        rescue InvalidRequestError => e
+          assert_equal(400, e.http_status)
+          assert(!!e.http_body)
+          assert(e.json_body.is_a?(Hash))
+        end
+      end
+
+      should 'be raised when HTTP status code is 404' do
+        response = test_response(test_missing_id_error, 404)
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 404))
+        assert_raises
+        begin
+          MockResource.retrieve('foo')
+        rescue InvalidRequestError => e
+          rescued = true
+          assert_equal(404, e.http_status)
+          assert_equal(true, !!e.http_body)
+          assert_equal(true, e.json_body.is_a?(Hash))
+        end
+        assert(rescued)
+      end
+    end
+
+    context 'APIError' do
+      should 'be raised when HTTP status code is 5XX' do
+        response = test_response(test_api_error, 500)
+        @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 500))
+
+        begin
+          MockResource.new('fake_id').refresh
+        rescue APIError => e
+          rescued = true
+          assert(e.is_a?(APIError))
+        end
+        assert(rescued)
+      end
+    end
+
+    context 'AuthenticationError' do
+      should 'be raised when HTTP status code is 401 (invalid credentials)' do
+        Checkr.api_key = 'invalid'
+        response = test_response(test_invalid_api_key_error, 401)
+        assert_raises(AuthenticationError) do
+          @mock.expects(:get).once.raises(RestClient::ExceptionWithResponse.new(response, 401))
+          MockResource.retrieve('failing')
+        end
+      end
+    end
+
+  end
+end

data/test/checkr/subscription_test.rb

@@ -0,0 +1,96 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Checkr
+  class SubscriptionTest < Test::Unit::TestCase
+    setup do
+      @subscription_url = "#{Checkr.api_base}/v1/subscriptions"
+    end
+
+    context 'Subscription class' do
+      should 'be retrieveable' do
+        id = "subscription_id"
+        @mock.expects(:get).once.with("#{@subscription_url}/#{id}", anything, anything).returns(test_response(test_subscription))
+        subscription = Subscription.retrieve(id)
+        assert(subscription.is_a?(Subscription))
+      end
+
+      should 'be createable' do
+        @mock.expects(:post).once.with(@subscription_url, anything, test_subscription).returns(test_response(test_subscription))
+        subscription = Subscription.create(test_subscription)
+        assert(subscription.is_a?(Subscription))
+        assert_equal(test_subscription[:id], subscription.id)
+      end
+    end
+
+    context 'Subscription instance' do
+      should 'be refreshable' do
+        @mock.expects(:get).once.with("#{@subscription_url}/#{test_subscription[:id]}", anything, anything).returns(test_response(test_subscription))
+        subscription = Subscription.new(test_subscription[:id])
+        subscription.refresh
+        assert_equal(test_subscription[:package], subscription.package)
+      end
+
+      should 'be cancelable' do
+        @mock.expects(:delete).once.with("#{@subscription_url}/#{test_subscription[:id]}", anything, anything).returns(test_response(test_subscription))
+        subscription = Subscription.new(test_subscription[:id])
+        subscription.cancel
+      end
+    end
+
+
+    context 'Retrieved Subscription instance' do
+      setup do
+        @mock.expects(:get).once.returns(test_response(test_subscription))
+        @subscription = Subscription.retrieve('subscription_id')
+      end
+
+      should 'have the id attribute' do
+        assert_equal(test_subscription[:id], @subscription.id)
+      end
+
+      should 'have the object attribute' do
+        assert_equal(test_subscription[:object], @subscription.object)
+      end
+
+      should 'have the uri attribute' do
+        assert_equal(test_subscription[:uri], @subscription.uri)
+      end
+
+      should 'have the status attribute' do
+        assert_equal(test_subscription[:status], @subscription.status)
+      end
+
+      should 'have the created_at attribute' do
+        assert_equal(test_subscription[:created_at], @subscription.created_at)
+      end
+
+      should 'have the canceled_at attribute' do
+        assert_equal(test_subscription[:canceled_at], @subscription.canceled_at)
+      end
+
+      should 'have the package attribute' do
+        assert_equal(test_subscription[:package], @subscription.package)
+      end
+
+      should 'have the interval_count attribute' do
+        assert_equal(test_subscription[:interval_count], @subscription.interval_count)
+      end
+
+      should 'have the start_date attribute' do
+        assert_equal(test_subscription[:start_date], @subscription.start_date)
+      end
+
+      should 'have the candidate attribute' do
+        assert_equal(test_subscription[:candidate_id], @subscription.candidate.id)
+        assert(@subscription.candidate.is_a?(Candidate))
+      end
+
+    end
+
+    should 'be registered' do
+      assert(APIClass.subclasses.include?(Subscription))
+      assert_equal(Subscription, APIClass.subclass_fetch("subscription"))
+    end
+
+  end
+end

data/test/checkr/terrorist_watchlist_search_test.rb

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

data/test/checkr/util_test.rb

@@ -0,0 +1,50 @@
+require File.expand_path('../../test_helper', __FILE__)
+
+module Checkr
+  class UtilTest < Test::Unit::TestCase
+    should "symbolize_keys should convert keys to symbols" do
+      start = {
+        'foo' => 'bar',
+        'array' => [{ 'foo' => 'bar' }],
+        'nested' => {
+          1 => 2,
+          :symbol => 9,
+          'string' => nil
+        }
+      }
+      finish = {
+        :foo => 'bar',
+        :array => [{ :foo => 'bar' }],
+        :nested => {
+          1 => 2,
+          :symbol => 9,
+          :string => nil
+        }
+      }
+
+      symbolized = Util.symbolize_keys(start)
+      assert_equal(finish, symbolized)
+    end
+
+    should 'query_array should convert { :a => "value" } to []' do
+      start = { :a => "value" }
+      finish = ["a=value"]
+
+      assert_equal(finish, Util.query_array(start))
+    end
+
+    should 'query_array should convert { :a => { :b => { :c => "cvalue" } } } to ["a[b][c]=cvalue"]' do
+      start = { :a => { :b => { :c => "cvalue" } } }
+      finish = ["a[b][c]=cvalue"]
+
+      assert_equal(finish, Util.query_array(start))
+    end
+
+    should 'query_array should convert { :a => [1, 2] } to ["a[]=1", "a[]=2"]' do
+      start = { :a => [1, 2] }
+      finish = ["a[]=1", "a[]=2"]
+
+      assert_equal(finish, Util.query_array(start))
+    end
+  end
+end

data/test/mock_resource.rb

@@ -0,0 +1,88 @@
+# Setup a fake resource for testing the APIResource
+
+class NestedResource < Checkr::APIResource
+  attribute :price
+
+  def self.path
+    "/nested_resources"
+  end
+end
+
+class NestedWithParent < Checkr::APIResource
+  attribute :price
+  attr_accessor :parent
+
+  def self.construct(json, parent=nil)
+    instance = super(json)
+    instance.parent = parent if parent
+    instance.clear_changed_attributes
+    instance
+  end
+
+  def path
+    parent.path + "/nested_path"
+  end
+end
+
+class MockResource < Checkr::APIResource
+  attribute :name
+  attribute :tarray
+  attribute :thash
+  attribute :nested, NestedResource
+  attribute :nested_alt, :NestedResource
+  attribute_writer_alias :nested_alt_id, :nested_alt
+  attribute :nested_with, :NestedWithParent, :nested => true, :default => {}
+
+  api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
+  api_class_method :all, :get, :constructor => Checkr::APIList.constructor(MockResource)
+  api_class_method :create, :post
+  api_class_method :many_args_get, :get, ":path/:b/many", :arguments => [:a, :b, :c]
+  api_class_method :many_args_post, :post, ":path/:b/many", :arguments => [:a, :b, :c]
+  api_class_method :crazy_path, :get, ":crazy"
+
+  api_class_method :with_con_self, :get, :constructor => :self
+  api_class_method :with_con_class, :get, :constructor => MockResource
+  api_class_method :with_con_lambda, :get, :constructor => lambda{ |json| "lamdba result" }
+  api_class_method :with_con_default, :get
+
+  def self.default_lambda
+    lambda do |this|
+      self.default_values
+    end
+  end
+  api_class_method :with_lambda, :post, :default_params => self.default_lambda
+  api_class_method :with_symbol, :post, :default_params => :default_values
+  api_class_method :with_symbol_and_args, :post, :default_params => :default_values, :arguments => [:name]
+
+  api_instance_method :refresh, :get, :constructor => :self
+  api_instance_method :save, :put, :default_params => changed_lambda, :constructor => :self
+  api_instance_method :delete, :delete
+  api_instance_method :custom_path, :get, ":path", :arguments => [:path]
+  api_instance_method :name_path, :get, ":name"
+  api_instance_method :crazy_path, :get, ":crazy"
+
+  api_instance_method :with_con_self, :get, :constructor => :self
+  api_instance_method :with_con_class, :get, :constructor => MockResource
+  api_instance_method :with_con_lambda, :get, :constructor => lambda{ |json| "lamdba result" }
+  api_instance_method :with_con_default, :get
+
+  api_instance_method :with_lambda, :put, :default_params => changed_lambda
+  api_instance_method :with_symbol, :put, :default_params => :changed_attributes
+  api_instance_method :with_symbol_and_args, :put, :default_params => :changed_attributes, :arguments => [:name]
+
+  def self.path
+    "/mocks"
+  end
+
+  def self.crazy
+    "/crazy_path"
+  end
+
+  def self.default_values
+    {
+      :name => "default name",
+      :tarray => [1,2,3]
+    }
+  end
+
+end