hussh 0.1.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: ab64923b5852ed124f71625eb035668ffac73fe7
-  data.tar.gz: 4eb55836fcacc42470e7376a2ae6e9153e09575a
+  metadata.gz: a257554c5698eec071106e3d07d3ba27ac8e4d68
+  data.tar.gz: 9898be5599601f68c93b161e37ca5569752b9e69
 SHA512:
-  metadata.gz: 4cbac79becbae698f895437051fb3ae239859ae67ac417913e5cce135235d0f1c535e307f1c8bca8f28b59ee16151680c8c944e5fdacb172a0956bbe03a04665
-  data.tar.gz: 84e10d5ded1e5b56151677b6c58172ec2c1c3c0a09a729f39c485483979a7fec24922b9ba04c4f94b91fd480d48d8e9baf84c681bf1ee06aa1474aa4a270dc2c
+  metadata.gz: 500700b7c98b007ccfabecc971b2939a829621e616dd84fe8248c18b5f89ecfc2f2d8d3ff291458f4ef7453c5f2834a0a8c85fb445dab6c95faecc34ffa966bc
+  data.tar.gz: df7f6353a10afea92a5d643cf6403e648f9a94d91d3824c85a942bf4a3cbf9a6963861f70055b0aca1ef3e690fb481c0fc6faac8c75ed8cadfb2327b7c3784e1

data/README.rdoc

@@ -3,6 +3,7 @@
 A mocking library for <tt>Net::SSH</tt> which allows testers to specify
 responses and record real-life responses for later use.
 
+{<img src="https://badge.fury.io/rb/hussh.svg" alt="Gem Version" />}[http://badge.fury.io/rb/hussh]
 {<img src="https://travis-ci.org/moneyadviceservice/hussh.svg?branch=master" alt="Build Status" />}[https://travis-ci.org/moneyadviceservice/hussh]
 
 == Installation

data/lib/hussh/channel.rb

@@ -5,47 +5,90 @@ module Hussh
       @request_pty = false
     end
 
-    def real_channel
-      @real_channel ||= @session.real_session.open_channel
+    def have_real_channel?
+      !!@real_channel
     end
 
-    def response_data
-      @data
+    def open_real_channel
+      @real_channel ||= @session.real_session.open_channel
     end
 
     attr :command
     attr :exec_block
     def exec(command, &block)
       @command = command
-      @exec_block = block
-    end
-
-    attr :on_data_block
-    def on_data(&block)
-      @on_data_block = block
-    end
+      Hussh.commands_run << @command
+      if !@session.has_response?(@command)
+        open_real_channel
+        request_pty(&@request_pty_callback) if @request_pty
+        on_data(&@on_data_callback) if @on_data_callback
+        if @on_extended_data_callback
+          on_extended_data(&@on_extended_data_callback)
+        end
 
-    attr :on_extended_data_block
-    def on_extended_data(&block)
-      @on_extended_data_block = block
+        @real_channel.exec(command) do |ch, success|
+          @exec_result = success
+          block.call(self, success) if block
+        end
+      elsif block_given?
+        yield(self, true)
+      end
     end
 
-    attr :request_pty_block
     def request_pty(&block)
-      @request_pty = true
-      @request_pty_block = block
+      if have_real_channel?
+        @real_channel.request_pty do |ch, success|
+          block.call(ch, success) if block
+        end
+      else
+        @request_pty = true
+        @request_pty_callback = block
+      end
     end
 
     def requested_pty?
       @request_pty
     end
 
-    # def on_close(&block)
-    #   @on_close = block
-    # end
+    def on_data(&block)
+      if have_real_channel?
+        @real_channel.on_data do |ch, output|
+          @stdout ||= ''
+          @stdout << output
+          block.call(ch, output) if block
+        end
+      else
+        @on_data_callback = block
+      end
+    end
+
+    def on_extended_data(&block)
+      if have_real_channel?
+        @real_channel.on_extended_data do |ch, output|
+          @stderr ||= ''
+          @stderr << output
+          block.call(ch, output) if block
+        end
+      else
+        @on_extended_data_callback = block
+      end
+    end
 
-    # def close
-    #   @real_channel.close if @real_channel
-    # end
+    def wait
+      if @real_channel
+        @real_channel.wait
+      end
+    end
+
+    def close
+      if have_real_channel?
+        @real_channel.close
+        @session.update_recording(@command, @stdout) if @stdout
+      else
+        stdout = @session.response_for(@command)
+        @on_data_callback.call(self, stdout) if stdout && @on_data_callback
+        @on_extended_data_callback.call(self, @stderr) if @stderr && @on_extended_data_callback
+      end
+    end
   end
 end

data/lib/hussh/configuration.rb

@@ -20,9 +20,18 @@ module Hussh
 
         config.before(:each, hussh: lambda { |v| !!v }) do |example|
           options = example.metadata[:hussh]
-          options = options.is_a?(Hash) ? options.dup : {}
-          recording_name = options.delete(:recording_name) ||
-                           recording_name_for[example.metadata]
+          if options.is_a?(Hash)
+            options = options.dup
+            recording_name = options.delete(:recording_name) ||
+                             recording_name_for[example.metadata]
+          elsif options.is_a?(String)
+            recording_name = options
+            options = {}
+          else
+            recording_name = recording_name_for[example.metadata]
+            options = {}
+          end
+
           Hussh.load_recording(recording_name)
           Hussh.clear_stubbed_responses
         end

data/lib/hussh/session.rb

@@ -5,12 +5,17 @@ module Hussh
     def initialize(host, user)
       @host = host
       @user = user
+      @channel_id_counter = 0
     end
 
     def real_session
       @real_session ||= Net::SSH.start_without_hussh(@host, @user)
     end
 
+    def have_real_session?
+      !!@real_session
+    end
+
     def has_response?(command)
       Hussh.stubbed_responses.fetch(@host, {}).fetch(@user, {})
         .has_key?(command) ||
@@ -43,54 +48,27 @@ module Hussh
       end
     end
 
-    def open_channel(&block)
-      @channel = Channel.new(self)
-      block.call(@channel)
-      Hussh.commands_run << @channel.command
-      if self.has_response?(@channel.command)
-        if @channel.exec_block.respond_to?(:call)
-          @channel.exec_block.call(@channel, true)
-        end
-
-        if @channel.on_data_block.respond_to?(:call)
-          @channel.on_data_block.call(@channel, self.response_for(@channel.command))
-        end
-      else
-        self.real_session.open_channel do |ch|
-
-          if @channel.requested_pty?
-            ch.request_pty do |ch, success|
-              if @channel.request_pty_block.respond_to?(:call)
-                @channel.request_pty_block.call(ch, success)
-              end
-            end
-          end
-
-          ch.exec(@channel.command) do |ch, success|
-            @channel.exec_block.call(@channel, success) if @channel.exec_block
-
-            ch.on_data do |ch, output|
-              if @channel.on_data_block.respond_to?(:call)
-                @channel.on_data_block.call(@channel, output)
-                @on_data = output
-                self.update_recording(@channel.command, @on_data)
-              end
-            end
+    def channels
+      @channels ||= {}
+    end
 
-            ch.on_extended_data do |ch, output|
-              if @channel.on_extended_data_block.respond_to?(:call)
-                @channel.on_extended_data_block.call(@channel, output)
-              end
-            end
+    def get_next_channel_id
+      @channel_id_counter += 1
+    end
 
-          end
-        end
-      end
+    def open_channel(&block)
+      channel = Channel.new(self)
+      yield(channel) if block_given?
+      channels[get_next_channel_id] = channel
     end
 
     def close
-      @real_session.close if @real_session
-      @real_session = nil
+      channels.each do |id, channel|
+        channel.close
+      end
+      if have_real_session?
+        real_session.close
+      end
     end
   end
 end

data/lib/hussh/version.rb

@@ -1,4 +1,4 @@
 module Hussh
-  VERSION = '0.1.0'
+  VERSION = '0.2.1'
 end
 

data/spec/hussh_channel_spec.rb

@@ -7,142 +7,156 @@ require 'hussh'
 RSpec.describe Hussh do
   include FakeFS::SpecHelpers
 
-  describe Hussh::Channel do
-    before do
-      Hussh.commands_run.clear
-      Hussh.clear_recorded_responses
-      Hussh.clear_stubbed_responses
-    end
+  let(:session) { spy(Hussh::Session) }
+  let(:channel) { Hussh::Channel.new(session) }
+  let(:real_channel) do
+    channel.instance_eval { @real_channel }
+  end
 
-    let!(:channel) do
-      channel = instance_spy('Net::SSH::Connection::Channel')
-      # Setup a fake Channel object which will hopefully behave like a
-      # Net::SSH channel, i.e. register the command and callbacks, and then
-      # call them all with the appropriate data and values.
-      allow(channel).to receive(:exec) do |cmd, &blk|
-        @command = cmd
-        @exec = blk
-      end
-      allow(channel).to receive(:request_pty) { |&block| @request_pty = block }
-      allow(channel).to receive(:on_data) { |&block| @on_data = block }
-      allow(channel).to receive(:on_extended_data) do |&block|
-        @on_extended_data = block
-      end
-      # TODO: loop and wait should also end up calling the callbacks
-      allow(channel).to receive(:close) do
-        # Allow the test to specify a command that fails.
-        @exec.call(channel, !@command.match(/fail/)) if @exec
-        # Allow the test to specify a failed pty request.
-        @request_pty.call(channel, !@command.match(/nopty/)) if @request_pty
-        @on_data.call(channel, "#{@command} output") if @on_data
-        if @on_extended_data
-          @on_extended_data.call(channel, "#{@command} stderr output")
-        end
-      end
-      allow(channel).to receive(:wait) do
-        channel.close
-      end
-      channel
-    end
+  let(:mock_block) do
+    block = Proc.new {}
+    allow(block).to receive(:call)
+    block
+  end
 
-    let!(:session) do
-      session = instance_spy('Net::SSH::Connection::Session')
-      # The session here is just used to stub our channel in for the real one.
-      allow(session).to receive(:open_channel) do |&blk|
-        blk.call(channel)
-        channel.close
-      end
-      allow(Net::SSH).to receive(:start_without_hussh).and_return(session)
-      session
+  context 'real channel opened' do
+    before do
+      spy = instance_spy('Net::SSH::Connection::Channel')
+      channel.instance_eval { @real_channel = spy }
     end
 
-    context 'when using an exec block' do
-      before do
-        FileUtils.mkdir_p 'fixtures/hussh'
-        File.write('fixtures/hussh/saved_responses.yaml', saved_responses)
-        Hussh.load_recording('saved_responses')
-
-        # Simulate how we would use Hussh, which sits between the
-        # application code (the code below) and the mocked-out Net::SSH
-        # code.
-        Net::SSH.start('host', 'user') do |session|
-          session.open_channel do |ch|
-            ch.request_pty
-            ch.exec command do |ch, success|
-              @exec_success = success
-              ch.on_data          { |c, data| @data = data }
-              ch.on_extended_data { |c, data| @extended_data = data }
-            end
+    describe :exec do
+      context 'where there is no saved response' do
+        before do
+          allow(real_channel).to receive(:exec) do |command, &block|
+            @command = command
+            @hussh_block = block
           end
         end
-      end
 
-      context 'with a command that has not been run before' do
-        let(:saved_responses) { {}.to_yaml }
+        before do
+          allow(session).to receive(:has_response?).and_return(false)
+        end
 
-        context 'and execution is succesful' do
-          let(:command) { 'test' }
+        it 'records that the command was run' do
+          channel.exec('record-command')
+          expect(Hussh.commands_run.last).to eql('record-command')
+        end
 
-          it 'runs the command via ssh' do
-            expect(channel).to have_received(:exec).with('test')
-          end
+        context 'when a pty has been requested' do
+          before { channel.instance_eval { @request_pty = true } }
 
-          it 'records that the command was run' do
-            expect(Hussh.commands_run).to include('test')
+          it 'requests a pty' do
+            channel.exec('request-pty')
+            expect(real_channel).to have_received(:request_pty)
           end
+        end
 
-          it 'passes command status to exec' do
-            expect(@exec_success).to eql(true)
-          end
+        context 'when a pty has not been requested' do
+          before { channel.instance_eval { @request_pty = false } }
 
-          it 'gives us the stdout' do
-            expect(@data).to eq 'test output'
+          it 'does not request a pty' do
+            channel.exec('no-request-pty')
+            expect(real_channel).to_not have_received(:request_pty)
           end
+        end
 
-          it 'gives us the stderr' do
-            expect(@extended_data).to eq 'test stderr output'
-          end
+        context 'when an on_data block has been previously defined' do
+          before { channel.instance_eval { @on_data_callback = Proc.new {} } }
 
-          it 'allows us to request a pty' do
-            expect(channel).to have_received(:request_pty)
+          it 'sets up an on_data callback' do
+            channel.exec('on-data')
+            expect(real_channel).to have_received(:on_data)
           end
+        end
 
-          it 'saves the result of the command' do
-            expect(Hussh.recorded_responses['host']['user']['test'])
-              .to eq 'test output'
-          end
+        context 'when an on_data block has not been previously defined' do
+          before { channel.instance_eval { @on_data_callback = nil } }
 
-          it 'flags the recording as changed' do
-            expect(Hussh.recording_changed?).to eql(true)
+          it 'does not setup an on_data callback' do
+            channel.exec('no-on-data')
+            expect(real_channel).to_not have_received(:on_data)
           end
         end
 
-        context 'and has failed to execute' do
-          let(:command) { 'test-fail' }
-          subject { @exec_success }
-          it { is_expected.to eq false }
+        it 'calls our block' do
+          channel.exec('block-command', &mock_block)
+          @hussh_block.call(channel, 'test-for-success')
+          expect(mock_block).to have_received(:call)
+                                 .with(channel, 'test-for-success')
         end
       end
 
-      context 'with a command that has recorded results' do
-        let(:saved_responses) do
-          {
-            'host' => { 'user' => { 'test' => 'recorded test output' } }
-          }.to_yaml
+      context 'where there is a saved response' do
+        before do
+          allow(session).to receive(:has_response?).and_return(true)
         end
 
-        context 'and execution is succesful' do
-          let(:command) { 'test' }
+        it 'calls our block' do
+          channel.exec('block-command') { @block_called = true }
+          expect(@block_called).to eql(true)
+        end
+      end
+    end
 
-          it 'gives us the stdout' do
-            expect(@data).to eq 'recorded test output'
-          end
+    describe :request_pty do
+      before do
+        allow(real_channel).to receive(:request_pty) { |&b| @hussh_block = b }
+      end
 
-          it 'gives us the success status' do
-            expect(@exec_success).to eql(true)
-          end
+      it 'calls request_pty on the real channel' do
+        channel.request_pty
+        expect(real_channel).to have_received(:request_pty)
+      end
+
+      it 'calls our block' do
+        channel.request_pty(&mock_block)
+        @hussh_block.call(channel, :status)
+        expect(mock_block).to have_received(:call).with(channel, :status)
+      end
+    end
+
+    describe :on_data do
+      before do
+        allow(real_channel).to receive(:on_data) { |&blk| @hussh_block = blk }
+      end
+
+      it 'calls on_data on the real channel' do
+        channel.on_data {}
+        expect(real_channel).to have_received(:on_data)
+      end
+
+      it 'calls our block' do
+        channel.on_data(&mock_block)
+        @hussh_block.call(channel, 'stdout')
+        expect(mock_block).to have_received(:call).with(channel, 'stdout')
+      end
+    end
+
+    describe :on_extended_data do
+      before do
+        allow(real_channel).to receive(:on_extended_data) do |&block|
+          @hussh_block = block
         end
       end
+
+      it 'calls on_extended_data on the real channel' do
+        channel.on_extended_data {}
+        expect(real_channel).to have_received(:on_extended_data)
+      end
+
+      it 'calls our block' do
+        channel.on_extended_data(&mock_block)
+        @hussh_block.call(channel, 'stderr')
+        expect(mock_block).to have_received(:call).with(channel, 'stderr')
+      end
+    end
+
+    describe :wait do
+      it 'calls wait on the real channel' do
+        channel.wait
+        expect(real_channel).to have_received(:wait)
+      end
     end
   end
 end

data/spec/hussh_configuration_spec.rb

@@ -29,7 +29,80 @@ RSpec.describe Hussh do
                              })
       end
 
-      context 'after block' do
+      describe 'before block' do
+        let(:recorded_responses) do
+          { 'host' => { 'user' => { 'cmd' => 'output' } } }
+        end
+
+        context 'with no params' do
+          before do
+            allow(@example).to receive(:metadata).and_return(
+                                 {
+                                   hussh: true,
+                                   description: 'some spec',
+                                   example_group: {
+                                     description: 'example group',
+                                     parent_example_group: {
+                                       description: 'parent group'
+                                     }
+                                   }
+                                 }
+                               )
+            FileUtils.mkdir_p('fixtures/hussh/parent group/example group')
+            File.write(
+              'fixtures/hussh/parent group/example group/some spec.yaml',
+              recorded_responses.to_yaml
+            )
+            @before.call(@example)
+          end
+
+          it 'loads a recording with a generated name' do
+            expect(Hussh.recorded_responses).to eq(recorded_responses)
+          end
+        end
+
+        context 'with a string param' do
+          before do
+            allow(@example).to receive(:metadata).and_return(
+                                 { hussh: 'group/spec' }
+                               )
+            FileUtils.mkdir_p('fixtures/hussh/group')
+            File.write(
+              'fixtures/hussh/group/spec.yaml',
+              recorded_responses.to_yaml
+            )
+            @before.call(@example)
+          end
+
+          it 'uses the string as the recording name' do
+            expect(Hussh.recorded_responses).to eq(recorded_responses)
+          end
+        end
+
+        context 'with a hash param' do
+          before do
+            allow(@example).to receive(:metadata).and_return(
+                                 {
+                                   hussh: {
+                                     recording_name: 'parent/spec'
+                                   }
+                                 }
+                               )
+            FileUtils.mkdir_p('fixtures/hussh/parent')
+            File.write(
+              'fixtures/hussh/parent/spec.yaml',
+              recorded_responses.to_yaml
+            )
+            @before.call(@example)
+          end
+
+          it 'gets the recording_name from the hash' do
+            expect(Hussh.recorded_responses).to eq(recorded_responses)
+          end
+        end
+      end
+
+      describe 'after block' do
         before do
           Hussh.recorded_responses = {
             'host' => { 'user' => { 'cmd' => 'output' } }

data/spec/hussh_functional_spec.rb

@@ -0,0 +1,377 @@
+require 'hussh'
+require 'fakefs/spec_helpers'
+require 'yaml'
+
+RSpec.describe Hussh do
+  include FakeFS::SpecHelpers
+
+  # Setup a fake Channel object which will hopefully behave like a Net::SSH
+  # channel, i.e. register the command and callbacks, and then call them all
+  # with the appropriate data and in the right order.
+  let!(:real_channel) do
+    channel = instance_spy('Net::SSH::Connection::Channel')
+
+    allow(channel).to receive(:exec) do |cmd, &block|
+      @command = cmd
+      # Allow the test to specify a command that fails.
+      #
+      # So ... in Ruby 1.9.3, `@command.match(/fail/)` returns nil even when it
+      # matches, inside this block to RSpec::Mocks::ExampleMethods#receive, but
+      # not outside of it. There's some deep dark voodoo going on here, so flip
+      # the Regexp and the String for now to make tests pass.
+      #
+      # See https://github.com/rspec/rspec-expectations/issues/781
+      @success = !/fail/.match(@command)
+      block.call(channel, @success) if block
+      output = "#{cmd} output"
+      error_output = "#{cmd} error output"
+      if cmd.match(/pty/) && !@request_pty
+        output = nil
+        error_output = 'no pty'
+      end
+
+      if output
+        if @on_data
+          @on_data.call(channel, output)
+        else
+          @on_data_pending = output
+        end
+      end
+
+      if error_output
+        if @on_extended_data
+          @on_extended_data.call(channel, error_output)
+        else
+          @on_extended_data_pending = error_output
+        end
+      end
+    end
+
+    allow(channel).to receive(:request_pty) do |&block|
+      block.call(channel, true) if block
+      @request_pty = true
+    end
+
+    allow(channel).to receive(:on_data) do |&block|
+      @on_data = block
+      if @on_data_pending
+        block.call(channel, @on_data_pending)
+        @on_data_pending = nil
+      end
+    end
+
+    allow(channel).to receive(:on_extended_data) do |&block|
+      @on_extended_data = block
+      if @on_extended_data_pending
+        block.call(channel, @on_extended_data_pending)
+        @on_extended_data_pending = nil
+      end
+    end
+
+    channel
+  end
+
+  # Inject our "real_channel" above into code that uses Net::SSH
+  let!(:real_session) do
+    session = instance_spy('Net::SSH::Connection::Session')
+    allow(session).to receive(:exec!) { |c| "#{c} output" }
+    allow(session).to receive(:open_channel) do |&blk|
+
+      blk.call(real_channel) if blk
+      real_channel
+    end
+    allow(Net::SSH).to receive(:start_without_hussh).and_return(session)
+    session
+  end
+
+  let(:saved_responses) { {}.to_yaml }
+
+
+  before do
+    Hussh.commands_run.clear
+    Hussh.clear_stubbed_responses
+
+    FileUtils.mkdir_p 'fixtures/hussh'
+    File.write('fixtures/hussh/saved_responses.yaml', saved_responses)
+    Hussh.load_recording('saved_responses')
+  end
+
+  describe :exec! do
+    context 'with a command that has not been run before' do
+      before do
+        Net::SSH.start('host', 'user') do |s|
+          @output = s.exec!('id')
+        end
+      end
+
+      it 'runs the command via ssh' do
+        expect(real_session).to have_received(:exec!).with('id')
+      end
+
+      it 'records that the command was run' do
+        expect(Hussh.commands_run).to include('id')
+      end
+
+      it 'returns the result of the command' do
+        expect(@output).to eql("id output")
+      end
+
+      it 'saves the result of the command' do
+        expect(Hussh.recorded_responses['host']['user']['id'])
+          .to eql("id output")
+      end
+
+      it 'flags the recording as changed' do
+        expect(Hussh.recording_changed?).to eql(true)
+      end
+    end
+
+    context 'with a command that has been run before' do
+      before do
+        FileUtils.mkdir_p 'fixtures/hussh'
+        File.write(
+          'fixtures/hussh/saved_responses.yaml',
+          {
+            'host' => { 'user' => { 'hostname' => "subsix\n" } }
+          }.to_yaml
+        )
+        Hussh.load_recording('saved_responses')
+        Net::SSH.start('host', 'user') { |s| s.exec!('hostname') }
+      end
+
+      it "doesn't run the command via ssh" do
+        expect(Net::SSH).to_not have_received(:start_without_hussh)
+      end
+
+      it 'records that the command was run' do
+        expect(Hussh.commands_run).to include('hostname')
+      end
+
+      it "doesn't flags the recording as changed" do
+        expect(Hussh.recording_changed?).to eql(false)
+      end
+    end
+  end
+
+  describe 'using callbacks defined after exec and no pty' do
+    before do
+      # Simulate how we would use Hussh, which sits between the
+      # application code (the code below) and the mocked-out Net::SSH
+      # code.
+      Net::SSH.start('host', 'user') do |session|
+        session.open_channel do |ch|
+          ch.exec command
+          ch.on_data          { |c, data| @data = data }
+          ch.on_extended_data { |c, data| @extended_data = data }
+        end
+      end
+    end
+
+    let(:command) { 'callbacks-after' }
+
+    it 'runs the command via ssh' do
+      expect(real_channel).to have_received(:exec).with(command)
+    end
+
+    it 'records the command was run' do
+      expect(Hussh.commands_run).to include(command)
+    end
+
+    it 'gives us the stdout' do
+      expect(@data).to eq "#{command} output"
+    end
+
+    it 'gives us the stderr' do
+      expect(@extended_data).to eq "#{command} error output"
+    end
+
+    context 'with a command that requires a pty' do
+      let(:command) { 'test-pty-fail' }
+
+      it 'has no stdout' do
+        expect(@data).to eq nil
+      end
+
+      it 'signals error on stderr' do
+        expect(@extended_data).to eq 'no pty'
+      end
+    end
+
+    context 'with saved responses' do
+      let(:saved_responses) do
+        {
+          'host' => { 'user' => { command => "recorded #{command} output" } }
+        }.to_yaml
+      end
+
+      it 'gives us the recorded stdout' do
+        expect(@data).to eq "recorded #{command} output"
+      end
+    end
+  end
+
+  describe 'callbacks defined before exec and no pty' do
+    before do
+      # Callbacks defined before the exec should still be called.
+      Net::SSH.start('host', 'user') do |session|
+        session.open_channel do |ch|
+          ch.on_data          { |c, data| @data = data }
+          ch.on_extended_data { |c, data| @extended_data = data }
+          ch.exec 'callbacks-before'
+        end
+      end
+    end
+
+    it 'runs the command via ssh' do
+      expect(real_channel).to have_received(:exec).with('callbacks-before')
+    end
+
+    it 'records the command was run' do
+      expect(Hussh.commands_run).to include('callbacks-before')
+    end
+
+    it 'gives us the stdout' do
+      expect(@data).to eq 'callbacks-before output'
+    end
+
+    it 'gives us the stderr' do
+      expect(@extended_data).to eq 'callbacks-before error output'
+    end
+  end
+
+  describe 'requesting a pty' do
+    before do
+      # Request a pty before we run exec.
+      Net::SSH.start('host', 'user') do |session|
+        session.open_channel do |ch|
+          ch.request_pty
+          ch.exec 'test-pty'
+        end
+      end
+    end
+
+    it 'requests a pty' do
+      expect(real_channel).to have_received(:request_pty)
+    end
+  end
+
+  describe 'using an exec block' do
+    before do
+      # Use Net::SSH and our callbacks defined in the exec block.
+      Net::SSH.start('host', 'user') do |session|
+        session.open_channel do |ch|
+          ch.exec command do |ch, success|
+            @exec_success = success
+            ch.on_data          { |c, data| @data = data }
+            ch.on_extended_data { |c, data| @extended_data = data }
+          end
+        end
+      end
+    end
+
+    let(:command) { 'block-test' }
+
+    it 'runs the command via ssh' do
+      expect(real_channel).to have_received(:exec).with(command)
+    end
+
+    it 'records that the command was run' do
+      expect(Hussh.commands_run).to include(command)
+    end
+
+    it 'passes command status to exec' do
+      expect(@exec_success).to eql(true)
+    end
+
+    it 'gives us the stdout' do
+      expect(@data).to eq "#{command} output"
+    end
+
+    it 'gives us the stderr' do
+      expect(@extended_data).to eq "#{command} error output"
+    end
+
+    it 'saves the result of the command' do
+      expect(Hussh.recorded_responses['host']['user'][command])
+        .to eq "#{command} output"
+    end
+
+    it 'flags the recording as changed' do
+      expect(Hussh.recording_changed?).to eql(true)
+    end
+
+    context 'with a failed connection' do
+      let(:command) { 'test-fail' }
+      subject { @exec_success }
+      it { is_expected.to eq false }
+    end
+
+    context 'with a command that has recorded results' do
+      let(:command) { 'recorded-test' }
+      let(:saved_responses) do
+        {
+          'host' => { 'user' => { 'test-recorded' => "#{command} output" } }
+        }.to_yaml
+      end
+
+      it 'gives us the stdout' do
+        expect(@data).to eq "#{command} output"
+      end
+
+      it 'gives us the success status' do
+        expect(@exec_success).to eql(true)
+      end
+    end
+  end
+
+  describe 'using exec wthout a block' do
+    before do
+      # Use Net::SSH and our callbacks defined in the exec block.
+      Net::SSH.start('host', 'user') do |session|
+        ch = session.open_channel
+        ch.on_data          { |c, data| @data = data }
+        ch.on_extended_data { |c, data| @extended_data = data }
+        ch.exec command
+      end
+    end
+
+    let(:command) { 'exec-no-block' }
+
+    it 'runs the command via ssh' do
+      expect(real_channel).to have_received(:exec).with(command)
+    end
+
+    it 'records that the command was run' do
+      expect(Hussh.commands_run).to include(command)
+    end
+
+    it 'gives us the stdout' do
+      expect(@data).to eq "#{command} output"
+    end
+
+    it 'gives us the stderr' do
+      expect(@extended_data).to eq "#{command} error output"
+    end
+
+    it 'saves the result of the command' do
+      expect(Hussh.recorded_responses['host']['user'][command])
+        .to eq "#{command} output"
+    end
+
+    it 'flags the recording as changed' do
+      expect(Hussh.recording_changed?).to eql(true)
+    end
+
+    context 'with a command that has recorded results' do
+      let(:saved_responses) do
+        {
+          'host' => { 'user' => { 'exec-no-block' => "#{command} output" } }
+        }.to_yaml
+      end
+
+      it 'gives us the stdout' do
+        expect(@data).to eq "#{command} output"
+      end
+    end
+  end
+end

data/spec/hussh_session_spec.rb

@@ -6,72 +6,35 @@ require 'hussh'
 
 RSpec.describe Hussh do
   include FakeFS::SpecHelpers
-  describe Hussh::Session do
-    describe :exec! do
-      let(:real_session) do
-        spy = instance_spy('Net::SSH::Connection::Session')
-        allow(spy).to receive(:exec!) { |c| "#{c} output" }
-        spy
-      end
-      before do
-        Hussh.commands_run.clear
-        Hussh.clear_recorded_responses
-        Hussh.clear_stubbed_responses
-        allow(Net::SSH).to receive(:start_without_hussh)
-                            .and_return(real_session)
-      end
-
-      context 'with a command that has not been run before' do
-        before do
-          Net::SSH.start('host', 'user') { |s| @output = s.exec!('hostname') }
-        end
 
-        it 'runs the command via ssh' do
-          expect(real_session).to have_received(:exec!).with('hostname')
-        end
-
-        it 'records that the command was run' do
-          expect(Hussh.commands_run).to include('hostname')
-        end
+  describe Hussh::Session do
+    let(:real_session) do
+      spy = instance_spy('Net::SSH::Connection::Session')
+      allow(spy).to receive(:exec!) { |c| "#{c} output" }
+      spy
+    end
 
-        it 'returns the result of the command' do
-          expect(@output).to eql('hostname output')
-        end
+    before do
+      Hussh.commands_run.clear
+      Hussh.clear_recorded_responses
+      Hussh.clear_stubbed_responses
+      allow(Net::SSH).to receive(:start_without_hussh)
+                          .and_return(real_session)
+    end
 
-        it 'saves the result of the command' do
-          expect(Hussh.recorded_responses['host']['user']['hostname'])
-            .to eql('hostname output')
-        end
+    describe :open_channel do
+      let(:session) { Hussh::Session.new('host', 'user') }
 
-        it 'flags the recording as changed' do
-          expect(Hussh.recording_changed?).to eql(true)
-        end
+      it 'returns a new channel' do
+        @channel = session.open_channel
+        expect(@channel).to be_a(Hussh::Channel)
       end
 
-      context 'with a command that has been run before' do
-        before do
-          FileUtils.mkdir_p 'fixtures/hussh'
-          File.write(
-            'fixtures/hussh/saved_responses.yaml',
-            {
-              'host' => { 'user' => { 'hostname' => "subsix\n" } }
-            }.to_yaml
-          )
-          Hussh.load_recording('saved_responses')
-          Net::SSH.start('host', 'user') { |s| s.exec!('hostname') }
-        end
-
-        it "doesn't run the command via ssh" do
-          expect(Net::SSH).to_not have_received(:start_without_hussh)
-        end
-
-        it 'records that the command was run' do
-          expect(Hussh.commands_run).to include('hostname')
-        end
-
-        it "doesn't flags the recording as changed" do
-          expect(Hussh.recording_changed?).to eql(false)
+      it 'runs the given block' do
+        session.open_channel do |ch|
+          @channel = ch
         end
+        expect(@channel).to be_a(Hussh::Channel)
       end
     end
   end

data/spec/spec_helper.rb

@@ -1,3 +1,6 @@
+require "codeclimate-test-reporter"
+CodeClimate::TestReporter.start
+
 # This file was generated by the `rspec --init` command. Conventionally, all
 # specs live under a `spec` directory, which RSpec adds to the `$LOAD_PATH`.
 # The generated `.rspec` file contains `--require spec_helper` which will cause
@@ -42,7 +45,6 @@ RSpec.configure do |config|
 
 # The settings below are suggested to provide a good initial experience
 # with RSpec, but feel free to customize to your heart's content.
-=begin
   # These two settings work together to allow you to limit a spec run
   # to individual examples or groups you care about by tagging them with
   # `:focus` metadata. When nothing is tagged with `:focus`, all examples
@@ -50,6 +52,7 @@ RSpec.configure do |config|
   config.filter_run :focus
   config.run_all_when_everything_filtered = true
 
+=begin
   # Limits the available syntax to the non-monkey patched syntax that is
   # recommended. For more details, see:
   #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: hussh
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.1
 platform: ruby
 authors:
 - Misha Gorodnitzky
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-04-12 00:00:00.000000000 Z
+date: 2015-05-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -136,6 +136,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '2.9'
+- !ruby/object:Gem::Dependency
+  name: codeclimate-test-reporter
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: Session-recording library for Net::SSH to make testing easy
 email: misaka@pobox.com
 executables: []
@@ -151,6 +165,7 @@ files:
 - lib/hussh/version.rb
 - spec/hussh_channel_spec.rb
 - spec/hussh_configuration_spec.rb
+- spec/hussh_functional_spec.rb
 - spec/hussh_session_spec.rb
 - spec/spec_helper.rb
 homepage: http://github.com/moneyadviceservice/hussh
@@ -180,5 +195,6 @@ summary: Session-recording library for Net::SSH to make testing easy
 test_files:
 - spec/hussh_channel_spec.rb
 - spec/hussh_configuration_spec.rb
+- spec/hussh_functional_spec.rb
 - spec/hussh_session_spec.rb
 - spec/spec_helper.rb