scout_agent 3.0.0

data/test/tc_core_extensions.rb

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby -wKU
+
+require "test/unit"
+
+require "scout_agent/core_extensions"
+
+class TestCoreExtensions < Test::Unit::TestCase
+  def test_to_word_list
+    { %w[]                   => "",
+      %w[one]                => "one",
+      %w[one two]            => "one and two",
+      %w[one two three]      => "one, two, and three",
+      %w[one two three four] => "one, two, three, and four" }.each do |arr, str|
+      assert_equal(str, arr.to_word_list)
+    end
+  end
+
+  def test_to_word_list_with_custom_conjunction
+    assert_equal("one, two, or three", %w[one two three].to_word_list("or"))
+  end
+  
+  def test_string_camel_case
+    { "class_name"           => "ClassName",
+      "symbols::are/removed" => "SymbolsAreRemoved",
+      "spaces are removed"   => "SpacesAreRemoved",
+      "agent_99_smart"       => "Agent99Smart",
+      "NoChange"             => "NoChange" }.each do |snake_case, camel_case|
+      assert_equal(camel_case, snake_case.CamelCase)
+    end
+  end
+  
+  def test_string_camel_case_alias
+    str = "test_string"
+    assert_equal(str.CamelCase, str.camel_case)
+  end
+  
+  def test_string_snake_case
+    { "ClassName"            => "class_name",
+      "Symbols::Are/Unified" => "symbols_are_unified",
+      "Spaces Are Converted" => "spaces_are_converted",
+      "Agent99Smart"         => "agent_99_smart",
+      "no_change"            => "no_change" }.each do |camel_case, snake_case|
+      assert_equal(snake_case, camel_case.snake_case)
+    end
+  end
+  
+  def test_string_trim_with_default
+    heredoc = <<-END_DEFAULT.trim
+    I am indented on purpose.
+    Leading space should be removed.
+    
+      but not these two spaces
+    END_DEFAULT
+    assert_match(/^I/,       heredoc)
+    assert_match(/^Leading/, heredoc)
+    assert_match(/^  but/,   heredoc)
+  end
+  
+  def test_string_trim_with_width
+    heredoc = <<-END_WIDTH.trim(2)
+    I'm indented four,
+    but we will just trim two.
+    END_WIDTH
+    assert_match(/^  I'm/, heredoc)
+    assert_match(/^  but/, heredoc)
+  end
+  
+  def test_to_question
+    assert_match(/\?  \z/, "A simple question?\n\t    ".to_question)
+  end
+  
+  def test_word_wrap_with_default
+    assert_no_match(/^.{61}/, ("A short and simple string." * 1000).word_wrap)
+  end
+  
+  def test_word_wrap_with_width
+    assert_no_match( /^.{11}/,
+                     ("A short and simple string." * 1000).word_wrap(10) )
+  end
+  
+  def test_word_wrap_skips_unbroken_content
+    assert_equal("0123456789", "0123456789".word_wrap(4))
+  end
+  
+  def test_word_wrap_strips_and_simplifes_space
+    assert_equal( "one two\nthree",
+                  " \t\none\n  \ttwo    three\n\n  \t".word_wrap(10) )
+  end
+end

data/test/tc_id_card.rb

@@ -0,0 +1,115 @@
+#!/usr/bin/env ruby -wKU
+
+require "test_helper"
+
+require "scout_agent"
+
+class TestIDCard < Test::Unit::TestCase
+  def setup
+    plan.prefix_path = test_prefix
+    plan.build_pid_dir(Process.egid)
+  end
+  
+  def teardown
+    id_card(:test).revoke
+    test_prefix.rmtree if test_prefix.exist?
+    plan.reset_defaults
+  end
+  
+  def test_authorize_creates_pid_file
+    @card = id_card(:test)
+    assert(!@card.pid_file.exist?,   "PID file already existed")
+    assert(@card.authorize,          "Failed to authorize our PID")
+    assert(@card.pid_file.exist?,    "PID wasn't created")
+    assert_equal("#{Process.pid}\n", @card.pid_file.read)
+  end
+  
+  def test_authorize_fails_for_an_existing_pid
+    test_authorize_creates_pid_file  # make sure we already have a file
+    assert(!@card.authorize, "Authorized with an existing PID file")
+  end
+  
+  def test_authorize_will_clear_a_stale_pid_file
+    create_and_kill_another_process
+    card = id_card(:test)
+    assert_not_equal(Process.pid,    card.pid_file.read)
+    assert(card.authorize,           "Failed to replace stale PID file")
+    assert_equal("#{Process.pid}\n", card.pid_file.read)
+  end
+  
+  def test_successful_authorize_updates_me
+    ScoutAgent::IDCard.me = nil
+    test_authorize_creates_pid_file
+    assert_equal(@card, ScoutAgent::IDCard.me)
+  end
+  
+  def test_revoke_clears_a_pid_file
+    test_authorize_creates_pid_file  # create a file
+    assert(@card.revoke, "Failed to clear file")
+  end
+  
+  def test_revoke_return_true_if_cleared_false_otherwise
+    test_authorize_creates_pid_file  # create a file
+    assert(@card.revoke, "Failed to clear file")
+    assert(!@card.revoke, "Clear a PID file that was already cleared")
+  end
+  
+  def test_pid_file_is_named_file
+    card = id_card(:my_name)
+    assert_match(/my_name\.pid\z/, card.pid_file.to_s)
+  end
+  
+  def test_pid_is_a_shorcut_for_reading_pid_file
+    test_authorize_creates_pid_file  # create a file
+    assert_equal(@card.pid_file.read.to_i, @card.pid)
+  end
+  
+  def test_pid_returns_nil_for_a_missing_pid_file
+    assert_nil(id_card(:does_not_exist).pid)
+  end
+  
+  def test_signal_delivers_messages
+    received_message = false
+    trap("USR1") { received_message = true }
+    test_authorize_creates_pid_file
+    
+    # have another process send us a signal
+    other_pid = fork { @card.signal("USR1") }
+    Process.wait(other_pid)
+    
+    assert(received_message, "Didn't receive signal")
+  end
+  
+  def test_signal_returns_false_for_missing_pid_files
+    assert(!id_card(:does_not_exist).signal(0), "Signal was sent without a PID")
+  end
+  
+  def test_signal_errors_bubble_up_to_caller
+    create_and_kill_another_process
+    card = id_card(:test)
+    assert_raise(Errno::ESRCH) { card.signal("KILL") }
+  end
+  
+  def test_to_s_includes_process_name_and_pid
+    test_authorize_creates_pid_file  # make an identity
+    assert_equal("test (#{Process.pid})", @card.to_s)
+  end
+  
+  def test_to_s_uses_unauthorized_for_a_missing_pid
+    assert_equal("missing (unauthorized)", id_card(:missing).to_s)
+  end
+  
+  private
+  
+  def id_card(*args)
+    ScoutAgent::IDCard.new(*args)
+  end
+  
+  def create_and_kill_another_process
+    other_pid = fork do
+      test_authorize_creates_pid_file  # make sure we claim the PID file
+      exit!                            # and exist without clearing it
+    end
+    Process.wait(other_pid)
+  end
+end

data/test/tc_plan.rb

@@ -0,0 +1,285 @@
+#!/usr/bin/env ruby -wKU
+
+require "test_helper"
+require "tempfile"
+
+require "scout_agent"
+
+class TestPlan < Test::Unit::TestCase
+  def teardown
+    test_prefix.rmtree if test_prefix.exist?
+  end
+  
+  ############
+  ### Type ###
+  ############
+  
+  def test_plan_is_a_customized_ostruct
+    assert_instance_of(OpenStruct, plan)
+  end
+  
+  ########################
+  ### Loading a Config ###
+  ########################
+  
+  def test_updating_plan_from_a_config_file
+    c = load_config_file(<<-END_SETTINGS)
+    config.string_setting  = "just a String"
+    config.integer_setting = 42
+    END_SETTINGS
+    assert_equal(plan,            c)
+    assert_equal("just a String", c.string_setting)
+    assert_equal(42,              c.integer_setting)
+  end
+  
+  def test_exceptions_bubble_up_to_the_caller_from_config_file
+    assert_raise(RuntimeError) do
+      load_config_file('raise "Oops!"')
+    end
+  end
+  
+  def test_updating_plan_from_switches
+    assert_nil(plan.switch_one)
+    assert_nil(plan.switch_two)
+    plan.update_from_switches(:switch_one => "One", :switch_two => "Two")
+    assert_equal("One", plan.switch_one)
+    assert_equal("Two", plan.switch_two)
+  end
+  
+  ################
+  ### Defaults ###
+  ################
+  
+  def test_defaults_are_available_in_an_enumerable_list
+    assert_kind_of(Enumerable, plan.defaults)
+  end
+  
+  # def test_agent_name_is_set
+  #   assert_match(/\A\w+\z/, plan.agent_name)
+  #   assert_equal( plan.agent_name.split("_"),
+  #                 plan.proper_agent_name.downcase.split(" ") )
+  # end
+  # 
+  # def test_agent_namespace_returns_module_based_on_agent_name
+  #   assert_equal(ScoutAgent, plan.agent_namespace)
+  # end
+  
+  def test_all_paths_return_pathname_objects
+    %w[ prefix_path
+        os_config_path
+        os_db_path
+        os_pid_path
+        os_log_path
+        config_file
+        db_dir
+        pid_dir
+        log_dir ].each do |path|
+      assert_instance_of(Pathname, plan(path))
+    end
+  end
+  
+  def test_prefix_path_defaults_to_the_root_path
+    assert_equal(Pathname.new("/"), plan.prefix_path)
+  end
+  
+  def test_default_os_paths_are_set
+    %w[ os_config_path
+        os_db_path
+        os_pid_path
+        os_log_path ].each do |path|
+      assert_path_match(%r{\A(?:/\w+)+/?\z}, path)
+    end
+  end
+  
+  def test_default_paths_are_set
+    assert_path_match(%r{\A(?:/\w+)+\.\w+\z}, :config_file)
+    %w[db_dir pid_dir log_dir].each do |dir|
+      assert_path_match(%r{\A(?:/\w+)+/?\z}, dir)
+    end
+  end
+  
+  def test_server_url_is_set
+    assert_match(%r{\Ahttps://}, plan.server_url)
+  end
+  
+  def test_run_as_daemon_is_set
+    assert(plan.run_as_daemon, "Daemon mode should default to on")
+  end
+  
+  def test_run_as_daemon_alias
+    assert_equal(plan.run_as_daemon, plan.run_as_daemon?)
+  end
+  
+  def test_user_choices_is_set
+    assert_equal(%w[daemon nobody], plan.user_choices)
+  end
+  
+  def test_group_choices_is_set
+    assert_equal(%w[daemon nogroup], plan.group_choices)
+  end
+  
+  def test_reset_defaults
+    current = plan.defaults.map { |name, _| [name, plan(name)] }
+    plan.defaults.each { |name, _| plan("#{name}=", "Junk!") }
+    current.each { |name, value| assert_not_equal(value, plan(name)) }
+    
+    plan.reset_defaults
+    current.each { |name, value| assert_equal(value, plan(name)) }
+  end
+  
+  ####################
+  ### Nested Paths ###
+  ####################
+  
+  def test_prefix_path_prepends_to_all_paths
+    %w[ os_config_path
+        os_db_path
+        os_pid_path
+        os_log_path
+        config_file
+        db_dir
+        pid_dir
+        log_dir ].each do |path|
+      configure(:prefix_path => test_prefix) do
+        assert_path_match(%r{\A#{test_prefix}/.+\z}, path)
+      end
+    end
+  end
+  
+  def test_os_paths_prepends_to_full_paths
+    { :config_file => :os_config_path,
+      :db_dir      => :os_db_path,
+      :pid_dir     => :os_pid_path,
+      :log_dir     => :os_log_path }.each do |path, parent|
+      assert_prepends_path(path, parent)
+    end
+  end
+  
+  def test_prefix_path_nests_with_os_paths
+    dir = "test_dir"
+    { :config_file => :os_config_path,
+      :db_dir      => :os_db_path,
+      :pid_dir     => :os_pid_path,
+      :log_dir     => :os_log_path }.each do |path, parent|
+      configure(:prefix_path => test_prefix, parent => dir) do
+        assert_path_match(%r{\A#{test_prefix}/#{dir}/.+\z}, path)
+      end
+    end
+  end
+  
+  ################
+  ### Creation ###
+  ################
+  
+  def test_write_default_config_file_creates_a_readable_ruby_configuration_file
+    configure(:prefix_path => test_prefix) do
+      assert(!File.exist?(plan.config_file), "Configuration already existed")
+      assert(plan.write_default_config_file, "Could not create config file")
+      assert(File.exist?(plan.config_file), "Configuration not created")
+      assert_equal("755", plan.config_file.stat.mode.to_s(8)[-3..-1])
+    end
+  end
+  
+  def test_write_default_config_file_wont_replace_an_existing_file
+    configure(:prefix_path => test_prefix) do
+      assert(plan.write_default_config_file, "Could not create config file")
+      assert(!plan.write_default_config_file, "Replaced config file")
+    end
+  end
+  
+  def test_builders_fails_if_they_dont_have_permission
+    configure(:prefix_path => test_prefix) do
+      { :write_default_config_file => :os_config_path,
+        :build_db_dir              => :os_db_path,
+        :build_pid_dir             => :os_pid_path,
+        :build_log_dir             => :os_log_path }.each do |builder, dir|
+        plan(dir).mkpath
+        plan(dir).chmod(0444)  # read only
+        args = builder == :write_default_config_file ? [ ] : [Process.egid]
+        assert(!plan(builder, *args), "Built without permission")
+      end
+    end
+  end
+  
+  # def test_directory_builders_create_a_readable_and_writable_directory
+  #   configure(:prefix_path => test_prefix) do
+  #     %w[db_dir pid_dir log_dir].each do |dir|
+  #       assert(!File.exist?(plan(dir)), "Directory already existed")
+  #       assert(plan("build_#{dir}", Process.egid), "Could not create directory")
+  #       assert(File.exist?(plan(dir)), "Directory not created")
+  #       assert_equal("775", plan(dir).stat.mode.to_s(8)[-3..-1])
+  #     end
+  #   end
+  # end
+  
+  ###################
+  ### Validations ###
+  ###################
+  
+  # def test_plan_is_present
+  #   configure(:prefix_path => test_prefix) do
+  #     assert(!plan.present?, "Card was present when missing")
+  #     # add some config
+  #     %w[db_dir log_dir].each do |dir|
+  #       assert(plan("build_#{dir}", Process.egid), "Could not create directory")
+  #     end
+  #     assert(!plan.present?, "Card was present when partially build")
+  #     # complete config
+  #     assert(plan.write_default_config_file, "Could not create config file")
+  #     assert(plan.present?, "Complete card was not present")
+  #   end
+  # end
+  # 
+  # def test_plan_is_valid
+  #   configure(:prefix_path => test_prefix) do
+  #     assert(!plan.valid?, "Card was valid when missing")
+  #     # add config
+  #     %w[db_dir log_dir].each do |dir|
+  #       assert(plan("build_#{dir}", Process.egid), "Could not create directory")
+  #     end
+  #     assert(plan.write_default_config_file, "Could not create config file")
+  #     assert(plan.valid?, "Complete card was not valid")
+  #     # break premissions
+  #     plan.db_dir.chmod(0444)  # read only
+  #     assert(!plan.valid?, "Card was valid when read only")
+  #   end
+  # end
+  
+  #######
+  private
+  #######
+  
+  # Creates a Tempfile, dumps configuration to it, and loads it.
+  def load_config_file(content = String.new)
+    cf = Tempfile.new("agent_config_test")
+    cf << content
+    cf.flush
+    plan.update_from_config_file(cf.path)
+  end
+  
+  # 
+  # Applies +settings+ to the configuaration, runs the passed block, then resets
+  # configuaration defaults.
+  # 
+  def configure(settings)
+    settings.each { |name, value| plan("#{name}=", value) }
+    begin
+      yield
+    ensure
+      plan.reset_defaults
+    end
+  end
+  
+  # Checks a Pathname +path+ against a +regexp+.
+  def assert_path_match(regexp, path)
+    assert_match(regexp, plan(path).to_s)
+  end
+  
+  # Sets the +parent+ dir and ensures that +path+ is updated as a result.
+  def assert_prepends_path(path, parent)
+    dir = "test_dir"
+    configure(parent => dir) do
+      assert_path_match(%r{\A/#{dir}/.+\z}, path)
+    end
+  end
+end