tf 0.3.0

data/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2011 Michal Papis
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

data/README.md

@@ -0,0 +1,71 @@
+# Testing Framework
+
+TF is a pluggable framework for testing shell scripts (at least now).
+TF also is an umbrella which incorporates (eventually) multiple gems, each of which provides additional functionality
+to TF. TF is the skeleton upon which all other tf-* gems build.
+
+
+## Usage
+
+    $ gem install tf
+    $ tf <path/to/file>_comment_test.sh
+    $ tf --text <path/to/file>_comment_test.sh
+
+## Comment tests
+
+Filename has to end with _comment_test.sh
+
+Example test file:
+
+    ## User comments start with double #
+    ## command can be writen in one line with multiple tests:
+    true # status=0; match=/^$/
+    ## or tests can be placed in following lines:
+    false
+    # status=1
+
+### Matchers
+
+The test can be negated by replacing `=` with `!=`
+
+- status=<number> - check if command returned given status (0 is success)
+- match=/<regexp>/ - regexp match command output
+- env[<var_name>]=/<regexp>/ - regexp match the given environment variable name
+
+## Example
+
+    $ bin/tf example_tests/comment/*
+    F..
+    ##### Processed commands 2 of 2, success tests 2 of 3, failure tests 1 of 3.
+    $ false
+    # failed: status = 0 # was 1
+    
+    $ bin/tf example_tests/comment/* --text
+    ##### starting test failure.
+    $ false
+    # failed: status = 0 # was 1
+    ##### starting test success.
+    $ true
+    # passed: status = 0
+    # passed: status != 1
+    ##### Processed commands 2 of 2, success tests 2 of 3, failure tests 1 of 3.
+
+## Internal architecture
+
+Framework will load plugins from any available gem and local `lib/` path, for example:
+
+    lib/plugins/tf/text_output.rb
+    lib/plugins/tf/status_test.rb
+    lib/plugins/tf/comment_test_input.rb
+
+The search pattern is:
+
+    lib/plugins/tf/*.rb
+
+And plugins are selected with:
+
+    lib/plugins/tf/*_{input,test,output}.rb
+
+## Thanks
+
+ - Deryl R. Doucette

data/bin/tf

@@ -0,0 +1,7 @@
+#!/usr/bin/env ruby
+
+program_root = File.dirname( File.dirname( __FILE__ ) )
+
+require "#{program_root}/lib/tf"
+
+exit TF.new.run_tests ARGV

data/lib/plugins/tf/comment_test_input.rb

@@ -0,0 +1,40 @@
+class TF::CommentTestInput
+  def initialize
+  end
+
+  def self.argument_matches? argument
+    if argument =~ /_comment_test\.sh$/ && File.exist?(argument)
+      [:load, :input]
+    else
+      nil
+    end
+  end
+
+  def load file_name
+    lines = []
+    File.readlines(file_name).each{|line|
+      # Fix jruby-1.6.6-d19 bug with empty strings from files
+      line = "#{line}"
+      # remove human comments
+      line.sub!(/##.*$/,'')
+      # reject empty lines
+      line.strip!
+      next if line =~ /^$/
+      # extract command and tests
+      cmd, tests = line.split("#")
+      cmd.strip!
+      tests = if tests.blank?
+        []
+      else
+        tests.split(";").map(&:strip)
+      end
+      if cmd.blank?
+        lines.last[:tests] += tests unless lines.last.nil?
+      else
+        lines << { :cmd => cmd, :tests => tests }
+      end
+    }
+    name = file_name.gsub(/^.*\//,'').sub(/_comment_test\.sh$/,'')
+    { :name => name, :commands => lines }
+  end
+end

data/lib/plugins/tf/env_match_test.rb

@@ -0,0 +1,18 @@
+class TF::EnvMatchTest
+  MATCHER = /^env\[(.*)\]([!]?=)[~]?\/(.*)\//
+
+  def matches? test
+    test =~ TF::EnvMatchTest::MATCHER
+  end
+
+  def execute test, _stdout, _stderr, _stdboth, _status, env
+    test =~ TF::EnvMatchTest::MATCHER
+    variable, sign, value = $1.strip, $2, $3
+    var_val = env[ variable ]
+    if ( sign == "=" ) ^ ( Regexp.new(value) =~ "#{var_val}" )
+      [ false, "failed: env #{variable} #{sign} /#{value}/ # was '#{var_val}'" ]
+    else
+      [ true, "passed: env #{variable} #{sign} /#{value}/" ]
+    end
+  end
+end

data/lib/plugins/tf/error_summary_output.rb

@@ -0,0 +1,93 @@
+class TF::ErrorSummaryOutput
+  RED = `tput setaf 1`
+  GREEN = `tput setaf 2`
+  YELLOW = `tput setaf 3`
+  BLUE = `tput setaf 4`
+  RESET = `tput setaf 9`
+
+  def self.argument_matches? argument
+    [:load] if argument == "--dotted"
+  end
+
+  def initialize output=nil
+    @counts={}
+    @counts[:commands] = 0
+    @counts[:tests] = 0
+    @counts[:commands_started] = 0
+    @counts[:commands_finished] = 0
+    @counts[:tests_success] = 0
+    @counts[:tests_failure] = 0
+    @counter_id = 0
+    @summary = {}
+    @output = output || $stdout
+  end
+
+  def start_processing
+  end
+
+  def status
+    text = "#{BLUE}##### Processed commands #{@counts[:commands_finished]} of #{@counts[:commands]}"
+    if @counts[:tests_success] > 0
+      text += ", #{GREEN}success tests #{@counts[:tests_success]} of #{@counts[:tests]}"
+    end
+    if @counts[:tests_failure] > 0
+      text += ", #{RED}failure tests #{@counts[:tests_failure]} of #{@counts[:tests]}"
+    end
+    skipped = @counts[:tests] - @counts[:tests_success] - @counts[:tests_failure]
+    if skipped > 0
+      text += ", #{YELLOW}skipped tests #{skipped} of #{@counts[:tests]}"
+    end
+    text += ".#{RESET}"
+    text
+  end
+
+  def summary
+    @summary.sort{|a,b| ak,_=a ; bk,_=b ; ak <=> bk }.each{|k,v|
+      @output.puts "#{YELLOW}$ #{v[:cmd]}#{RESET}"
+      v[:failed_tests].each{|t| puts "#{RED}# #{t}#{RESET}" }
+    }
+    text = ""
+    text
+  end
+
+  def end_processing
+    @output.printf "\n"
+    @output.puts status
+    @output.puts summary
+  end
+
+  def start_test test, env
+    @counts[:commands] += test[:commands].size
+    tests_counts = test[:commands].map{|line| line[:tests].nil? ? 0 : line[:tests].size }
+    @counts[:tests] += tests_counts.empty? ? 0 : tests_counts.inject(&:+)
+  end
+
+  def end_test test
+  end
+
+  def start_command line
+    @counts[:commands_started] += 1
+    @current_line = line.merge(:counter_id => @counts[:commands_started])
+  end
+
+  def end_command line, status, env
+    @counts[:commands_finished] += 1
+  end
+
+  def command_out out
+  end
+
+  def command_err err
+  end
+
+  def test_processed test, status, msg
+    @output.printf status ? "." : "F"
+    if status
+      @counts[:tests_success] += 1
+    else
+      @counts[:tests_failure] += 1
+      @summary[@current_line[:counter_id]] ||= @current_line.merge({:failed_tests=>[]})
+      @summary[@current_line[:counter_id]][:failed_tests] << msg
+    end
+  end
+end

data/lib/plugins/tf/output_match_test.rb

@@ -0,0 +1,17 @@
+class TF::OutputMatchTest
+  MATCHER = /^match([!]?=)[~]?\/(.*)\//
+
+  def matches? test
+    test =~ TF::OutputMatchTest::MATCHER
+  end
+
+  def execute test, _stdout, _stderr, _stdboth, _status, env
+    test =~ TF::OutputMatchTest::MATCHER
+    sign, value = $1, $2
+    if ( sign == "=" ) ^ ( Regexp.new(value) =~ "#{_stdboth}" )
+      [ false, "failed: match #{sign} /#{value}/" ]
+    else
+      [ true, "passed: match #{sign} /#{value}/" ]
+    end
+  end
+end

data/lib/plugins/tf/stats_output.rb

@@ -0,0 +1,73 @@
+class TF::StatsOutput
+  RED = `tput setaf 1`
+  GREEN = `tput setaf 2`
+  YELLOW = `tput setaf 3`
+  BLUE = `tput setaf 4`
+  RESET = `tput setaf 9`
+
+  def self.argument_matches? argument
+    [:load] if argument == "--text"
+  end
+
+  def initialize
+    @counts={}
+    @counts[:commands] = 0
+    @counts[:tests] = 0
+    @counts[:commands_finished] = 0
+    @counts[:tests_success] = 0
+    @counts[:tests_failure] = 0
+  end
+
+  def start_processing
+  end
+
+  def status
+    text = "#{BLUE}##### Processed commands #{@counts[:commands_finished]} of #{@counts[:commands]}"
+    if @counts[:tests_success] > 0
+      text += ", #{GREEN}success tests #{@counts[:tests_success]} of #{@counts[:tests]}"
+    end
+    if @counts[:tests_failure] > 0
+      text += ", #{RED}failure tests #{@counts[:tests_failure]} of #{@counts[:tests]}"
+    end
+    skipped = @counts[:tests] - @counts[:tests_success] - @counts[:tests_failure]
+    if skipped > 0
+      text += ", #{YELLOW}skipped tests #{skipped} of #{@counts[:tests]}"
+    end
+    text += ".#{RESET}"
+    text
+  end
+
+  def end_processing
+    puts status
+  end
+
+  def start_test test, env
+    @counts[:commands] += test[:commands].size
+    tests_counts = test[:commands].map{|line| line[:tests].nil? ? 0 : line[:tests].size }
+    @counts[:tests] += tests_counts.empty? ? 0 : tests_counts.inject(&:+)
+  end
+
+  def end_test test
+  end
+
+  def start_command line
+  end
+
+  def end_command line, status, env
+    @counts[:commands_finished] += 1
+  end
+
+  def command_out out
+  end
+
+  def command_err err
+  end
+
+  def test_processed test, status, msg
+    if status
+      @counts[:tests_success] += 1
+    else
+      @counts[:tests_failure] += 1
+    end
+  end
+end

data/lib/plugins/tf/status_test.rb

@@ -0,0 +1,17 @@
+class TF::StatusTest
+  MATCHER = /^status([!]?=)([[:digit:]]+)$/
+
+  def matches? test
+    test =~ TF::StatusTest::MATCHER
+  end
+
+  def execute test, _stdout, _stderr, _stdboth, _status, env
+    test =~ TF::StatusTest::MATCHER
+    sign, value = $1, $2.to_i
+    if ( sign == "=" ) ^ ( _status == value )
+      [ false, "failed: status #{sign} #{value} # was #{_status}" ]
+    else
+      [ true, "passed: status #{sign} #{value}" ]
+    end
+  end
+end

data/lib/plugins/tf/text_output.rb

@@ -0,0 +1,52 @@
+class TF::TextOutput
+  RED = `tput setaf 1`
+  GREEN = `tput setaf 2`
+  YELLOW = `tput setaf 3`
+  BLUE = `tput setaf 4`
+  RESET = `tput setaf 9`
+
+  def self.argument_matches? argument
+    [:load] if argument == "--text"
+  end
+
+  def initialize
+  end
+
+  def start_processing
+  end
+
+  def end_processing
+  end
+
+  def start_test test, env
+    puts "#{BLUE}##### starting test #{test[:name]}.#{RESET}"
+  end
+
+  def end_test test
+    #puts "#{BLUE}##### finished test #{test[:name]}.#{RESET}"
+  end
+
+  def start_command line
+    puts "#{YELLOW}$ #{line[:cmd]}#{RESET}"
+  end
+
+  def end_command line, status, env
+    #puts ": $?=#{status}"
+  end
+
+  def command_out out
+    puts out
+  end
+
+  def command_err err
+    puts err
+  end
+
+  def test_processed test, status, msg
+    if status
+      puts "#{GREEN}# #{msg}#{RESET}"
+    else
+      puts "#{RED}# #{msg}#{RESET}"
+    end
+  end
+end

data/lib/tf.rb

@@ -0,0 +1,94 @@
+require 'rubygems'
+require 'singleton'
+require 'yaml'
+require 'session'
+
+lib_root = File.dirname( __FILE__ )
+
+# include lib in path so plugins get found with Gem.find_files
+$:.unshift "#{lib_root}"
+
+class TF; end
+# load tf/*.rb
+Dir["#{lib_root}/tf/*.rb"].each{|lib| require lib }
+
+class TF
+  def initialize
+    @ruby = File.join(RbConfig::CONFIG["bindir"],RbConfig::CONFIG["ruby_install_name"])
+    @plugins = TF::Plugins.instance
+    @failures = 0
+  end
+
+  def run_tests args
+    @plugins.load(%w( all_test ))
+    input_files, not_processed = @plugins.parse_args(args)
+    if not_processed.size > 0
+      $stderr.puts "No plugin recognized this option '#{not_processed*" "}'."
+      exit 1
+    end
+    @plugins.load(%w( ErrorSummaryOutput )) if @plugins.output_plugins.empty?
+    process(input_files)
+    @failures == 0
+  end
+
+  def process input_files
+    @plugins.output_plugins(:start_processing)
+    input_files.each do |plugin,file|
+      process_test( plugin.load(file) )
+    end
+    @plugins.output_plugins(:end_processing)
+  end
+
+  def env shell
+    Hash[ shell.execute(
+      @ruby + ' -e \'ENV.each{|k,v| printf "#{k}=#{v}\0"}\''
+    )[0].split("\0").map{|var| var.split('=', 2) } ]
+  end
+
+  def process_test test
+    name, commands = test[:name], test[:commands]
+    shell = Session::Bash.new
+    _env = env(shell)
+    @plugins.output_plugins(:start_test, test, _env)
+    commands.each do |line|
+      command, tests = line[:cmd], line[:tests]
+      @plugins.output_plugins(:start_command, line)
+      _stdout  = StringIO.new
+      _stderr  = StringIO.new
+      _stdboth = StringIO.new
+      shell.execute "#{command}" do |out, err|
+        if out
+          @plugins.output_plugins(:command_out, out)
+          _stdout  << out
+          _stdboth << out
+        end
+        if err
+          @plugins.output_plugins(:command_err, err)
+          _stderr  << err
+          _stdboth << err
+        end
+      end
+      _status = shell.status
+      _env = env(shell)
+      @plugins.output_plugins(:end_command, line, _status, _env)
+      process_command_tests _stdout.string, _stderr.string, _stdboth.string, _status, _env, tests
+    end
+    @plugins.output_plugins(:end_test, test)
+  end
+
+  def process_command_tests _stdout, _stderr, _stdboth, _status, env, tests
+    tests.each do |test|
+      plugin = @plugins.test_plugins.find{|_plugin| _plugin.matches? test }
+      if plugin.nil?
+        status, msg = false, "Could not find plugin for test '#{test}'."
+      else
+        status, msg = plugin.execute(test, _stdout, _stderr, _stdboth, _status, env)
+      end
+      @failures+=1 unless status
+      @plugins.output_plugins(:test_processed, test, status, msg)
+    end
+  end
+
+  class << self
+  end
+end

data/lib/tf/active_patches.rb

@@ -0,0 +1,21 @@
+unless String.method_defined? :blank?
+  String.class_eval do
+    def blank?
+      self == ""
+    end
+  end
+end
+unless Array.method_defined? :blank?
+  Array.class_eval do
+    def blank?
+      size == 0
+    end
+  end
+end
+unless NilClass.method_defined? :blank?
+  NilClass.class_eval do
+    def blank?
+      true
+    end
+  end
+end

data/lib/tf/plugins.rb

@@ -0,0 +1,102 @@
+class TF::Plugins
+  include Singleton
+
+  def initialize
+    detect
+    @additional_plugins = []
+    @input_plugins = []
+    @output_plugins = []
+    @test_plugins = []
+  end
+
+  def detect
+    @plugins = Gem.find_files('plugins/tf/*.rb')
+  end
+
+  def add plugin
+    @additional_plugins << plugin
+  end
+
+  def delete plugin
+    @additional_plugins.delete plugin
+  end
+
+  def file_to_class item
+    File.basename(item,'.rb').capitalize.gsub(/_(.)/){ $1.upcase }
+  end
+
+  def list pattern=nil
+    # collect to lists
+    _list = @plugins + @additional_plugins
+    # filter by pattern if given
+    _list = _list.select{|item| item.match("_#{pattern}.rb$") } unless pattern.nil?
+    # get path and class name
+    _list.map!{|item| [ item, file_to_class(item), pattern ] }
+    # TODO: limit plugin versions (highest || use bundler)
+    _list.each{|item, klass, type| require item }
+    _list
+  end
+
+  def load wanted
+    [ :input, :test, :output ].each do |type|
+      _list = list(type)
+      if ! wanted.include?("all") && ! wanted.include?("all_#{type}")
+        _list = _list.select{|item, klass, _type| wanted.include?(klass) }
+      end
+      _list.each{|item, klass, _type|
+        klass = TF.const_get(klass)
+        instance_variable_get("@#{type}_plugins".to_sym) << klass.new
+      }
+    end
+  end
+
+  def match_arg_klass arg, klass, type
+    klass = TF.const_get(klass)
+    return nil unless klass.respond_to? :argument_matches?
+    matches = klass.argument_matches? arg
+    return nil if matches.nil?
+    matches.each do |match|
+      case match
+      when :load
+        instance_variable_get("@#{type}_plugins".to_sym) << klass.new
+      when :input
+        @input_files << [klass.new, arg]
+      else
+        return nil
+      end
+    end
+    return matches
+  rescue NameError
+    return nil
+  end
+
+  def parse_args args
+    @input_files, not_processed = [], []
+    available_plugins = [ :input, :test, :output ].map{ |type| list(type) }.flatten(1)
+    args.each do |arg|
+      matched = available_plugins.map do |item, klass, type|
+        match_arg_klass arg, klass, type
+      end.flatten.reject(&:nil?)
+      if matched.empty?
+        not_processed << arg
+      end
+    end
+    [ @input_files, not_processed ]
+  end
+
+  def input_plugins
+    @input_plugins
+  end
+
+  def output_plugins *args
+    if args.empty?
+      @output_plugins
+    else
+      @output_plugins.each{|plugin| plugin.send(*args) }
+    end
+  end
+
+  def test_plugins
+    @test_plugins
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: tf
+version: !ruby/object:Gem::Version
+  version: 0.3.0
+  prerelease: 
+platform: ruby
+authors:
+- Michal Papis
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-05-28 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: session
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: Testing Framework solely based on plugins. For now only tests using Bash.
+email: mpapis+tf@gmail.com
+executables:
+- tf
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/tf.rb
+- lib/tf/active_patches.rb
+- lib/tf/plugins.rb
+- lib/plugins/tf/error_summary_output.rb
+- lib/plugins/tf/text_output.rb
+- lib/plugins/tf/output_match_test.rb
+- lib/plugins/tf/env_match_test.rb
+- lib/plugins/tf/stats_output.rb
+- lib/plugins/tf/comment_test_input.rb
+- lib/plugins/tf/status_test.rb
+- bin/tf
+- LICENSE
+- README.md
+homepage: http://github.com/mpapis/tf
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Testing Framework
+test_files: []