gossip 0.3.0

data/test/script/fanout-slowtests.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-09-25.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'test/unit'
+require 's4t-utils'
+S4tUtils.set_test_paths(__FILE__)
+
+require 'test/script/util'
+
+unless S4tUtils.on_windows?
+  class TestFanoutCommandExecution < Test::Unit::TestCase
+    def test_scandal_and_details
+      as_script_test('.fanout.yml') do
+        result = `echo "some details" | ruby fanout --details arg "another arg"`
+        lines = result.split("\n")
+        assert_match(/arg another arg/, lines.first)
+        assert_match(/some details/, lines.last)
+      end
+    end
+    
+    def test_scandal_alone
+      as_script_test('.fanout.yml') do
+        result = `ruby fanout --no-det arg "another arg"`
+        lines = result.split("\n")
+        assert_equal(1, lines.length)
+        assert_match(/arg another arg/, lines.first)
+      end
+    end
+
+    def test_details_are_default
+      as_script_test('.fanout.yml') do
+        results = `echo sloop | ruby fanout arg "another arg"`
+        assert_match(/sloop/, results)
+      end
+    end
+
+  end
+end

data/test/script/svntell-slowtests.rb

@@ -0,0 +1,40 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-09-27.
+#  Copyright (c) 2007. All rights reserved.
+
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-09-25.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'test/unit'
+require 's4t-utils'
+S4tUtils.set_test_paths(__FILE__)
+
+require 'test/script/util'
+
+unless S4tUtils.on_windows?
+  class TestFanoutCommandExecution < Test::Unit::TestCase
+    def test_revision_is_required
+      as_script_test('.svntell.yml') do
+        result = `ruby svntell --repository /svn 2>&1`
+        assert_match(/must choose a revision/, result)
+      end
+    end
+
+    def test_repository_is_required
+      as_script_test('.svntell.yml') do
+        result = `ruby svntell --revision 5 foo 2>&1`
+        assert_match(/must choose a repository/, result)
+      end
+    end
+
+    def test_svnlook_must_exist
+      as_script_test('.svntell.yml') do
+        result = `ruby svntell --svnlook /foo/bar --repository /svn --revision 5 foo 2>&1`
+        assert_match(%r{svnlook path '/foo/bar' does not exist.}, result)
+      end
+    end
+  end
+end

data/test/script/util.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-09-25.
+#  Copyright (c) 2007. All rights reserved.
+
+
+class Test::Unit::TestCase
+  include S4tUtils
+  
+  def as_script_test(config_name)
+    yaml = %q{
+      standard-output: true
+    }
+
+    Dir.chdir(PACKAGE_ROOT + "/scripts") do
+      with_local_config_file(config_name, yaml) do
+        yield
+      end
+    end
+  end
+  
+end

data/test/script/watchdog-slowtests.rb

@@ -0,0 +1,56 @@
+require 'test/unit'
+require 's4t-utils'
+include S4tUtils
+set_test_paths(__FILE__)
+
+require 'test/script/util'
+load "#{PACKAGE_ROOT}/scripts/watchdog"
+
+class TestWatchdogCommand < Test::Unit::TestCase
+  include Gossip
+
+  class RandomWatchdogCommand < Watchdog
+    # Erase behaviors of no interest
+    def initialize; end
+  end
+    
+
+  def test_command_name_ignores_ruby
+    dog = RandomWatchdogCommand.new
+    assert_equal('echo', dog.command_name(['echo', 'foo']))
+    assert_equal('echo.rb', dog.command_name(['ruby', 'echo.rb', 'foo']))
+  end
+
+  def test_command_name_is_just_basename
+    dog = RandomWatchdogCommand.new
+    assert_equal('echo.rb', dog.command_name(['ruby', '/usr/bin/echo.rb', 'foo']))
+  end
+
+  def test_timer
+    duration, result = RandomWatchdogCommand.new.time {
+      sleep 2
+      5
+    }
+    # Rough check because time is inaccurate.
+    assert_true(duration >= 1.5)
+    assert_equal(5, result)
+  end
+
+
+end
+
+unless S4tUtils.on_windows?
+  class TestWatchdogCommandExecution < Test::Unit::TestCase
+    def test_command_line_only
+      as_script_test('.watchdog.yml') do
+        actual_string = `ruby watchdog ruby ../test/util/silly-little-test-program.rb 1 2`
+        assert_match(/Program silly-little-test-program.rb finished/, actual_string)
+        assert_match(/Duration: /, actual_string)
+        assert_match(%r{Command: ruby ../test/util/silly-little-test-program.rb 1 2}, actual_string)
+
+        assert_match(/I mostly write to standard output./, actual_string)
+        assert_match(/I also write to standard error./, actual_string)
+      end
+    end
+  end
+end

data/test/unit/command-crony-interaction-tests.rb

@@ -0,0 +1,116 @@
+#!/usr/bin/env ruby
+#
+#  Created by Brian Marick on 2007-09-17.
+#  Copyright (c) 2007. All rights reserved.
+
+require 'test/unit'
+require 's4t-utils'
+include S4tUtils
+set_test_paths(__FILE__)
+
+
+require 'gossip'
+
+class ChoicesTests < Test::Unit::TestCase
+  include Gossip
+  
+  def test_that_crony_presence_sets_switch
+    # Note that the cronymaker key and Crony name must be the same. 
+    # That duplication is an artifact of trying to make the declarations
+    # in the scripts (like watchdog.rb) look nice.
+    crony_maker = { :winner => proc {@winner = Exhibitionist.named(:winner)},
+                    :loser => proc {@loser = Exhibitionist.named(:loser)} }
+                    
+    sophie = Preteen.new(crony_maker, [:winner], [:loser])
+    cmd = SomeRandomCommand.new(sophie)
+    
+    # Switch is initialized, with default value
+    assert_equal(true, cmd.user_choices[:winner])
+    assert_equal(false, cmd.user_choices[:loser])
+    
+    # Shorthand for the default value
+    assert_true(@winner.is_bff_by_default?)
+    assert_false(@loser.is_bff_by_default?)
+
+    # Cronies share user choices with command.
+    assert_equal(@winner.user_choices, cmd.user_choices)
+    assert_equal(@loser.user_choices, cmd.user_choices)
+  end
+
+  def test_how_command_initializes_a_crony
+    crony_maker = { :bff => proc {Exhibitionist.named(:bff)}}
+    sophie = Preteen.new(crony_maker, [:bff], [])
+    SomeRandomCommand.new(sophie).execute
+    assert_equal(['command_line_description()', # This is the crony's only part in determining whether it's called by default
+                  'add_configuration_choices()',
+                  # Command line and config files are read here
+                  'user_choices=()',   # Give crony access to user choices
+                  'postprocess_user_choices()',
+                  # Can now execute.
+                  'hear("boyfriend!", "Joshua")'
+                  ], sophie.cronies[0].logged)
+  end
+  
+  
+  class Exhibitionist < Crony
+    attr_reader :logged, :user_choices, :symbol
+    
+    def name; symbol.to_s; end
+    
+    def self.named(sym); new(sym); end
+    def initialize(sym)
+      @symbol = sym
+      @logged = []
+      super
+    end
+    
+    def user_choices=(value)
+      log("user_choices=")
+      @user_choices = value
+    end
+
+    def command_line_description()
+      log("command_line_description")
+      ['-e', "--exhibitionist", "Defaults to #{is_bff_by_default?}."]
+    end
+    
+    def add_configuration_choices(builder)
+      log("add_configuration_choices"); 
+    end
+    def postprocess_user_choices; 
+      log("postprocess_user_choices") 
+    end
+    
+    def hear(*args)
+      log('hear', *args)
+    end
+
+    private 
+    
+    def log(message, *args); @logged << how_called(message, *args); end
+    
+    def how_called(message, *args)
+      args = args.collect { |a| a.inspect }
+      "#{message}(" + args.join(", ") + ")"
+    end
+    
+  end
+  
+
+  class SomeRandomCommand < Gossip::GossipCommand    
+    
+    attr_reader :user_choices
+    
+    def add_sources(builder)
+      # There must be at least a command line.
+      builder.add_source(CommandLineSource, :usage,
+            "Usage: ruby #{$0} [options] program args...")
+    end
+
+    def execute
+      preteen.tell_bffs("boyfriend!", "Joshua")
+    end
+  end
+  
+  
+end

data/test/unit/command-tests.rb

@@ -0,0 +1,119 @@
+require 'test/unit'
+require 's4t-utils'
+include S4tUtils
+set_test_paths(__FILE__)
+
+require 'gossip'
+
+class CommandTests < Test::Unit::TestCase
+  include Gossip
+
+  class SomeRandomCommand < GossipCommand    
+    def script_config_file; ".localrc"; end
+    def gossip_config_file; ".globalrc"; end
+    
+    def usage; "Usage: ruby #{$0} [options] program args..."; end
+    def add_sources(builder)
+      builder.add_source(PosixCommandLineSource, :usage, *describe_all_but_options)
+      builder.add_source(YamlConfigFileSource, :from_file, ".sophie.yml")  
+      builder.add_source(XmlConfigFileSource, :from_file, ".sophie.xml")  
+    end
+
+    def execute
+      preteen.tell_bffs("boyfriend!", "Joshua")
+      preteen.cronies.collect { |crony| crony.value }
+    end
+  end
+  
+  def setup
+    crony_maker = {
+      :bff => proc {
+        require PACKAGE_ROOT + '/test/util/bff'
+        OneTestCrony.new(:default_format_string => "scandal: %s, details: %s")
+      },
+      :doghouse => proc {
+        require PACKAGE_ROOT + '/test/util/doghouse'
+        AnotherTestCrony.new(:default_format_string => "%s: %s")
+      }
+    }
+    
+    @sophie = Preteen.new(crony_maker, [:bff], [:doghouse])
+  end
+  
+  def test_behavior_when_not_overridden_is_as_set
+    SomeRandomCommand.new(@sophie).execute
+    result = @sophie.cronies.collect { |crony|  crony.value }
+    assert_equal(["scandal: boyfriend!, details: Joshua", "doghouse crony was not told!"], 
+                  result)
+  end
+
+
+  def test_that_config_files_can_change_who_gets_told
+    flip = %Q{
+        <sophie>
+          <bff>false</bff>
+          <doghouse>true</doghouse>
+        </sophie>
+    }
+    with_local_config_file('.sophie.xml', flip) {
+      SomeRandomCommand.new(@sophie).execute
+      result = @sophie.cronies.collect { |crony| crony.value }
+      assert_equal(["bff was not told!", "boyfriend!: Joshua"], 
+                  result)
+    }
+  end
+
+
+
+  def test_that_both_switches_and_options_can_be_overridden
+    reconcile = %Q{
+      doghouse: true
+    }
+    
+    with_command_args('--bff-format=%s/%s --doghouse-form %s+%s') {
+      with_local_config_file('.sophie.yml', reconcile) {
+        SomeRandomCommand.new(@sophie).execute
+        result = @sophie.cronies.collect { |crony|  crony.value }
+        assert_equal(["boyfriend!/Joshua", "boyfriend!+Joshua"], 
+                      result)
+      }
+    }
+  end
+  
+  def test_typical_usage_lines
+    with_command_args('--help') do
+      output = capturing_stderr do
+        assert_wants_to_exit do
+          SomeRandomCommand.new(@sophie)
+        end
+      end
+      lines = output.split("\n")
+      assert_equal("Usage: ruby #{$0} [options] program args...", lines[0])
+      assert_match(/Site-wide defaults/, lines[1])
+      assert_match(/Override them in the '.localrc' or '.globalrc' files in your home folder./, lines[2])
+    end
+  end
+  
+  class LongerUsageCommand < SomeRandomCommand
+    def usage; ['line 1', 'line 2']; end
+  end
+    
+  def test_that_usage_lines_can_be_an_array
+    with_command_args('--help') do
+      output = capturing_stderr do
+        assert_wants_to_exit do
+          LongerUsageCommand.new(@sophie).execute
+        end
+      end
+      lines = output.split("\n")
+      assert_equal("line 1", lines[0])
+      assert_equal("line 2", lines[1])
+      assert_match(/Site-wide defaults/, lines[2])
+    end
+      
+  end
+  
+  
+  
+  
+end

data/test/unit/crony-tests.rb

@@ -0,0 +1,46 @@
+require 'test/unit'
+require 's4t-utils'
+include S4tUtils
+set_test_paths(__FILE__)
+
+require 'gossip'
+
+# Most of the crony behavior is interaction with Command, so see 
+# command-tests.rb
+
+class ChoicesTests < Test::Unit::TestCase
+  include Gossip
+
+  class ConcreteCrony < Crony
+    def name; 'non-abstract'; end
+    def symbol; :sym; end
+  end
+
+  def test_crony_checks_for_typos
+    crony = ConcreteCrony.new(:key => 'value')
+    
+    assert_equal('value', crony.checked(:key))
+    assert_raises_with_matching_message(StandardError, /:ky is nil.*#{crony.name}.*typo/) do 
+      crony.checked(:ky)
+    end
+  end
+  
+  
+  def test_crony_can_describe_defaults
+    crony = ConcreteCrony.new(:key => 'value')
+    assert_equal('Defaults to "value".', crony.df(:key))
+
+    assert_raises_with_matching_message(StandardError, /:ky is nil.*#{crony.name}.*typo/) do 
+      crony.checked(:ky)
+    end
+  end
+  
+  def test_crony_friendship_depends_on_user_choices
+    crony = ConcreteCrony.new
+    crony.user_choices=({:sym => true})
+    assert_true(crony.is_bff?)
+    crony.user_choices=({:sym => false})
+    assert_false(crony.is_bff?)
+  end
+  
+end

data/test/unit/multi-exception-tests.rb

@@ -0,0 +1,70 @@
+require 'test/unit'
+require 's4t-utils'
+include S4tUtils
+set_test_paths(__FILE__)
+
+require 'gossip/multi-exceptions'
+
+class QueueExtensionTests < Test::Unit::TestCase
+  def test_to_a
+    queue = Queue.new
+    queue << 1
+    assert_equal([1], queue.to_a)
+  end
+end
+
+class MultiExceptionTests < Test::Unit::TestCase
+  include Gossip
+
+  def two_exceptions
+    retval = []
+    [IndexError.new("index error"),
+      RuntimeError.new("runtime error")].each do | ex | 
+      begin
+        raise ex  # You have to raise to get a backtrace.
+      rescue Exception => caught
+        retval << caught
+      end
+    end
+    retval
+  end
+
+  def setup
+    @ex = MultiException.new(two_exceptions)
+  end
+
+
+  def test_multi_exception_aggregates_messages
+    messages = @ex.message.split("\n")
+    assert_match(/index error/, messages[0])
+    assert_match(/runtime error/, messages[1])
+  end
+
+  def test_multi_exception_includes_exception_classes_in_messages
+    messages = @ex.message.split("\n")
+    assert_match(/IndexError/, messages[0])
+    assert_match(/RuntimeError/, messages[1])
+  end
+
+  def test_multi_exception_aggregates_backtraces_in_traces_field
+    assert_equal(2, @ex.traces.length)
+    assert_equal(1, @ex.traces[0].grep(/setup/).length)
+    assert_equal(1, @ex.traces[1].grep(/setup/).length)
+  end
+
+  def test_combined_trace
+    begin
+      MultiException.reraise_with_combined_backtrace do
+        raise @ex
+      end
+    rescue MultiException => ex
+      assert_equal(1, ex.backtrace.grep(/Trace number 0:/).length)
+      assert_equal(1, ex.backtrace.grep(/Trace number 1:/).length)
+      # The raise in this method is wiped out.
+      assert_equal(0, ex.backtrace.grep(/test_combined_trace/).length)
+      # The raises in setup are preserved.
+      assert_equal(2, ex.backtrace.grep(/setup/).length)
+    end
+  end
+
+end