rutema 1.3.0 → 2.0.0.pre

data/test/data/duplicate_name.spec

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<specification name="sample">
-<title>Duplicate name specification</title>
-<description>Check for parser errors</description>
-<scenario>
-	<echo text="Hello testing world"/>
-</scenario>
-</specification>

data/test/data/no_title.spec

@@ -1,5 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<specification name="no_title">
-<description>Expect a parser error</description>
-<scenario></scenario>
-</specification>

data/test/data/sample.spec

@@ -1,8 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<specification name="sample">
-<title>Sample specification</title>
-<description>Something to play with</description>
-<scenario>
-	<echo text="Hello testing world"/>
-</scenario>
-</specification>

data/test/data/test_identifiers.rutema

@@ -1,7 +0,0 @@
-require 'rutema/parsers/xml'
-configuration.parser={:class=>Rutema::MinimalXMLParser}
-configuration.tests=[
-"../examples/specs/T001.spec",
-"22345",
-"../examples/specs/T003.spec",
-]

data/test/test_configuration.rb

@@ -1,43 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","lib")
-require 'test/unit'
-require 'rutema/configuration'
-#$DEBUG=true
-module TestRutema
-  class TestRutemaConfigurator<Test::Unit::TestCase
-    def setup
-      @prev_dir=Dir.pwd
-      Dir.chdir(File.dirname(__FILE__))
-    end
-    def teardown
-      Dir.chdir(@prev_dir)
-    end
-    def test_rutema_configuration
-      cfg=nil
-      #load the valid configuration
-      assert_nothing_raised() { cfg=Rutema::RutemaConfigurator.new("../examples/config/full.rutema").configuration}
-      assert_not_nil(cfg.parser)
-      assert_not_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])
-      assert_equal("test", cfg.tools.test[:name])
-      assert_not_nil(cfg.paths)
-      assert_not_nil(cfg.paths.test)
-      assert_not_nil(cfg.setup)
-      assert_not_nil(cfg.teardown)
-      assert_not_nil(cfg.check)
-      assert_not_nil(cfg.tests)
-      assert_not_nil(cfg.context)
-    end
-    
-    def test_specification_paths
-      cfg=Rutema::RutemaConfigurator.new("data/test_identifiers.rutema").configuration
-      assert_not_nil(cfg.tests)
-      assert(File.exists?(cfg.tests[0]))
-      assert(File.exists?(cfg.tests[2]))
-      assert(cfg.tests.include?('22345'))
-    end
-    
-  end
-end

data/test/test_objectmodel.rb

@@ -1,82 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..","lib")
-require 'test/unit'
-require 'rutema/objectmodel'
-module TestRutema
-  class DummyCommand
-    include Patir::Command
-    def initialize
-      @name="dummy"
-      @output="output"
-      @error="error"
-    end
-  end
-  class Dummy
-    include Rutema::SpecificationElement
-  end
-  class TestStep<Test::Unit::TestCase
-    def test_new
-      step=Rutema::TestStep.new("test step",DummyCommand.new())
-      assert(!step.attended?, "attended?")
-      assert_not_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 }
-      assert_equal(:success, step.status)
-      assert_nothing_raised() { step.reset }
-      assert_equal(:not_executed, step.status)
-      assert_equal("", step.output)
-      assert(/0 - step - .*DummyCommand.*- not_executed/=~step.to_s)
-    end
-  end
-  class TestSpecification<Test::Unit::TestCase
-    def test_new
-      spec=Rutema::TestSpecification.new(:name=>"name",:title=>"title",:description=>"description")
-      assert_equal("name", spec.name)
-      assert_equal("title", spec.title)
-      assert_equal("description", spec.description)
-      assert_not_nil(spec.scenario)
-      assert(spec.requirements.empty?)
-      assert_equal("name - title", spec.to_s)
-    end
-  end
-  class TestScenario<Test::Unit::TestCase
-    def test_new
-      scenario=Rutema::TestScenario.new
-      assert(scenario.steps.empty?)
-      assert(!scenario.attended?)
-    end
-    def test_add_step
-      step=Rutema::TestStep.new("test step",DummyCommand.new())
-      scenario=Rutema::TestScenario.new
-      scenario.add_step(step)
-      assert_equal(1,scenario.steps.size)
-    end
-  end
-  class TestSpecificationElement<Test::Unit::TestCase
-    def test_attribute
-      obj=Dummy.new
-      assert_raise(NoMethodError) { obj.name }
-      obj.attribute(:name,"name")
-      assert(obj.has_name?)
-      assert_equal(obj.name, "name")
-      assert_raise(NoMethodError) { obj.bool }
-      obj.attribute(:bool,true)
-      assert(obj.bool?)
-      assert_equal(true, obj.bool)
-      assert_raise(NoMethodError) { obj.text_bool }
-      obj.attribute(:text_bool,"true")
-      assert(obj.text_bool?)
-      assert_not_equal(true, obj.text_bool)
-    end
-    
-    def test_method_missing
-      obj=Dummy.new
-      assert_raise(NoMethodError) { obj.name }
-      obj.name="name"
-      assert(obj.has_name?)
-      assert_equal(obj.name, "name")
-    end
-  end
-end

data/test/test_parsers.rb

@@ -1,131 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),'..','lib')
-require 'test/unit'
-require 'ostruct'
-require 'mocha/setup'
-require 'rutema/parsers/xml'
-
-#$DEBUG=true
-module TestRutema
-  class TestSpecificationParser<Test::Unit::TestCase
-    def test_specification_parser
-      parser=nil
-      assert_nothing_raised() { parser=Rutema::SpecificationParser.new({}) }
-      assert_not_nil(parser)
-      assert(!parser.configuration.empty?)
-      assert_raise(Rutema::ParserError) { parser.parse_specification("foo") }
-    end
-  end
-  class TestBaseXMlParser<Test::Unit::TestCase
-    SAMPLE_SPEC=<<-EOT
-    <specification name="sample">
-    <title>Title</title>
-    <description>Description</description>
-    <scenario>
-    <step/>
-    <another_step script="script"/>
-    </scenario>
-    </specification>
-    EOT
-    INCLUDE_SPEC=<<-EOT
-    <specification name="include">
-    <title>Title</title>
-    <description>Description</description>
-    <scenario>
-    <step/>
-    <include_scenario file="#{File.expand_path(File.dirname(__FILE__))}/../examples/specs/include.scenario"/>
-    </scenario>
-    </specification>
-    EOT
-    BAD_INCLUDE_SPEC=<<-EOT
-    <specification name="bad_include">
-    <title>Title</title>
-    <description>Description</description>
-    <scenario>
-    <include_scenario file=unknown.scenario"/>
-    </scenario>
-    </specification>
-    EOT
-    MISSING_INCLUDE_SPEC=<<-EOT
-    <specification name="bad_include">
-    <title>Title</title>
-    <description>Description</description>
-    <scenario>
-    <include_scenario/>
-    </scenario>
-    </specification>
-    EOT
-
-    def test_parse_specification
-      parser=Rutema::BaseXMLParser.new({})
-      specification=parser.parse_specification(SAMPLE_SPEC)
-      assert_equal("sample",specification.name)
-      assert_equal("Description", specification.description)
-      assert_equal("Title", specification.title)
-      assert(specification.scenario)
-      assert_equal(2, specification.scenario.steps.size)
-      assert_equal(1, specification.scenario.steps[0].number)
-      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") }
-    end
-
-    def test_include
-      parser=Rutema::BaseXMLParser.new({})
-      specification=parser.parse_specification(INCLUDE_SPEC)
-      assert_equal(3, specification.scenario.steps.size)
-      assert(specification.scenario.steps[2].has_included_in?)
-      assert_raise(Rutema::ParserError) {  parser.parse_specification(BAD_INCLUDE_SPEC) }
-      assert_raise(Rutema::ParserError) {  parser.parse_specification(MISSING_INCLUDE_SPEC) }
-    end
-
-  end
-  class TestExtensibleXMlParser<Test::Unit::TestCase
-    SAMPLE_SPEC=<<-EOT
-    <specification name="sample">
-    <title>Title</title>
-    <description>Description</description>
-    <scenario>
-    <step/>
-    <another_step script="script"/>
-    </scenario>
-    </specification>
-    EOT
-    def test_parse_specification
-      parser=Rutema::ExtensibleXMLParser.new({})
-      assert_not_nil(parser.configuration)
-      specification=nil
-      assert_nothing_raised() { specification=parser.parse_specification(SAMPLE_SPEC) }
-      assert_equal(2, specification.scenario.steps.size)
-    end
-    def test_parse_error
-      parser=Rutema::ExtensibleXMLParser.new({})
-      assert_not_nil(parser.configuration)
-      specification=nil
-      assert_raise(Rutema::ParserError) { specification=parser.parse_specification("<") }
-    end
-  end
-  class TestMinimalXMlParser<Test::Unit::TestCase
-    SAMPLE_SPEC=<<-EOT
-    <specification name="sample">
-    <title>Title</title>
-    <description>Description</description>
-    <scenario>
-    <echo/>
-    <command cmd="l"/>
-    </scenario>
-    </specification>
-    EOT
-    def test_parse_specification
-      parser=Rutema::MinimalXMLParser.new({})
-      specification=nil
-      assert_nothing_raised() { specification=parser.parse_specification(SAMPLE_SPEC) }
-      assert_not_nil(specification)
-      assert_equal(2, specification.scenario.steps.size)
-      assert_equal("Description", specification.description)
-      assert_equal("Title", specification.title)
-      assert_equal("sample", specification.name)
-    end
-  end
-end

data/test/test_reporters.rb

@@ -1,115 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..",'lib')
-require 'test/unit'
-require 'ostruct'
-require 'fileutils'
-require 'rutema/reporters/base'
-require 'rutema/reporters/email'
-require 'rutema/reporters/text'
-require 'mocha/setup'
-#$DEBUG=true
-module TestRutema
-  class MockCommand
-    include Patir::Command
-    def initialize number
-      @number=number
-    end
-  end
-  class TestEmailReporter<Test::Unit::TestCase
-    def setup
-      @parse_errors=[{:filename=>"f.spec",:error=>"error"}]
-      st=Patir::CommandSequenceStatus.new("test_seq")
-      st.step=MockCommand.new(1)
-      st.step=MockCommand.new(2)
-      st.step=MockCommand.new(3)
-      @status=[st]
-    end
-    
-    def test_new
-      spec=mock()
-      spec.expects(:title).returns("A test sequence")
-      specs={"test_seq"=>spec}
-      definition={:server=>"localhost",:port=>25,:recipients=>["test"],:sender=>"rutema",:subject=>"test",:footer=>"footer"}
-      r=Rutema::EmailReporter.new(definition)
-      Net::SMTP.expects(:start).times(2)
-      assert_nothing_raised() { puts r.report(specs,@status,@parse_errors,nil) }
-      assert_nothing_raised() { puts r.report(specs,[],[],nil) }
-    end
-
-    def test_multiple_scenarios
-      #The status mocks
-      status1=status_mock("test6. Status - error. States 3\nStep status summary:\n\t1:'echo' - success\n\t2:'check' - warning\n\t3:'try' - error",6,"T2",:error)
-      
-      status2=status_mock("test10. Status - success. States 3\nStep status summary:\n\t1:'echo' - success\n\t2:'check' - success\n\t3:'try' - success",10,"T1",:success)
-      status3=status_mock("testNil. Status - success. States 3\nStep status summary:\n\t1:'echo' - success\n\t2:'check' - success\n\t3:'try' - success",nil,nil,:success)
-      status4=status_mock("test10s. Status - success. States 3\nStep status summary:\n\t1:'echo' - success\n\t2:'check' - success\n\t3:'try' - success","10s","Setup",:success)
-      status5=status_mock("test60. Status - error. States 3\nStep status summary:\n\t1:'echo' - success\n\t2:'check' - warning\n\t3:'try' - error",60,"T1",:error)
-      stati=[status1,status2,status3,status4,status5]
-      #mock the mailing code
-      definition={:server=>"localhost",:port=>25,:recipients=>["test"],:sender=>"rutema",:subject=>"test"}
-      r=Rutema::EmailReporter.new(definition)
-      Net::SMTP.expects(:start)
-      #The specification mocks
-      spec1=mock()
-      spec1.expects(:title).times(2).returns("T1")
-      spec2=mock()
-      spec2.expects(:title).returns("T2")
-      specs={"T1"=>spec1, "T2"=>spec2}
-      assert_nothing_raised() {  puts r.report(specs,stati,@parse_errors,nil) }
-    end
-    
-    def status_mock summary,id,name,state
-      ret=mock()
-      ret.stubs(:summary).returns(summary)
-      ret.stubs(:sequence_id).returns(id)
-      if name
-        ret.stubs(:sequence_name).returns(name)
-      else
-        ret.stubs(:sequence_name).returns(name)
-      end
-      ret.stubs(:status).returns(state)
-      return ret
-    end
-  end
-
-  class TestTextReporter<Test::Unit::TestCase
-      def setup
-        @parse_errors=[{:filename=>"f.spec",:error=>"error"}]
-        st=Patir::CommandSequenceStatus.new("test_seq")
-        st.step=MockCommand.new(1)
-        st.step=MockCommand.new(2)
-        st.step=MockCommand.new(3)
-        @status=[st]
-      end
-      
-      def test_no_errors
-        spec=mock
-        spec.stubs(:title).returns("T")
-        r=Rutema::TextReporter.new
-        assert_nothing_raised() { puts r.report({"0"=>spec},[runner_state_mock],[],nil) }
-      end
-      
-      def test_a_bit_of_everything
-        spec=mock
-        spec.stubs(:title).returns("T")
-        r=Rutema::TextReporter.new
-        assert_nothing_raised() { puts r.report({"1"=>spec,"0"=>spec},[runner_state_mock,runner_state_mock(1,:success)],[],nil)}
-      end
-      
-      def scenario_mock id,no_summary=false
-        ret = mock()
-        ret.expects(:sequence_id).returns(id)
-        ret.expects(:sequence_name).returns("test").times(2)
-        ret.expects(:summary).returns("summary") unless no_summary
-        return ret
-      end
-      
-      def runner_state_mock n=0,status=:success,step_states=[]
-        rs=mock()
-        rs.expects(:sequence_name).returns("#{n}").times(3)
-        rs.expects(:sequence_id).returns("seq_id#{n}")
-        rs.expects(:status).returns(status).times(4)
-        rs.expects(:summary).returns("summary")
-        return rs
-      end
-  end
-end

data/test/test_runners.rb

@@ -1,70 +0,0 @@
-$:.unshift File.join(File.dirname(__FILE__),"..",'lib')
-require 'test/unit'
-require 'ostruct'
-require 'patir/command'
-require 'mocha/setup'
-
-require 'rutema/objectmodel'
-require 'rutema/runners/default'
-require 'rutema/runners/step'
-
-#$DEBUG=true
-module TestRutema
-  class TestRunner<Test::Unit::TestCase
-    def test_new
-      runner=Rutema::Runner.new
-      assert(!runner.attended?)
-      assert_nil(runner.setup)
-      assert_nil(runner.teardown)
-      assert(runner.states.empty?)
-    end
-    def test_run
-      runner=Rutema::Runner.new
-      scenario=Rutema::TestScenario.new
-      state1=runner.run("test1",scenario)
-      state2=runner.run("test2",scenario)
-      assert_equal(state1, runner["test1"])
-      assert_equal(state2, runner["test2"])
-      assert_equal(2, runner.states.size)
-      state2=runner.run("test2",scenario)
-      assert_equal(2, runner.states.size)
-    end
-    def test_run_exceptions
-      runner=Rutema::Runner.new
-      scenario=Rutema::TestScenario.new
-      step=Rutema::TestStep.new("bad",Patir::RubyCommand.new("bad"){|cmd| raise "Bad command"})
-      scenario.add_step(step)
-      state1=:success
-      assert_nothing_raised() { state1=runner.run("test1",scenario) }
-      assert_equal(:error, state1.status)
-    end
-    def test_reset
-      runner=Rutema::Runner.new
-      scenario=Rutema::TestScenario.new
-      state1=runner.run("test1",scenario)
-      state2=runner.run("test2",scenario)
-      assert_equal(2, runner.states.size)
-      runner.reset
-      assert(runner.states.empty?)
-    end
-    def test_ignore
-      step=OpenStruct.new("status"=>:not_executed)
-      step.stubs(:number).returns(1)
-      step.stubs(:name).returns("mock")
-      step.stubs(:step_type).returns("mock")
-      step.stubs(:output).returns("mock")
-      step.stubs(:error).returns("")
-      step.stubs(:strategy).returns(:attended)
-      step.stubs(:exec_time).returns(12)
-      step.stubs(:has_cmd?).returns(false)
-      step.expects(:ignore?).returns(true)
-      step.expects(:status).times(6).returns(:not_executed).then.returns(:not_executed).then.returns(:error).then.returns(:warning).then.returns(:warning).then.returns(:warning)
-      scenario=Rutema::TestScenario.new
-      scenario.expects(:attended?).returns(false)
-      scenario.stubs(:steps).returns([step])
-      runner=Rutema::Runner.new
-      runner.run("ignore",scenario)
-      assert(runner.success?,"run is not a success")
-    end
-  end
-end