rspec-bash 0.1.1 → 0.2.0

data/spec/classes/{call_log_spec.rb → command/call_log_spec.rb}

@@ -3,11 +3,11 @@ include Rspec::Bash
 include Rspec::Bash::Util
 
 describe 'CallLog' do
-  let(:stubbed_env) { create_stubbed_env }
-  let(:mock_log_file) { StringFileIO.new }
-  let(:mock_log_pathname) { instance_double(Pathname) }
+  subject { CallLog.new }
+
   let(:mock_call_log_matcher) { instance_double(CallLogArgumentListMatcher) }
-  before(:each) do
+
+  before do
     allow(mock_call_log_matcher).to receive(:get_call_log_matches).and_return(
       [
         {
@@ -28,77 +28,73 @@ describe 'CallLog' do
     allow(mock_call_log_matcher).to receive(:args_match?).and_return(true)
     allow(CallLogArgumentListMatcher).to receive(:new).with(any_args)
       .and_return(mock_call_log_matcher)
-    allow(mock_log_pathname).to receive(:open).with('r').and_yield(mock_log_file)
-    allow(mock_log_pathname).to receive(:open).with('w').and_yield(mock_log_file)
   end
 
-  subject { CallLog.new(mock_log_pathname) }
-
   context '#stdin_for_args' do
     it 'returns the first matching stdin via the specialized matcher' do
       expect(mock_call_log_matcher).to receive(:get_call_log_matches)
         .with(any_args)
-      expect(subject.stdin_for_args('first_argument', 'second_argument')).to eql 'first_stdin'
+
+      expect(subject.stdin_for_args(%w(first_argument second_argument))).to eql 'first_stdin'
     end
   end
+
   context '#call_count?' do
     it 'returns the expected call count via the specialized matcher' do
       expect(mock_call_log_matcher).to receive(:get_call_count)
         .with(any_args)
-      expect(subject.call_count('first_argument', 'second_argument')).to eql 3
+
+      expect(subject.call_count(%w(first_argument second_argument))).to eql 3
     end
   end
+
   context '#called_with_args' do
     it 'returns the expected value via the specialized matcher' do
       expect(mock_call_log_matcher).to receive(:args_match?)
         .with(any_args)
-      expect(subject.called_with_args?('first_argument', 'second_argument')).to eql true
+
+      expect(subject.called_with_args?(%w(first_argument second_argument))).to eql true
     end
   end
+
   context '#called_with_no_args?' do
     it 'returns false if no call log is found' do
-      @subject = Rspec::Bash::CallLog.new(mock_log_pathname)
-      @subject.call_log = []
+      subject.call_log = []
 
-      expect(@subject.called_with_no_args?).to be_falsey
+      expect(subject.called_with_no_args?).to be_falsey
     end
     it 'returns true if no arguments are in call log' do
       actual_call_log = [{
         args: nil,
         stdin: []
       }]
-      @subject = Rspec::Bash::CallLog.new(mock_log_pathname)
-      @subject.call_log = actual_call_log
+      subject.call_log = actual_call_log
 
-      expect(@subject.called_with_no_args?).to be_truthy
+      expect(subject.called_with_no_args?).to be_truthy
     end
     it 'returns fails if a single argument is in call log' do
       actual_call_log = [{
         args: ['I am an argument'],
         stdin: []
       }]
-      @subject = Rspec::Bash::CallLog.new(mock_log_pathname)
-      @subject.call_log = actual_call_log
+      subject.call_log = actual_call_log
 
-      expect(@subject.called_with_no_args?).to be_falsey
+      expect(subject.called_with_no_args?).to be_falsey
     end
     it 'returns fails if multiple arguments is in call log' do
       actual_call_log = [{
         args: ['I am an argument', 'as am I'],
         stdin: []
       }]
-      @subject = Rspec::Bash::CallLog.new(mock_log_pathname)
-      @subject.call_log = actual_call_log
+      subject.call_log = actual_call_log
 
-      expect(@subject.called_with_no_args?).to be_falsey
+      expect(subject.called_with_no_args?).to be_falsey
     end
   end
 
   context '#add_log' do
     context 'with any setup' do
-      subject { Rspec::Bash::CallLog.new(mock_log_pathname) }
-
-      context 'with no existing configuration' do
+      context 'with no existing log' do
         let(:expected_log) do
           [
             {
@@ -111,11 +107,6 @@ describe 'CallLog' do
           subject.add_log('first_stdin', %w(first_argument second_argument))
           expect(subject.call_log).to eql expected_log
         end
-
-        it 'writes that log to its log file' do
-          expect(mock_log_file).to receive(:write).with(expected_log.to_yaml)
-          subject.add_log('first_stdin', %w(first_argument second_argument))
-        end
       end
       context 'with an existing log' do
         let(:expected_log) do
@@ -130,7 +121,7 @@ describe 'CallLog' do
             }
           ]
         end
-        before(:each) do
+        before do
           subject.call_log = [
             {
               args: %w(first_argument second_argument),
@@ -142,64 +133,14 @@ describe 'CallLog' do
           subject.add_log('second_stdin', %w(first_argument))
           expect(subject.call_log).to eql expected_log
         end
-
-        it 'writes that log to its log file' do
-          expect(mock_log_file).to receive(:write).with(expected_log.to_yaml)
-          subject.add_log('second_stdin', %w(first_argument))
-        end
-      end
-    end
-    context 'with no config_path' do
-      subject { Rspec::Bash::CallConfiguration.new(nil, anything) }
-      it 'raises an error' do
-        expect do
-          subject.add_output('new_content', :stderr, %w(first_argument second_argument))
-        end.to raise_exception(NoMethodError)
       end
     end
   end
   context '#call_log' do
-    context 'when there is no call_log_path' do
-      subject { Rspec::Bash::CallLog.new(nil) }
-      it 'returns an empty array' do
-        expect(subject.call_log).to eql []
-      end
-    end
     context 'when the call log exists but is empty' do
-      subject { Rspec::Bash::CallLog.new(mock_log_pathname) }
-      before(:each) do
-        allow(mock_log_file).to receive(:read).and_return('')
-      end
-      it 'returns an empty array' do
-        expect(subject.call_log).to eql []
-      end
-    end
-    context 'when the call log file open throws a file not found exception' do
-      subject { Rspec::Bash::CallLog.new(mock_log_pathname) }
-      before(:each) do
-        allow(mock_log_pathname).to receive(:open).with('r').and_raise(Errno::ENOENT)
-      end
       it 'returns an empty array' do
         expect(subject.call_log).to eql []
       end
     end
-    context 'when setup is valid' do
-      subject { Rspec::Bash::CallLog.new(mock_log_pathname) }
-      let(:log) do
-        [{
-          args: %w(first_argument second_argument),
-          stdin: 'first_stdin'
-        }]
-      end
-      context 'and a call log exists' do
-        before(:each) do
-          allow(mock_log_file).to receive(:read).and_return(log.to_yaml)
-        end
-
-        it 'reads out what was in its configuration file' do
-          expect(subject.call_log).to eql log
-        end
-      end
-    end
   end
 end

data/spec/classes/command/stubbed_command_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+include Rspec::Bash
+
+describe 'StubbedCommand' do
+  let(:call_log_manager) { double(CallLogManager) }
+  let(:call_conf_manager) { double(CallConfigurationManager) }
+
+  subject { StubbedCommand.new('command', call_log_manager, call_conf_manager) }
+
+  context '#called_with_args?' do
+    context 'with only a series of arguments' do
+      it 'passes the check to its CallLog\'s #called_with_args? method' do
+        expect(call_log_manager).to receive(:called_with_args?)
+          .with('command', %w(first_argument second_argument))
+          .and_return(true)
+        subject.called_with_args?('first_argument', 'second_argument')
+      end
+    end
+  end
+
+  context '#with_args' do
+    before do
+      subject.with_args('argument_one', 'argument_two')
+    end
+
+    it 'sets the arguments array on the StubbedCommand to the arguments that were passed in' do
+      expect(subject.arguments).to eql %w(argument_one argument_two)
+    end
+  end
+
+  context '#call_count' do
+    it 'returns value returned from call_log argument count when there are no arguments' do
+      expect(call_log_manager).to(
+        receive(:call_count)
+          .with('command', [])
+          .and_return('arbitrary return value')
+      )
+
+      expect(subject.call_count).to eql 'arbitrary return value'
+    end
+    it 'returns value returned from call_log argument count when there is only one argument' do
+      expect(call_log_manager).to receive(:call_count)
+        .with('command', ['only arg'])
+        .and_return('arbitrary return value')
+
+      expect(subject.call_count('only arg')).to eql 'arbitrary return value'
+    end
+    it 'returns value returned from call_log argument count when there are multiple  arguments' do
+      expect(call_log_manager).to receive(:call_count)
+        .with('command', ['first arg', 'second arg'])
+        .and_return('arbitrary return value')
+
+      expect(subject.call_count('first arg', 'second arg')).to eql 'arbitrary return value'
+    end
+  end
+
+  context '#called?' do
+    it 'returns false when call_log is not called with args' do
+      expect(call_log_manager).to receive(:called_with_args?).and_return(false)
+
+      expect(subject.called?).to be_falsey
+    end
+    it 'returns true when call_log is called with args' do
+      expect(call_log_manager).to receive(:called_with_args?).and_return(true)
+
+      expect(subject.called?).to be_truthy
+    end
+  end
+
+  context '#stdin' do
+    it 'returns stdin from call log when call_log exists' do
+      expect(call_log_manager).to receive(:stdin_for_args).and_return('arbitrary stdin')
+
+      expect(subject.stdin).to eql 'arbitrary stdin'
+    end
+  end
+
+  context '#returns_exitstatus' do
+    it 'sets the exitcode on call_configuration' do
+      expect(call_conf_manager).to receive(:set_exitcode).with('command', 'exit code', anything)
+
+      subject.returns_exitstatus 'exit code'
+    end
+    it 'returns itself' do
+      expect(call_conf_manager).to receive(:set_exitcode)
+
+      expect(subject.returns_exitstatus(anything)).to eql subject
+    end
+  end
+
+  context '#outputs' do
+    it 'sets the output on the call_configuration' do
+      expect(call_conf_manager).to receive(:add_output).with(
+        'command',
+        'contents',
+        'stderr',
+        anything
+      )
+
+      subject.outputs('contents', to: 'stderr')
+    end
+    it 'sets the "to" value for the output to stdout by default' do
+      expect(call_conf_manager).to receive(:add_output).with(
+        'command',
+        'contents',
+        :stdout,
+        anything
+      )
+
+      subject.outputs('contents')
+    end
+    it 'returns itself' do
+      expect(call_conf_manager).to receive(:add_output)
+
+      expect(subject.outputs(anything)).to eql subject
+    end
+  end
+end

data/spec/classes/server/bash_stub_marshaller_spec.rb

@@ -0,0 +1,38 @@
+require 'spec_helper'
+include Rspec::Bash
+
+describe 'BashStubMarshaller' do
+  subject { BashStubMarshaller.new }
+
+  context '#unmarshal' do
+    before do
+      allow(JSON).to receive(:parse)
+        .with('message_to_unmarshal')
+        .and_return('message.child' => 'unmarshalled')
+      allow(Sparsify).to receive(:unsparse)
+        .with('message.child' => 'unmarshalled')
+        .and_return(message: { child: 'unmarshalled' })
+      allow(JSON).to receive(:parse)
+        .with('{"message":{"child":"unmarshalled"}}', symbolize_names: true)
+        .and_return(message: { child: 'unmarshalled' })
+    end
+    it 'uses the JSON and sparsify libraries to unflatten the data' do
+      expect(subject.unmarshal('message_to_unmarshal'))
+        .to eql(message: { child: 'unmarshalled' })
+    end
+  end
+  context '#marshal' do
+    before do
+      allow(Sparsify).to receive(:sparse)
+        .with({ message: { child: 'unmarshalled' } }, sparse_array: true)
+        .and_return(:'message.child' => 'unmarshalled')
+      allow(JSON).to receive(:pretty_generate)
+        .with({ :'message.child' => 'unmarshalled' }, indent: '', space: '')
+        .and_return("{\n\"message.child\":\"unmarshalled\"\n}")
+    end
+    it 'uses the JSON and sparsify libraries to flatten the data' do
+      expect(subject.marshal(message: { child: 'unmarshalled' }))
+        .to eql("{\n\"message.child\":\"unmarshalled\"\n}")
+    end
+  end
+end

data/spec/classes/server/ruby_stub_marshaller_spec.rb

@@ -0,0 +1,31 @@
+require 'spec_helper'
+include Rspec::Bash
+
+describe 'RubyStubMarshaller' do
+  subject { RubyStubMarshaller.new }
+
+  context '#unmarshal' do
+    before do
+      allow(Marshal).to receive(:load)
+        .with('message_to_unmarshal')
+        .and_return(message: 'unmarshalled')
+    end
+
+    it 'uses the built-in marshal library to unmarshal the data' do
+      expect(subject.unmarshal('message_to_unmarshal'))
+        .to eql(message: 'unmarshalled')
+    end
+  end
+  context '#marshal' do
+    before do
+      allow(Marshal).to receive(:dump)
+        .with(message: 'unmarshalled')
+        .and_return('marshalled_message')
+    end
+
+    it 'uses the built-in marshal library to marshal the data' do
+      expect(subject.marshal(message: 'unmarshalled'))
+        .to eql('marshalled_message')
+    end
+  end
+end

data/spec/classes/server/stub_server_spec.rb

@@ -0,0 +1,121 @@
+require 'spec_helper'
+include Rspec::Bash
+
+describe 'StubServer' do
+  let(:call_log_manager) { double(CallLogManager) }
+  let(:call_conf_manager) { double(CallConfigurationManager) }
+  let(:stub_marshaller) { double(RubyStubMarshaller) }
+  let(:tcp_server) { double(TCPServer) }
+  let(:accept_thread) { double(Thread) }
+
+  subject { StubServer.new(call_log_manager, call_conf_manager, stub_marshaller) }
+
+  context '#start' do
+    before do
+      allow(accept_thread).to receive(:kill)
+      allow(subject).to receive(:accept_loop)
+      allow(Thread).to receive(:new)
+        .and_yield
+        .and_return(accept_thread)
+    end
+
+    it 'returns the thread that the server is accepting connections on' do
+      expect(subject.start(tcp_server)).to eql(accept_thread)
+    end
+    it 'enters the accept loop' do
+      expect(subject).to receive(:accept_loop)
+        .with(tcp_server)
+      subject.start(tcp_server)
+    end
+  end
+  context '#accept_loop' do
+    let(:tcp_server) { double(TCPServer) }
+    let(:tcp_socket) { double(TCPSocket) }
+
+    before do
+      allow(tcp_server).to receive(:accept)
+        .and_return(tcp_socket)
+      allow(tcp_socket).to receive(:read)
+        .and_return('client_message')
+      allow(subject).to receive(:process)
+        .with('client_message')
+        .and_return('server_message')
+    end
+    it 'accepts the connection and replies' do
+      expect(tcp_socket).to receive(:write)
+        .with('server_message')
+      expect(tcp_socket).to receive(:close)
+
+      subject.accept_loop(tcp_server, false)
+    end
+  end
+  context '#process' do
+    let(:client_message) do
+      {
+        command: 'first_command',
+        stdin:   'stdin',
+        args:    %w(first_argument second_argument)
+      }
+    end
+    let(:server_message) do
+      {
+        args:     %w(first_argument second_argument),
+        exitcode: 0,
+        outputs:  []
+      }
+    end
+    it 'calls its marshaller to serialize and deserialize messages' do
+      expect(stub_marshaller).to receive(:unmarshal)
+        .with('client_message')
+        .and_return(client_message)
+
+      expect(subject).to receive(:process_stub_call)
+        .with(client_message)
+        .and_return(server_message)
+
+      expect(stub_marshaller).to receive(:marshal)
+        .with(server_message)
+        .and_return('server_message')
+
+      expect(subject.process('client_message'))
+        .to eql 'server_message'
+    end
+  end
+  context '#process_stub_call' do
+    before do
+      allow(call_log_manager).to receive(:add_log)
+      allow(call_conf_manager).to receive(:get_best_call_conf)
+        .with('first_command', %w(first_argument second_argument))
+        .and_return(
+          args:     %w(first_argument second_argument),
+          exitcode: 0,
+          outputs:  []
+        )
+    end
+
+    it 'logs the call for the command' do
+      expect(call_log_manager).to receive(:add_log)
+        .with('first_command', 'stdin', %w(first_argument second_argument))
+
+      subject.process_stub_call(
+        command: 'first_command',
+        stdin:   'stdin',
+        args:    %w(first_argument second_argument)
+      )
+    end
+
+    it 'returns the best matching call configuration for the command' do
+      expect(
+        subject.process_stub_call(
+          command: 'first_command',
+          stdin:   'stdin',
+          args:    %w(first_argument second_argument)
+        )
+      ).to eql(
+        args:     %w(first_argument second_argument),
+        exitcode: 0,
+        outputs:  []
+      )
+    end
+  end
+end