ruby-activeldap 0.8.1 → 0.8.2

data/lib/active_ldap/validations.rb

@@ -12,23 +12,20 @@ module ActiveLdap
         validate :validate_required_values
 
         class << self
-          alias_method :evaluate_condition_for_active_record,
-                       :evaluate_condition
-          def evaluate_condition(condition, entry)
-            evaluate_condition_for_active_record(condition, entry)
+          def evaluate_condition_with_active_ldap_support(condition, entry)
+            evaluate_condition_without_active_ldap_support(condition, entry)
           rescue ActiveRecord::ActiveRecordError
             raise Error, $!.message
           end
+          alias_method_chain :evaluate_condition, :active_ldap_support
         end
 
-        alias_method :save_with_validation_for_active_record!,
-                     :save_with_validation!
-        def save_with_validation!
-          save_with_validation_for_active_record!
+        def save_with_active_ldap_support!
+          save_without_active_ldap_support!
         rescue ActiveRecord::RecordInvalid
           raise EntryInvalid, $!.message
         end
-        alias_method :save!, :save_with_validation!
+        alias_method_chain :save!, :active_ldap_support
 
         def valid?
           ensure_apply_object_class
@@ -46,7 +43,8 @@ module ActiveLdap
           @musts.each do |object_class, attributes|
             attributes.each do |required_attribute|
               # Normalize to ensure we catch schema problems
-              real_name = to_real_attribute_name(required_attribute)
+              real_name = to_real_attribute_name(required_attribute, true)
+              raise UnknownAttribute.new(required_attribute) if real_name.nil?
               # # Set default if it wasn't yet set.
               # @data[real_name] ||= [] # need?
               value = @data[real_name] || []
@@ -66,12 +64,12 @@ module ActiveLdap
         end
 
         private
-        alias_method :run_validations_for_active_record, :run_validations
-        def run_validations(validation_method)
-          run_validations_for_active_record(validation_method)
+        def run_validations_with_active_ldap_support(validation_method)
+          run_validations_without_active_ldap_support(validation_method)
         rescue ActiveRecord::ActiveRecordError
           raise Error, $!.message
         end
+        alias_method_chain :run_validations, :active_ldap_support
       end
     end
   end

data/rails/plugin/active_ldap/generators/scaffold_al/scaffold_al_generator.rb

@@ -0,0 +1,7 @@
+class ScaffoldAlGenerator < Rails::Generator::Base
+  def manifest
+    record do |m|
+      m.template("ldap.yml", File.join("config", "ldap.yml"))
+    end
+  end
+end

data/rails/plugin/active_ldap/generators/scaffold_al/templates/ldap.yml

@@ -0,0 +1,21 @@
+development:
+  host: 127.0.0.1
+  port: 389
+  base: dc=devel,dc=local,dc=net
+  bind_dn: cn=admin,dc=local,dc=net
+  password: secret
+
+test:
+  host: 127.0.0.1
+  port: 389
+  base: dc=test,dc=local,dc=net
+  bind_dn: cn=admin,dc=local,dc=net
+  password: secret
+
+production:
+  host: 127.0.0.1
+  port: 389
+  method: :tls
+  base: dc=production,dc=local,dc=net
+  bind_dn: cn=admin,dc=local,dc=net
+  password: secret

data/rails/plugin/active_ldap/init.rb

@@ -1,6 +1,12 @@
-require_dependency 'active_ldap'
+require_library_or_gem 'active_ldap'
 ActiveLdap::Base.logger ||= RAILS_DEFAULT_LOGGER
 ldap_configuration_file = File.join(RAILS_ROOT, 'config', 'ldap.yml')
-configurations = YAML::load(ERB.new(IO.read(ldap_configuration_file)).result)
-ActiveLdap::Base.configurations = configurations
-ActiveLdap::Base.establish_connection
+if File.exist?(ldap_configuration_file)
+  configurations = YAML::load(ERB.new(IO.read(ldap_configuration_file)).result)
+  ActiveLdap::Base.configurations = configurations
+  ActiveLdap::Base.establish_connection
+else
+  message = "You should run 'script/generator scaffold_al' " +
+    "to make #{ldap_configuration_file}"
+  ActiveLdap::Base.logger.error(message)
+end

data/test/al-test-utils.rb

@@ -22,6 +22,7 @@ module AlTestUtils
       include Populate
       include TemporaryEntry
       include CommandSupport
+      include MockLogger
     end
   end
 
@@ -47,7 +48,12 @@ module AlTestUtils
       unless File.exist?(@config_file)
         raise "config file for testing doesn't exist: #{@config_file}"
       end
-      YAML.load(ERB.new(File.read(@config_file)).result)
+      config = YAML.load(ERB.new(File.read(@config_file)).result)
+      config.each do |key, value|
+        adapter = ENV["ACTIVE_LDAP_TEST_ADAPTER"]
+        value[:adapter] = adapter if adapter
+      end
+      config
     end
   end
 
@@ -112,7 +118,10 @@ module AlTestUtils
         next if dc_class.exists?(value, :prefix => "dc=#{value}")
         dc = dc_class.new(value)
         dc.o = dc.dc
-        dc.save
+        begin
+          dc.save
+        rescue ActiveLdap::OperationNotPermitted
+        end
       end
     end
 
@@ -136,10 +145,11 @@ module AlTestUtils
 
     def populate_user_class
       @user_class = Class.new(ActiveLdap::Base)
+      @user_class_classes = ["posixAccount", "person"]
       @user_class.ldap_mapping :dn_attribute => "uid",
                                :prefix => "ou=Users",
                                :scope => :sub,
-                               :classes => ["posixAccount", "person"]
+                               :classes => @user_class_classes
     end
 
     def populate_group_class
@@ -335,4 +345,37 @@ module AlTestUtils
       Command.run(*args, &block)
     end
   end
+
+  module MockLogger
+    def make_mock_logger
+      logger = Object.new
+      class << logger
+        def messages(type)
+          @messages ||= {}
+          @messages[type] ||= []
+          @messages[type]
+        end
+
+        def info(content=nil)
+          messages(:info) << (block_given? ? yield : content)
+        end
+        def warn(content=nil)
+          messages(:warn) << (block_given? ? yield : content)
+        end
+        def error(content=nil)
+          messages(:error) << (block_given? ? yield : content)
+        end
+      end
+      logger
+    end
+
+    def with_mock_logger
+      original_logger = ActiveLdap::Base.logger
+      mock_logger = make_mock_logger
+      ActiveLdap::Base.logger = mock_logger
+      yield(mock_logger)
+    ensure
+      ActiveLdap::Base.logger = original_logger
+    end
+  end
 end

data/test/run-test.rb

@@ -10,8 +10,20 @@ $LOAD_PATH.unshift(File.join(top_dir, "test"))
 
 require 'test-unit-ext'
 
-if Test::Unit::AutoRunner.respond_to?(:standalone?)
-  exit Test::Unit::AutoRunner.run($0, File.dirname($0))
-else
-  exit Test::Unit::AutoRunner.run(false, File.dirname($0))
+test_file = "test/test_*.rb"
+Dir.glob(test_file) do |file|
+  require file
+end
+
+[nil, "ldap", "net-ldap"].each do |adapter|
+  ENV["ACTIVE_LDAP_TEST_ADAPTER"] = adapter
+  puts "using adapter: #{adapter ? adapter : 'default'}"
+  args = [File.dirname($0), ARGV.dup]
+  if Test::Unit::AutoRunner.respond_to?(:standalone?)
+    args.unshift(false)
+  else
+    args.unshift($0)
+  end
+  Test::Unit::AutoRunner.run(*args)
+  puts
 end

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/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.rm_f(not_passed_file)
+        else
+          FileUtils.touch(not_passed_file)
+        end
+      end
+
+      private
+      def previous_test_success?
+        not File.exist?(not_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 not_passed_file
+        File.join(result_dir, "not-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_adapter.rb

@@ -0,0 +1,81 @@
+require 'al-test-utils'
+
+class TestAdapter < Test::Unit::TestCase
+  include AlTestUtils
+
+  def setup
+  end
+
+  def teardown
+  end
+
+  priority :must
+
+  priority :normal
+  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"]}]])
+  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