ttk 0.1.576

data/lib/ttk/strategies/ProbabilityThreshold.rb

@@ -0,0 +1,42 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: ProbabilityThreshold.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+module TTK
+
+  module Strategies
+
+    class ProbabilityThreshold < Proxy
+      include Concrete
+
+      def prologue 
+        super
+        if @threshold > 1
+          raise ArgumentError, "Threshold too high: #@threshold not in [0..1]"
+        elsif @threshold < 0
+          raise ArgumentError, "Threshold too low: #@threshold not in [0..1]"
+        end
+        create(@test)
+      end
+      protected :prologue
+
+
+      def assertion
+        compute_final_weight
+        fail("Not enough (#@final_weight)") if @final_weight < @threshold
+        pass
+      end
+      protected :assertion
+
+
+      attribute :test,      'the strategy',              :mandatory, :invisble
+      attribute :threshold, 'the probability threshold', :mandatory, nil
+                                                         Weights::Weight
+
+    end # class ProbabilityThreshold
+
+  end # module Strategies
+
+end # module TTK

data/lib/ttk/strategies/Proxy.rb

@@ -0,0 +1,42 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: Proxy.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+module TTK
+
+  module Strategies
+
+    class Proxy < Composite
+      include Abstract
+
+
+      def create ( anObject, &block )
+        unless @contents.empty?
+          raise ArgumentError, "A proxy can contain only one test"
+        end
+        super
+      end
+
+
+      def run_composite 
+        test = @contents.first
+        test.reject :name, :strategy, :status
+        reject :reason
+        run_test(test, @log)
+      end
+      protected :run_composite
+
+
+      def new_symtbl
+        @symtbl
+      end
+      protected :new_symtbl
+
+
+    end # class Proxy
+
+  end # module Strategies
+
+end # module TTK

data/lib/ttk/strategies/RUnit.rb

@@ -0,0 +1,170 @@
+# Author::    Nicolas Despres  <nicolas.despres@gmail.com>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: RUnit.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+require 'yaml'
+require 'rbconfig'
+
+module TTK
+
+  module Strategies
+
+    #
+    # = Description
+    #
+    # This strategy is wrapper around a Ruby unit test suite based on the
+    # test/unit library. Using RUnit you avoid the Ruby `require' problem
+    # and you use all the power of the TTK's Suite and/or Pool.
+    #
+    # = How it works ?
+    #
+    # RUnit works by invoking Ruby on the specified file and then parsing the
+    # output to inject the result in the TTK's log stream. To do that, you must
+    # use a specific TestRunner based on YAML. This TestRunner produces a YAML
+    # output readable by a human and the strategy.
+    #
+    # = Examples
+    #
+    # You need to first write your unit test suite using the test/unit package
+    # and the YAML TestRunner. Then, you write a few line in the input TTK file
+    # to incorporate the unit test in the TTK's suite.
+    #
+    # == The unit test suite file: foo_test.rb
+    #
+    #   require 'test/unit/ui/yaml/testrunner'
+    #   require 'foo'
+    #
+    #   class FooTest < Test::Unit::TestCase
+    #
+    #     def test_1
+    #       assert(true)
+    #     end
+    #
+    #   end
+    #
+    #   Test::Unit::UI::Yaml::TestRunner.run(FooTest)
+    #
+    # == The YAML input file for TTK
+    #
+    #   ---
+    #   RUnit example test:
+    #     strategy: RUnit
+    #     unit_file: my_unit_directory/foo_test.rb
+    #
+    # == One suite for all your unit test suite
+    #
+    # If you find cumbersome to write for every unit test file a single RUnit
+    # strategy into the YAML input file of TTK, there is another way to do so.
+    # Here we go:
+    #
+    #   ---
+    #   TTK's unit test suite:
+    #   strategy: Glob
+    #   glob: '<<pwd>>/../runit/**/*_test.rb'
+    #   regexp: !re /(runit/.+_test\.rb)$
+    #   test:
+    #     'Unit test <<match>>':
+    #       strategy: RUnit
+    #       unit_file: <<match>>
+    #       work_dir: <<pwd>>/..
+    #       load_path: ../lib
+    #       verbose: true
+    #
+    # This file is extracted from the TTK's minimal test suite
+    # (test/ttk-minimal/unit_test.yml). The strategy upon it is based (Glob)
+    # looks for every file ending by `_test.rb' in a particular directory
+    # relative to the place the TTK YAML input file is located (<<pwd>>). All
+    # these files are loaded as RUnit strategy with a verbose mode on, the TTK
+    # library loaded in the $LOAD_PATH Ruby variable, and the correct working
+    # directory. Thus, every unit test files are embedded in a TTK suite.
+    #
+    class RUnit < Strategy #FIXME: inherit from CmdBase
+      include Concrete
+
+      protected
+      def prologue
+        super
+        @outfile = TempPath.new
+        @errfile = TempPath.new
+        unless File.directory?(@work_dir) and File.readable?(@work_dir)
+          raise "`#@work_dir' - is not a valid directory"
+        end
+        work_dir = Pathname.new(@work_dir)
+        p = work_dir + Pathname.new(@unit_file)
+        unless p.file? and p.readable?
+          raise "`#{p}' - is not a readable regular file"
+        end
+        @load_path.each do |dir|
+          p = work_dir + Pathname.new(dir)
+          unless p.directory? and p.readable?
+            raise "`#{dir}' - is not a valid directory"
+          end
+        end
+        ruby_bin = Config::CONFIG["RUBY_INSTALL_NAME"]
+        @cmd = "cd #@work_dir && #{ruby_bin} "
+        @cmd += '-w ' if @verbose
+        @cmd += "-I#{ABS_RUBY_EX_DIR} "
+        @load_path.each { |x| @cmd += "-I#{x} " }
+        @cmd += "#@unit_file "
+        @cmd += "> #@outfile 2> #@errfile"
+        @log.log_debug{@cmd}
+      end
+
+      protected
+      def run_impl
+        system(@cmd)
+      end
+
+      protected
+      def assertion
+        result = nil
+        if @errfile.zero?
+          if @outfile.zero?
+            skip('No result has been collected probably because no test ' +
+                 'suite has been run')
+          else
+            @outfile.open { |io| result = YAML.load(io) }
+            @log[:result] = result
+            if result['failures_number'] != 0 or result['errors_number'] != 0
+              if result['failures_number'] == 0
+                fail('there are errors')
+              elsif result['errors_number'] == 0
+                fail('there are failures')
+              else
+                fail('there are failures and errors')
+            end
+            end
+            pass
+          end
+        else
+          @errfile.open { |io| result = io.read }
+          raise "Some error occures while running the unit test:\n" + result
+        end
+      end
+
+      protected
+      def epilogue
+        @outfile.clean
+        @errfile.clean
+        super
+      end
+
+      attribute :unit_file, 'files which contains the runit test class to run',
+                            :mandatory
+      attribute :work_dir,  'directory where the test must be run',
+                            '.', :invisible
+      attribute :load_path, 'directories to add to the $LOAD_PATH variable',
+                            :invisible do [] end
+      attribute :verbose,   'turn on/off the ruby verbose mode',
+                            false, :invisible
+
+    end # class RUnit
+
+  end # module Strategies
+
+end # module TTK
+
+
+

data/lib/ttk/strategies/RemoteCmd.rb

@@ -0,0 +1,48 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: RemoteCmd.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+require 'ttk/Tools/HostDispatcher'
+
+module TTK
+
+  module Strategies
+
+    # I'm not maintained any more, don't use me.
+    class RemoteCmd < Cmd
+
+      def prologue
+	if @dispatcher
+	  conf = @dispatcher.aConf
+	  @login, @port, @hostname = conf.values_at :login, :port, :hostname
+	end
+	super
+      end
+
+      def mk_command
+	cmd = 'ssh'
+	cmd += " -l '#@login'" if @login
+	cmd += " -p '#@port'" if @port
+	cmd += " #@hostname #{super}"
+      end
+      protected :mk_command
+
+      def dispatcher=(doc)
+        raise ArgumentError, "require a `hosts' attribute" if doc[:hosts].nil?
+	@dispatcher = TTK::Tools::HostDispatcher.instance
+	@dispatcher.hosts = doc[:hosts]
+      end
+
+      attribute :hostname, 'the machine hostname where launch the command',
+                           :mandatory
+      attribute :port,     'the port for the remote connection'
+      attribute :login,    'the login for the remote connection'
+      attribute :dispatcher, 'the host dispatcher', :invisible
+
+    end # class RemoteCmd
+
+  end # module Strategies
+
+end # module TTK

data/lib/ttk/strategies/SignalCmd.rb

@@ -0,0 +1,85 @@
+# Author::    Vincent CUISSARD  <cuissa_v@epita.fr>.
+# Copyright:: Copyright (c) 2005 TTK Team. All rights reserved.
+# License::   LGPL
+# $Id: SignalCmd.rb 572 2005-04-13 14:53:54Z ertai $
+
+
+module TTK
+
+  module Strategies
+
+    class SignalCmd < Cmd
+      include Concrete
+      
+      @@signal_names = nil
+
+      #
+      # Methods
+      #
+
+      def run_impl
+        super
+        
+        # Check if command has exited normaly
+        case 
+        when @my_status.exited?
+          # Process run successfully
+          @my_signaled = false
+        when @my_status.signaled?
+          # Process was signaled
+          @my_signaled = true
+          @my_exit = 128 + @my_status.termsig
+        else
+          # Problem on process
+          fail('process may be ill')
+        end
+      end
+      protected :run_impl
+
+
+      def assertion
+        case
+        when (@my_signaled and not @signaled)
+          fail("command was signaled by #{SignalCmd.signal_name(@my_exit)}")
+        when (not @my_signaled and @signaled)
+          fail("command wasn't signaled by #@signal") 
+        when (@my_signaled == @signaled and @signaled)
+          sig_name = SignalCmd.signal_name(@my_exit)
+          unless sig_name == signal
+            err = "command signaled by #{sig_name}, "
+            err << "must be signaled by #@signal"
+            fail(err)
+          end
+        end
+        super
+      end
+      protected :assertion
+
+      def SignalCmd.signal_name ( status )
+        signal = status - 128
+        if @@signal_names.nil?
+          @@signal_names = { }
+          Signal.list.each do |key, value|
+            @@signal_names[value] = key
+          end
+        end
+        @@signal_names[signal]
+      end
+
+      def signal= ( signal_name )
+        @signal = signal_name
+        @signaled = true
+      end
+
+      #
+      # Attributes
+      #
+
+      attribute :signal,        'the signal name',              nil
+      attribute :signaled,      'process must be signaled',     false
+
+    end # class SignalCmd
+
+  end # module Strategies
+
+end # module TTK

data/lib/ttk/strategies/Sleep.rb

@@ -0,0 +1,36 @@
+# Author::    Nicolas Despres  <nicolas.despres@gmail.com>.
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: Sleep.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+module TTK
+
+  module Strategies
+
+    # A test strategy class that only sleep for a moment before to pass.
+    class Sleep < Strategy
+      include Concrete
+
+      def delay=(other)
+        other = other.to_f
+        if other >= 0
+          @delay = other
+        else
+          raise(ArgumentError, "`#{other}' - sleep delay must be >= 0")
+        end
+      end
+
+      protected
+      def run_impl 
+        sleep(@delay)
+        pass
+      end
+
+      attribute :delay, 'Delay in second to sleep', 0
+
+    end # class Sleep
+
+  end # module Strategies
+
+end # module TTK

data/lib/ttk/strategies/SqlQuery.rb

@@ -0,0 +1,120 @@
+# Author::    Vincent Cuissard  <cuissa_v@epita.fr>
+# Copyright:: Copyright (c) 2004, 2005 TTK team. All rights reserved.
+# License::   LGPL
+# $Id: SqlQuery.rb 567 2005-04-13 08:00:06Z polrop $
+
+
+module TTK
+
+  module Strategies
+
+    #
+    # This strategy manage _SQL_ base tests.
+    # It use unit testing (EXCEPT ALL query) for checking results.
+    # To use it, you need to have _dbi_ installed on your test system
+    # and have a database with these things:
+    #   * a test schema (MY)
+    #   * a reference schema (REF)
+    #
+    # After that you have just to write all queries that you want to test.
+    # Queries will be called on each schema by applying a delta operation:
+    #    (REF ` MY) U (MY ` REF).
+    #
+    # In queries, %s will be replaced by given schemas.
+    #
+
+    class SqlQuery < Strategy
+      include Concrete
+
+      @@db = nil
+
+      #
+      # Methods
+      #
+
+      def prologue 
+        super
+        if @@db.nil?
+          require 'dbi'
+          # Check if driver is available
+          if DBI.available_drivers.to_s !~ /#@driver/
+            raise_error("Unknown driver: #@driver")
+          else
+            # Start DB connection
+            @@db = DBI.connect("DBI:#@driver:host=#@host;database=#@database",
+                               @user, @passwd)
+          end
+        end
+      end
+      protected :prologue
+
+
+      def run_impl 
+        @delta = nil
+        begin
+          @delta = perform_delta
+        rescue DBI::DatabaseError => ex
+          fail(ex)
+        end
+      end
+      protected :run_impl
+
+
+      def assertion
+        unless @delta.nil?
+          @log.diff_output = @delta
+          fail('Delta not empty')
+        end
+        super
+      end
+      protected :assertion
+
+
+      def perform_delta
+        output_a = []
+        output_b = []
+
+        # Make queries
+        ref_query = @query.gsub(/%s/, @ref_schema)
+        my_query = @query.gsub(/%s/, @my_schema)
+
+        # Perform REF ` MY
+        @@db.execute("#{ref_query} EXCEPT ALL #{my_query}").fetch do |row|
+          output_a << row.join(' | ')
+        end
+
+        # Perform MY ` REF
+        @@db.execute("#{my_query} EXCEPT ALL #{ref_query}").fetch do |row|
+          output_b << row.join(' | ')
+        end
+
+        # REF DELTA MY    =>    (REF ` MY) U (MY ` REF) = {}
+        # Check this
+        return nil if output_a.empty? and output_b.empty?
+
+        # Make report
+        { :'REF ` MY' => output_a.join("\n"),
+          :'MY ` REF' => output_b.join("\n") }
+      end
+      private :perform_delta
+
+      #
+      # Attributes
+      #
+
+      attribute :my_schema,     'Test schema',                   'my'
+      attribute :ref_schema,    'Reference schema',              'ref'
+      attribute :query,         'SQL query (%s for the schema)', :mandatory
+      attribute :driver,        'SQL server driver',             :mandatory
+      attribute :database,      'SQL database name',             :mandatory
+      attribute :host,          'SQL server host',               :mandatory
+      attribute :user,          'SQL user',                      :mandatory
+      attribute :passwd,        'SQL pass',                      :mandatory
+
+    end # class SqlQuery
+
+  end # module Strategies
+
+end # module TTK
+
+