ruby-activeldap 0.8.2 → 0.8.3

data/test/command.rb

@@ -1,62 +0,0 @@
-require "thread"
-require "socket"
-require "shellwords"
-
-module Command
-  class Error < StandardError
-    attr_reader :command, :result
-    def initialize(command, result)
-      @command = command
-      @result = result
-      super("#{command}: #{result}")
-    end
-  end
-
-  module_function
-  def detach_io
-    require 'fcntl'
-    [TCPSocket, ::File].each do |c|
-      ObjectSpace.each_object(c) do |io|
-        begin
-          unless io.closed?
-            io.fcntl(Fcntl::F_SETFD, Fcntl::FD_CLOEXEC)
-          end
-        rescue SystemCallError,IOError => e
-        end
-      end
-    end
-  end
-
-  def run(cmd, *args)
-    raise ArgumentError, "command isn't specified" if cmd.nil?
-    if args.any? {|x| x.nil?}
-      raise ArgumentError, "args has nil: #{args.inspect}"
-    end
-    in_r, in_w = IO.pipe
-    out_r, out_w = IO.pipe
-    pid = exit_status = nil
-    Thread.exclusive do
-      verbose = $VERBOSE
-      # ruby(>=1.8)'s fork terminates other threads with warning messages
-      $VERBOSE = nil
-      pid = fork do
-        $VERBOSE = verbose
-        detach_io
-        out = STDERR.dup
-        STDIN.reopen(in_r)
-        in_r.close
-        STDOUT.reopen(out_w)
-        STDERR.reopen(out_w)
-        out_w.close
-        exec(cmd, *args.collect {|arg| arg.to_s})
-        exit!(-1)
-      end
-      $VERBOSE = verbose
-    end
-    yield(out_r, in_w) if block_given?
-    in_r.close unless in_r.closed?
-    out_w.close unless out_w.closed?
-    pid, status = Process.waitpid2(pid)
-    [status.exited? && status.exitstatus.zero?, out_r.read]
-  end
-end

data/test/config.yaml.sample

@@ -1,6 +0,0 @@
-test:
-  host: 127.0.0.1
-  base: dc=test,dc=localdomain
-  method: :tls
-  bind_dn: cn=user-name,dc=localdomain
-  password: secret

data/test/run-test.rb

@@ -1,29 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'yaml'
-require "test/unit"
-
-base_dir = File.expand_path(File.dirname(__FILE__))
-top_dir = File.expand_path(File.join(base_dir, ".."))
-$LOAD_PATH.unshift(File.join(top_dir, "lib"))
-$LOAD_PATH.unshift(File.join(top_dir, "test"))
-
-require 'test-unit-ext'
-
-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.rb

@@ -1,2 +0,0 @@
-require "test-unit-ext/always-show-result"
-require "test-unit-ext/priority"

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

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

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