ttk 0.1.580 → 0.2.0

data/ruby_ex/session/test/dispatcher_test.rb

@@ -1,409 +0,0 @@
-# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
-# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
-# License: Gnu General Public License.
-
-# $LastChangedBy: ertai $
-# $Id: dispatcher_test.rb 186 2005-04-03 00:07:45Z ertai $
-
-
-#
-# Dispatcher test suite
-#
-if defined? TEST_MODE or $0 == __FILE__
-
-if RUBY_VERSION >= '1.9.0'
-
-#
-# WARNING:
-#
-#  run me with ruby1.9 !!
-#  commented tests are very violents and can crash your machine
-#
-# ADVICE:
-#
-#  run this test suite using this command:
-#
-#  killall -KILL ruby1.9; ruby1.9 session/test/dispatcher_test.rb; killall -KILL ruby1.9
-#
-#  keep a killall -KILL ruby1.9 next to you if things go wrong ;-p
-#
-
-require 'test/unit/ui/yaml/testrunner'
-require 'session/dispatcher'
-require 'session/server'
-
-
-module Session
-
-  module Test
-
-    class DispatcherTest < ::Test::Unit::TestCase
-
-      #
-      # Setup
-      #
-      class HelloServer < Server
-
-        protected
-        def request_hello(sid, profile)
-          uri = @mutex.synchronize { profile[:uri].dup }
-          "hello to #{uri} from #{DRb.uri}"
-        end
-
-        protected
-        def request_dispatch_hello(sid, profile, dispatcher)
-          dispatcher.dispatch_all(:hello)
-          #         dispatcher.hello   # doesn't work from a server
-        end
-
-        protected
-        def request_hello_block(sid, profile, &block)
-          uri = @mutex.synchronize { profile[:uri].dup }
-          "#{block[]} to #{uri} from #{DRb.uri}"
-        end
-
-        protected
-        def request_my_sleep(sid, profile)
-          sleep(2)
-          request_hello(sid, profile)
-        end
-
-        protected
-        def request_dispatch_my_sleep(sid, profile, dispatcher)
-          dispatcher.dispatch_all(:my_sleep)
-        end
-
-        protected
-        def request_active_loop(sid, profile)
-          for i in 0...10000 do end
-          request_hello(sid, profile)
-        end
-
-        protected
-        def request_dispatch_active_loop(sid, profile, dispatcher)
-          dispatcher.dispatch_all(:active_loop)
-        end
-
-      end # class HelloServer
-
-      #
-      # Tests
-      #
-      def test_multi_select_by
-        n = 5
-        uris = []
-        for i in 0...n do
-          uris << "druby://localhost:#{42000 + i * 100}"
-        end
-        srvdb = create_srvdb(*uris)
-        assert(srvdb.size > 0, 'bad srvdb')
-        d = nil
-        assert_nothing_raised { d = Dispatcher.new(srvdb, 1) }
-        assert_not_nil(d)
-
-        h1 = { :port => 42000, :hostname => 'localhost' }
-        r1 = d.and_multi_select_by(h1)
-        assert_equal(1, r1.size)
-        assert_equal(d['druby://localhost:42000'][:client], r1[0])
-        r2 = d.multi_select_by(h1) { |a, b| (a and b) }
-        assert_equal(1, r2.size)
-        assert_equal(r1, r2)
-        r1 = d.or_multi_select_by(h1)
-        r2 = d.multi_select_by(h1, false) { |a, b| (a or b) }
-        assert_equal(r1, r2)
-      end
-
-      def test_hello_block
-        begin
-          n = 5
-          uris = []
-          for i in 0...n do
-            uris << "druby://localhost:#{42000 + i * 100}"
-          end
-          start_servers(*uris)
-          srvdb = create_srvdb(*uris)
-          assert(srvdb.size > 0, 'bad srvdb')
-          d = nil
-          assert_nothing_raised { d = Dispatcher.new(srvdb, 1) }
-          assert_not_nil(d)
-          assert_equal(n, d.select_all.size, 'bad select_all size')
-
-          STDERR.puts "hello_block" if $VERBOSE
-
-          ref_res = {}
-          d.each do |uri, desc|
-            client = desc[:client]
-            ref_res[uri] = "salut to #{client.profile[:uri]} from #{client.uri}"
-          end
-          assert_equal(ref_res,
-                       d.dispatch_all(:hello_block) { 'salut' },
-                       'bad hello_block')
-
-          assert_nothing_raised { d.logout }
-        ensure
-          stop_servers
-        end
-      end
-
-      def test_hello_1
-        several_server_test(1, 1, :hello, 5)
-      end
-
-      def test_hello_2x1
-        several_server_test(2, 1, :hello, 5)
-      end
-
-      def test_hello_3x1
-        several_server_test(3, 1, :hello, 2)
-      end
-
-      def test_hello_5x1
-        several_server_test(5, 1, :hello, 2)
-      end
-
-      def test_hello_10x1
-        several_server_test(10, 1, :hello, 1)
-      end
-
-      def test_my_sleep_1x1
-        several_server_test(1, 1, :my_sleep, 1)
-      end
-
-      def test_my_sleep_2x1
-        several_server_test(2, 1, :my_sleep, 2)
-      end
-
-      def test_my_sleep_3x1
-        several_server_test(3, 1, :my_sleep, 3)
-      end
-
-      def test_my_sleep_5x1
-        several_server_test(5, 1, :my_sleep, 5)
-      end
-
-      def test_my_sleep_10x1
-        several_server_test(10, 1, :my_sleep, 100)
-      end
-
-      def test_active_loop_1x1
-        several_server_test(1, 1, :active_loop, 1)
-      end
-
-      def test_active_loop_2x1
-        several_server_test(2, 1, :active_loop, 2)
-      end
-
-      def test_active_loop_3x1
-        several_server_test(3, 1, :active_loop, 3)
-      end
-
-      def test_active_loop_5x1
-        several_server_test(5, 1, :active_loop, 5)
-      end
-
-      def test_active_loop_10x1
-        several_server_test(10, 1, :active_loop, 10)
-      end
-
-      def test_hello_1x2
-        several_server_test(1, 2, :hello, 5)
-      end
-
-      def test_hello_1x10
-        several_server_test(1, 10, :hello, 5)
-      end
-
-      def test_hello_5x5
-        several_server_test(5, 5, :hello, 5)
-      end
-
-      def test_active_loop_5x5
-        several_server_test(5, 5, :active_loop, 5)
-      end
-
-      def test_my_sleep_5x5
-        several_server_test(5, 5, :my_sleep, 5)
-      end
-
-
-      #     Ruby thread implementation can segfault with this test
-      #     def test_hello_10x10
-      #       several_server_test(10, 10, :hello, 5)
-      #     end
-
-      #      Ruby thread implementation can segfault with this test
-      #     def test_hello_10x10
-      #       several_server_test(10, 10, :hello, 10)
-      #     end
-
-      #     50 servers is quite a lot for a single machine. Very dangerous test
-      #     def test_hello_50x1
-      #       several_server_test(50, 1, :hello, 1)
-      #     end
-
-      #
-      # Utilities
-      #
-      protected
-      def start_servers(*uris)
-        @srv_pids = []
-        uris.each do |uri|
-          unless @srv_pid = fork # son
-            begin
-              my_uri = uri
-              $stderr = File.open('/dev/null')
-              opts = Server::OPTS
-              opts[:usrdb]['guest'][:allowed_requests] += [
-                :hello, :dispatch_hello, :my_sleep, :dispatch_my_sleep,
-                :active_loop, :dispatch_active_loop, :hello_block
-              ]
-              @srv = HelloServer.new(opts)
-              DRb.start_service(my_uri, @srv)
-              DRb.thread.join
-            rescue Exception => exc
-              STDERR.puts "!!!EXCEPTION IN START SERVER!!! #{exc.inspect}"
-              raise
-            end
-          else
-            @srv_pids << @srv_pid
-          end
-        end
-      end
-
-      protected
-      def stop_servers
-        @srv_pids.each do |pid|
-          Process.kill('TERM', pid)
-          Process.waitpid(pid)
-        end
-      end
-
-      protected
-      def create_srvdb(*uris)
-        srvdb = {}
-        uris.each do |uri|
-          srvdb[uri] = {
-            :usrname => 'guest',
-            :passwd => 'guest'.crypt(Const::SALT_KEY)
-          }
-        end
-        srvdb
-      end
-
-
-      # Create n HelloServer plus m dispatchers each connected to the n servers
-      # Run these m dispatchers in m separated threads. The test procedure is
-      # the same for all the dispatchers. First send request ping to all server.
-      # Then, send a bad requests to all server. Then, a request request. Then,
-      # a request request to server selected by port (result to all server).
-      # Then, a request request to server selected by hostname (result to all
-      # server).
-      # Finaly, send a resquest dispatch_request to all servers. Dispatch_request
-      # dispatch to all server the request request.
-      # use ruby -w to display progression message.
-      protected
-      def several_server_test(n, m, request, max_jobs)
-        begin
-          STDERR.puts "+++ start #{n}x#{m} #{request} #{max_jobs}" if $VERBOSE
-
-          uris = []
-          for i in 0...n do
-            uris << "druby://localhost:#{42000 + i * 100}"
-          end
-          start_servers(*uris)
-
-          threads = []
-          for i in 1..m do
-            threads << Thread.new(i) do |j|
-              STDERR.puts "#{j}: create dispatcher #{n}"  if $VERBOSE
-
-              srvdb = create_srvdb(*uris)
-              assert(srvdb.size > 0, 'bad srvdb')
-              d = nil
-              assert_nothing_raised { d = Dispatcher.new(srvdb, max_jobs) }
-              assert_not_nil(d)
-              assert_equal(n, d.select_all.size, 'bad select_all size')
-
-              STDERR.puts "#{j}: ping" if $VERBOSE
-
-              ref_res = {}
-              uris.each { |uri| ref_res[uri] = 'data' }
-              assert_equal(ref_res, d.dispatch_all(:ping, 'data'), 'bad ping')
-
-              STDERR.puts "#{j}: bad request" if $VERBOSE
-
-              ref_res = {}
-              uris.each { |uri| ref_res[uri] = '#<Session::RequestError: `unknown\' - not a request>' }
-              res = {}
-              assert_nothing_raised do
-                res = d.dispatch(d.select_all, :unknown, 'data')
-              end
-              res.each do |uri, desc|
-                assert_equal(ref_res[uri], desc.inspect, "bad result #{uri}")
-              end
-
-              STDERR.puts "#{j}: select all, #{request}" if $VERBOSE
-
-              ref_res = {}
-              d.each do |uri, desc|
-                client = desc[:client]
-                ref_res[uri] = "hello to #{client.profile[:uri]} from #{client.uri}"
-              end
-              assert_equal(ref_res, d.dispatch(d.select_all, request), 'bad result for sid')
-
-              STDERR.puts "#{j}: select_by port, #{request}" if $VERBOSE
-
-              ports_selected = []
-              for i in 0...n do
-                ports_selected << d.select_by(:port, 42000 + i * 100)
-              end
-              ports_selected.flatten!
-              assert_equal(n, ports_selected.size, 'bad port selected size')
-              result = d.dispatch(ports_selected, request)
-              assert_equal(ref_res, result, 'bad result for port')
-
-              STDERR.puts "#{j}: select_by hostname, #{request}" if $VERBOSE
-
-              hosts_selected = d.select_by(:hostname, 'localhost')
-              assert_equal(n, hosts_selected.size, 'bad hosts selected size')
-              result = d.dispatch(hosts_selected, request)
-              assert_equal(ref_res, result, 'bad result for hosts')
-
-              STDERR.puts "#{j}: dispatch" if $VERBOSE
-
-              ref_res = {}
-              d.each_client do |uri1, c1|
-                ref_res[uri1] = {}
-                d.each_client do |uri2, c2|
-                  ref_res[uri1][uri2] = "hello to #{c2.profile[:uri]} from #{c2.uri}"
-                end
-              end
-              req = ('dispatch_' + request.to_s).to_sym
-              res = d.dispatch_all(req, d)
-              assert_equal(ref_res, res, "bad result for dispatch #{req}")
-
-              STDERR.puts "#{j}: logout" if $VERBOSE
-
-              assert_nothing_raised { d.logout }
-            end
-          end
-          threads.each { |t| t.join }
-        ensure
-          stop_servers
-          STDERR.puts "*** finish #{n}x#{m} #{request} #{max_jobs}" if $VERBOSE
-        end
-      end
-
-    end # DispatcherTest
-
-  end # module Test
-
-end # module Session
-
-
-else
-  STDERR.puts('need ruby1.9')
-end
-
-
-end

data/ruby_ex/session/test/fetchable_test.rb

@@ -1,119 +0,0 @@
-# Copyright: Copyright (c) 2004  Nicolas Despres. All rights reserved.
-# Author: Nicolas Despres  <polrop@lrde.epita.fr>.
-# License: Gnu General Public License.
-
-# $LastChangedBy: polrop $
-# $Id: fetchable_test.rb 74 2004-12-10 13:47:17Z polrop $
-
-
-#
-# Unit 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/fetchable'
-require 'session/client'
-require 'session/fetcher'
-require 'pathname'
-require 'fileutils'
-require 'tempfile'
-
-
-module Session
-
-  class FetcherTest < ::Test::Unit::TestCase
-
-    class MyServer < Server
-      include Fetchable
-    end
-
-    class MyClient < Client
-      include Fetcher
-    end
-
-    #
-    # Tests
-    #
-    def test_simple
-      src_filename = nil
-      dst_filename = nil
-      begin
-        start_server
-        clt = nil
-        assert_nothing_raised do
-          clt = MyClient.new('druby://localhost:42000',
-                             'root',
-                             'root'.crypt(Const::SALT_KEY),
-                             true)
-        end
-        assert_not_nil(clt, "login failed")
-        src_filename = Tempfile.new('src_fetcher')
-        dst_filename = Tempfile.new('dst_fetcher')
-        filename = dst_filename.path
-        dst_filename.delete
-        dst_filename = Pathname.new(filename)
-        system("man printf > #{src_filename.path} 2> /dev/null")
-
-        assert_raises(ArgumentError) { clt.fetch('azer', 'z') }
-        assert_raises(Errno::ENOENT) { clt.fetch('azer', 'r') }
-
-        assert(clt.upload(src_filename.path, dst_filename.to_s))
-        assert(dst_filename.exist?, 'no dest file')
-        assert_equal(src_filename.size, dst_filename.size, 'bad size')
-        assert(FileUtils.compare_file(src_filename.path,
-                                      dst_filename.to_s),
-               'files different')
-
-        File.truncate(src_filename.path, 0)
-        assert_equal(0, src_filename.size)
-
-        assert(clt.download(dst_filename.to_s, src_filename.path))
-        assert_equal(src_filename.size, dst_filename.size, 'bad size')
-        assert(FileUtils.compare_file(src_filename.path,
-                                      dst_filename.to_s),
-               'files different')
-
-        assert_nothing_raised { clt.logout }
-      ensure
-        src_filename.delete if src_filename
-        dst_filename.delete if (dst_filename) and (dst_filename.exist?)
-        stop_server
-      end
-    end
-
-    #
-    # Utilities
-    #
-    protected
-    def start_server
-      unless $srv_pid = fork # son
-        $stderr = File.open('/dev/null')
-        @opts = MyServer::OPTS
-        @srv = MyServer.new(@opts)
-        DRb.start_service('druby://localhost:42000', @srv)
-        DRb.thread.join
-      end
-    end
-
-    protected
-    def stop_server
-      Process.kill('TERM', $srv_pid)
-      Process.waitpid($srv_pid)
-    end
-
-  end # class Fetcher
-
-end # module Session
-
-
-else
-  STDERR.puts('need ruby1.9')
-end
-
-
-end
-