Merge 9b742b6 into 76f4f0c

Gemfile

@@ -5,9 +5,9 @@ gem "highline","~>1.7"
 
 group :development do
   gem 'coveralls', :require => false
-	gem "hoe",'~>3.14.2'
-	gem 'rdoc','~>4.2.0'
-	gem "mocha","~>1.1.0", :require => false
-  gem "pry"
-  gem "test-unit", "~>3.1.3", :require => false
+	gem "hoe",'~>3.16.0', :require => false
+	gem 'rdoc','~>5.0.0', :require => false
+	gem "mocha","~>1.2.1", :require => false
+  gem "pry", :require => false
+  gem 'minitest','~>5.10.1',:require => false
 end

History.txt

@@ -1,3 +1,6 @@
+== 2.0.0.pre15 /2017-02-08
+ * Update gem dependencies
+ * Switch to minitest
 == 2.0.0.pre14 /2017-01-11
  * Fixed 2.3.1 compat issue (mrkita)
 == 2.0.0.pre13 /2016-09-13

Rakefile

@@ -23,7 +23,7 @@ Rake::Task[:default].clear()
 task :default =>[:"test:coverage"]
 
 task :"test:coverage" do
-  require "test-unit"
+  require "minitest"
   require 'coveralls'
   Coveralls.wear!
   Rake::FileList["#{File.dirname(__FILE__)}/test/test_*.rb"].each do |test_file|

lib/rutema/version.rb

@@ -3,7 +3,7 @@ module Rutema
   module Version
     MAJOR=2
     MINOR=0
-    TINY="0.pre14"
+    TINY="0.pre15"
     STRING=[ MAJOR, MINOR, TINY ].join( "." )
   end
 end

test/test_configuration.rb

@@ -1,7 +1,7 @@
 
 require_relative '../lib/rutema/core/configuration'
 #$DEBUG=true
-require 'test/unit'
+require 'minitest'
 require 'mocha/setup'
 
 FULL_CONFIG=<<-EOT
@@ -30,7 +30,7 @@
 EOT
 
 module TestRutema
-  class TestRutemaConfiguration<Test::Unit::TestCase
+  class TestRutemaConfiguration<Minitest::Test
     def test_rutema_configuration
       cfg="foo.cfg"
       File.expects(:read).with("full.rutema").returns(FULL_CONFIG)
@@ -39,24 +39,24 @@ def test_rutema_configuration
       File.expects(:exist?).with(File.expand_path("setup.spec")).returns(true)
       File.expects(:exist?).with("T001.spec").returns(false)
       #load the valid configuration
-      assert_nothing_raised() { cfg=Rutema::Configuration.new("full.rutema")}
-      assert_not_nil(cfg.parser)
-      assert_not_nil(cfg.reporters)
+      cfg=Rutema::Configuration.new("full.rutema")
+      refute_nil(cfg.parser)
+      refute_nil(cfg.reporters)
       assert_equal(1, cfg.reporters.size)
-      assert_not_nil(cfg.tools)
-      assert_not_nil(cfg.tools.test[:configuration])
-      assert_not_nil(cfg.tools.test[:path])
+      refute_nil(cfg.tools)
+      refute_nil(cfg.tools.test[:configuration])
+      refute_nil(cfg.tools.test[:path])
       assert_equal("test", cfg.tools.test[:name])
-      assert_not_nil(cfg.paths)
-      assert_not_nil(cfg.paths.test)
-      assert_not_nil(cfg.tests)
-      assert_not_nil(cfg.context)
+      refute_nil(cfg.paths)
+      refute_nil(cfg.paths.test)
+      refute_nil(cfg.tests)
+      refute_nil(cfg.context)
     end
 
     def test_specification_paths
       File.expects(:read).with("test_identifiers.rutema").returns(IDENTIFIERS)
       cfg=Rutema::Configuration.new("test_identifiers.rutema")
-      assert_not_nil(cfg.tests)
+      refute_nil(cfg.tests)
       assert_equal(3, cfg.tests.size)
       assert(cfg.tests.include?('22345'))
     end

test/test_engine.rb

@@ -1,4 +1,4 @@
-require 'test/unit'
+require 'minitest'
 require 'ostruct'
 require 'mocha/setup'
 require_relative '../lib/rutema/core/engine'
@@ -34,12 +34,12 @@ def self.updates
     end
   end
 
-  class TestEngine<Test::Unit::TestCase
+  class TestEngine<Minitest::Test
     def test_checks
       conf={}
-      assert_raise(NoMethodError){Rutema::Engine.new(conf)}
+      assert_raises(NoMethodError){Rutema::Engine.new(conf)}
       conf=OpenStruct.new(:parser=>{},:runner=>{})
-      assert_raise(Rutema::RutemaError){Rutema::Engine.new(conf)}
+      assert_raises(Rutema::RutemaError){Rutema::Engine.new(conf)}
     end
 
     def test_run
@@ -51,13 +51,11 @@ def test_run
             "#{File.expand_path(File.dirname(__FILE__))}/data/duplicate_name.spec"],
           :context=>{})
       engine=nil
-      #assert_nothing_raised() do 
-        engine=Rutema::Engine.new(conf)
-        engine.run
-      #end
+      engine=Rutema::Engine.new(conf)
+      engine.run
       assert_equal(5, MockReporter.updates)
       #test for a spec that is not in the config and re-entry
-      assert_raise(Rutema::RutemaError) { engine.run("foo")}
+      assert_raises(Rutema::RutemaError) { engine.run("foo")}
       assert_equal(1, MockReporter.updates)
     end
   end

test/test_objectmodel.rb

@@ -1,4 +1,4 @@
-require 'test/unit'
+require 'minitest'
 require_relative '../lib/rutema/core/objectmodel'
 module TestRutema
   class DummyCommand
@@ -12,48 +12,48 @@ def initialize
   class Dummy
     include Rutema::SpecificationElement
   end
-  class TestSpecificationElement<Test::Unit::TestCase
+  class TestSpecificationElement<Minitest::Test
     def test_attribute
       obj=Dummy.new
-      assert_raise(NoMethodError) { obj.name }
+      assert_raises(NoMethodError) { obj.name }
       obj.attribute(:name,"name")
       assert(obj.has_name?)
       assert_equal(obj.name, "name")
-      assert_raise(NoMethodError) { obj.bool }
+      assert_raises(NoMethodError) { obj.bool }
       obj.attribute(:bool,true)
       assert(obj.bool?)
       assert_equal(true, obj.bool)
-      assert_raise(NoMethodError) { obj.text_bool }
+      assert_raises(NoMethodError) { obj.text_bool }
       obj.attribute(:text_bool,"true")
       assert(obj.text_bool?)
-      assert_not_equal(true, obj.text_bool)
+      refute_equal(true, obj.text_bool)
     end
 
     def test_method_missing
       obj=Dummy.new
-      assert_raise(NoMethodError) { obj.name }
+      assert_raises(NoMethodError) { obj.name }
       obj.name="name"
       assert(obj.has_name?)
       assert_equal(obj.name, "name")
     end
   end
-  class TestStep<Test::Unit::TestCase
+  class TestStep<Minitest::Test
     def test_new
       step=Rutema::Step.new("Step",DummyCommand.new())
-      assert_not_equal("dummy", step.name)
+      refute_equal("dummy", step.name)
       assert(/step - .*DummyCommand.*/=~step.name)
       assert_equal("output", step.output)
       assert_equal("error", step.error)
       assert_equal(:not_executed, step.status)
-      assert_nothing_raised() { step.run }
+      refute_nil(step.run)
       assert_equal(:success, step.status)
-      assert_nothing_raised() { step.reset }
+      refute_nil(step.reset)
       assert_equal(:not_executed, step.status)
       assert_equal("", step.output)
       assert(/0 - .*DummyCommand.*/=~step.to_s)
     end
   end
-  class TestScenario<Test::Unit::TestCase
+  class TestScenario<Minitest::Test
     def test_add_step
       scenario=Rutema::Scenario.new([])
       assert(scenario.steps.empty?)
@@ -64,7 +64,7 @@ def test_add_step
       assert_equal(2,scenario.steps.size)
     end
   end
-  class TestSpecification<Test::Unit::TestCase
+  class TestSpecification<Minitest::Test
     def test_new
       spec=Rutema::Specification.new(:name=>"name",:title=>"title",:description=>"description")
       assert(!spec.has_version?, "Version present")
@@ -73,7 +73,7 @@ def test_new
       assert_equal("description", spec.description)
       assert(!spec.has_scenario?,"Scenario present")
       spec.scenario="Foo"
-      assert_not_nil(spec.scenario)
+      refute_nil(spec.scenario)
       assert_equal("name - title", spec.to_s)
       #we can arbitrarily add attributes to a spec
       spec.requirements=["R1","R2"]

test/test_parsers.rb

@@ -1,4 +1,4 @@
-require 'test/unit'
+require 'minitest'
 require 'ostruct'
 require 'mocha/setup'
 require_relative '../lib/rutema/parsers/xml'
@@ -63,16 +63,16 @@ module Samples
     </scenario>
     EOT
   end
-  class TestSpecificationParser<Test::Unit::TestCase
+  class TestSpecificationParser<Minitest::Test
     def test_specification_parser
       parser=nil
-      assert_nothing_raised() { parser=Rutema::Parsers::SpecificationParser.new({}) }
-      assert_not_nil(parser)
+      parser=Rutema::Parsers::SpecificationParser.new({})
+      refute_nil(parser)
       assert(parser.configuration.empty?,"Configuration is not empty")
-      assert_raise(Rutema::ParserError) { parser.parse_specification("foo") }
+      assert_raises(Rutema::ParserError) { parser.parse_specification("foo") }
     end
   end
-  class TestXMLParser<Test::Unit::TestCase
+  class TestXMLParser<Minitest::Test
     def test_parse_specification
       config=stub()
       config.stubs(:parser).returns({})
@@ -87,8 +87,8 @@ def test_parse_specification
       assert_equal("another_step", specification.scenario.steps[1].step_type)
       assert_equal("script", specification.scenario.steps[1].script)
       assert_equal(2, specification.scenario.steps[1].number)
-      assert_raise(Rutema::ParserError) { parser.parse_specification("") }
-      assert_raise(Rutema::ParserError) { parser.parse_specification("missing.spec") }
+      assert_raises(Rutema::ParserError) { parser.parse_specification("") }
+      assert_raises(Rutema::ParserError) { parser.parse_specification("missing.spec") }
     end
     def test_include
       config=stub()
@@ -97,16 +97,16 @@ def test_include
       specification=parser.parse_specification(Samples::INCLUDE_SPEC)
       assert_equal(3, specification.scenario.steps.size)
       assert(specification.scenario.steps[2].has_included_in?)
-      assert_raise(Rutema::ParserError) {  parser.parse_specification(Samples::BAD_INCLUDE_SPEC) }
-      assert_raise(Rutema::ParserError) {  parser.parse_specification(Samples::MISSING_INCLUDE_SPEC) }
+      assert_raises(Rutema::ParserError) {  parser.parse_specification(Samples::BAD_INCLUDE_SPEC) }
+      assert_raises(Rutema::ParserError) {  parser.parse_specification(Samples::MISSING_INCLUDE_SPEC) }
     end
     def test_parse_error
       config=stub()
       config.stubs(:parser).returns({})
       parser=Rutema::Parsers::XML.new(config)
-      assert_not_nil(parser.configuration)
+      refute_nil(parser.configuration)
       specification=nil
-      assert_raise(Rutema::ParserError) { specification=parser.parse_specification("<") }
+      assert_raises(Rutema::ParserError) { specification=parser.parse_specification("<") }
     end
   end
 end

test/test_reporters.rb

@@ -1,9 +1,9 @@
-require 'test/unit'
+require 'minitest'
 require_relative '../lib/rutema/reporters/junit'
 require 'mocha/setup'
 
 module TestRutema
-  class TestReporters<Test::Unit::TestCase
+  class TestReporters<Minitest::Test
     def test_junit
       #Rutema::Utilities.expects(:write_file).returns("OK")
       configuration = mock()

test/test_runners.rb

@@ -1,4 +1,4 @@
-require 'test/unit'
+require 'minitest'
 require 'ostruct'
 require 'patir/command'
 require 'mocha/setup'
@@ -7,14 +7,14 @@
 require_relative '../lib/rutema/core/runner'
 
 module TestRutema
-  class TestRunner<Test::Unit::TestCase
+  class TestRunner<Minitest::Test
     def test_new
       scenario=Rutema::Scenario.new([Rutema::Step.new("desc")])
       spec=Rutema::Specification.new(:scenario=>scenario)
       queue=Queue.new
       runner=Rutema::Runners::Default.new({},queue)
       state=nil
-      assert_nothing_raised() { state=runner.run(spec) }
+      state=runner.run(spec)
       assert_equal(1, state["steps"].size)
       assert_equal(4, queue.size)
       assert_equal("started", queue.pop.text)
@@ -29,7 +29,7 @@ def test_run_exceptions
       queue=Queue.new
       runner=Rutema::Runners::Default.new({},queue)
       state=nil
-      assert_nothing_raised() { state=runner.run(spec) }
+      state=runner.run(spec)
       assert_equal(:error, state['status'])
     end
   end