socialcast-net-ldap 0.1.5

data/spec/integration/ssl_ber_spec.rb

@@ -0,0 +1,33 @@
+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
+    
+    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/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,83 @@
+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)', 
+      ].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 !, &, *, :, | and ~" do
+      Net::LDAP::Filter.escape('!&*:|~').should == "\\21\\26\\2A\\3A\\7C\\7E"
+    end 
+  end
+end

data/spec/unit/ldap_spec.rb

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

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

data/test/test_entry.rb

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