checkr-official 1.0.0

data/lib/checkr/terrorist_watchlist_search.rb

@@ -0,0 +1,17 @@
+module Checkr
+  class TerroristWatchlistSearch < APIResource
+
+    attribute :status
+    attribute :completed_at
+    attribute :turnaround_time
+    attribute :records
+
+    api_class_method :retrieve, :get, ":path/:id", :arguments => [:id]
+
+    def self.path
+      "/v1/terrorist_watchlist_searches"
+    end
+
+    APIClass.register_subclass(self, "terrorist_watchlist_search")
+  end
+end

data/lib/checkr/util.rb

@@ -0,0 +1,91 @@
+module Checkr
+  module Util
+
+    def self.query_string(params)
+      if params && params.any?
+        return query_array(params).join('&')
+      else
+        return ""
+      end
+    end
+
+    # Three major use cases (and nesting of them needs to be supported):
+    #   { :a => { :b => "bvalue" } }  => ["a[b]=bvalue"]
+    #   { :a => [1, 2] }           => ["a[]=1", "a[]=2"]
+    #   { :a => "value" }          => ["a=value"]
+    def self.query_array(params, key_prefix=nil)
+      ret = []
+      params.each do |key, value|
+        if params.is_a?(Array)
+          value = key
+          key = ''
+        end
+        key_suffix = escape(key)
+        full_key = key_prefix ? "#{key_prefix}[#{key_suffix}]" : key_suffix
+
+        if value.is_a?(Hash) || value.is_a?(Array)
+          # Handles the following cases:
+          #   { :a => { :b => "bvalue" } }  => ["a[b]=bvalue"]
+          #   { :a => [1, 2] }           => ["a[]=1", "a[]=2"]
+          ret += query_array(value, full_key)
+        else
+          # Handles the base case with just key and value:
+          #   { :a => "value" } => ["a=value"]
+          ret << "#{full_key}=#{escape(value)}"
+        end
+      end
+      ret
+    end
+
+    def self.escape(val)
+      URI.escape(val.to_s, Regexp.new("[^#{URI::PATTERN::UNRESERVED}]"))
+    end
+
+    def self.symbolize_keys(obj)
+      if obj.is_a?(Hash)
+        ret = {}
+        obj.each do |key, value|
+          ret[(key.to_sym rescue key) || key] = symbolize_keys(value)
+        end
+        return ret
+      elsif obj.is_a?(Array)
+        return obj.map{ |value| symbolize_keys(value) }
+      else
+        return obj
+      end
+    end
+
+    def self.sorta_deep_clone(json)
+      if json.is_a?(Hash)
+        ret = {}
+        json.each do |k, v|
+          ret[k] = sorta_deep_clone(v)
+        end
+        ret
+      elsif json.is_a?(Array)
+        json.map{ |j| sorta_deep_clone(j) }
+      else
+        begin
+          json.dup
+        rescue
+          json
+        end
+      end
+    end
+
+    def self.constantize(str, prefix=false)
+      str = str.to_s
+      begin
+        str.split('::').reduce(Module, :const_get)
+      rescue NameError => e
+        if prefix
+          raise e
+        else
+          p = "#{self.name}".split("::").first
+          constantize("#{p}::#{str}", true)
+        end
+      end
+    end
+
+  end
+end

data/lib/checkr/version.rb

@@ -0,0 +1,3 @@
+module Checkr
+  VERSION = File.open(File.expand_path("../../../VERSION", __FILE__)).read()
+end

data/tasks/api_test.rb

@@ -0,0 +1,192 @@
+require 'checkr'
+
+class APITest
+  def initialize(api_key)
+    Checkr.api_key = api_key
+  end
+
+  def run
+    geos = run_geos_test
+    candidate = run_candidate_tests(geos)
+    document = run_document_tests(candidate)
+    consider, clear = run_report_tests(candidate)
+    run_ssn_trace_tests(consider, clear)
+    run_sex_offender_search_tests(consider, clear)
+    # TODO: Uncomment this when there isn't a forbidden bug with shared resources in test.
+    # run_terrorist_watchlist_search_tests(consider, clear)
+    run_national_criminal_search_tests(consider, clear)
+    run_county_criminal_search_tests(consider, clear)
+    run_motor_vehicle_report_tests(consider, clear)
+  end
+
+  def run_geos_test
+    puts "Looking up geos..."
+    geos = Checkr::Geo.all
+    puts "Found #{geos.length} geos."
+
+    scranton = geos.select{ |g| g.name == "Scranton" }.first
+
+    unless scranton
+      scranton = Checkr::Geo.create({
+        :name => "Scranton",
+        :state => "PA"
+      })
+    end
+
+    puts "Deleting the geo for Scranton"
+    scranton.delete
+
+    puts "Create the Scranton geo..."
+    scranton = Checkr::Geo.create({
+      :name => "Scranton",
+      :state => "PA"
+    })
+    puts "Created: #{scranton.inspect}"
+
+    puts "Looking up a created geo."
+    geo = Checkr::Geo.retrieve(scranton.id)
+    puts "Found: #{geo.inspect}"
+
+    Checkr::Geo.all.select{ |g| g.state == "CA" }
+  end
+
+  def run_candidate_tests(geos)
+    puts "Creating a candidate..."
+    candidate = Checkr::Candidate.create({
+      :first_name => "John",
+      :middle_name => "Alfred",
+      :last_name => "Smith",
+      :email => "John.Smith@gmail.com",
+      :phone => "5555555555",
+      :zipcode => "90401",
+      :dob => "1970-01-22",
+      :ssn => "543-43-4645",
+      :driver_license_number => "F211165",
+      :driver_license_state => "CA",
+      :geo_ids => geos.map(&:id)
+    })
+    puts "Created: #{candidate.inspect}"
+
+    puts "Looking up all candidates..."
+    candidates = Checkr::Candidate.all
+    puts "Found #{candidates.length} candidates."
+
+    puts "Retrieving the created candidate..."
+    candidate = Checkr::Candidate.retrieve(candidate.id)
+    puts "Retrieved the candidate with id=#{candidate.id}"
+
+    candidate
+  end
+
+  def run_document_tests(candidate)
+    puts "Creating a document..."
+    document = candidate.documents.create({
+      :type => "driver_license",
+      :file => File.open("#{File.dirname(__FILE__)}/../mclovin.jpg")
+    })
+    puts "Created: #{document.inspect}"
+
+    puts "Looking up all documents..."
+    documents = candidate.documents.all
+    puts "Found #{documents.length} documents."
+
+    document
+  end
+
+  def run_report_tests(candidate)
+    puts "Creating a report for Candidate##{candidate.id}..."
+    report = candidate.reports.create("tasker_plus")
+    puts "Created #{report.inspect}"
+
+    puts "Retrieving the created report..."
+    report = Checkr::Report.retrieve(report.id)
+    puts "Retrieved the report with id=#{report.id}"
+
+    puts "Updating the report..."
+    report.package = "driver_plus"
+    report.save
+    puts "New package is #{report.package}"
+
+    puts "Retrieving a consider report..."
+    consider = Checkr::Report.retrieve("59b650f567e1dd0f01422b92")
+    puts "Retrieving a clear report..."
+    clear = Checkr::Report.retrieve("31e894fc23e30953c26a2d26")
+
+    [consider, clear]
+  end
+
+  def run_ssn_trace_tests(consider, clear)
+    puts "Retrieving SSN Trace using the consider report."
+    consider.ssn_trace.refresh
+    puts "Retrieved the SSN Trace: #{consider.ssn_trace.inspect}"
+
+    puts "Retrieving SSN Trace using the clear report."
+    ssn_trace = Checkr::SSNTrace.retrieve(clear.ssn_trace.id)
+    puts "Retrieved the SSN Trace: #{ssn_trace.inspect}"
+
+    ssn_trace
+  end
+
+  def run_sex_offender_search_tests(consider, clear)
+    puts "Retrieving Sex Offender Search using the consider report."
+    consider.sex_offender_search.refresh
+    puts "Retrieved the Sex Offender Search: #{consider.sex_offender_search.inspect}"
+
+    puts "Retrieving Sex Offender Search using the clear report."
+    sex_offender_search = Checkr::SexOffenderSearch.retrieve(clear.sex_offender_search.id)
+    puts "Retrieved the Sex Offender Search: #{sex_offender_search.inspect}"
+
+    sex_offender_search
+  end
+
+  def run_terrorist_watchlist_search_tests(consider, clear)
+    puts "Retrieving using consider..."
+    consider.terrorist_watchlist_search.refresh
+    puts "Retrieved the terrorist_watchlist_search: #{consider.terrorist_watchlist_search.inspect}"
+
+    puts "Retrieving using clear report..."
+    terrorist_watchlist_search = Checkr::TerroristWatchlistSearch.retrieve(clear.terrorist_watchlist_search.id)
+    puts "Retrieved the terrorist_watchlist_search: #{terrorist_watchlist_search.inspect}"
+
+    terrorist_watchlist_search
+  end
+
+  def run_national_criminal_search_tests(consider, clear)
+    puts "Retrieving using consider..."
+    consider.national_criminal_search.refresh
+    puts "Retrieved the national_criminal_search: #{consider.national_criminal_search.inspect}"
+
+    puts "Retrieving using clear report..."
+    national_criminal_search = Checkr::NationalCriminalSearch.retrieve(clear.national_criminal_search.id)
+    puts "Retrieved the national_criminal_search: #{national_criminal_search.inspect}"
+
+    national_criminal_search
+  end
+
+  def run_county_criminal_search_tests(consider, clear)
+    puts "Retrieving using consider..."
+    consider.county_criminal_searches.first.refresh
+    puts "Retrieved the county_criminal_search: #{consider.county_criminal_searches.first.inspect}"
+
+    puts "Retrieving using clear report..."
+    county_criminal_search = Checkr::CountyCriminalSearch.retrieve(clear.county_criminal_searches.first.id)
+    puts "Retrieved the county_criminal_search: #{county_criminal_search.inspect}"
+
+    county_criminal_search
+  end
+
+  def run_motor_vehicle_report_tests(consider, clear)
+    puts "Retrieving using consider..."
+    consider.motor_vehicle_report.refresh
+    puts "Retrieved the motor_vehicle_report: #{consider.motor_vehicle_report.inspect}"
+
+    puts "Retrieving using clear report..."
+    motor_vehicle_report = Checkr::MotorVehicleReport.retrieve(clear.motor_vehicle_report.id)
+    puts "Retrieved the motor_vehicle_report: #{motor_vehicle_report.inspect}"
+
+    motor_vehicle_report
+  end
+
+
+
+end

data/test/checkr/api_class_test.rb

@@ -0,0 +1,426 @@
+# -*- coding: utf-8 -*-
+require File.expand_path('../../test_helper', __FILE__)
+
+module Checkr
+  class ApiClassTest < Test::Unit::TestCase
+
+    context 'Non-network actions' do
+      setup do
+        @mock.expects(:get).never
+        @mock.expects(:post).never
+        @mock.expects(:put).never
+        @mock.expects(:delete).never
+      end
+
+      should 'not fetch over the network when creating a new APIClass' do
+        MockResource.new('fake_id')
+      end
+
+      should 'not fetch over the network when creating a new APIClass from a hash' do
+        MockResource.construct(test_mock_resource)
+      end
+
+      should 'not fetch over the network when setting an attribute' do
+        c = MockResource.new('fake_id')
+        c.name = 'Another Name'
+      end
+
+      should 'not fetch over the network when accessing an attribute' do
+        c = MockResource.new('fake_id')
+        c.id
+      end
+    end
+
+    # These GET, POST, etc should really be in a dif test, but this is easier.
+    context 'Making a GET request' do
+      should 'urlencode values in params and have no payload' do
+        response = test_response(test_mock_resource_list)
+
+        # The test is to basically make sure this expectation passes.
+        @mock.expects(:get).with do |url, headers, params|
+          (url == "#{Checkr.api_base}#{MockResource.path}?page=1&filter=test%20filter" ||
+            url == "#{Checkr.api_base}#{MockResource.path}?filter=test%20filter&page=1") &&
+          params == nil
+        end.returns(response)
+
+        list = MockResource.all({
+          :page => 1,
+          :filter => 'test filter',
+        })
+      end
+    end
+
+    context 'Making a DELETE request' do
+      should 'urlencode values in params and have no payload' do
+        @mock.expects(:get).once.returns(test_response(test_mock_resource))
+        mock_resource = MockResource.retrieve("fake_id")
+
+        @mock.expects(:delete).once.with do |url, headers, payload|
+          url == "#{Checkr.api_base}#{mock_resource.path}?reason=delinquent%20payments" && payload.nil?
+        end.returns(test_response({}))
+        mock_resource.delete(:reason => "delinquent payments")
+      end
+    end
+
+    context 'Making a PUT request' do
+      should 'have a payload with no query string' do
+        @mock.expects(:get).once.returns(test_response(test_mock_resource))
+        mock_resource = MockResource.retrieve("fake_id")
+        mock_resource.name = "new name"
+
+        @mock.expects(:put).once.with do |url, header, payload|
+          payload == { :name => "new name" }
+        end.returns(test_response(test_mock_resource))
+        mock_resource.save
+      end
+    end
+
+    context 'Making a POST request' do
+      should 'have a payload with no query string' do
+        params = { :name => "some name" }
+        @mock.expects(:post).once.with("#{Checkr.api_base}#{MockResource.path}", anything, params).returns(test_response(test_mock_resource))
+
+        MockResource.create(params)
+      end
+    end
+
+    context 'APIClass :default_params' do
+      context 'api_instance_method' do
+        setup do
+          @response = test_response(test_mock_resource_list)
+          @mr = MockResource.new(test_mock_resource)
+        end
+
+        should 'call any provided lambdas and set the result as params' do
+          @mock.expects(:put).once.with(anything, anything, { :name => "new name" }).returns(@response)
+
+          @mr.name = "new name"
+          @mr.with_lambda
+        end
+
+        should 'call any method defined by a symbol and set the results as params' do
+          @mock.expects(:put).once.with(anything, anything, { :name => "new name" }).returns(@response)
+
+          @mr.name = "new name"
+          @mr.with_symbol
+        end
+
+        context 'order priority' do
+          # Intended order of priority:
+          # 1. Params. eg in mock_resource.save(params, opts), params should take
+          #    priority with duplicate keys.
+          # 2. Arguments. These should take priority over default values from :params
+          #    method.
+          # 3. Results from method defined by :default_params. This can be a symbol that is
+          #    the name of a method to call, or a lambda (though a hash is preferred).
+          should 'prioritize params argument over args and default_params method' do
+            params = {
+              :name => "not arg name",
+              :tarray => ["not method tarray"],
+              :thash => { :val => "custom hash" }
+            }
+            @mock.expects(:put).once.with(anything, anything, params).returns(@response)
+
+            @mr.tarray = ["method array"]
+            @mr.with_symbol_and_args("arg name", params)
+          end
+
+          should 'prioritize arguments over :default_params' do
+            @mock.expects(:put).once.with(anything, anything, { :name => "arg name" }).returns(@response)
+
+            @mr.name = "changed name"
+            @mr.with_symbol_and_args("arg name")
+          end
+
+          should 'use :default_params method as even when args and params are present' do
+            @mock.expects(:put).once.with(anything, anything, {
+              :thash => { :val => "params hash" },
+              :name => "arg name",
+              :tarray => ["change array"],
+            }).returns(@response)
+
+            @mr.tarray = ["change array"]
+            @mr.with_symbol_and_args("arg name", { :thash => { :val => "params hash" } })
+          end
+        end
+      end
+
+      context 'api_class_method' do
+        setup do
+          @response = test_response(test_mock_resource_list)
+        end
+
+        should 'call any provided lambdas and set the result as params' do
+          @mock.expects(:post).once.with(anything, anything, MockResource.default_values).returns(@response)
+          MockResource.with_lambda
+        end
+
+        should 'call any method defined by a symbol and set the results as params' do
+          @mock.expects(:post).once.with(anything, anything, MockResource.default_values).returns(@response)
+          MockResource.with_symbol
+        end
+
+        context 'order priority' do
+          # Intended order of priority:
+          # 1. Params. eg in mock_resource.save(params, opts), params should take
+          #    priority with duplicate keys.
+          # 2. Arguments. These should take priority over default values from :params
+          #    method.
+          # 3. Results from method defined by :default_params. This can be a symbol that is
+          #    the name of a method to call, or a lambda (though a hash is preferred).
+          should 'prioritize params argument over args and default_params method' do
+            params = {
+              :name => "not arg name",
+              :tarray => ["not method tarray"],
+              :thash => { :val => "custom hash" }
+            }
+            @mock.expects(:post).once.with(anything, anything, params).returns(@response)
+            MockResource.with_symbol_and_args("name arg", params)
+          end
+
+          should 'prioritize arguments over :default_params' do
+            params = Util.sorta_deep_clone(MockResource.default_values)
+            params[:name] = "name arg"
+            @mock.expects(:post).once.with(anything, anything, params).returns(@response)
+            MockResource.with_symbol_and_args("name arg", params)
+          end
+
+          should 'use :default_params method as even when args and params are present' do
+            params = {
+              :name => "name arg",
+              :tarray => MockResource.default_values[:tarray].dup,
+              :thash => { :val => "custom hash" }
+            }
+            @mock.expects(:post).once.with(anything, anything, params).returns(@response)
+            MockResource.with_symbol_and_args("name arg", { :thash => { :val => "custom hash" }})
+          end
+        end
+      end
+    end
+
+
+    context 'APIClass#attribute' do
+      should 'create a getter method' do
+        assert(MockResource.method_defined?(:name))
+      end
+
+      should 'create a setter method' do
+        assert(MockResource.method_defined?(:name=))
+      end
+
+      should 'have no changed attributes after init' do
+        mr = MockResource.new(test_mock_resource)
+        assert(mr.changed_attributes.empty?)
+      end
+
+      should 'keep track of changed attributes' do
+        mr = MockResource.new(test_mock_resource)
+        assert(mr.changed_attributes.empty?)
+        mr.name = "new name"
+        assert_equal({:name => "new name"}, mr.changed_attributes)
+      end
+
+      should 'keep track of changed arrays' do
+        mr = MockResource.new(test_mock_resource)
+        assert(mr.changed_attributes.empty?)
+        mr.tarray << "new"
+        assert_equal({:tarray => test_mock_resource[:tarray] + ["new"]}, mr.changed_attributes)
+      end
+
+      should 'keep track of changed hashes' do
+        mr = MockResource.new(test_mock_resource)
+        assert(mr.changed_attributes.empty?)
+        mr.thash[:some_key] = "new value"
+        assert_equal({:thash => { :some_key => "new value" }}, mr.changed_attributes)
+      end
+
+      context 'constructors' do
+        should 'instantiate on #new' do
+          mr = MockResource.new(test_mock_resource)
+          assert(mr.nested.is_a?(NestedResource))
+          assert(mr.nested_alt.is_a?(NestedResource))
+          assert(mr.nested_with.is_a?(NestedWithParent))
+          assert_equal(mr.path + "/nested_path", mr.nested_with.path)
+        end
+
+        should 'instantiate on #construct' do
+          mr = MockResource.construct(test_mock_resource)
+          assert(mr.nested.is_a?(NestedResource))
+          assert(mr.nested_alt.is_a?(NestedResource))
+          assert(mr.nested_with.is_a?(NestedWithParent))
+          assert_equal(mr.path + "/nested_path", mr.nested_with.path)
+        end
+
+        should 'instantiate on #refresh_from' do
+          mr = MockResource.new('fake_id')
+          assert(mr.nested.nil?)
+          mr.refresh_from(test_mock_resource)
+          assert(mr.nested.is_a?(NestedResource))
+          assert(mr.nested_alt.is_a?(NestedResource))
+          assert(mr.nested_with.is_a?(NestedWithParent))
+          assert_equal(mr.path + "/nested_path", mr.nested_with.path)
+        end
+
+        should 'with default values' do
+          mr = MockResource.new('fake_id')
+          assert(mr.nested_with.is_a?(NestedWithParent))
+          assert_equal(mr.path + "/nested_path", mr.nested_with.path)
+        end
+      end
+    end
+
+    context 'APIClass :constructor' do
+      context 'for api_class_method' do
+        setup do
+          @mock.expects(:get).once.returns(test_response(test_mock_resource))
+        end
+
+        should 'create a new MockResource with :constructor => :self' do
+          mr = MockResource.with_con_self
+          assert(mr.is_a?(MockResource))
+        end
+
+        should 'create a new MockResource with :constructor => MockResource' do
+          mr = MockResource.with_con_class
+          assert(mr.is_a?(MockResource))
+        end
+
+        should 'use the lambda with :constructor => lambda{...}' do
+          mr = MockResource.with_con_lambda
+          assert_equal("lamdba result", mr)
+        end
+
+        should 'create a new MockResource with no constructor defined' do
+          mr = MockResource.with_con_default
+          assert(mr.is_a?(MockResource))
+        end
+      end
+
+      context 'for api_instance_method' do
+        setup do
+          @mock.expects(:get).once.returns(test_response(test_mock_resource))
+          @mr = MockResource.new('fake_id')
+        end
+
+        should 'update this instance with :constructor => :self' do
+          @mr.with_con_self
+          assert(@mr.is_a?(MockResource))
+          assert_equal(test_mock_resource[:id], @mr.id)
+        end
+
+        should 'create a new instance with :constructor => MockResource' do
+          res = @mr.with_con_class
+          assert(res.is_a?(MockResource))
+          assert_not_equal(@mr.id, res.id)
+        end
+
+        should 'use the lambda with :constructor => lambda{...}' do
+          res = @mr.with_con_lambda
+          assert_equal("lamdba result", res)
+        end
+
+        should 'update this instance with no constructor defined' do
+          @mr.with_con_default
+          assert(@mr.is_a?(MockResource))
+          assert_equal(test_mock_resource[:id], @mr.id)
+        end
+      end
+    end
+
+    context 'APIClass api_*_method arguments' do
+      should 'throw an ArgumentError if too few arguments are provided' do
+        assert_raises(ArgumentError) { MockResource.retrieve }
+      end
+
+      should 'throw an ArgumentError with the name of missing arguments' do
+        begin
+          MockResource.retrieve
+          assert(false, "ArgumentError was expected.")
+        rescue ArgumentError => e
+          assert(e.message =~ /id/)
+        end
+      end
+
+      should 'throw an ArgumentError if too many arguments are provided' do
+        assert_raises(ArgumentError) { MockResource.retrieve(1, 2, {}, {}) }
+      end
+
+      should 'throw an ArgumentError if the param argument is invalid' do
+        assert_raises(ArgumentError) { MockResource.retrieve(1, 2) }
+      end
+
+      should 'throw an ArgumentError if the opts argument is invalid' do
+        assert_raises(ArgumentError) { MockResource.retrieve(1, {}, "abc") }
+      end
+
+      should 'not throw an ArgumentError if the opts or params are nil' do
+        @mock.expects(:get).times(2).returns(test_response(test_mock_resource))
+        MockResource.retrieve(1, nil, {})
+        MockResource.retrieve(1, {}, nil)
+      end
+
+      should 'urlencode unused arguments via GET' do
+        response = test_response(test_mock_resource)
+        @mock.expects(:get).with do |url, headers, params|
+          (url == "#{Checkr.api_base}#{MockResource.path}/bval/many?a=aval&c=cval" ||
+            url == "#{Checkr.api_base}#{MockResource.path}/bval/many?c=cval&a=aval") &&
+          params.nil?
+        end.returns(response)
+
+        MockResource.many_args_get("aval", "bval", "cval")
+      end
+
+      should 'assign unused arguments to the params payload via POST' do
+        response = test_response(test_mock_resource)
+        @mock.expects(:post).with("#{Checkr.api_base}#{MockResource.path}/bval/many", anything, { :a => "aval", :c => "cval" }).returns(response)
+
+        MockResource.many_args_post("aval", "bval", "cval")
+      end
+    end
+
+    context 'APIClass api_instance_method paths' do
+      should 'use the provided argument if it is present' do
+        response = test_response(test_mock_resource)
+        @mock.expects(:get).with("#{Checkr.api_base}/custom_path", anything, anything).returns(response)
+
+        mr = MockResource.new(test_mock_resource)
+        mr.custom_path("/custom_path")
+      end
+
+      should 'use the instance method for path values' do
+        response = test_response(test_mock_resource)
+        name = "/mock_resource_name"
+        @mock.expects(:get).with("#{Checkr.api_base}#{name}", anything, anything).returns(response)
+
+        mr = MockResource.new(test_mock_resource)
+        mr.name = name
+        mr.name_path
+      end
+
+      should 'use the class method for path values' do
+        response = test_response(test_mock_resource)
+        @mock.expects(:get).with("#{Checkr.api_base}#{MockResource.crazy}", anything, anything).returns(response)
+
+        mr = MockResource.new(test_mock_resource)
+        mr.crazy_path
+      end
+    end
+
+    context 'APIClass api_class_method paths' do
+      should 'use the provided argument if it is present' do
+        response = test_response(test_mock_resource)
+        @mock.expects(:get).with("#{Checkr.api_base}#{MockResource.path}/fake_id", anything, anything).returns(response)
+
+        mr = MockResource.retrieve('fake_id')
+      end
+
+      should 'use the class method for path values' do
+        response = test_response(test_mock_resource)
+        @mock.expects(:get).with("#{Checkr.api_base}#{MockResource.crazy}", anything, anything).returns(response)
+
+        MockResource.crazy_path
+      end
+    end
+
+  end
+end