vcs 0.1 → 0.2.148

data/ruby_ex/session/test/administrable_test.rb

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

data/ruby_ex/session/test/basic_test.rb

@@ -0,0 +1,523 @@
+# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
+# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
+# License: Gnu General Public License.
+
+# $LastChangedBy: polrop $
+# $Id: basic_test.rb 67 2004-12-07 01:00:10Z polrop $
+
+
+#
+# Client/Server basic 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/client'
+
+
+module Session
+
+  module Test
+
+    class BasicTest < ::Test::Unit::TestCase
+
+      USRDB = Server::USRDB.merge('no_rights' => {
+                                    :passwd => 'no_rights'.crypt(Const::SALT_KEY),
+                                    :allowed_requests => [],
+                                    :admin => false},
+                                  'tester' => {
+                                    :passwd => 'tester'.crypt(Const::SALT_KEY),
+                                    :allowed_requests => [ :testme ],
+                                    :admin => false})
+
+      class MyServer < Server
+
+        protected
+        def request_testme(sid, profile, test_obj)
+          ret = test_obj.run
+          return test_obj, ret
+        end
+
+      end
+
+      def setup
+        unless @srv_pid = fork # son
+          $stderr = File.open('/dev/null')
+          @opts = MyServer::OPTS
+          @opts[:usrdb] = USRDB
+          @opts[:max_usr] = 2
+          @opts[:wipeout_delay] = 2
+          @srv = MyServer.new(@opts)
+          DRb.start_service('druby://localhost:42000', @srv)
+          DRb.thread.join
+          exit(0)
+        end
+      end
+
+      def teardown
+        Process.kill('TERM', @srv_pid)
+        Process.waitpid(@srv_pid)
+      end
+
+      #
+      # Tests
+      #
+      def test_single_login_logout
+        assert_nothing_raised do
+          clt = Client.new
+          assert(! clt.online?, 'clt online 1')
+          assert(clt.logout)
+          assert(! clt.online?, 'clt online 2')
+          assert('data', clt.request(:ping, 'data'))
+          assert(clt.online?, 'clt online 3')
+          assert(clt.logout)
+          assert(! clt.online?, 'clt online 4')
+        end
+      end
+
+      def test_single_force_login_logout
+        assert_raises(ArgumentError) do
+          clt = Client.new(Client::URI,
+                           Client::USRNAME,
+                           Client::PASSWD,
+                           nil)
+        end
+        assert_nothing_raised do
+          clt = Client.new(Client::URI,
+                           Client::USRNAME,
+                           Client::PASSWD,
+                           true)
+          assert(clt.online?, 'clt online 1')
+          assert('data', clt.request(:ping, 'data'))
+          assert(clt.online?, 'clt online 3')
+          assert(clt.logout)
+          assert(! clt.online?, 'clt online 2')
+          assert(clt.logout)
+          assert(! clt.online?, 'clt online 2')
+        end
+      end
+
+      def test_several_login_logout
+        assert_nothing_raised do
+          clt = Client.new(Client::URI,
+                           Client::USRNAME,
+                           Client::PASSWD,
+                           true)
+          assert(clt.online?, 'clt online? 1')
+          assert(clt.logout)
+          assert(! clt.online?, 'clt not online? 1')
+          assert(clt.login)
+          assert(clt.online?, 'clt online? 2')
+          assert(clt.logout)
+          assert(! clt.online?, 'clt not online? 2')
+          assert(clt.login)
+          assert(clt.online?, 'clt online? 3')
+          assert(clt.logout)
+          assert(! clt.online?, 'clt not online? 3')
+        end
+      end
+
+      class Hook
+        include Session::Hookable
+
+        def initialize
+          @online = nil
+        end
+
+        def online?
+          @online
+        end
+
+        protected
+        def hook_logout(sid, profile)
+          @online = false
+        end
+
+        protected
+        def hook_login(sid, profile)
+          @online = true
+        end
+
+      end
+
+      def test_hook
+        hook = Hook.new
+        assert_nil(hook.online?)
+        clt = nil
+        assert_raises(ArgumentError) do
+          clt = Client.new(Client::URI,
+                           Client::USRNAME,
+                           Client::PASSWD,
+                           true,
+                           nil)
+        end
+        assert_nothing_raised do
+          clt = Client.new(Client::URI,
+                           Client::USRNAME,
+                           Client::PASSWD,
+                           true,
+                           hook)
+          assert(clt.online?, 'clt online? 1')
+        end
+        assert_not_nil(clt, 'login failed')
+        assert_equal(true, hook.online?, 'bad hook online?')
+        assert_nothing_raised { assert(clt.logout) }
+      end
+
+      def test_bad_usr_name
+        clt = nil
+        assert_raises(Session::AuthError) do
+          clt = Client.new('druby://localhost:42000',
+                           'nobody',
+                           'prout'.crypt(Const::SALT_KEY),
+                           true)
+        end
+      end
+
+      def test_bad_passwd
+        assert_raises(Session::AuthError) do
+          clt = Client.new('druby://localhost:42000',
+                           'guest',
+                           'prout'.crypt(Const::SALT_KEY),
+                           true)
+        end
+      end
+
+      def test_permission_denied
+        clt = nil
+        assert_nothing_raised do
+          clt = Client.new
+        end
+        assert_not_nil(clt, 'login failed')
+        assert_raises(Session::PermissionError) do
+          clt.request(:get_usr_profile, 'toto')
+        end
+        assert_nothing_raised { assert(clt.logout) }
+      end
+
+      def test_bad_request
+        clt = nil
+        assert_nothing_raised { clt = Client.new }
+        assert_not_nil(clt, 'login failed')
+        assert_raises(Session::RequestError) do
+          clt.request(:foo)
+        end
+        assert_nothing_raised { assert(clt.logout) }
+      end
+
+      def test_no_opened_session
+        drb_srv = DRb.start_service
+        drb_obj = DRbObject.new(nil, 'druby://localhost:42000')
+        assert_raises(Session::ParameterError) do
+          drb_obj.request('mais_ou���_mon_sid', :logout)
+        end
+        assert_raises(Session::SessionError) do
+          drb_obj.request('0123456789abcdef', :foo)
+        end
+        drb_srv.stop_service
+      end
+
+      def test_cannot_call_server_protected_method
+        drb_srv = DRb.start_service
+        drb_obj = DRbObject.new(nil, 'druby://localhost:42000')
+        assert_raises(NameError) do
+          drb_obj.request_profile('sid')
+        end
+        drb_srv.stop_service
+      end
+
+      def test_max_users
+        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(false, 'not reached')
+        end
+        assert_not_nil(clt3, 'login 3 failed')
+        assert_nothing_raised { assert(clt1.logout, 'clt1 logout') }
+        assert(! clt1.online?, 'clt 1 not online 2')
+        assert_nothing_raised { clt3.login }
+        assert(clt3.online?, 'clt 3 online')
+        assert_nothing_raised { assert(clt2.logout, 'clt2 logout') }
+        assert(! clt2.online?, 'clt 2 not online 2')
+        assert_nothing_raised { assert(clt3.logout, 'clt3 logout') }
+        assert(! clt3.online?, 'clt 3 not online')
+      end
+
+      def test_wipeout
+        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(false, 'not reached')
+        end
+        while clt1.online? and clt2.online?
+          sleep(4)
+        end
+        assert(clt1.logout, 'clt1 already logout')
+        assert(clt2.logout, 'clt2 already logout')
+        clt1 = nil
+        assert_nothing_raised { clt1 = Client.new }
+        assert_not_nil(clt1, 'login 1 failed 2')
+        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 2')
+        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(false, 'not reached')
+        end
+        assert_nothing_raised { assert(clt1.logout) }
+        assert_nothing_raised { assert(clt2.logout) }
+      end
+
+      def test_request_profile
+        usrname = 'guest'
+        passwd = 'guest'.crypt(Const::SALT_KEY)
+        usr = Server::USRDB
+        usr = {
+          usrname => {
+            :passwd => passwd,
+            :allowed_requests => [
+              :profile, :help, :nb_requests, :ping
+            ],
+            :admin => false
+          }
+        }
+        prof = Profile.new(usrname, usr[usrname], DRb.uri, nil)
+        clt = nil
+        assert_nothing_raised do
+          clt = Client.new('druby://localhost:42000', usrname, passwd, true)
+        end
+        assert_not_nil(clt, 'login failed')
+        prof[:uri] = clt.local_uri
+        prof[:protocol], prof[:hostname], prof[:port] = Profile.parse_uri(clt.local_uri)
+        prof[:hooks] = [clt]
+        comp_profile(prof, clt.profile, :dispatcher)
+        assert(clt.profile[:login_time] < clt.profile[:last_request_time])
+        assert_nothing_raised { assert(clt.logout) }
+      end
+
+      def test_request_help
+        clt = nil
+        assert_nothing_raised { clt = Client.new }
+        assert_not_nil(clt, 'login 1 failed')
+        ref_res = {
+          "ping"=>"no description available",
+          "help"=>"[requests...] return all or several request descriptions",
+          "detach"=>"no description available",
+          "logout_at"=>"no description available",
+          "add_hook"=>"no description available",
+          "login_at"=>"no description available",
+          "profile"=>"return the session profile",
+          "stop"=>"no description available",
+          "logout"=>"disconnect from the server",
+          "testme"=>"no description available",
+          "rsend"=>"no description available",
+          "del_hook"=>"no description available",
+          "request_at"=>"no description available",
+          "stop_all_sub_server"=>"no description available",
+          "nb_requests"=>"no description available",
+          "chdir"=>"no description available",
+          "start_sub_server"=>"no description available",
+          "stop_sub_server"=>"no description available",
+          "total_nb_requests"=>"no description available",
+          "get_usr_profile"=>"no description available",
+          "pid"=>"no description available"
+        }
+        assert_equal(ref_res, clt.help)
+        assert_equal({'profile' => ref_res['profile']}, clt.help('profile'))
+        assert_equal({
+                       'profile' => ref_res['profile'],
+                       'help' => ref_res['help']
+                     },
+                     clt.help('profile', :help, 'sessions'))
+        assert_equal({}, clt.help('toto'))
+        assert_equal({'help' => ref_res['help']}, clt.help(:help))
+        assert_nothing_raised { assert(clt.logout) }
+      end
+
+      def test_request_get_usr_profile
+        clt1 = nil
+        assert_nothing_raised { clt1 = Client.new }
+        assert_not_nil(clt1, 'login 1 failed')
+        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_nothing_raised do
+          comp_profile(clt1.profile,
+                       clt2.request(:get_usr_profile, 'guest'),
+                       :hooks)
+        end
+        assert_raises(Session::UserError) do
+          clt2.request(:get_usr_profile, 'toto')
+        end
+        assert_nothing_raised do
+          comp_profile(clt2.profile,
+                       clt2.request(:get_usr_profile, clt2.profile[:usrname]))
+        end
+        assert_nothing_raised { assert(clt1.logout) }
+        assert_nothing_raised { assert(clt2.logout) }
+      end
+
+      def test_nb_request
+        nb_clt = 2
+        clt = []
+        for i in 0...nb_clt do
+          assert_nothing_raised { clt[i] = Client.new }
+          assert_not_nil(clt[i], "login #{i} failed")
+        end
+        threads = []
+        for i in 0...nb_clt do
+          threads << Thread.new do
+            c = i
+            for j in 0...nb_clt do
+              clt[c].request(:nb_requests)
+            end
+          end
+        end
+        threads.each { |t| t.join }
+        for i in 0...nb_clt do
+          assert_equal(1,
+                       clt[i].request(:nb_requests),
+                       "#{i}: bad request number")
+        end
+        for i in 0...nb_clt do
+          assert_nothing_raised { assert(clt[i].logout) }
+        end
+      end
+
+      class TestObj
+
+        def run
+          DRb.uri
+        end
+
+      end
+
+      def test_object_is_runned_remotely
+        clt = nil
+        assert_nothing_raised do
+          clt = Client.new('druby://localhost:42000',
+                           'tester',
+                           'tester'.crypt(Const::SALT_KEY))
+        end
+        assert_not_nil(clt, "login failed")
+        foo = TestObj.new
+        assert_not_equal('druby://localhost:42000', clt.local_uri)
+        robj, foo_uri = clt.request(:testme, foo)
+        assert_equal('druby://localhost:42000', foo_uri)
+        comp_obj(foo, robj)
+        assert_nothing_raised { clt.logout }
+      end
+
+      def test_rsend
+        begin
+          clt = nil
+          assert_nothing_raised do
+            clt = Client.new('druby://localhost:42000',
+                             'root',
+                             'root'.crypt(Const::SALT_KEY),
+                             true)
+          end
+          assert_not_nil(clt, "login failed")
+          io = clt.request(:rsend, File, :open, '/tmp/x', 'w')
+          assert(io.is_a?(DRb::DRbObject), 'io is a DRbObject')
+          assert_equal(5,
+                       clt.request(:rsend, io, :write, "test\n"),
+                       'test write')
+          assert_nothing_raised { clt.request(:rsend, io, :close) }
+          assert(File.exist?('/tmp/x'), 'file exist')
+          assert_nothing_raised { clt.logout }
+        ensure
+          File.delete('/tmp/x') if File.exist?('/tmp/x')
+        end
+      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
+
+      protected
+      def comp_obj(ref, val)
+        assert_equal(ref.class, val.class, 'bad class')
+        assert_not_equal(ref.object_id, val.object_id)
+        assert_not_equal(ref, val)
+        ref.instance_variables.each do |v|
+          assert_equal(val.instance_variable_get(v),
+                       ref.instance_variable_get(v),
+                       "bad attributes #{v}")
+        end
+        val.instance_variables.each do |v|
+          assert(ref.instance_variables.include?(v), 'addionnal attributes')
+        end
+      end
+
+    end # class BasicTest
+
+  end # module Test
+
+end # module Session
+
+else
+  STDERR.puts('need ruby1.9')
+end
+
+
+end