ucb_ldap 2.0.0.pre1 → 2.0.0.pre3

data/lib/{ucb_ldap_student_term.rb → ucb_ldap/student_term.rb}

@@ -1,8 +1,7 @@
-
 module UCB
   module LDAP
     # = UCB::LDAP::StudentTerm
-    # 
+    #
     # This class models a student's term entries in the UCB LDAP directory.
     #
     #   terms = StudentTerm.find_by_uid("1234")       #=> [#<UCB::LDAP::StudentTerm: ...>, ...]
@@ -13,7 +12,7 @@ module UCB
     #   terms = p.student_terms        #=> [#<UCB::LDAP::StudentTerm: ...>, ...]
     #
     # == Note on Binds
-    # 
+    #
     # You must have a privileged bind and pass your credentials to UCB::LDAP.authenticate()
     # before performing your StudentTerm search.
     #
@@ -23,79 +22,78 @@ module UCB
       def change_datetime
         UCB::LDAP.local_datetime_parse(berkeleyEduStuChangeDate)
       end
-      
+
       def college_code
         berkeleyEduStuCollegeCode
       end
-      
+
       def college_name
         berkeleyEduStuCollegeName
       end
-      
+
       def level_code
         berkeleyEduStuEduLevelCode
       end
-      
+
       def level_name
         berkeleyEduStuEduLevelName
       end
-      
+
       def role_code
         berkeleyEduStuEduRoleCode
       end
-      
+
       def role_name
         berkeleyEduStuEduRoleName
       end
-      
+
       def major_code
         berkeleyEduStuMajorCode
       end
-      
+
       def major_name
         berkeleyEduStuMajorName
       end
-      
+
       def registration_status_code
         berkeleyEduStuRegStatCode
       end
-      
+
       def registration_status_name
         berkeleyEduStuRegStatName
       end
-      
+
       def term_code
         berkeleyEduStuTermCode
       end
-      
+
       def term_name
         berkeleyEduStuTermName
       end
-      
+
       def term_status
         berkeleyEduStuTermStatus
       end
-      
+
       def term_year
         berkeleyEduStuTermYear
       end
-      
+
       def under_graduate_code
         berkeleyEduStuUGCode
       end
-      
-      class << self
-        # Returns an Array of JobAppointment for <tt>uid</tt>, sorted by
-        # record_number().
-        # Returns an empty Array ([]) if nothing is found.  
-        #
-        def find_by_uid(uid)
-          base = "uid=#{uid},ou=people,dc=berkeley,dc=edu"
-          filter = Net::LDAP::Filter.eq("objectclass", 'berkeleyEduPersonTerm')
-          search(:base => base, :filter => filter)
-        end
-         
+
+      ##
+      # Returns an Array of JobAppointment for <tt>uid</tt>, sorted by
+      # record_number().
+      # Returns an empty Array ([]) if nothing is found.
+      #
+      def self.find_by_uid(uid)
+        base = "uid=#{uid},ou=people,dc=berkeley,dc=edu"
+        filter = Net::LDAP::Filter.eq("objectclass", 'berkeleyEduPersonTerm')
+        search(:base => base, :filter => filter)
       end
+
     end
   end
-end
+end

data/lib/ucb_ldap/version.rb

@@ -0,0 +1,3 @@
+module UcbLdap
+  VERSION = "2.0.0.pre3"
+end

data/spec/rails_binds.yml

@@ -0,0 +1,9 @@
+# Used for testing Rails binds -- these aren't real credentials
+development:
+    username: username_development
+    password: password_development
+  
+production:
+    username: username_production
+    password: password_production
+

data/spec/spec_helper.rb

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'rspec'
+require_relative "../lib/ucb_ldap"
+
+RSpec.configure do |config|
+  # config block
+end
+
+$TESTING = true
+
+include UCB::LDAP
+UCB::LDAP.host = "ldap-test.berkeley.edu"
+
+$binds ||= YAML.load(IO.read("#{File.dirname(__FILE__)}/binds.yml"))
+
+def bind_for(bind_key)
+  bind = $binds[bind_key] or raise("No bind found for '#{bind_key}'")
+  UCB::LDAP.authenticate(bind["username"], bind["password"])
+end
+
+def address_bind
+  bind_for("address")
+end
+
+def job_appointment_bind
+  bind_for("job_appointment")
+end
+
+def namespace_bind
+  bind_for("namespace")
+end
+
+def org_bind
+  bind_for("org")
+end
+
+def affiliation_bind
+  bind_for("affiliation")
+end
+
+def service_bind
+  bind_for("affiliation")
+end

data/spec/ucb_ldap/address_spec.rb

@@ -0,0 +1,54 @@
+require_relative "../spec_helper"
+
+
+describe "UCB::LDAP::Address" do
+  before(:all) do
+    address_bind
+  end
+
+  before(:each) do
+    # assumes 'sh' has 1 address, 'ba' has 1
+    @sh_addresses = Address.find_by_uid('61065')
+    @ba_addresses = Address.find_by_uid('230455')
+  end
+  
+  after(:all) do
+    UCB::LDAP.clear_authentication
+  end
+  
+  it "should find addresses by uid" do
+    @sh_addresses.should be_instance_of(Array)
+    @sh_addresses.first.should be_instance_of(Address)
+    @sh_addresses.size.should == 1
+    
+    @ba_addresses.size.should == 1
+  end
+
+  it "should know primary work address" do
+    @sh_addresses.first.should be_primary_work_address
+    
+    @ba_addresses.each do |addr|
+      addr.should(be_primary_work_address) if addr.berkeleyEduPersonAddressPrimaryFlag
+      addr.should_not(be_primary_work_address) if !addr.berkeleyEduPersonAddressPrimaryFlag
+    end
+  end
+  
+  it "should return addresses in sort order" do
+    [@sh_addresses, @ba_addresses].each do |addresses|
+      addresses.each_with_index do |addr, i|
+        addr.sort_order.should == (i + 1)
+      end
+    end
+  end
+
+#  it "should print itself" do
+#    [@sh_addresses, @ba_addresses].flatten.each do |a|
+#      puts "----"
+#      a.attributes.keys.sort_by{|k|k.to_s}.each do |k|
+#        puts "#{k}: #{a.attributes[k].inspect}"#, a.send(k).inspect
+#      end
+#    end
+#  end
+  
+end
+

data/spec/ucb_ldap/affiliation_spec.rb

@@ -0,0 +1,85 @@
+require_relative "../spec_helper"
+
+
+describe "UCB::LDAP::Affiliation" do
+  before(:all) do
+    affiliation_bind
+    @uid = "61065"
+    @student = Person.find_by_uid(@uid)
+    @datetime_string = '20010203040506Z'
+    @datetime_expected = '2001-02-02T20:05:06-08:00'
+    @date_expected = '2001-02-02'
+  end
+
+  after(:all) do
+    UCB::LDAP.clear_authentication
+  end
+
+  it "should find affiliations by uid" do
+    Affiliation.find_by_uid(@uid).class.should == Array
+  end
+  
+  it "should find affiliations from Person" do
+    @student.affiliations.class.should == Array
+  end
+  
+  it "should return create_datetime" do
+    Affiliation.new({}).create_datetime.should be_nil
+    Affiliation.new(:berkeleyEduAffCreateDate => [@datetime_string]).create_datetime.to_s.should == @datetime_expected
+  end
+  
+  it "should return expired_by" do
+    Affiliation.new({}).expired_by.should be_nil
+    Affiliation.new(:berkeleyEduAffExpBy => ['foo']).expired_by.to_s.should == 'foo'    
+  end
+  
+  it "should return expiration_date" do
+    Affiliation.new({}).expiration_date.should be_nil
+    Affiliation.new(:berkeleyEduAffExpDate => [@datetime_string]).expiration_date.to_s.should == @date_expected
+  end
+  
+  it "should return affiliate_id" do
+    Affiliation.new({}).affiliate_id.should be_nil
+    Affiliation.new(:berkeleyEduAffID => ['foo']).affiliate_id.to_s.should == 'foo'    
+  end
+  
+  it "should return affiliate_type" do
+    Affiliation.new({}).affiliate_type.should be_nil
+    Affiliation.new(:berkeleyEduAffType => ['foo']).affiliate_type.to_s.should == 'foo'    
+  end
+  
+  it "should return first_name" do
+    Affiliation.new({}).first_name.should be_nil
+    Affiliation.new(:givenName => ['foo']).first_name.to_s.should == 'foo'    
+  end
+  
+  it "should return middle_name" do
+    Affiliation.new({}).middle_name.should be_nil
+    Affiliation.new(:berkeleyEduMiddleName => ['foo']).middle_name.to_s.should == 'foo'    
+  end
+  
+  it "should return last_name" do
+    Affiliation.new({}).last_name.should be_nil
+    Affiliation.new(:sn => ['foo']).last_name.to_s.should == 'foo'    
+  end
+  
+  it "should return modified_by" do
+    Affiliation.new({}).modified_by.should be_nil
+    Affiliation.new(:berkeleyEduModifiedBy => ['foo']).modified_by.to_s.should == 'foo'    
+  end
+  
+  it "should return source" do
+    Affiliation.new({}).source.should be_nil
+    Affiliation.new(:berkeleyEduPersonAffiliateSource => ['foo']).source.to_s.should == 'foo'    
+  end
+  
+  it "should return dept_code" do
+    Affiliation.new({}).dept_code.should be_nil
+    Affiliation.new(:departmentNumber => ['foo']).dept_code.to_s.should == 'foo'    
+  end
+  
+  it "should return dept_name" do
+    Affiliation.new({}).dept_name.should be_nil
+    Affiliation.new(:berkeleyEduUnitCalNetDeptName => ['foo']).dept_name.to_s.should == 'foo'    
+  end
+end

data/spec/ucb_ldap/entry_spec.rb

@@ -0,0 +1,241 @@
+require_relative '../spec_helper'
+
+
+describe UCB::LDAP::Entry do
+  before(:each) do
+    Entry.stub!(:entity_name).and_return("org")
+    Entry.schema_attributes_array # force load
+  end
+
+  it "should make canonical attribute names" do
+    Entry.canonical("firstLast").should == :firstlast
+    Entry.canonical("FIRSTLAST").should == :firstlast
+    Entry.canonical(:FIRSTLAST).should == :firstlast
+  end
+
+  it "should return an Array of object_classes" do
+    Entry.object_classes.should == %w{top organizationalunit berkeleyEduOrgUnit}
+  end
+
+  it "should return unique object class" do
+    Entry.unique_object_class.should == 'berkeleyEduOrgUnit'
+  end
+
+  it "should return an Array of Schema::Attribute" do
+    Entry.schema_attributes_array.should be_instance_of(Array)
+    Entry.schema_attributes_array[0].should be_instance_of(Schema::Attribute)
+  end
+
+  it "schema_attribute works by name, alias, symbol, any-case version of same" do
+    fax_attr = Entry.schema_attributes_array.find { |attr| attr.name == "facsimileTelephoneNumber" }
+    fax_attr.aliases.should == ["fax"]
+    ["facsimileTelephoneNumber", "facsimiletelephonenumber",
+     "fax", "FAX", :fax].each do |version|
+      Entry.schema_attribute(version).should equal(fax_attr)
+    end
+  end
+
+  it "should raise exception trying to access bad attribute name" do
+    lambda { Entry.schema_attribute("bogus") }.should raise_error(BadAttributeNameException)
+  end
+
+  it "should know which of its attributes are required" do
+    # commonname is an alias for cn
+    # userid is an alias for uid
+    # surname is an alias for sn
+    # aliases should not show up in the required attributes
+    required_person_attributes = [:cn, :objectclass, :sn, :uid]
+
+    TestPerson = Class.new(Entry)
+    TestPerson.stub!(:entity_name).and_return("person")
+    TestPerson.required_attributes.length.should == required_person_attributes.length
+    TestPerson.required_attributes.each do |attr|
+      required_person_attributes.should include(attr)
+    end
+  end
+end
+
+
+describe "UCB::LDAP::Entry instance" do
+  before(:each) do
+    Entry.stub!(:entity_name).and_return("org")
+    Entry.schema_attributes_array # force load
+    @e = Entry.new("facsimileTelephoneNumber" => ["1", "2"], :dn => ["dn"])
+  end
+
+  it "should make canonical attribute names" do
+    @e.canonical("firstLast").should == :firstlast
+    @e.canonical("FIRSTLAST").should == :firstlast
+    @e.canonical(:FIRSTLAST).should == :firstlast
+  end
+
+  it "should return dn (Distinguished Name)" do
+    @e.dn.should == ["dn"]
+  end
+
+  it "should raise NoMethodError if bad attribute name treated like method" do
+    lambda { @e.bogus }.should raise_error(NoMethodError)
+  end
+
+  it "should retrieve values by 'official' attribute name as instance method" do
+    @e.facsimileTelephoneNumber.should == ["1", "2"]
+  end
+
+  it "should retrieve values by any-cased name as instance method" do
+    @e.facsimiletelephonenumber.should == ["1", "2"]
+  end
+
+  it "should retrieve values by alias" do
+    @e.fax.should == ["1", "2"]
+  end
+
+  it "should return scalar result for scalars" do
+    @e = Entry.new("berkeleyEduOrgUnitProcessUnitFlag" => ["true"])
+    @sa = Entry.schema_attribute("berkeleyEduOrgUnitProcessUnitFlag")
+    @e.berkeleyEduOrgUnitProcessUnitFlag.should be_true
+  end
+
+  it "should return array result for multi-valued attributes" do
+    @e.facsimileTelephoneNumber.should == ["1", "2"]
+  end
+
+  it "setter methods end in '='" do
+    @e.send(:setter_method?, :foo=).should be_true
+    @e.send(:setter_method?, "foo=").should be_true
+    @e.send(:setter_method?, :foo).should be_false
+    @e.send(:setter_method?, "foo").should be_false
+  end
+end
+
+
+describe "Setting UCB::LDAP::Namespace attributes" do
+  before(:all) do
+    namespace_bind # _setup_specs.rb
+  end
+
+  before(:each) do
+    @namespace = Namespace.find_by_uid("61065").first
+  end
+
+  after(:all) do
+    UCB::LDAP.clear_authentication
+  end
+
+  it "should set assigned attributes when set w/scalar" do
+    @namespace.cn = "a_name"
+    @namespace.assigned_attributes[:cn].should == ["a_name"]
+  end
+
+  it "should set assigned attributes when set w/array" do
+    @namespace.cn = ["a", "b"]
+    @namespace.assigned_attributes[:cn].should == ["a", "b"]
+  end
+
+  it "should set assigned attributes when set w/nil" do
+    @namespace.cn = nil
+    @namespace.assigned_attributes[:cn].should be_nil
+  end
+
+  it "should trim leading/trailing spaces and imbedded newlines" do
+    @namespace.cn = " foo\nbar "
+    @namespace.assigned_attributes[:cn].should == ['foobar']
+  end
+
+  it "should set modify operations correctly" do
+    @namespace.cn = ["CN"]
+    @namespace.uid = nil
+    @namespace.berkeleyEduServices = ["s1", "s2"]
+    @namespace.modify_operations.should == [
+        [:replace, :berkeleyeduservices, ["s1", "s2"]],
+        [:replace, :cn, ["CN"]],
+        [:delete, :uid, nil]
+    ]
+  end
+end
+
+
+describe "Updating UCB::LDAP::Namespace entries" do
+  before(:all) do
+    UCB::LDAP.host == HOST_TEST
+    namespace_bind
+  end
+
+  before(:each) do
+    @uid = '61065'
+    @cn = 'test_add'
+    @dn_base = 'ou=names,ou=namespace,dc=berkeley,dc=edu'
+    delete_by_cn(@cn)
+  end
+
+  after(:all) do
+    UCB::LDAP.clear_authentication
+  end
+
+  def delete_by_cn(cn)
+    Namespace.find_by_cn(cn).delete rescue nil
+  end
+
+  def add_entry(cn, services="calnet", method="create")
+    dn = "cn=#{cn},#{@dn_base}"
+    attrs = { :cn => @cn, :berkeleyEduServices => services, :uid => @uid }
+    Namespace.send(method, :dn => dn, :attributes => attrs)
+  end
+
+  it "create should return new entry on success, false on failure" do
+    pending "Need to Fix Ldap Permissions"
+
+    Namespace.find_by_cn(@cn).should be_nil
+    ns = add_entry(@cn)
+    ns.class.should == Namespace
+    ns.cn.should == [@cn]
+    ns.services.should == ['calnet']
+    add_entry(@cn).should be_false
+  end
+
+  it "create! should return new entry on success, raise error on failure" do
+    pending "Need to Fix Ldap Permissions"
+
+    Namespace.find_by_cn(@cn).should be_nil
+    ns = add_entry(@cn, 'calmail', "create!")
+    ns.should be_instance_of(Namespace)
+    ns.cn.should == [@cn]
+    lambda { add_entry(@cn, 'calnet', "create!") }.should raise_error(DirectoryNotUpdatedException)
+  end
+
+  it "update_attributes should return true on success, false on failure" do
+    pending "Need to Fix Ldap Permissions"
+
+    ns = add_entry(@cn)
+    ns.services.should == ['calnet']
+    ns.update_attributes(:berkeleyEduServices => ['calmail', 'calnet']).should be_true
+    ns.services.should == ['calmail', 'calnet']
+    ns.update_attributes(:berkeleyEduServices => ["calmail", "calmail"]).should be_false
+  end
+
+  it "update_attributes! should raise error on failure" do
+    pending "Need to Fix Ldap Permissions"
+
+    ns = add_entry(@cn)
+    ns.services.should == ['calnet']
+    ns.update_attributes!(:berkeleyEduServices => "calmail").should be_true
+    ns.services.should == ['calmail']
+    lambda { ns.update_attributes!(:berkeleyEduServices => ["calmail", "calmail"]) }.should raise_error(DirectoryNotUpdatedException)
+  end
+
+  it "delete should return true on success and false on failure" do
+    pending "Need to Fix Ldap Permissions"
+
+    ns = add_entry(@cn)
+    ns.delete.should be_true
+    ns.delete.should be_false
+  end
+
+  it "delete! should return true on success, raise DirectoryNotUpdated on failure" do
+    pending "Need to Fix Ldap Permissions"
+
+    ns = add_entry(@cn)
+    ns.delete!.should be_true
+    lambda { ns.delete! }.should raise_error(DirectoryNotUpdatedException)
+  end
+end
+