ucb_ldap 2.0.0 → 3.0.0

data/spec/ucb_ldap/schema_attribute_spec.rb

@@ -1,122 +0,0 @@
-require_relative "../spec_helper"
-
-
-describe "The UCB::LDAP::Schema::Attribute constructor" do
-  it "should set name instance variable" do
-    UCB::LDAP::Schema::Attribute.new("name" => "attr_name").name.should == "attr_name"
-  end
-
-  it "should set type instance variable" do
-    UCB::LDAP::Schema::Attribute.new("syntax" => "string").type.should == "string"
-  end
-
-  it "should set description instance variable" do
-    UCB::LDAP::Schema::Attribute.new("description" => "attr_descr").description.should == "attr_descr"
-  end
-
-  it "should aliases instance variable (empty and present)" do
-    UCB::LDAP::Schema::Attribute.new({}).aliases.should == []
-    UCB::LDAP::Schema::Attribute.new("aliases" => ["a", "b"]).aliases.should == ["a", "b"]
-  end
-  
-  it "should set required instance variable" do
-    UCB::LDAP::Schema::Attribute.new("required" => true).required?.should be_true
-    UCB::LDAP::Schema::Attribute.new("required" => false).required?.should be_false
-  end
-
-  it "should set multi_valued instance variable" do
-    UCB::LDAP::Schema::Attribute.new("multi" => true).multi_valued?.should be_true
-    UCB::LDAP::Schema::Attribute.new("multi" => false).multi_valued?.should be_false
-  end
-end
-
-
-describe "Schema::Attribute get_value() for multi_valued" do
-  it "should return array when multi_valued" do
-    Schema::Attribute.new("multi" => true, "syntax" => "string").get_value(%w{1 2}).should == %w{1 2}
-  end
-
-  it "should return empty array when multi_valued and no value" do
-    Schema::Attribute.new("multi" => true, "syntax" => "string").get_value(nil).should == []
-  end
-end
-
-
-describe "Schema::Attribute get_value() for not multi_valued" do
-  it "should return scalar when not multi_valued" do
-    Schema::Attribute.new("multi" => false, "syntax" => "string").get_value(%w{1}).should == "1"
-  end
-
-  it "should return nil when not multi_valued and no value" do
-    Schema::Attribute.new("multi" => false).get_value(nil).should be_nil
-  end
-end
-
-
-describe "Schema::Attribute get_value() for string" do
-  it "returns string" do
-    Schema::Attribute.new("syntax" => "string", "multi" => true).get_value(%w{1 2}).should == ["1", "2"]
-    Schema::Attribute.new("syntax" => "string", "multi" => false).get_value(%w{1}).should == "1"
-  end
-end
-
-
-describe "Schema::Attribute get_value() for integer" do
-  it "returns integer" do
-    Schema::Attribute.new("syntax" => "integer", "multi" => true).get_value(%w{1 2}).should == [1, 2]
-    Schema::Attribute.new("syntax" => "integer", "multi" => false).get_value(%w{1}).should == 1
-  end
-end
-
-
-describe "Schema::Attribute get_value() for boolean" do
-  it "returns boolean" do
-    Schema::Attribute.new("syntax" => "boolean").get_value(["true"]).should be_true
-    Schema::Attribute.new("syntax" => "boolean").get_value(["1"]).should be_true
-    Schema::Attribute.new("syntax" => "boolean").get_value(["false"]).should be_false
-    Schema::Attribute.new("syntax" => "boolean").get_value([""]).should be_false
-    Schema::Attribute.new("syntax" => "boolean").get_value(nil).should be_false
-  end
-end
-
-
-describe "Schema::Attribute get_value() for timestamp" do
-  it "returns Date" do
-    schema_attribute = Schema::Attribute.new("syntax" => "timestamp")
-    datetime = schema_attribute.get_value(["19980101123456Z"])
-    datetime.class.should == DateTime
-    datetime.to_s.should == "1998-01-01T04:34:56-08:00"
-    
-    schema_attribute.get_value(nil).should be_nil
-  end
-end
-
-
-describe "Schema::Attribute ldap_value()" do
-  before do
-    @a = Schema::Attribute.new({})
-  end
-  
-  it "should return an Array when given an Array" do
-    @a.ldap_value(["foo"]).should == ["foo"]  
-  end
-  
-  it "should return an Array when given a scalar" do
-    @a.ldap_value("foo").should == ["foo"]
-  end
-  
-  it "should return Array of String regardless of input type" do
-    @a.ldap_value(1).should == ["1"]
-    @a.ldap_value([1, true, "three"]).should == ["1", "true", "three"]
-  end
-  
-  it "should return nil when passed nil" do
-    @a.ldap_value(nil).should be_nil
-  end
-
-  it "should remove leading/trailing spaces, any newlines" do
-    @a.ldap_value(' foo').should == ['foo']  
-    @a.ldap_value('foo ').should == ['foo']  
-    @a.ldap_value("f\noo").should == ['foo']  
-  end
-end

data/spec/ucb_ldap/schema_spec.rb

@@ -1,104 +0,0 @@
-require_relative "../spec_helper"
-
-
-describe "UCB::LDAP::Schema" do
-  before(:all) do
-    @schema_yaml = IO.read(Schema::SCHEMA_FILE)
-  end
-  
-  before(:each) do
-    Schema.schema_hash = nil
-    Schema.schema_file = nil
-    Schema.schema_base_url = nil
-    Schema.schema_content_path = nil 
-  end
-  
-  it "should define SCHEMA_URL" do
-    Schema::SCHEMA_BASE_URL.class.should == String
-  end
-  
-  it "schema_base_url() should default to SCHEMA_BASE_URL constant" do
-    Schema.schema_base_url.should == Schema::SCHEMA_BASE_URL  
-  end
-  
-  it "schema_base_url() can be reset" do
-    Schema.schema_base_url = "foo"
-    Schema.schema_base_url.should == "foo"  
-  end
-  
-  it "schema_content_path() should default to SCHEMA_CONTENT_PATH constant" do
-    Schema.schema_content_path.should == Schema::SCHEMA_CONTENT_PATH  
-  end
-  
-  it "schema_content_path() can be reset" do
-    Schema.schema_content_path = "foo"
-    Schema.schema_content_path.should == "foo"  
-  end
-  
-  it "should get schema yaml from url" do
-    @yaml = Schema.yaml_from_url
-    %w{person: org:}.each do |entity|
-      @yaml.should include(entity)
-    end
-  end
-  
-  it "should load attributes from url" do
-    Schema.schema_hash_i.should be_nil
-    Schema.should_receive(:yaml_from_url).and_return(@schema_yaml)
-    Schema.load_attributes_from_url
-    verify_schema_hash
-  end
-  
-  it "should define SCHEMA_FILE" do
-    Schema::SCHEMA_FILE.class.should == String
-  end
-  
-  it "schema_file() should default to SCHEMA_FILE constant" do
-    Schema.schema_file.should == Schema::SCHEMA_FILE
-  end
-  
-  it "schema_file() can be reset" do
-    Schema.schema_file = "foo"
-    Schema.schema_file.should == "foo"  
-  end
-  
-  it "should get schema yaml from file" do
-    yaml = Schema.yaml_from_file
-    verify_yaml(yaml)
-  end
-  
-  it "should load attributes from file" do
-    Schema.schema_hash_i.should be_nil
-    Schema.load_attributes_from_file
-    verify_schema_hash
-  end
-  
-  it "should load_attributes from url if available" do
-    Schema.schema_hash_i.should be_nil
-    Schema.should_receive(:yaml_from_url).and_return(@schema_yaml)
-    Schema.should_not_receive(:load_attributes_from_file)
-    UCB::LDAP::Schema.load_attributes
-    verify_schema_hash
-  end
-
-  it "should load_attributes from local file if url data not available" do
-    Schema.schema_hash_i.should be_nil
-    Schema.should_receive(:load_attributes_from_url).and_raise("schema unavailable from url")
-    Schema.load_attributes
-    verify_schema_hash
-  end
-
-  # Verify we have something that looks like the schema yaml file
-  def verify_yaml(yaml)
-    yaml.should be_instance_of(String)
-    yaml.should have_at_least(40_000).characters
-    %w{person: personAddress: syntax:}.each{|s| yaml.should include(s)}
-  end
-
-  # Verify schema_hash looks right
-  def verify_schema_hash
-    Schema.schema_hash_i.should be_instance_of(Hash)
-    %w{person org}.each{|e| Schema.schema_hash.keys.should include(e)}
-  end
-
-end

data/spec/ucb_ldap/service_spec.rb

@@ -1,127 +0,0 @@
-require_relative "../spec_helper"
-
-
-describe UCB::LDAP::Service do
-  before(:all) do
-    service_bind
-    @student_uid = "61065"
-    @student = Person.find_by_uid(@student_uid)
-    @dt_str = '20010203080000Z'
-    @dt_exp = '2001-02-03T00:00:00-08:00'
-  end
-
-  after(:all) do
-    UCB::LDAP.clear_authentication
-  end
-
-  it "find_by_uid(uid) should return terms" do
-    Service.find_by_uid(@student_uid).class.should == Array
-  end
-  
-  it "Person should find services" do
-    @student.services.class.should == Array
-  end
-  
-  it "should return eligible_by" do
-    Service.new({}).eligible_by.should be_nil
-    Service.new({:berkeleyEduPersonServiceEligibleBy => ['foo']}).eligible_by.should == 'foo'
-  end
-  
-  it "should return eligible_date" do
-    Service.new({}).eligible_date.should be_nil
-    s = Service.new({:berkeleyEduPersonServiceEligibleDate => [@dt_str]})
-    s.eligible_date.class.should == DateTime
-    s.eligible_date.to_s.should == @dt_exp
-  end
-  
-  it "should return ended_by" do
-    Service.new({}).ended_by.should be_nil
-    Service.new({:berkeleyEduPersonServiceEndBy => ['foo']}).ended_by.should == 'foo'
-  end
-  
-  it "should return end_date" do
-    Service.new({}).end_date.should be_nil
-    s = Service.new({:berkeleyEduPersonServiceEndDate => [@dt_str]})
-    s.end_date.class.should == DateTime
-    s.end_date.to_s.should == @dt_exp
-  end
-  
-  it "should return entered_by" do
-    Service.new({}).entered_by.should be_nil
-    Service.new({:berkeleyEduPersonServiceEnteredBy => ['foo']}).entered_by.should == 'foo'
-  end
-  
-  it "should return entered_date" do
-    Service.new({}).entered_date.should be_nil
-    s = Service.new({:berkeleyEduPersonServiceEnteredDate => [@dt_str]})
-    s.entered_date.class.should == DateTime
-    s.entered_date.to_s.should == @dt_exp
-  end
-  
-  it "should return level" do
-    Service.new({}).level.should be_nil
-    Service.new({:berkeleyEduPersonServiceLevel => ['42']}).level.should == 42
-  end
-  
-  it "should return modified_by" do
-    Service.new({}).modified_by.should be_nil
-    Service.new({:berkeleyEduPersonServiceModifiedBy => ['foo']}).modified_by.should == 'foo'
-  end
-  
-  it "should return modified_date" do
-    Service.new({}).modified_date.should be_nil
-    s = Service.new({:berkeleyEduPersonServiceModifiedDate => [@dt_str]})
-    s.modified_date.class.should == DateTime
-    s.modified_date.to_s.should == @dt_exp
-  end
-  
-  it "should return naughty_bit" do
-    Service.new({}).naughty_bit.should be_false
-    Service.new({:berkeleyEduPersonServiceNaughtyBit => ['true']}).naughty_bit.should be_true
-  end
-  
-  it "should return notified_by" do
-    Service.new({}).notified_by.should be_nil
-    Service.new({:berkeleyEduPersonServiceNotifyBy => ['foo']}).notified_by.should == 'foo'
-  end
-  
-  it "should return notify_date" do
-    Service.new({}).notify_date.should be_nil
-    s = Service.new({:berkeleyEduPersonServiceNotifyDate => [@dt_str]})
-    s.notify_date.class.should == DateTime
-    s.notify_date.to_s.should == @dt_exp
-  end
-  
-  it "should return stopped_by" do
-    Service.new({}).stopped_by.should be_nil
-    Service.new({:berkeleyEduPersonServiceStopBy => ['foo']}).stopped_by.should == 'foo'
-  end
-  
-  it "should return stop_date" do
-    Service.new({}).stop_date.should be_nil
-    s = Service.new({:berkeleyEduPersonServiceStopDate => [@dt_str]})
-    s.stop_date.class.should == DateTime
-    s.stop_date.to_s.should == @dt_exp
-  end
-  
-  it "should return value" do
-    Service.new({}).value.should be_nil
-    Service.new({:berkeleyEduPersonServiceValue => ['foo']}).value.should == 'foo'
-  end
-  
-  it "should return service" do
-    Service.new({}).service.should be_nil
-    Service.new({:berkeleyEduService => ['foo']}).service.should == 'foo'
-  end
-  
-  it "should return common_name" do
-    Service.new({}).common_name.should == []
-    Service.new({:cn => ['foo']}).common_name.should == ['foo']
-  end
-  
-  it "should return description" do
-    Service.new({}).description.should be_nil
-    Service.new({:description => ['foo']}).description.should == 'foo'
-  end
-end
-  

data/spec/ucb_ldap/student_term_spec.rb

@@ -1,121 +0,0 @@
-require_relative "../spec_helper"
-
-describe "UCB::LDAP::StudentTerm" do
-  before(:all) do
-    job_appointment_bind
-    @student_uid = "191501"
-    @student = Person.find_by_uid(@student_uid)
-    @datetime_string = '20010203040506Z'
-    @date_expected = '2001-02-03'
-    @datetime_expected = '2001-02-02T20:05:06-08:00'
-  end
-
-  before(:each) do
-  end
-  
-  after(:all) do
-    UCB::LDAP.clear_authentication
-  end
-
-  it "find_by_uid(uid) should return terms" do
-    StudentTerm.find_by_uid(@student_uid).class.should == Array
-  end
-  
-  it "should be able to get terms from UCB::LDAP::Person instance" do
-    @student.student_terms.class.should == Array
-  end
-  
-  it "returns change_datetime" do
-    StudentTerm.new({}).change_datetime.should be_nil
-    StudentTerm.new({:berkeleyEduStuChangeDate => [@datetime_string]}).change_datetime.to_s.should == @datetime_expected
-  end
-  
-  it "returns college_code" do
-    StudentTerm.new({}).college_code.should be_nil
-    StudentTerm.new({:berkeleyEduStuCollegeCode => ['foo']}).college_code.should == 'foo'
-  end
-    
-  it "returns college_name" do
-    StudentTerm.new({}).college_name.should be_nil
-    StudentTerm.new({:berkeleyEduStuCollegeName => ['foo']}).college_name.should == 'foo'
-  end
-
-  it "returns level_code" do
-    StudentTerm.new({}).level_code.should be_nil
-    StudentTerm.new({:berkeleyEduStuEduLevelCode => ['foo']}).level_code.should == 'foo'
-  end
-
-  
-  it "returns level_name" do
-    StudentTerm.new({}).level_name.should be_nil
-    StudentTerm.new({:berkeleyEduStuEduLevelName => ['foo']}).level_name.should == 'foo'
-  end
-
-  
-  it "returns role_code" do
-    StudentTerm.new({}).role_code.should be_nil
-    StudentTerm.new({:berkeleyEduStuEduRoleCode => ['foo']}).role_code.should == 'foo'
-  end
-
-  
-  it "returns role_name" do
-    StudentTerm.new({}).role_name.should be_nil
-    StudentTerm.new({:berkeleyEduStuEduRoleName => ['foo']}).role_name.should == 'foo'
-  end
-
-  
-  it "returns major_code" do
-    StudentTerm.new({}).major_code.should be_nil
-    StudentTerm.new({:berkeleyEduStuMajorCode => ['foo']}).major_code.should == 'foo'
-  end
-
-  
-  it "returns major_name" do
-    StudentTerm.new({}).major_name.should be_nil
-    StudentTerm.new({:berkeleyEduStuMajorName => ['foo']}).major_name.should == 'foo'
-  end
-
-  
-  it "returns registration_status_code" do
-    StudentTerm.new({}).registration_status_code.should be_nil
-    StudentTerm.new({:berkeleyEduStuRegStatCode => ['foo']}).registration_status_code.should == 'foo'
-  end
-
-  
-  it "returns registration_status_name" do
-    StudentTerm.new({}).registration_status_name.should be_nil
-    StudentTerm.new({:berkeleyEduStuRegStatName => ['foo']}).registration_status_name.should == 'foo'
-  end
-
-  
-  it "returns term_code" do
-    StudentTerm.new({}).term_code.should be_nil
-    StudentTerm.new({:berkeleyEduStuTermCode => ['foo']}).term_code.should == 'foo'
-  end
-
-  
-  it "returns term_name" do
-    StudentTerm.new({}).term_name.should be_nil
-    StudentTerm.new({:berkeleyEduStuTermName => ['foo']}).term_name.should == 'foo'
-  end
-
-  
-  it "returns term_status" do
-    StudentTerm.new({}).term_status.should be_nil
-    StudentTerm.new({:berkeleyEduStuTermStatus => ['foo']}).term_status.should == 'foo'
-  end
-
-  
-  it "returns term_year" do
-    StudentTerm.new({}).term_year.should be_nil
-    StudentTerm.new({:berkeleyEduStuTermYear => ['2000']}).term_year.should == 2000
-  end
-
-  
-  it "returns under_graduate_code" do
-    StudentTerm.new({}).under_graduate_code.should be_nil
-    StudentTerm.new({:berkeleyEduStuUGCode => ['foo']}).under_graduate_code.should == 'foo'
-  end
-
-end
-