ucb_ldap 2.0.0 → 3.0.0

data/spec/ucb_ldap/namespace_spec.rb

@@ -1,72 +0,0 @@
-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

@@ -1,217 +0,0 @@
-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

@@ -1,225 +0,0 @@
-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
-