dk 0.0.1 → 0.1.0

data/test/system/has_the_stubs_tests.rb

@@ -0,0 +1,355 @@
+require 'assert'
+require 'dk/has_the_stubs'
+
+require 'stringio'
+require 'dk/config'
+require 'dk/dry_runner'
+require 'dk/tree_runner'
+require 'dk/test_runner'
+
+module Dk::HasTheStubs
+
+  class SystemTests < Assert::Context
+    desc "Dk::HasTheStubs"
+
+  end
+
+  class RunnerTests < SystemTests
+    desc "used by a runner"
+    setup do
+      @runner_class = [
+        Dk::DryRunner,
+        Dk::TreeRunner,
+        Dk::TestRunner
+      ].sample
+
+      # turn off the stdout logging
+      @dk_config = Dk::Config.new
+      @logger    = Dk::NullLogger.new
+      Assert.stub(@dk_config, :dk_logger){ @logger }
+
+      @task_class = StubTestTask
+      @runner     = build_runner(@task_class)
+
+      @cmd_str   = Factory.string
+      @cmd_input = Factory.string
+      @cmd_opts  = { Factory.string => Factory.string }
+
+      @params = {
+        'use_bang'  => false,
+        'cmd_str'   => @cmd_str,
+        'cmd_input' => @cmd_input,
+        'cmd_opts'  => @cmd_opts
+      }
+    end
+
+    private
+
+    def build_runner(task_class)
+      if @runner_class == Dk::TestRunner
+        @runner_class.new(:logger => @logger).tap{ |r| r.task_class = task_class }
+      elsif @runner_class == Dk::TreeRunner
+        @runner_class.new(@dk_config, StringIO.new)
+      else
+        @runner_class.new(@dk_config)
+      end
+    end
+
+    def run_runner(runner, task_class, params)
+      if @runner_class == Dk::TestRunner
+        runner.run(params)
+      else
+        runner.run(task_class, params)
+      end
+    end
+
+    def add_stubs(runner, local)
+      method = local ? :stub_cmd : :stub_ssh
+
+      @only_cmd_stdout  = Factory.stdout
+      @only_cmd_stderr  = Factory.stderr
+      @only_cmd_success = Factory.boolean
+      @only_cmd_spy     = nil
+      @runner.send(method, @cmd_str) do |spy|
+        spy.stdout     = @only_cmd_stdout
+        spy.stderr     = @only_cmd_stderr
+        spy.exitstatus = @only_cmd_success ? 0 : 1
+        @only_cmd_spy  = spy
+      end
+
+      @with_input_cmd_stdout  = Factory.stdout
+      @with_input_cmd_stderr  = Factory.stderr
+      @with_input_cmd_success = Factory.boolean
+      @with_input_cmd_spy     = nil
+      @runner.send(method, @cmd_str, :input => @cmd_input) do |spy|
+        spy.stdout          = @with_input_cmd_stdout
+        spy.stderr          = @with_input_cmd_stderr
+        spy.exitstatus      = @with_input_cmd_success ? 0 : 1
+        @with_input_cmd_spy = spy
+      end
+
+      @with_opts_cmd_stdout  = Factory.stdout
+      @with_opts_cmd_stderr  = Factory.stderr
+      @with_opts_cmd_success = Factory.boolean
+      @with_opts_cmd_spy     = nil
+      @runner.send(method, @cmd_str, :opts => @cmd_opts) do |spy|
+        spy.stdout         = @with_opts_cmd_stdout
+        spy.stderr         = @with_opts_cmd_stderr
+        spy.exitstatus     = @with_opts_cmd_success ? 0 : 1
+        @with_opts_cmd_spy = spy
+      end
+
+      @with_all_cmd_stdout  = Factory.stdout
+      @with_all_cmd_stderr  = Factory.stderr
+      @with_all_cmd_success = Factory.boolean
+      @with_all_cmd_spy     = nil
+      @runner.send(method, @cmd_str, {
+        :input => @cmd_input,
+        :opts  => @cmd_opts
+      }) do |spy|
+        spy.stdout        = @with_all_cmd_stdout
+        spy.stderr        = @with_all_cmd_stderr
+        spy.exitstatus    = @with_all_cmd_success ? 0 : 1
+        @with_all_cmd_spy = spy
+      end
+    end
+
+  end
+
+  class CmdStubTests < RunnerTests
+    setup do
+      @params.merge!('local' => true)
+      add_stubs(@runner, @params['local'])
+    end
+
+    should "allow stubbing `cmd` calls" do
+      task = run_runner(@runner, @task_class, @params)
+
+      # ensure calls return the cmd spy they are stubbed with
+      assert_same @only_cmd_spy,       task.only_cmd
+      assert_same @with_input_cmd_spy, task.with_input_cmd
+      assert_same @with_opts_cmd_spy,  task.with_opts_cmd
+      assert_same @with_all_cmd_spy,   task.with_all_cmd
+
+      # ensure the cmd spies are local spies
+      assert_false @only_cmd_spy.ssh?
+      assert_false @with_input_cmd_spy.ssh?
+      assert_false @with_opts_cmd_spy.ssh?
+      assert_false @with_all_cmd_spy.ssh?
+
+      # ensure cmd spies are run
+      assert_true @only_cmd_spy.run_called?
+      assert_true @with_input_cmd_spy.run_called?
+      assert_true @with_opts_cmd_spy.run_called?
+      assert_true @with_all_cmd_spy.run_called?
+
+      # ensure stubs can set stdout
+      assert_equal @only_cmd_stdout,       @only_cmd_spy.stdout
+      assert_equal @with_input_cmd_stdout, @with_input_cmd_spy.stdout
+      assert_equal @with_opts_cmd_stdout,  @with_opts_cmd_spy.stdout
+      assert_equal @with_all_cmd_stdout,   @with_all_cmd_spy.stdout
+
+      # ensure stubs can set stderr
+      assert_equal @only_cmd_stderr,       @only_cmd_spy.stderr
+      assert_equal @with_input_cmd_stderr, @with_input_cmd_spy.stderr
+      assert_equal @with_opts_cmd_stderr,  @with_opts_cmd_spy.stderr
+      assert_equal @with_all_cmd_stderr,   @with_all_cmd_spy.stderr
+
+      # ensure stubs can set exitstatus
+      assert_equal @only_cmd_success,       @only_cmd_spy.success?
+      assert_equal @with_input_cmd_success, @with_input_cmd_spy.success?
+      assert_equal @with_opts_cmd_success,  @with_opts_cmd_spy.success?
+      assert_equal @with_all_cmd_success,   @with_all_cmd_spy.success?
+    end
+
+    should "allow stubbing `cmd!` calls" do
+      @params['use_bang'] = true
+      task = run_runner(@runner, @task_class, @params)
+
+      # ensure stubs can control whether a `cmd!` raises an error or not
+
+      if @only_cmd_success
+        assert_equal @only_cmd_spy, task.only_cmd
+      else
+        assert_true task.only_cmd_failed
+      end
+
+      if @with_input_cmd_success
+        assert_equal @with_input_cmd_spy, task.with_input_cmd
+      else
+        assert_true task.with_input_cmd_failed
+      end
+
+      if @with_opts_cmd_success
+        assert_equal @with_opts_cmd_spy, task.with_opts_cmd
+      else
+        assert_true task.with_opts_cmd_failed
+      end
+
+      if @with_all_cmd_success
+        assert_equal @with_all_cmd_spy, task.with_all_cmd
+      else
+        assert_true task.with_all_cmd_failed
+      end
+    end
+
+    should "unstub all cmd spies" do
+      @runner.unstub_all_cmds
+      @params['use_bang'] = Factory.boolean
+      task = run_runner(@runner, @task_class, @params)
+
+      assert_not_same @only_cmd_spy,       task.only_cmd
+      assert_not_same @with_input_cmd_spy, task.with_input_cmd
+      assert_not_same @with_opts_cmd_spy,  task.with_opts_cmd
+      assert_not_same @with_all_cmd_spy,   task.with_all_cmd
+    end
+
+  end
+
+  class SshStubTests < RunnerTests
+    setup do
+      @cmd_opts = Factory.ssh_cmd_opts
+      @params.merge!({
+        'local'    => false,
+        'cmd_opts' => @cmd_opts
+      })
+      add_stubs(@runner, @params['local'])
+    end
+
+    should "allow stubbing `ssh` calls" do
+      task = run_runner(@runner, @task_class, @params)
+
+      # ensure calls return the cmd spy they are stubbed with
+      assert_same @only_cmd_spy,       task.only_cmd
+      assert_same @with_input_cmd_spy, task.with_input_cmd
+      assert_same @with_opts_cmd_spy,  task.with_opts_cmd
+      assert_same @with_all_cmd_spy,   task.with_all_cmd
+
+      # ensure the cmd spies are remote spies
+      assert_true @only_cmd_spy.ssh?
+      assert_true @with_input_cmd_spy.ssh?
+      assert_true @with_opts_cmd_spy.ssh?
+      assert_true @with_all_cmd_spy.ssh?
+
+      # ensure cmd spies are run
+      assert_true @only_cmd_spy.run_called?
+      assert_true @with_input_cmd_spy.run_called?
+      assert_true @with_opts_cmd_spy.run_called?
+      assert_true @with_all_cmd_spy.run_called?
+
+      # ensure stubs can set stdout
+      assert_equal @only_cmd_stdout,       @only_cmd_spy.stdout
+      assert_equal @with_input_cmd_stdout, @with_input_cmd_spy.stdout
+      assert_equal @with_opts_cmd_stdout,  @with_opts_cmd_spy.stdout
+      assert_equal @with_all_cmd_stdout,   @with_all_cmd_spy.stdout
+
+      # ensure stubs can set stderr
+      assert_equal @only_cmd_stderr,       @only_cmd_spy.stderr
+      assert_equal @with_input_cmd_stderr, @with_input_cmd_spy.stderr
+      assert_equal @with_opts_cmd_stderr,  @with_opts_cmd_spy.stderr
+      assert_equal @with_all_cmd_stderr,   @with_all_cmd_spy.stderr
+
+      # ensure stubs can set exitstatus
+      assert_equal @only_cmd_success,       @only_cmd_spy.success?
+      assert_equal @with_input_cmd_success, @with_input_cmd_spy.success?
+      assert_equal @with_opts_cmd_success,  @with_opts_cmd_spy.success?
+      assert_equal @with_all_cmd_success,   @with_all_cmd_spy.success?
+    end
+
+    should "allow stubbing `ssh!` calls" do
+      @params['use_bang'] = true
+      task = run_runner(@runner, @task_class, @params)
+
+      # ensure stubs can control whether a `ssh!` raises an error or not
+
+      if @only_cmd_success
+        assert_equal @only_cmd_spy, task.only_cmd
+      else
+        assert_true task.only_cmd_failed
+      end
+
+      if @with_input_cmd_success
+        assert_equal @with_input_cmd_spy, task.with_input_cmd
+      else
+        assert_true task.with_input_cmd_failed
+      end
+
+      if @with_opts_cmd_success
+        assert_equal @with_opts_cmd_spy, task.with_opts_cmd
+      else
+        assert_true task.with_opts_cmd_failed
+      end
+
+      if @with_all_cmd_success
+        assert_equal @with_all_cmd_spy, task.with_all_cmd
+      else
+        assert_true task.with_all_cmd_failed
+      end
+    end
+
+    should "unstub all cmd spies" do
+      @runner.unstub_all_ssh
+      @params['use_bang'] = Factory.boolean
+      task = run_runner(@runner, @task_class, @params)
+
+      assert_not_same @only_cmd_spy,       task.only_cmd
+      assert_not_same @with_input_cmd_spy, task.with_input_cmd
+      assert_not_same @with_opts_cmd_spy,  task.with_opts_cmd
+      assert_not_same @with_all_cmd_spy,   task.with_all_cmd
+    end
+
+  end
+
+  class StubTestTask
+    include Dk::Task
+
+    attr_reader :only_cmd, :with_input_cmd, :with_opts_cmd, :with_all_cmd
+    attr_reader :only_cmd_failed, :with_input_cmd_failed
+    attr_reader :with_opts_cmd_failed, :with_all_cmd_failed
+
+    ssh_hosts 'test'
+
+    def run!
+      method = if params['local']
+        params['use_bang'] ? :cmd! : :cmd
+      else
+        params['use_bang'] ? :ssh! : :ssh
+      end
+
+      begin
+        @only_cmd = send(method, params['cmd_str'])
+        @only_cmd_failed = false
+      rescue CmdRunError, SSHRunError
+        @only_cmd_failed = true
+      end
+
+      begin
+        @with_input_cmd = send(method, params['cmd_str'], params['cmd_input'])
+        @with_input_cmd_failed = false
+      rescue CmdRunError, SSHRunError
+        @with_input_cmd_failed = true
+      end
+
+      begin
+        @with_opts_cmd = send(method, params['cmd_str'], params['cmd_opts'])
+        @with_opts_cmd_failed = false
+      rescue CmdRunError, SSHRunError
+        @with_opts_cmd_failed = true
+      end
+
+      begin
+        @with_all_cmd = send(
+          method,
+          params['cmd_str'],
+          params['cmd_input'],
+          params['cmd_opts']
+        )
+        @with_all_cmd_failed = false
+      rescue CmdRunError, SSHRunError
+        @with_all_cmd_failed = true
+      end
+    end
+
+  end
+
+end

data/test/system/runner_tests.rb

@@ -0,0 +1,222 @@
+require 'assert'
+require 'dk/runner'
+
+require 'stringio'
+require 'dk/config'
+require 'dk/dk_runner'
+require 'dk/dry_runner'
+require 'dk/null_logger'
+require 'dk/task'
+require 'dk/test_runner'
+require 'dk/tree_runner'
+
+class Dk::Runner
+
+  class SystemTests < Assert::Context
+
+  end
+
+  class DryTreeRunSystemTests < SystemTests
+    setup do
+      @task_class = Class.new do
+        include Dk::Task
+        ssh_hosts Factory.string
+
+        attr_reader :regular_cmd, :dry_tree_run_cmd, :stubbed_cmd
+        attr_reader :regular_ssh, :dry_tree_run_ssh, :stubbed_ssh
+
+        def run!
+          @regular_cmd      = cmd!(params['cmd_str'])
+          @dry_tree_run_cmd = cmd!(params['cmd_str'], :dry_tree_run => true)
+          @stubbed_cmd      = cmd!(params['stubbed_cmd_str'], :dry_tree_run => true)
+          @regular_ssh      = ssh!(params['cmd_str'])
+          @dry_tree_run_ssh = ssh!(params['cmd_str'], :dry_tree_run => true)
+          @stubbed_ssh      = ssh!(params['stubbed_cmd_str'], :dry_tree_run => true)
+        end
+      end
+
+      # turn off the stdout logging
+      @dk_config = Dk::Config.new
+      @logger    = Dk::NullLogger.new
+      Assert.stub(@dk_config, :dk_logger){ @logger }
+
+      @params = {
+        'cmd_str'         => Factory.string,
+        'stubbed_cmd_str' => Factory.string
+      }
+    end
+  end
+
+  class DTRDkRunnerSystemTests < DryTreeRunSystemTests
+    desc "DkRunner"
+    setup do
+      @runner = Dk::DkRunner.new(@dk_config)
+      @task   = @runner.run(@task_class, @params)
+    end
+    subject{ @task }
+
+    should "run all cmds/ssh regardless of the `dry_tree_run` opt" do
+      # scmd is in test mode so we can test its spy and see if it was run
+      # called; if scmd was run then as far as dk is concerned it ran the cmd
+      assert_instance_of Dk::Local::Cmd, @task.regular_cmd
+      assert_true @task.regular_cmd.scmd.run_called?
+      assert_instance_of Dk::Local::Cmd, @task.dry_tree_run_cmd
+      assert_true @task.dry_tree_run_cmd.scmd.run_called?
+      assert_instance_of Dk::Local::Cmd, @task.stubbed_cmd
+      assert_true @task.stubbed_cmd.scmd.run_called?
+
+      # check that the first local cmd of the remote cmd was run
+      assert_instance_of Dk::Remote::Cmd, @task.regular_ssh
+      assert_true @task.regular_ssh.local_cmds.values.first.scmd.start_called?
+      assert_instance_of Dk::Remote::Cmd, @task.dry_tree_run_ssh
+      assert_true @task.dry_tree_run_ssh.local_cmds.values.first.scmd.start_called?
+      assert_instance_of Dk::Remote::Cmd, @task.stubbed_ssh
+      assert_true @task.stubbed_ssh.local_cmds.values.first.scmd.start_called?
+    end
+
+  end
+
+  class DTRDryRunnerSystemTests < DryTreeRunSystemTests
+    desc "DryRunner"
+    setup do
+      @runner = Dk::DryRunner.new(@dk_config)
+
+      stub_cmd_str = [
+        @params['stubbed_cmd_str'],
+        proc{ params['stubbed_cmd_str']}
+      ].sample
+
+      # stub a cmd/ssh using `dry_tree_run` so we can test that the stub takes
+      # precedence over the `dry_tree_run` opt
+      @runner.stub_cmd(stub_cmd_str, {
+        :opts => { :dry_tree_run => true }
+      }) do |s|
+        s.stdout = Factory.string
+      end
+      @runner.stub_ssh(stub_cmd_str, {
+        :opts => { :dry_tree_run => true }
+      }) do |s|
+        s.stdout = Factory.string
+      end
+
+      @task = @runner.run(@task_class, @params)
+    end
+    subject{ @task }
+
+    should "not spy cmds that use the `dry_tree_run` opt" do
+      # scmd is in test mode so we can test its spy and see if it was run
+      # called; if scmd was run then as far as dk is concerned it ran the cmd
+      assert_instance_of Dk::Local::Cmd, @task.dry_tree_run_cmd
+      assert_true @task.dry_tree_run_cmd.scmd.run_called?
+      # check that the first local cmd of the remote cmd was run
+      assert_instance_of Dk::Remote::Cmd, @task.dry_tree_run_ssh
+      assert_true @task.dry_tree_run_ssh.local_cmds.values.first.scmd.start_called?
+    end
+
+    should "spy cmds that don't use the `dry_tree_run` opt" do
+      assert_instance_of Dk::Local::CmdSpy, @task.regular_cmd
+      assert_true @task.regular_cmd.run_called?
+      assert_instance_of Dk::Remote::CmdSpy, @task.regular_ssh
+      assert_true @task.regular_ssh.run_called?
+    end
+
+    should "spy cmds that are stubbed and use the `dry_tree_run` opt" do
+      assert_instance_of Dk::Local::CmdSpy, @task.stubbed_cmd
+      assert_true @task.stubbed_cmd.run_called?
+      assert_instance_of Dk::Remote::CmdSpy, @task.stubbed_ssh
+      assert_true @task.stubbed_ssh.run_called?
+    end
+
+  end
+
+  class DTRTreeRunnerSystemTests < DryTreeRunSystemTests
+    desc "TreeRunner"
+    setup do
+      @runner = Dk::TreeRunner.new(@dk_config, StringIO.new)
+
+      stub_cmd_str = [
+        @params['stubbed_cmd_str'],
+        proc{ params['stubbed_cmd_str']}
+      ].sample
+
+      # stub a cmd/ssh using `dry_tree_run` so we can test that the stub takes
+      # precedence over the `dry_tree_run` opt
+      @runner.stub_cmd(stub_cmd_str, {
+        :opts => { :dry_tree_run => true }
+      }) do |s|
+        s.stdout = Factory.string
+      end
+      @runner.stub_ssh(stub_cmd_str, {
+        :opts => { :dry_tree_run => true }
+      }) do |s|
+        s.stdout = Factory.string
+      end
+
+      @task = @runner.run(@task_class, @params)
+    end
+    subject{ @task }
+
+    should "not spy cmds that use the `dry_tree_run` opt" do
+      # scmd is in test mode so we can test its spy and see if it was run
+      # called; if scmd was run then as far as dk is concerned it ran the cmd
+      assert_instance_of Dk::Local::Cmd, @task.dry_tree_run_cmd
+      assert_true @task.dry_tree_run_cmd.scmd.run_called?
+      # check that the first local cmd of the remote cmd was run
+      assert_instance_of Dk::Remote::Cmd, @task.dry_tree_run_ssh
+      assert_true @task.dry_tree_run_ssh.local_cmds.values.first.scmd.start_called?
+    end
+
+    should "spy cmds that don't use the `dry_tree_run` opt" do
+      assert_instance_of Dk::Local::CmdSpy, @task.regular_cmd
+      assert_true @task.regular_cmd.run_called?
+      assert_instance_of Dk::Remote::CmdSpy, @task.regular_ssh
+      assert_true @task.regular_ssh.run_called?
+    end
+
+    should "spy cmds that are stubbed and use the `dry_tree_run` opt" do
+      assert_instance_of Dk::Local::CmdSpy, @task.stubbed_cmd
+      assert_true @task.stubbed_cmd.run_called?
+      assert_instance_of Dk::Remote::CmdSpy, @task.stubbed_ssh
+      assert_true @task.stubbed_ssh.run_called?
+    end
+
+  end
+
+  class DTRTestRunnerSystemTests < DryTreeRunSystemTests
+    desc "TestRunner"
+    setup do
+      @runner = Dk::TestRunner.new(:logger => @logger)
+      @runner.task_class = @task_class
+
+      # stub a cmd/ssh using `dry_tree_run` so we can test that the stub takes
+      # precedence over the `dry_tree_run` opt
+      @runner.stub_cmd(@params['stubbed_cmd_str'], :dry_tree_run => true) do |s|
+        s.stdout = Factory.string
+      end
+      @runner.stub_ssh(@params['stubbed_cmd_str'], :dry_tree_run => true) do |s|
+        s.stdout = Factory.string
+      end
+
+      @task = @runner.run(@params)
+    end
+    subject{ @task }
+
+    should "spy all cmds/ssh regardless of the `dry_tree_run` opt" do
+      assert_instance_of Dk::Local::CmdSpy, @task.dry_tree_run_cmd
+      assert_true @task.dry_tree_run_cmd.run_called?
+      assert_instance_of Dk::Local::CmdSpy, @task.regular_cmd
+      assert_true @task.regular_cmd.run_called?
+      assert_instance_of Dk::Local::CmdSpy, @task.stubbed_cmd
+      assert_true @task.stubbed_cmd.run_called?
+
+      assert_instance_of Dk::Remote::CmdSpy, @task.dry_tree_run_ssh
+      assert_true @task.dry_tree_run_cmd.run_called?
+      assert_instance_of Dk::Remote::CmdSpy, @task.regular_ssh
+      assert_true @task.regular_ssh.run_called?
+      assert_instance_of Dk::Remote::CmdSpy, @task.stubbed_ssh
+      assert_true @task.stubbed_ssh.run_called?
+    end
+
+  end
+
+end

data/test/unit/ansi_tests.rb

@@ -0,0 +1,40 @@
+require 'assert'
+require 'dk/ansi'
+
+module Dk::Ansi
+
+  class UnitTests < Assert::Context
+    desc "Dk::Ansi"
+    subject{ Dk::Ansi }
+
+    should have_imeths :styled_msg, :code_for
+
+    should "know its codes" do
+      assert_not_empty subject::CODES
+    end
+
+    should "map its code style names to ansi code strings" do
+      styles = Factory.integer(3).times.map{ subject::CODES.keys.sample }
+      exp = styles.map{ |n| "\e[#{subject::CODES[n]}m" }.join('')
+      assert_equal exp, subject.code_for(*styles)
+
+      styles = Factory.integer(3).times.map{ Factory.string }
+      assert_equal '', subject.code_for(*styles)
+
+      styles = []
+      assert_equal '', subject.code_for(*styles)
+    end
+
+    should "know how to build ansi styled messages" do
+      msg = Factory.string
+      assert_equal msg, subject.styled_msg(msg)
+
+      styles   = Factory.integer(3).times.map{ subject::CODES.keys.sample }
+      exp_code = subject.code_for(*styles)
+      exp      = exp_code + msg + subject.code_for(:reset)
+      assert_equal exp, subject.styled_msg(msg, *styles)
+    end
+
+  end
+
+end