patir 0.2

data/lib/patir/configuration.rb

@@ -0,0 +1,84 @@
+#  Copyright (c) 2007 Vassilis Rizopoulos. All rights reserved.
+
+require 'patir/base'
+module Patir
+  #This exception is thrown when encountering a configuration error
+  class ConfigurationException<RuntimeError
+  end
+  
+  #Configurator is the base class for all the Patir configuration classes.
+  # 
+  #The idea behind the configurator is that the developer creates a module that contains as methods
+  #all the configuration directives.
+  #He then derives a class from Configurator and includes the directives module. 
+  #The Configurator loads the configuration file and evals it with itself as context (variable configuration), so the directives become methods in the configuration file:
+  # configuration.directive="some value"
+  # configuration.other_directive={:key=>"way to group values together",:other_key=>"omg"}
+  #
+  #The Configurator instance contains all the configuration data.
+  #Configurator#configuration method is provided as a post-processing step. It should be overriden to return the configuration data in the desired format and perform any overall validation steps (single element validation steps should be done in the directives module).
+  #==Example
+  # module SimpleConfiguration
+  #   def name= tool_name
+  #     raise Patir::ConfigurationException,"Inappropriate language not allowed" if tool_name=="@#!&@&$}"
+  #     @name=tool_name
+  #   end
+  # end
+  #   
+  # class SimpleConfigurator
+  #   include SimpleConfiguration
+  #     
+  #   def configuration
+  #     return @name
+  #   end
+  # end
+  #The configuration file would then be 
+  # configuration.name="really polite name"
+  #To use it you would do
+  # cfg=SimpleConfigurator.new("config.cfg").configuration
+  class Configurator
+    attr_reader :logger,:config_file
+    def initialize config_file,logger=nil
+      @logger=logger
+      @logger||=Patir.setup_logger
+      @config_file=config_file
+      load_configuration(@config_file)
+    end
+    
+    #Returns self. This should be overriden in the actual implementations
+    def configuration
+      return self
+    end
+    private 
+    #loads the configuration from a file
+    def load_configuration filename
+      begin 
+        #change into the directory of the configuration file to make requiring easy
+        prev_dir=Dir.pwd
+        Dir.chdir(File.dirname(filename))
+        cfg_txt=File.readlines(File.basename(filename))
+        configuration=self
+        eval(cfg_txt.join(),binding())
+        #load File.basename(filename)
+        @logger.info("Configuration loaded from #{filename}") if @logger
+      rescue ConfigurationException
+        #pass it on, do not wrap again
+        raise
+      rescue SyntaxError
+        #Just wrap the exception so we can differentiate
+        @logger.debug($!)
+        raise ConfigurationException.new,"Syntax error in the configuration file '#{filename}':\n#{$!.message}"
+      rescue NoMethodError
+        @logger.debug($!)
+        raise ConfigurationException.new,"Encountered an unknown directive in configuration file '#{filename}':\n#{$!.message}"
+      rescue 
+        @logger.debug($!)
+        #Just wrap the exception so we can differentiate
+        raise ConfigurationException.new,"#{$!.message}"
+      ensure
+        #ensure we go back to our previous dir
+        Dir.chdir(prev_dir)
+      end
+    end
+  end
+end

data/test/test_patir_base.rb

@@ -0,0 +1,26 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+require 'test/unit'
+require 'patir/base.rb'
+
+class TestBase<Test::Unit::TestCase
+  def teardown
+    #clean up 
+    File.delete("temp.log") if File.exists?("temp.log")
+  end
+  #simple match test
+  def test_drb_service
+    assert_equal("druby://service.host:7000",Patir.drb_service("service.host",7000))
+  end
+  #This is not actually testing anything meaningfull but can be expanded when we learn more about 
+  #the logger
+  def test_setup_logger
+    logger=Patir.setup_logger
+    assert_not_nil(logger)
+    logger=Patir.setup_logger(nil,:silent)
+    assert_not_nil(logger)
+    logger=Patir.setup_logger("temp.log",:silent)
+    assert_not_nil(logger)
+    logger.close
+  end
+  
+end

data/test/test_patir_command.rb

@@ -0,0 +1,261 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+require 'test/unit'
+require 'patir/command.rb'
+
+class MockCommandObject
+  include Patir::Command
+end
+
+class MockCommandWarning
+  include Patir::Command
+  def run
+    @status=:warning
+    return :warning
+  end
+end
+
+class MockCommandError
+  include Patir::Command
+  def run
+    @status=:error
+    return :error
+  end
+end
+
+class TestCommand<Test::Unit::TestCase
+  #tests the default values set by the module
+  def test_module
+    obj=MockCommandObject.new
+    assert_equal("",obj.name)
+    assert_equal(:not_executed,obj.status)
+    assert(!obj.run?)
+    assert_nothing_raised{obj.run}
+    assert(obj.run?)
+    assert_equal(:success,obj.status)
+    assert_equal("",obj.output)
+    assert_equal("",obj.error)
+    assert_equal(0,obj.exec_time)
+    assert_nothing_raised{obj.reset}
+    assert_equal(:not_executed,obj.status)
+  end
+end
+
+class TestShellCommand<Test::Unit::TestCase
+  include Patir
+  def teardown
+    Dir.delete("missing/") if File.exists?("missing/")
+  end
+  #test the expected behaviour of a succesfull command
+  def test_echo
+    cmd=nil
+    assert_nothing_raised(){cmd=ShellCommand.new(:cmd=>"echo hello")}
+    assert_not_nil(cmd)
+    assert(!cmd.run?)
+    assert(!cmd.success?)
+    assert_nothing_raised(){cmd.run}
+    assert(cmd.run?)
+    assert(cmd.success?)
+    assert_equal("hello\n",cmd.output)
+    assert_equal("",cmd.error)
+    assert_equal(:success,cmd.status)
+  end
+  #test that error status is reported correctly, by testing a command that fails.
+  def test_error
+    cmd=nil
+    assert_nothing_raised(){cmd=ShellCommand.new(:cmd=>"cd /missing")}
+    assert(!cmd.run?)
+    assert(!cmd.success?)
+    assert_nothing_raised(){cmd.run}
+    assert(cmd.run?)
+    assert(!cmd.success?)
+    assert_equal(:error,cmd.status)
+  end
+  #when passed a wroking directory, the command should change into that directory
+  def test_cwd
+    cmd=nil
+    assert_nothing_raised(){cmd=ShellCommand.new(:cmd=>"echo", :working_directory=>"samples/")}
+    assert_nothing_raised(){cmd.run}
+    assert(cmd.success?)
+  end
+  
+  #when the working directory is missing, it should be created when the command is run
+  def test_missing_cwd
+    cmd=nil
+    assert_nothing_raised(){cmd=ShellCommand.new(:cmd=>"echo hello", :working_directory=>"missing/")}
+    assert_not_nil(cmd)
+    assert_equal(:success,cmd.run)
+    assert(cmd.success?)
+    assert(File.exists?("missing/"))
+  end
+  #an exception should be thrown when :cmd is nil
+  def test_missing_cmd
+    assert_raise(ParameterException){cmd=ShellCommand.new(:working_directory=>"missing/")}
+  end
+  #an exception should be thrown when no parameters are passed
+  def test_missing_params
+    assert_raise(ParameterException){cmd=ShellCommand.new()}
+  end
+  
+end
+
+class TestCommandSequence<Test::Unit::TestCase
+  include Patir
+  def setup
+    @echo=ShellCommand.new(:cmd=>"echo hello")
+    @void=MockCommandObject.new
+    @error=MockCommandError.new
+    @warning=MockCommandWarning.new
+  end
+  def test_normal
+    seq=CommandSequence.new("test")
+    assert(seq.steps.empty?)
+    assert_nothing_raised{seq.run}
+    assert(!seq.state.success?)
+    assert_equal(:warning,seq.state.status)
+    assert_nothing_raised{seq.add_step(@echo)}
+    assert_nothing_raised{seq.add_step(@void)}
+    assert_nothing_raised{seq.run}
+    assert(seq.state.success?)
+  end
+  def test_flunk_on_error
+    seq=CommandSequence.new("test")
+    assert(seq.steps.empty?)
+    assert_nothing_raised{seq.add_step(@echo,:flunk_on_error)}
+    assert_nothing_raised{seq.add_step(@error,:flunk_on_error)}
+    assert_nothing_raised{seq.add_step(@void,:flunk_on_error)}
+    assert(:not_executed==seq.state.step_state(0)[:status])
+    assert(:not_executed==seq.state.step_state(1)[:status])
+    assert(:not_executed==seq.state.step_state(2)[:status])
+    assert_nothing_raised{seq.run}
+    assert(!seq.state.success?)
+    #all three steps should have been run
+    assert(:not_executed!=seq.state.step_state(0)[:status])
+    assert(:not_executed!=seq.state.step_state(1)[:status])
+    assert(:not_executed!=seq.state.step_state(2)[:status])
+  end
+  
+  def test_fail_on_error
+    seq=CommandSequence.new("test")
+    assert(seq.steps.empty?)
+    assert_nothing_raised{seq.add_step(@echo)}
+    assert_nothing_raised{seq.add_step(@error,:fail_on_error)}
+    assert_nothing_raised{seq.add_step(@void)}
+    assert(:not_executed==seq.state.step_state(0)[:status])
+    assert(:not_executed==seq.state.step_state(1)[:status])
+    assert(:not_executed==seq.state.step_state(2)[:status])
+    assert_nothing_raised{seq.run}
+    assert(!seq.state.success?)
+    #only two steps should have been run
+    assert(:not_executed!=seq.state.step_state(0)[:status])
+    assert(:not_executed!=seq.state.step_state(1)[:status])
+    assert(:not_executed==seq.state.step_state(2)[:status])
+  end
+  
+  def test_flunk_on_warning
+    seq=CommandSequence.new("test")
+    assert(seq.steps.empty?)
+    assert_nothing_raised{seq.add_step(@echo)}
+    assert_nothing_raised{seq.add_step(@warning,:flunk_on_warning)}
+    assert_nothing_raised{seq.add_step(@void)}
+    assert(:not_executed==seq.state.step_state(0)[:status])
+    assert(:not_executed==seq.state.step_state(1)[:status])
+    assert(:not_executed==seq.state.step_state(2)[:status])
+    assert_nothing_raised{seq.run}
+    assert(!seq.state.success?)
+    #all three steps should have been run
+    assert(:not_executed!=seq.state.step_state(0)[:status])
+    assert(:not_executed!=seq.state.step_state(1)[:status])
+    assert(:not_executed!=seq.state.step_state(2)[:status])
+  end
+  
+  def test_fail_on_warning
+    seq=CommandSequence.new("test")
+    assert(seq.steps.empty?)
+    assert_nothing_raised{seq.add_step(@echo)}
+    assert_nothing_raised{seq.add_step(@warning,:fail_on_warning)}
+    assert_nothing_raised{seq.add_step(@void)}
+    assert(:not_executed==seq.state.step_state(0)[:status])
+    assert(:not_executed==seq.state.step_state(1)[:status])
+    assert(:not_executed==seq.state.step_state(2)[:status])
+    assert_nothing_raised{seq.run}
+    assert(!seq.state.success?)
+    #only two steps should have been run
+    assert(:not_executed!=seq.state.step_state(0)[:status])
+    assert(:not_executed!=seq.state.step_state(1)[:status])
+    assert(:not_executed==seq.state.step_state(2)[:status])
+  end
+end
+
+class TestCommandSequenceStatus<Test::Unit::TestCase
+  def test_new
+    st=Patir::CommandSequenceStatus.new("sequence")
+    assert(!st.running?)
+    assert(!st.success?)
+    assert_equal(:not_executed, st.status)
+    assert_nil(st.step_state(3))
+  end
+  
+  def test_step=
+    st=Patir::CommandSequenceStatus.new("sequence")
+    step1=MockCommandObject.new
+    step2=MockCommandWarning.new
+    step3=MockCommandError.new
+    step1.run
+    step1.number=1
+    step2.run
+    step2.number=2
+    step3.run
+    step3.number=3
+    st.step=step1
+    assert_equal(:success, st.status)
+    assert_equal(step1.status, st.step_state(1)[:status])
+    st.step=step2
+    assert_equal(:warning, st.status)
+    st.step=step3
+    assert_equal(:error, st.status)
+    step2.number=1
+    st.step=step2
+    assert_equal(step2.status, st.step_state(1)[:status])
+    assert_equal(:error, st.status)
+    st.step=step1
+    assert_equal(:error, st.status)
+  end
+  
+  def test_completed?
+    st=Patir::CommandSequenceStatus.new("sequence")
+    step1=MockCommandObject.new
+    step1.number=1
+    step2=MockCommandWarning.new
+    step2.number=2
+    step3=MockCommandError.new
+    step3.number=3
+    step4=MockCommandObject.new
+    st.step=step1
+    st.step=step2
+    st.step=step3
+    st.step=step4
+    assert(!st.completed?, "should not be complete.")
+    step1.run
+    st.step=step1
+    assert(!st.completed?, "should not be complete.")
+    step2.run
+    st.step=step2
+    assert(!st.completed?, "should not be complete.")
+    step2.strategy=:fail_on_warning
+    st.step=step2
+    assert(st.completed?, "should be complete.")
+    step2.strategy=nil
+    st.step=step2
+    assert(!st.completed?, "should not be complete.")
+    step3.run
+    step3.strategy=:fail_on_error
+    st.step=step3
+    assert(st.completed?, "should be complete.")
+    step3.strategy=nil
+    st.step=step3
+    assert(!st.completed?, "should not be complete.")
+    step4.run
+    st.step=step4
+    assert(st.completed?, "should be complete.")
+  end
+end

data/test/test_patir_configuration.rb

@@ -0,0 +1,19 @@
+$:.unshift File.join(File.dirname(__FILE__),"..","lib")
+require 'test/unit'
+
+require 'patir/configuration'
+module Patir
+  class TestConfigurator<Test::Unit::TestCase
+    def setup
+      @prev_dir=Dir.pwd
+      Dir.chdir(File.dirname(__FILE__))
+    end
+    def teardown
+      Dir.chdir(@prev_dir)
+    end
+    def test_configuration
+      c=Patir::Configurator.new("samples/empty.cfg")
+      assert_equal(c.configuration,c)
+    end
+  end
+end

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.1
+specification_version: 1
+name: patir
+version: !ruby/object:Gem::Version 
+  version: "0.2"
+date: 2007-05-17 00:00:00 +02:00
+summary: patir (Project Automation Tools in Ruby) provides libraries for use in automation tools
+require_paths: 
+- lib
+email: riva@braveworld.net
+homepage: http://patir.rubyforge.org
+rubyforge_project: patir
+description: "== SYNOPSIS:  patir is the library of common functionality used in the patir projects. This includes a class that allows you to build configuration files in Ruby and a library for command abstraction.  == REQUIREMENTS:  * systemu"
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: true
+required_ruby_version: !ruby/object:Gem::Version::Requirement 
+  requirements: 
+  - - ">"
+    - !ruby/object:Gem::Version 
+      version: 0.0.0
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: 
+post_install_message: 
+authors: 
+- Vassilis Rizopoulos
+files: 
+- History.txt
+- Manifest.txt
+- README.txt
+- COPYING.txt
+- Rakefile
+- lib/patir/base.rb
+- lib/patir/command.rb
+- lib/patir/configuration.rb
+- test/test_patir_base.rb
+- test/test_patir_command.rb
+- test/test_patir_configuration.rb
+- test/samples/empty.cfg
+test_files: 
+- test/test_patir_base.rb
+- test/test_patir_command.rb
+- test/test_patir_configuration.rb
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: systemu
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">"
+      - !ruby/object:Gem::Version 
+        version: 0.0.0
+    version: 
+- !ruby/object:Gem::Dependency 
+  name: hoe
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Version::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 1.2.0
+    version: