zombie-chaser 0.0.1

data/lib/interface.rb

@@ -0,0 +1,77 @@
+class Interface
+  attr_writer :human, :current_zombie
+
+  def initialize
+    @representations = []
+    @current_zombie = nil
+  end
+
+  def current_representation
+    if @current_zombie.nil?
+      "." * human_successful_step_count + @human.current_symbol
+    elsif human_successful_step_count > @current_zombie.successful_step_count
+      "." * @current_zombie.successful_step_count + @current_zombie.current_symbol + "." * (@human.successful_step_count - @current_zombie.successful_step_count - 1) + @human.current_symbol
+    else
+      "." * @current_zombie.successful_step_count + @current_zombie.current_symbol
+    end
+  end
+
+  def human_successful_step_count
+    @human.successful_step_count
+  end
+
+  def something_happened
+    @representations << current_representation
+    display_representation(@representations.last)
+  end
+
+end
+
+class NoInterface < Interface
+  attr_reader :representations
+
+  def display_representation(representation)
+    #Do nothing
+  end
+
+  def finish
+    #Do nothing
+  end
+end
+
+class ConsoleInterface < Interface
+
+  def display_representation(representation)
+    print "\r", representation
+    STDOUT.flush
+    sleep 0.2
+  end
+
+  def finish
+    puts
+  end
+end
+
+class GuiInterface < Interface
+
+  def initialize
+    @window = Window.new
+    #Actor.window = @window #Fixme why can't this do the trick?
+    Human.window = @window
+    Zombie.window = @window
+    @window_showing_thread = Thread.new {@window.show}
+  end
+
+  #Doesn't need to be used, as window updates 60 times a second anyway
+  def something_happened
+  end
+
+  def human=(human)
+    @window.human = human
+  end
+
+  def current_zombie=(current_zombie)
+    @window.current_zombie = current_zombie
+  end
+
+end

data/lib/test_unit_handler.rb

@@ -0,0 +1,42 @@
+require "test/unit/collector/objectspace"
+require "test/unit/ui/testrunnermediator"
+
+class TestUnitHandler
+  attr_reader :results
+
+  def initialize(test_pattern, actor)
+    @actor = actor
+    raise "Error: can't detect any files in test pattern \"#{test_pattern} (Don't forget to use forward slashes even in Windows)" if Dir.glob(test_pattern).empty?
+    Dir.glob(test_pattern).each {|test| require test} #In heckle, this is separated out
+    @finished = false
+    @results = []
+    @step_count = 0
+    obj_sp = Test::Unit::Collector::ObjectSpace.new
+    test_suite = Test::Unit::TestSuite.new("Mutation slayer test suite")
+    test_suite << obj_sp.collect
+    @test_runner_mediator =  Test::Unit::UI::TestRunnerMediator.new(test_suite)
+    @test_runner_mediator.add_listener(Test::Unit::TestResult::FAULT) {test_failed}
+    @test_runner_mediator.add_listener(Test::Unit::TestCase::FINISHED) {test_finished}
+
+  end
+
+  def run
+    catch(:stop_test_runner) do
+      @test_runner_mediator.run_suite
+    end
+  end
+
+  def test_failed
+    @results << :failure
+    @actor.notify_failing_step
+    sleep 0.5
+    throw :stop_test_runner
+  end
+
+  def test_finished
+    sleep 0.1 #Hack to avoid it being too quick
+    @results << :pass
+    @actor.notify_passing_step
+  end
+
+end

data/lib/world.rb

@@ -0,0 +1,93 @@
+require "human"
+require "interface"
+
+class World
+  attr_reader :representations, :interface
+
+  def self.new_using_results(human_results, zombies_results)
+    world = new(:no_interface)
+    human = MockHuman.new_using_results(human_results, world)
+    zombie_list = MockZombieList.new_using_results(zombies_results, world)
+    world.set_human(human)
+    world.set_zombie_list(zombie_list)
+    world
+  end
+
+  def self.new_using_test_unit_handler(test_pattern)
+    world = new(:gui_interface) #FIXME make this a choice between console and gui
+    human = Human.new_using_test_unit_handler(test_pattern, world)
+    zombie_list = MockZombieList.new_using_results([], world) #Fixme
+    world.set_human(human)
+    world.set_zombie_list(zombie_list)
+    world.set_test_pattern(test_pattern)
+    world
+  end
+
+  def initialize(interface_type)
+    @human = nil
+    @current_zombie = nil
+    @zombie_list = nil
+    @test_pattern = nil
+    @interface = case interface_type
+      when :console_interface then ConsoleInterface.new
+      when :no_interface then NoInterface.new
+      when :gui_interface then GuiInterface.new
+    end
+  end
+
+  def set_human(human)
+    raise "Already set" unless @human.nil?
+    @human = human
+    interface.human = human
+  end
+
+  def set_zombie_list(zombie_list)
+    raise "Already set" unless @zombie_list.nil?
+    @zombie_list = zombie_list
+  end
+
+  def set_test_pattern(test_pattern)
+    raise "Already set" unless @test_pattern.nil?
+    @test_pattern = test_pattern
+  end
+
+  #FIXME currently only used by the unit tests. It is equivalent to ZombieTestChaser.validate
+  def run
+    run_human
+    until (@human.dead? or @zombie_list.all_slain?)
+      run_zombie(@zombie_list.supply_next_zombie)
+    end
+    @interface.finish
+  end
+
+  def run_human
+    @human.run
+    @human.finish_dying if @human.dying?
+    ! @human.dead?
+  end
+
+  def create_zombie_using_test_unit_handler
+    raise "@test_pattern not defined?" if @test_pattern.nil?
+    zombie = Zombie.new_using_test_unit_handler(@test_pattern, self)
+  end
+
+  def run_zombie(zombie)
+    @current_zombie = zombie
+    @interface.current_zombie = zombie
+    sleep 0.2
+    @current_zombie.run
+    if @current_zombie.dying?
+      @current_zombie.finish_dying
+    else
+      @current_zombie.eat(@human)
+      sleep 1
+    end
+    ! @current_zombie.dead?
+  end
+
+  def something_happened
+    @interface.something_happened
+  end
+
+end
+

data/lib/zombie_test_chaser.rb

@@ -0,0 +1,133 @@
+#!/usr/bin/env ruby
+
+require "test/unit/collector/objectspace"
+require "test/unit/ui/testrunnermediator"
+require 'chaser'
+
+$: << 'lib' << 'test'
+
+# Make sure test/unit doesn't swallow our timeout
+begin
+  Test::Unit::TestCase::PASSTHROUGH_EXCEPTIONS << Chaser::Timeout
+rescue NameError
+  # ignore
+end
+
+class ZombieTestChaser < Chaser
+
+  VERSION = '0.0.1'
+
+  @@test_pattern = 'test/test_*.rb'
+  @@tests_loaded = false
+  @@world = nil
+
+  def self.test_pattern=(value)
+    @@test_pattern = value
+  end
+
+  def self.create_world
+    @@tests_loaded = true
+    @@world = World.new_using_test_unit_handler(@@test_pattern)
+  end
+
+  def self.world
+    @@world
+  end
+
+  def self.current_class_names(exclude_list)
+    result = []
+    ObjectSpace.each_object(Class) do |klass|
+      next if klass.to_s.include?("Class:0x")
+      next unless klass.ancestors.all? {|ancestor| (ancestor.to_s.split(/::/) & exclude_list).empty?}
+      result << klass.to_s
+    end
+    result
+  end
+
+  def self.validate(klass_name = nil, method_name = nil, force = false)
+    pre_existing_class_names = self.current_class_names([]) unless klass_name
+    create_world
+
+    if klass_name
+      klass = klass_name.to_class
+      # Does the method exist?
+      klass_methods = klass.singleton_methods(false).collect {|meth| "self.#{meth}"}
+      if method_name
+        if method_name =~ /self\./
+          abort "Unknown method: #{klass_name}.#{method_name.gsub('self.', '')}" unless klass_methods.include? method_name
+        else
+          abort "Unknown method: #{klass_name}##{method_name}" unless klass.instance_methods(false).map{|sym| sym.to_s}.include? method_name
+        end
+      end
+    end
+
+    initial_time = Time.now
+
+    chaser = self.new(klass_name)
+
+    passed = chaser.human_survives?
+
+    unless force or passed then
+      abort "Initial run of tests failed... fix and run chaser again"
+    end
+
+    if self.guess_timeout? then
+      running_time = Time.now - initial_time
+      adjusted_timeout = (running_time * 2 < 5) ? 5 : (running_time * 2).ceil
+      self.timeout = adjusted_timeout
+    end
+
+    puts "Timeout set to #{adjusted_timeout} seconds."
+
+    if passed then
+      puts "Initial tests pass. Let's rumble."
+    else
+      puts "Initial tests failed but you forced things. Let's rumble."
+    end
+    puts
+
+    counts = Hash.new(0)
+
+    klass_names = klass_name ? Array(klass_name) : self.current_class_names(["Test"]) - pre_existing_class_names
+    klass_names.each do |block_klass_name|
+      block_klass = block_klass_name.to_class
+
+      methods = method_name ? Array(method_name) : block_klass.instance_methods(false) + block_klass.singleton_methods(false).collect {|meth| "self.#{meth}"}
+
+      methods.sort.each do |block_method_name|
+        result = self.new(block_klass_name, block_method_name).validate
+        counts[result] += 1
+      end
+    end
+    all_good = counts[false] == 0
+
+    puts "Chaser Results:"
+    puts
+    puts "Passed    : %3d" % counts[true]
+    puts "Failed    : %3d" % counts[false]
+    puts
+
+    if all_good then
+      puts "All chasing was thwarted! YAY!!!"
+    else
+      puts "Improve the tests and try again."
+    end
+
+    all_good
+  end
+
+  def human_survives?
+    self.class.world.run_human
+  end
+
+  def zombie_survives?
+    zombie = self.class.world.create_zombie_using_test_unit_handler
+    self.class.world.run_zombie(zombie)
+  end
+
+  def initialize(klass_name=nil, method_name=nil)
+    super
+    self.class.create_world unless @@tests_loaded
+  end
+
+end

data/test/fixtures/chased.rb

@@ -0,0 +1,56 @@
+class Chased
+  def add(a,b)
+    a + b
+  end
+
+  def say_hello
+    "G'day!"
+  end
+
+  def self.static_method
+    "Zap!"
+  end
+
+  def block_using_instance_method
+    result = []
+    block_yielding_instance_method do |i|
+      result << i * 2
+    end
+    result
+  end
+
+  def block_yielding_instance_method
+    yield 1
+    yield 2
+    yield 3
+  end
+
+  def self.block_using_class_method
+    result = []
+    block_yielding_class_method do |i|
+      result << i * 2
+    end
+    result
+  end
+
+  def self.block_yielding_class_method
+    yield 1
+    yield 2
+  end
+
+  def [](x)
+    x * 2
+  end
+
+  def self.[](x)
+    x * 2
+  end
+
+  def question?
+    "exclamation!"
+  end
+
+  def foo=(x)
+    nil
+  end
+end

data/test/test_chaser.rb

@@ -0,0 +1,144 @@
+$:.unshift(File.dirname(__FILE__) + '/fixtures')
+$:.unshift(File.dirname(__FILE__) + '/../lib')
+
+require 'test/unit/testcase'
+require 'test/unit' if $0 == __FILE__
+require 'zombie_test_chaser'
+require 'chased'
+
+class TestChaser < Chaser
+  def rand(*args)
+    5
+  end
+
+  def rand_string
+    "l33t h4x0r"
+  end
+
+  def rand_number(*args)
+    5
+  end
+
+  def rand_symbol
+    :"l33t h4x0r"
+  end
+end
+
+class ChaserTestCase < Test::Unit::TestCase
+  unless defined? Mini then
+    undef_method :default_test
+    alias :refute_equal :assert_not_equal
+  end
+
+  def setup
+  end
+
+  def teardown
+    @chaser.unmodify_method if defined?(@chaser) && @chaser
+  end
+
+  def test_unmodified_behaves_as_expected
+    chased = Chased.new
+    assert_equal 5, chased.add(2,3), "Unmodified version should equal 5"
+  end
+
+  def test_modify_and_unmodify_instance_method
+    @chaser = TestChaser.new("Chased", "add")
+    chased = Chased.new
+    assert_equal 5, chased.add(2,3), "method has been modified before it should have been"
+    @chaser.modify_method
+    assert_equal 10, chased.add(2,3), "method hasn't been modified"
+    @chaser.unmodify_method
+    assert_equal 5, chased.add(2,3), "method should be back to normal, but it isn't"
+  end
+
+  def test_modify_and_unmodify_string
+    @chaser = TestChaser.new("Chased", "say_hello")
+    chased = Chased.new
+    assert_equal "G'day!", chased.say_hello, "method has been modified before it should have been"
+    @chaser.modify_method
+    assert_equal "l33t h4x0r", chased.say_hello, "method hasn't been modified"
+    @chaser.unmodify_method
+    assert_equal "G'day!", chased.say_hello, "method should be back to normal, but it isn't"
+  end
+
+  def test_modify_and_unmodify_class_method
+    @chaser = TestChaser.new("Chased", "self.static_method")
+    assert_equal "Zap!", Chased.static_method, "class method has been modified before it should have been"
+    @chaser.modify_method
+    assert_equal "l33t h4x0r", Chased.static_method, "class method hasn't been modified"
+    @chaser.unmodify_method
+    assert_equal "Zap!", Chased.static_method, "class method should be back to normal, but it isn't"
+  end
+
+  def test_pass_blocks_on_in_instance_methods
+    @chaser = TestChaser.new("Chased", "block_yielding_instance_method")
+    chased = Chased.new
+    assert_equal [2,4,6], chased.block_using_instance_method, "block yielding instance method has been modified before it should have been"
+    @chaser.modify_method
+    assert_equal [12, 14, 16], chased.block_using_instance_method, "yielded values haven't been modified"
+    @chaser.unmodify_method
+    assert_equal [2,4,6], chased.block_using_instance_method, "block yielding instance method has been modified before it should have been"
+  end
+
+  def test_pass_blocks_on_in_class_methods
+    @chaser = TestChaser.new("Chased", "self.block_yielding_class_method")
+    assert_equal [2,4], Chased.block_using_class_method, "block yielding class method has been modified before it should have been"
+    @chaser.modify_method
+    assert_equal [12, 14], Chased.block_using_class_method, "yielded values haven't been modified"
+    @chaser.unmodify_method
+    assert_equal [2,4], Chased.block_using_class_method, "block yielding class method has been modified before it should have been"
+  end
+
+  def test_handle_funny_characters_in_instance_method_names
+    @chaser = TestChaser.new("Chased", "[]")
+    chased = Chased.new
+    assert_equal 2, chased[1], "Original doesn't work"
+    @chaser.modify_method
+    assert_equal 7, chased[1], "Modified doesn't work"
+    @chaser.unmodify_method
+    assert_equal 2, chased[1], "Modified then unmodified doesn't work"
+  end
+
+  def test_handle_funny_characters_in_class_method_names
+    @chaser = TestChaser.new("Chased", "self.[]")
+    assert_equal 2, Chased[1], "Original doesn't work"
+    @chaser.modify_method
+    assert_equal 7, Chased[1], "Modified doesn't work"
+    @chaser.unmodify_method
+    assert_equal 2, Chased[1], "Modified then unmodified doesn't work"
+  end
+
+  def test_more_funny_characters
+    assert_nothing_raised("Can't handle certain characters") do
+      @chaser = TestChaser.new("Chased", "question?")
+      chased = Chased.new
+      chased.question?
+      @chaser.modify_method
+      chased.question?
+      @chaser.unmodify_method
+      chased.question?
+    end
+
+    assert_nothing_raised("Can't handle equal signs") do
+      @chaser = TestChaser.new("Chased", "foo=")
+      chased = Chased.new
+      chased.foo= 1
+      @chaser.modify_method
+      chased.foo = 2
+      @chaser.unmodify_method
+      chased.foo = 3
+    end
+  end
+end
+
+
+class ZombieTestChaserCase < Test::Unit::TestCase
+  def test_detects_invalid_glob
+    incorrect_glob = 'test\test_chaser.rb'
+    ZombieTestChaser.test_pattern = incorrect_glob
+    assert_raise(RuntimeError, "Can't detect an incorrect glob") do
+      ZombieTestChaser.create_world
+    end
+  end
+end

data/test/test_unit.rb

@@ -0,0 +1,2 @@
+require "test/test_chaser.rb"
+require "test/test_zombie.rb"

data/test/test_zombie.rb

@@ -0,0 +1,95 @@
+$: << "lib"
+
+require "test/unit"
+require "world"
+
+module TestHumanHelper
+  def assert_that_representations_include(expected_representation, human_results, failure_message)
+    world = create_world(human_results)
+    interface = world.interface
+    assert interface.representations.include?(expected_representation), failure_message + "Expected #{expected_representation}, got #{world.representations.inspect}"
+  end
+
+  def assert_that_representations_include_these_representations(expected_representations, human_results, zombies_results, failure_message)
+    world = create_world(human_results, zombies_results)
+    interface = world.interface
+    expected_representations.each do |expected_representation|
+      assert interface.representations.include?(expected_representation), failure_message + ": Expected #{expected_representation}, got #{world.representations.inspect}"
+    end
+  end
+
+  def create_world(human_results, zombies_results = [])
+    world = World.new_using_results(human_results, zombies_results)
+    world.run
+    world
+  end
+end
+
+class TestHuman < Test::Unit::TestCase
+  include TestHumanHelper
+
+  def test_human_single_success
+    human_results = [:pass]
+    failure_message = "Can't handle single success"
+    assert_that_representations_include(".@", human_results, failure_message)
+  end
+
+  def test_human_single_failure
+    human_results = [:failure]
+    failure_message = "Can't handle single failure"
+    assert_that_representations_include("+", human_results, failure_message)
+  end
+
+  def test_human_two_successes
+    human_results = [:pass, :pass]
+    expected_representations = ["@", ".@", "..@"]
+    failure_message = "Needs to be able to do multiple steps"
+    #This'll run the simulation three times. Optimize if neccessary (it isn't yet)
+    expected_representations.each do |expected_representation|
+      assert_that_representations_include(expected_representation, human_results, failure_message)
+    end
+  end
+
+  def test_human_success_failure
+    human_results = [:pass, :failure]
+    expected_representation = ".+"
+    failure_message = "Can't handle success and failure"
+    assert_that_representations_include(expected_representation, human_results, failure_message)
+  end
+
+  def test_human_success_failure_success
+    human_results = [:pass, :failure, :pass]
+    expected_representation = ".+"
+    failure_message = "Can't handle success and failure"
+    assert_that_representations_include(expected_representation, human_results, failure_message)
+  end
+
+  def test_human_exploding
+    human_results = [:pass, :failure]
+    expected_representation = ".*"
+    failure_message = "Doesn't represent the human exploding"
+    assert_that_representations_include(expected_representation, human_results, failure_message)
+  end
+
+end
+
+class TestZombie < Test::Unit::TestCase
+  include TestHumanHelper
+
+  def test_human_surviving_zombie_slaying
+    human_results = [:pass, :pass]
+    zombies_results = [[:failure]]
+    expected_representations = ["..@", "*.@"]
+    failure_message = "Can't represent a zombie slaying."
+    assert_that_representations_include_these_representations(expected_representations, human_results, zombies_results, failure_message)
+  end
+
+  def test_human_surviving_zombie_slaying2
+    human_results = [:pass, :pass, :pass]
+    zombies_results = [[:pass, :failure]]
+    expected_representations = ["...@", "Z..@", ".*.@"]
+    failure_message = "Can't represent a zombie slaying."
+    assert_that_representations_include_these_representations(expected_representations, human_results, zombies_results, failure_message)
+  end
+
+end