ttk 0.1.576

data/ruby_ex/session/test/dispatcher_test.rb

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

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