activeldap 0.9.0

data/test/test-unit-ext/always-show-result.rb

@@ -0,0 +1,28 @@
+require "test/unit/ui/testrunnermediator"
+
+module Test
+  module Unit
+    module UI
+      class TestRunnerMediator
+        alias_method :original_run_suite, :run_suite
+        def run_suite
+          @notified_finished = false
+          begin_time = Time.now
+          original_run_suite
+        rescue Interrupt
+          unless @notified_finished
+            end_time = Time.now
+            elapsed_time = end_time - begin_time
+            notify_listeners(FINISHED, elapsed_time)
+          end
+          raise
+        end
+
+        def notify_listeners(channel_name, *arguments)
+          @notified_finished = true if channel_name == FINISHED
+          super
+        end
+      end
+    end
+  end
+end

data/test/test-unit-ext/backtrace-filter.rb

@@ -0,0 +1,17 @@
+require 'test/unit/util/backtracefilter'
+
+module Test
+  module Unit
+    module Util
+      module BacktraceFilter
+        TEST_UNIT_EXT_PREFIX = File.dirname(__FILE__)
+
+        alias_method :original_filter_backtrace, :filter_backtrace
+        def filter_backtrace(backtrace, prefix=nil)
+          original_result = original_filter_backtrace(backtrace, prefix)
+          original_filter_backtrace(original_result, TEST_UNIT_EXT_PREFIX)
+        end
+      end
+    end
+  end
+end

data/test/test-unit-ext/long-display-for-emacs.rb

@@ -0,0 +1,25 @@
+require 'test/unit/failure'
+require 'test/unit/error'
+
+module Test
+  module Unit
+    BACKTRACE_INFO_RE = /.+:\d+:in `.+?'/
+    class Failure
+      alias_method :original_long_display, :long_display
+      def long_display
+        extract_backtraces_re =
+          /^    \[(#{BACKTRACE_INFO_RE}(?:\n     #{BACKTRACE_INFO_RE})+)\]:$/
+        original_long_display.gsub(extract_backtraces_re) do |backtraces|
+          $1.gsub(/^     (#{BACKTRACE_INFO_RE})/, '\1') + ':'
+        end
+      end
+    end
+
+    class Error
+      alias_method :original_long_display, :long_display
+      def long_display
+        original_long_display.gsub(/^    (#{BACKTRACE_INFO_RE})/, '\1')
+      end
+    end
+  end
+end

data/test/test-unit-ext/priority.rb

@@ -0,0 +1,163 @@
+require "test/unit"
+
+require "fileutils"
+
+module Test
+  module Unit
+    class TestCase
+      class << self
+        def inherited(sub)
+          super
+          sub.instance_variable_set("@priority_initialized", true)
+          sub.instance_variable_set("@priority_table", {})
+          sub.priority :normal
+        end
+
+        def include(*args)
+          args.reverse_each do |mod|
+            super(mod)
+            next unless defined?(@priority_initialized)
+            mod.instance_methods(false).each do |name|
+              set_priority(name)
+            end
+          end
+        end
+
+        def method_added(name)
+          set_priority(name) if defined?(@priority_initialized)
+        end
+
+        def priority(name, *tests)
+          unless private_methods.include?(priority_check_method_name(name))
+            raise ArgumentError, "unknown priority: #{name}"
+          end
+          if tests.empty?
+            @current_priority = name
+          else
+            tests.each do |test|
+              set_priority(test, name)
+            end
+          end
+        end
+
+        def need_to_run?(test_name)
+          normalized_test_name = normalize_test_name(test_name)
+          priority = @priority_table[normalized_test_name]
+          return true unless priority
+          __send__(priority_check_method_name(priority), test_name)
+        end
+
+        private
+        def priority_check_method_name(priority_name)
+          "run_priority_#{priority_name}?"
+        end
+
+        def normalize_test_name(test_name)
+          "test_#{test_name.to_s.sub(/^test_/, '')}"
+        end
+
+        def set_priority(name, priority=@current_priority)
+          @priority_table[normalize_test_name(name)] = priority
+        end
+
+        def run_priority_must?(test_name)
+          true
+        end
+
+        def run_priority_important?(test_name)
+          rand > 0.1
+        end
+
+        def run_priority_high?(test_name)
+          rand > 0.3
+        end
+
+        def run_priority_normal?(test_name)
+          rand > 0.5
+        end
+
+        def run_priority_low?(test_name)
+          rand > 0.75
+        end
+
+        def run_priority_never?(test_name)
+          false
+        end
+      end
+
+      def need_to_run?
+        !previous_test_success? or self.class.need_to_run?(@method_name)
+      end
+
+      alias_method :original_run, :run
+      def run(result, &block)
+        original_run(result, &block)
+      ensure
+        if passed?
+          FileUtils.touch(passed_file)
+        else
+          FileUtils.rm_f(passed_file)
+        end
+      end
+
+      private
+      def previous_test_success?
+        File.exist?(passed_file)
+      end
+
+      def result_dir
+        dir = File.join(File.dirname($0), ".test-result",
+                        self.class.name, @method_name.to_s)
+        dir = File.expand_path(dir)
+        FileUtils.mkdir_p(dir)
+        dir
+      end
+
+      def passed_file
+        File.join(result_dir, "passed")
+      end
+    end
+
+    class TestSuite
+      @@priority_mode = false
+
+      class << self
+        def priority_mode=(bool)
+          @@priority_mode = bool
+        end
+      end
+
+      alias_method :original_run, :run
+      def run(*args, &block)
+        priority_mode = @@priority_mode
+        if priority_mode
+          @original_tests = @tests
+          apply_priority
+        end
+        original_run(*args, &block)
+      ensure
+        @tests = @original_tests if priority_mode
+      end
+
+      def apply_priority
+        @tests = @tests.reject {|test| !test.need_to_run?}
+      end
+
+      def need_to_run?
+        apply_priority
+        !@tests.empty?
+      end
+    end
+
+    class AutoRunner
+      alias_method :original_options, :options
+      def options
+        opts = original_options
+        opts.on("--[no-]priority", "use priority mode") do |bool|
+          TestSuite.priority_mode = bool
+        end
+        opts
+      end
+    end
+  end
+end

data/test/test-unit-ext.rb

@@ -0,0 +1,4 @@
+require "test-unit-ext/always-show-result"
+require "test-unit-ext/priority"
+require "test-unit-ext/backtrace-filter"
+require "test-unit-ext/long-display-for-emacs"

data/test/test_acts_as_tree.rb

@@ -0,0 +1,57 @@
+require 'al-test-utils'
+
+class TestActsAsTree < Test::Unit::TestCase
+  include AlTestUtils
+
+  priority :must
+
+  priority :normal
+  def test_children
+    users = ou_class.find("Users")
+    assert_equal([], users.children.collect(&:ou))
+
+    sub_users = users.class.new("SubUsers")
+    users.children << sub_users
+    assert_equal(["SubUsers"], users.children.collect(&:ou))
+
+    users = ou_class.find("Users")
+    assert_equal(["SubUsers"], users.children.collect(&:ou))
+
+    assert_equal("ou=SubUsers,#{users.dn}", sub_users.dn)
+
+    assert(ou_class.exists?("SubUsers"))
+    users.children.replace([])
+    assert(!ou_class.exists?("SubUsers"))
+    assert_equal([], users.children.collect(&:ou))
+  end
+
+  def test_parent
+    users = ou_class.find("Users")
+    assert_equal([], users.children.collect(&:ou))
+
+    sub_users = users.class.new("SubUsers")
+    sub_users.parent = users
+    assert_equal("ou=SubUsers,#{users.dn}", sub_users.dn)
+    assert_equal(["SubUsers"], users.children.collect(&:ou))
+
+    sub_users = ou_class.find("SubUsers")
+    assert_equal(users.dn, sub_users.parent.dn)
+
+    assert_raises(ArgumentError) do
+      sub_users.parent = nil
+    end
+
+    make_ou("OtherUsers")
+    other_users = ou_class.find("OtherUsers")
+    assert_equal([], other_users.children.collect(&:ou))
+
+    sub_users.parent = other_users.dn
+    assert_equal("ou=SubUsers,#{other_users.dn}", sub_users.dn)
+
+    other_users.clear_association_cache
+    assert_equal(["SubUsers"], other_users.children.collect(&:ou))
+
+    users.clear_association_cache
+    assert_equal([], users.children.collect(&:ou))
+  end
+end

data/test/test_adapter.rb

@@ -0,0 +1,98 @@
+require 'al-test-utils'
+
+class TestAdapter < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  priority :must
+
+  priority :normal
+  def test_filter_with_escaped_character
+    assert_parse_filter("(uid=Alice\\28Bob)", {:uid => "Alice(Bob"})
+    assert_parse_filter("(uid=Alice\\29Bob)", {:uid => "Alice)Bob"})
+    assert_parse_filter("(uid=Alice\\29Bob\\28)", {:uid => "Alice)Bob("})
+    assert_parse_filter("(uid=Alice\\28\\29Bob)", {:uid => "Alice()Bob"})
+    assert_parse_filter("(uid=Alice*Bob)", {:uid => "Alice*Bob"})
+    assert_parse_filter("(uid=Alice\\2ABob)", {:uid => "Alice**Bob"})
+    assert_parse_filter("(uid=Alice\\2A*\\5CBob)", {:uid => "Alice***\\Bob"})
+    assert_parse_filter("(uid=Alice\\5C\\2A*Bob)", {:uid => "Alice\\***Bob"})
+  end
+
+  def test_empty_filter
+    assert_parse_filter(nil, nil)
+    assert_parse_filter(nil, "")
+    assert_parse_filter(nil, "   ")
+  end
+
+  def test_simple_filter
+    assert_parse_filter("(objectClass=*)", "objectClass=*")
+    assert_parse_filter("(objectClass=*)", "(objectClass=*)")
+    assert_parse_filter("(&(uid=bob)(objectClass=*))",
+                        "(&(uid=bob)(objectClass=*))")
+
+    assert_parse_filter("(objectClass=*)", {:objectClass => "*"})
+    assert_parse_filter("(&(objectClass=*)(uid=bob))",
+                        {:uid => "bob", :objectClass => "*"})
+
+    assert_parse_filter("(&(uid=bob)(objectClass=*))",
+                        [:and, "uid=bob", "objectClass=*"])
+    assert_parse_filter("(&(uid=bob)(objectClass=*))",
+                        [:&, "uid=bob", "objectClass=*"])
+    assert_parse_filter("(|(uid=bob)(objectClass=*))",
+                        [:or, "uid=bob", "objectClass=*"])
+    assert_parse_filter("(|(uid=bob)(objectClass=*))",
+                        [:|, "uid=bob", "objectClass=*"])
+  end
+
+  def test_multi_value_filter
+    assert_parse_filter("(&(objectClass=top)(objectClass=posixAccount))",
+                        {:objectClass => ["top", "posixAccount"]})
+
+    assert_parse_filter("(&(objectClass=top)(objectClass=posixAccount))",
+                        [[:objectClass, "top"],
+                         [:objectClass, "posixAccount"]])
+    assert_parse_filter("(&(objectClass=top)(objectClass=posixAccount))",
+                        [[:objectClass, ["top", "posixAccount"]]])
+  end
+
+  def test_nested_filter
+    assert_parse_filter("(&(objectClass=*)(uid=bob))",
+                        [:and, {:uid => "bob", :objectClass => "*"}])
+    assert_parse_filter("(&(objectClass=*)(|(uid=bob)(uid=alice)))",
+                        [:and, {:objectClass => "*"},
+                         [:or, [:uid, "bob"], [:uid, "alice"]]])
+    assert_parse_filter("(&(objectClass=*)(|(uid=bob)(uid=alice)))",
+                        [:and,
+                         {:objectClass => "*",
+                          :uid => [:or, "bob", "alice"]}])
+    assert_parse_filter("(&(gidNumber=100001)" +
+                        "(|(uid=temp-user1)(uid=temp-user2)))",
+                        [:and,
+                         [:and, {"gidNumber"=>["100001"]}],
+                         [:or, {"uid"=>["temp-user1", "temp-user2"]}]])
+    assert_parse_filter("(&(gidNumber=100001)" +
+                        "(objectClass=person)(objectClass=posixAccount))",
+                        [:and,
+                         [:or, ["gidNumber", "100001"]],
+                         ["objectClass", "person"],
+                         ["objectClass", "posixAccount"]])
+  end
+
+  def test_invalid_operator
+    assert_raises(ArgumentError) do
+      assert_parse_filter("(&(objectClass=*)(uid=bob))",
+                          [:xxx, {:uid => "bob", :objectClass => "*"}])
+    end
+  end
+
+  private
+  def assert_parse_filter(expected, filter)
+    adapter = ActiveLdap::Adapter::Base.new
+    assert_equal(expected, adapter.send(:parse_filter, filter))
+  end
+end