activesambaldap 0.0.1

data/test/asl-test-utils.rb

@@ -0,0 +1,276 @@
+require 'test/unit'
+require 'test-unit-ext'
+
+require 'rbconfig'
+require 'fileutils'
+require 'tmpdir'
+
+require File.join(File.dirname(__FILE__), "command")
+
+require 'active_samba_ldap'
+
+module AslTestUtils
+  def self.included(base)
+    base.class_eval do
+      include Configuration
+      include Connection
+      include Populate
+      include TemporaryEntry
+      include CommandSupport
+    end
+  end
+
+  module Configuration
+    def setup
+      super
+      @test_dir = File.expand_path(File.dirname(__FILE__))
+      @top_dir = File.expand_path(File.join(@test_dir, ".."))
+      @parent_dir = File.expand_path(File.join(@top_dir, ".."))
+      @config_file = File.join(@test_dir, "config.yaml")
+      ActiveSambaLdap::Base.configurations = read_config
+    end
+
+    def teardown
+      super
+    end
+
+    def reference_configuration
+      ActiveSambaLdap::Base.configurations["reference"]
+    end
+
+    def update_configuration
+      ActiveSambaLdap::Base.configurations["update"]
+    end
+
+    def read_config
+      unless File.exist?(@config_file)
+        raise "config file for testing doesn't exist: #{@config_file}"
+      end
+      ActiveSambaLdap::Configuration.read(@config_file)
+    end
+  end
+
+  module Connection
+    def setup
+      super
+      ActiveSambaLdap::Base.establish_connection(update_configuration)
+    end
+
+    def teardown
+      super
+      ActiveSambaLdap::Base.clear_active_connections!
+    end
+  end
+
+  module Populate
+    def setup
+      super
+      @dumped_data = ""
+      begin
+        @dumped_data = ActiveSambaLdap::Base.dump(:scope => :sub)
+      rescue ActiveLdap::ConnectionError
+      end
+      ActiveSambaLdap::Base.purge
+      ActiveSambaLdap::Base.populate
+    end
+
+    def teardown
+      super
+      ActiveSambaLdap::Base.establish_connection(update_configuration)
+      ActiveSambaLdap::Base.purge
+      ActiveSambaLdap::Base.load(@dumped_data)
+    end
+  end
+
+  module TemporaryEntry
+    def setup
+      super
+      @user_class = Class.new(ActiveSambaLdap::SambaUser)
+      @user_class.ldap_mapping
+      @computer_class = Class.new(ActiveSambaLdap::SambaComputer)
+      @computer_class.ldap_mapping
+      @group_class = Class.new(ActiveSambaLdap::SambaGroup)
+      @group_class.ldap_mapping
+
+      @user_class.set_associated_class(:primary_group, @group_class)
+      @computer_class.set_associated_class(:primary_group, @group_class)
+      @user_class.set_associated_class(:groups, @group_class)
+      @computer_class.set_associated_class(:groups, @group_class)
+
+      @group_class.set_associated_class(:users, @user_class)
+      @group_class.set_associated_class(:computers, @computer_class)
+      @group_class.set_associated_class(:primary_users, @user_class)
+      @group_class.set_associated_class(:primary_computers, @computer_class)
+
+      @user_index = 0
+      @computer_index = 0
+      @group_index = 0
+    end
+
+    def make_dummy_user(config={})
+      @user_index += 1
+      name = config[:name] || "test-user#{@user_index}"
+      home_directory = config[:home_directory] || "/tmp/#{name}-#{Process.pid}"
+      ensure_delete_user(name, home_directory) do
+        password = config[:password] || "password"
+        uid_number = config[:uid_number] || "100000#{@user_index}"
+        default_user_gid = @user_class.configuration[:default_user_gid]
+        gid_number = config[:gid_number] || default_user_gid
+        _wrap_assertion do
+          assert(!@user_class.exists?(name))
+          options = {
+            :uid => name,
+            :uid_number => uid_number,
+            :group => @group_class.find_by_gid_number(gid_number),
+            :home_directory => home_directory,
+            :password => password,
+          }
+          user = @user_class.create(options)
+          assert_equal([], user.errors.to_a)
+          user.save!
+          FileUtils.mkdir(home_directory)
+          assert(@user_class.exists?(name))
+          yield(user, password)
+        end
+      end
+    end
+
+    def ensure_delete_user(uid, home=nil)
+      yield(uid, home)
+    ensure
+      if @user_class.exists?(uid)
+        @user_class.find(uid).destroy(:remove_from_group => true,
+                                      :remove_home_directory => true)
+      end
+      FileUtils.rm_rf(home) if home
+    end
+
+    def make_dummy_computer(config={})
+      @computer_index += 1
+      name = config[:name] || "test-computer#{@computer_index}$"
+      home_directory = config[:home_directory] || "/tmp/#{name}-#{Process.pid}"
+      ensure_delete_computer(name, home_directory) do |name, home_directory|
+        password = config[:password]
+        uid_number = config[:uid_number] || "100000#{@computer_index}"
+        default_computer_gid =
+          @computer_class.configuration[:default_computer_gid]
+        gid_number = config[:gid_number] || default_computer_gid
+        _wrap_assertion do
+          assert(!@computer_class.exists?(name))
+          options = {
+            :uid => name,
+            :uid_number => uid_number,
+            :group => @group_class.find_by_gid_number(gid_number),
+            :password => password,
+          }
+          computer = @computer_class.create(options)
+          assert_equal([], computer.errors.to_a)
+          FileUtils.mkdir(home_directory)
+          assert(@computer_class.exists?(name))
+          yield(computer, password)
+        end
+      end
+    end
+
+    def ensure_delete_computer(uid, home=nil)
+      yield(uid.sub(/\$+\z/, '') + "$", home)
+    ensure
+      if @computer_class.exists?(uid)
+        @computer_class.find(uid).destroy(:remove_from_group => true,
+                                          :remove_home_directory => true)
+      end
+      FileUtils.rm_rf(home) if home
+    end
+
+    def make_dummy_group(config={})
+      @group_index += 1
+      name = config[:name] || "test-group#{@group_index}"
+      ensure_delete_group(name) do
+        gid_number = config[:gid_number] || "200000#{@group_index}"
+        group_type = config[:group_type] || "domain"
+        _wrap_assertion do
+          assert(!@group_class.exists?(name))
+          options = {
+            :cn => name,
+            :gid_number => gid_number,
+            :group_type => group_type,
+          }
+          group = @group_class.create(options)
+          assert_equal([], group.errors.to_a)
+          assert(@group_class.exists?(name))
+          yield(group)
+        end
+      end
+    end
+
+    def ensure_delete_group(name)
+      yield(name)
+    ensure
+      if @group_class.exists?(name)
+        @group_class.find(name).destroy(:remove_members => false)
+      end
+    end
+
+    def ensure_delete_ou(ou)
+      yield(ou)
+    ensure
+      ou_class = Class.new(ActiveSambaLdap::Ou)
+      ou_class.ldap_mapping
+      ou_class.destroy(ou) if ou_class.exists?(ou)
+    end
+
+    def pool
+      pool_class = Class.new(ActiveSambaLdap::UnixIdPool)
+      pool_class.ldap_mapping
+      pool_class.required_configuration_variables :samba_domain
+      pool_class.new(pool_class.configuration[:samba_domain])
+    end
+
+    def next_uid_number
+      pool.uid_number || @user_class.configuration[:start_uid]
+    end
+
+    def next_gid_number
+      pool.gid_number || @group_class.configuration[:start_gid]
+    end
+  end
+
+  module CommandSupport
+    def setup
+      super
+      @fakeroot = "fakeroot"
+      @ruby = File.join(::Config::CONFIG["bindir"],
+                        ::Config::CONFIG["RUBY_INSTALL_NAME"])
+      @bin_dir = File.join(@top_dir, "bin")
+      @lib_dir = File.join(@top_dir, "lib")
+      @ruby_args = [
+                    "-I", @lib_dir,
+                    "-I", File.join(@parent_dir, "activeldap", "lib"),
+#                     "-I", File.join(@parent_dir, "ldap", "lib"),
+#                     "-I", File.join(@parent_dir, "ldap"),
+                 ]
+    end
+
+    def run_command_as_normal_user(*args, &block)
+      run_ruby(*[@command, "--config", @config_file, *args], &block)
+    end
+
+    def run_command_with_fakeroot(*args, &block)
+      run_ruby_with_fakeroot(*[@command, "--config", @config_file, *args],
+                             &block)
+    end
+    alias_method :run_command, :run_command_with_fakeroot
+
+    def run_ruby(*ruby_args, &block)
+      args = [@ruby, *@ruby_args]
+      args.concat(ruby_args)
+      Command.run(*args, &block)
+    end
+
+    def run_ruby_with_fakeroot(*ruby_args, &block)
+      args = [@fakeroot, @ruby, *@ruby_args]
+      args.concat(ruby_args)
+      Command.run(*args, &block)
+    end
+  end
+end

data/test/command.rb

@@ -0,0 +1,64 @@
+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
+    err_r, err_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
+        $stdin.reopen(in_r)
+        in_r.close
+        $stdout.reopen(out_w)
+        $stderr.reopen(err_w)
+        out_w.close
+        err_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?
+    err_w.close unless err_w.closed?
+    pid, status = Process.waitpid2(pid)
+    [status.exited? && status.exitstatus.zero?, out_r.read, err_r.read]
+  end
+end

data/test/config.yaml.sample

@@ -0,0 +1,17 @@
+common:
+  sid: S-1-5-21-915876905-2926214379-2876160357
+  user_home_directory: /home/%U
+  user_login_shell: /bin/sh
+
+update:
+  base: dc=test,dc=local,dc=net
+  host: 127.0.0.1
+#  method: :tls
+  bind_dn: cn=admin,dc=local,dc=net
+  password: secret
+
+reference:
+  base: dc=test,dc=local,dc=net
+  host: 127.0.0.1
+#  method: :tls
+  allow_anonymous: true

data/test/run-test.rb

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

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

data/test/test_asl_groupadd.rb

@@ -0,0 +1,69 @@
+require 'asl-test-utils'
+
+class AslGroupAddTest < Test::Unit::TestCase
+  include AslTestUtils
+
+  def setup
+    super
+    @command = File.join(@bin_dir, "asl-groupadd")
+  end
+
+  def test_run_as_normal_user
+    assert_equal([false, "", "need root authority.\n"],
+                 run_command_as_normal_user("group-name"))
+  end
+
+  def test_exist_group
+    make_dummy_group do |group|
+      assert(@group_class.exists?(group.cn))
+      assert_equal([false, "", "group '#{group.cn}' already exists.\n"],
+                   run_command(group.cn))
+      assert(@group_class.exists?(group.cn))
+    end
+  end
+
+  def test_add_group
+    ensure_delete_group("test-group") do |cn|
+      assert_asl_groupadd_successfully(cn)
+    end
+  end
+
+  def test_specify_gid
+    ensure_delete_group("test-group") do |cn|
+      gid_number = "11111"
+      assert_asl_groupadd_successfully(cn, "#{gid_number}\n",
+                                       "--print-gid-number",
+                                       "--gid", gid_number)
+    end
+  end
+
+  def test_print_gid_number
+    ensure_delete_group("test-group") do |cn|
+      pool_class = Class.new(ActiveSambaLdap::UnixIdPool)
+      pool_class.ldap_mapping
+      pool = pool_class.new(pool_class.configuration[:samba_domain])
+      next_gid = pool.find_available_gid_number(@group_class)
+      assert_asl_groupadd_successfully(cn, "#{next_gid}\n",
+                                       "--print-gid-number")
+    end
+  end
+
+  private
+  def assert_asl_groupadd_successfully(name, message=nil, *args)
+    _wrap_assertion do
+      assert(!@group_class.exists?(name))
+      args << name
+      assert_equal([true, "#{message}", ""], run_command(*args))
+      assert(@group_class.exists?(name))
+    end
+  end
+
+  def assert_asl_groupadd_failed(name, message, *args)
+    _wrap_assertion do
+      assert(!@group_class.exists?(name))
+      args << name
+      assert_equal([false, "", message], run_command(*args))
+      assert(!@group_class.exists?(name))
+    end
+  end
+end