jstorimer-deep-test 1.4.0 → 2.0.0

data/test/deep_test/distributed/landing_ship_test.rb

@@ -0,0 +1,48 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module DeepTest
+  module Distributed
+    unit_tests do
+      test "generates a local working copy path based on host and source of request" do
+        Socket.stubs(:gethostname).returns("myhost")
+        Telegraph::Wire.stubs(:connect).returns :wire
+        landing_ship = LandingShip.new(:address => "host")
+        options = Options.new(:sync_options => {:source => "/my/local/dir"})
+        RSync.expects(:push).with("host", options.sync_options, "/tmp/myhost_my_local_dir")
+        landing_ship.push_code(options)
+      end
+
+      test "establish_beachhead launches beachhead process on remote machine" do
+        Socket.stubs(:gethostname).returns("myhost")
+        Telegraph::Wire.stubs(:connect).returns :wire
+        landing_ship = LandingShip.new(:address => "remote_host")
+        options = Options.new(:sync_options => {:source => "/my/local/dir"})
+
+        landing_ship.expects(:`).with(
+          "ssh -4 remote_host " + 
+          "'#{ShellEnvironment.like_login} && cd /tmp/myhost_my_local_dir && " + 
+          "OPTIONS=#{options.to_command_line} " + 
+          "ruby lib/deep_test/distributed/establish_beachhead.rb' 2>&1"
+        ).returns("blah blah\nBeachhead port: 9999\nblah")
+
+        landing_ship.establish_beachhead(options)
+      end
+
+      test "establish_beachhead launches beachhead process on remote machine with usernames specified in sync_options" do
+        Socket.stubs(:gethostname).returns("myhost")
+        Telegraph::Wire.stubs(:connect).returns :wire
+        landing_ship = LandingShip.new(:address => "remote_host")
+        options = Options.new(:sync_options => {:username => "me", :source => "/my/local/dir"})
+
+        landing_ship.expects(:`).with(
+          "ssh -4 remote_host -l me " + 
+          "'#{ShellEnvironment.like_login} && cd /tmp/myhost_my_local_dir && " + 
+          "OPTIONS=#{options.to_command_line} " + 
+          "ruby lib/deep_test/distributed/establish_beachhead.rb' 2>&1"
+        ).returns("blah blah\nBeachhead port: 9999\nblah")
+
+        landing_ship.establish_beachhead(options)
+      end
+    end
+  end
+end

data/test/deep_test/distributed/remote_deployment_test.rb

@@ -0,0 +1,134 @@
+require File.dirname(__FILE__) + "/../../test_helper"
+
+module DeepTest
+  module Distributed
+    unit_tests do
+      test "load_files broadcasts before_sync" do
+        class FakeListener; end
+        deployment = RemoteDeployment.new(
+          options = Options.new(:listener => FakeListener,
+                                :sync_options => {:source => "/tmp"}),
+          landing_ship = stub_everything,
+          failover_deployment = mock
+        )
+        FakeListener.any_instance.expects(:before_sync)
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+
+      end
+
+      test "load_files pushes code to remote machines" do
+        deployment = RemoteDeployment.new(
+          options = Options.new(:sync_options => {:source => "/tmp"}),
+          landing_ship = stub_everything,
+          failover_deployment = mock
+        )
+
+        landing_ship.expects(:push_code).with(options)
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+      end
+
+      test "load_files loads files locally" do
+        beachhead = stub_everything
+        deployment = RemoteDeployment.new(
+          Options.new(:sync_options => {:source => "/tmp"}),
+          landing_ship = stub_everything,
+          failover_deployment = mock
+        )
+
+        deployment.expects(:load).with("filelist")
+        deployment.load_files ["filelist"]
+      end
+
+      test "deploy_agents starts agents on agent server" do
+        deployment = RemoteDeployment.new(
+          options = Options.new(:sync_options => {:source => "/tmp"}),
+          landing_ship = stub_everything,
+          failover_deployment = mock
+        )
+
+        landing_ship.expects(:establish_beachhead).with(options)  
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+
+        landing_ship.expects(:deploy_agents)
+        deployment.deploy_agents
+      end
+
+      test "exception in deploy_agents causes failover to failover_deployment" do
+        deployment = RemoteDeployment.new(
+          options = Options.new(:sync_options => {:source => "/tmp"}, :ui => UI::Null),
+          landing_ship = stub_everything,
+          failover_deployment = mock
+        )
+
+        landing_ship.expects(:establish_beachhead).with(options)  
+        landing_ship.expects(:load_files)
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+
+        landing_ship.expects(:deploy_agents).raises("An Error")
+
+        failover_deployment.expects(:deploy_agents)
+        deployment.deploy_agents
+      end
+
+      test "exception in push_code causes failover to failover_deployment" do
+        deployment = RemoteDeployment.new(
+          options = Options.new(:sync_options => {:source => "/tmp"}, :ui => UI::Null),
+          landing_ship = mock,
+          failover_deployment = mock
+        )
+
+        landing_ship.expects(:push_code).raises("An Error")
+
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+
+        failover_deployment.expects(:deploy_agents)
+        deployment.deploy_agents
+      end
+
+      test "exception in load_files causes failover to failover_deployment" do
+        deployment = RemoteDeployment.new(
+          options = Options.new(:sync_options => {:source => "/tmp"}, :ui => UI::Null),
+          landing_ship = mock,
+          failover_deployment = mock
+        )
+
+        landing_ship.expects(:push_code)
+        landing_ship.expects(:establish_beachhead)
+        landing_ship.expects(:load_files).raises("An Error")
+
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+
+        failover_deployment.expects(:deploy_agents)
+        deployment.deploy_agents
+      end
+
+      test "exception from deploy_agents of failover_deployment is raised" do
+        deployment = RemoteDeployment.new(
+          options = Options.new(:sync_options => {:source => "/tmp"}, :ui => UI::Null),
+          landing_ship = stub_everything,
+          failover_deployment = mock
+        )
+
+        landing_ship.expects(:establish_beachhead).with(options)
+        landing_ship.expects(:load_files).raises("An Error")
+        deployment.expects(:load)
+        deployment.load_files ["filelist"]
+
+        failover_deployment.expects(:deploy_agents).raises("Failover Error").then.returns(nil)
+
+        begin 
+          deployment.deploy_agents
+          flunk
+        rescue RuntimeError => e
+          assert_equal "Failover Error", e.message
+        end
+      end
+    end
+  end
+end

data/test/deep_test/distributed/rsync_test.rb

@@ -1,67 +1,47 @@
 require File.dirname(__FILE__) + "/../../test_helper"
 
-unit_tests do
-  test "executes rsync with source and destination" do
-    options = DeepTest::Options.new(:sync_options => {:source => "source", :local => true})
-
-    DeepTest::Distributed::RSync.expects(:system).
-       with("rsync -az --delete source/ destination").returns(true)
-
-    DeepTest::Distributed::RSync.sync(mock, options, "destination")
-  end
-
-  test "raises error if sync fails" do
-    DeepTest::Distributed::RSync.expects(:system).returns(false)
-
-    assert_raises(RuntimeError) do
-      DeepTest::Distributed::RSync.sync(
-        mock,
-        DeepTest::Options.new(:sync_options => {:source => "a", :local => true}),
-        "destination"
-      )
+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
-
-  test "include rsync_options in command" do
-    options = DeepTest::Options.new(:sync_options => {:source => "source", 
-                                                      :local => true,
-                                                      :rsync_options => "opt1 opt2"})
-
-    args = DeepTest::Distributed::RSync::Args.new(mock, options)
-    assert_equal "rsync -az --delete opt1 opt2 source/", args.command("")
-  end
-
-  test "includes host in source_location" do
-    options = DeepTest::Options.new(:sync_options => {:source => "source"})
-    args = DeepTest::Distributed::RSync::Args.new(mock(:address => 'host'), 
-                                                  options)
-
-    assert_equal "host:source", args.source_location
-  end
-
-  test "separates host and source with double colon if using daemon" do
-    options = DeepTest::Options.new(
-      :sync_options => {:source => "source", :daemon => true}
-    )
-    args = DeepTest::Distributed::RSync::Args.new(mock(:address => 'host'), 
-                                                  options)
-
-    assert_equal "host::source", args.source_location
-  end
-
-  test "includes username in source_location if specified" do
-    options = DeepTest::Options.new(:sync_options => {:source => "source", 
-                                                      :username => "user"})
-    args = DeepTest::Distributed::RSync::Args.new(mock(:address => 'host'),
-                                                  options)
-
-    assert_equal "user@host:source", args.source_location
-  end
-
-  test "does not include host in source_location if local is specified" do
-    options = DeepTest::Options.new(:sync_options => {:source => "source", :local => true})
-    args = DeepTest::Distributed::RSync::Args.new(mock, options)
-
-    assert_equal "source", args.source_location
-  end
 end

data/test/deep_test/distributed/shell_environment_fixtures/set_bar_to_foo

@@ -0,0 +1 @@
+export BAR=foo

data/test/deep_test/distributed/shell_environment_fixtures/set_foo_to_bar

@@ -0,0 +1 @@
+export FOO=bar

data/test/deep_test/distributed/shell_environment_fixtures/set_foo_to_baz

@@ -0,0 +1 @@
+export FOO=baz

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