authpds 0.0.1

data/lib/authpds/version.rb

@@ -0,0 +1,3 @@
+module Authpds
+  VERSION = "0.0.1"
+end

data/lib/tasks/pds-auth_tasks.rake

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

data/test/authpds_test.rb

@@ -0,0 +1,7 @@
+require 'test_helper'
+
+class AuthpdsTest < ActiveSupport::TestCase
+  test "truth" do
+    assert_kind_of Module, Authpds
+  end
+end

data/test/fixtures/users.yml

@@ -0,0 +1,49 @@
+scot:
+  email: scot.dalton@gmail.com
+  password_salt: <%= salt = Authlogic::Random.hex_token %>
+  crypted_password: <%= Authlogic::CryptoProviders::Sha512.encrypt("scot" + salt) %>
+  persistence_token: <%= Authlogic::Random.hex_token %>
+
+ba36:
+  id: 1
+  password_salt: <%= salt = Authlogic::Random.hex_token %>
+  crypted_password: <%= Authlogic::CryptoProviders::Sha512.encrypt("ba36" + salt) %>
+  persistence_token: <%= Authlogic::Random.hex_token %>
+  username: ba36
+  email: barnaby.alter@nyu.edu
+  firstname: Barnaby
+  lastname: Alter
+  user_attributes: <%= {
+    :nyuidn => "N18158418", 
+    :verification => "6EAF453D8B01E5AC27D9",
+    :bor_status => "51",
+		:aleph_permissions => {} }.to_yaml.inspect  %>
+# std5:
+#   password_salt: <%#= salt = Authlogic::Random.hex_token %>
+#   crypted_password: <%#= Authlogic::CryptoProviders::Sha512.encrypt("std5" + salt) %>
+#   persistence_token: <%#= Authlogic::Random.hex_token %>
+#   username: std5
+#   email: scot.dalton@nyu.edu
+#   firstname: Scot
+#   lastname: Dalton
+#   user_attributes: <%#= {
+#     :nyuidn => "N12162279", 
+#     :verification => "d4465aacaa645f2164908cd4184c09f0",
+#     :bor_status => "51",
+#     :aleph_permissions => {} }.to_yaml.inspect  %>
+
+st75:
+  id: 3
+  password_salt: <%= salt = Authlogic::Random.hex_token %>
+  crypted_password: <%= Authlogic::CryptoProviders::Sha512.encrypt("st75" + salt) %>
+  persistence_token: <%= Authlogic::Random.hex_token %>
+  username: st75
+  email: sydney.thompson@nyu.edu
+  firstname: Sydney Leigh
+  lastname: Thompson
+  user_attributes: <%= {
+    :nyuidn => "N10450419", 
+    :verification => "A64C45148D130E78D8AA",
+    :bor_status => "50",
+		:aleph_permissions => {} }.to_yaml.inspect  %>
+

data/test/support/config/institutions.yml

@@ -0,0 +1,63 @@
+NYU:
+  login_attributes:
+    link_code: NYSID
+    logout_url: 'http://bobcat.library.nyu.edu/nysid'
+  default_institution: true
+  display_name: NYU Libraries
+  view_attributes:
+    test_view_attribute1: test_attribute1_nyu
+    test_view_attribute2: test_attribute2_nyu
+  ip_addresses:
+    - 128.122.0.0-128.122.149.239
+    - 172.26.*.*
+    - 172.27.*.*
+    - 172.22.88.*
+    - 216.165.*.*
+    - 128.238.*.*
+    
+NYUAD:
+  default_institution: false
+  display_name: NYUAD Library
+  view_attributes:
+    test_view_attribute1: test_attribute1_nyuad
+    test_view_attribute2: test_attribute2_nyuad
+  ip_addresses:
+    - 128.122.0.1
+
+NYSID:
+  login_attributes:
+    link_code: NYSID
+    logout_url: 'http://bobcat.library.nyu.edu/nysid'
+  default_institution: false
+  display_name: New York School of Interior Design Library
+  view_attributes:
+    test_view_attribute1: test_attribute1_nysid
+    test_view_attribute2: test_attribute2_nysid
+  ip_addresses:
+    - 128.122.0.1
+
+CU:
+  login_attributes:
+    link_code: CU
+    logout_url: 'http://bobcat.library.nyu.edu/cooper'
+  display_name: Cooper Union Library
+  view_attributes:
+    test_view_attribute1: test_attribute1_cu
+    test_view_attribute2: test_attribute2_cu
+  ip_addresses:
+    - 199.98.16.0-199.98.31.255 
+
+NS:
+  login_attributes:
+    link_code: NS
+    logout_url: 'http://bobcat.library.nyu.edu/newschool'
+  display_name: New School Libraries
+  view_attributes:
+    test_view_attribute1: test_attribute1_ns
+    test_view_attribute2: test_attribute2_ns
+  ip_addresses:
+    - 128.122.138.0/24
+    - 69.64.210.46
+    - 69.64.210.50
+    - 69.64.210.42
+    - 69.193.198.126

data/test/support/user.rb

@@ -0,0 +1,9 @@
+class User < ActiveRecord::Base
+	serialize :user_attributes  
+
+	acts_as_authentic do |c|
+		c.validations_scope = :username
+		c.validate_password_field = false
+		c.require_password_confirmation = false  
+	end
+end

data/test/support/user_session.rb

@@ -0,0 +1,23 @@
+class UserSession < Authlogic::Session::Base
+  pds_url "https://logindev.library.nyu.edu"
+  redirect_logout_url "https://logindev.library.nyu.edu/logout"
+  calling_system "authpds"
+  remember_me true
+  remember_me_for 300
+  httponly true
+  secure true
+  login_inaccessible_url "http://library.nyu.edu/errors/bobcat-library-nyu-edu/"
+  pds_attributes :id => "id", :uid => "uid", 
+    :opensso => "opensso", :name => "name", :firstname => "givenname", 
+    :lastname => "sn", :commonname => "cn", :email => "email",
+    :nyuidn => "nyuidn", :verification => "verification", :institute => "institute",
+    :bor_status => "bor-status", :bor_type => "bor-type",
+    :college_code => "college_code", :college_name => "college_name",
+    :dept_name => "dept_name", :dept_code => "dept_code",
+    :major_code => "major_code", :major => "major", :ill_permission => "ill-permission", 
+    :newschool_ldap => "newschool_ldap"
+  
+  def expiration_date
+    1.day.ago
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,78 @@
+require 'authlogic'
+require 'authlogic/test_case'
+require "test/unit"
+require 'rubygems'
+require "active_record"
+require "active_record/fixtures"
+# Configure Rails Environment
+ENV["RAILS_ENV"] = "test"
+
+ActiveRecord::Base.establish_connection(:adapter => "sqlite3", :database => ":memory:")
+logger = Logger.new(STDOUT)
+logger.level= Logger::FATAL
+ActiveRecord::Base.logger = logger
+ActiveRecord::Base.configurations = true
+ActiveRecord::Schema.define(:version => 1) do
+  drop_table :users if table_exists?(:users)
+  create_table :users do |t|
+    t.string   "username", :default => "", :null => false
+    t.string   "email"
+    t.string   "firstname", :limit => 100
+    t.string   "lastname", :limit => 100
+    t.string   "mobile_phone"
+    t.string   "crypted_password"
+    t.string   "password_salt"
+    t.string   "session_id"
+    t.string   "persistence_token", :null => false
+    t.integer  "login_count", :default => 0, :null => false
+    t.datetime "last_request_at"
+    t.datetime "current_login_at"
+    t.datetime "last_login_at"
+    t.string   "last_login_ip" 
+    t.string   "current_login_ip" 
+    t.text     "user_attributes"
+    t.datetime "refreshed_at"
+    t.timestamps
+  end unless table_exists?(:users)
+end
+
+# Load support files
+require File.dirname(__FILE__) + '/../lib/authpds' unless defined?(Authpds)
+Dir["#{File.dirname(__FILE__)}/support/**/*.rb"].each { |f| require f }
+
+class ActiveSupport::TestCase
+  VALID_PDS_HANDLE_FOR_NYU = '132012112947113134742310506860'
+  VALID_PDS_HANDLE_FOR_NEWSCHOOL = '272201212284614806184193096120278'
+  VALID_PDS_HANDLE_FOR_COOPER = '272201212284614806184193096120278'
+  INVALID_PDS_HANDLE = "Invalid"
+  SESSION_ID = "qwertyuiopasdfghjkllzxcvbnm1234567890"
+  include ActiveRecord::TestFixtures
+  include Authlogic::TestCase
+  self.fixture_path = File.dirname(__FILE__) + "/fixtures"
+  self.use_transactional_fixtures = false
+  self.use_instantiated_fixtures  = false
+  self.pre_loaded_fixtures = false
+  fixtures :all
+  setup :activate_authlogic
+end
+
+class Authlogic::TestCase::MockController
+  def self.helper_method(*args)
+  end
+
+  include Authpds::Controllers::AuthpdsController
+  
+  def url_for(options={})
+    return "http://railsapp.library.nyu.edu/validate?return_url=#{options[:return_url]}"
+  end
+  
+  def root_url
+  end
+
+  def performed?
+    false
+  end
+end
+
+
+

data/test/unit/pds_test.rb

@@ -0,0 +1,72 @@
+require 'test_helper'
+
+class PdsTest < ActiveSupport::TestCase
+  
+  def setup
+    @pds_url = "https://login.library.nyu.edu"
+    @calling_system = "authpds"
+    @valid_pds_handle_for_nyu = VALID_PDS_HANDLE_FOR_NYU
+    @valid_pds_handle_for_newschool = VALID_PDS_HANDLE_FOR_NEWSCHOOL
+    @invalid_pds_handle = INVALID_PDS_HANDLE
+    @attribute = "bor_info"
+    # Ordered in Ruby 1.9 so :uid will overwrite id
+    @bor_info_attributes = { :id => "id", :uid => "uid", 
+      :opensso => "opensso", :name => "name", :firstname => "givenname", 
+      :lastname => "sn", :commonname => "cn", :email => "email",
+      :nyuidn => "nyuidn", :verification => "verification", :institute => "institute",
+      :bor_status => "bor-status", :bor_type => "bor-type",
+      :college_code => "college_code", :college_name => "college_name",
+      :dept_name => "dept_name", :dept_code => "dept_code",
+      :major_code => "major_code", :major => "major", :ill_permission => "ill-permission", 
+      :newschool_ldap => "newschool_ldap" }
+  end
+  
+  test "get_attribute_valid" do
+    get_attribute = Authpds::Exlibris::Pds::GetAttribute.new(@pds_url, @calling_system, @valid_pds_handle_for_nyu, "bor_info")
+    assert_equal("N12162279", get_attribute.response.at("//id").inner_text)
+    get_attribute = Authpds::Exlibris::Pds::GetAttribute.new(@pds_url, @calling_system, @valid_pds_handle_for_nyu, "bor_verification")
+    assert_equal("N12162279", get_attribute.response.at("//id").inner_text)
+    get_attribute = Authpds::Exlibris::Pds::GetAttribute.new(@pds_url, @calling_system, @valid_pds_handle_for_nyu, "authenticate")
+    assert_equal("N12162279", get_attribute.response.at("//id").inner_text)
+    get_attribute = Authpds::Exlibris::Pds::GetAttribute.new(@pds_url, @calling_system, @valid_pds_handle_for_nyu, "bor_id")
+    assert_equal("N12162279", get_attribute.response.at("//id").inner_text)
+  end
+  
+  test "get_attribute_invalid" do
+    get_attribute = Authpds::Exlibris::Pds::GetAttribute.new(@pds_url, @calling_system, @invalid_pds_handle, "bor_info")
+    assert_equal("Error User does not exist", get_attribute.error)
+  end
+  
+  test "bor_info_valid" do
+    nyu = Authpds::Exlibris::Pds::BorInfo.new(@pds_url, @calling_system, @valid_pds_handle_for_nyu, @bor_info_attributes)
+    assert_equal("N12162279", nyu.id)
+    assert_equal("std5", nyu.uid)
+    assert_equal("N12162279", nyu.nyuidn)
+    assert_equal("51", nyu.bor_status)
+    assert_equal("CB", nyu.bor_type)
+    assert_equal("true", nyu.opensso)
+    assert_equal("Scot Thomas", nyu.name)
+    assert_equal("Scot Thomas", nyu.firstname)
+    assert_equal("Dalton", nyu.lastname)
+    assert_equal("Y", nyu.ill_permission)
+    assert_equal("GA", nyu.college_code)
+    assert_equal("CSCI", nyu.dept_code)
+    assert_equal("Information Systems", nyu.major)
+    newschool = Authpds::Exlibris::Pds::BorInfo.new(@pds_url, @calling_system, @valid_pds_handle_for_newschool, @bor_info_attributes)
+    assert_equal("N00206454", newschool.id)
+    assert_equal("314519567249252", newschool.uid)
+    assert_equal("N00206454", newschool.nyuidn)
+    assert_equal("31", newschool.bor_status)
+    assert_equal("0", newschool.bor_type)
+    assert_equal("true", newschool.newschool_ldap)
+    assert_equal("Allen", newschool.name)
+    assert_equal("Allen", newschool.firstname)
+    assert_equal("Jones", newschool.lastname)
+    assert_equal("Y", newschool.ill_permission)
+  end
+  
+  test "bor_info_invalid" do
+    get_attribute = Authpds::Exlibris::Pds::BorInfo.new(@pds_url, @calling_system, @invalid_pds_handle, @bor_info_attributes)
+    assert_equal("Error User does not exist", get_attribute.error)
+  end
+end

data/test/unit/user_session_test.rb

@@ -0,0 +1,123 @@
+require 'test_helper'
+class UserSessionTest < ActiveSupport::TestCase
+  
+  def setup
+    activate_authlogic
+    controller.session[:session_id] = "FakeSessionID"
+    controller.cookies[:PDS_HANDLE] = { :value => VALID_PDS_HANDLE_FOR_NYU }
+  end
+  
+  test "login_url" do
+    user_session = UserSession.new
+    assert_equal(
+      "https://logindev.library.nyu.edu/pds?func=load-login&institute=&calling_system=authpds&url=http%3A%2F%2Frailsapp.library.nyu.edu%2Fvalidate%3Freturn_url%3D", 
+        user_session.login_url)
+  end
+  
+  test "logout_url" do
+    user_session = UserSession.new
+    assert_equal(
+      "https://logindev.library.nyu.edu/pds?func=logout&url=https%253A%252F%252Flogindev.library.nyu.edu%252Flogout", 
+        user_session.logout_url)
+  end
+  
+  test "validate_url" do
+    user_session = UserSession.new
+    assert_equal(
+      "http://railsapp.library.nyu.edu/validate?return_url=http://railsapp.library.nyu.edu", 
+        user_session.send(:validate_url, :return_url => "http://railsapp.library.nyu.edu"))
+    assert_equal(
+      "http://railsapp.library.nyu.edu/validate?return_url=http://railsapp.library.nyu.edu&authpds_custom_param1=custom_param1", 
+        user_session.send(:validate_url, :controller => "test_controller", 
+          :action => "test_action", :return_url => "http://railsapp.library.nyu.edu",
+            :custom_param1 => "custom_param1"))
+  end
+  
+  test "pds_handle" do
+    user_session = UserSession.new
+    assert_equal(VALID_PDS_HANDLE_FOR_NYU, user_session.send(:pds_handle))
+  end
+  
+  test "pds_user" do
+    user_session = UserSession.new
+    pds_user = user_session.pds_user
+    assert_instance_of(Authpds::Exlibris::Pds::BorInfo, pds_user)
+    assert_equal("N12162279", pds_user.id)
+    assert_equal("std5", pds_user.uid)
+    assert_equal("N12162279", pds_user.nyuidn)
+    assert_equal("51", pds_user.bor_status)
+    assert_equal("CB", pds_user.bor_type)
+    assert_equal("true", pds_user.opensso)
+    assert_equal("Scot Thomas", pds_user.name)
+    assert_equal("Scot Thomas", pds_user.firstname)
+    assert_equal("Dalton", pds_user.lastname)
+    assert_equal("Y", pds_user.ill_permission)
+    assert_equal("GA", pds_user.college_code)
+    assert_equal("CSCI", pds_user.dept_code)
+    assert_equal("Information Systems", pds_user.major)
+    assert_equal("NYU", pds_user.institute)
+  end
+  
+  test "persist_session" do
+    user_session = UserSession.new
+    assert_nil(controller.session["authpds_credentials"])
+    assert_nil(user_session.send(:attempted_record))
+    assert_nil(user_session.record)
+    assert_no_difference('User.count') do
+      user_session.send(:persist_session)
+    end
+    assert_not_nil(user_session.send(:attempted_record))
+    assert_nil(user_session.record)
+    assert_equal("N12162279", user_session.send(:attempted_record).username)
+  end
+  
+  test "after_login" do
+    user_session = UserSession.new
+    assert_nil(controller.session["auth_test_credentials"])
+    assert_nil(user_session.send(:attempted_record))
+    assert_nil(user_session.record)
+    assert_no_difference('User.count') {
+        user_session.send(:after_login)
+    }
+    assert_nil(controller.session["auth_test_credentials"])
+    assert_not_nil(user_session.send(:attempted_record))
+    assert_nil(user_session.record)
+    assert_equal("N12162279", user_session.send(:attempted_record).username)
+  end
+  
+  test "find" do
+    user_session = UserSession.new
+    assert_nil(controller.session["authpds_credentials"])
+    assert_nil(user_session.send(:attempted_record))
+    assert_nil(user_session.record)
+    assert_difference('User.count') {
+        user_session = UserSession.find
+    }
+    assert_not_nil(controller.session["authpds_credentials"])
+    assert_not_nil(user_session.send(:attempted_record))
+    assert_not_nil(user_session.record)
+    assert_equal(controller.session["authpds_credentials"], user_session.record.persistence_token)
+    assert_equal("N12162279", user_session.record.username)
+  end
+  
+  test "expiration_date" do
+    user_session = UserSession.new
+    assert_in_delta(-0.00001, 1.day.ago.to_f, user_session.expiration_date.to_f)
+  end
+  
+  test "get_record" do
+    user_session = UserSession.new
+    record = user_session.send(:get_record, "std5")
+    assert_instance_of(User, record)
+    assert_equal("std5", record.username)
+    assert_nil(record.id)
+    assert_nil(record.firstname)
+    record = user_session.send(:get_record, "st75")
+    assert_instance_of(User, record)
+    assert_equal("st75", record.username)
+    assert_not_nil(record.id)
+    assert_equal(3, record.id)
+    assert_not_nil(record.firstname)
+    assert_equal("Sydney Leigh", record.firstname)
+  end
+end

data/test/unit/user_test.rb

@@ -0,0 +1,77 @@
+require 'test_helper'
+class UserSessionTest < ActiveSupport::TestCase
+  
+  def setup
+    activate_authlogic
+    controller.session[:session_id] = "FakeSessionID"
+    controller.cookies[:PDS_HANDLE] = { :value => VALID_PDS_HANDLE_FOR_NYU }
+    InstitutionList.class_variable_set(:@@institutions_yaml_path, nil)
+    InstitutionList.instance.instance_variable_set(:@institutions, nil)
+  end
+
+  test "username=" do
+    ba36 = User.find(1)
+    token1 = ba36.persistence_token
+    ba36.username=("ba36")
+    token2 = ba36.persistence_token
+    assert_equal(token1, token2)
+    ba36.username=("ba37")
+    token2 = ba36.persistence_token
+    assert_not_equal(token1, token2)
+  end
+
+  
+  
+  test "user_attributes" do
+    user = User.new
+    user.user_attributes= {:test_attribute1 => "value1", :test_attribute2 => "value2"}
+    assert_equal("value1", user.user_attributes[:test_attribute1])
+    assert_equal("value2", user.user_attributes[:test_attribute2])
+    user.user_attributes= {:test_attribute3 => "value3", :test_attribute4 => "value4"}
+    assert_equal("value1", user.user_attributes[:test_attribute1])
+    assert_equal("value2", user.user_attributes[:test_attribute2])
+    assert_equal("value3", user.user_attributes[:test_attribute3])
+    assert_equal("value4", user.user_attributes[:test_attribute4])
+    user.user_attributes= {:test_attribute3 => "value3.1", :test_attribute4 => "value4.1"}
+    assert_equal("value1", user.user_attributes[:test_attribute1])
+    assert_equal("value2", user.user_attributes[:test_attribute2])
+    assert_equal("value3.1", user.user_attributes[:test_attribute3])
+    assert_equal("value4.1", user.user_attributes[:test_attribute4])
+  end
+  
+  test "primary_institution" do
+    user = User.new
+    assert_raise ArgumentError do
+      user.primary_institution= "NYU"
+    end
+    InstitutionList.yaml_path= "#{File.dirname(__FILE__)}/../support/config/institutions.yml"
+    assert_nothing_raised ArgumentError do
+      user.primary_institution= "NYU"
+    end
+  end
+  
+  test "institutions" do
+    user = User.new
+    assert_raise ArgumentError do
+      user.institutions= "NYU"
+    end
+    assert_raise ArgumentError do
+      user.institutions= ["NYU"]
+    end
+    assert_nil(user.institutions)
+    InstitutionList.yaml_path= "#{File.dirname(__FILE__)}/../support/config/institutions.yml"
+    user.institutions= ["NYU"]
+    assert_not_nil(user.institutions)
+    assert_equal([InstitutionList.instance.get("NYU")], user.institutions)
+  end
+
+  test "expired?" do
+    user = User.new
+    user.expiration_date = 1.week.ago
+    user.refreshed_at = 1.week.ago - 1.second
+    assert(user.expired?)
+    user.expiration_date = 1.week.ago
+    user.refreshed_at = 1.week.ago + 1.second
+    assert(!user.expired?)
+  end
+end