gorgon 0.11.0 → 0.11.1

data/spec/originator_spec.rb

@@ -1,6 +1,8 @@
 require 'gorgon/originator'
+require File.expand_path("../support/stream_helpers", __FILE__)
 
-describe Originator do
+describe Gorgon::Originator do
+  include Gorgon::StreamHelpers
   let(:protocol){ double("Originator Protocol", :connect => nil, :publish_files => nil,
     :publish_job_to_all => nil, :publish_job_to_one => nil, :receive_payloads => nil, :cancel_job => nil,
     :disconnect => nil, :receive_new_listener_notifications => nil)}
@@ -10,15 +12,16 @@ describe Originator do
     :add_observer => nil)}
   let(:progress_bar_view){ double("Progress Bar View", :show => nil)}
   let(:originator_logger){ double("Originator Logger", :log => nil, :log_message => nil)}
-  let(:source_tree_syncer) { double("Source Tree Syncer", :push => nil, :exclude= => nil, :success? => true,
-    :sys_command => 'command')}
-  let(:job_definition){ JobDefinition.new }
+  let(:source_tree_syncer) { double("Source Tree Syncer")}
+  let(:sync_execution_context) { double("Sync Execution Context", success: true, command: "command")}
+  let(:job_definition){ Gorgon::JobDefinition.new }
 
   before do
-    OriginatorLogger.stub(:new).and_return originator_logger
-    SourceTreeSyncer.stub(:new).and_return source_tree_syncer
-    Dir.stub(:[]).and_return(["file"])
-    @originator = Originator.new
+    allow(Gorgon::OriginatorLogger).to receive(:new).and_return originator_logger
+    allow(Gorgon::SourceTreeSyncer).to receive(:new).and_return source_tree_syncer
+    allow(source_tree_syncer).to receive(:push).and_return(sync_execution_context)
+    allow(Dir).to receive(:[]).and_return(["file"])
+    @originator = Gorgon::Originator.new
   end
 
   describe "#publish" do
@@ -27,61 +30,63 @@ describe Originator do
     end
 
     it "creates a JobState instance and passes total files" do
-      @originator.stub(:files).and_return ["a file", "other file"]
-      JobState.should_receive(:new).with(2).and_return job_state
+      allow(@originator).to receive(:files).and_return ["a file", "other file"]
+      expect(Gorgon::JobState).to receive(:new).with(2).and_return job_state
 
       @originator.publish
     end
 
     it "propagates the success result of handle_reply" do
-      @originator.publish.should eq Originator::SPEC_SUCCESS_EXIT_STATUS
+      expect(@originator.publish).to eq Gorgon::Originator::SPEC_SUCCESS_EXIT_STATUS
     end
 
     it "propagates the error result of handle_reply" do
-      OriginatorProtocol.should_receive(:new).and_return(protocol)
-      protocol.should_receive(:receive_payloads).and_yield(Yajl::Encoder.encode({:type => 'fail'}))
+      expect(Gorgon::OriginatorProtocol).to receive(:new).and_return(protocol)
+      expect(protocol).to receive(:receive_payloads).and_yield(Yajl::Encoder.encode({:type => 'fail'}))
 
-      @originator.publish.should eq Originator::SPEC_FAILURE_EXIT_STATUS
+      silence_streams($stdout) do
+        expect(@originator.publish).to eq Gorgon::Originator::SPEC_FAILURE_EXIT_STATUS
+      end
     end
 
     it "creates a ProgressBarView and show" do
-      JobState.stub(:new).and_return job_state
-      ProgressBarView.should_receive(:new).with(job_state).and_return progress_bar_view
-      progress_bar_view.should_receive(:show)
+      allow(Gorgon::JobState).to receive(:new).and_return job_state
+      expect(Gorgon::ProgressBarView).to receive(:new).with(job_state).and_return progress_bar_view
+      expect(progress_bar_view).to receive(:show)
       @originator.publish
     end
 
     it "pushes source code" do
-      source_tree_syncer.should_receive(:push)
-      source_tree_syncer.should_receive(:success?).and_return true
+      expect(source_tree_syncer).to receive(:push).and_return(sync_execution_context)
+      expect(sync_execution_context).to receive(:success).and_return true
 
       @originator.publish
     end
 
     it "errors and halts when there are no test files" do
-      Dir.stub(:[] => [])
+      allow(Dir).to receive(:[]).and_return([])
 
-      $stderr.should_receive(:puts)
-      OriginatorProtocol.should_not_receive(:new)
-      source_tree_syncer.should_not_receive(:push)
+      expect($stderr).to receive(:puts)
+      expect(Gorgon::OriginatorProtocol).not_to receive(:new)
+      expect(source_tree_syncer).not_to receive(:push)
 
       expect { @originator.publish }.to raise_error(SystemExit)
     end
 
     it "calls before_originate callback" do
-      CallbackHandler.any_instance.should_receive(:before_originate)
+      expect_any_instance_of(Gorgon::CallbackHandler).to receive(:before_originate)
       @originator.publish
     end
 
     it "uses results of before_originate callback to build a job_queue_name" do
-      CallbackHandler.any_instance.stub(:before_originate).and_return('job_1')
-      OriginatorProtocol.should_receive(:new).with(anything, 'job_1')
+      allow_any_instance_of(Gorgon::CallbackHandler).to receive(:before_originate).and_return('job_1')
+      expect(Gorgon::OriginatorProtocol).to receive(:new).with(anything, 'job_1')
 
       @originator.publish
     end
 
     it "calls after_job_finishes callback" do
-      CallbackHandler.any_instance.should_receive(:after_job_finishes)
+      expect_any_instance_of(Gorgon::CallbackHandler).to receive(:after_job_finishes)
 
       @originator.publish
     end
@@ -93,12 +98,12 @@ describe Originator do
     end
 
     it "exits with a non-zero status code when the originator crashes" do
-      originator_logger.stub(:log_error)
+      allow(originator_logger).to receive(:log_error)
       $stderr = StringIO.new # slurp up the error output so we don't pollute the rspec run
-      CallbackHandler.any_instance.should_receive(:before_originate).and_throw("I'm an unhandled exception")
+      expect_any_instance_of(Gorgon::CallbackHandler).to receive(:before_originate).and_throw("I'm an unhandled exception")
 
       expect { @originator.originate }.to raise_error(SystemExit) do |error|
-        error.success?.should be_false
+        expect(error.success?).to be_falsey
       end
       $stderr = STDERR
     end
@@ -111,12 +116,12 @@ describe Originator do
 
     it 'tells ShutdownManager to cancel_job' do
       shutdown_manager = double('ShutdownManager')
-      JobState.stub(:new).and_return job_state
+      allow(Gorgon::JobState).to receive(:new).and_return job_state
 
-      ShutdownManager.should_receive(:new).
+      expect(Gorgon::ShutdownManager).to receive(:new).
           with(hash_including(protocol: protocol, job_state: job_state)).
           and_return(shutdown_manager)
-      shutdown_manager.should_receive(:cancel_job)
+      expect(shutdown_manager).to receive(:cancel_job)
 
       @originator.publish
       @originator.cancel_job
@@ -126,18 +131,18 @@ describe Originator do
   describe "#cleanup_if_job_complete" do
     before do
       stub_methods
-      JobState.stub(:new).and_return job_state
+      allow(Gorgon::JobState).to receive(:new).and_return job_state
       @originator.publish
     end
 
     it "calls JobState#is_job_complete?" do
-      job_state.should_receive(:is_job_complete?).and_return false
+      expect(job_state).to receive(:is_job_complete?).and_return false
       @originator.cleanup_if_job_complete
     end
 
     it "disconnect if job is complete" do
-      job_state.stub(:is_job_complete?).and_return true
-      protocol.should_receive(:disconnect)
+      allow(job_state).to receive(:is_job_complete?).and_return true
+      expect(protocol).to receive(:disconnect)
       @originator.cleanup_if_job_complete
     end
   end
@@ -145,47 +150,51 @@ describe Originator do
   describe "#handle_reply" do
     before do
       stub_methods
-      JobState.stub(:new).and_return job_state
+      allow(Gorgon::JobState).to receive(:new).and_return job_state
       @originator.publish
     end
 
     it "returns SPEC_SUCCESS_EXIT_STATUS when payload[:action] is start" do
-      job_state.stub(:file_started)
-      @originator.handle_reply(start_payload).should eq Originator::SPEC_SUCCESS_EXIT_STATUS
+      allow(job_state).to receive(:file_started)
+      expect(@originator.handle_reply(start_payload)).to eq Gorgon::Originator::SPEC_SUCCESS_EXIT_STATUS
     end
 
     it "returns SPEC_SUCCESS_EXIT_STATUS when payload[:action] is finish" do
-      job_state.stub(:file_finished)
-      @originator.handle_reply(finish_payload).should eq Originator::SPEC_SUCCESS_EXIT_STATUS
+      allow(job_state).to receive(:file_finished)
+      expect(@originator.handle_reply(finish_payload)).to eq Gorgon::Originator::SPEC_SUCCESS_EXIT_STATUS
     end
 
     it "returns SPEC_FAILURE_EXIT_STATUS when payload[:action] is crash" do
-      job_state.stub(:gorgon_crash_message)
-      @originator.handle_reply(Yajl::Encoder.encode(gorgon_crash_message)).should eq Originator::SPEC_FAILURE_EXIT_STATUS
+      allow(job_state).to receive(:gorgon_crash_message)
+      expect(@originator.handle_reply(Yajl::Encoder.encode(gorgon_crash_message))).to eq Gorgon::Originator::SPEC_FAILURE_EXIT_STATUS
     end
 
     it "returns SPEC_FAILURE_EXIT_STATUS when payload[:action] is exception" do
-      @originator.handle_reply(Yajl::Encoder.encode({:type => 'exception'})).should eq Originator::SPEC_FAILURE_EXIT_STATUS
+      silence_streams($stdout) do
+        expect(@originator.handle_reply(Yajl::Encoder.encode({:type => 'exception'}))).to eq Gorgon::Originator::SPEC_FAILURE_EXIT_STATUS
+      end
     end
 
     it "returns SPEC_FAILURE_EXIT_STATUS when payload[:action] is fail" do
-      @originator.handle_reply(Yajl::Encoder.encode({:type => 'fail'})).should eq Originator::SPEC_FAILURE_EXIT_STATUS
+      silence_streams($stdout) do
+        expect(@originator.handle_reply(Yajl::Encoder.encode({:type => 'fail'}))).to eq Gorgon::Originator::SPEC_FAILURE_EXIT_STATUS
+      end
     end
 
     it "calls cleanup_if_job_complete" do
-      @originator.should_receive(:cleanup_if_job_complete)
+      expect(@originator).to receive(:cleanup_if_job_complete)
       @originator.handle_reply finish_payload
     end
 
     it "calls JobState#file_started if payload[:action] is 'start'" do
       Yajl::Parser.new(:symbolize_keys => true).parse(start_payload)
-      job_state.should_receive(:file_started)
+      expect(job_state).to receive(:file_started)
       @originator.handle_reply(start_payload)
     end
 
     it "calls JobState#file_finished if payload[:action] is 'finish'" do
       payload = Yajl::Parser.new(:symbolize_keys => true).parse(finish_payload)
-      job_state.should_receive(:file_finished).with(payload)
+      expect(job_state).to receive(:file_finished).with(payload)
       @originator.handle_reply(finish_payload)
     end
 
@@ -193,7 +202,7 @@ describe Originator do
         :stdout => "some output", :stderr => "some errors"}}
 
     it "calls JobState#gorgon_crash_message if payload[:type] is 'crash'" do
-      job_state.should_receive(:gorgon_crash_message).with(gorgon_crash_message)
+      expect(job_state).to receive(:gorgon_crash_message).with(gorgon_crash_message)
       @originator.handle_reply(Yajl::Encoder.encode(gorgon_crash_message))
     end
   end
@@ -203,48 +212,48 @@ describe Originator do
       stub_methods
       @originator.publish
 
-      protocol.should_receive(:publish_job_to_one).with(job_definition, 'abcd1234')
+      expect(protocol).to receive(:publish_job_to_one).with(job_definition, 'abcd1234')
       @originator.handle_new_listener_notification({:listener_queue_name => 'abcd1234'}.to_json)
     end
   end
 
   describe "#job_definition" do
     it "returns a JobDefinition object" do
-      @originator.stub(:configuration).and_return configuration
-      job_definition = JobDefinition.new
-      JobDefinition.should_receive(:new).and_return job_definition
-      @originator.job_definition.should equal job_definition
+      allow(@originator).to receive(:configuration).and_return configuration
+      job_definition = Gorgon::JobDefinition.new
+      expect(Gorgon::JobDefinition).to receive(:new).and_return job_definition
+      expect(@originator.job_definition).to equal job_definition
     end
 
     it "builds anonymous source_tree_path if it was not specified in the configuration" do
-      @originator.stub(:configuration).and_return(configuration.merge(:file_server => {:host => 'host-name'}))
-      Socket.stub(:gethostname => 'my-host')
-      Dir.stub(:pwd => 'dir')
+      allow(@originator).to receive(:configuration).and_return(configuration.merge(:file_server => {:host => 'host-name'}))
+      allow(Socket).to receive(:gethostname).and_return('my-host')
+      allow(Dir).to receive(:pwd).and_return('dir')
 
-      @originator.job_definition.sync[:source_tree_path].should == "rsync://host-name:43434/src/my-host_dir"
+      expect(@originator.job_definition.sync[:source_tree_path]).to eq("rsync://host-name:43434/src/my-host_dir")
     end
 
     it "builds ssh source_tree_path if using ssh rsync transport" do
-      @originator.stub(:configuration).and_return(configuration.merge(
+      allow(@originator).to receive(:configuration).and_return(configuration.merge(
         :file_server => {:host => 'host-name'},
         :job => { :sync => { :rsync_transport => 'ssh'}}
       ))
-      Socket.stub(:gethostname => 'my-host')
-      Dir.stub(:pwd => 'dir')
+      allow(Socket).to receive(:gethostname).and_return('my-host')
+      allow(Dir).to receive(:pwd).and_return('dir')
 
-      @originator.job_definition.sync[:source_tree_path].should == "host-name:my-host_dir"
+      expect(@originator.job_definition.sync[:source_tree_path]).to eq("host-name:my-host_dir")
     end
   end
 
   private
 
   def stub_methods
-    EventMachine.stub(:run).and_yield
-    ProgressBarView.stub(:new).and_return progress_bar_view
-    OriginatorProtocol.stub(:new).and_return protocol
-    @originator.stub(:configuration).and_return configuration
-    @originator.stub(:connection_information).and_return 'host'
-    @originator.stub(:job_definition).and_return job_definition
+    allow(EventMachine).to receive(:run).and_yield
+    allow(Gorgon::ProgressBarView).to receive(:new).and_return progress_bar_view
+    allow(Gorgon::OriginatorProtocol).to receive(:new).and_return protocol
+    allow(@originator).to receive(:configuration).and_return configuration
+    allow(@originator).to receive(:connection_information).and_return 'host'
+    allow(@originator).to receive(:job_definition).and_return job_definition
   end
 
   def start_payload

data/spec/ping_service_spec.rb

@@ -1,6 +1,6 @@
 require 'gorgon/ping_service'
 
-describe "PingService" do
+describe Gorgon::PingService do
   describe "#ping_listeners" do
     let(:configuration){ {:connection => {:host => "host"}, :originator_log_file => "file.log"}}
     let(:protocol) { double("OriginatorProtocol", :connect => nil, :ping => nil,
@@ -9,34 +9,34 @@ describe "PingService" do
     let(:logger){ double("Originator Logger", :log => nil, :log_message => nil)}
 
     before do
-      $stdout.stub(:write)
-      PingService.any_instance.stub(:load_configuration_from_file).and_return configuration
-      EventMachine.stub(:run).and_yield
-      EM.stub(:add_timer).and_yield
-      OriginatorLogger.stub(:new).and_return logger
+      allow($stdout).to receive(:write)
+      allow_any_instance_of(Gorgon::PingService).to receive(:load_configuration_from_file).and_return configuration
+      allow(EventMachine).to receive(:run).and_yield
+      allow(EM).to receive(:add_timer).and_yield
+      allow(Gorgon::OriginatorLogger).to receive(:new).and_return logger
     end
 
     it "connnects and calls OriginatorProtocol#send_message_to_listeners" do
-      OriginatorProtocol.should_receive(:new).once.ordered.and_return(protocol)
-      protocol.should_receive(:connect).once.ordered.with({:host => "host"}, anything)
-      protocol.should_receive(:send_message_to_listeners).once.ordered
-      PingService.new.ping_listeners
+      expect(Gorgon::OriginatorProtocol).to receive(:new).once.ordered.and_return(protocol)
+      expect(protocol).to receive(:connect).once.ordered.with({:host => "host"}, anything)
+      expect(protocol).to receive(:send_message_to_listeners).once.ordered
+      Gorgon::PingService.new.ping_listeners
     end
 
     context "after sending ping messages" do
       before do
-        OriginatorProtocol.stub(:new).and_return(protocol)
-        @service = PingService.new
+        allow(Gorgon::OriginatorProtocol).to receive(:new).and_return(protocol)
+        @service = Gorgon::PingService.new
       end
 
       it "adds an Event machine timer" do
-        EM.should_receive(:add_timer).and_yield
+        expect(EM).to receive(:add_timer).and_yield
         @service.ping_listeners
       end
 
       it "receives a ping_response message" do
         payload = {:type => "ping_response", :hostname => "host", :version => "1.1.1"}
-        protocol.should_receive(:receive_payloads).and_yield Yajl::Encoder.encode(payload)
+        expect(protocol).to receive(:receive_payloads).and_yield Yajl::Encoder.encode(payload)
         @service.ping_listeners
       end
     end

data/spec/pipe_forker_spec.rb

@@ -1,53 +1,53 @@
 require 'gorgon/pipe_forker'
 
-describe PipeForker do
+describe Gorgon::PipeForker do
   let(:io_pipe) { double("IO object", :close => nil)}
   let(:pipe) {double("Pipe", :write => io_pipe)}
 
   let(:container_class) do
     Class.new do
-      extend(PipeForker)
+      extend(Gorgon::PipeForker)
     end
   end
 
   before do
-    IO.stub(:pipe).and_return([io_pipe, io_pipe])
-    STDIN.stub(:reopen)
-    container_class.stub(:fork).and_yield.and_return(1)
-    container_class.stub(:exit)
+    allow(IO).to receive(:pipe).and_return([io_pipe, io_pipe])
+    allow(STDIN).to receive(:reopen)
+    allow(container_class).to receive(:fork).and_yield.and_return(1)
+    allow(container_class).to receive(:exit)
   end
 
   describe ".pipe_fork" do
     it "creates a new pipe" do
-      IO.should_receive(:pipe).once.and_return ([io_pipe,io_pipe])
+      expect(IO).to receive(:pipe).once.and_return ([io_pipe,io_pipe])
       container_class.pipe_fork { }
     end
 
     it "forks once" do
-      container_class.should_receive(:fork).and_yield
+      expect(container_class).to receive(:fork).and_yield
       container_class.pipe_fork { }
     end
 
     it "closes both side of pipe inside child and read in parent" do
-      io_pipe.should_receive(:close).exactly(3).times
+      expect(io_pipe).to receive(:close).exactly(3).times
       container_class.pipe_fork { }
     end
 
     it "reopens stdin with a pipe" do
-      STDIN.should_receive(:reopen).with(io_pipe)
+      expect(STDIN).to receive(:reopen).with(io_pipe)
       container_class.pipe_fork { }
     end
 
     it "yields" do
       has_yielded = false
       container_class.pipe_fork { has_yielded = true }
-      has_yielded.should be_true
+      expect(has_yielded).to be_truthy
     end
 
     it "returns pid of new process and a pipe" do
       pid, stdin = container_class.pipe_fork { }
-      pid.should be 1
-      stdin.should == io_pipe
+      expect(pid).to eq(1)
+      expect(stdin).to eq(io_pipe)
     end
   end
 end

data/spec/progress_bar_view_spec.rb

@@ -1,28 +1,28 @@
 require 'gorgon/progress_bar_view'
 require 'gorgon/job_state'
 
-describe ProgressBarView do
+describe Gorgon::ProgressBarView do
   before do
-    EventMachine::PeriodicTimer.stub(:new)
+    allow(EventMachine::PeriodicTimer).to receive(:new)
   end
 
   describe "#initialize" do
     it "adds itself to observers of job_state" do
-      job_state = JobState.new 1
-      job_state.should_receive(:add_observer)
-      ProgressBarView.new job_state
+      job_state = Gorgon::JobState.new 1
+      expect(job_state).to receive(:add_observer)
+      Gorgon::ProgressBarView.new job_state
     end
   end
 
   describe "#show" do
     before do
-      job_state = JobState.new 1
-      @progress_bar_view = ProgressBarView.new job_state
+      job_state = Gorgon::JobState.new 1
+      @progress_bar_view = Gorgon::ProgressBarView.new job_state
     end
 
     it "prints in console gorgon's version and that is loading workers" do
-      $stdout.should_receive(:write).with(/loading .*workers/i)
-      ProgressBar.should_not_receive(:create)
+      expect($stdout).to receive(:write).with(/loading .*workers/i)
+      expect(ProgressBar).not_to receive(:create)
       @progress_bar_view.show
     end
   end
@@ -37,64 +37,64 @@ describe ProgressBarView do
     }
 
     before do
-      ProgressBar.stub(:create).and_return progress_bar
-      @job_state = JobState.new 2
-      @job_state.stub(:state).and_return :running
-      @progress_bar_view = ProgressBarView.new @job_state
-      $stdout.stub(:write)
+      allow(ProgressBar).to receive(:create).and_return progress_bar
+      @job_state = Gorgon::JobState.new 2
+      allow(@job_state).to receive(:state).and_return :running
+      @progress_bar_view = Gorgon::ProgressBarView.new @job_state
+      allow($stdout).to receive(:write)
       @progress_bar_view.show
     end
 
     it "doesn't create ProgressBar if JobState is not running" do
-      @job_state.should_receive(:state).and_return :starting
-      ProgressBar.should_not_receive(:create).with(hash_including(:total => 2))
+      expect(@job_state).to receive(:state).and_return :starting
+      expect(ProgressBar).not_to receive(:create).with(hash_including(:total => 2))
       @progress_bar_view.update
     end
 
     it "doesn't create a ProgressBar if one was already created" do
       @progress_bar_view.update
-      ProgressBar.should_not_receive(:create).with(hash_including(:total => 2))
+      expect(ProgressBar).not_to receive(:create).with(hash_including(:total => 2))
       @progress_bar_view.update
     end
 
     it "gets total files from JobState and create a ProgressBar once JobState is running" do
-      ProgressBar.should_receive(:create).with(hash_including(:total => 2))
+      expect(ProgressBar).to receive(:create).with(hash_including(:total => 2))
       @progress_bar_view.update
     end
 
     it "gets finished_files_count" do
-      @job_state.should_receive :finished_files_count
+      expect(@job_state).to receive :finished_files_count
       @progress_bar_view.update
     end
 
     it "gets failed_files_count" do
-      @job_state.should_receive(:failed_files_count).and_return 0
+      expect(@job_state).to receive(:failed_files_count).and_return 0
       @progress_bar_view.update
     end
 
     it "prints failures and finish progress_bar when job is done" do
       @progress_bar_view.update
-      @job_state.stub(:each_failed_test).and_yield(payload)
-      @job_state.stub(:is_job_complete?).and_return :true
-      $stdout.should_receive(:write).with(/Failure messages/)
+      allow(@job_state).to receive(:each_failed_test).and_yield(payload)
+      allow(@job_state).to receive(:is_job_complete?).and_return :true
+      expect($stdout).to   receive(:write).with(/Failure messages/)
       @progress_bar_view.update
     end
 
     context "when job is cancelled" do
       before do
         @progress_bar_view.update
-        @job_state.stub(:is_job_cancelled?).and_return :true
+        allow(@job_state).to receive(:is_job_cancelled?).and_return :true
       end
 
       it "prints failures and finish progress_bar when job is cancelled" do
-        @job_state.stub(:each_failed_test).and_yield(payload)
-        $stdout.should_receive(:write).with(/Failure messages/)
+        allow(@job_state).to receive(:each_failed_test).and_yield(payload)
+        expect($stdout).to receive(:write).with(/Failure messages/)
         @progress_bar_view.update
       end
 
       it "prints files that were running when the job was cancelled" do
-        @job_state.should_receive(:each_running_file).and_yield("hostname", "file1.rb")
-        $stdout.should_receive(:write).with(/file1\.rb.*hostname/)
+        expect(@job_state).to receive(:each_running_file).and_yield("hostname", "file1.rb")
+        expect($stdout).to receive(:write).with(/file1\.rb.*hostname/)
         @progress_bar_view.update
       end
     end
@@ -103,10 +103,10 @@ describe ProgressBarView do
       let(:crash_message) {{:type => "crash", :hostname => "host",
           :stdout => "some output", :stderr => "some errors"}}
       it "prints info about crash in standard error" do
-        $stderr.stub(:write)
-        $stderr.should_receive(:write).with(/crash.*host/i)
-        $stderr.should_receive(:write).with(/some output/i)
-        $stderr.should_receive(:write).with(/some errors/i)
+        allow($stderr).to receive(:write)
+        expect($stderr).to receive(:write).with(/crash.*host/i)
+        expect($stderr).to receive(:write).with(/some output/i)
+        expect($stderr).to receive(:write).with(/some errors/i)
         @progress_bar_view.update crash_message
       end
     end