ad-ldap 0.0.1

data/.gitignore

@@ -0,0 +1,4 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in ad-ldap.gemspec
+gemspec
+
+gem 'rake', '~>0.9.2'

data/README.markdown

@@ -0,0 +1,128 @@
+# AD::LDAP
+
+A small wrapper to Net::LDAP to provide some extended functionality and utility.
+
+## Description
+
+AD::LDAP is a small wrapper to the Net::LDAP library. Net::LDAP provides a nice low-level interface for interacting with an LDAP server. AD::LDAP simply wraps that interface and provides some extended functionality through:
+
+* Built-in logging of any communication with the LDAP server
+* Easier searching
+
+## Installation
+
+    gem install ad-ldap
+
+## Usage
+
+First, you need to configure the gem:
+
+```ruby
+AD::LDAP.configure do |config|
+  config.host = "127.0.0.1"
+  config.port = 389
+  config.base = "DC=mydomain, DC=com"
+  config.encrytion = :simple_tls
+  config.logger = Rails.logger
+end
+```
+
+Then you can start running LDAP commands like you would with Net::LDAP.
+
+```ruby
+AD::LDAP.search({
+  :base => "DC=Users, DC=mydomain, DC=com",
+  :filter => "(name=collin)"
+})
+```
+
+Most of the commands have the same syntax as they do in net-ldap:
+
+```ruby
+AD::LDAP.add({
+  :dn => "DN=collin, DC=Users, DC=mydomain, DC=com",
+  :attributes => { :givenname => "Collin", :lastname => "Redding" }
+})
+```
+
+Some are slightly different though, the following:
+
+```ruby
+AD::LDAP.delete("DN=collin, DC=Users, DC=mydomain, DC=com")
+```
+
+is equivalent to:
+
+```ruby
+ldap = Net::LDAP.new
+ldap.delete({ :dn => "DN=collin, DC=Users, DC=mydomain, DC=com })`
+```
+
+The biggest feature of AD::LDAP is some of the conventions when using the search method. If I don't provide a filter and have extra keys not supported by net-ldap's search, they are converted to filters automatically:
+
+```ruby
+AD::LDAP.search({ :name__eq => "collin" })
+```
+
+which can be simplified even further:
+
+```ruby
+AD::LDAP.search({ :name => "collin" })
+```
+
+Multiple filters are joined together (Net::LDAP::Filter.join) by default:
+
+```ruby
+AD::LDAP.search({ :name => "collin", :objectclass => "user" })
+```
+
+AD::LDAP won't get in your wa if you need to do something complex:
+
+```ruby
+name_filter = Net::LDAP::Filter.eq("name", "collin*")
+class_filter = Net::LDAP::Filter.eq("objectclass", "user")
+filters = name_filter | class_filter
+AD::LDAP.search({ :filter => filters, :size => 1 })
+```
+
+Finally, because the LDAP names for most fields are not very ruby-ish (are all one word) it's sometimes convenient to setup mappings from a more ruby friendly name to a LDAP name:
+
+```ruby
+AD::LDAP.configure do |config|
+  # ...
+  config.mapppings = {
+    "login" => "samaccountname"
+  }
+end
+```
+
+with the above config you can then search with the mapping:
+
+```ruby
+AD::LDAP.search({ :login => "jcredding" })
+```
+
+## License
+
+Copyright (c) 2011 Collin Redding and Team Insight
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,7 @@
+include Rake::DSL
+
+require 'bundler'
+Bundler::GemHelper.install_tasks
+
+require 'assert/rake_tasks'
+Assert::RakeTasks.for :test

data/ad-ldap.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "ad-ldap/version"
+
+Gem::Specification.new do |s|
+  s.name        = "ad-ldap"
+  s.version     = AD::LDAP::VERSION
+  s.authors     = ["Collin Redding"]
+  s.homepage    = "http://github.com/teaminsight/ad-ldap"
+  s.summary     = %q{A small wrapper to Net::LDAP to provide some extended functionality and utility.}
+  s.description = %q{A small wrapper to Net::LDAP to provide some extended functionality and utility.}
+
+  s.rubyforge_project = "ad-ldap"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_runtime_dependency "net-ldap", "~>0.2.2"
+
+  s.add_development_dependency "assert" #TODO: lock the version of assert
+  s.add_development_dependency "mocha", "=0.9.12"
+end

data/lib/ad-ldap.rb

@@ -0,0 +1,97 @@
+require 'benchmark'
+require 'ostruct'
+
+require 'ad-ldap/adapter'
+require 'ad-ldap/logger'
+require 'ad-ldap/search_args'
+require 'ad-ldap/version'
+
+module AD
+  module LDAP
+    class << self
+
+      def configure
+        yield self.config
+      end
+
+      def config
+        @config ||= OpenStruct.new({
+          :run_commands => false,
+          :search_size_supported => true,
+          :mappings => {}
+        })
+      end
+
+      def adapter
+        @adapter ||= AD::LDAP::Adapter.new(self.config)
+      end
+
+      def logger
+        @logger ||= AD::LDAP::Logger.new(self.config)
+      end
+
+      def add(args = {})
+        self.run(:add, args)
+      end
+
+      def delete(dn)
+        self.run(:delete, { :dn => dn })
+      end
+
+      def replace_attribute(dn, field, value)
+        self.run(:replace_attribute, dn, field, value)
+      end
+
+      def delete_attribute(dn, field)
+        self.run(:delete_attribute, dn, field)
+      end
+
+      def search(args = {})
+        self.run_search(args)
+      end
+
+      def bind_as(args = {})
+        if !args[:filter]
+          password = args.delete(:password)
+          search_args = AD::LDAP::SearchArgs.new(args)
+          args = {
+            :filter => search_args[:filter],
+            :password => password
+          }
+        end
+        !!self.run(:bind_as, args)
+      end
+
+      protected
+
+      def run_search(args)
+        search_args = AD::LDAP::SearchArgs.new(args)
+        if !self.config.search_size_supported
+          size = search_args.delete(:size)
+        end
+        results = (self.run(:search, search_args) || [])
+        if !self.config.search_size_supported && size && results.kind_of?(Array)
+          results[0..(size.to_i - 1)]
+        else
+          results
+        end
+      end
+
+      # Inspired by https://github.com/tpett/perry logger
+      def run(method, *args)
+        result, time = [ nil, -1 ]
+        if self.config.run_commands
+          time = (Benchmark.measure do
+            result = self.adapter.send(method, *args)
+          end).real
+        end
+        self.logger.out(method, args, result, time)
+        result
+      rescue Exception => exception
+        self.logger.out(method, args, result, time)
+        raise(exception)
+      end
+
+    end
+  end
+end

data/lib/ad-ldap/adapter.rb

@@ -0,0 +1,69 @@
+require 'net/ldap'
+
+require 'ad-ldap/response'
+
+module AD
+  module LDAP
+
+    class Adapter < ::Net::LDAP
+      attr_accessor :config
+
+      def initialize(config)
+        self.config = config
+        super({
+          :host => self.config.host,
+          :port => self.config.port,
+          :base => self.config.base,
+          :encryption => self.config.encryption
+        })
+        if self.config.auth
+          self.auth(self.config.auth.username, self.config.auth.password)
+        end
+      end
+
+      # don't raise when an open connection is already open, just yield it
+      def open
+        if @open_connection
+          yield @open_connection
+        else
+          super
+        end
+      end
+
+      [ :add, :delete, :modify ].each do |method|
+        define_method(method) do |args|
+          result = super
+          self.check_operation
+          result
+        end
+      end
+      [ :add_attribute, :replace_attribute ].each do |method|
+        define_method(method) do |dn, attribute, value|
+          result = super
+          self.check_operation
+          result
+        end
+      end
+      def delete_attribute(dn, attribute)
+        result = super
+        self.check_operation
+        result
+      end
+
+      def search(args = {})
+        results = super(args.dup)
+        self.check_operation
+        results
+      end
+
+      protected
+
+      def check_operation
+        check = self.get_operation_result
+        AD::LDAP::Response.new(check.code, check.message).handle!
+      end
+
+    end
+
+  end
+end

data/lib/ad-ldap/exceptions.rb

@@ -0,0 +1,6 @@
+module AD::LDAP
+
+  class Error < StandardError
+  end
+
+end

data/lib/ad-ldap/logger.rb

@@ -0,0 +1,59 @@
+module AD
+  module LDAP
+
+    # Inspired by https://github.com/tpett/perry logger
+    class Logger
+      attr_accessor :logger, :silent
+
+      def initialize(config)
+        self.logger = config.logger
+        self.silent = !!config.silent
+      end
+
+      def out(method, args, result, time)
+        color = "4;32;1"
+        name = "%s (%.1fms)" % [ "LDAP", time ]
+        message = self.generate_message(method, args)
+        output = "  \e[#{color}]#{name}   #{message}\e[0m"
+        if self.logger
+          self.logger.debug(output)
+        elsif !self.silent
+          puts output
+        end
+      end
+
+      protected
+
+      def generate_message(method, args)
+        case(method.to_sym)
+        when :replace_attribute
+          dn, field, value = args
+          "#{method}(#{dn.inspect}, #{field.inspect}, #{self.filter_value(value, field).inspect})"
+        when :delete_attribute
+          dn, field = args
+          "#{method}(#{dn.inspect}, #{field.inspect})"
+        else
+          "#{method}(#{self.filter_args(args.first)})"
+        end
+      end
+
+      FILTERED = [ /password/, /unicodePwd/ ]
+      def filter_args(args = {})
+        (args.inject({}) do |filtered, (key, value)|
+          filtered[key] = self.filter_value(value, key)
+          filtered
+        end).inspect
+      end
+      def filter_value(value, key)
+        case(key.to_s)
+        when *FILTERED
+          "[FILTERED]"
+        else
+          value
+        end
+      end
+
+    end
+
+  end
+end

data/lib/ad-ldap/response.rb

@@ -0,0 +1,28 @@
+require 'ad-ldap/exceptions'
+
+module AD
+  module LDAP
+
+    # descriptions: http://wiki.service-now.com/index.php?title=LDAP_Error_Codes
+    class Response
+      attr_accessor :code, :message
+
+      CODES = {
+        :success => 0
+      }.freeze
+
+      def initialize(code, message)
+        self.code = code.to_i
+        self.message = message
+      end
+
+      def handle!
+        if self.code != CODES[:success]
+          raise(AD::LDAP::Error, "#{self.code}: #{self.message}")
+        end
+      end
+
+    end
+
+  end
+end

data/lib/ad-ldap/search_args.rb

@@ -0,0 +1,45 @@
+require 'net/ldap'
+
+module AD
+  module LDAP
+
+    class SearchArgs < Hash
+
+      LDAP_KEYS = [
+        :base, :filter, :attributes, :return_result, :attributes_only,
+        :scope, :size
+      ]
+
+      def initialize(args)
+        super()
+        conditions = {}
+        args.each do |key, value|
+          if LDAP_KEYS.include?(key.to_sym)
+            self[key.to_sym] = value
+          else
+            conditions[key.to_sym] = value
+          end
+        end
+        if !self[:filter] && (filters = self.build_filters(conditions))
+          self[:filter] = filters ? filters.to_s : nil
+        end
+      end
+
+      protected
+
+      def build_filters(conditions = {})
+        conditions.inject(nil) do |filters, (key, value)|
+          field, operator = key.to_s.split("__")
+          operator ||= "eq"
+          if mapping = AD::LDAP.config.mappings[field.to_sym]
+            field = (mapping || field)
+          end
+          filter = ::Net::LDAP::Filter.send(operator, field, value)
+          filters ? ::Net::LDAP::Filter.join(filters, filter) : filter
+        end
+      end
+
+    end
+
+  end
+end

data/lib/ad-ldap/version.rb

@@ -0,0 +1,5 @@
+module AD
+  module LDAP
+    VERSION = "0.0.1"
+  end
+end

data/test/helper.rb

@@ -0,0 +1,17 @@
+require 'mocha'
+
+# add the current gem root path to the LOAD_PATH
+root_path = File.expand_path("../..", __FILE__)
+if !$LOAD_PATH.include?(root_path)
+  $LOAD_PATH.unshift(root_path)
+end
+
+require 'ad-ldap'
+
+class Assert::Context
+  include Mocha::API
+end
+
+AD::LDAP.configure do |config|
+  config.silent = true
+end

data/test/unit/ad-ldap/adapter_test.rb

@@ -0,0 +1,20 @@
+require 'assert'
+
+class AD::LDAP::Adapter
+
+  class BaseTest < Assert::Context
+    desc "the AD::LDAP::Adapter class"
+    setup do
+      @adapter = AD::LDAP::Adapter.new(AD::LDAP.config)
+    end
+    subject{ @adapter }
+
+    should have_instance_methods :open, :add, :delete, :modify, :search
+    should have_instance_methods :add_attribute, :replace_attribute, :delete_attribute
+
+    should "be a kind of Net::LDAP" do
+      assert_kind_of Net::LDAP, subject
+    end
+  end
+
+end

data/test/unit/ad-ldap/logger_test.rb

@@ -0,0 +1,107 @@
+require 'assert'
+
+class AD::LDAP::Logger
+
+  class BaseTest < Assert::Context
+    desc "the AD::LDAP::Logger class"
+    setup do
+      @config = OpenStruct.new(:silent => true)
+      @logger = AD::LDAP::Logger.new(@config)
+    end
+    subject{ @logger }
+
+    should have_accessors :logger, :silent
+    should have_instance_methods :out
+
+  end
+
+  class OutTest < BaseTest
+    desc "out method"
+    setup do
+      @logger.expects(:generate_message)
+    end
+
+    should "call generate message to build the message to be logged" do
+      assert_nothing_raised do
+        @logger.out(:add, {}, [], "2")
+      end
+    end
+  end
+
+  class GenerateMessageTest < BaseTest
+    desc "generate message method"
+    setup do
+      @arg_sets = [
+        [ :add, [ { :dn => "something", :attributes => { :name => "something" } } ] ],
+        [ :replace_attribute, [ "something", :name, "something_else" ] ],
+        [ :delete_attribute, [ "something", :name ] ]
+      ]
+      @expected_messages = []
+      add_args = @arg_sets[0]
+      @expected_messages.push("#{add_args[0]}(#{add_args[1].first.inspect})")
+      rep_args = @arg_sets[1]
+      params_str = rep_args[1].collect(&:inspect).join(", ")
+      @expected_messages.push("#{rep_args[0]}(#{params_str})")
+      del_args = @arg_sets[2]
+      params_str = del_args[1].collect(&:inspect).join(", ")
+      @expected_messages.push("#{del_args[0]}(#{params_str})")
+    end
+
+    should "build the correct message strings based on different args" do
+      @arg_sets.each_with_index do |args, n|
+        assert_equal @expected_messages[n], subject.send(:generate_message, *args)
+      end
+    end
+  end
+
+  class WithPasswordArgTest < GenerateMessageTest
+    desc "with a filtered arg"
+    setup do
+      @arg_sets = [
+        [ :add, [ { :dn => "something", :attributes => { :password => "something" } } ] ],
+        [ :replace_attribute, [ "something", :unicodePwd, "something_else" ] ]
+      ]
+      @expected_messages = []
+      add_args = @arg_sets[0].dup
+      add_args[1].first[:attributes][:password] = "[FILTERED]"
+      @expected_messages.push("#{add_args[0]}(#{add_args[1].first.inspect})")
+      rep_args = @arg_sets[1].dup
+      rep_args[1][2] = "[FILTERED]"
+      params_str = rep_args[1].collect(&:inspect).join(", ")
+      @expected_messages.push("#{rep_args[0]}(#{params_str})")
+    end
+    
+    should "build the correct message strings with filtered args" do
+      @arg_sets.each_with_index do |args, n|
+        assert_equal @expected_messages[n], subject.send(:generate_message, *args)
+      end
+    end
+  end
+
+  class WithLoggerTest < Assert::Context
+    desc "an AD::LDAP::Logger with a logger"
+    setup do
+      @base_logger = OpenStruct.new
+      @config = OpenStruct.new(:silent => true, :logger => @original_logger)
+      @logger = AD::LDAP::Logger.new(@config)
+    end
+    subject{ @logger }
+
+    class OutTest < WithLoggerTest
+      desc "out method"
+      setup do
+        @logger.expects(:generate_message)
+        @base_logger.expects(:debug)
+      end
+      subject{ @logger }
+
+      should "call generate message to build the message to be logged" do
+        assert_nothing_raised do
+          @logger.out(:add, {}, [], "2")
+        end
+      end
+    end
+
+  end
+
+end

data/test/unit/ad-ldap/response_test.rb

@@ -0,0 +1,44 @@
+require 'assert'
+
+class AD::LDAP::Response
+  
+  class BaseTest < Assert::Context
+    desc "the AD::LDAP::Response class"
+    setup do
+      @response = AD::LDAP::Response.new(AD::LDAP::Response::CODES[:success], "success")
+    end
+    subject{ @response }
+
+    should have_accessors :code, :message
+    should have_instance_methods :handle!
+
+  end
+  
+  class SuccessHandleTest < Assert::Context
+    desc "a successful ldap response handle! method"
+    setup do
+      @response = AD::LDAP::Response.new(AD::LDAP::Response::CODES[:success], "success")
+    end
+    subject{ @response }
+    
+    should "not raise an error" do
+      assert_nothing_raised do
+        subject.handle!
+      end
+    end
+  end
+  
+  class FailureHandleTest < Assert::Context
+    desc "a failed ldap response handle! method"
+    setup do
+      @response = AD::LDAP::Response.new(1, "failed")
+    end
+    subject{ @response }
+    
+    should "not raise an error" do
+      assert_raises(AD::LDAP::Error) do
+        subject.handle!
+      end
+    end
+  end
+end

data/test/unit/ad-ldap/search_args_test.rb

@@ -0,0 +1,144 @@
+require 'assert'
+
+class AD::LDAP::SearchArgs
+  
+  class BaseTest < Assert::Context
+    desc "the AD::LDAP::SearchArgs class"
+    setup do
+      @search_args = AD::LDAP::SearchArgs.new({})
+    end
+    subject{ @search_args }
+    
+    should "be a kind of Hash" do
+      assert_kind_of Hash, subject
+    end
+  end
+  
+  class WithOnlyLDAPKeysTest < Assert::Context
+    desc "the AD::LDAP::SearchArgs initialized with only net-ldap keys"
+    setup do
+      @original = {
+        :base => "DN=something, DC=somewhere, DC=com",
+        :filter => "(name=something)"
+      }
+      @search_args = AD::LDAP::SearchArgs.new(@original)
+    end
+    subject{ @search_args }
+    
+    should "not alter the hash passed to it" do
+      @original.each do |key, value|
+        assert_equal value, @search_args[key]
+      end
+    end
+  end
+  
+  class WithNonLDAPKeysTest < Assert::Context
+    desc "the AD::LDAP::SearchArgs initialized with non net-ldap keys"
+    setup do
+      @original = {
+        :base => "DN=something, DC=somewhere, DC=com",
+        :name => "something"
+      }
+      @expected_filter = Net::LDAP::Filter.eq(:name, @original[:name])
+      @search_args = AD::LDAP::SearchArgs.new(@original)
+    end
+    subject{ @search_args }
+    
+    should "set the filter based off the non net-ldap keys" do
+      assert_equal @original[:base], subject[:base]
+      assert_equal @expected_filter.to_s, subject[:filter].to_s
+    end
+  end
+  
+  class WithMappingsTest < Assert::Context
+    desc "search args with a mapping filter"
+    setup do
+      AD::LDAP.config.mappings = { :dn => "distinguishedname" }
+      @original = { :dn => "something" }
+      @expected_filter = Net::LDAP::Filter.eq(AD::LDAP.config.mappings[:dn], @original[:dn])
+      @search_args = AD::LDAP::SearchArgs.new(@original)
+    end
+    subject{ @search_args }
+    
+    should "use the mapping for the field" do
+      assert_equal @expected_filter.to_s, subject[:filter].to_s
+    end
+    
+    teardown do
+      AD::LDAP.config.mappings = {}
+    end
+  end
+  
+  class WithMultipleFiltersTest < Assert::Context
+    desc "search args with a multiple filters"
+    setup do
+      @original = { :dn => "something", :objectclass => "top" }
+      first_filter = Net::LDAP::Filter.eq(:dn, @original[:dn])
+      second_filter = Net::LDAP::Filter.eq(:objectclass, @original[:objectclass])
+      @expected_filter = Net::LDAP::Filter.join(second_filter, first_filter)
+      @search_args = AD::LDAP::SearchArgs.new(@original)
+    end
+    subject{ @search_args }
+    
+    should "join the filters together" do
+      assert_equal @expected_filter.to_s, subject[:filter].to_s
+    end
+  end
+  
+  class WithEqualFilterTest < Assert::Context
+    desc "search args with a equal filter"
+    setup do
+      @original = { :name__eq => "something" }
+      @expected_filter = Net::LDAP::Filter.eq(:name, @original[:name__eq])
+      @search_args = AD::LDAP::SearchArgs.new(@original)
+    end
+    subject{ @search_args }
+    
+    should "create an equal filter for the field" do
+      assert_equal @expected_filter.to_s, subject[:filter].to_s
+    end
+  end
+  
+  class WithNotEqualFilterTest < Assert::Context
+    desc "search args with a not equal filter"
+    setup do
+      @original = { :name__ne => "something" }
+      @expected_filter = Net::LDAP::Filter.ne(:name, @original[:name__ne])
+      @search_args = AD::LDAP::SearchArgs.new(@original)
+    end
+    subject{ @search_args }
+    
+    should "create a not equal filter for the field" do
+      assert_equal @expected_filter.to_s, subject[:filter].to_s
+    end
+  end
+  
+  class WithGreaterThanOrEqualFilterTest < Assert::Context
+    desc "search args with a greater than or equal filter"
+    setup do
+      @original = { :number__ge => 1 }
+      @expected_filter = Net::LDAP::Filter.ge(:number, @original[:number__ge])
+      @search_args = AD::LDAP::SearchArgs.new(@original)
+    end
+    subject{ @search_args }
+    
+    should "create a greater than or equal filter for the field" do
+      assert_equal @expected_filter.to_s, subject[:filter].to_s
+    end
+  end
+  
+  class WithLessThanOrEqualFilterTest < Assert::Context
+    desc "search args with a less than or equal filter"
+    setup do
+      @original = { :number__le => 1 }
+      @expected_filter = Net::LDAP::Filter.le(:number, @original[:number__le])
+      @search_args = AD::LDAP::SearchArgs.new(@original)
+    end
+    subject{ @search_args }
+    
+    should "create a less than or equal filter for the field" do
+      assert_equal @expected_filter.to_s, subject[:filter].to_s
+    end
+  end
+  
+end

data/test/unit/ad-ldap_test.rb

@@ -0,0 +1,139 @@
+require 'assert'
+
+module AD::LDAP
+
+  class BaseTest < Assert::Context
+    desc "the module AD::LDAP"
+    setup do
+      @module = AD::LDAP.dup
+    end
+    subject{ @module }
+
+    [ :configure, :config, :adapter, :logger, :add, :delete, :replace_attribute, :delete_attribute,
+      :search, :bind_as
+    ].each do |method|
+      should "respond to ##{method}" do
+        assert_respond_to subject, method
+      end
+    end
+
+    should "return an instance of OpenStruct with #config" do
+      assert_instance_of OpenStruct, subject.config
+    end
+    should "return an instance of AD::LDAP::Adapter with #adapter" do
+      assert_instance_of AD::LDAP::Adapter, subject.adapter
+    end
+    should "return an instance of AD::LDAP::Logger with #logger" do
+      assert_instance_of AD::LDAP::Logger, subject.logger
+    end
+
+    should "call it's run method when the method #add is called" do
+      args = [ { :dn => "something", :attributes => { :name => "something" } } ]
+      @module.expects(:run).with(:add, *args)
+      assert_nothing_raised{ @module.add(*args) }
+    end
+    should "call it's run method when the method #delete is called" do
+      args = [ "something" ]
+      @module.expects(:run).with(:delete, { :dn => args.first })
+      assert_nothing_raised{ @module.delete(*args) }
+    end
+    should "call it's run method when the method #replace_attribute is called" do
+      args = [ "something", :name, "silly" ]
+      @module.expects(:run).with(:replace_attribute, *args)
+      assert_nothing_raised{ @module.replace_attribute(*args) }
+    end
+    should "call it's run method when the method #delete_attribute is called" do
+      args = [ "something", :name ]
+      @module.expects(:run).with(:delete_attribute, *args)
+      assert_nothing_raised{ @module.delete_attribute(*args) }
+    end
+
+    should "call it's run_search method when the method #search is called" do
+      args = [ { :name => "something" } ]
+      @module.expects(:run_search).with(*args)
+      assert_nothing_raised{ @module.search(*args) }
+    end
+
+  end
+
+  class BindAsTest < AD::LDAP::BaseTest
+    desc "bind_as method"
+
+    should "call the run method with net-ldap args" do
+      args = [ { :filter => "(name=something)", :password => "poop" } ]
+      @module.expects(:run).with(:bind_as, *args)
+      assert_nothing_raised{ @module.bind_as(*args) }
+    end
+    should "call the run method with net-ldap args given no filter" do
+      args = { :name => "something", :password => "poop" }
+      search_args = args.dup.reject{|(k, v)| k == :password }
+      @module.expects(:run).with(:bind_as, {
+        :filter => AD::LDAP::SearchArgs.new(search_args)[:filter],
+        :password => args[:password]
+      })
+      assert_nothing_raised{ @module.bind_as(args) }
+    end
+
+  end
+
+  class RunTest < AD::LDAP::BaseTest
+    desc "run method"
+    setup do
+      mock_config = mock()
+      mock_config.expects(:run_commands)
+      @module.expects(:config).returns(mock_config)
+      Benchmark.expects(:measure)
+      mock_adapter = mock()
+      mock_adapter.expects(:add)
+      @module.expects(:adapter).returns(mock_adapter)
+      mock_logger = mock()
+      mock_logger.expects(:out)
+      @module.expects(:logger).returns(mock_logger)
+    end
+    subject{ @module }
+
+    should "call the method passed to it on the adapter and benchmark it" do
+      assert_nothing_raised do
+        subject.send(:run, :add, { :dn => "something" })
+      end
+    end
+
+  end
+
+  class RunSearchTest < AD::LDAP::BaseTest
+    desc "run_search method"
+    setup do
+      @args = { :size => 2, :name => "something" }
+      mock_config = mock()
+      mock_config.stubs(:search_size_supported).returns(false)
+      @module.stubs(:config).returns(mock_config)
+      @module.expects(:run).returns([ "a", "b", "c" ])
+    end
+    subject{ @module }
+
+    should "call run with :search and pass it the search args" do
+      results = nil
+      assert_nothing_raised do
+        results = subject.send(:run_search, @args)
+      end
+      assert_instance_of Array, results
+      assert_equal @args[:size], results.size
+    end
+  end
+
+  class ConfigureTest < AD::LDAP::BaseTest
+    desc "configure method"
+    setup do
+      AD::LDAP.configure do |config|
+        @config = config
+      end
+    end
+    subject{ @config }
+
+    should "yield it's config" do
+      assert_kind_of OpenStruct, subject
+      assert_equal AD::LDAP.config, subject
+    end
+  end
+
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification 
+name: ad-ldap
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Collin Redding
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-17 00:00:00 -05:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: net-ldap
+  prerelease: false
+  version_requirements: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 19
+        segments: 
+        - 0
+        - 2
+        - 2
+        version: 0.2.2
+  type: :runtime
+  requirement: *id001
+- !ruby/object:Gem::Dependency 
+  name: assert
+  prerelease: false
+  version_requirements: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  type: :development
+  requirement: *id002
+- !ruby/object:Gem::Dependency 
+  name: mocha
+  prerelease: false
+  version_requirements: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 0
+        - 9
+        - 12
+        version: 0.9.12
+  type: :development
+  requirement: *id003
+description: A small wrapper to Net::LDAP to provide some extended functionality and utility.
+email: 
+executables: []
+
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- ad-ldap.gemspec
+- lib/ad-ldap.rb
+- lib/ad-ldap/adapter.rb
+- lib/ad-ldap/exceptions.rb
+- lib/ad-ldap/logger.rb
+- lib/ad-ldap/response.rb
+- lib/ad-ldap/search_args.rb
+- lib/ad-ldap/version.rb
+- test/helper.rb
+- test/unit/ad-ldap/adapter_test.rb
+- test/unit/ad-ldap/logger_test.rb
+- test/unit/ad-ldap/response_test.rb
+- test/unit/ad-ldap/search_args_test.rb
+- test/unit/ad-ldap_test.rb
+has_rdoc: true
+homepage: http://github.com/teaminsight/ad-ldap
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: ad-ldap
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: A small wrapper to Net::LDAP to provide some extended functionality and utility.
+test_files: 
+- test/helper.rb
+- test/unit/ad-ldap/adapter_test.rb
+- test/unit/ad-ldap/logger_test.rb
+- test/unit/ad-ldap/response_test.rb
+- test/unit/ad-ldap/search_args_test.rb
+- test/unit/ad-ldap_test.rb