# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
# License: Gnu General Public License.

# $LastChangedBy: polrop $
# $Id: administrable_test.rb 67 2004-12-07 01:00:10Z polrop $


#
# Client/Server administrable test suite
#
if defined? TEST_MODE or $0 == __FILE__


if RUBY_VERSION >= '1.9.0'


require 'test/unit/ui/yaml/testrunner'
require 'session/server'
require 'session/administrable'
require 'session/client'


module Session

  module Test

    class AdministrableTest < ::Test::Unit::TestCase

      class ServerAdministrable < Server
        include Administrable

      end # class ServerAdministrable

      def setup
        unless @srv_pid = fork # son
          $stderr = File.open('/dev/null')
          @opts = Server::OPTS
          @opts[:usrdb] = Server::USRDB
          @opts[:max_usr] = 2
          @opts[:wipeout_delay] = 2
          @srv = ServerAdministrable.new(@opts)
          DRb.start_service("druby://localhost:42000", @srv)
          DRb.thread.join
        end
      end

      def teardown
        Process.kill('TERM', @srv_pid)
        Process.waitpid(@srv_pid)
      end

      #
      # Tests
      #
      def test_normal_login_logout
        assert_nothing_raised do
          clt = Client.new
          clt.logout
        end
      end

      def test_admin_can_connect_even_if_server_full
        clt1 = nil
        assert_nothing_raised { clt1 = Client.new }
        assert_not_nil(clt1, 'login 1 failed')
        assert(! clt1.online?, 'clt 1 not online')
        assert_equal('data', clt1.request(:ping, 'data'))
        assert(clt1.online?, 'clt 1 online')
        clt2 = nil
        assert_nothing_raised { clt2 = Client.new }
        assert_not_nil(clt2, 'login 2 failed')
        assert(! clt2.online?, 'clt 2 not online')
        assert_equal('data', clt2.request(:ping, 'data'))
        assert(clt2.online?, 'clt 2 online')
        clt3 = nil
        assert_raises(Session::FullError) do
          clt3 = Client.new
          assert_not_nil(clt3, 'login 3 failed')
          assert(! clt3.online?, 'clt 3 not online')
          assert_equal('data', clt3.request(:ping, 'data'))
          assert(clt3.online?, 'clt 3 online')
        end
        clt_admin = nil
        assert_nothing_raised do
          clt_admin = Client.new('druby://localhost:42000',
                                 'admin',
                                 'admin'.crypt(Const::SALT_KEY))
        end
        assert_not_nil(clt_admin, 'login admin failed')
        assert_equal(3, clt_admin.request(:sessions).size)
        assert_equal(2, clt_admin.request(:get_max_usr))
        assert_nothing_raised { clt_admin.logout }
        assert_nothing_raised { clt1.logout }
        assert_nothing_raised { clt3 = Client.new }
        assert_not_nil(clt3, 'login 3 failed')
        assert_nothing_raised { clt2.logout }
        assert_nothing_raised { clt3.logout }
      end

      def test_request_set_get_max_usr
        clt = nil
        assert_nothing_raised do
          clt = Client.new('druby://localhost:42000',
                           'root',
                           'root'.crypt(Const::SALT_KEY))
        end
        assert_not_nil(clt, 'login failed')
        assert_nothing_raised do
          assert_equal(2, clt.request(:get_max_usr), 'bad max_usr')
          assert_equal(3, clt.request(:set_max_usr, 3))
          assert_equal(3, clt.request(:get_max_usr), 'bad max_usr')
          clt.request(:set_max_usr, 2)
          assert_equal(2, clt.request(:get_max_usr), 'bad max_usr')
        end
        assert_raises(Session::ParameterError, 'set O') do
          clt.request(:set_max_usr, 0)
        end
        assert_raises(Session::ParameterError, 'set -42') do
          clt.request(:set_max_usr, -42)
        end
        assert_raises(Session::ParameterError, 'set 4') do
          clt.request(:set_max_usr, '4')
        end
        assert_nothing_raised do
          assert_equal(2, clt.request(:set_max_usr, '2'.to_i), 'bad max_usr')
        end
        assert_nothing_raised do
          assert_equal(2, clt.request(:get_max_usr), 'bad max_usr')
        end
        assert_nothing_raised { clt.logout }
      end

      def test_request_set_get_wipeout_delay
        clt = nil
        assert_nothing_raised do
          clt = Client.new('druby://localhost:42000',
                           'root',
                           'root'.crypt(Const::SALT_KEY))
        end
        assert_not_nil(clt, 'login failed')
        assert_nothing_raised do
          assert_equal(2, clt.request(:get_wipeout_delay), 'bad wipeout_delay')
          assert_equal(3, clt.request(:set_wipeout_delay, 3))
          assert_equal(3, clt.request(:get_wipeout_delay), 'bad wipeout_delay')
          clt.request(:set_wipeout_delay, 2)
          assert_equal(2, clt.request(:get_wipeout_delay), 'bad wipeout_delay')
        end
        assert_raises(Session::ParameterError, 'set 1') do
          clt.request(:set_wipeout_delay, 1)
        end
        assert_raises(Session::ParameterError, 'set -42') do
          clt.request(:set_wipeout_delay, -42)
        end
        assert_raises(Session::ParameterError, 'set 4') do
          clt.request(:set_wipeout_delay, '4')
        end
        assert_nothing_raised do
          assert_equal(2,
                       clt.request(:set_wipeout_delay, '2'.to_i),
                       'bad wipeout_delay')
        end
        assert_nothing_raised do
          assert_equal(2, clt.request(:get_wipeout_delay), 'bad wipeout_delay')
        end
        assert_nothing_raised { clt.logout }
      end

      def test_request_sessions
        clt1 = nil
        assert_nothing_raised { clt1 = Client.new }
        assert_not_nil(clt1, 'login 1 failed')
        assert(! clt1.online?, 'clt 1 not online')
        assert_equal('data', clt1.ping('data'))
        assert(clt1.online?, 'clt 1 online')
        clt2 = nil
        assert_nothing_raised do
          clt2 = Client.new('druby://localhost:42000',
                            'root',
                            'root'.crypt(Const::SALT_KEY))
        end
        assert_not_nil(clt2, 'login 2 failed')
        ses = clt2.request(:sessions)
        assert_equal(2, ses.size, 'bad sessions number')
        assert(ses.has_key?(clt1.sid), 'bad clt1 sid')
        assert(ses.has_key?(clt2.sid), 'bad clt2 sid')
        ses.each do |sid, prof|
          prof[:usrname] = 'toto'
        end
        assert_equal(2, clt2.request(:sessions).size, 'bad sessions number')
        clt2.request(:sessions).each do |sid, prof|
          assert_equal('toto', ses[sid][:usrname])
          assert_not_equal('toto', prof[:usrname])
        end
        assert_nothing_raised { clt1.logout }
        assert_nothing_raised { clt2.logout }
      end

      def test_request_kick
        clt1 = nil
        assert_nothing_raised { clt1 = Client.new }
        assert_not_nil(clt1, 'login 1 failed')
        assert(! clt1.online?, 'clt 1 not online')
        assert_equal('data', clt1.ping('data'))
        assert(clt1.online?, 'clt 1 online')
        clt2 = nil
        assert_nothing_raised do
          clt2 = Client.new('druby://localhost:42000',
                            'root',
                            'root'.crypt(Const::SALT_KEY))
        end
        assert_not_nil(clt2, 'login 2 failed')
        ses = clt2.request(:sessions)
        assert_equal(2, ses.size, 'bad sessions number')
        assert(ses.has_key?(clt1.sid), 'bad clt1 sid')
        assert(ses.has_key?(clt2.sid), 'bad clt2 sid')
        assert_raises(Session::SessionError) do
          clt2.request(:kick, 'toto')
        end
        assert_raises(Session::PermissionError) do
          clt2.request(:kick, clt2.sid)
        end
        assert_nothing_raised { clt2.request(:kick, clt1.sid) }
        assert(! clt1.online?)
        assert_nil(clt1.sid)
        assert_nothing_raised { assert(clt2.logout) }
      end

      def test_usr_management
        clt2 = nil
        assert_nothing_raised do
          clt2 = Client.new('druby://localhost:42000',
                            'root',
                            'root'.crypt(Const::SALT_KEY))
        end
        assert_not_nil(clt2, 'login 2 failed')
        assert_equal(ServerAdministrable::USRDB, clt2.request(:get_usrdb))
        assert_raises(Session::ParameterError) do
          clt2.request(:get_usr_desc, '')
        end
        assert_raises(Session::UserError) do
          clt2.request(:add_usr, 'guest', clt2.request(:get_usr_desc, 'guest'))
        end
        assert_raises(Session::UserError) do
          clt2.request(:add_usr, 'root', clt2.request(:get_usr_desc, 'root'))
        end
        assert_raises(Session::ParameterError) do
          clt2.request(:add_usr, 'toto)', {})
        end
        assert_raises(Session::ParameterError) do
          clt2.request(:add_usr, '', {})
        end
        usrdesc = {
          :allowed_requests => [ :profile, :add_hook ],
          :allowed_hooks => [],
          :admin => false,
          :passwd => 'toto'.crypt(Const::SALT_KEY)
        }
        assert_equal(usrdesc, clt2.request(:add_usr, 'toto', usrdesc))
        assert_equal(ServerAdministrable::USRDB.merge('toto'=>usrdesc),
                     clt2.request(:get_usrdb))
        assert_raises(Session::UserError) do
          clt2.request(:del_usr, 'foo')
        end
        assert_raises(Session::UserError) do
          clt2.request(:del_usr, 'root')
        end
        assert_raises(Session::UserError) do
          clt2.request(:del_usr, 'admin')
        end
        prof = Profile.new('toto', usrdesc, DRb.uri, nil)
        clt1 = nil
        assert_nothing_raised do
          clt1 = Client.new('druby://localhost:42000',
                            'toto',
                            'toto'.crypt(Const::SALT_KEY), true)
        end
        assert_not_nil(clt1, 'login 1 failed')
        prof[:uri] = clt1.local_uri
        prof[:protocol], prof[:hostname], prof[:port] = Profile.parse_uri(clt1.local_uri)
        prof[:hooks] = [ clt1 ]
        comp_profile(prof, clt1.profile, :dispatcher)
        assert_raises(Session::PermissionError) { clt1.help }
        new_usrdesc = {
          :allowed_requests => [ :profile, :help, :add_hook ],
          :allowed_hooks => [],
          :admin => false,
          :passwd => 'toto'.crypt(Const::SALT_KEY)
        }
        assert_equal(new_usrdesc,
                     clt2.request(:set_usr_desc, 'toto', new_usrdesc))
        assert_raises(Session::PermissionError) { clt1.help }
        assert_nothing_raised { clt1.logout }
        clt1 = nil
        assert_nothing_raised do
          clt1 = Client.new('druby://localhost:42000',
                            'toto',
                            'toto'.crypt(Const::SALT_KEY))
        end
        assert_not_nil(clt1, 'login 1 new failed')
        assert_nothing_raised('help is allowed now') { clt1.help }
        assert_nothing_raised { clt1.logout }
        assert_equal(new_usrdesc,
                     clt2.request(:del_usr, 'toto'),
                     'bad usrdesc returned')
        assert_equal(ServerAdministrable::USRDB, clt2.request(:get_usrdb))
        assert_nothing_raised { clt2.logout }
      end

      #
      # Utilities
      #
      protected
      def comp_profile(ref_prof, prof, *ignore)
        ref_prof.each do |k, v|
          next if ignore.include?(k)
          if k == :login_time or k == :last_request_time
            assert(ref_prof[k] <= prof[k], "bad time for #{k}")
          else
            assert_equal(ref_prof[k], prof[k], "bad value for #{k}")
          end
        end
      end

    end # class AdministrableTest

  end # module Test

end # module Session


else
  STDERR.puts('need ruby1.9')
end


end