uttk 0.3.1.2

data/test/unit/logger/severity_test.rb

@@ -0,0 +1,37 @@
+# Author::    Nicolas Despr�s  <nicolas.despres@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/test/unit/logger/severity_test.rb 21975 2006-02-19T22:24:11.182512Z pouillar  $
+
+
+test_section __FILE__ do
+
+module Uttk
+
+  class Logger
+
+    class SeverityTest < ::Test::Unit::TestCase
+
+      def test_unshift
+        assert_equal(Severity::DEBUG, Severity.lower)
+        Severity.unshift('DEBUG1')
+        assert_equal(Severity::DEBUG1, Severity.lower)
+      end
+
+      def test_push
+        assert_equal(Severity::UNKNOWN, Severity.higher)
+        Severity.push('UNKNOWN1')
+        assert_equal(Severity::UNKNOWN1, Severity.higher)
+      end
+
+      def test_label
+        assert_equal('WARN', Severity.label(3))
+      end
+
+    end # class SeverityTest
+
+  end # class Logger
+
+end # module Uttk
+
+end

data/test/unit/logger/to_uttk_log_test.rb

@@ -0,0 +1,113 @@
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# License::   LGPL
+# Revision::  $Id: /w/fey/uttk/trunk/test/unit/logger/to_uttk_log_test.rb 21975 2006-02-19T22:24:11.182512Z pouillar  $
+
+test_section __FILE__ do
+
+module Uttk
+
+  class ToUttkLogTest < Test::Unit::TestCase
+    include Mocks::Assertions
+
+    @@ordered = { :ordered => true }.freeze
+
+    def setup
+      self.mock_object = Mocks::Observer.new
+      @l = Logger.new(mock_object)
+
+      @very_simple_tree_with_ohash =
+      {
+        :contents => OHash[:test1, :cmd1, :test2, :cmd2]
+      }
+      @very_simple_tree_with_array =
+      {
+        :contents => [{:test1 => :cmd1}, {:test2 => :cmd2}]
+      }
+      @very_simple_notifs = Logger.make_notifs [
+       [[[:contents, {:ordered=>true}], :test1], :cmd1],
+       [[[:contents, {:ordered=>true}], :test2], :cmd2]]
+
+      @simple_tree_with_ohash =
+      {
+        :contents => OHash[:test1, { :cmd => [:a] }]
+      }
+      @simple_notifs = Logger.make_notifs [
+        [[[:contents, {:ordered=>true}], :test1, :cmd], [:a]]]
+
+      @complex_tree_with_array =
+      {
+        :root =>
+        {
+          :strategy => [ :cmd ],
+          :contents =>
+          [
+            {
+              :test1 =>
+              {
+                :cmd  => [:a],
+                :exit => [:aa]
+              },
+            },
+            {
+              :test2 =>
+              {
+                :cmd  => :b,
+                :exit => :bb
+              },
+            }
+          ]
+        }
+      }
+
+      @complex_tree_with_ohash =
+      {
+        :root =>
+        {
+          :strategy => :cmd,
+          :contents =>
+          OHash[
+            :test1, { :cmd => [:a], :exit=> [:aa] },
+            :test2, { :cmd => :b, :exit => :bb }
+          ]
+        }
+      }
+      @complex_notifs = Logger.make_notifs [
+       [[[:root, {:type=>:cmd}], [:contents, {:ordered=>true}], :test1, :cmd], [:a]],
+       [[[:root, {:type=>:cmd}], [:contents, {:ordered=>true}], :test1, :exit], [:aa]],
+       [[[:root, {:type=>:cmd}], [:contents, {:ordered=>true}], :test2, :cmd], :b],
+       [[[:root, {:type=>:cmd}], [:contents, {:ordered=>true}], :test2, :exit], :bb]]
+    end
+
+    def test_very_simple_with_ohash
+      @l << @very_simple_tree_with_ohash
+      assert_mock @very_simple_notifs
+    end
+
+    def test_very_simple_with_array
+      @l << @very_simple_tree_with_array
+      assert_mock @very_simple_notifs
+    end
+
+    def test_simple
+      @l << @simple_tree_with_ohash
+      assert_mock @simple_notifs
+    end
+
+    def test_complex
+      @l << @complex_tree_with_ohash
+      args = mock_object.mock_args
+      @complex_notifs.each do |notif|
+        assert args.include?(notif), "args.include?(#{notif.inspect})"
+      end
+      test1 = []
+      args.each_with_index { |notif, i| test1 << i if notif.include? :test1 }
+      max_test1 = test1.max
+      args.each_with_index { |notif, i| assert(i > max_test1) if notif.include? :test2 }
+    end
+
+  end # class LoggerTest
+
+end # module Uttk
+
+end

data/test/unit/logger/verbosity_test.rb

@@ -0,0 +1,44 @@
+# Author::    Nicolas Despr�s  <nicolas.despres@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/test/unit/logger/verbosity_test.rb 21975 2006-02-19T22:24:11.182512Z pouillar  $
+
+
+test_section __FILE__ do
+
+module Uttk
+
+  class Logger
+
+    class VerbosityTest < ::Test::Unit::TestCase
+
+      class VerbosityEx < Verbosity
+      end
+
+      def test_self_verbosity
+        assert_raises(ArgumentError) do
+          VerbosityEx.verbosity :foo, 42
+        end
+        assert_raises(ArgumentError) do
+          VerbosityEx.verbosity :sections, 0
+        end
+      end
+
+      def test_self_level_fields
+        assert_equal([], Verbosity.level_fields(0))
+        assert_equal([:severity_level], Verbosity.level_fields(1))
+        assert_equal([:sections], Verbosity.level_fields(2))
+        assert_equal([:date], Verbosity.level_fields(3))
+      end
+
+      def test_higher_level
+        assert_equal(3, VerbosityEx.higher_level)
+      end
+
+    end # class VerbosityTest
+
+  end # class Logger
+
+end # module Uttk
+
+end

data/test/unit/logger_test.rb

@@ -0,0 +1,203 @@
+# Author::    Nicolas Despr�s  <nicolas.despres@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# $Id: /w/fey/uttk/trunk/test/unit/logger_test.rb 22057 2006-02-20T21:40:27.185401Z pouillar  $
+
+
+test_section __FILE__ do
+
+module Uttk
+
+  class LoggerTest < Test::Unit::TestCase
+    include Mocks::Assertions
+
+    def setup
+      self.mock_object = Mocks::Observer.new
+      @l = Logger.new(mock_object)
+    end
+
+    def assert_path ( ref )
+      assert_equal(ref, @l.path.to_s)
+    end
+
+    def assert_logger_mock ( *notifs )
+      assert_mock(*Logger.make_notifs(notifs))
+    end
+
+    @@ordered = { :ordered => true }.freeze
+
+    def test_path
+      assert_path '/'
+    end
+
+    def test_new_leaf
+      assert_logger_mock
+      assert_path '/'
+      @l.new_leaf('foo')
+      assert_logger_mock [[], "foo"]
+      assert_path '/'
+    end
+
+    def test_new_node
+      @l.new_node('foo') do
+        assert_logger_mock
+        @l.new_leaf('leaf_bar')
+        assert_path '/foo'
+        assert_logger_mock [[:foo], 'leaf_bar']
+      end
+      assert_mock_size 1
+      @l.close
+      assert_last_mock :close
+      assert_mock_size 2
+      assert_path '/'
+    end
+
+    def test_log__basic
+      @l.log { 'foo' }
+      assert_logger_mock [[:UNKNOWN], 'foo']
+    end
+
+    def test_severity_level
+      @l.severity_level = Logger::Severity::ERROR
+      @l.log(Logger::Severity::INFO) { 'foo' }
+      assert_logger_mock
+      @l.log(Logger::Severity::ERROR) { 'foo' }
+      assert_logger_mock [[:ERROR], 'foo']
+    end
+
+    def test_block_returning_nil_with_severity_level
+      @l.severity_level = Logger::Severity::ERROR
+      x = 0
+      @l.log(Logger::Severity::INFO) { x = 1 }
+      assert_equal(0, x)
+      @l.log(Logger::Severity::ERROR) { x = 2 ; nil }
+      assert_logger_mock
+      assert_equal(2, x)
+    end
+
+    def test_verbosity_level__simple
+      assert_raises(ArgumentError) { @l.verbosity_level = -1 }
+      @l.verbosity_level = 1
+      @l.log { 'foo' }
+      assert_logger_mock [[:UNKNOWN, :severity_level], 'UNKNOWN'],
+                         [[:UNKNOWN, :message], 'foo']
+    end
+
+    def test_verbosity_level__complex
+      assert_raises(ArgumentError) { @l.verbosity_level = -1 }
+      @l.verbosity_level = 2
+      @l.log { 'foo' }
+      assert_logger_mock [[:UNKNOWN, :severity_level], 'UNKNOWN'],
+                         [[:UNKNOWN, :sections], []],
+                         [[:UNKNOWN, :message], 'foo']
+    end
+
+    def test_active_section
+      @l.section_tree.push(Logger::SectionNode.new('foo'),
+                          Logger::SectionNode.new('bar',
+                                            Logger::SectionNode.new('baz'),
+                                            Logger::SectionNode.new('goo')))
+      %w(all foo bar baz goo).each do |s|
+        assert(! @l.active_section?(s), "section active #{s}")
+      end
+      @l.active_section(true, 'foo', 'baz')
+      expected_section = %w(all foo bar baz)
+      expected_section.each do |s|
+        assert(@l.active_section?(s), "section not active #{s}")
+      end
+      @l.severity_level = Logger::Severity::WARN
+      @l.verbosity_level = 2
+      @l.log(Logger::Severity::ERROR, 'foo', 'baz') { 'foo' }
+      assert_logger_mock [[:ERROR, :severity_level], 'ERROR'],
+                         [[:ERROR, :sections], ['foo', 'baz']],
+                         [[:ERROR, :message], 'foo']
+      mock_object.mock_clear
+      @l.log(Logger::Severity::FATAL, 'all') { 'toto' }
+      assert_logger_mock [[:FATAL_1, :severity_level], 'FATAL'],
+                         [[:FATAL_1, :sections], ['all']],
+                         [[:FATAL_1, :message], 'toto']
+      mock_object.mock_clear
+      @l.log(Logger::Severity::FATAL, 'goo') { 'titi' }
+      assert_logger_mock
+    end
+
+    def test_make_log_arguments
+      assert_equal([Logger::Severity::FATAL],
+                   @l.make_log_arguments('fatal'))
+      assert_equal([Logger::Severity::ERROR],
+                   @l.make_log_arguments('erROr'))
+      assert_raises(NameError) { @l.make_log_arguments('foo') }
+      assert_equal([Logger::Severity::WARN, 'all', 'goo', 'foo', 'baz'],
+                   @l.make_log_arguments('warN_all_goo_foo_baz'))
+    end
+
+    def test_sugar
+      @l.section_tree.push(Logger::SectionNode.new('foo'),
+                          Logger::SectionNode.new('bar',
+                                            Logger::SectionNode.new('baz'),
+                                            Logger::SectionNode.new('goo')))
+      %w(all foo bar baz goo).each do |s|
+        assert(! @l.active_section?(s), "section active #{s}")
+      end
+      @l.active_section(true, 'foo', 'baz')
+      expected_section = %w(all foo bar baz)
+      expected_section.each do |s|
+        assert(@l.active_section?(s), "section not active #{s}")
+      end
+      @l.severity_level = Logger::Severity::WARN
+      @l.verbosity_level = 2
+      @l.error_foo_baz{'foo'}
+      assert_logger_mock [[:ERROR, :severity_level], 'ERROR'],
+                         [[:ERROR, :sections], ['foo', 'baz']],
+                         [[:ERROR, :message], 'foo']
+    end
+
+    def test_severity_level_writer
+      high_bad_value = Logger::Severity.higher + 1
+      assert_raises(ArgumentError) { @l.severity_level = high_bad_value }
+      low_bad_value = Logger::Severity.lower - 1
+      assert_raises(ArgumentError) { @l.severity_level = low_bad_value }
+      good_value = Logger::Severity.lower + 1
+      assert_nothing_raised { @l.severity_level = good_value }
+      assert_equal(good_value, @l.severity_level)
+      assert_raises(NameError) { @l.severity_level = 'toto' }
+      assert_nothing_raised { @l.severity_level = 'warn' }
+      assert_equal(Logger::Severity::WARN, @l.severity_level)
+    end
+
+    def test_log_complex_structure
+      hsh = OHash.new
+      hsh['foo'] = :bar
+      hsh[:goo] = { :bar => 42 }
+      hsh[:qux] = [42, 43]
+
+      in_ref =
+        {
+          :root =>
+            {
+              :rest => [
+                { :'3' => hsh },
+                { 'fu' => 'yu' }
+              ]
+            }
+        }
+
+
+      out_ref =
+      [
+        [[:root, [:rest, {:ordered=>true}], [:'3', {:ordered=>true}], :foo], :bar],
+        [[:root, [:rest, {:ordered=>true}], [:'3', {:ordered=>true}], :goo, :bar], 42],
+        [[:root, [:rest, {:ordered=>true}], [:'3', {:ordered=>true}], :qux], [42, 43]],
+        [[:root, [:rest, {:ordered=>true}], :fu], "yu"]
+      ]
+
+      @l << in_ref
+
+      assert_logger_mock(*out_ref)
+    end
+
+  end # class LoggerTest
+
+end # module Uttk
+
+end

data/test/unit/strategies/suite_test.rb

@@ -0,0 +1,151 @@
+# Author::    Nicolas Pouillard  <ertai@lrde.epita.fr>.
+# Copyright:: Copyright (c) 2005 Uttk Team. All rights reserved.
+# License::   LGPL
+# $Id$
+
+
+test_section __FILE__ do
+
+module Uttk
+
+  module Strategies
+
+    class SuiteTest < ::Test::Unit::TestCase
+
+      #
+      # Tests
+      #
+
+      def test_example
+        output_ref = %q{
+          |---
+          |A set of tests: !S::Suite
+          |  attributes:
+          |    strategy: Uttk::Strategies::Cmd
+          |    exit: 0
+          |  contents:
+          |    - I'm suppose to pass 1: !S::Cmd
+          |        command: 'true'
+          |        running: 'true'
+          |        status: PASS
+          |    - I'm suppose to fail 2: !S::Cmd
+          |        weight: -1
+          |        command: 'false'
+          |        running: 'false'
+          |        my_exit: 1
+          |        status: FAIL
+          |        reason: wrong exit value
+          |    - I'm suppose to pass 3: !S::Cmd
+          |        command: 'false'
+          |        running: 'false'
+          |        status: PASS
+          |  status: PASS
+          |}.head_cut!
+
+        output_ref2 = %q{
+          |A set of tests: !S::Suite
+          |  attributes:
+          |    strategy: Uttk::Strategies::Cmd
+          |    exit: 0
+          |  contents:
+          |    - I'm suppose to pass 4: !S::Cmd
+          |        command: 'true'
+          |        running: 'true'
+          |        status: PASS
+          |    - I'm suppose to fail 5: !S::Cmd
+          |        weight: -1
+          |        command: 'false'
+          |        running: 'false'
+          |        my_exit: 1
+          |        status: FAIL
+          |        reason: wrong exit value
+          |    - I'm suppose to pass 6: !S::Cmd
+          |        command: 'false'
+          |        running: 'false'
+          |        status: PASS
+          |  status: PASS
+          |}.head_cut!
+
+        # Dynamically fix the reference output for ruby 1.8.2 since there is a
+        # strange bug with Yaml and/or Dumpers::Yaml
+        # But it's ok with ruby 1.8.3
+        unless HAVE_YAML_TAGURI
+          output_ref.gsub!(/'(true|false)'/, '\1')
+          output_ref2.gsub!(/'(true|false)'/, '\1')
+        end
+
+        TempPath.new do |tmp|
+          log = Logger.new(Dumpers::Yaml.new(tmp.open('w')))
+          log.severity_level = Logger::Severity::INFO
+          log.verbosity_level = 0
+          loader = Loaders::Yaml.new
+          symtbl = SymTbl.new
+          symtbl[:loader] = loader
+          symtbl[:log] = log
+          aDoc = {
+            :name => 'A set of tests',
+            :strategy => Strategies::Suite,
+            :symtbl => symtbl,
+            :wclass => Weights::WFloat,
+            :attributes => {
+              :strategy => Strategies::Cmd,
+              :exit => 0
+            },
+            :contents => OHash[
+              "I'm suppose to pass 1", { :command => 'true' },
+              "I'm suppose to fail 2", { :command => 'false', :weight => -1 },
+              "I'm suppose to pass 3", { :command => 'false', :exit   => 1 }
+            ]
+          }
+          aSuite = aDoc.testify(:loader => loader)
+          aSuite.run
+          # mini_diff(output_ref, tmp.read)
+          assert_nothing_raised { @my = YAML::load(tmp.read) }
+          assert_equal(YAML::load(output_ref), @my)
+
+          aSuite = Strategies::Suite.new
+          aSuite.name = 'A set of tests'
+          aSuite.symtbl = symtbl
+          aSuite.wclass = Weights::WFloat
+          aSuite.strategyclass = Strategies::Cmd
+          aSuite.exit = 0    # a sugar when its unambiguous.
+          t1 = aSuite.create
+          t1.name = "I'm suppose to pass 4"
+          t1.command = 'true'
+          aSuite.create(:name    => "I'm suppose to fail 5",
+                        :command => 'false',
+                        :weight  => -1)
+
+          io = StringIO.new
+          io << "|---
+                 |I'm suppose to pass 6:
+                 |  command: 'false'
+                 |  exit: 1".gsub(/^\s*\|/, '')
+
+          io.rewind
+          aSuite.create(io)
+
+          aSuite.run
+          # mini_diff(output_ref, tmp.read)
+          assert_nothing_raised { @my = YAML::load(tmp.read) }
+          assert_equal(YAML::load(output_ref2), @my)
+        end
+      end
+
+      def mini_diff ( a, b )
+        a = a.split(/\n/)
+        b = b.split(/\n/)
+        d = a.zip(b).delete_if { |x, y| x == y }
+        d.each do |x, y|
+          puts "-#{x}"
+          puts "+#{y}"
+        end
+      end
+
+    end # class SuiteTest
+
+  end # module Strategies
+
+end # module Uttk
+
+end