net-ldap 0.8.0 → 0.9.0

data/.autotest

@@ -1,11 +0,0 @@
-require 'rubygems'
-#require 'redgreen/autotest'
-require 'autotest/timestamp'
-
-Autotest.add_hook :initialize do |autotest|
-  %w{.git .hg .DS_Store ._* tmp log doc}.each do |exception|
-    autotest.add_exception(exception)
-  end
-end
-
-# vim: syntax=ruby

data/.rspec

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

data/autotest/discover.rb

@@ -1 +0,0 @@
-Autotest.add_discovery { "rspec2" }

data/spec/integration/ssl_ber_spec.rb

@@ -1,39 +0,0 @@
-require 'spec_helper'
-
-require 'net/ldap'
-require 'timeout'
-
-describe "BER serialisation (SSL)" do
-  # Transmits str to #to and reads it back from #from. 
-  #
-  def transmit(str)
-    Timeout::timeout(1) do
-      to.write(str)
-      to.close
-
-      from.read
-    end
-  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

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

data/spec/spec_helper.rb

@@ -1,28 +0,0 @@
-require 'net/ldap'
-
-RSpec.configure do |config|
-  config.mock_with :flexmock
-
-  def raw_string(s)
-    # Conveniently, String#b only needs to be called when it exists
-    s.respond_to?(:b) ? s.b : s
-  end
-end
-
-class MockInstrumentationService
-  def initialize
-    @events = {}
-  end
-
-  def instrument(event, payload)
-    result = yield(payload)
-    @events[event] ||= []
-    @events[event] << [payload, result]
-    result
-  end
-
-  def subscribe(event)
-    @events[event] ||= []
-    @events[event]
-  end
-end

data/spec/unit/ber/ber_spec.rb

@@ -1,141 +0,0 @@
-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           => raw_string("\x02\x01\x00"),
-      1           => raw_string("\x02\x01\x01"),
-      127         => raw_string("\x02\x01\x7F"),
-      128         => raw_string("\x02\x01\x80"),
-      255         => raw_string("\x02\x01\xFF"),
-      256         => raw_string("\x02\x02\x01\x00"),
-      65535       => raw_string("\x02\x02\xFF\xFF"),
-      65536       => raw_string("\x02\x03\x01\x00\x00"),
-      16_777_215  => raw_string("\x02\x03\xFF\xFF\xFF"),
-      0x01000000  => raw_string("\x02\x04\x01\x00\x00\x00"),
-      0x3FFFFFFF  => raw_string("\x02\x04\x3F\xFF\xFF\xFF"),
-      0x4FFFFFFF  => raw_string("\x02\x04\x4F\xFF\xFF\xFF"),
-
-      # Some odd samples...
-      5           => raw_string("\002\001\005"),
-      500         => raw_string("\002\002\001\364"),
-      50_000      => raw_string("\x02\x02\xC3P"),
-      5_000_000_000  => raw_string("\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 ==
-          raw_string("\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 properly encode binary data strings using to_ber_bin" do
-				# This is used for searching for GUIDs in Active Directory
-				["6a31b4a12aa27a41aca9603f27dd5116"].pack("H*").to_ber_bin.should == 
-					raw_string("\x04\x10" + "j1\xB4\xA1*\xA2zA\xAC\xA9`?'\xDDQ\x16")
-			end
-      it "should not fail on strings that can not be converted to UTF-8" do
-        error = Encoding::UndefinedConversionError
-        lambda {"\x81".to_ber }.should_not 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
-
-describe Net::BER::BerIdentifiedString do
-  describe "initialize" do
-    subject { Net::BER::BerIdentifiedString.new(data) }
-
-    context "binary data" do
-      let(:data) { ["6a31b4a12aa27a41aca9603f27dd5116"].pack("H*").force_encoding("ASCII-8BIT") }
-
-      its(:valid_encoding?) { should be_true }
-      specify { subject.encoding.name.should == "ASCII-8BIT" }
-    end
-
-    context "ascii data in UTF-8" do
-      let(:data) { "some text".force_encoding("UTF-8") }
-
-      its(:valid_encoding?) { should be_true }
-      specify { subject.encoding.name.should == "UTF-8" }
-    end
-
-    context "UTF-8 data in UTF-8" do
-      let(:data) { ["e4b8ad"].pack("H*").force_encoding("UTF-8") }
-      
-      its(:valid_encoding?) { should be_true }
-      specify { subject.encoding.name.should == "UTF-8" }
-    end
-  end
-end

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

@@ -1,24 +0,0 @@
-require 'spec_helper'
-require 'metaid'
-
-describe Array, "when extended with BER core extensions" do
-
-  it "should correctly convert a control code array" do
-    control_codes = []
-    control_codes << ['1.2.3'.to_ber, true.to_ber].to_ber_sequence
-    control_codes << ['1.7.9'.to_ber, false.to_ber].to_ber_sequence
-    control_codes = control_codes.to_ber_sequence
-    res = [['1.2.3', true],['1.7.9',false]].to_ber_control
-    res.should eq(control_codes)
-  end
-
-  it "should wrap the array in another array if a nested array is not passed" do
-    result1 = ['1.2.3', true].to_ber_control
-    result2 = [['1.2.3', true]].to_ber_control
-    result1.should eq(result2)
-  end
-
-  it "should return an empty string if an empty array is passed" do
-    [].to_ber_control.should be_empty
-  end
-end

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

@@ -1,51 +0,0 @@
-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 = raw_string("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 = raw_string("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

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

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