sterling_api 1.0.4

data/lib/sterling_api.rb

@@ -0,0 +1,124 @@
+$: << File.expand_path(File.dirname(__FILE__) + '/../lib')
+require 'sterling_api/xml_helper'
+require 'sterling_api/background_check'
+require 'sterling_api/password_change'
+require 'sterling_api/remote_actions'
+
+module SterlingApi
+
+  URLS = {
+    :test => {
+      :wsdl_background_checks => {
+        :name => 'WSDL - Back Ground Checks',
+        :description => 'URL for background screening web services WSDL',
+        :url => 'https://deuce.tandemselect.com:9000/wh_soap_listener.cgi'
+      },
+      :order_one_step => {
+        :name => 'New Requests URL - Customer Test (One-Step)',
+        :description => 'URL for web service CreateOrder',
+        :url => 'https://deuce.tandemselect.com:9000/wh_soap_listener.cgi'
+      },
+      :order_two_step => {
+        :name => 'New Requests URL - Customer Test (Two-Step)',
+        :description => 'URL for web service CreateOrder',
+        :url => 'https://deuce.tandemselect.com:9000/wh_soap_listener.cgi'
+      },
+      :provider_website => {
+        :name => 'Provider Website URL - Test',
+        :description => 'CPScreen.com URL',
+        :url => 'https://deuce.tandemselect.com:9000/wh_soap_listener.cgi'
+      },
+      :response_post => {
+        :name => 'Response URL - Customer Test',
+        :description => 'URL ChoicePoint uses to post results to ATS',
+        :url => ''
+      },
+      :wsdl_admin => {
+        :name => 'WSDL - Admin',
+        :description => 'URL for admin web services WSDL',
+        :url => 'https://deuce.tandemselect.com:9000/wh_soap_listener.cgi'
+      },
+      :password_change => {
+        :name => 'Password Change Requests URL - Test',
+        :description => 'URL for web service ChangePasswords, GetPackages',
+        :url => 'https://deuce.tandemselect.com:9000/wh_soap_listener.cgi'
+      },
+    },
+
+    :prod => {
+      :wsdl_background_checks => {
+        :name => 'WSDL - Back Ground Checks',
+        :description => 'URL for background screening web services WSDL',
+        :url => 'https://orders.tandemselect.com:444/wh_soap_listener.cgi'
+      },
+      :order_one_step => {
+        :name => 'New Requests URL - Production (One-Step)',
+        :description => 'URL for web service CreateOrder',
+        :url => 'https://orders.tandemselect.com:444/wh_soap_listener.cgi'
+      },
+      :order_two_step => {
+        :name => 'New Requests URL - Production (Two-Step)',
+        :description => 'URL for web service CreateOrder',
+        :url => 'https://orders.tandemselect.com:444/wh_soap_listener.cgi'
+      },
+      :provider_website => {
+        :name => 'Provider Website URL - Production',
+        :description => 'CPScreen.com URL',
+        :url => 'https://orders.tandemselect.com:444/wh_soap_listener.cgi'
+      },
+      :response_post => {
+        :name => 'Response URL - Production',
+        :description => 'URL ChoicePoint uses to post results to ATS',
+        :url => ''
+      },
+      :wsdl_admin => {
+        :name => 'WSDL - Admin',
+        :description => 'URL for admin web services WSDL',
+        :url => 'https://orders.tandemselect.com:444/wh_soap_listener.cgi'
+      },
+      :password_change => {
+        :name => 'Password Change Requests URL - Production',
+        :description => 'URL for web service ChangePasswords, GetPackages',
+        :url => 'https://orders.tandemselect.com:444/wh_soap_listener.cgi'
+      },
+    }
+  }
+
+
+  class Api
+
+    # mode: prod[uction] or test
+    def initialize(mode)
+      @mode = mode
+      # test system password is 'Password2' until changed
+      self
+    end
+
+    def mode
+      @mode.to_s =~ /prod/i ? :prod : :test
+    end
+
+    def order(background_check)
+      req = SterlingApi::RemoteActions::Request.new(
+        :url => url(:order_one_step),
+        :body => background_check.to_xml
+      )
+      req.send_request
+    end
+
+    def password_change_request(password_change)
+      req = SterlingApi::RemoteActions::Request.new(
+        :url => url(:password_change),
+        :body => password_change.to_xml
+      )
+      req.send_request
+    end
+
+    def url(type)
+      SterlingApi::URLS[mode][type][:url]
+    end
+
+  end # class Api
+
+
+end

data/lib/tasks/sterling_api_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :sterling_api do
+#   # Task goes here
+# end

data/sterling_api.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "sterling_api/version"
+
+Gem::Specification.new do |s|
+  s.name        = "sterling_api"
+  s.version     = SterlingApi::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Manny Rodriguez"]
+  s.email       = ["manny@7compass.com"]
+  s.homepage    = "https://github.com/7compass/sterling_api"
+  s.summary     = %q{Sterling Api}
+  s.description = %q{For requesting background checks}
+
+  s.rubyforge_project = "sterling_api"
+
+  s.add_runtime_dependency("nokogiri")
+  s.add_runtime_dependency("net/http")
+  s.add_runtime_dependency("net/https")
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+  
+  s.license = 'MIT'
+end

data/test/background_check_test.rb

@@ -0,0 +1,304 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class BackgroundCheckTest < ActiveSupport::TestCase
+
+  test 'should get mvr node' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2')
+    one_year_ago = 1.year.ago.to_date
+    bg_hash[:licenses] << license_hash(
+      {
+        :valid_from => one_year_ago,
+        :valid_to => nil,
+        :country_code => 'US',
+        :license_number => '1234ABC',
+        :license_region => 'FL',
+      }
+    )
+    bg_hash[:licenses] << license_hash(
+      {
+        :valid_from => '1999-03-13',
+        :valid_to => one_year_ago,
+        :country_code => 'US',
+        :license_number => 'in&val<id>',
+        :license_region => 'CA',
+      }
+    )
+    
+    bg = SterlingApi::BackgroundCheck.for_package(2116, bg_hash)
+    xml = bg.to_xml
+
+    assert_node xml, 'License', :attributes => {:validFrom => one_year_ago.to_s(:db), :validTo => ""}
+    assert_node xml, 'LicenseNumber', :content => '1234ABC'
+    assert_node xml, 'LicenseRegion', :content => 'FL'
+
+    assert_node xml, 'License', :attributes => {:validFrom => "1999-03-13", :validTo => one_year_ago.to_s(:db)}
+    assert_node xml, 'LicenseNumber', :content => 'in&amp;val&lt;id&gt;'
+    assert_node xml, 'LicenseRegion', :content => 'CA'
+  end
+
+  test 'should get names' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2')
+    bg_hash[:person_names] << name_hash({
+        :type => 'subject',
+        :first_name => 'First1',
+        :middle_name => 'M1',
+        :last_name => 'Last1'
+      })
+    bg_hash[:person_names] << name_hash({
+        :type => 'alias',
+        :first_name => 'First2',
+        :middle_name => 'M2',
+        :last_name => 'Last2'
+      })
+    bg = SterlingApi::BackgroundCheck.for_package(2112, bg_hash)
+    xml = bg.to_xml
+
+    assert_node xml, 'PersonName', :attributes => {:type => 'subject'}, :child => {:node_name => 'GivenName', :content => 'First1'}
+    assert_node xml, 'PersonName', :attributes => {:type => 'subject'}, :child => {:node_name => 'MiddleName', :content => 'M1'}
+    assert_node xml, 'PersonName', :attributes => {:type => 'subject'}, :child => {:node_name => 'FamilyName', :content => 'Last1'}
+
+    assert_node xml, 'PersonName', :attributes => {:type => 'alias'}, :child => {:node_name => 'GivenName', :content => 'First2'}
+    assert_node xml, 'PersonName', :attributes => {:type => 'alias'}, :child => {:node_name => 'MiddleName', :content => 'M2'}
+    assert_node xml, 'PersonName', :attributes => {:type => 'alias'}, :child => {:node_name => 'FamilyName', :content => 'Last2'}
+  end
+
+  test 'should get addresses' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2')
+    bg_hash[:postal_addresses] << address_hash({
+        :type => 'current',
+        :valid_from => '2010-01-02',
+        :valid_to => '2020-12-31',
+        :municipality => 'Madison',
+        :region => 'WI',
+        :postal_code => '53711',
+        :country_code => 'US',
+        :address1 => '1234 Main St',
+        :address2 => '',
+      })
+    bg_hash[:postal_addresses] << address_hash({
+        :type => 'prior',
+        :valid_from => '2001-02-03',
+        :valid_to => '2009-11-12',
+        :municipality => 'Podunk',
+        :region => 'KS',
+        :postal_code => '98765',
+        :country_code => 'US',
+        :address1 => '222 There St',
+        :address2 => 'Apt 2',
+      })
+    bg = SterlingApi::BackgroundCheck.for_package(2112, bg_hash)
+    xml = bg.to_xml
+
+    assert_node xml, 'PostalAddress', :attributes => {:type => 'current', :validFrom => '2010-01-02', :validTo => '2020-12-31'},
+        :child => {:node_name => 'Municipality', :content => 'Madison'}
+    assert_node xml, 'PostalAddress', :attributes => {:type => 'current', :validFrom => '2010-01-02', :validTo => '2020-12-31'},
+        :child => {:node_name => 'Region', :content => 'WI'}
+    assert_node xml, 'PostalAddress', :attributes => {:type => 'current', :validFrom => '2010-01-02', :validTo => '2020-12-31'},
+        :child => {:node_name => 'PostalCode', :content => '53711'}
+    assert_node xml, 'PostalAddress', :attributes => {:type => 'current', :validFrom => '2010-01-02', :validTo => '2020-12-31'},
+        :child => {:node_name => 'CountryCode', :content => 'US'}
+    assert_node xml, 'PostalAddress', :attributes => {:type => 'current', :validFrom => '2010-01-02', :validTo => '2020-12-31'},
+        :child => {:node_name => 'DeliveryAddress', :child => {
+        :node_name => 'AddressLine', :content => '1234 Main St'
+      }}
+    assert_no_node xml, 'PostalAddress', :attributes => {:type => 'current', :validFrom => '2010-01-02', :validTo => '2020-12-31'},
+        :child => {:node_name => 'DeliveryAddress', :child => {
+        :node_name => 'AddressLine', :content => ''
+      }}
+
+    assert_node xml, 'PostalAddress', :attributes => {:type => 'prior', :validFrom => '2001-02-03', :validTo => '2009-11-12'},
+        :child => {:node_name => 'Municipality', :content => 'Podunk'}
+    assert_node xml, 'PostalAddress', :attributes => {:type => 'prior', :validFrom => '2001-02-03', :validTo => '2009-11-12'},
+        :child => {:node_name => 'Region', :content => 'KS'}
+    assert_node xml, 'PostalAddress', :attributes => {:type => 'prior', :validFrom => '2001-02-03', :validTo => '2009-11-12'},
+        :child => {:node_name => 'PostalCode', :content => '98765'}
+    assert_node xml, 'PostalAddress', :attributes => {:type => 'prior', :validFrom => '2001-02-03', :validTo => '2009-11-12'},
+        :child => {:node_name => 'CountryCode', :content => 'US'}
+    assert_node xml, 'PostalAddress', :attributes => {:type => 'prior', :validFrom => '2001-02-03', :validTo => '2009-11-12'},
+        :child => {:node_name => 'DeliveryAddress', :child => {
+        :node_name => 'AddressLine', :content => '222 There St'
+      }}
+    assert_node xml, 'PostalAddress', :attributes => {:type => 'prior', :validFrom => '2001-02-03', :validTo => '2009-11-12'},
+        :child => {:node_name => 'DeliveryAddress', :child => {
+        :node_name => 'AddressLine', :content => 'Apt 2'
+      }}
+  end
+
+  test 'should get ssnv' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2')
+    bg_hash.merge!(ssnv_hash({
+          :ssn => '333224444',
+          :date_of_birth => '1951-02-03'
+        }))
+    bg = SterlingApi::BackgroundCheck.for_package(2112, bg_hash)
+    xml = bg.to_xml
+    assert_node xml, 'DemographicDetail', :child => {
+      :node_name => 'GovernmentId', :content => '333224444'
+    }
+    assert_node xml, 'DemographicDetail', :child => {
+      :node_name => 'DateOfBirth', :content => '1951-02-03'
+    }
+  end
+
+  test 'should have soap wrapper in to_xml' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2')
+    bg = SterlingApi::BackgroundCheck.for_package(2112, bg_hash)
+    xml = bg.to_xml
+    assert_node xml, 'soapenv:Envelope'
+  end
+
+  test 'should have order_as user and account' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2', :order_as_user_id => 'joeuser', :order_as_account_suffix => 'XYZ')
+    bg = SterlingApi::BackgroundCheck.for_package(2112, bg_hash)
+    xml = bg.to_xml
+    
+    assert_node xml, 'ClientReferences', :child => {:node_name => 'ClientReference', :content => 'joeuser'}
+    assert_node xml, 'OrderAccount', :child => {:node_name => 'Account', :content => '036483XYZ'}
+  end
+
+  test '2112 should have correct parts' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2')
+    bg_hash[:person_names] << name_hash
+    bg_hash[:postal_addresses] << address_hash
+    bg_hash[:licenses] << license_hash
+    bg_hash.merge!(ssnv_hash)
+
+    bg = SterlingApi::BackgroundCheck.for_package(2112, bg_hash)
+    xml = bg.to_xml
+
+    assert_node xml, 'PackageId', :content => '2112'
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PersonName'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PostalAddress'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'GovernmentId'}}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'DateOfBirth'}}
+    assert_no_node xml, 'PersonalData', :child => {:node_name => 'Licenses'}
+  end
+
+  test '2113 should have correct parts' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2')
+    bg_hash[:person_names] << name_hash
+    bg_hash[:postal_addresses] << address_hash
+    bg_hash[:licenses] << license_hash
+    bg_hash.merge!(ssnv_hash)
+
+    bg = SterlingApi::BackgroundCheck.for_package(2113, bg_hash)
+    xml = bg.to_xml
+
+    assert_node xml, 'PackageId', :content => '2113'
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PersonName'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PostalAddress'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'GovernmentId'}}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'DateOfBirth'}}
+    assert_no_node xml, 'PersonalData', :child => {:node_name => 'Licenses'}
+  end
+
+  test '2114 should have correct parts' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2')
+    bg_hash[:person_names] << name_hash
+    bg_hash[:postal_addresses] << address_hash
+    bg_hash[:licenses] << license_hash
+    bg_hash.merge!(ssnv_hash)
+
+    bg = SterlingApi::BackgroundCheck.for_package(2114, bg_hash)
+    xml = bg.to_xml
+
+    assert_node xml, 'PackageId', :content => '2114'
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PersonName'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PostalAddress'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'GovernmentId'}}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'DateOfBirth'}}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'Licenses'}
+  end
+
+  test '2116 should have correct parts' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2')
+    bg_hash[:person_names] << name_hash
+    bg_hash[:postal_addresses] << address_hash
+    bg_hash[:licenses] << license_hash
+    bg_hash.merge!(ssnv_hash)
+
+    bg = SterlingApi::BackgroundCheck.for_package(2116, bg_hash)
+    xml = bg.to_xml
+
+    assert_node xml, 'PackageId', :content => '2116'
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PersonName'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PostalAddress'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'GovernmentId'}}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'DateOfBirth'}}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'Licenses'}
+  end
+
+  test '2117 should have correct parts' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2')
+    bg_hash[:person_names] << name_hash
+    bg_hash[:postal_addresses] << address_hash
+    bg_hash[:licenses] << license_hash
+    bg_hash.merge!(ssnv_hash)
+
+    bg = SterlingApi::BackgroundCheck.for_package(2117, bg_hash)
+    xml = bg.to_xml
+
+    assert_node xml, 'PackageId', :content => '2117'
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PersonName'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PostalAddress'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'GovernmentId'}}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'DateOfBirth'}}
+    assert_no_node xml, 'PersonalData', :child => {:node_name => 'Licenses'}
+  end
+
+  test '2168 should have correct parts' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2')
+    bg_hash[:person_names] << name_hash
+    bg_hash[:postal_addresses] << address_hash
+    bg_hash[:licenses] << license_hash
+    bg_hash.merge!(ssnv_hash)
+
+    bg = SterlingApi::BackgroundCheck.for_package(2168, bg_hash)
+    xml = bg.to_xml
+
+    assert_node xml, 'PackageId', :content => '2168'
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PersonName'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PostalAddress'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'GovernmentId'}}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'DateOfBirth'}}
+    assert_no_node xml, 'PersonalData', :child => {:node_name => 'Licenses'}
+  end
+
+  test '2169 should have correct parts' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2')
+    bg_hash[:person_names] << name_hash
+    bg_hash[:postal_addresses] << address_hash
+    bg_hash[:licenses] << license_hash
+    bg_hash.merge!(ssnv_hash)
+
+    bg = SterlingApi::BackgroundCheck.for_package(2169, bg_hash)
+    xml = bg.to_xml
+
+    assert_node xml, 'PackageId', :content => '2169'
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PersonName'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PostalAddress'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'GovernmentId'}}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'DateOfBirth'}}
+    assert_no_node xml, 'PersonalData', :child => {:node_name => 'Licenses'}
+  end
+
+  test '2360 should have correct parts' do
+    bg_hash = background_check_hash(:account => '036483', :password => 'Password2')
+    bg_hash[:person_names] << name_hash
+    bg_hash[:postal_addresses] << address_hash
+    bg_hash[:licenses] << license_hash
+    bg_hash.merge!(ssnv_hash)
+
+    bg = SterlingApi::BackgroundCheck.for_package(2360, bg_hash)
+    xml = bg.to_xml
+
+    assert_node xml, 'PackageId', :content => '2360'
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PersonName'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'PostalAddress'}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'GovernmentId'}}
+    assert_node xml, 'PersonalData', :child => {:node_name => 'DemographicDetail', :child => {:node_name => 'DateOfBirth'}}
+    assert_no_node xml, 'PersonalData', :child => {:node_name => 'Licenses'}
+  end
+
+
+end

data/test/password_change_test.rb

@@ -0,0 +1,32 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class PasswordChangeTest < ActiveSupport::TestCase
+
+  test 'should get new without subaccount' do
+    pc = SterlingApi::PasswordChange.new(
+      '12345',
+      'secret',
+      'secreter'
+    )
+
+    xml = pc.to_xml
+
+    assert_node xml, 'ChoicePointAdminRequest', :attributes => {:account => '12345'}
+    assert_node xml, 'Account', :content => '12345'
+  end
+
+  test 'should get new with subaccount' do
+    pc = SterlingApi::PasswordChange.new(
+      '12345',
+      'secret',
+      'secreter',
+      'ABC'
+    )
+
+    xml = pc.to_xml
+
+    assert_node xml, 'ChoicePointAdminRequest', :attributes => {:account => '12345ABC'}
+    assert_node xml, 'Account', :content => '12345ABC'
+  end
+
+end

data/test/remote_actions_test.rb

@@ -0,0 +1,47 @@
+require 'test_helper'
+
+class RemoteActionsTest < ActiveSupport::TestCase
+
+  test 'should get host_from_url' do
+    req = SterlingApi::RemoteActions::Request.new(:url => 'http://test.lexisnexis.fake/foo/bar')
+    assert_equal 'test.lexisnexis.fake', req.host_from_url
+
+    req = SterlingApi::RemoteActions::Request.new(:url => 'http://this.that-test.lexisnexis.fake/foo/bar')
+    assert_equal 'this.that-test.lexisnexis.fake', req.host_from_url
+
+    req = SterlingApi::RemoteActions::Request.new(:url => 'http://test2.lexisnexis.fake')
+    assert_equal 'test2.lexisnexis.fake', req.host_from_url
+
+    req = SterlingApi::RemoteActions::Request.new(:url => 'test3.lexisnexis.fake/foo/bar')
+    assert_equal 'test3.lexisnexis.fake', req.host_from_url
+
+    req = SterlingApi::RemoteActions::Request.new(:url => '')
+    assert_equal nil, req.host_from_url
+  end
+
+  test 'should get port_from_url' do
+    req = SterlingApi::RemoteActions::Request.new(:url => 'http://test.lexisnexis.fake/foo/bar')
+    assert_equal 80, req.port_from_url
+
+    req = SterlingApi::RemoteActions::Request.new(:url => 'https://test.lexisnexis.fake/foo/bar')
+    assert_equal 443, req.port_from_url
+
+    req = SterlingApi::RemoteActions::Request.new(:url => 'http://test.lexisnexis.fake:8765/foo/bar')
+    assert_equal 8765, req.port_from_url
+  end
+
+  test 'should get is_ssl?' do
+    req = SterlingApi::RemoteActions::Request.new(:url => 'http://test.lexisnexis.fake/foo/bar')
+    assert !req.is_ssl?
+
+    req = SterlingApi::RemoteActions::Request.new(:url => 'https://test.lexisnexis.fake/foo/bar')
+    assert req.is_ssl?
+  end
+
+  test 'should get response errors' do
+    res = SterlingApi::RemoteActions::MockResponse.new(:body => SterlingApi::XmlSamples::CHANGE_PASSWORD_FAIL_RESPONSE)
+    assert_equal '250', res.errors[:error_code]
+    assert_equal 'Invalid old password', res.errors[:error_description]
+  end
+
+end

data/test/sterling_api_test.rb

@@ -0,0 +1,70 @@
+require File.join(File.dirname(__FILE__), 'test_helper')
+
+class SterlingApiTest < ActiveSupport::TestCase
+
+  def setup
+    # DO YOU REALLY WANT TO SEND THESE TEST REQUESTS TO LEXIS-NEXIS?
+    @SEND_REQUESTS = false
+  end
+
+  test 'should order packages' do
+    if @SEND_REQUESTS
+      %w(Eligible Ineligible).each do |status|
+        @status = status
+        @client_reference1 = "Make me #{@status}"
+        @order_as_user_id = nil
+        @order_as_account_suffix = nil
+
+        [2112, 2113, 2114, 2116, 2117, 2168, 2169, 2360].each do |id|
+          bg_hash = background_check_hash(:account => '036483', :password => 'Password2',
+            :order_as_user_id => @order_as_user_id,
+            :order_as_account_suffix => @order_as_account_suffix,
+            :client_reference1 => @client_reference1
+          )
+          bg_hash[:person_names] << name_hash(:last_name => @status)
+          bg_hash[:postal_addresses] << address_hash
+          bg_hash[:licenses] << license_hash
+          bg_hash.merge!(ssnv_hash)
+
+          bg = SterlingApi::BackgroundCheck.for_package(id, bg_hash)
+          api = SterlingApi::Api.new(:test)
+          response = api.order(bg)
+
+          puts "response for package #{id}: #{response.inspect}"
+          assert_no_match %r{<ErrorReport>}, response.body, "Error on package #{id}"
+        end
+      end
+    end
+  end
+
+  test 'should order packages with suffix' do
+    if @SEND_REQUESTS
+      %w(Eligible Ineligible).each do |status|
+        @status = status
+        @client_reference1 = "Make me #{@status}"
+        @order_as_user_id = 'test_user'
+        @order_as_account_suffix = 'TST'
+
+        [2112, 2113, 2114, 2116, 2117, 2168, 2169, 2360].each do |id|
+          bg_hash = background_check_hash(:account => '036483', :password => 'Password2',
+            :order_as_user_id => @order_as_user_id,
+            :order_as_account_suffix => @order_as_account_suffix,
+            :client_reference1 => @client_reference1
+          )
+          bg_hash[:person_names] << name_hash(:last_name => @status)
+          bg_hash[:postal_addresses] << address_hash
+          bg_hash[:licenses] << license_hash
+          bg_hash.merge!(ssnv_hash)
+
+          bg = SterlingApi::BackgroundCheck.for_package(id, bg_hash)
+          api = SterlingApi::Api.new(:test)
+          response = api.order(bg)
+
+          puts "response for package #{id}: #{response.inspect}"
+          assert_no_match %r{<ErrorReport>}, response.body, "Error on package #{id}"
+        end
+      end
+    end
+  end
+
+end