deep_test_pre 2.0

data/test/deep_test/distributed/rsync_test.rb

@@ -0,0 +1,47 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module DeepTest
+  module Distributed
+    unit_tests do
+      test "push executes rsync with using destination as remote location" do
+        RSync.expects(:system).
+           with("rsync -az --delete #{DeepTest::LIB_ROOT} source host:destination").returns(true)
+
+        RSync.push('host', {:source => "source"}, "destination")
+      end
+
+      test "raises error if push fails" do
+        RSync.expects(:system).returns(false)
+
+        assert_raises(RuntimeError) do
+          RSync.push(mock, {:source => "a", :local => true}, "destination")
+        end
+      end
+
+      test "include rsync_options in command" do
+        args = RSync::Args.new(mock, {:local => true, :rsync_options => "opt1 opt2"})
+        assert_equal "rsync -az --delete opt1 opt2 #{DeepTest::LIB_ROOT}", args.command("", "")
+      end
+
+      test "includes host in remote_location" do
+        args = RSync::Args.new('host', {})
+        assert_equal "host:dest", args.remote_location('dest')
+      end
+
+      test "separates host and dest with double colon if using daemon" do
+        args = RSync::Args.new('host', {:daemon => true})
+        assert_equal "host::dest", args.remote_location('dest')
+      end
+
+      test "includes username in dest_location if specified" do
+        args = RSync::Args.new('host', {:username => "user"})
+        assert_equal "user@host:dest", args.remote_location('dest')
+      end
+
+      test "does not include host in dest_location if local is specified" do
+        args = RSync::Args.new(mock, {:local => true})
+        assert_equal "dest", args.remote_location('dest')
+      end
+    end
+  end
+end

data/test/deep_test/distributed/shell_environment_test.rb

@@ -0,0 +1,108 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module DeepTest
+  module Distributed
+    unit_tests do
+      test "like_login creates enviroment that will behave like login shell" do
+        expected_env = ShellEnvironment.new
+        expected_env.include_first '/etc/profile'
+        expected_env.include_first '~/.profile', '~/.bash_profile', '~/.bashrc'
+
+        assert_equal expected_env, ShellEnvironment.like_login
+      end
+
+      test "include_first command loads the specified file when it exists" do
+        environment = ShellEnvironment.new
+        environment.include_first fixture_path('set_foo_to_bar')
+
+        assert_enviroment({:FOO => "bar"}, environment)
+      end
+
+      test "include_first does not load the file if it doesnt exist" do
+        environment = ShellEnvironment.new
+        environment.include_first fixture_path('nonexistent')
+        assert_enviroment({:SHELL => ENV['SHELL']}, environment)
+      end
+
+      test "include_first loads second file if first does not exist" do
+        environment = ShellEnvironment.new
+
+        environment.include_first fixture_path('nonexistent'),
+                                  fixture_path('set_foo_to_bar')
+
+        assert_enviroment({:FOO => "bar"}, environment)
+      end
+
+      test "include_first does not load second file if first exists" do
+        environment = ShellEnvironment.new
+
+        environment.include_first fixture_path('set_foo_to_bar'),
+                                  fixture_path('set_foo_to_baz')
+      
+        assert_enviroment({:FOO => "bar"}, environment)
+      end
+
+      test "include_first loads each file when called two separate times" do
+        environment = DeepTest::Distributed::ShellEnvironment.new
+        environment.include_first fixture_path('set_foo_to_bar')
+        environment.include_first fixture_path('set_bar_to_foo')
+
+        assert_enviroment({:FOO => "bar", :BAR => "foo"}, environment)
+      end
+
+      test "include_first loads files in order in which it was called" do
+        environment = ShellEnvironment.new
+        environment.include_first fixture_path('set_foo_to_bar')
+        environment.include_first fixture_path('set_foo_to_baz')
+
+        assert_enviroment({:FOO => "baz"}, environment)
+      end
+
+      test "source file lists are equal when they will load the same files" do
+        assert_equal ShellEnvironment::SourceFileList.new(['a','b']),
+                     ShellEnvironment::SourceFileList.new(['a','b'])
+
+        assert_not_equal ShellEnvironment::SourceFileList.new(['a','b']),
+                         ShellEnvironment::SourceFileList.new(['b','a'])
+      end
+
+      test "environments are equal when files will load in the same order" do
+        env1, env2 = ShellEnvironment.new, ShellEnvironment.new
+
+        env1.include_first 'A'; env2.include_first 'A'
+        env1.include_first 'B'; env2.include_first 'B'
+
+        assert_equal env1, env2
+      end
+
+      test "environments are not equal when files will load in the different order" do
+        env1, env2 = ShellEnvironment.new, ShellEnvironment.new
+
+        env1.include_first 'A'; env2.include_first 'B'
+        env1.include_first 'B'; env2.include_first 'A'
+
+        assert_not_equal env1, env2
+      end
+
+      def assert_enviroment(expected_hash, environment)
+        output = `#{environment} && env`
+        assert $?.success?, "'#{environment} && env' command failed"
+
+        actual_hash = output.inject({}) do |h, line|
+          if line =~ /^(.*?)=(.*)/ && expected_hash.key?($1.to_sym)
+            h[$1.to_sym] = $2
+          end
+          h
+        end
+
+        assert_equal expected_hash, actual_hash
+      end
+
+      def fixture_path(filename)
+        File.expand_path(File.join(File.dirname(__FILE__), 
+                                   'shell_environment_fixtures', 
+                                   filename))
+      end
+    end
+  end
+end

data/test/deep_test/distributed/ssh_client_connection_info_test.rb

@@ -0,0 +1,34 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module DeepTest
+  module Distributed
+    unit_tests do
+      test "returns ipaddress from SSH_CLIENT as address" do
+        info = nil
+        with_env("SSH_CLIENT", "168.0.0.1 33345 22") do
+          info = SshClientConnectionInfo.new
+        end
+        assert_equal "168.0.0.1", info.address
+      end
+
+      test "raises an error if SSH_CLIENT is blank" do
+        with_env("SSH_CLIENT", "") do
+          assert_raises(RuntimeError) { SshClientConnectionInfo.new }
+        end
+      end
+
+      test "raises an error if no SSH_CLIENT is found" do
+        with_env("SSH_CLIENT", nil) do
+          assert_raises(RuntimeError) { SshClientConnectionInfo.new }
+        end
+      end
+
+      def with_env(variable, value)
+        old_value, ENV[variable] = ENV[variable], value
+        yield
+      ensure
+        ENV[variable] = old_value
+      end
+    end
+  end
+end

data/test/deep_test/extensions/object_extension_test.rb

@@ -0,0 +1,37 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+unit_tests do
+  test "retrying once" do
+    object = Object.new
+    object.expects(:call_it_twice).times(2).raises(RuntimeError).then.returns(:ok)
+    result = nil
+    capture_stdout do
+      result = retrying do
+        object.call_it_twice
+      end
+    end
+    assert_equal :ok, result
+  end
+  
+  test "retrying defaults to 5 times" do
+    object = Object.new
+    object.expects(:may_i_please_have_another).times(5).
+      raises(RuntimeError).raises(RuntimeError).raises(RuntimeError).raises(RuntimeError).returns("ok")
+    capture_stdout do
+      retrying do
+        object.may_i_please_have_another
+      end
+    end
+  end
+  
+  test "retrying raises exception if still failing after number of attempts" do
+    my_error = Class.new(StandardError)
+    assert_raises(my_error) do
+      capture_stdout do
+        retrying "", 1 do
+          raise my_error
+        end
+      end
+    end
+  end
+end

data/test/deep_test/listener_list_test.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+module DeepTest
+  unit_tests do
+    test "forwards methods defined in NullListener to all listeners" do
+      listener_1, listener_2 = mock, mock
+      list = ListenerList.new([listener_1, listener_2])
+      listener_1.expects(:starting).with(:agent)
+      listener_2.expects(:starting).with(:agent)
+      listener_1.expects(:starting_work).with(:agent, :work)
+      listener_2.expects(:starting_work).with(:agent, :work)
+      list.starting(:agent)
+      list.starting_work(:agent, :work)
+    end
+
+    test "doesn't forward methods not defined in NullListener" do
+      listener = mock
+      listener.expects(:to_s).never
+      ListenerList.new([listener]).to_s
+    end
+  end
+end

data/test/deep_test/local_deployment_test.rb

@@ -0,0 +1,19 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+module DeepTest
+  unit_tests do
+    test "number_of_agents is determined by options" do
+      deployment = LocalDeployment.new Options.new(:number_of_agents => 4)
+      assert_equal 4, deployment.number_of_agents
+    end
+
+    test "load_files simply loads each file provided" do
+      deployment = LocalDeployment.new Options.new({})
+
+      deployment.expects(:load).with(:file_1)
+      deployment.expects(:load).with(:file_2)
+
+      deployment.load_files([:file_1, :file_2])
+    end
+  end
+end

data/test/deep_test/logger_test.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+module DeepTest
+  unit_tests do
+    test "info log level by default" do
+      assert_equal Logger::INFO, DeepTest.logger.level
+    end
+    
+    test "formatter uses msg only" do
+      time = Time.parse("2009-09-22 12:01:33")
+      assert_equal "[DeepTest@#{Socket.gethostname}] 2009-09-22 12:01:33 my_msg\n", DeepTest.logger.formatter.call(nil, time, nil, "my_msg")
+    end
+
+    Logger::Severity.constants.each do |severity|
+      test "#{severity.downcase} can not be called with any arguments" do
+        logger = Logger.new stub_everything
+        assert_raises(ArgumentError) { logger.send severity.downcase, "a"  }
+      end
+
+      THE_DATE = '\d{4}-\d\d-\d\d \d\d:\d\d:\d\d' unless defined?(THE_DATE)
+
+      test "#{severity.downcase} can be called with a block" do
+        logger = Logger.new(out = StringIO.new)
+        logger.level = Logger.const_get(severity)
+        logger.send(severity.downcase) { "a" }
+        assert_match /\[DeepTest@#{Socket.gethostname}\] #{THE_DATE} a\n/, out.string
+      end
+
+      test "#{severity.downcase} rescues errors from block and logs them" do
+        logger = Logger.new(out = StringIO.new)
+        logger.level = Logger.const_get(severity)
+        logger.send(severity.downcase) { raise Exception, "e" }
+        assert_match /\[DeepTest@#{Socket.gethostname}\] #{THE_DATE} Exception: e occurred logging on #{__FILE__}:#{__LINE__ - 1}:in `send'\n/,
+                    out.string
+      end
+    end
+  end
+end

data/test/deep_test/main_test.rb

@@ -0,0 +1,12 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+module DeepTest
+  unit_tests do
+    test "shutdown calls done_with_work" do
+      main = Main.new(nil, stub_everything, nil, central_command = mock)
+      central_command.expects(:done_with_work)
+
+      main.shutdown
+    end
+  end
+end

data/test/deep_test/marshallable_exception_wrapper_test.rb

@@ -0,0 +1,46 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+module DeepTest
+  unit_tests do
+    test "loading a marshallable exception evals the classname and returns an instance of the original exception" do
+      original = RuntimeError.new "message"
+      original.set_backtrace ['1', '2']
+
+      marshalled = MarshallableExceptionWrapper.new(original)
+      MarshallableExceptionWrapper.any_instance.expects(:eval).
+        with("::RuntimeError").returns(RuntimeError)
+
+      loaded = Marshal.load(Marshal.dump(marshalled)).resolve
+
+      assert_equal original.class,     loaded.class
+      assert_equal original.message,   loaded.message
+      assert_equal original.backtrace, loaded.backtrace
+    end
+
+    test "loading a marshallable exception when class is not available returns an instance of unloadable exception" do
+      original = RuntimeError.new "message"
+      original.set_backtrace ['1', '2']
+
+      marshalled = MarshallableExceptionWrapper.new(original)
+      MarshallableExceptionWrapper.any_instance.expects(:eval).
+        raises("Eval Error")
+
+      loaded = Marshal.load(Marshal.dump(marshalled)).resolve
+
+      assert_equal UnloadableException, loaded.class
+      assert_equal "RuntimeError: " + original.message,   loaded.message
+      assert_equal original.backtrace, loaded.backtrace
+    end
+
+    test "loading a marshallable exception when class init throws an error returns an unloadable exception" do
+      original = RuntimeError.new "message"
+
+      marshalled = MarshallableExceptionWrapper.new(original)
+      RuntimeError.expects(:new).raises(StandardError.new)
+
+      loaded = Marshal.load(Marshal.dump(marshalled)).resolve
+
+      assert_equal UnloadableException, loaded.class
+    end
+  end
+end

data/test/deep_test/metrics/data_test.rb

@@ -0,0 +1,22 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module DeepTest
+  module Metrics
+    class DataTest < ::Test::Unit::TestCase
+      test "measurements are summarized in report" do
+        data = Data.new
+        data.add Measurement.new("category a", 1, "bytes")
+        data.add Measurement.new("category b", 2, "seconds")
+        data.add Measurement.new("category a", 2, "bytes")
+        data.add Measurement.new("category b", 3, "seconds")
+
+        assert_equal <<-end_text, data.summary
+Metrics Data
+------------
+category a: 1.5 avg / 3 total bytes
+category b: 2.5 avg / 5 total seconds
+        end_text
+      end
+    end
+  end
+end

data/test/deep_test/metrics/measurement_test.rb

@@ -0,0 +1,18 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module DeepTest
+  module Metrics
+    class MeasurementTest < ::Test::Unit::TestCase
+      test "of_time_taken should measure time an operation takes" do
+        measurement = Measurement.of_time_taken("category") do
+          sleep 0.5
+        end
+
+        assert_equal "category", measurement.category
+        assert_in_delta 0.5, measurement.value, 0.1
+        assert_equal "seconds", measurement.units
+      end
+    end
+  end
+end
+

data/test/deep_test/proxy_io_test.rb

@@ -0,0 +1,104 @@
+require File.dirname(__FILE__) + "/../test_helper"
+
+module DeepTest
+  unit_tests do
+    test "should write strings to proxy wire" do
+      io = ProxyIO.new(ProxyIO::Stdout, wire = mock)
+      wire.expects(:send_message).with ProxyIO::Stdout::Output.new("my_string")
+      io.write "my_string"
+    end
+
+    test "should call to_s on any received objects" do
+      io = ProxyIO.new(ProxyIO::Stdout, wire = mock)
+      wire.expects(:send_message).with ProxyIO::Stdout::Output.new("some value")
+      io.write mock(:to_s => "some value")
+    end
+
+    test "should clear string buffer after forwarding to wire" do
+      io = ProxyIO.new(ProxyIO::Stdout, wire = mock)
+      wire.expects(:send_message).with ProxyIO::Stdout::Output.new("string 1")
+      wire.expects(:send_message).with ProxyIO::Stdout::Output.new("string 2")
+      io.write "string 1"
+      io.write "string 2"
+    end
+
+    test "should forward flush to the wire" do
+      io = ProxyIO.new(ProxyIO::Stdout, wire = mock)
+      wire.expects(:send_message).with kind_of(ProxyIO::Stdout::Flush)
+      io.flush
+    end
+
+    test "Stdout::Output prints to stdout" do
+      output = ProxyIO::Stdout::Output.new("output")
+      assert_equal "output", capture_stdout { output.execute }
+    end
+
+    test "Stderr::Output prints to stdout" do
+      output = ProxyIO::Stderr::Output.new("output")
+      assert_equal "output", capture_stderr { output.execute }
+    end
+
+    test "Stdout::Flush prints to stdout" do
+      output = ProxyIO::Stdout::Flush.new
+      $stdout.expects :flush
+      output.execute
+    end
+
+    test "Stderr::Flush prints to stdout" do
+      output = ProxyIO::Stderr::Flush.new
+      $stderr.expects :flush
+      output.execute
+    end
+
+    test "replace_stdout_stderr! yields" do
+      yielded = false
+      ProxyIO.replace_stdout_stderr!(mock) { yielded = true }
+      assert yielded, "didn't yield"
+    end
+
+    test "will replace stdout with proxy to wire" do
+      ProxyIO.replace_stdout_stderr!(wire = mock) do
+        wire.expects(:send_message).with ProxyIO::Stdout::Output.new("global string")
+        wire.expects(:send_message).with ProxyIO::Stdout::Output.new("const string")
+        $stdout.write "global string"
+        STDOUT.write "const string"
+      end
+    end
+
+    test "will restore stdout after yielding" do
+      old_stdout_global, old_stdout_const = $stdout, STDOUT
+      ProxyIO.replace_stdout_stderr!(mock) { raise "error" } rescue nil
+      assert_equal old_stdout_global, $stdout
+      assert_equal old_stdout_const, STDOUT
+    end
+
+    test "will replace stderr with proxy to wire" do
+      ProxyIO.replace_stdout_stderr!(wire = mock) do
+        wire.expects(:send_message).with ProxyIO::Stderr::Output.new("global string")
+        wire.expects(:send_message).with ProxyIO::Stderr::Output.new("const string")
+        $stderr.write "global string"
+        STDERR.write "const string"
+      end
+    end
+
+    test "will restore stderr after yielding" do
+      old_stderr_global, old_stderr_const = $stderr, STDERR
+      ProxyIO.replace_stdout_stderr!(mock) { raise "error" } rescue nil
+      assert_equal old_stderr_global, $stderr
+      assert_equal old_stderr_const, STDERR
+    end
+
+    test "reconnect the logger to the new stdout" do
+      old_stderr_global, old_stderr_const = $stderr, STDERR
+      ProxyIO.replace_stdout_stderr!(mock) do 
+        assert_equal $stdout, DeepTest.logger.io_stream
+      end
+    end
+
+    test "supress warnings restores verbose" do
+      old_verbose = $VERBOSE
+      ProxyIO.supress_warnings { raise "error" } rescue nil
+      assert_equal old_verbose, $VERBOSE
+    end
+  end
+end