net-ldap 0.8.0 → 0.9.0

data/spec/unit/ldap/filter_parser_spec.rb

@@ -1,26 +0,0 @@
-# encoding: utf-8
-require 'spec_helper'
-
-describe Net::LDAP::Filter::FilterParser do
-
-  describe "#parse" do
-    context "Given ASCIIs as filter string" do
-      let(:filter_string) { "(cn=name)" }
-      specify "should generate filter object" do
-        expect(Net::LDAP::Filter::FilterParser.parse(filter_string)).to be_a Net::LDAP::Filter
-      end
-    end
-    context "Given string including multibyte chars as filter string" do
-      let(:filter_string) { "(cn=名前)" }
-      specify "should generate filter object" do
-        expect(Net::LDAP::Filter::FilterParser.parse(filter_string)).to be_a Net::LDAP::Filter
-      end
-    end
-    context "Given string including colons ':'" do
-      let(:filter_string) { "(ismemberof=cn=edu:berkeley:app:calmessages:deans,ou=campus groups,dc=berkeley,dc=edu)" }
-      specify "should generate filter object" do
-        expect(Net::LDAP::Filter::FilterParser.parse(filter_string)).to be_a Net::LDAP::Filter
-      end
-    end
-  end
-end

data/spec/unit/ldap/filter_spec.rb

@@ -1,115 +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
-
-  context 'with a well-known BER string' do
-    ber = raw_string("\xa4\x2d" \
-      "\x04\x0b" "objectclass" \
-      "\x30\x1e" \
-      "\x80\x08" "foo" "*\\" "bar" \
-      "\x81\x08" "foo" "*\\" "bar" \
-      "\x82\x08" "foo" "*\\" "bar")
-
-    describe "<- .to_ber" do
-      [
-        "foo" "\\2A\\5C" "bar",
-        "foo" "\\2a\\5c" "bar",
-        "foo" "\\2A\\5c" "bar",
-        "foo" "\\2a\\5C" "bar"
-      ].each do |escaped|
-        it 'unescapes escaped characters' do
-          filter = Net::LDAP::Filter.eq("objectclass", "#{escaped}*#{escaped}*#{escaped}")
-          filter.to_ber.should == ber
-        end
-      end
-    end
-
-    describe '<- .parse_ber' do
-      it 'escapes characters' do
-        escaped = Net::LDAP::Filter.escape("foo" "*\\" "bar")
-        filter = Net::LDAP::Filter.parse_ber(ber.read_ber(Net::LDAP::AsnSyntax))
-        filter.to_s.should == "(objectclass=#{escaped}*#{escaped}*#{escaped})"
-      end
-    end
-  end
-end

data/spec/unit/ldap/search_spec.rb

@@ -1,49 +0,0 @@
-# -*- ruby encoding: utf-8 -*-
-
-describe Net::LDAP, "search method" do
-  class FakeConnection
-    def search(args)
-      OpenStruct.new(:result_code => 1, :message => "error", :success? => false)
-    end
-  end
-
-  before(:each) do
-    @service = MockInstrumentationService.new
-    @connection = Net::LDAP.new :instrumentation_service => @service
-    @connection.instance_variable_set(:@open_connection, FakeConnection.new)
-  end
-
-  context "when :return_result => true" do
-    it "should return nil upon error" do
-      result_set = @connection.search(:return_result => true)
-      result_set.should be_nil
-    end
-  end
-
-  context "when :return_result => false" do
-    it "should return false upon error" do
-      result = @connection.search(:return_result => false)
-      result.should be_false
-    end
-  end
-
-  context "When :return_result is not given" do
-    it "should return nil upon error" do
-      result_set = @connection.search
-      result_set.should be_nil
-    end
-  end
-
-  context "when instrumentation_service is configured" do
-    it "should publish a search.net_ldap event" do
-      events = @service.subscribe "search.net_ldap"
-
-      @connection.search :filter => "test"
-
-      payload, result = events.pop
-      payload.should have_key(:result)
-      payload.should have_key(:filter)
-      payload[:filter].should == "test"
-    end
-  end
-end

data/spec/unit/ldap_spec.rb

@@ -1,223 +0,0 @@
-require 'spec_helper'
-
-describe Net::LDAP do
-  describe "initialize" do
-    context "when instrumentation is configured" do
-      before do
-        @connection = flexmock(:connection, :close => true)
-        flexmock(Net::LDAP::Connection).should_receive(:new).and_return(@connection)
-
-        @service = MockInstrumentationService.new
-      end
-
-      subject do
-        Net::LDAP.new \
-          :server => "test.mocked.com", :port => 636,
-          :force_no_page => true, # so server capabilities are not queried
-          :instrumentation_service => @service
-      end
-
-      it "should instrument bind" do
-        events = @service.subscribe "bind.net_ldap"
-
-        bind_result = flexmock(:bind_result, :success? => true)
-        @connection.should_receive(:bind).with(Hash).and_return(bind_result)
-
-        subject.bind.should be_true
-
-        payload, result = events.pop
-        result.should be_true
-        payload[:bind].should == bind_result
-      end
-
-      it "should instrument search" do
-        events = @service.subscribe "search.net_ldap"
-
-        @connection.should_receive(:bind).and_return(flexmock(:bind_result, :result_code => 0))
-        @connection.should_receive(:search).with(Hash, Proc).
-                    yields(entry = Net::LDAP::Entry.new("uid=user1,ou=users,dc=example,dc=com")).
-                    and_return(flexmock(:search_result, :success? => true, :result_code => 0))
-
-        subject.search(:filter => "(uid=user1)").should be_true
-
-        payload, result = events.pop
-        result.should == [entry]
-        payload[:result].should == [entry]
-        payload[:filter].should == "(uid=user1)"
-      end
-    end
-  end
-end
-
-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
-
-  context "populate error messages" do
-    before do
-      @tcp_socket = flexmock(:connection)
-      @tcp_socket.should_receive(:write)
-      flexmock(TCPSocket).should_receive(:new).and_return(@tcp_socket)
-    end
-
-    subject { Net::LDAP::Connection.new(:server => 'test.mocked.com', :port => 636) }
-
-    it "should get back error messages if operation fails" do
-      ber = Net::BER::BerIdentifiedArray.new([53, "", "The provided password value was rejected by a password validator:  The provided password did not contain enough characters from the character set 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.  The minimum number of characters from that set that must be present in user passwords is 1"])
-      ber.ber_identifier = Net::LDAP::PDU::ModifyResponse
-      @tcp_socket.should_receive(:read_ber).and_return([2, ber])
-
-      result = subject.modify(:dn => "1", :operations => [[:replace, "mail", "something@sothsdkf.com"]])
-      result.should be_failure
-      result.error_message.should == "The provided password value was rejected by a password validator:  The provided password did not contain enough characters from the character set 'ABCDEFGHIJKLMNOPQRSTUVWXYZ'.  The minimum number of characters from that set that must be present in user passwords is 1"
-    end
-
-    it "shouldn't get back error messages if operation succeeds" do
-      ber = Net::BER::BerIdentifiedArray.new([0, "", ""])
-      ber.ber_identifier = Net::LDAP::PDU::ModifyResponse
-      @tcp_socket.should_receive(:read_ber).and_return([2, ber])
-
-      result = subject.modify(:dn => "1", :operations => [[:replace, "mail", "something@sothsdkf.com"]])
-      result.should be_success
-      result.error_message.should == ""
-    end
-  end
-
-  context "instrumentation" do
-    before do
-      @tcp_socket = flexmock(:connection)
-      # handle write
-      @tcp_socket.should_receive(:write)
-      # return this mock
-      flexmock(TCPSocket).should_receive(:new).and_return(@tcp_socket)
-
-      @service = MockInstrumentationService.new
-    end
-
-    subject do
-      Net::LDAP::Connection.new(:server => 'test.mocked.com', :port => 636,
-                                :instrumentation_service => @service)
-    end
-
-    it "should publish a write.net_ldap_connection event" do
-      ber = Net::BER::BerIdentifiedArray.new([0, "", ""])
-      ber.ber_identifier = Net::LDAP::PDU::BindResult
-      read_result = [2, ber]
-      @tcp_socket.should_receive(:read_ber).and_return(read_result)
-
-      events = @service.subscribe "write.net_ldap_connection"
-
-      result = subject.bind(method: :anon)
-      result.should be_success
-
-      # a write event
-      payload, result = events.pop
-      payload.should have_key(:result)
-      payload.should have_key(:content_length)
-    end
-
-    it "should publish a read.net_ldap_connection event" do
-      ber = Net::BER::BerIdentifiedArray.new([0, "", ""])
-      ber.ber_identifier = Net::LDAP::PDU::BindResult
-      read_result = [2, ber]
-      @tcp_socket.should_receive(:read_ber).and_return(read_result)
-
-      events = @service.subscribe "read.net_ldap_connection"
-
-      result = subject.bind(method: :anon)
-      result.should be_success
-
-      # a read event
-      payload, result = events.pop
-      payload.should have_key(:result)
-      result.should == read_result
-    end
-
-    it "should publish a bind.net_ldap_connection event" do
-      ber = Net::BER::BerIdentifiedArray.new([0, "", ""])
-      ber.ber_identifier = Net::LDAP::PDU::BindResult
-      bind_result = [2, ber]
-      @tcp_socket.should_receive(:read_ber).and_return(bind_result)
-
-      events = @service.subscribe "bind.net_ldap_connection"
-
-      result = subject.bind(method: :anon)
-      result.should be_success
-
-      # a read event
-      payload, result = events.pop
-      payload.should have_key(:result)
-      result.should be_success
-    end
-
-    it "should publish a search.net_ldap_connection event" do
-      # search data
-      search_data_ber = Net::BER::BerIdentifiedArray.new([2, [
-        "uid=user1,ou=OrgUnit2,ou=OrgUnitTop,dc=openldap,dc=ghe,dc=local",
-        [ ["uid", ["user1"]] ]
-      ]])
-      search_data_ber.ber_identifier = Net::LDAP::PDU::SearchReturnedData
-      search_data = [2, search_data_ber]
-      # search result (end of results)
-      search_result_ber = Net::BER::BerIdentifiedArray.new([0, "", ""])
-      search_result_ber.ber_identifier = Net::LDAP::PDU::SearchResult
-      search_result = [2, search_result_ber]
-      @tcp_socket.should_receive(:read_ber).and_return(search_data).
-                                            and_return(search_result)
-
-      events = @service.subscribe "search.net_ldap_connection"
-
-      result = subject.search(filter: "(uid=user1)")
-      result.should be_success
-
-      # a search event
-      payload, result = events.pop
-      payload.should have_key(:result)
-      payload.should have_key(:filter)
-      payload[:filter].to_s.should == "(uid=user1)"
-      result.should be_truthy
-    end
-  end
-end

data/test/common.rb

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