dk 0.0.1 → 0.1.0

data/test/unit/config_tests.rb

@@ -0,0 +1,427 @@
+require 'assert'
+require 'dk/config'
+
+require 'logsly'
+require 'dk/has_set_param'
+require 'dk/has_ssh_opts'
+require 'dk/task'
+
+class Dk::Config
+
+  class UnitTests < Assert::Context
+    desc "Dk::Config"
+    setup do
+      @config_class = Dk::Config
+    end
+    subject{ @config_class }
+
+    should "include HasSetParam" do
+      assert_includes Dk::HasSetParam, subject
+    end
+
+    should "include HasSSHOpts" do
+      assert_includes Dk::HasSSHOpts, subject
+    end
+
+    should "know its defaults" do
+      assert_equal Array.new,          subject::DEFAULT_INIT_PROCS
+      assert_equal Hash.new,           subject::DEFAULT_PARAMS
+      assert_equal Hash.new,           subject::DEFAULT_CALLBACKS
+      assert_equal Hash.new,           subject::DEFAULT_SSH_HOSTS
+      assert_equal '',                 subject::DEFAULT_SSH_ARGS
+      assert_equal Hash.new,           subject::DEFAULT_HOST_SSH_ARGS
+      assert_equal Hash.new,           subject::DEFAULT_TASKS
+      assert_equal "%m\n",             subject::DEFAULT_LOG_PATTERN
+      assert_equal '[%d %-5l] : %m\n', subject::DEFAULT_LOG_FILE_PATTERN
+      assert_equal 'info',             subject::DEFAULT_STDOUT_LOG_LEVEL
+      assert_equal Array.new,          subject::DEFAULT_STUBS
+    end
+
+    should "know the file output log level" do
+      assert_equal 'debug', subject::FILE_LOG_LEVEL
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @config = @config_class.new
+    end
+    subject{ @config }
+
+    should have_readers :init_procs, :params
+    should have_readers :before_callbacks, :prepend_before_callbacks
+    should have_readers :after_callbacks, :prepend_after_callbacks
+    should have_readers :tasks, :dry_tree_cmd_stubs, :dry_tree_ssh_stubs
+    should have_imeths :init
+    should have_imeths :before, :prepend_before, :after, :prepend_after
+    should have_imeths :before_callback_task_classes
+    should have_imeths :prepend_before_callback_task_classes
+    should have_imeths :after_callback_task_classes
+    should have_imeths :prepend_after_callback_task_classes
+    should have_imeths :task, :stdout_log_level
+    should have_imeths :log_pattern, :log_file, :log_file_pattern
+    should have_imeths :stub_dry_tree_cmd, :stub_dry_tree_ssh
+    should have_imeths :dk_logger_stdout_output_name, :dk_logger_file_output_name
+    should have_imeths :dk_logger
+
+    should "default its attrs" do
+      assert_equal @config_class::DEFAULT_INIT_PROCS,       subject.init_procs
+      assert_equal @config_class::DEFAULT_PARAMS,           subject.params
+      assert_equal @config_class::DEFAULT_CALLBACKS,        subject.before_callbacks
+      assert_equal @config_class::DEFAULT_CALLBACKS,        subject.prepend_before_callbacks
+      assert_equal @config_class::DEFAULT_CALLBACKS,        subject.after_callbacks
+      assert_equal @config_class::DEFAULT_CALLBACKS,        subject.prepend_after_callbacks
+      assert_equal @config_class::DEFAULT_SSH_HOSTS,        subject.ssh_hosts
+      assert_equal @config_class::DEFAULT_SSH_ARGS,         subject.ssh_args
+      assert_equal @config_class::DEFAULT_HOST_SSH_ARGS,    subject.host_ssh_args
+      assert_equal @config_class::DEFAULT_TASKS,            subject.tasks
+      assert_equal @config_class::DEFAULT_STDOUT_LOG_LEVEL, subject.stdout_log_level
+      assert_equal @config_class::DEFAULT_LOG_PATTERN,      subject.log_pattern
+      assert_equal @config_class::DEFAULT_LOG_FILE_PATTERN, subject.log_file_pattern
+      assert_equal @config_class::DEFAULT_STUBS,            subject.dry_tree_cmd_stubs
+      assert_equal @config_class::DEFAULT_STUBS,            subject.dry_tree_ssh_stubs
+
+      assert_nil subject.log_file
+    end
+
+    should "instance eval its init procs on init" do
+      init_self = nil
+      subject.init_procs << proc{ init_self = self }
+
+      subject.init
+      assert_equal @config, init_self
+    end
+
+    should "append callback tasks to other tasks" do
+      subj_task_class  = Class.new{ include Dk::Task }
+      other_task_class = Factory.string
+      cb_task_class    = Factory.string
+      cb_params        = Factory.string
+
+      subject.before(subj_task_class, other_task_class)
+      subject.before(subj_task_class, cb_task_class, cb_params)
+
+      cb = subject.before_callbacks[subj_task_class].last
+      assert_equal cb_task_class, cb.task_class
+      assert_equal cb_params,     cb.params
+
+      subject.after(subj_task_class, other_task_class)
+      subject.after(subj_task_class, cb_task_class, cb_params)
+
+      cb = subject.after_callbacks[subj_task_class].last
+      assert_equal cb_task_class, cb.task_class
+      assert_equal cb_params,     cb.params
+
+      exp = [other_task_class, cb_task_class]
+      assert_equal exp, subject.before_callback_task_classes(subj_task_class)
+      assert_equal exp, subject.after_callback_task_classes(subj_task_class)
+    end
+
+    should "prepend callback tasks to other tasks" do
+      subj_task_class  = Class.new{ include Dk::Task }
+      other_task_class = Factory.string
+      cb_task_class    = Factory.string
+      cb_params        = Factory.string
+
+      subject.prepend_before(subj_task_class, other_task_class)
+      subject.prepend_before(subj_task_class, cb_task_class, cb_params)
+
+      cb = subject.prepend_before_callbacks[subj_task_class].first
+      assert_equal cb_task_class, cb.task_class
+      assert_equal cb_params,     cb.params
+
+      subject.prepend_after(subj_task_class, other_task_class)
+      subject.prepend_after(subj_task_class, cb_task_class, cb_params)
+
+      cb = subject.prepend_after_callbacks[subj_task_class].first
+      assert_equal cb_task_class, cb.task_class
+      assert_equal cb_params,     cb.params
+
+      exp = [other_task_class, cb_task_class].reverse
+      assert_equal exp, subject.prepend_before_callback_task_classes(subj_task_class)
+      assert_equal exp, subject.prepend_after_callback_task_classes(subj_task_class)
+    end
+
+    should "not duplicate callback tasks if they've already been added" do
+      subj_task_class  = Class.new{ include Dk::Task }
+      other_task_class = Factory.string
+      cb_task_class    = Factory.string
+      cb_params        = Factory.string
+
+      subject.before(subj_task_class, other_task_class)
+      subject.before(subj_task_class, other_task_class)
+      assert_equal 1, subject.before_callbacks[subj_task_class].size
+
+      subject.before(subj_task_class, cb_task_class, cb_params)
+      subject.before(subj_task_class, cb_task_class, cb_params)
+      assert_equal 2, subject.before_callbacks[subj_task_class].size
+
+      subject.after(subj_task_class, other_task_class)
+      subject.after(subj_task_class, other_task_class)
+      assert_equal 1, subject.after_callbacks[subj_task_class].size
+
+      subject.after(subj_task_class, cb_task_class, cb_params)
+      subject.after(subj_task_class, cb_task_class, cb_params)
+      assert_equal 2, subject.after_callbacks[subj_task_class].size
+
+      subject.prepend_before(subj_task_class, other_task_class)
+      subject.prepend_before(subj_task_class, other_task_class)
+      assert_equal 1, subject.prepend_before_callbacks[subj_task_class].size
+
+      subject.prepend_before(subj_task_class, cb_task_class, cb_params)
+      subject.prepend_before(subj_task_class, cb_task_class, cb_params)
+      assert_equal 2, subject.prepend_before_callbacks[subj_task_class].size
+
+      subject.prepend_after(subj_task_class, other_task_class)
+      subject.prepend_after(subj_task_class, other_task_class)
+      assert_equal 1, subject.prepend_after_callbacks[subj_task_class].size
+
+      subject.prepend_after(subj_task_class, cb_task_class, cb_params)
+      subject.prepend_after(subj_task_class, cb_task_class, cb_params)
+      assert_equal 2, subject.prepend_after_callbacks[subj_task_class].size
+    end
+
+    should "add callable tasks" do
+      assert_empty subject.tasks
+
+      task_name  = Factory.string
+      task_class = Class.new{ include Dk::Task }
+      subject.task(task_name, task_class)
+
+      assert_equal task_class, subject.task(task_name)
+    end
+
+    should "complain when adding a callable task that isn't a Dk::Task" do
+      assert_raises(ArgumentError) do
+        subject.task(Factory.string, Factory.string)
+      end
+      assert_raises(ArgumentError) do
+        subject.task(Factory.string, Class.new)
+      end
+    end
+
+    should "complain when looking up a named task that hasn't been configured" do
+      assert_raises(UnknownTaskError) do
+        subject.task(Factory.string)
+      end
+    end
+
+    should "know its stdout log level" do
+      level = Factory.string
+
+      assert_equal @config_class::DEFAULT_STDOUT_LOG_LEVEL, subject.stdout_log_level
+      assert_equal level, subject.stdout_log_level(level)
+      assert_equal level, subject.stdout_log_level
+    end
+
+    should "know its log pattern" do
+      pattern = Factory.string
+
+      assert_equal @config_class::DEFAULT_LOG_PATTERN, subject.log_pattern
+      assert_equal pattern, subject.log_pattern(pattern)
+      assert_equal pattern, subject.log_pattern
+    end
+
+    should "know its log file" do
+      file = Factory.file_path
+
+      assert_nil subject.log_file
+      assert_equal file, subject.log_file(file)
+      assert_equal file, subject.log_file
+    end
+
+    should "know its log file pattern" do
+      pattern = Factory.string
+
+      assert_equal @config_class::DEFAULT_LOG_FILE_PATTERN, subject.log_file_pattern
+      assert_equal pattern, subject.log_file_pattern(pattern)
+      assert_equal pattern, subject.log_file_pattern
+    end
+
+    should "know its logger output names" do
+      exp = "dk-config-#{subject.object_id}-stdout"
+      assert_equal exp, subject.dk_logger_stdout_output_name
+
+      exp = "dk-config-#{subject.object_id}-file"
+      assert_equal exp, subject.dk_logger_file_output_name
+    end
+
+    should "know its logger" do
+      logger = subject.dk_logger
+
+      assert_instance_of LogslyLogger, logger
+      assert_equal subject, logger.config
+    end
+
+  end
+
+  class DryTreeStubsTests < InitTests
+    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
+    end
+
+    should "allow adding dry tree runner cmd stubs" do
+      assert_equal 0, subject.dry_tree_cmd_stubs.size
+
+      cmd_str    = get_raw_value(@cmd_str)
+      input      = get_raw_value(@input)
+      given_opts = get_raw_value(@given_opts)
+
+      subject.stub_dry_tree_cmd(@cmd_str, &@stub_block)
+      assert_equal 1, subject.dry_tree_cmd_stubs.size
+      assert_equal @stub_block, lookup_cmd_stub_block(cmd_str, nil, nil)
+
+      subject.stub_dry_tree_cmd(@cmd_str, :input => @input, &@stub_block)
+      assert_equal 2, subject.dry_tree_cmd_stubs.size
+      assert_equal @stub_block, lookup_cmd_stub_block(cmd_str, input, nil)
+
+      subject.stub_dry_tree_cmd(@cmd_str, :opts => @given_opts, &@stub_block)
+      assert_equal 3, subject.dry_tree_cmd_stubs.size
+      assert_equal @stub_block, lookup_cmd_stub_block(cmd_str, nil, given_opts)
+
+      subject.stub_dry_tree_cmd(@cmd_str, {
+        :input => @input,
+        :opts  => @given_opts
+      }, &@stub_block)
+      assert_equal 4, subject.dry_tree_cmd_stubs.size
+      assert_equal @stub_block, lookup_cmd_stub_block(cmd_str, input, given_opts)
+    end
+
+    should "allow adding dry tree runner ssh stubs" do
+      assert_equal 0, subject.dry_tree_ssh_stubs.size
+
+      cmd_str    = get_raw_value(@cmd_str)
+      input      = get_raw_value(@input)
+      given_opts = get_raw_value(@given_opts)
+
+      subject.stub_dry_tree_ssh(@cmd_str, &@stub_block)
+      assert_equal 1, subject.dry_tree_ssh_stubs.size
+      assert_equal @stub_block, lookup_ssh_stub_block(cmd_str, nil, nil)
+
+      subject.stub_dry_tree_ssh(@cmd_str, :input => @input, &@stub_block)
+      assert_equal 2, subject.dry_tree_ssh_stubs.size
+      assert_equal @stub_block, lookup_ssh_stub_block(cmd_str, input, nil)
+
+      subject.stub_dry_tree_ssh(@cmd_str, :opts => @given_opts, &@stub_block)
+      assert_equal 3, subject.dry_tree_ssh_stubs.size
+      assert_equal @stub_block, lookup_ssh_stub_block(cmd_str, nil, given_opts)
+
+      subject.stub_dry_tree_ssh(@cmd_str, {
+        :input => @input,
+        :opts  => @given_opts
+      }, &@stub_block)
+      assert_equal 4, subject.dry_tree_ssh_stubs.size
+      assert_equal @stub_block, lookup_ssh_stub_block(cmd_str, input, given_opts)
+    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)
+      stubs = @config.dry_tree_cmd_stubs
+      find_cmd_ssh_stub_block(stubs, @task, cmd_str, input, given_opts)
+    end
+
+    def lookup_ssh_stub_block(cmd_str, input, given_opts)
+      stubs = @config.dry_tree_ssh_stubs
+      find_cmd_ssh_stub_block(stubs, @task, cmd_str, input, given_opts)
+    end
+
+    def find_cmd_ssh_stub_block(stubs, task, cmd_str, input, given_opts)
+      stub = stubs.find do |stub|
+        task.instance_eval(&stub.cmd_str_proc)    == cmd_str    &&
+        task.instance_eval(&stub.input_proc)      == input      &&
+        task.instance_eval(&stub.given_opts_proc) == given_opts
+      end
+      stub ? stub.block : nil
+    end
+
+  end
+
+  class LogslyLoggerTests < UnitTests
+    desc "LogslyLogger"
+    setup do
+      @logger_class = LogslyLogger
+    end
+    subject{ @logger_class }
+
+    should "be a logsly logger and know its log type" do
+      assert_includes Logsly, subject
+      assert_equal 'dk', subject::LOG_TYPE
+    end
+
+  end
+
+  class LogslyLoggerInitTests < LogslyLoggerTests
+    desc "when init"
+    setup do
+      @config = @config_class.new
+      @logger = @logger_class.new(@config)
+    end
+    subject{ @logger }
+
+    should "know its log type" do
+      assert_equal @logger_class::LOG_TYPE, subject.log_type
+    end
+
+    should "have only a logsly stdout output" do
+      assert_equal 1, subject.outputs.size
+      assert_equal @config.dk_logger_stdout_output_name, subject.outputs.first
+
+      out = Logsly.outputs(@config.dk_logger_stdout_output_name)
+      assert_instance_of Logsly::Outputs::Stdout, out
+
+      data = out.data(subject)
+      assert_equal @config.stdout_log_level, data.level
+      assert_equal @config.log_pattern,      data.pattern
+    end
+
+  end
+
+  class LogslyLoggerInitWithLogFileTests < LogslyLoggerInitTests
+    desc "with a log file"
+    setup do
+      @config.log_file Factory.log_file
+      @logger = @logger_class.new(@config)
+    end
+    teardown do
+      @config.log_file.delete
+    end
+
+    should "have a logsly file output in addition to the stdout output" do
+      assert_equal 2, subject.outputs.size
+      assert_equal @config.dk_logger_stdout_output_name, subject.outputs.first
+      assert_equal @config.dk_logger_file_output_name,   subject.outputs.last
+
+      out = Logsly.outputs(@config.dk_logger_file_output_name)
+      assert_instance_of Logsly::Outputs::File, out
+
+      data = out.data(subject)
+      exp = File.expand_path(@config.log_file, ENV['PWD'])
+      assert_equal exp, data.path
+      assert_equal @config_class::FILE_LOG_LEVEL, data.level
+      assert_equal @config.log_file_pattern,      data.pattern
+    end
+
+  end
+
+end

data/test/unit/dk_runner_tests.rb

@@ -0,0 +1,34 @@
+require 'assert'
+require 'dk/dk_runner'
+
+require 'dk/config_runner'
+
+class Dk::DkRunner
+
+  class UnitTests < Assert::Context
+    desc "Dk::DkRunner"
+    setup do
+      @runner_class = Dk::DkRunner
+    end
+    subject{ @runner_class }
+
+    should "be a Dk::ConfigRunner" do
+      assert_true subject < Dk::ConfigRunner
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @config = Dk::Config.new
+    end
+
+    should "be init with a config instance" do
+      assert_nothing_raised{ @runner_class.new(@config) }
+      assert_raises(ArgumentError){ @runner_class.new }
+    end
+
+  end
+
+end

data/test/unit/dk_tests.rb

@@ -0,0 +1,49 @@
+require 'assert'
+require 'dk'
+
+require 'dk/config'
+
+module Dk
+
+  class UnitTests < Assert::Context
+    desc "Dk"
+    setup do
+      @dk_module = Dk
+    end
+    subject{ @dk_module }
+
+    should have_imeths :config, :configure, :init, :reset
+
+    should "know its config" do
+      assert_instance_of Config, subject.config
+    end
+
+    should "add init procs to its config on `configure`" do
+      assert_equal [], subject.config.init_procs
+
+      init_block = proc{}
+      subject.configure(&init_block)
+
+      assert_equal [init_block], subject.config.init_procs
+    end
+
+    should "instance eval its init procs on init" do
+      config_init_called = false
+      Assert.stub(subject.config, :init){ config_init_called = true }
+
+      subject.init
+      assert_true config_init_called
+    end
+
+    should "reset itself by rewriting the config with a new instance" do
+      config_obj_id = subject.config.object_id
+      subject.init
+      assert_equal config_obj_id, subject.config.object_id
+
+      subject.reset
+      assert_not_equal config_obj_id, subject.config.object_id
+    end
+
+  end
+
+end

data/test/unit/dry_runner_tests.rb

@@ -0,0 +1,71 @@
+require 'assert'
+require 'dk/dry_runner'
+
+require 'dk/config'
+require 'dk/config_runner'
+require 'dk/has_the_stubs'
+
+class Dk::DryRunner
+
+  class UnitTests < Assert::Context
+    desc "Dk::DryRunner"
+    setup do
+      @runner_class = Dk::DryRunner
+    end
+    subject{ @runner_class }
+
+    should "be a Dk::ConfigRunner" do
+      assert_true subject < Dk::ConfigRunner
+    end
+
+    should "have the stubs" do
+      assert_includes Dk::HasTheStubs, subject
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @dk_config = Dk::Config.new
+      Factory.integer(3).times.each do
+        @dk_config.stub_dry_tree_cmd(Factory.string, {
+          :input => Factory.string,
+          :opts  => { Factory.string => Factory.string }
+        }){ |s| Factory.string }
+      end
+      Factory.integer(3).times.each do
+        @dk_config.stub_dry_tree_ssh(Factory.string, {
+          :input => Factory.string,
+          :opts  => { Factory.string => Factory.string }
+        }){ |s| Factory.string }
+      end
+
+      @runner = @runner_class.new(@dk_config)
+    end
+    subject{ @runner }
+
+    should "add cmd/ssh dry tree stubs from its config" do
+      @dk_config.dry_tree_cmd_stubs.each do |stub|
+        exp = Dk::HasTheStubs::Stub.new(
+          stub.cmd_str_proc,
+          stub.input_proc,
+          stub.given_opts_proc,
+          stub.block
+        )
+        assert_includes exp, @runner.local_cmd_stubs
+      end
+      @dk_config.dry_tree_ssh_stubs.each do |stub|
+        exp = Dk::HasTheStubs::Stub.new(
+          stub.cmd_str_proc,
+          stub.input_proc,
+          stub.given_opts_proc,
+          stub.block
+        )
+        assert_includes exp, @runner.remote_cmd_stubs
+      end
+    end
+
+  end
+
+end

data/test/unit/has_set_param_tests.rb

@@ -0,0 +1,46 @@
+require 'assert'
+require 'dk/has_set_param'
+
+require 'much-plugin'
+
+module Dk::HasSetParam
+
+  class UnitTests < Assert::Context
+    desc "Dk::HasSetParam"
+    setup do
+      @mixin_class = Dk::HasSetParam
+
+      @params_class = Class.new do
+        include Dk::HasSetParam
+        attr_reader :params
+        def initialize; @params = {}; end
+      end
+    end
+    subject{ @params_class }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @params = @params_class.new
+    end
+    subject{ @params }
+
+    should have_imeths :set_param
+
+    should "stringify and set param values with `set_param`" do
+      key, value = Factory.string.to_sym, Factory.string
+      subject.set_param(key, value)
+
+      assert_equal value, subject.params[key.to_s]
+      assert_nil subject.params[key]
+    end
+
+  end
+
+end

data/test/unit/has_ssh_opts_tests.rb

@@ -0,0 +1,81 @@
+require 'assert'
+require 'dk/has_ssh_opts'
+
+require 'much-plugin'
+require 'dk/config'
+
+module Dk::HasSSHOpts
+
+  class UnitTests < Assert::Context
+    desc "Dk::HasSSHOpts"
+    setup do
+      @mixin_class = Dk::HasSSHOpts
+
+      @opts_class = Class.new do
+        include Dk::HasSSHOpts
+        def initialize
+          @ssh_hosts     = Dk::Config::DEFAULT_SSH_HOSTS.dup
+          @ssh_args      = Dk::Config::DEFAULT_SSH_ARGS.dup
+          @host_ssh_args = Dk::Config::DEFAULT_HOST_SSH_ARGS.dup
+        end
+      end
+    end
+    subject{ @opts_class }
+
+    should "use much-plugin" do
+      assert_includes MuchPlugin, subject
+    end
+
+  end
+
+  class InitTests < UnitTests
+    desc "when init"
+    setup do
+      @opts = @opts_class.new
+    end
+    subject{ @opts }
+
+    should have_imeths :ssh_hosts, :ssh_args, :host_ssh_args
+
+    should "know its ssh hosts" do
+      group_name = Factory.string
+      hosts      = Factory.hosts
+
+      assert_equal Dk::Config::DEFAULT_SSH_HOSTS, subject.ssh_hosts
+      assert_nil subject.ssh_hosts(group_name)
+
+      assert_equal hosts, subject.ssh_hosts(group_name, hosts)
+      assert_equal hosts, subject.ssh_hosts(group_name)
+
+      assert_equal hosts, subject.ssh_hosts(group_name, *hosts)
+      assert_equal hosts, subject.ssh_hosts(group_name)
+
+      exp = { group_name => hosts }
+      assert_equal exp, subject.ssh_hosts
+    end
+
+    should "know its ssh args" do
+      args = Factory.string
+
+      assert_equal Dk::Config::DEFAULT_SSH_ARGS, subject.ssh_args
+      assert_equal args, subject.ssh_args(args)
+      assert_equal args, subject.ssh_args
+    end
+
+    should "know its host ssh args" do
+      host_name = Factory.string
+      args      = Factory.string
+
+      assert_equal Hash.new, subject.host_ssh_args
+      assert_equal Dk::Config::DEFAULT_SSH_ARGS, subject.host_ssh_args(host_name)
+
+      assert_equal args, subject.host_ssh_args(host_name, args)
+      assert_equal args, subject.host_ssh_args(host_name)
+
+      exp = { host_name => args }
+      assert_equal exp, subject.host_ssh_args
+    end
+
+  end
+
+end