ucb_ldap 2.0.0.pre1 → 2.0.0.pre3

data/spec/ucb_ldap/job_appointment_spec.rb

@@ -0,0 +1,65 @@
+require_relative "../spec_helper"
+
+
+describe "UCB::LDAP::JobAppointment" do
+  before(:all) do
+    job_appointment_bind
+    @sh_appts = JobAppointment.find_by_uid('61065')
+    @sh_appt = @sh_appts.first
+  end
+
+  after(:all) do
+    UCB::LDAP.clear_authentication
+  end
+  
+  it "should find job appointments by uid" do
+    @sh_appts.should be_instance_of(Array)
+    @sh_appts.first.should be_instance_of(JobAppointment)
+    @sh_appts.size.should == 1
+  end
+  
+  it "should return cto code" do
+    @sh_appt.cto_code.should == 'F15'
+  end
+  
+  it "should return deptid" do
+    @sh_appt.deptid.should == 'JKASD'
+  end
+  
+  it "should return record number" do
+    @sh_appt.record_number.should == 0
+  end
+  
+  it "should return Personnel Program Code" do
+    @sh_appt.personnel_program_code.should == "2"
+  end
+  
+  it "should return primary? flag" do
+    @sh_appt.should be_primary
+  end
+  
+  it "should return primary? flag" do
+    @sh_appt.should be_primary
+  end
+  
+  it "should return ERC code" do
+    @sh_appt.erc_code.should == "E"
+  end
+  
+  it "should return represented? flag" do
+    @sh_appt.should_not be_represented
+  end
+  
+  it "should return title code" do
+    @sh_appt.title_code.should == '0531'
+  end
+  
+  it "should return appointment type" do
+    @sh_appt.appointment_type.should == '2'
+  end
+  
+  it "should return wos? flag" do
+    @sh_appt.should_not be_wos
+  end
+end
+

data/spec/ucb_ldap/namespace_spec.rb

@@ -0,0 +1,72 @@
+require_relative "../spec_helper"
+
+
+describe UCB::LDAP::Namespace do
+  before(:all) do
+    namespace_bind()
+  end
+
+  before(:each) do
+    @uid = '61065'
+    @cn = 'runner'
+  end
+
+  after(:all) do
+    UCB::LDAP.clear_authentication
+  end
+  
+  it "should set tree base" do
+    Namespace.tree_base.should == 'ou=names,ou=namespace,dc=berkeley,dc=edu'
+  end
+  
+  it "should set entity name" do
+    Namespace.entity_name.should == "namespaceName"
+  end
+  
+  it "should set schema attributes" do
+    Namespace.schema_attributes_array.should be_instance_of(Array)
+    Namespace.schema_attributes_array[0].should be_instance_of(Schema::Attribute)
+    lambda { Namespace.schema_attribute('berkeleyEduServices') }.should_not raise_error 
+    lambda { Namespace.schema_attribute('bogus') }.should raise_error(BadAttributeNameException)
+  end
+
+  it "should find namespaces by uid and return Array of Namespace" do
+    ns = Namespace.find_by_uid(@uid)
+    ns.should be_instance_of(Array)
+    ns.first.should be_instance_of(Namespace)
+    ns.first.uid.should == @uid
+  end
+  
+  it "should find namespaces by cn and return single Namespace" do
+    ns = Namespace.find_by_cn(@cn)
+    ns.class.should == Namespace
+    ns.name.should == @cn
+    ns.uid.should == @uid
+  end
+end
+
+
+describe "UCB::LDAP::Namespace instance" do
+  before(:all) do
+    namespace_bind()
+    @cn = 'runner'
+    @n = Namespace.find_by_cn(@cn)
+  end
+  
+  after(:all) do
+    UCB::LDAP.clear_authentication
+  end
+  
+  it "should return uid as scalar" do
+    @n.uid.should == '61065'
+  end
+
+  it "should return name as scalar" do
+    @n.name.should == @cn
+  end
+  
+  it "should return services as an array" do
+    @n.services.class.should == Array
+    @n.services.should == ['calmail', "calnet"]
+  end
+end

data/spec/ucb_ldap/org_spec.rb

@@ -0,0 +1,217 @@
+require_relative "../spec_helper"
+
+
+describe UCB::LDAP::Org do
+  before(:all) do
+    # when fetching > 200 entries, we need to point to production
+    UCB::LDAP.host = UCB::LDAP::HOST_PRODUCTION
+  end
+
+  after(:all) do
+    # revert to test host in case suite of specs are being run
+     UCB::LDAP.host = HOST_TEST
+  end
+  
+  it "should set tree base" do
+    UCB::LDAP::Org.tree_base.should == 'ou=org units,dc=berkeley,dc=edu'
+  end
+  
+  it "should set entity name" do
+    UCB::LDAP::Org.entity_name.should == "org"
+  end
+  
+  it "should set schema attributes" do
+    UCB::LDAP::Org.schema_attributes_array.should be_instance_of(Array)
+    UCB::LDAP::Org.schema_attributes_array[0].should be_instance_of(UCB::LDAP::Schema::Attribute)
+    ou_attr = UCB::LDAP::Org.schema_attribute(:ou)
+  end
+
+  it "find_by_ou should fetch Org instance" do
+    UCB::LDAP::Org.clear_all_nodes
+    e = UCB::LDAP::Org.find_by_ou('jkasd')
+    e.should be_instance_of(UCB::LDAP::Org)
+    e.ou.should == ['JKASD']
+    # verify cache empty
+    UCB::LDAP::Org.all_nodes_i.should be_nil
+  end
+  
+  it 'org_by_ou is alias for find_by_ou' do
+    e = UCB::LDAP::Org.org_by_ou('jkasd')
+    e.should be_instance_of(UCB::LDAP::Org)
+  end
+
+  it 'search should return Array of UCB::LDAP::Org' do
+    entries = UCB::LDAP::Org.search(:filter => {:ou => 'jkasd'})
+    entries.should be_instance_of(Array)
+    entries[0].should be_instance_of(UCB::LDAP::Org)
+  end
+
+  it 'root_node should return the root node' do
+    UCB::LDAP::Org.root_node.deptid.should == 'UCBKL'
+  end
+
+  it "should load_all_nodes" do
+    UCB::LDAP::Org.clear_all_nodes
+    UCB::LDAP::Org.all_nodes_i.should be_nil
+    UCB::LDAP::Org.load_all_nodes
+    UCB::LDAP::Org.all_nodes_i.should have_at_least(1000).keys
+  end
+  
+  it "should return Array of all org nodes when sent all_nodes()" do
+    all_nodes = UCB::LDAP::Org.all_nodes
+    all_nodes.should have_at_least(1000).keys
+    all_nodes[all_nodes.keys.first].should be_instance_of(UCB::LDAP::Org)
+  end
+
+  it "should cache the org tree" do
+    UCB::LDAP::Org.clear_all_nodes
+    UCB::LDAP::Org.all_nodes_i.should be_nil
+    UCB::LDAP::Org.all_nodes
+    UCB::LDAP::Org.all_nodes_i.should_not be_nil
+    # In the future, additional nodes may be added or deleted directly beneath
+    # the root node, in which case this test would fail need to be altered.
+    UCB::LDAP::Org.root_node.child_nodes_i.should have(14).keys
+  end
+
+  it "should be able to fetch orgs from cache" do
+    UCB::LDAP::Org.clear_all_nodes
+    UCB::LDAP::Org.find_by_ou_from_cache("jkasd").should be_nil
+    UCB::LDAP::Org.all_nodes # forces load of cache
+    UCB::LDAP::Org.find_by_ou_from_cache("jkasd").deptid.should == 'JKASD'
+  end
+  
+  it "should return flattened_tree" do
+    UCB::LDAP::Org.flattened_tree.should be_instance_of(Array)
+    UCB::LDAP::Org.flattened_tree.size.should == UCB::LDAP::Org.all_nodes.keys.size
+    UCB::LDAP::Org.flattened_tree.first.should equal(UCB::LDAP::Org.root_node)
+  end
+
+  it "should return flattened_tree down to certain level" do
+    UCB::LDAP::Org.flattened_tree.map { |o| o.level }.sort.last.should == 6
+    UCB::LDAP::Org.flattened_tree(:level => 4).map { |o| o.level }.sort.last.should == 4
+  end
+end
+
+
+describe "UCB::LDAP::Org instance" do
+  before(:all) { UCB::LDAP.host = UCB::LDAP::HOST_PRODUCTION }
+  after(:all) { UCB::LDAP.host = HOST_TEST }
+  
+  before(:each) do
+    @e = UCB::LDAP::Org.find_by_ou('jkasd')
+  end
+  
+  it "should return deptid" do
+    @e.deptid.should == 'JKASD'
+    @e.ou.should == ['JKASD']
+  end
+  
+  it "should return name" do
+    @e.name.should == 'Enterprise Application Service'
+  end
+  
+  it "should return processing_unit?" do
+    UCB::LDAP::Org.find_by_ou('UCBKL').should_not be_processing_unit
+    UCB::LDAP::Org.find_by_ou('jkasd').should_not be_processing_unit
+    UCB::LDAP::Org.find_by_ou('jkweb').should be_processing_unit
+  end
+
+  it "should return parent_deptids" do
+    @e.parent_deptids.should ==  %w{UCBKL AVCIS VRIST} 
+  end
+  
+  it "should return parent_deptid" do
+    UCB::LDAP::Org.find_by_ou("avcis").parent_deptid.should == 'UCBKL'
+  end
+
+  it "should return level" do
+    @e.level.should == 4
+  end
+
+  it "should return parent_node" do
+    @e.parent_node.deptid.should == 'VRIST'
+    UCB::LDAP::Org.root_node.parent_node.should be_nil
+  end
+
+  it "should return parent_nodes" do
+    @e.parent_deptids.should == @e.parent_nodes.map{|n| n.deptid}
+  end
+
+  it "should return child_nodes" do
+    r = UCB::LDAP::Org.root_node
+    r.child_nodes.should have(14).items
+    r.child_nodes.first.deptid.should == 'AVCIS'
+    r.child_nodes.last.deptid.should == 'VCURL'
+    
+    #  test_push_child_node
+    o = UCB::LDAP::Org.new({})
+    o.child_nodes_i.should be_nil
+    
+    # add 1
+    o.push_child_node(@e)
+    o.should have(1).child_nodes_i
+    
+    # add another
+    o.push_child_node(UCB::LDAP::Org.find_by_ou('VCURL'))
+    o.should have(2).child_nodes_i
+    
+    # can't add one a second time
+    o.push_child_node(UCB::LDAP::Org.find_by_ou('VCURL'))
+    o.should have(2).child_nodes_i
+  end
+
+  it "should return child_nodes sorted by deptid" do
+    UCB::LDAP::Org.root_node.child_nodes.should == UCB::LDAP::Org.root_node.child_nodes.sort_by { |n| n.deptid }
+  end
+  
+  it "should load department persons" do
+    org = UCB::LDAP::Org.find_by_ou('JFAVC')
+    org.persons.first.should be_instance_of(UCB::LDAP::Person)
+    org.persons.first.deptid.should == 'JFAVC'
+  end
+end
+
+
+describe "UCB::LDAP::Org levels" do
+  before(:all) do
+    UCB::LDAP.host = UCB::LDAP::HOST_PRODUCTION
+    @okliv = UCB::LDAP::Org.find_by_ou('okliv')
+    @root = UCB::LDAP::Org.root_node
+  end
+  
+  after(:all) do
+    UCB::LDAP.host = HOST_TEST
+  end
+  
+  it "should return level_1_org_code, level_1_org_description" do
+    @okliv.level_1_code.should == 'UCBKL'
+    @okliv.level_1_name.should == 'UC Berkeley Campus'
+  end
+
+  it "should return level_2_org_code, level_2_org_description" do
+    @okliv.level_2_code.should == 'VCUGA'
+    @okliv.level_2_name.should_not be_nil
+    @root.level_2_code.should be_nil
+    @root.level_2_name.should be_nil
+  end
+
+  it "should return level_3_org_code, level_3_org_description" do
+    @okliv.level_3_code.should == 'UG1VC'
+    @okliv.level_3_name.should_not be_nil
+  end
+
+  it "should return level_4_org_code, level_4_org_description" do
+    @okliv.level_4_code.should == 'OKLHS'
+    @okliv.level_4_name.should_not be_nil
+  end
+
+  it "should return level_5_org_code, level_5_org_description" do
+    @okliv.level_5_code.should == 'OKCUR'
+    @okliv.level_5_name.should_not be_nil
+  end
+
+  it "should return level_6_org_code, level_6_org_description" do
+    @okliv.level_6_code.should == 'OKLIV'
+    @okliv.level_6_name.should_not be_nil
+  end
+end

data/spec/ucb_ldap/person_spec.rb

@@ -0,0 +1,225 @@
+require_relative "../spec_helper"
+
+
+describe UCB::LDAP::Person, "searching for test entries" do
+  it "excludes test entries by default" do
+    Person.instance_variable_set(:@include_test_entries, nil)
+    Person.include_test_entries?.should be_false
+    Person.find_by_uid("212387").should be_nil
+  end
+  
+  it "allows for test entries to be included" do
+    Person.include_test_entries = true
+    Person.include_test_entries?.should be_true
+    Person.find_by_uid("212387").uid.should == "212387"
+  end
+end
+
+
+describe UCB::LDAP::Person do
+  before(:all) do
+    Person.include_test_entries = true
+    @staff = Person.find_by_uid "212387"
+    @student = Person.find_by_uid "232588"
+  end
+  
+  it "constructor should return Person instances" do
+    @staff.should be_instance_of(Person)
+    @student.should be_instance_of(Person)
+  end
+  
+  it "persons_by_uid should return Array of Person" do
+    persons = Person.find_by_uids ['212386', '212387']
+    persons.should be_instance_of(Array)
+    persons.should have(2).items
+    persons[0].should be_instance_of(Person)
+    persons[0].uid.should == '212386'
+    persons[1].uid.should == '212387'
+    
+    Person.persons_by_uids([]).should == []
+  end
+
+  it "find_by_uid(s) is an alias for person(s)_by_uid" do
+    Person.respond_to?(:find_by_uids).should be_true
+    Person.respond_to?(:find_by_uid).should be_true
+  end
+
+  it "find_by_uid works with a String or an Integer" do
+    staff_from_int_uid = Person.find_by_uid(212387)
+    staff_from_int_uid.uid.should == @staff.uid
+  end
+end
+
+
+describe "UCB::LDAP::Person instance" do
+  before(:all) do
+    UCB::LDAP::Person.include_test_entries = true
+    @staff = Person.find_by_uid("212387")
+    @student = Person.find_by_uid("232588")
+  end
+  
+  it "should know if an person is a test entry" do
+    @staff.test?.should be_true
+    Person.find_by_uid('61065').test?.should_not be_true
+  end
+  
+  it "should return uid as scalar" do
+    @staff.uid.should == "212387"
+  end
+  
+  it "should return firstname and first_name as (scalar) synonyms for givenname" do
+    @staff.givenname.should == ['EMP-STAFF']
+    @staff.firstname.should == 'EMP-STAFF'
+    @staff.first_name.should == 'EMP-STAFF'
+  end
+  
+  it "should return lastname and last_name as (scalar) synonyms for sn" do
+    @staff.sn.should == ['TEST']
+    @staff.lastname.should == 'TEST'
+    @staff.last_name.should == 'TEST'
+  end
+  
+  it "should return email as scalar synonym for mail" do
+    @staff.mail.should == %w(test-212387@berkeley.edu)
+    @staff.email.should == 'test-212387@berkeley.edu'
+  end
+  
+  it "should return phone as scalar synonym for telephoneNumber" do
+    @staff.telephoneNumber.should == ['+1 (510) 643-1234'] 
+    @staff.phone.should == '+1 (510) 643-1234' 
+  end
+
+  it "should return deptid, dept_code as scalar synonym for berkeleyEduPrimaryDeptUnit" do
+    @staff.berkeleyEduPrimaryDeptUnit.should == 'JICCS' 
+    @staff.deptid.should == 'JICCS' 
+    @staff.dept_code.should == 'JICCS'
+  end
+
+  it "should return dept_name as scalar synonym for berkeleyEduUnitCalNetDeptName" do
+    # here we aren't using a test entry as no test entires have values
+    # for the below attributes
+    p = UCB::LDAP::Person.find_by_uid(61065)
+    p.berkeleyEduUnitCalNetDeptName.should == "IST-Application Services"
+    p.dept_name.should == "IST-Application Services"
+  end
+
+  it "should return org_node (UCB::LDAP::Org instance)" do
+    @staff.org_node.should be_instance_of(Org) 
+    @staff.org_node.deptid.should == 'JICCS'
+  end
+  
+  it "should return affiliations" do
+    @staff.affiliations.should include('EMPLOYEE-TYPE-STAFF')
+    @student.affiliations.should include('STUDENT-TYPE-REGISTERED')
+    
+    @staff.has_affiliation?("bogus").should be_false
+    @staff.has_affiliation?('EMPLOYEE-TYPE-STAFF').should be_true
+    @staff.has_affiliation?('employee-type-staff').should be_true
+    
+    @student.has_affiliation?("bogus").should be_false
+    @student.has_affiliation?('STUDENT-TYPE-REGISTERED').should be_true
+    @student.has_affiliation?('student-type-registered').should be_true
+  end
+  
+  it "should return has_affiliation_of_type?()" do
+    Person.new({}).has_affiliation_of_type?(:affiliate).should be_false
+    Person.new({:berkeleyEduAffiliations => ["AFFILIATE-TYPE-FOO"]}).has_affiliation_of_type?(:affiliate).should be_true
+  end
+  
+  it "should return addresses" do
+    address_bind()
+    Person.find_by_uid('61065').addresses.first.should be_instance_of(Address)
+    UCB::LDAP.clear_authentication
+  end
+  
+  it "should return job appointments" do
+    job_appointment_bind()
+    Person.find_by_uid('61065').job_appointments.first.should be_instance_of(JobAppointment)
+    UCB::LDAP.clear_authentication
+  end
+  
+  it "should return namespaces" do
+    namespace_bind()
+    Person.find_by_uid('61065').namespaces.first.class.should  == Namespace
+    UCB::LDAP.clear_authentication
+  end
+end
+
+
+describe "Employee" do
+  it "should return employee_staff?" do
+    Person.new(:berkeleyEduAffiliations => ["EMPLOYEE-TYPE-STAFF"]).should be_employee_staff
+    Person.new({}).should_not be_employee_staff
+  end
+  
+  it "should return employee_academic?" do
+    Person.new(:berkeleyEduAffiliations => ["EMPLOYEE-TYPE-ACADEMIC"]).should be_employee_academic
+    Person.new({}).should_not be_employee_academic
+  end
+  
+  it "should return employee_expired?" do
+    Person.new(:berkeleyEduAffiliations => ["EMPLOYEE-STATUS-EXPIRED"]).should be_employee_expired
+    Person.new({}).should_not be_employee_expired
+  end
+  
+  it "should return employee?" do
+    Person.new({}).should_not be_employee
+    Person.new(:berkeleyEduAffiliations => ["EMPLOYEE-TYPE-STAFF"]).should be_employee
+    Person.new(:berkeleyEduAffiliations => ["EMPLOYEE-TYPE-ACADEMIC"]).should be_employee
+    Person.new(:berkeleyEduAffiliations => ["EMPLOYEE-TYPE-STAFF", "EMPLOYEE-STATUS-EXPIRED"]).should_not be_employee
+  end
+  
+  it "should return employee_expiration_date" do
+    p = Person.new({:berkeleyEduEmpExpDate => ['20000102080000Z']})
+    p.employee_expiration_date.to_s.should == '2000-01-02'
+  end
+end
+
+
+describe "Student" do
+  it "should return student_registered?" do
+    Person.new({}).should_not be_student_registered
+    Person.new(:berkeleyEduAffiliations => ["STUDENT-TYPE-REGISTERED"]).should be_student_registered
+  end
+  
+  it "should return student_not_registered?" do
+    Person.new({}).should_not be_student_not_registered
+    Person.new(:berkeleyEduAffiliations => ["STUDENT-TYPE-NOT REGISTERED"]).should be_student_not_registered
+  end
+  
+  it "should return student_expired?" do
+    Person.new({}).should_not be_student_expired
+    Person.new(:berkeleyEduAffiliations => ["STUDENT-STATUS-EXPIRED"]).should be_student_expired
+  end
+  
+  it "should return student?" do
+    Person.new({}).should_not be_student
+    Person.new(:berkeleyEduAffiliations => ["STUDENT-TYPE-FOO"]).should be_student
+    Person.new(:berkeleyEduAffiliations => ["STUDENT-TYPE-FOO", "STUDENT-STATUS-EXPIRED"]).should_not be_student
+  end
+  
+  it "should return student_expiration_date()" do
+    student = Person.new(:berkeleyEduStuExpDate => ['20070912080000Z'])
+    student.student_expiration_date.to_s.should == '2007-09-12'
+  end
+end
+
+
+describe "Affiliate" do
+  it "should return affiliate?" do
+    Person.new({}).should_not be_affiliate
+    Person.new(:berkeleyEduAffiliations => ["AFFILIATE-TYPE-FOO"]).should be_affiliate
+    Person.new(:berkeleyEduAffiliations => ["AFFILIATE-TYPE-FOO", "AFFILIATE-STATUS-EXPIRED"]).should_not be_affiliate
+  end
+      
+  it "should return affiliate_expiration_date()" do
+    student = Person.new(:berkeleyEduAffExpDate => ['20070912080000Z'])
+    student.affiliate_expiration_date.to_s.should == '2007-09-12'
+  end
+  
+  it "should return affiliate_expired?" do
+    Person.new({}).should_not be_affiliate_expired
+    Person.new(:berkeleyEduAffiliations => ["AFFILIATE-STATUS-EXPIRED"]).should be_affiliate_expired
+  end
+end
+