zombie-chaser 0.0.1

data/README.txt

@@ -0,0 +1,47 @@
+== DESCRIPTION:
+
+Zombie chaser is a graphic(al) interface to mutation testing. Kill off the mutants, or they will eat your brains!
+
+The human running across the screen represents the normal running of your unit tests. If one of them fails, then the human dies.
+
+Then the zombies chase after you. Each zombie represents a mutation to your code. If your unit tests detect that something's wrong with your code, then the mutation gets killed. Otherwise, the zombie gets to meet you.
+
+== FEATURES/PROBLEMS:
+
+* Code is slightly different to chaser.
+* Not quite finished.
+
+== REQUIREMENTS:
+
+* Gosu
+* Test-unit (for ruby 1.9)
+
+== INSTALL:
+
+* sudo gem install zombie-chaser
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2006-2009 Ryan Davis and Kevin Clark and Andrew Grimm,
+Chris Lloyd, Dave Newman, Carl Woodward & Daniel Bogan.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,24 @@
+task :default => [:test]
+
+begin
+  require 'jeweler'
+  require File.dirname(__FILE__) + "/lib/zombie_test_chaser.rb"
+  Jeweler::Tasks.new do |gemspec|
+    gemspec.name = "zombie-chaser"
+    gemspec.summary = "Lightweight mutation testing ... with ZOMBIES!!!"
+    gemspec.description = "A zombie-themed graphic(al) user interface for mutation testing"
+    gemspec.email = "andrew.j.grimm@gmail.com"
+    gemspec.authors = ["Andrew Grimm", "Ryan Davis", "Eric Hodel", "Kevin Clark"]
+    #gemspec.add_dependency('test-unit') #FIXME Don't know how to only add the dependency for ruby 1.9
+    gemspec.add_dependency('gosu') #FIXME add option for command-line version, which'll make gosu an optional dependency
+    gemspec.version = ZombieTestChaser::VERSION
+    gemspec.homepage = "http://andrewjgrimm.wordpress.com/2009/11/08/declare-war-on-everything-with-chaser/"
+  end
+rescue LoadError
+  puts "Jeweler not available. Install it with: sudo gem install jeweler"
+end
+
+task :test do
+  ruby "test/test_unit.rb"
+end
+

data/bin/zombie-chaser

@@ -0,0 +1,65 @@
+#!/usr/local/bin/ruby
+
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. lib])
+require 'zombie_test_chaser'
+require 'optparse'
+
+force = false
+target_everything = false
+
+opts = OptionParser.new do |opts|
+  opts.banner = "Usage: #{File.basename($0)} class_name [method_name]"
+  opts.on("-v", "--verbose", "Loudly explain chaser run") do |opt|
+    ZombieTestChaser.debug = true
+  end
+
+  opts.on("-V", "--version", "Prints zombie-chaser's version number") do |opt|
+    puts "zombie-chaser #{ZombieTestChaser::VERSION}"
+    exit 0
+  end
+
+  opts.on("-t", "--tests TEST_PATTERN",
+          "Location of tests (glob). Unix-style even on Windows, so use forward slashes.") do |pattern|
+    ZombieTestChaser.test_pattern = pattern
+  end
+
+  opts.on("--everything", "Zombie chase all classes") do |opt|
+    puts "You're now facing a plague of zombies!"
+    target_everything = true
+  end
+
+  opts.on("-F", "--force", "Ignore initial test failures") do |opt|
+    force = true
+  end
+
+  opts.on("-T", "--timeout SECONDS", "The maximum time for a test run in seconds",
+                                     "Used to catch infinite loops") do |timeout|
+    Chaser.timeout = timeout.to_i
+    puts "Setting timeout at #{timeout} seconds."
+  end
+
+  opts.on("-r", "--random-seed SEED", "Random seed number (under development)") do |seed|
+    srand(seed.to_i)
+  end
+
+  opts.on("-h", "--help", "Show this message") do |opt|
+    puts opts
+    exit 0
+  end
+end
+
+looks_like_rails = test ?f, 'config/environment.rb'
+ZombieTestChaser.test_pattern = "test/**/*.rb" if looks_like_rails
+
+opts.parse!
+
+impl = ARGV.shift
+meth = ARGV.shift
+
+unless impl or target_everything then
+  puts opts
+  exit 1
+end
+
+exit ZombieTestChaser.validate(impl, meth, force)
+

data/lib/chaser.rb

@@ -0,0 +1,373 @@
+require 'rubygems'
+require 'timeout'
+require 'world'
+
+class String # :nodoc:
+  def to_class
+    split(/::/).inject(Object) { |klass, name| klass.const_get(name) }
+  end
+end
+
+##
+# Test Unit Sadism
+
+class Chaser
+
+  class Timeout < Timeout::Error; end
+
+  ##
+  # The version of Chaser you are using.
+
+  VERSION = '0.0.4'
+
+  ##
+  # Is this platform MS Windows-like?
+
+  WINDOZE = RUBY_PLATFORM =~ /mswin/
+
+  ##
+  # Path to the bit bucket.
+
+  NULL_PATH = WINDOZE ? 'NUL:' : '/dev/null'
+
+  ##
+  # Class being chased
+
+  attr_accessor :klass
+
+  ##
+  # Name of class being chased
+
+  attr_accessor :klass_name
+
+  ##
+  # Method being chased
+
+  attr_accessor :method
+
+  ##
+  # Name of method being chased
+
+  attr_accessor :method_name
+
+  ##
+  # The original version of the method being chased
+
+  attr_reader :old_method
+
+  @@debug = false
+  @@guess_timeout = true
+  @@timeout = 60 # default to something longer (can be overridden by runners)
+
+  def self.debug
+    @@debug
+  end
+
+  def self.debug=(value)
+    @@debug = value
+  end
+
+  def self.timeout=(value)
+    @@timeout = value
+    @@guess_timeout = false # We've set the timeout, don't guess
+  end
+
+  def self.guess_timeout?
+    @@guess_timeout
+  end
+
+  ##
+  # Creates a new Chaser that will chase +klass_name+ and +method_name+,
+  # sending results to +reporter+.
+
+  def initialize(klass_name = nil, method_name = nil, reporter = Reporter.new)
+    @klass_name = klass_name
+    @method_name = method_name.intern if method_name
+
+    @klass = klass_name.to_class if klass_name
+
+    @method = nil
+    @reporter = reporter
+
+    @mutated = false
+
+    @failure = false
+  end
+
+  ##
+  # Overwrite test_pass? for your own Chaser runner.
+
+  def tests_pass?
+    raise NotImplementedError
+  end
+
+  def run_tests
+    if zombie_survives? then
+      record_passing_mutation
+    else
+      @reporter.report_test_failures
+    end
+  end
+
+  ############################################################
+  ### Running the script
+
+  def validate
+    @reporter.method_loaded(klass_name, method_name)
+
+    begin
+      modify_method
+      timeout(@@timeout, Chaser::Timeout) { run_tests }
+    rescue Chaser::Timeout
+      @reporter.warning "Your tests timed out. Chaser may have caused an infinite loop."
+    rescue Interrupt
+      @reporter.warning 'Mutation canceled, hit ^C again to exit'
+      sleep 2
+    end
+
+    unmodify_method # in case we're validating again. we should clean up.
+
+    if @failure
+      @reporter.report_failure
+      false
+    else
+      @reporter.no_surviving_mutant
+      true
+    end
+  end
+
+  def record_passing_mutation
+    @failure = true
+  end
+
+  def calculate_proxy_method_name(original_name)
+    result = "__chaser_proxy__#{original_name}"
+    character_renaming = {"[]" => "square_brackets", "^" => "exclusive_or",
+    "=" => "equals", "&" => "ampersand", "*" => "splat", "+" => "plus",
+    "-" => "minus", "%" => "percent", "~" => "tilde", "@" => "at",
+    "/" => "forward_slash", "<" => "less_than", ">" => "greater_than"}
+    character_renaming.each do |characters, renamed_string_portion|
+      result.gsub!(characters, renamed_string_portion)
+    end
+    result
+  end
+
+  def unmodify_instance_method
+    chaser = self
+    @mutated = false
+    chaser_proxy_method_name = calculate_proxy_method_name(@method_name)
+    @klass.send(:define_method, chaser_proxy_method_name) do |block, *args|
+      chaser.old_method.bind(self).call(*args) {|*yielded_values| block.call(*yielded_values)}
+    end
+  end
+
+  def unmodify_class_method
+    chaser = self
+    @mutated = false
+    chaser_proxy_method_name = calculate_proxy_method_name(clean_method_name)
+    aliasing_class(@method_name).send(:define_method, chaser_proxy_method_name) do |block, *args|
+      chaser.old_method.bind(self).call(*args) {|*yielded_values| block.call(*yielded_values)}
+    end
+  end
+
+  # Ruby 1.8 doesn't allow define_method to handle blocks.
+  # The blog post http://coderrr.wordpress.com/2008/10/29/using-define_method-with-blocks-in-ruby-18/
+  # show that define_method has problems, and showed how to do workaround_method_code_string
+  def modify_instance_method
+    chaser = self
+    @mutated = true
+    @old_method = @klass.instance_method(@method_name)
+    chaser_proxy_method_name = calculate_proxy_method_name(@method_name)
+    workaround_method_code_string = <<-EOM
+      def #{@method_name}(*args, &block)
+        #{chaser_proxy_method_name}(block, *args)
+      end
+    EOM
+    @klass.class_eval do
+      eval(workaround_method_code_string)
+    end
+    @klass.send(:define_method, chaser_proxy_method_name) do |block, *args|
+      original_value = chaser.old_method.bind(self).call(*args) do |*yielded_values|
+        mutated_yielded_values = yielded_values.map{|value| chaser.mutate_value(value)}
+        block.call(*mutated_yielded_values)
+      end
+      chaser.mutate_value(original_value)
+    end
+  end
+
+  def modify_class_method
+    chaser = self
+    @mutated = true
+    @old_method = aliasing_class(@method_name).instance_method(clean_method_name)
+    chaser_proxy_method_name = calculate_proxy_method_name(clean_method_name)
+    workaround_method_code_string = <<-EOM
+      def #{@method_name}(*args, &block)
+        #{chaser_proxy_method_name}(block, *args)
+      end
+    EOM
+    @klass.class_eval do
+      eval(workaround_method_code_string)
+    end
+    aliasing_class(@method_name).send(:define_method, chaser_proxy_method_name) do |block, *args|
+      original_value = chaser.old_method.bind(self).call(*args) do |*yielded_values|
+        mutated_yielded_values = yielded_values.map{|value| chaser.mutate_value(value)}
+        block.call(*mutated_yielded_values)
+      end
+      chaser.mutate_value(original_value)
+    end
+  end
+
+  def modify_method
+    if method_name.to_s =~ /self\./
+      modify_class_method
+    else
+      modify_instance_method
+    end
+  end
+
+  def unmodify_method
+    if method_name.to_s =~ /self\./ #TODO fix duplication. Give the test a name
+      unmodify_class_method
+    else
+      unmodify_instance_method
+    end
+  end
+
+
+  ##
+  # Replaces the value with a random value.
+
+  def mutate_value(value)
+    case value
+    when Fixnum, Float, Bignum
+      value + rand_number
+    when String
+      rand_string
+    when Symbol
+      rand_symbol
+    when Regexp
+      Regexp.new(Regexp.escape(rand_string.gsub(/\//, '\\/')))
+    when Range
+      rand_range
+    when NilClass, FalseClass
+      rand_number
+    when TrueClass
+      false
+    else
+      nil
+    end
+  end
+
+  ############################################################
+  ### Convenience methods
+
+  def aliasing_class(method_name)
+    method_name.to_s =~ /self\./ ? class << @klass; self; end : @klass
+  end
+
+  def clean_method_name
+    method_name.to_s.gsub(/self\./, '')
+  end
+
+  ##
+  # Returns a random Fixnum.
+
+  def rand_number
+    (rand(100) + 1)*((-1)**rand(2))
+  end
+
+  ##
+  # Returns a random String
+
+  def rand_string
+    size = rand(50)
+    str = ""
+    size.times { str << rand(126).chr }
+    str
+  end
+
+  ##
+  # Returns a random Symbol
+
+  def rand_symbol
+    letters = ('a'..'z').to_a + ('A'..'Z').to_a
+    str = ""
+    (rand(50) + 1).times { str << letters[rand(letters.size)] }
+    :"#{str}"
+  end
+
+  ##
+  # Returns a random Range
+
+  def rand_range
+    min = rand(50)
+    max = min + rand(50)
+    min..max
+  end
+
+  ##
+  # Suppresses output on $stdout and $stderr.
+
+  def silence_stream
+    return yield if @@debug
+
+    begin
+      dead = File.open(Chaser::NULL_PATH, "w")
+
+      $stdout.flush
+      $stderr.flush
+
+      oldstdout = $stdout.dup
+      oldstderr = $stderr.dup
+
+      $stdout.reopen(dead)
+      $stderr.reopen(dead)
+
+      result = yield
+
+    ensure
+      $stdout.flush
+      $stderr.flush
+
+      $stdout.reopen(oldstdout)
+      $stderr.reopen(oldstderr)
+      result
+    end
+  end
+
+  class Reporter
+    def method_loaded(klass_name, method_name)
+      info "#{klass_name}\##{method_name} loaded"
+    end
+
+    def warning(message)
+      puts "!" * 70
+      puts "!!! #{message}"
+      puts "!" * 70
+      puts
+    end
+
+    def info(message)
+      puts "*"*70
+      puts "***  #{message}"
+      puts "*"*70
+      puts
+    end
+
+    def report_failure
+      puts
+      puts "The affected method didn't cause test failures."
+      puts
+    end
+
+    def no_surviving_mutant
+      puts "The mutant didn't survive. Cool!\n\n"
+    end
+
+    def report_test_failures
+      puts "Tests failed -- this is good" if Chaser.debug
+    end
+  end
+
+end
+

data/lib/human.rb

@@ -0,0 +1,180 @@
+$:.unshift File.join(File.dirname(__FILE__), *%w[.. ui])
+
+require "test_unit_handler"
+require "ui" #For actor superclass
+
+class Human < Actor
+  private_class_method :new
+  attr_reader :successful_step_count
+
+  def self.new_using_test_unit_handler(test_pattern, world)
+    new(test_pattern, world)
+  end
+
+  def initialize(test_pattern, world)
+    @status = nil #Currently only used by zombie
+    @world = world
+    @successful_step_count = 0
+    @health = :alive
+    @test_handler = TestUnitHandler.new(test_pattern, self)
+  end
+
+  def run
+    notify_world
+    @test_handler.run
+  end
+
+  def current_symbol
+    case @health
+    when :alive
+      "@"
+    when :dying
+      "*"
+    when :dead
+      "+"
+    end
+  end
+
+  def actor_type
+    'robot'
+  end
+
+  def actor_state
+    return "attacking" if @status == :attacking
+    case @health
+    when :alive
+      "moving"
+    when :dying
+      "dying"
+    when :dead
+      "dead"
+    end
+  end
+
+  def actor_direction
+    270.0
+  end
+
+  def notify_passing_step
+    @successful_step_count += 1
+    notify_world
+  end
+
+  def notify_failing_step
+    @health = :dying
+    notify_world
+  end
+
+  def dying?
+    @health == :dying
+  end
+
+  def dead?
+    @health == :dead
+  end
+
+  def finish_dying
+    sleep 0.5
+    raise "I'm not dead yet!" unless dying?
+    @health = :dead
+    notify_world
+    sleep 0.5
+  end
+
+  def notify_world
+    @world.something_happened
+  end
+
+  def get_eaten
+    @health = :dying unless dead?
+  end
+end
+
+class MockHuman < Human
+  private_class_method :new
+
+  def self.new_using_results(results, world)
+    new(results, world)
+  end
+
+  def initialize(results, world)
+    @world = world
+    @results = results
+    @successful_step_count = 0
+    @health = :alive
+  end
+
+  def run
+    until @successful_step_count == @results.size
+      if @results[@successful_step_count] == :failure
+        @health = :dying
+        notify_world
+        return
+      end
+      notify_world
+      @successful_step_count += 1
+    end
+    notify_world
+  end
+end
+
+class MockZombieList
+
+  def self.new_using_results(zombies_results, world)
+    zombies = zombies_results.map do |zombie_results|
+      MockZombie.new_using_results(zombie_results, world)
+    end
+    new(zombies)
+  end
+
+  def initialize(zombies)
+    @zombies = zombies
+    @current_zombie_number = 0
+  end
+
+  def supply_next_zombie
+    zombie = @zombies[@current_zombie_number]
+    @current_zombie_number += 1
+    zombie
+  end
+
+  def all_slain?
+    @current_zombie_number == @zombies.length
+  end
+end
+
+module ZombieInterface
+  def current_symbol
+    case @health
+    when :alive
+      "Z"
+    when :dying
+      "*"
+    when :dead
+      "+"
+    end
+  end
+
+  def actor_type
+    'zombie'
+  end
+
+  def actor_direction
+    90.0
+  end
+
+end
+
+class Zombie < Human
+  include ZombieInterface
+
+  def eat(human)
+    @status = :attacking #Even if the human's dead, look for leftovers
+    human.get_eaten
+  end
+end
+
+class MockZombie < MockHuman #Fixme provide a proper hierarchy
+  include ZombieInterface
+
+end