runssh 0.2.2 → 0.4.0

data/spec/runsshlib/cli_spec.rb

@@ -21,47 +21,18 @@ require 'stringio'
 require 'yaml'
 
 describe "The CLI interface" do
-  # a shortcut to verify the help for print command
-  def match_print
-    @buffer.should match(/Print host configuration/)
-  end
-
-  before(:each) do
-    @buffer = ""
-    $stdout = StringIO.open(@buffer, 'w')
-    $stderr = StringIO.open(@buffer, 'w')
-  end
-
-  describe "when initialized" do
-    it "should display help when run with no arguments" do
-      expect { RunSSHLib::CLI.new([]) }.to exit_normaly
-      @buffer.should match(/Available commands:/)
-    end
-
-    it "should display help when called with help as the only parameter" do
-      expect { RunSSHLib::CLI.new(['help']) }.to exit_normaly
-      @buffer.should match(/Available commands:/)
-    end
-
+  context "argument parser" do
     it "should correctly process the -f argument" do
       cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} print test))
       global_options = cli.instance_variable_get :@global_options
       global_options[:config_file].should eql("#{TMP_FILE}")
-      cli.instance_variable_get(:@c).
-          instance_variable_get(:@config_file).
-          should eql("#{TMP_FILE}")
     end
 
     it "should display version when asked for" do
-      expect { RunSSHLib::CLI.new(['-v'])}.to exit_normaly
-      @buffer.should include(RunSSHLib::Version::STRING)
-    end
-
-    it "should correctly process the `help command` scheme" do
-      expect do
-        RunSSHLib::CLI.new(%w(help print ?))
-      end.to exit_normaly
-      match_print
+      expect {
+        capture(:stdout) { RunSSHLib::CLI.new(['-v']) }
+      }.to exit_normaly
+      @buf.should include(RunSSHLib::Version::STRING)
     end
 
     it "should correctly parse the `?` for completion" do
@@ -71,334 +42,225 @@ describe "The CLI interface" do
 
     it "should raise an error when invoked with invalid command" do
       expect do
-        RunSSHLib::CLI.new(%W(-f #{TMP_FILE} wrong))
-      end.to exit_abnormaly
-      @buffer.should match(/invalid command/)
-    end
-
-    it "should display right message upon older configuration error" do
-      dump_config Hash.new
-      expect do
-        cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} print ?))
+        capture(:stderr) {
+          RunSSHLib::CLI.new(%W(-f #{TMP_FILE} wrong))
+        }
       end.to exit_abnormaly
-      @buffer.should match(/--update-config/)
-      @buffer.should match(/.none/)
+      @buf.should match(/invalid command/)
     end
 
-    describe "with --update_config" do
-      let(:config_v_none) do
-        YAML.load_file(File.join(File.dirname(__FILE__), '..',
-                                 'fixtures', 'runssh_v_none.yml'))
-      end
-
-      it "should accept --update-config as argument" do
-        cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} --update-config))
-      end
-
-      it "should not fail upon initialization if config is of older version" do
-        dump_config config_v_none
-        cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} --update-config))
-      end
-
-      it "should not initialize @config object after initialization" do
-        cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} --update-config))
-        cli.instance_variable_get(:@c).should be_nil
-      end
+    it "displays completions and exit if requested" do
+      import_fixtures
+      capture(:stdout) {
+        RunSSHLib::CLI.new(%W(-f #{TMP_FILE} print ?)).run
+      }
+      @buf.should include("cust1")
+      @buf.should include("cust2")
     end
   end
 
-  describe "main help" do
-    it "should include a description of all subcommands" do
-      expect { RunSSHLib::CLI.new([]) }.to exit_normaly
+  context "help" do
+    it "includes a description of all subcommands" do
+      expect {
+        capture(:stdout) { RunSSHLib::CLI.new([]) }
+      }.to exit_normaly
       RunSSHLib::CLI::COMMAND.each do |subcmd|
-        @buffer.should include("* #{subcmd}")
+        @buf.should include("* #{subcmd}")
       end
     end
   end
 
-  describe "when run" do
-    before(:all) do
-      import_fixtures
+  context "update_config" do
+    before(:each) do
+      dump_config Hash.new
     end
 
-    it "should parse display completions and exit if requested" do
-      cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} print ?))
-      cli.should_not_receive(:run_print)
-      cli.instance_variable_get(:@c).should_receive(:list_groups).with([])
-      cli.run
+    it "displays an appropriate message when configuration version is invalid" do
+      expect {
+        capture(:stdout) {
+          RunSSHLib::CLI.new(%W(-f #{TMP_FILE} shell))
+        }
+      }.to exit_abnormaly
+      @buf.should match(/--update-config/)
+      @buf.should match(/.none/)
+      @buf.should include("-f #{TMP_FILE}")
     end
 
-    it "should run run_update_config when called with --update-config" do
-      @cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} --update-config))
-      @cli.should_receive(:run_update_config)
-      @cli.run
+    it "doesn't display the config file path in the error message if using default config file" do
+      RunSSHLib::ConfigFile.stub(:new) { raise RunSSHLib::OlderConfigVersionError, 'none' }
+      expect {
+        capture(:stdout) {
+          RunSSHLib::CLI.new(%w(shell)).run
+        }
+      }.to exit_abnormaly
+      @buf.should_not include("-f")
     end
 
-    context "update_config" do
-      let(:cf) { double('ConfigFile') }
-
-      it "should initialize ConfigFile with old_version=true and run update_config" do
-        cf.should_receive(:update_config)
-        RunSSHLib::ConfigFile.should_receive(:new).with(TMP_FILE, true).
-                              and_return(cf)
-        @cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} --update-config))
-        @cli.run
-      end
-
-      it "should inform the user of success and backup file" do
-        backup_path = "/path/to/backup_file"
-        cf.should_receive(:update_config).and_return(backup_path)
-        RunSSHLib::ConfigFile.should_receive(:new).and_return(cf)
-        @cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} --update-config))
-        @cli.run
-        @buffer.should include(backup_path)
-      end
-
-      it "should inform the user if no backup was required" do
-        cf.should_receive(:update_config).and_return(nil)
-        RunSSHLib::ConfigFile.should_receive(:new).and_return(cf)
-        @cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} --update-config))
-        @cli.run
-        @buffer.should include("No update was performed")
-      end
+    it "upgrades the configuration" do
+      capture(:stdout) {
+        RunSSHLib::CLI.new(%W(-f #{TMP_FILE} --update-config)).run
+      }
+      config = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} print ?)).instance_variable_get(:@c)
+      config.instance_variable_get(:@config)['VERSION'].should == RunSSHLib::ConfigFile::Version
     end
 
-    describe "with subcommand" do
-      context "shell" do
-        before(:each) do
-          @shell_cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} shell))
-        end
-
-        it "should require a path" do
-          expect { @shell_cli.run }.to exit_abnormaly
-          @buffer.should include("not host definition")
-        end
-
-        it "should execute the run_shell method" do
-          @shell_cli.should_receive(:run_shell)
-          @shell_cli.run
-        end
-
-        it "should parse 's' as shell" do
-          @shell_cli.send(:extract_subcommand, %w(s root)).should eql('shell')
-        end
-
-        it "should have all required arguments" do
-          options = @shell_cli.instance_variable_get :@options
-          options.should have_key(:login)
-          options.should have_key(:local_tunnel)
-        end
-
-        it "should not overwrite nil arguments with saved ones when merging" do
-          import_fixtures
-          RunSSHLib::SshBackend.should_receive(:shell).
-                                with(hash_including(
-                                     :host_name => "a.example.com",
-                                     :login => "otheruser")).
-                                and_return(nil)
-          cli = RunSSHLib::CLI.new(
-                %W(-f #{TMP_FILE} shell cust2 dc internal somehost))
-          cli.run
-        end
-
-        it "should correctly call SshBackend.shell with merged definition" do
-          import_fixtures
-          RunSSHLib::SshBackend.should_receive(:shell).
-                                with(hash_including(:host_name => "a.example.com",
-                                                    :login => "someuser")).
-                                and_return(nil)
-          cli = RunSSHLib::CLI.new(
-                %W(-f #{TMP_FILE} shell -l someuser cust2 dc internal somehost))
-          cli.run
-        end
-
-        it "should correctly allow overriding of hostname" do
-          import_fixtures
-          RunSSHLib::SshBackend.should_receive(:shell).
-                                with(hash_including(:host_name => "overridehost"))
-          cli = RunSSHLib::CLI.new(
-                %W(-f #{TMP_FILE} shell -n overridehost cust2 dc internal somehost))
-          cli.run
-        end
+    it "informs the user of success and backup file" do
+      capture(:stdout) {
+        RunSSHLib::CLI.new(%W(-f #{TMP_FILE} --update-config)).run
+      }
+      @buf.should include "updated to the approproate version"
+      @buf.should include "#{TMP_FILE}.none"
+    end
 
-        it "should correctly parse remote command (indicated by --)" do
-          import_fixtures
-          RunSSHLib::SshBackend.should_receive(:shell).
-                                with(hash_including(:remote_cmd => "ls -l /tmp")).
-                                and_return(nil)
-          cli = RunSSHLib::CLI.new(
-                %W(-f #{TMP_FILE} shell -l someuser cust2 dc internal somehost
-                   -- ls -l /tmp)
-          )
-          cli.run
-        end
-      end
+    it "informs the user if run with --update-config and no update is required" do
+      # we're running this twice to make sure we have a valid config file
+      # remember that we create invalid config file in the before method
+      capture(:stdout) {
+        RunSSHLib::CLI.new(%W(-f #{TMP_FILE} --update-config)).run
+      }
+      capture(:stdout) {
+        RunSSHLib::CLI.new(%W(-f #{TMP_FILE} --update-config)).run
+      }
+      @buf.should include "Your configuration seems to be at the appropriate version"
+      @buf.should include "No update was performed"
+    end
+  end
 
-      describe "add" do
-        before(:each) do
-          @add_cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} add -n host one two))
-        end
+  describe "shell subcommand" do
+    it "should not overwrite nil arguments with saved ones when merging" do
+      import_fixtures
+      RunSSHLib::SshBackend.should_receive(:shell).
+                            with(hash_including(
+                                 :host_name => "a.example.com",
+                                 :login => "otheruser")).
+                            and_return(nil)
+      cli = RunSSHLib::CLI.new(
+            %W(-f #{TMP_FILE} shell cust2 dc internal somehost))
+      cli.run
+    end
 
-        it "should parse 'a' as add" do
-          @add_cli.send(:extract_subcommand, ['a']).should eql('add')
-        end
+    it "should correctly call SshBackend.shell with merged definition" do
+      import_fixtures
+      RunSSHLib::SshBackend.should_receive(:shell).
+                            with(hash_including(:host_name => "a.example.com",
+                                                :login => "someuser")).
+                            and_return(nil)
+      cli = RunSSHLib::CLI.new(
+            %W(-f #{TMP_FILE} shell -l someuser cust2 dc internal somehost))
+      cli.run
+    end
 
-        it "should have all required arguments" do
-          options = @add_cli.instance_variable_get :@options
-          options.should have_key(:host_name)
-          options.should have_key(:login)
-        end
+    it "merges given options with saved ones" do
+      stub_ssh_exec
 
-        it "should invoke the add_host_def" do
-          @add_cli.instance_variable_get(:@c).should_receive(:add_host_def).
-                   with([:one], :two, RunSSHLib::SshHostDef.new({
-                     :host_name => 'host',:login => nil
-                   }))
-          @add_cli.run
-        end
+			# multiple options saved, single option given
+      RunSSHLib::CLI.new(%W(-f #{TMP_FILE} add one two -n some.host -N)).run
+      capture(:stdout) do
+        RunSSHLib::CLI.new(%W(-f #{TMP_FILE} shell one two -o ForwardAgent=true)).run
       end
+      @buf.should include('ssh some.host')
+      @buf.should include('StrictHostKeyChecking=no')
+      @buf.should include('UserKnownHostsFile=/dev/null')
+      @buf.should include('ForwardAgent=true')
+
+			# single option saved, multiple options given
+			RunSSHLib::CLI.new(%W(-f #{TMP_FILE} add one three -n some.host 
+														-o ForwardAgent=true)).run
+			capture(:stdout) do
+				RunSSHLib::CLI.new(%W(-f #{TMP_FILE} shell one three
+															-o StrictHostKeyChecking=no
+															-o UserKnownHostsFile=/dev/null)).run
+			end
+      @buf.should include('ssh some.host')
+      @buf.should include('StrictHostKeyChecking=no')
+      @buf.should include('UserKnownHostsFile=/dev/null')
+      @buf.should include('ForwardAgent=true')
+    end
 
-      describe "del" do
-        before(:each) do
-          @d_cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} del))
-          @d_cli.instance_variable_get(:@c).stub(:delete_path)
-          @hl = double('HighLine')
-          HighLine.stub(:new) {@hl}
-          @hl.stub(:agree)
-        end
-
-        it "should parse 'd' as del" do
-          @d_cli.send(:extract_subcommand, ['d']).should eql('del')
-        end
-
-        it "should verify the deletion" do
-          @hl.should_receive(:agree).with(/Are you sure/)
-          @d_cli.run
-        end
-
-        it "should perform the deletion upon confirmation" do
-          @hl.should_receive(:agree).and_return(true)
-          @d_cli.instance_variable_get(:@c).should_receive(:delete_path)
-          @d_cli.run
-        end
-
-        it "should cancel the deletion if not confirmed" do
-          @hl.should_receive(:agree).and_return(false)
-          @d_cli.instance_variable_get(:@c).should_not_receive(:delete_path)
-          @d_cli.run
-          @buffer.should match(/cancel/)
-        end
-
-        it "should pass the right path to delete_path" do
-          cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} del one two three))
-          @hl.should_receive(:agree).and_return(true)
-          cli.instance_variable_get(:@c).should_receive(:delete_path).
-                                         with([:one, :two, :three])
-          cli.run
-        end
+    context "insecure-host-key" do
+      let (:cli) {
+        RunSSHLib::CLI.new(%W(-f #{TMP_FILE} shell --insecure-host-key 1 some host))
+      }
+      let(:khud) { double('RunSSHLib::SshBackend::KnownHostsUtils') }
+      let(:input) { 'no' }
+
+      before(:each) do
+        stub_ssh_exec
+        create_known_hosts_file 'some.host'
+        RunSSHLib::CLI.new(%W(-f #{TMP_FILE} add some host -n some.host))
+        RunSSHLib::SshBackend::KnownHostsUtils.should_receive(:new).and_return(khud)
+        khud.should_receive(:known_hosts_file).and_return(KNOWN_HOSTS_FILE)
       end
 
-      describe "update" do
-        before(:each) do
-          @update_cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} update -n newhost root))
-        end
-
-        it "should parse 'u' as update" do
-          @update_cli.send(:extract_subcommand, ['u']).should eql('update')
-        end
-
-        it "should have all required argumants" do
-          options = @update_cli.instance_variable_get :@options
-          options.should have_key(:host_name)
-          options.should have_key(:login)
-        end
-
-        it "should invoke update_host_def" do
-          config = @update_cli.instance_variable_get :@c
-          config.should_receive(:update_host_def).
-                 with([:root], RunSSHLib::SshHostDef.new({
-                   :host_name => "newhost", :login => nil
-                 }))
-          @update_cli.run
+      it "warns the user about deleting conflicting key" do
+        capture(:stderr) do # avoid stderr
+          capture(:stdout, input) do |variable|
+            # Since were cancelling it should exit with error but we don't
+            # test that now
+            expect { cli.run }.to exit_abnormaly
+          end
+          @buf.should match /Conflicting key could indicate compromised host/
+          @buf.should match /some.host/
         end
       end
 
-      describe "print" do
-        before(:each) do
-          import_fixtures
-          @p_cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} print cust2 dc internal somehost))
-        end
-
-        it "should parse 'p' as print" do
-          @p_cli.send(:extract_subcommand, ['p']).should eql('print')
-        end
-
-        it "should print correctly host definition" do
-          @p_cli.run
-          @buffer.should match(/Host definition for: somehost/)
-          @buffer.should match(/host: a.example.com/)
+      it "aborts execution if canceling the deletion at the prompt" do
+        capture(:stdout) do # just a wrapper to avoid output
+          capture(:stderr, input) do
+            expect { cli.run }.to exit_abnormaly
+          end.should == "Cancelled\n"
         end
       end
+    end
+  end
 
-      describe "import" do
-        before(:each) do
-          @i_cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} import -i inputfile))
-          @i_cli.instance_variable_get(:@c).stub(:import)
-          @hl = double('HighLine')
-          HighLine.stub(:new) {@hl}
-          @hl.stub(:agree)
-        end
+  context "Add bookmark with ssh options" do
+    it "adds options specified with '-o' to the '--no-host-key-checking' options" do
+      options = %W(-f #{TMP_FILE} add -o ForwardAgent=true --no-host-key-checking -n some.host one two)
+      RunSSHLib::CLI.new(options).run
+      host = get_host('one two')
+      host.definition[:option].should include('ForwardAgent=true')
+      host.definition[:option].should include('StrictHostKeyChecking=no')
+      host.definition[:option].should include('UserKnownHostsFile=/dev/null')
+    end
+  end
 
-        it "should parse 'i' as import" do
-          @i_cli.send(:extract_subcommand, ['i']).should eql('import')
-        end
+  context "Command abbreviation" do
+    before(:each) do
+      # we just need valid cli. Args are not important!
+      @ab_cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} print))
+    end
 
-        it "should have the right arguments" do
-          options = @i_cli.instance_variable_get :@options
-          options.include?(:input_file)
-        end
+    it "should parse 'd' as del" do
+      @ab_cli.send(:extract_subcommand, ['d']).should eql('del')
+    end
 
-        it "should verify the import with the user" do
-          @hl.should_receive(:agree).with(/OVERWRITES/)
-          @i_cli.run
-        end
+    it "should parse 'a' as add" do
+      @ab_cli.send(:extract_subcommand, ['a']).should eql('add')
+    end
 
-        it "should run import upon confirmation" do
-          @hl.should_receive(:agree).and_return(true)
-          @i_cli.instance_variable_get(:@c).should_receive(:import)
-          @i_cli.run
-        end
+    it "should parse 's' as shell" do
+      @ab_cli.send(:extract_subcommand, %w(s root)).should eql('shell')
+    end
 
-        it "should cancel if not confirmed" do
-          @hl.should_receive(:agree).and_return(false)
-          @i_cli.instance_variable_get(:@c).should_not_receive(:import)
-          @i_cli.run
-          @buffer.should match(/cancel/)
-        end
+    it "should parse 'i' as import" do
+      @ab_cli.send(:extract_subcommand, ['i']).should eql('import')
+    end
 
-        it "should pass the right argument to import" do
-          @hl.should_receive(:agree).and_return(true)
-          @i_cli.instance_variable_get(:@c).should_receive(:import).
-                                            with('inputfile')
-          @i_cli.run
-        end
-      end
+    it "should parse 'u' as update" do
+      @ab_cli.send(:extract_subcommand, ['u']).should eql('update')
+    end
 
-      describe "export" do
-        before(:each) do
-          @e_cli = RunSSHLib::CLI.new(%W(-f #{TMP_FILE} export -o somefile))
-        end
+    it "should parse 'p' as print" do
+      @ab_cli.send(:extract_subcommand, ['p']).should eql('print')
+    end
 
-        it "should parse 'e' as export" do
-          @e_cli.send(:extract_subcommand, ['e']).should eql('export')
-        end
+    it "should parse 'e' as export" do
+      @ab_cli.send(:extract_subcommand, ['e']).should eql('export')
+    end
 
-        it "should run export with the right parameters" do
-          @e_cli.instance_variable_get(:@c).should_receive(:export).
-                                            with('somefile')
-          @e_cli.run
-        end
-      end
+    it "should parse 'c' as cpid" do
+      @ab_cli.send(:extract_subcommand, ['c']).should eql('cpid')
     end
   end
 

data/spec/runsshlib/config_file_spec.rb

@@ -291,10 +291,8 @@ describe "RunSSH Configuration class" do
   end
 
   describe "when importing" do
-    let(:yml) { File.join(File.dirname(__FILE__), '../fixtures', 'runssh.yml') }
-
     it "should not accept config from different config version" do
-      y = YAML.load_file(yml)
+      y = YAML.load_file(YML_FIXTURE)
       y['VERSION'] = 2.0
       File.open(@tmp_yml, 'w') { |out| YAML.dump(y, out) }
       expect do
@@ -305,9 +303,9 @@ describe "RunSSH Configuration class" do
 
     it "should correctly export and import YAML files" do
       c = RunSSHLib::ConfigFile.new(@temp_file)
-      c.import(yml)
+      c.import(YML_FIXTURE)
       c.export(@tmp_yml)
-      YAML.load_file(@tmp_yml).should == YAML.load_file(yml)
+      YAML.load_file(@tmp_yml).should == YAML.load_file(YML_FIXTURE)
     end
   end
 

data/spec/runsshlib/ssh_backend_spec.rb

@@ -20,7 +20,33 @@ require 'spec_helper'
 require 'runsshlib'
 
 describe RunSSHLib::SshBackend do
-  context "#shell" do
+
+  describe "KnownHostsUtils" do
+    let(:ckhu) {
+      RunSSHLib::SshBackend::KnownHostsUtils
+    }
+
+    it "initializes with ~/.ssh/known_hosts file by default" do
+      khu = ckhu.new
+      khu.instance_variable_get(:@known_hosts_file).should == File.expand_path('~/.ssh/known_hosts')
+    end
+
+    it "accepts custom known_hosts file" do
+      khu = ckhu.new(KNOWN_HOSTS_FILE)
+      khu.instance_variable_get(:@known_hosts_file).should == KNOWN_HOSTS_FILE
+    end
+
+    it "deletes the correct line number" do
+      File.open(KNOWN_HOSTS_FILE, 'w') do |io|
+        io.write("some bogus line\nline to delete\nlast line\n")
+      end
+      khu = ckhu.new(KNOWN_HOSTS_FILE)
+      khu.delete_line_from_known_hosts_file(2)
+      IO.read(KNOWN_HOSTS_FILE).should == "some bogus line\nlast line\n"
+    end
+  end
+
+  describe "#shell" do
     let(:test_data) do
       {:host_name => "a",
        :login => "user",
@@ -54,11 +80,19 @@ describe RunSSHLib::SshBackend do
 
     it "should handle correctly remote commands" do
       RunSSHLib::SshBackend.should_receive(:exec).
-                            with(/^ssh\s+-l\s+#{test_data[:login]}\s+#{test_data[:host_name]}\s+--\s+"uptime"$/).
+                            with(/^ssh\s+-t\s-l\s+#{test_data[:login]}\s+#{test_data[:host_name]}\s+--\s+"uptime"$/).
                             and_return(nil)
       RunSSHLib::SshBackend.shell(test_data)
     end
 
+    it "should not enable pseudo terminal with remote command if run with -T" do
+      data = test_data.merge(:no_pseudo_terminal => true)
+      RunSSHLib::SshBackend.should_receive(:exec).
+                            with(/^ssh\s+-l\s+#{test_data[:login]}\s+#{test_data[:host_name]}\s+--\s+"uptime"$/).
+                            and_return(nil)
+      RunSSHLib::SshBackend.shell(data)
+    end
+
     it "should ignore empty remote commands" do
       data = test_data.merge(:remote_cmd => "")
       RunSSHLib::SshBackend.should_receive(:exec).
@@ -73,9 +107,20 @@ describe RunSSHLib::SshBackend do
                             with(/^ssh\s+.*\s-L\s+6000:localhost:6000.*/)
       RunSSHLib::SshBackend.shell(data)
     end
+
+    it "calls all available ssh options, each with '-o'" do
+      data = test_data.merge(:remote_cmd => '', :login => '',
+                             :option => %w(UserKnownHostsFile=/dev/null StrictHostKeyChecking=no))
+      stub_ssh_exec
+      capture(:stdout) do
+        RunSSHLib::SshBackend.shell(data)
+      end
+      @buf.should match(%r{-o UserKnownHostsFile=/dev/null})
+      @buf.should match(/-o StrictHostKeyChecking=no/)
+    end
   end
 
-  context "#normalize_tunnel_definition" do
+  describe "#normalize_tunnel_definition" do
     it "converts abbreviated tunnel definition correctly" do
       RunSSHLib::SshBackend.normalize_tunnel_definition("7070").should ==
           "7070:localhost:7070"