prathe_net-ldap 0.2.20110317223538

data/net-ldap.gemspec

@@ -0,0 +1,59 @@
+# -*- encoding: utf-8 -*-
+
+Gem::Specification.new do |s|
+  s.name = %q{prathe_net-ldap}
+  s.version = "0.2.20110317223538"
+
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.authors = ["Francis Cianfrocca", "Emiel van de Laar", "Rory O'Connell", "Kaspar Schiess", "Austin Ziegler"]
+  s.date = %q{2011-03-17}
+  s.description = %q{Net::LDAP for Ruby (also called net-ldap) implements client access for the
+Lightweight Directory Access Protocol (LDAP), an IETF standard protocol for
+accessing distributed directory services. Net::LDAP is written completely in
+Ruby with no external dependencies. It supports most LDAP client features and a
+subset of server features as well.
+
+Net::LDAP has been tested against modern popular LDAP servers including
+OpenLDAP and Active Directory. The current release is mostly compliant with
+earlier versions of the IETF LDAP RFCs (2251–2256, 2829–2830, 3377, and 3771).
+Our roadmap for Net::LDAP 1.0 is to gain full <em>client</em> compliance with
+the most recent LDAP RFCs (4510–4519, plutions of 4520–4532).}
+  s.email = ["blackhedd@rubyforge.org", "gemiel@gmail.com", "rory.ocon@gmail.com", "kaspar.schiess@absurd.li", "austin@rubyforge.org"]
+  s.extra_rdoc_files = ["Manifest.txt", "Contributors.rdoc", "Hacking.rdoc", "History.rdoc", "License.rdoc", "README.rdoc"]
+  s.files = [".autotest", ".rspec", "Contributors.rdoc", "Hacking.rdoc", "History.rdoc", "License.rdoc", "Manifest.txt", "README.rdoc", "Rakefile", "autotest/discover.rb", "lib/net-ldap.rb", "lib/net/ber.rb", "lib/net/ber/ber_parser.rb", "lib/net/ber/core_ext.rb", "lib/net/ber/core_ext/array.rb", "lib/net/ber/core_ext/bignum.rb", "lib/net/ber/core_ext/false_class.rb", "lib/net/ber/core_ext/fixnum.rb", "lib/net/ber/core_ext/string.rb", "lib/net/ber/core_ext/true_class.rb", "lib/net/ldap.rb", "lib/net/ldap/dataset.rb", "lib/net/ldap/dn.rb", "lib/net/ldap/entry.rb", "lib/net/ldap/filter.rb", "lib/net/ldap/password.rb", "lib/net/ldap/pdu.rb", "lib/net/snmp.rb", "net-ldap.gemspec", "spec/integration/ssl_ber_spec.rb", "spec/spec.opts", "spec/spec_helper.rb", "spec/unit/ber/ber_spec.rb", "spec/unit/ber/core_ext/string_spec.rb", "spec/unit/ldap/dn_spec.rb", "spec/unit/ldap/entry_spec.rb", "spec/unit/ldap/filter_spec.rb", "spec/unit/ldap_spec.rb", "test/common.rb", "test/test_entry.rb", "test/test_filter.rb", "test/test_ldap_connection.rb", "test/test_ldif.rb", "test/test_password.rb", "test/test_rename.rb", "test/test_snmp.rb", "test/testdata.ldif", "testserver/ldapserver.rb", "testserver/testdata.ldif", ".gemtest"]
+  s.homepage = %q{http://net-ldap.rubyforge.org/}
+  s.rdoc_options = ["--main", "README.rdoc"]
+  s.require_paths = ["lib"]
+  s.required_ruby_version = Gem::Requirement.new(">= 1.8.7")
+  s.rubyforge_project = %q{net-ldap}
+  s.rubygems_version = %q{1.5.2}
+  s.summary = %q{Net::LDAP for Ruby (also called net-ldap) implements client access for the Lightweight Directory Access Protocol (LDAP), an IETF standard protocol for accessing distributed directory services}
+  s.test_files = ["test/test_entry.rb", "test/test_filter.rb", "test/test_ldap_connection.rb", "test/test_ldif.rb", "test/test_password.rb", "test/test_rename.rb", "test/test_snmp.rb"]
+
+  if s.respond_to? :specification_version then
+    s.specification_version = 3
+
+    if Gem::Version.new(Gem::VERSION) >= Gem::Version.new('1.2.0') then
+      s.add_development_dependency(%q<hoe-git>, ["~> 1"])
+      s.add_development_dependency(%q<hoe-gemspec>, ["~> 1"])
+      s.add_development_dependency(%q<metaid>, ["~> 1"])
+      s.add_development_dependency(%q<flexmock>, ["~> 0.9.0"])
+      s.add_development_dependency(%q<rspec>, ["~> 2.0"])
+      s.add_development_dependency(%q<hoe>, [">= 2.9.1"])
+    else
+      s.add_dependency(%q<hoe-git>, ["~> 1"])
+      s.add_dependency(%q<hoe-gemspec>, ["~> 1"])
+      s.add_dependency(%q<metaid>, ["~> 1"])
+      s.add_dependency(%q<flexmock>, ["~> 0.9.0"])
+      s.add_dependency(%q<rspec>, ["~> 2.0"])
+      s.add_dependency(%q<hoe>, [">= 2.9.1"])
+    end
+  else
+    s.add_dependency(%q<hoe-git>, ["~> 1"])
+    s.add_dependency(%q<hoe-gemspec>, ["~> 1"])
+    s.add_dependency(%q<metaid>, ["~> 1"])
+    s.add_dependency(%q<flexmock>, ["~> 0.9.0"])
+    s.add_dependency(%q<rspec>, ["~> 2.0"])
+    s.add_dependency(%q<hoe>, [">= 2.9.1"])
+  end
+end

data/spec/integration/ssl_ber_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+require 'net/ldap'
+
+describe "BER serialisation (SSL)" do
+  # Transmits str to #to and reads it back from #from. 
+  #
+  def transmit(str)
+    to.write(str)
+    to.close
+    
+    from.read
+  end
+    
+  attr_reader :to, :from
+  before(:each) do
+    @from, @to = IO.pipe
+    
+    # The production code operates on sockets, which do need #connect called
+    # on them to work. Pipes are more robust for this test, so we'll skip 
+    # the #connect call since it fails. 
+    flexmock(OpenSSL::SSL::SSLSocket).
+      new_instances.should_receive(:connect => nil)
+              
+    @to   = Net::LDAP::Connection.wrap_with_ssl(to)
+    @from = Net::LDAP::Connection.wrap_with_ssl(from)
+  end
+  
+  it "should transmit strings" do
+    transmit('foo').should == 'foo'
+  end 
+  it "should correctly transmit numbers" do
+    to.write 1234.to_ber
+    from.read_ber.should == 1234
+  end 
+end

data/spec/spec.opts

@@ -0,0 +1,2 @@
+--format specdoc
+--colour

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+require 'net/ldap'
+
+RSpec.configure do |config|
+  config.mock_with :flexmock
+end

data/spec/unit/ber/ber_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+require 'net/ber'
+require 'net/ldap'
+
+describe "BER encoding of" do
+  
+  RSpec::Matchers.define :properly_encode_and_decode do 
+    match do |given|
+      given.to_ber.read_ber.should == given
+    end
+  end
+   
+  context "arrays" do
+    it "should properly encode/decode []" do
+      [].should properly_encode_and_decode
+    end 
+    it "should properly encode/decode [1,2,3]" do
+      ary = [1,2,3]
+      encoded_ary = ary.map { |el| el.to_ber }.to_ber
+      
+      encoded_ary.read_ber.should == ary
+    end 
+  end
+  context "booleans" do
+    it "should encode true" do
+      true.to_ber.should == "\x01\x01\x01"
+    end
+    it "should encode false" do
+      false.to_ber.should == "\x01\x01\x00"
+    end
+  end
+  context "numbers" do
+    # Sample based
+    {
+      0           => "\x02\x01\x00", 
+      1           => "\x02\x01\x01", 
+      127         => "\x02\x01\x7F", 
+      128         => "\x02\x01\x80", 
+      255         => "\x02\x01\xFF", 
+      256         => "\x02\x02\x01\x00", 
+      65535       => "\x02\x02\xFF\xFF", 
+      65536       => "\x02\x03\x01\x00\x00", 
+      16_777_215  => "\x02\x03\xFF\xFF\xFF", 
+      0x01000000  => "\x02\x04\x01\x00\x00\x00", 
+      0x3FFFFFFF  => "\x02\x04\x3F\xFF\xFF\xFF", 
+      0x4FFFFFFF  => "\x02\x04\x4F\xFF\xFF\xFF", 
+      
+      # Some odd samples...
+      5           => "\002\001\005", 
+      500         => "\002\002\001\364", 
+      50_000      => "\x02\x02\xC3P", 
+      5_000_000_000  => "\002\005\001*\005\362\000"
+    }.each do |number, expected_encoding| 
+      it "should encode #{number} as #{expected_encoding.inspect}" do
+        number.to_ber.should == expected_encoding
+      end 
+    end
+
+    # Round-trip encoding: This is mostly to be sure to cover Bignums well.
+    context "when decoding with #read_ber" do
+      it "should correctly handle powers of two" do
+        100.times do |p|
+          n = 2 << p
+          
+          n.should properly_encode_and_decode
+        end
+      end 
+      it "should correctly handle powers of ten" do
+        100.times do |p|
+          n = 5 * 10**p
+          
+          n.should properly_encode_and_decode
+        end
+      end 
+    end
+  end
+  if "Ruby 1.9".respond_to?(:encoding)
+    context "strings" do
+      it "should properly encode UTF-8 strings" do
+        "\u00e5".force_encoding("UTF-8").to_ber.should ==
+          "\x04\x02\xC3\xA5"
+      end
+      it "should properly encode strings encodable as UTF-8" do
+        "teststring".encode("US-ASCII").to_ber.should == "\x04\nteststring"
+      end
+      it "should fail on strings that can not be converted to UTF-8" do
+        error = Encoding::UndefinedConversionError
+        lambda {"\x81".to_ber }.should raise_exception(error)
+      end
+    end
+  end
+end
+
+describe "BER decoding of" do
+  context "numbers" do
+    it "should decode #{"\002\001\006".inspect} (6)" do
+      "\002\001\006".read_ber(Net::LDAP::AsnSyntax).should == 6
+    end
+    it "should decode #{"\004\007testing".inspect} ('testing')" do
+      "\004\007testing".read_ber(Net::LDAP::AsnSyntax).should == 'testing'
+    end
+    it "should decode an ldap bind request" do
+      "0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus".
+        read_ber(Net::LDAP::AsnSyntax).should ==
+          [1, [3, "Administrator", "ad_is_bogus"]]
+    end 
+  end
+end

data/spec/unit/ber/core_ext/string_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+require 'metaid'
+
+describe String, "when extended with BER core extensions" do
+  describe "<- #read_ber! (consuming read_ber method)" do
+    context "when passed an ldap bind request and some extra data" do
+      attr_reader :str, :result
+      before(:each) do
+        @str = "0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus UNCONSUMED" 
+        @result = str.read_ber!(Net::LDAP::AsnSyntax)
+      end
+      
+      it "should correctly parse the ber message" do
+        result.should == [1, [3, "Administrator", "ad_is_bogus"]]
+      end 
+      it "should leave unconsumed part of message in place" do
+        str.should == " UNCONSUMED"
+      end
+
+      context "if an exception occurs during #read_ber" do
+        attr_reader :initial_value
+        before(:each) do
+          stub_exception_class = Class.new(StandardError)
+          
+          @initial_value = "0$\002\001\001`\037\002\001\003\004\rAdministrator\200\vad_is_bogus" 
+          @str = initial_value.dup 
+
+          # Defines a string
+          io = StringIO.new(initial_value)
+          io.meta_def :read_ber do |syntax|
+            read
+            raise stub_exception_class
+          end
+          flexmock(StringIO).should_receive(:new).and_return(io)
+          
+          begin
+            str.read_ber!(Net::LDAP::AsnSyntax)            
+          rescue stub_exception_class
+            # EMPTY ON PURPOSE
+          else
+            raise "The stub code should raise an exception!"
+          end
+        end
+        
+        it "should not modify string" do
+          str.should == initial_value
+        end
+      end
+    end
+  end
+end

data/spec/unit/ldap/dn_spec.rb

@@ -0,0 +1,80 @@
+require 'spec_helper'
+require 'net/ldap/dn'
+
+describe Net::LDAP::DN do
+  describe "<- .construct" do
+    attr_reader :dn
+
+    before(:each) do
+      @dn = Net::LDAP::DN.new('cn', ',+"\\<>;', 'ou=company')
+    end
+
+    it "should construct a Net::LDAP::DN" do
+      dn.should be_an_instance_of(Net::LDAP::DN)
+    end 
+
+    it "should escape all the required characters" do
+      dn.to_s.should == 'cn=\\,\\+\\"\\\\\\<\\>\\;,ou=company'
+    end
+  end
+
+  describe "<- .to_a" do
+    context "parsing" do
+      {
+        'cn=James, ou=Company\\,\\20LLC' => ['cn','James','ou','Company, LLC'],
+        'cn =  \ James , ou  =  "Comp\28ny"  ' => ['cn',' James','ou','Comp(ny'],
+        '1.23.4=  #A3B4D5  ,ou=Company' => ['1.23.4','#A3B4D5','ou','Company'],
+      }.each do |key, value|
+        context "(#{key})" do
+          attr_reader :dn
+
+          before(:each) do
+            @dn = Net::LDAP::DN.new(key)
+          end
+
+          it "should decode into a Net::LDAP::DN" do
+            dn.should be_an_instance_of(Net::LDAP::DN)
+          end
+
+          it "should return the correct array" do
+            dn.to_a.should == value
+          end
+        end
+      end
+    end
+
+    context "parsing bad input" do
+      [
+        'cn=James,',
+        'cn=#aa aa',
+        'cn="James',
+        'cn=J\ames',
+        'cn=\\',
+        '1.2.d=Value',
+        'd1.2=Value',
+      ].each do |value|
+        context "(#{value})" do
+          attr_reader :dn
+
+          before(:each) do
+            @dn = Net::LDAP::DN.new(value)
+          end
+
+          it "should decode into a Net::LDAP::DN" do
+            dn.should be_an_instance_of(Net::LDAP::DN)
+          end
+
+          it "should raise an error on parsing" do
+            lambda { dn.to_a }.should raise_error
+          end
+        end
+      end
+    end
+  end
+
+  describe "<- .escape(str)" do
+    it "should escape ,, +, \", \\, <, >, and ;" do
+      Net::LDAP::DN.escape(',+"\\<>;').should == '\\,\\+\\"\\\\\\<\\>\\;'
+    end 
+  end
+end

data/spec/unit/ldap/entry_spec.rb

@@ -0,0 +1,51 @@
+require 'spec_helper'
+
+describe Net::LDAP::Entry do
+  attr_reader :entry
+  before(:each) do
+    @entry = Net::LDAP::Entry.from_single_ldif_string(
+      %Q{dn: something
+foo: foo
+barAttribute: bar
+      }
+    )
+  end
+
+  describe "entry access" do
+    it "should always respond to #dn" do
+      entry.should respond_to(:dn)
+    end 
+    
+    context "<- #foo" do
+      it "should respond_to?" do
+        entry.should respond_to(:foo)
+      end 
+      it "should return 'foo'" do
+        entry.foo.should == ['foo']
+      end
+    end
+    context "<- #Foo" do
+      it "should respond_to?" do
+        entry.should respond_to(:Foo)
+      end 
+      it "should return 'foo'" do
+        entry.foo.should == ['foo']
+      end 
+    end
+    context "<- #foo=" do
+      it "should respond_to?" do
+        entry.should respond_to(:foo=)
+      end 
+      it "should set 'foo'" do
+        entry.foo= 'bar'
+        entry.foo.should == ['bar']
+      end 
+    end
+    context "<- #fOo=" do
+      it "should return 'foo'" do
+        entry.fOo= 'bar'
+        entry.fOo.should == ['bar']
+      end 
+    end
+  end
+end

data/spec/unit/ldap/filter_spec.rb

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