net-ldap 0.3.1 → 0.17.0

data/spec/unit/ldap/filter_spec.rb

@@ -1,84 +0,0 @@
-require 'spec_helper'
-
-describe Net::LDAP::Filter do
-  describe "<- .ex(attr, value)" do
-    context "('foo', 'bar')" do
-      attr_reader :filter
-      before(:each) do
-        @filter = Net::LDAP::Filter.ex('foo', 'bar')
-      end
-      it "should convert to 'foo:=bar'" do
-        filter.to_s.should == '(foo:=bar)'
-      end 
-      it "should survive roundtrip via to_s/from_rfc2254" do
-        Net::LDAP::Filter.from_rfc2254(filter.to_s).should == filter
-      end 
-      it "should survive roundtrip conversion to/from ber" do
-        ber = filter.to_ber
-        Net::LDAP::Filter.parse_ber(ber.read_ber(Net::LDAP::AsnSyntax)).should ==
-          filter
-      end 
-    end
-    context "various legal inputs" do
-      [
-        '(o:dn:=Ace Industry)', 
-        '(:dn:2.4.8.10:=Dino)', 
-        '(cn:dn:1.2.3.4.5:=John Smith)', 
-        '(sn:dn:2.4.6.8.10:=Barbara Jones)',
-        '(&(sn:dn:2.4.6.8.10:=Barbara Jones))'
-      ].each do |filter_str|
-        context "from_rfc2254(#{filter_str.inspect})" do
-          attr_reader :filter
-          before(:each) do
-            @filter = Net::LDAP::Filter.from_rfc2254(filter_str)
-          end
-
-          it "should decode into a Net::LDAP::Filter" do
-            filter.should be_an_instance_of(Net::LDAP::Filter)
-          end 
-          it "should survive roundtrip conversion to/from ber" do
-            ber = filter.to_ber
-            Net::LDAP::Filter.parse_ber(ber.read_ber(Net::LDAP::AsnSyntax)).should ==
-              filter
-          end 
-        end
-      end
-    end
-  end
-  describe "<- .construct" do
-    it "should accept apostrophes in filters (regression)" do
-      Net::LDAP::Filter.construct("uid=O'Keefe").to_rfc2254.should == "(uid=O'Keefe)"
-    end 
-  end
-
-  describe "convenience filter constructors" do
-    def eq(attribute, value)
-      described_class.eq(attribute, value)
-    end
-    describe "<- .equals(attr, val)" do
-      it "should delegate to .eq with escaping" do
-        described_class.equals('dn', 'f*oo').should == eq('dn', 'f\2Aoo')
-      end 
-    end
-    describe "<- .begins(attr, val)" do
-      it "should delegate to .eq with escaping" do
-        described_class.begins('dn', 'f*oo').should == eq('dn', 'f\2Aoo*')
-      end 
-    end
-    describe "<- .ends(attr, val)" do
-      it "should delegate to .eq with escaping" do
-        described_class.ends('dn', 'f*oo').should == eq('dn', '*f\2Aoo')
-      end 
-    end
-    describe "<- .contains(attr, val)" do
-      it "should delegate to .eq with escaping" do
-        described_class.contains('dn', 'f*oo').should == eq('dn', '*f\2Aoo*')
-      end 
-    end
-  end
-  describe "<- .escape(str)" do
-    it "should escape nul, *, (, ) and \\" do
-      Net::LDAP::Filter.escape("\0*()\\").should == "\\00\\2A\\28\\29\\5C"
-    end 
-  end
-end

data/spec/unit/ldap_spec.rb

@@ -1,48 +0,0 @@
-require 'spec_helper'
-
-describe Net::LDAP::Connection do
-  describe "initialize" do
-    context "when host is not responding" do
-      before(:each) do
-        flexmock(TCPSocket).
-          should_receive(:new).and_raise(Errno::ECONNREFUSED)
-      end
-      
-      it "should raise LdapError" do
-        lambda {
-          Net::LDAP::Connection.new(
-            :server => 'test.mocked.com', 
-            :port   => 636)
-        }.should raise_error(Net::LDAP::LdapError)
-      end
-    end
-    context "when host is blocking the port" do
-      before(:each) do
-        flexmock(TCPSocket).
-          should_receive(:new).and_raise(SocketError)
-      end
-      
-      it "should raise LdapError" do
-        lambda {
-          Net::LDAP::Connection.new(
-            :server => 'test.mocked.com', 
-            :port   => 636)
-        }.should raise_error(Net::LDAP::LdapError)
-      end
-    end
-    context "on other exceptions" do
-      before(:each) do
-        flexmock(TCPSocket).
-          should_receive(:new).and_raise(NameError)
-      end
-      
-      it "should rethrow the exception" do
-        lambda {
-          Net::LDAP::Connection.new(
-            :server => 'test.mocked.com', 
-            :port   => 636)
-        }.should raise_error(NameError)
-      end
-    end
-  end
-end

data/test/common.rb

@@ -1,3 +0,0 @@
-# Add 'lib' to load path.
-require 'test/unit'
-require 'net/ldap'

data/test/test_entry.rb

@@ -1,59 +0,0 @@
-require 'common'
-
-=begin
-class TestEntry < Test::Unit::TestCase
-Commented out until I can make it a spec.
-  context "An instance of Entry" do
-    setup do
-      @entry = Net::LDAP::Entry.new 'cn=Barbara,o=corp'
-    end
-
-    should "be initialized with the DN" do
-      assert_equal 'cn=Barbara,o=corp', @entry.dn
-    end
-
-    should 'return an empty array when accessing a nonexistent attribute (index lookup)' do
-      assert_equal [], @entry['sn']
-    end
-
-    should 'return an empty array when accessing a nonexistent attribute (method call)' do
-      assert_equal [], @entry.sn
-    end
-
-    should 'create an attribute on assignment (index lookup)' do
-      @entry['sn'] = 'Jensen'
-      assert_equal ['Jensen'], @entry['sn']
-    end
-
-    should 'create an attribute on assignment (method call)' do
-      @entry.sn = 'Jensen'
-      assert_equal ['Jensen'], @entry.sn
-    end
-
-    should 'have attributes accessible by index lookup' do
-      @entry['sn'] = 'Jensen'
-      assert_equal ['Jensen'], @entry['sn']
-    end
-
-    should 'have attributes accessible using a Symbol as the index' do
-      @entry[:sn] = 'Jensen'
-      assert_equal ['Jensen'], @entry[:sn]
-    end
-
-    should 'have attributes accessible by method call' do
-      @entry['sn'] = 'Jensen'
-      assert_equal ['Jensen'], @entry.sn
-    end
-
-    should 'ignore case of attribute names' do
-      @entry['sn'] = 'Jensen'
-      assert_equal ['Jensen'], @entry.sn
-      assert_equal ['Jensen'], @entry.Sn
-      assert_equal ['Jensen'], @entry.SN
-      assert_equal ['Jensen'], @entry['sn']
-      assert_equal ['Jensen'], @entry['Sn']
-      assert_equal ['Jensen'], @entry['SN']
-    end
-	end
-end
-=end

data/test/test_filter.rb

@@ -1,122 +0,0 @@
-require 'common'
-
-class TestFilter < Test::Unit::TestCase
-  Filter = Net::LDAP::Filter
-
-  def test_bug_7534_rfc2254
-    assert_equal("(cn=Tim Wizard)",
-                 Filter.from_rfc2254("(cn=Tim Wizard)").to_rfc2254)
-  end
-
-  def test_invalid_filter_string
-    assert_raises(Net::LDAP::LdapError) { Filter.from_rfc2254("") }
-  end
-
-  def test_invalid_filter
-    assert_raises(Net::LDAP::LdapError) {
-      # This test exists to prove that our constructor blocks unknown filter
-      # types. All filters must be constructed using helpers.
-      Filter.__send__(:new, :xx, nil, nil)
-    }
-  end
-
-  def test_to_s
-    assert_equal("(uid=george *)", Filter.eq("uid", "george *").to_s)
-  end
-
-  def test_convenience_filters
-    assert_equal("(uid=\\2A)", Filter.equals("uid", "*").to_s)
-    assert_equal("(uid=\\28*)", Filter.begins("uid", "(").to_s)
-    assert_equal("(uid=*\\29)", Filter.ends("uid", ")").to_s)
-    assert_equal("(uid=*\\5C*)", Filter.contains("uid", "\\").to_s)	
-  end
-
-  def test_c2
-    assert_equal("(uid=george *)",
-                 Filter.from_rfc2254("uid=george *").to_rfc2254)
-    assert_equal("(uid:=george *)",
-                 Filter.from_rfc2254("uid:=george *").to_rfc2254)
-    assert_equal("(uid=george*)",
-                 Filter.from_rfc2254(" ( uid =  george*   ) ").to_rfc2254)
-    assert_equal("(!(uid=george*))",
-                 Filter.from_rfc2254("uid!=george*").to_rfc2254)
-    assert_equal("(uid<=george*)",
-                 Filter.from_rfc2254("uid <= george*").to_rfc2254)
-    assert_equal("(uid>=george*)",
-                 Filter.from_rfc2254("uid>=george*").to_rfc2254)
-    assert_equal("(&(uid=george*)(mail=*))",
-                 Filter.from_rfc2254("(& (uid=george* ) (mail=*))").to_rfc2254)
-    assert_equal("(|(uid=george*)(mail=*))",
-                 Filter.from_rfc2254("(| (uid=george* ) (mail=*))").to_rfc2254)
-    assert_equal("(!(mail=*))",
-                 Filter.from_rfc2254("(! (mail=*))").to_rfc2254)
-  end
-
-  def test_filter_with_single_clause
-    assert_equal("(cn=name)", Net::LDAP::Filter.construct("(&(cn=name))").to_s)
-  end
-
-  def test_filters_from_ber
-    [
-      Net::LDAP::Filter.eq("objectclass", "*"),
-      Net::LDAP::Filter.pres("objectclass"),
-      Net::LDAP::Filter.eq("objectclass", "ou"),
-      Net::LDAP::Filter.ge("uid", "500"),
-      Net::LDAP::Filter.le("uid", "500"),
-      (~ Net::LDAP::Filter.pres("objectclass")),
-      (Net::LDAP::Filter.pres("objectclass") & Net::LDAP::Filter.pres("ou")),
-      (Net::LDAP::Filter.pres("objectclass") & Net::LDAP::Filter.pres("ou") & Net::LDAP::Filter.pres("sn")),
-      (Net::LDAP::Filter.pres("objectclass") | Net::LDAP::Filter.pres("ou") | Net::LDAP::Filter.pres("sn")),
-
-      Net::LDAP::Filter.eq("objectclass", "*aaa"),
-      Net::LDAP::Filter.eq("objectclass", "*aaa*bbb"),
-      Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*ccc"),
-      Net::LDAP::Filter.eq("objectclass", "aaa*bbb"),
-      Net::LDAP::Filter.eq("objectclass", "aaa*bbb*ccc"),
-      Net::LDAP::Filter.eq("objectclass", "abc*def*1111*22*g"),
-      Net::LDAP::Filter.eq("objectclass", "*aaa*"),
-      Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*"),
-      Net::LDAP::Filter.eq("objectclass", "*aaa*bbb*ccc*"),
-      Net::LDAP::Filter.eq("objectclass", "aaa*"),
-      Net::LDAP::Filter.eq("objectclass", "aaa*bbb*"),
-      Net::LDAP::Filter.eq("objectclass", "aaa*bbb*ccc*"),
-    ].each do |ber|
-      f = Net::LDAP::Filter.parse_ber(ber.to_ber.read_ber(Net::LDAP::AsnSyntax))
-      assert(f == ber)
-      assert_equal(f.to_ber, ber.to_ber)
-    end
-  end
-
-  def test_ber_from_rfc2254_filter
-    [
-      Net::LDAP::Filter.construct("objectclass=*"),
-      Net::LDAP::Filter.construct("objectclass=ou"),
-      Net::LDAP::Filter.construct("uid >= 500"),
-      Net::LDAP::Filter.construct("uid <= 500"),
-      Net::LDAP::Filter.construct("(!(uid=*))"),
-      Net::LDAP::Filter.construct("(&(uid=*)(objectclass=*))"),
-      Net::LDAP::Filter.construct("(&(uid=*)(objectclass=*)(sn=*))"),
-      Net::LDAP::Filter.construct("(|(uid=*)(objectclass=*))"),
-      Net::LDAP::Filter.construct("(|(uid=*)(objectclass=*)(sn=*))"),
-
-      Net::LDAP::Filter.construct("objectclass=*aaa"),
-      Net::LDAP::Filter.construct("objectclass=*aaa*bbb"),
-      Net::LDAP::Filter.construct("objectclass=*aaa bbb"),
-      Net::LDAP::Filter.construct("objectclass=*aaa  bbb"),
-      Net::LDAP::Filter.construct("objectclass=*aaa*bbb*ccc"),
-      Net::LDAP::Filter.construct("objectclass=aaa*bbb"),
-      Net::LDAP::Filter.construct("objectclass=aaa*bbb*ccc"),
-      Net::LDAP::Filter.construct("objectclass=abc*def*1111*22*g"),
-      Net::LDAP::Filter.construct("objectclass=*aaa*"),
-      Net::LDAP::Filter.construct("objectclass=*aaa*bbb*"),
-      Net::LDAP::Filter.construct("objectclass=*aaa*bbb*ccc*"),
-      Net::LDAP::Filter.construct("objectclass=aaa*"),
-      Net::LDAP::Filter.construct("objectclass=aaa*bbb*"),
-      Net::LDAP::Filter.construct("objectclass=aaa*bbb*ccc*"),
-    ].each do |ber|
-      f = Net::LDAP::Filter.parse_ber(ber.to_ber.read_ber(Net::LDAP::AsnSyntax))
-      assert(f == ber)
-      assert_equal(f.to_ber, ber.to_ber)
-    end
-  end
-end

data/test/test_ldap_connection.rb

@@ -1,24 +0,0 @@
-require 'common'
-
-class TestLDAP < Test::Unit::TestCase
-  def test_modify_ops_delete
-    args = { :operations => [ [ :delete, "mail" ] ] }
-    result = Net::LDAP::Connection.modify_ops(args[:operations])
-    expected = [ "0\r\n\x01\x010\b\x04\x04mail1\x00" ]
-    assert_equal(expected, result)
-  end
-
-  def test_modify_ops_add
-    args = { :operations => [ [ :add, "mail", "testuser@example.com" ] ] }
-    result = Net::LDAP::Connection.modify_ops(args[:operations])
-    expected = [ "0#\n\x01\x000\x1E\x04\x04mail1\x16\x04\x14testuser@example.com" ]
-    assert_equal(expected, result)
-  end
-
-  def test_modify_ops_replace
-    args = { :operations =>[ [ :replace, "mail", "testuser@example.com" ] ] }
-    result = Net::LDAP::Connection.modify_ops(args[:operations])
-    expected = [ "0#\n\x01\x020\x1E\x04\x04mail1\x16\x04\x14testuser@example.com" ]
-    assert_equal(expected, result)
-  end
-end

data/test/test_ldif.rb

@@ -1,79 +0,0 @@
-# $Id: testldif.rb 61 2006-04-18 20:55:55Z blackhedd $
-
-require 'common'
-
-require 'digest/sha1'
-require 'base64'
-
-class TestLdif < Test::Unit::TestCase
-  TestLdifFilename = "#{File.dirname(__FILE__)}/testdata.ldif"
-
-  def test_empty_ldif
-    ds = Net::LDAP::Dataset.read_ldif(StringIO.new)
-    assert_equal(true, ds.empty?)
-  end
-
-  def test_ldif_with_comments
-    str = ["# Hello from LDIF-land", "# This is an unterminated comment"]
-    io = StringIO.new(str[0] + "\r\n" + str[1])
-    ds = Net::LDAP::Dataset::read_ldif(io)
-    assert_equal(str, ds.comments)
-  end
-
-  def test_ldif_with_password
-    psw = "goldbricks"
-    hashed_psw = "{SHA}" + Base64::encode64(Digest::SHA1.digest(psw)).chomp
-
-    ldif_encoded = Base64::encode64(hashed_psw).chomp
-    ds = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: Goldbrick\r\nuserPassword:: #{ldif_encoded}\r\n\r\n"))
-    recovered_psw = ds["Goldbrick"][:userpassword].shift
-    assert_equal(hashed_psw, recovered_psw)
-  end
-
-  def test_ldif_with_continuation_lines
-    ds = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: abcdefg\r\n hijklmn\r\n\r\n"))
-    assert_equal(true, ds.has_key?("abcdefghijklmn"))
-  end
-
-  def test_ldif_with_continuation_lines_and_extra_whitespace
-    ds1 = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: abcdefg\r\n   hijklmn\r\n\r\n"))
-    assert_equal(true, ds1.has_key?("abcdefg  hijklmn"))
-    ds2 = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: abcdefg\r\n hij  klmn\r\n\r\n"))
-    assert_equal(true, ds2.has_key?("abcdefghij  klmn"))
-  end
-
-  def test_ldif_tab_is_not_continuation
-    ds = Net::LDAP::Dataset::read_ldif(StringIO.new("dn: key\r\n\tnotcontinued\r\n\r\n"))
-    assert_equal(true, ds.has_key?("key"))
-  end
-
-  # TODO, INADEQUATE. We need some more tests
-  # to verify the content.
-  def test_ldif
-    File.open(TestLdifFilename, "r") {|f|
-      ds = Net::LDAP::Dataset::read_ldif(f)
-      assert_equal(13, ds.length)
-    }
-  end
-
-  # Must test folded lines and base64-encoded lines as well as normal ones.
-  def test_to_ldif
-    data = File.open(TestLdifFilename, "rb") { |f| f.read }
-    io = StringIO.new(data)
-
-    # added .lines to turn to array because 1.9 doesn't have
-    # .grep on basic strings
-    entries = data.lines.grep(/^dn:\s*/) { $'.chomp }
-    dn_entries = entries.dup
-
-    ds = Net::LDAP::Dataset::read_ldif(io) { |type, value|
-      case type
-      when :dn
-        assert_equal(dn_entries.first, value)
-        dn_entries.shift
-      end
-    }
-    assert_equal(entries.size, ds.size)
-    assert_equal(entries.sort, ds.to_ldif.grep(/^dn:\s*/) { $'.chomp })
-  end
-end

data/test/test_password.rb

@@ -1,17 +0,0 @@
-# $Id: testpsw.rb 72 2006-04-24 21:58:14Z blackhedd $
-
-require 'common'
-
-class TestPassword < Test::Unit::TestCase
-
-  def test_psw
-    assert_equal(
-	"{MD5}xq8jwrcfibi0sZdZYNkSng==",
-	Net::LDAP::Password.generate( :md5, "cashflow" ))
-
-    assert_equal(
-	"{SHA}YE4eGkN4BvwNN1f5R7CZz0kFn14=",
-	Net::LDAP::Password.generate( :sha, "cashflow" ))
-  end
-
-end