dk 0.0.1 → 0.1.0

data/test/unit/has_the_runs_tests.rb

@@ -0,0 +1,37 @@
+require 'assert'
+require 'dk/has_the_runs'
+
+require 'much-plugin'
+
+module Dk::HasTheRuns
+
+  class UnitTests < Assert::Context
+    desc "Dk::HasTheRuns"
+    setup do
+      @mixin_class = Dk::HasTheRuns
+      @runs_class  = Class.new{ include Dk::HasTheRuns }
+    end
+    subject{ @mixin_class }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @runs = @runs_class.new
+    end
+    subject{ @runs }
+
+    should have_imeths :runs
+
+    should "have no runs by default" do
+      assert_equal [], subject.runs
+    end
+
+  end
+
+end

data/test/unit/has_the_stubs_tests.rb

@@ -0,0 +1,279 @@
+require 'assert'
+require 'dk/has_the_stubs'
+
+require 'dk/local'
+require 'dk/remote'
+
+module Dk::HasTheStubs
+
+  class UnitTests < Assert::Context
+    desc "Dk::HasTheStubs"
+    setup do
+      @module = Dk::HasTheStubs
+    end
+    subject{ @module }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+  end
+
+  class MixinTests < UnitTests
+    desc "mixed in"
+    setup do
+      @class = Class.new do
+        include Dk::HasTheStubs
+
+        def has_the_stubs_build_local_cmd(cmd_str, given_opts)
+          BuiltCmd.new(cmd_str, given_opts)
+        end
+
+        def has_the_stubs_build_remote_cmd(cmd_str, ssh_opts)
+          BuiltCmd.new(cmd_str, ssh_opts)
+        end
+      end
+    end
+    subject{ @class }
+
+  end
+
+  class InitTests < MixinTests
+    desc "when init"
+    setup do
+      raw_cmd_str    = Factory.string
+      raw_input      = Factory.string
+      raw_given_opts = { Factory.string => Factory.string }
+
+      @cmd_str    = [raw_cmd_str, proc{ "#{raw_cmd_str},#{some_attr}" }].sample
+      @input      = [raw_input,   proc{ "#{raw_input},#{some_attr}" }].sample
+      @given_opts = [
+        raw_given_opts,
+        proc{ raw_given_opts.merge('some_attr' => some_attr) }
+      ].sample
+      @ssh_opts   = { :hosts => Factory.hosts }
+      @stub_block = Proc.new{ |s| Factory.string }
+
+      task_class = Class.new{ def some_attr; @some_attr ||= Factory.string; end }
+      @task      = task_class.new
+      @instance  = @class.new
+    end
+    subject{ @instance }
+
+    should have_imeths :local_cmd_stubs, :stub_cmd, :unstub_all_cmds
+    should have_imeths :remote_cmd_stubs, :stub_ssh, :unstub_all_ssh
+
+    should "allow stubbing cmds" do
+      assert_equal 0, subject.local_cmd_stubs.size
+
+      cmd_str    = get_raw_value(@cmd_str)
+      input      = get_raw_value(@input)
+      given_opts = get_raw_value(@given_opts)
+
+      subject.stub_cmd(@cmd_str, &@stub_block)
+      assert_equal 1, subject.local_cmd_stubs.size
+      assert_equal @stub_block, lookup_cmd_stub_block(cmd_str, nil, nil)
+
+      subject.stub_cmd(@cmd_str, :input => @input, &@stub_block)
+      assert_equal 2, subject.local_cmd_stubs.size
+      assert_equal @stub_block, lookup_cmd_stub_block(cmd_str, input, nil)
+
+      subject.stub_cmd(@cmd_str, :opts => @given_opts, &@stub_block)
+      assert_equal 3, subject.local_cmd_stubs.size
+      assert_equal @stub_block, lookup_cmd_stub_block(cmd_str, nil, given_opts)
+
+      subject.stub_cmd(@cmd_str, {
+        :input => @input,
+        :opts  => @given_opts
+      }, &@stub_block)
+      assert_equal 4, subject.local_cmd_stubs.size
+      assert_equal @stub_block, lookup_cmd_stub_block(cmd_str, input, given_opts)
+    end
+
+    should "allow unstubbing all cmds" do
+      subject.stub_cmd(@cmd_str, &@stub_block)
+      subject.stub_cmd(@cmd_str, :input => @input, &@stub_block)
+      subject.stub_cmd(@cmd_str, :opts  => @given_opts, &@stub_block)
+      subject.stub_cmd(@cmd_str, {
+        :input => @input,
+        :opts  => @given_opts
+      }, &@stub_block)
+
+      assert_equal 4, subject.local_cmd_stubs.size
+      subject.unstub_all_cmds
+      assert_equal 0, subject.local_cmd_stubs.size
+    end
+
+    should "allow stubbing ssh" do
+      assert_equal 0, subject.remote_cmd_stubs.size
+
+      cmd_str    = get_raw_value(@cmd_str)
+      input      = get_raw_value(@input)
+      given_opts = get_raw_value(@given_opts)
+
+      subject.stub_ssh(@cmd_str, &@stub_block)
+      assert_equal 1, subject.remote_cmd_stubs.size
+      assert_equal @stub_block, lookup_ssh_stub_block(cmd_str, nil, nil)
+
+      subject.stub_ssh(@cmd_str, :input => @input, &@stub_block)
+      assert_equal 2, subject.remote_cmd_stubs.size
+      assert_equal @stub_block, lookup_ssh_stub_block(cmd_str, input, nil)
+
+      subject.stub_ssh(@cmd_str, :opts => @given_opts, &@stub_block)
+      assert_equal 3, subject.remote_cmd_stubs.size
+      assert_equal @stub_block, lookup_ssh_stub_block(cmd_str, nil, given_opts)
+
+      subject.stub_ssh(@cmd_str, {
+        :input => @input,
+        :opts  => @given_opts
+      }, &@stub_block)
+      assert_equal 4, subject.remote_cmd_stubs.size
+      assert_equal @stub_block, lookup_ssh_stub_block(cmd_str, input, given_opts)
+    end
+
+    should "allow unstubbing all ssh" do
+      subject.stub_ssh(@cmd_str, &@stub_block)
+      subject.stub_ssh(@cmd_str, :input => @input, &@stub_block)
+      subject.stub_ssh(@cmd_str, :opts  => @given_opts, &@stub_block)
+      subject.stub_ssh(@cmd_str, {
+        :input => @input,
+        :opts  => @given_opts
+      }, &@stub_block)
+
+      assert_equal 4, subject.remote_cmd_stubs.size
+      subject.unstub_all_ssh
+      assert_equal 0, subject.remote_cmd_stubs.size
+    end
+
+    # test the `Runner` interface that this overwrites, these are private
+    # methods but since they overwrite the runner's interface we want to test
+    # them as if they were public methods
+
+    should "use stubs with `build_local_cmd`" do
+      task       = @task
+      cmd_str    = get_raw_value(@cmd_str)
+      input      = get_raw_value(@input)
+      given_opts = get_raw_value(@given_opts)
+
+      subject.stub_cmd(@cmd_str){ |s| s.exitstatus = 1 }
+      spy = subject.instance_eval do
+        build_local_cmd(task, cmd_str, nil, nil)
+      end
+      assert_false spy.success?
+
+      subject.unstub_all_cmds
+      subject.stub_cmd(@cmd_str, :input => @input){ |s| s.exitstatus = 1 }
+      spy = subject.instance_eval do
+        build_local_cmd(task, cmd_str, input, nil)
+      end
+      assert_false spy.success?
+
+      subject.unstub_all_cmds
+      subject.stub_cmd(@cmd_str, :opts => @given_opts){ |s| s.exitstatus = 1 }
+      spy = subject.instance_eval do
+        build_local_cmd(task, cmd_str, nil, given_opts)
+      end
+      assert_false spy.success?
+
+      subject.unstub_all_cmds
+      subject.stub_cmd(@cmd_str, {
+        :input => @input,
+        :opts  => @given_opts
+      }){ |s| s.exitstatus = 1 }
+      spy = subject.instance_eval do
+        build_local_cmd(task, cmd_str, input, given_opts)
+      end
+      assert_false spy.success?
+    end
+
+    should "defer to `has_the_stubs_build_local_cmd` when cmd isn't stubbed" do
+      task       = @task
+      cmd_str    = get_raw_value(@cmd_str)
+      input      = get_raw_value(@input)
+      given_opts = get_raw_value(@given_opts)
+
+      result = subject.instance_eval do
+        build_local_cmd(task, cmd_str, input, given_opts)
+      end
+      assert_equal BuiltCmd.new(cmd_str, given_opts), result
+    end
+
+    should "use stubs with `build_remote_cmd`" do
+      task       = @task
+      cmd_str    = get_raw_value(@cmd_str)
+      input      = get_raw_value(@input)
+      given_opts = get_raw_value(@given_opts)
+      ssh_opts   = @ssh_opts
+
+      subject.stub_ssh(@cmd_str){ |s| s.exitstatus = 1 }
+      spy = subject.instance_eval do
+        build_remote_cmd(task, cmd_str, nil, nil, ssh_opts)
+      end
+      assert_false spy.success?
+
+      subject.unstub_all_ssh
+      subject.stub_ssh(@cmd_str, :input => @input){ |s| s.exitstatus = 1 }
+      spy = subject.instance_eval do
+        build_remote_cmd(task, cmd_str, input, nil, ssh_opts)
+      end
+      assert_false spy.success?
+
+      subject.unstub_all_ssh
+      subject.stub_ssh(@cmd_str, :opts => @given_opts){ |s| s.exitstatus = 1 }
+      spy = subject.instance_eval do
+        build_remote_cmd(task, cmd_str, nil, given_opts, ssh_opts)
+      end
+      assert_false spy.success?
+
+      subject.unstub_all_ssh
+      subject.stub_ssh(@cmd_str, {
+        :input => @input,
+        :opts  => @given_opts
+      }){ |s| s.exitstatus = 1 }
+      spy = subject.instance_eval do
+        build_remote_cmd(task, cmd_str, input, given_opts, ssh_opts)
+      end
+      assert_false spy.success?
+    end
+
+    should "defer to `has_the_stubs_build_remote_cmd` when cmd isn't stubbed" do
+      task       = @task
+      cmd_str    = get_raw_value(@cmd_str)
+      input      = get_raw_value(@input)
+      given_opts = get_raw_value(@given_opts)
+      ssh_opts   = @ssh_opts
+
+      result = subject.instance_eval do
+        build_remote_cmd(task, cmd_str, input, given_opts, ssh_opts)
+      end
+      assert_equal BuiltCmd.new(cmd_str, ssh_opts), result
+    end
+
+    private
+
+    def get_raw_value(value)
+      value.kind_of?(::Proc) ? @task.instance_eval(&value) : value
+    end
+
+    def lookup_cmd_stub_block(cmd_str, input, given_opts)
+      instance = subject
+      task     = @task
+      subject.instance_eval do
+        find_cmd_ssh_stub_block(instance.local_cmd_stubs, task, cmd_str, input, given_opts)
+      end
+    end
+
+    def lookup_ssh_stub_block(cmd_str, input, given_opts)
+      instance = subject
+      task     = @task
+      subject.instance_eval do
+        find_cmd_ssh_stub_block(instance.remote_cmd_stubs, task, cmd_str, input, given_opts)
+      end
+    end
+
+  end
+
+  BuiltCmd = Struct.new(:cmd_str, :opts)
+
+end
+

data/test/unit/local_tests.rb

@@ -0,0 +1,174 @@
+require 'assert'
+require 'dk/local'
+
+require 'scmd/command_spy'
+
+module Dk::Local
+
+  class UnitTests < Assert::Context
+    desc "Dk::Local"
+    setup do
+      @cmd_str  = Factory.string
+      @scmd_spy = Scmd::CommandSpy.new(@cmd_str).tap do |spy|
+        spy.exitstatus = Factory.exitstatus
+        spy.stdout     = [Factory.stdout, nil].sample
+        spy.stderr     = [Factory.stderr, nil].sample
+      end
+
+      @scmd_new_called_with = nil
+      Assert.stub(Scmd, :new) do |*args|
+        @scmd_new_called_with = args
+        @scmd_spy
+      end
+
+      @scmd_cmd_new_called_with = nil
+      Assert.stub(Scmd::Command, :new) do |*args|
+        @scmd_cmd_new_called_with = args
+        @scmd_spy
+      end
+
+      @scmd_spy_new_called_with = nil
+      Assert.stub(Scmd::CommandSpy, :new) do |*args|
+        @scmd_spy_new_called_with = args
+        @scmd_spy
+      end
+    end
+    subject{ @cmd }
+
+  end
+
+  class BaseCmdTests < UnitTests
+    desc "BaseCmd"
+    setup do
+      @cmd_class = Dk::Local::BaseCmd
+      @opts = {
+        :env           => Factory.string,
+        Factory.string => Factory.string
+      }
+
+      @cmd = @cmd_class.new(Scmd, @cmd_str, @opts)
+    end
+
+    should have_readers :scmd, :cmd_str
+    should have_imeths :to_s, :run
+    should have_imeths :stdout, :stderr, :success?, :output_lines
+
+    should "build an scmd with the cmd str and any given :env option" do
+      assert_equal @scmd_spy, subject.scmd
+      assert_equal [@cmd_str, { :env => @opts[:env] }], @scmd_new_called_with
+
+      cmd = @cmd_class.new(Scmd::CommandSpy, @cmd_str, @opts)
+      assert_equal @scmd_spy, cmd.scmd
+      assert_equal [@cmd_str, { :env => @opts[:env] }], @scmd_spy_new_called_with
+    end
+
+    should "know its cmd str" do
+      assert_equal @cmd_str,        subject.cmd_str
+      assert_equal subject.cmd_str, subject.to_s
+    end
+
+    should "demeter its scmd" do
+      assert_false @scmd_spy.run_called?
+      input = Factory.string
+      subject.run(input)
+      assert_true @scmd_spy.run_called?
+      assert_equal input, @scmd_spy.run_calls.last.input
+
+      assert_equal @scmd_spy.stdout,   subject.stdout
+      assert_equal @scmd_spy.stderr,   subject.stderr
+      assert_equal @scmd_spy.success?, subject.success?
+    end
+
+    should "know its output lines" do
+      stdout_lines = subject.stdout.to_s.split("\n")
+      stderr_lines = subject.stderr.to_s.split("\n")
+      output_lines = subject.output_lines
+
+      exp = (stdout_lines + stderr_lines).size
+      assert_equal exp, output_lines.size
+
+      if output_lines.size > 0
+        assert_instance_of BaseCmd::OutputLine, output_lines.sample
+      end
+
+      exp = stdout_lines.size.times.map{ 'stdout' } +
+            stderr_lines.size.times.map{ 'stderr' }
+      assert_equal exp, output_lines.map(&:name)
+
+      exp = stdout_lines + stderr_lines
+      assert_equal exp, output_lines.map(&:line)
+    end
+
+  end
+
+  class CmdTests < UnitTests
+    desc "Cmd"
+    setup do
+      @cmd_class = Dk::Local::Cmd
+      @cmd = @cmd_class.new(@cmd_str)
+    end
+
+    should "build an Scmd with the cmd str and any given options" do
+      assert_equal [@cmd_str, { :env => nil }], @scmd_new_called_with
+
+      opts = { :env => Factory.string }
+      cmd  = @cmd_class.new(@cmd_str, opts)
+      assert_equal [@cmd_str, { :env => opts[:env] }], @scmd_new_called_with
+    end
+
+  end
+
+  class CmdSpyTests < UnitTests
+    desc "CmdSpy"
+    setup do
+      @cmd_class = Dk::Local::CmdSpy
+      @cmd = @cmd_class.new(@cmd_str)
+    end
+
+    should have_readers :cmd_opts
+    should have_imeths :run_input, :stdout=, :stderr=, :exitstatus=
+    should have_imeths :run_calls, :run_called?, :ssh?
+
+    should "build an scmd spy with the cmd str and any given options" do
+      assert_equal [@cmd_str, { :env => nil }], @scmd_spy_new_called_with
+      assert_nil subject.cmd_opts
+
+      opts = { :env => Factory.string }
+      cmd  = @cmd_class.new(@cmd_str, opts)
+      assert_equal [@cmd_str, { :env => opts[:env] }], @scmd_spy_new_called_with
+      assert_equal opts, cmd.cmd_opts
+    end
+
+    should "know the input it was run with" do
+      input = Factory.string
+
+      assert_nil subject.run_input
+      subject.run(input)
+      assert_equal input, subject.run_input
+    end
+
+    should "demeter its scmd spy" do
+      stdout = Factory.stdout
+      subject.stdout = stdout
+      assert_equal stdout, @scmd_spy.stdout
+
+      stderr = Factory.stderr
+      subject.stderr = stderr
+      assert_equal stderr, @scmd_spy.stderr
+
+      exitstatus = Factory.exitstatus
+      subject.exitstatus = exitstatus
+      assert_equal exitstatus, @scmd_spy.exitstatus
+
+      subject.run
+      assert_equal @scmd_spy.run_calls,   subject.run_calls
+      assert_equal @scmd_spy.run_called?, subject.run_called?
+    end
+
+    should "not be ssh" do
+      assert_false subject.ssh?
+    end
+
+  end
+
+end

data/test/unit/null_logger_tests.rb

@@ -0,0 +1,17 @@
+require 'assert'
+require 'dk/null_logger'
+
+class Dk::NullLogger
+
+  class UnitTests < Assert::Context
+    desc "Dk::NullLogger"
+    setup do
+      @null_logger = Dk::NullLogger.new
+    end
+    subject{ @null_logger }
+
+    should have_imeths :info, :debug, :error
+
+  end
+
+end