gorgon 0.11.0 → 0.11.1

data/spec/listener_spec.rb

@@ -1,65 +1,66 @@
 require 'gorgon/listener'
 
-describe Listener do
+describe Gorgon::Listener do
   let(:connection_information) { double }
   let(:queue) { double("GorgonBunny Queue", :bind => nil, :name => "some supposedly unique string") }
   let(:exchange) { double("GorgonBunny Exchange", :publish => nil) }
   let(:bunny) { double("GorgonBunny", :start => nil, :queue => queue, :exchange => exchange) }
   let(:logger) { double("Logger", :info => true, :datetime_format= => "")}
+  let(:sync_execution_context) { double("Sync Execution Context", success: true, command: "command", output: "some output", errors: "some errors")}
 
   before do
-    Logger.stub(:new).and_return(logger)
-    GorgonBunny.stub(:new).and_return(bunny)
-    Listener.any_instance.stub(:configuration => {})
-    Listener.any_instance.stub(:connection_information => connection_information)
+    allow(Logger).to receive(:new).and_return(logger)
+    allow(GorgonBunny).to receive(:new).and_return(bunny)
+    allow_any_instance_of(Gorgon::Listener).to receive(:configuration).and_return({})
+    allow_any_instance_of(Gorgon::Listener).to receive(:connection_information).and_return(connection_information)
   end
 
   describe "logging to a file" do
     context "passing a log file path in the configuration" do
       before do
-        Listener.any_instance.stub(:configuration).and_return({:log_file => 'listener.log'})
+        allow_any_instance_of(Gorgon::Listener).to receive(:configuration).and_return({:log_file => 'listener.log'})
       end
 
       it "should use 'log_file' from the configuration as the log file" do
-        Logger.should_receive(:new).with('listener.log', anything, anything)
-        Listener.new
+        expect(Logger).to receive(:new).with('listener.log', anything, anything)
+        Gorgon::Listener.new
       end
 
       it "should log to 'log_file'" do
-        logger.should_receive(:info).with(/Listener.*initializing/)
+        expect(logger).to receive(:info).with(/Listener.*initializing/)
 
-        Listener.new
+        Gorgon::Listener.new
       end
     end
 
     context "passing a literal '-'' as the path in the configuration" do
       before do
-        Listener.any_instance.stub(:configuration).and_return({:log_file => "-"})
+        allow_any_instance_of(Gorgon::Listener).to receive(:configuration).and_return({:log_file => "-"})
       end
 
       it "logs to stdout" do
-        Logger.should_receive(:new).with($stdout)
-        Listener.new
+        expect(Logger).to receive(:new).with($stdout)
+        Gorgon::Listener.new
       end
     end
 
     context "without specifying a log file path" do
       it "should not log" do
-        Logger.should_not_receive(:new)
-        logger.should_not_receive(:info)
+        expect(Logger).not_to receive(:new)
+        expect(logger).not_to receive(:info)
 
-        Listener.new
+        Gorgon::Listener.new
       end
     end
   end
 
   context "initialized" do
-    let(:listener) { Listener.new }
+    let(:listener) { Gorgon::Listener.new }
 
     describe "#connect" do
       it "connects" do
-        GorgonBunny.should_receive(:new).with(connection_information).and_return(bunny)
-        bunny.should_receive(:start)
+        expect(GorgonBunny).to receive(:new).with(connection_information).and_return(bunny)
+        expect(bunny).to receive(:start)
 
         listener.connect
       end
@@ -67,21 +68,21 @@ describe Listener do
 
     describe "#initialize_personal_job_queue" do
       it "creates the job queue" do
-        UUIDTools::UUID.stub(:timestamp_create => "abcd1234")
+        allow(UUIDTools::UUID).to receive(:timestamp_create).and_return("abcd1234")
 
-        bunny.should_receive(:queue).with("job_queue_abcd1234", :auto_delete => true)
+        expect(bunny).to receive(:queue).with("job_queue_abcd1234", :auto_delete => true)
         listener.initialize_personal_job_queue
       end
 
       it "builds job_exchange_name using cluster_id from configuration" do
-        Listener.any_instance.stub(:configuration).and_return(:cluster_id => 'cluster5')
-        bunny.should_receive(:exchange).with('gorgon.jobs.cluster5', anything).and_return(exchange)
+        allow_any_instance_of(Gorgon::Listener).to receive(:configuration).and_return(:cluster_id => 'cluster5')
+        expect(bunny).to receive(:exchange).with('gorgon.jobs.cluster5', anything).and_return(exchange)
         listener.initialize_personal_job_queue
       end
 
       it "binds the exchange to the queue. Uses gorgon.jobs if there is no job_exchange_name in configuration" do
-        bunny.should_receive(:exchange).with("gorgon.jobs", :type => :fanout).and_return(exchange)
-        queue.should_receive(:bind).with(exchange)
+        expect(bunny).to receive(:exchange).with("gorgon.jobs", :type => :fanout).and_return(exchange)
+        expect(queue).to receive(:bind).with(exchange)
         listener.initialize_personal_job_queue
       end
     end
@@ -90,8 +91,8 @@ describe Listener do
       it "publishes data to the originator exchange" do
         originator_exchange = double
 
-        bunny.should_receive(:exchange).with("gorgon.originators", :type => :fanout).and_return(originator_exchange)
-        originator_exchange.should_receive(:publish).with({:listener_queue_name => "some supposedly unique string"}.to_json)
+        expect(bunny).to receive(:exchange).with("gorgon.originators", :type => :fanout).and_return(originator_exchange)
+        expect(originator_exchange).to receive(:publish).with({:listener_queue_name => "some supposedly unique string"}.to_json)
 
         listener.announce_readiness_to_originators
       end
@@ -102,37 +103,37 @@ describe Listener do
       let(:empty_queue) { [nil, nil, nil] }
       let(:job_payload) { [nil, nil, Yajl::Encoder.encode({:type => "job_definition"})] }
       before do
-        listener.stub(:run_job)
+        allow(listener).to receive(:run_job)
       end
 
       context "empty queue" do
         before do
-          queue.stub(:pop => empty_queue)
+          allow(queue).to receive(:pop).and_return(empty_queue)
         end
 
         it "checks the job queue" do
-          queue.should_receive(:pop).and_return(empty_queue)
+          expect(queue).to receive(:pop).and_return(empty_queue)
           listener.poll
         end
 
         it "returns false" do
-          listener.poll.should be_false
+          expect(listener.poll).to be_falsey
         end
       end
 
       context "job pending on queue" do
         before do
-          queue.stub(:pop => job_payload)
+          allow(queue).to receive(:pop).and_return(job_payload)
         end
 
         it "starts a new job when there is a job payload" do
-          queue.should_receive(:pop).and_return(job_payload)
-          listener.should_receive(:run_job).with({:type => "job_definition"})
+          expect(queue).to receive(:pop).and_return(job_payload)
+          expect(listener).to receive(:run_job).with({:type => "job_definition"})
           listener.poll
         end
 
         it "returns true" do
-          listener.poll.should be_true
+          expect(listener.poll).to be_truthy
         end
       end
 
@@ -140,16 +141,16 @@ describe Listener do
         let(:ping_payload) { [nil, nil, Yajl::Encoder.encode({:type => "ping", :reply_exchange_name => "name", :body => {}}) ] }
 
         before do
-          queue.stub(:pop => ping_payload)
-          listener.stub(:configuration).and_return({:worker_slots => 3})
+          allow(queue).to receive(:pop).and_return(ping_payload)
+          allow(listener).to receive(:configuration).and_return({:worker_slots => 3})
        end
 
         it "publishes ping_response message with Gorgon's version" do
-          listener.should_not_receive(:run_job)
-          bunny.should_receive(:exchange).with("name", anything).and_return(exchange)
+          expect(listener).not_to receive(:run_job)
+          expect(bunny).to receive(:exchange).with("name", anything).and_return(exchange)
           response = {:type => "ping_response", :hostname => Socket.gethostname,
             :version => Gorgon::VERSION, :worker_slots => 3}
-          exchange.should_receive(:publish).with(Yajl::Encoder.encode(response))
+          expect(exchange).to receive(:publish).with(Yajl::Encoder.encode(response))
           listener.poll
         end
       end
@@ -165,13 +166,13 @@ describe Listener do
         let(:gem_command_handler) { double("GemCommandHandler", :handle => nil)  }
         let(:configuration) { {:worker_slots => 3} }
         before do
-          queue.stub(:pop => [nil, nil, Yajl::Encoder.encode(payload)])
-          listener.stub(:configuration).and_return(configuration)
+          allow(queue).to receive(:pop).and_return([nil, nil, Yajl::Encoder.encode(payload)])
+          allow(listener).to receive(:configuration).and_return(configuration)
         end
 
         it "calls GemCommandHandler#handle and pass payload" do
-          GemCommandHandler.should_receive(:new).with(bunny).and_return gem_command_handler
-          gem_command_handler.should_receive(:handle).with payload, configuration
+          expect(Gorgon::GemCommandHandler).to receive(:new).with(bunny).and_return gem_command_handler
+          expect(gem_command_handler).to receive(:handle).with payload, configuration
           listener.poll
         end
       end
@@ -182,9 +183,7 @@ describe Listener do
           :sync => {:source_tree_path => "path/to/source", :exclude => ["log"]}, :callbacks => {:a_callback => "path/to/callback"}
         }}
 
-      let(:syncer) { double("SourceTreeSyncer", :sync => nil, :exclude= => nil, :success? => true,
-                          :output => "some output", :errors => "some errors",
-                          :remove_temp_dir => nil, :sys_command => "rsync ...")}
+      let(:syncer) { double("SourceTreeSyncer")}
       let(:process_status) { double("Process Status", :exitstatus => 0)}
       let(:callback_handler) { double("Callback Handler", :after_sync => nil) }
       let(:stdin) { double("IO object", :write => nil, :close => nil)}
@@ -193,62 +192,56 @@ describe Listener do
 
       before do
         stub_classes
-        @listener = Listener.new
+        @listener = Gorgon::Listener.new
       end
 
       it "copy source tree" do
-        SourceTreeSyncer.should_receive(:new).once.
+        expect(Gorgon::SourceTreeSyncer).to receive(:new).once.
           with(source_tree_path: "path/to/source", exclude: ["log"]).
           and_return(syncer)
-        syncer.should_receive(:sync)
-        syncer.should_receive(:success?).and_return(true)
+        expect(syncer).to receive(:pull).and_yield(sync_execution_context)
         @listener.run_job(payload)
       end
 
       context "syncer#sync fails" do
         before do
-          syncer.stub(:success?).and_return false
-          syncer.stub(:output).and_return "some output"
-          syncer.stub(:errors).and_return "some errors"
+          allow(sync_execution_context).to receive(:success).and_return false
+          allow(sync_execution_context).to receive(:output).and_return "some output"
+          allow(sync_execution_context).to receive(:errors).and_return "some errors"
         end
 
         it "aborts current job" do
-          callback_handler.should_not_receive(:after_sync)
+          expect(callback_handler).not_to receive(:after_sync)
           @listener.run_job(payload)
         end
 
         it "sends message to originator with output and errors from syncer" do
-          @listener.should_receive(:send_crash_message).with exchange, "some output", "some errors"
+          expect(@listener).to receive(:send_crash_message).with(exchange, "some output", "some errors")
           @listener.run_job(payload)
         end
       end
 
       context "Worker Manager crashes" do
         before do
-          process_status.should_receive(:exitstatus).and_return 2, 2
+          expect(process_status).to receive(:exitstatus).and_return 2, 2
         end
 
         it "report_crash with pid, exitstatus, stdout and stderr outputs" do
-          @listener.should_receive(:report_crash).with(exchange,
-                                                       :out_file => WorkerManager::STDOUT_FILE,
-                                                       :err_file => WorkerManager::STDERR_FILE,
-                                                       :footer_text => Listener::ERROR_FOOTER_TEXT)
+          expect(@listener).to receive(:report_crash).with(exchange,
+                                                       :out_file => Gorgon::WorkerManager::STDOUT_FILE,
+                                                       :err_file => Gorgon::WorkerManager::STDERR_FILE,
+                                                       :footer_text => Gorgon::Listener::ERROR_FOOTER_TEXT)
           @listener.run_job(payload)
         end
       end
 
-      it "remove temp source directory when complete" do
-        syncer.should_receive(:remove_temp_dir)
-        @listener.run_job(payload)
-      end
-
       it "creates a CallbackHandler object using callbacks passed in payload" do
-        CallbackHandler.should_receive(:new).once.with({:a_callback => "path/to/callback"}).and_return(callback_handler)
+        expect(Gorgon::CallbackHandler).to receive(:new).once.with({:a_callback => "path/to/callback"}).and_return(callback_handler)
         @listener.run_job(payload)
       end
 
       it "calls after_sync callback" do
-        callback_handler.should_receive(:after_sync).once
+        expect(callback_handler).to receive(:after_sync).once
         @listener.run_job(payload)
       end
     end
@@ -256,11 +249,12 @@ describe Listener do
     private
 
     def stub_classes
-      SourceTreeSyncer.stub(:new).and_return syncer
-      CallbackHandler.stub(:new).and_return callback_handler
-      Open4.stub(:popen4).and_return([1, stdin, stdout, stderr])
-      Process.stub(:waitpid2).and_return([0, process_status])
-      Socket.stub(:gethostname).and_return("hostname")
+      allow(Gorgon::SourceTreeSyncer).to receive(:new).and_return syncer
+      allow(syncer).to receive(:pull).and_yield(sync_execution_context)
+      allow(Gorgon::CallbackHandler).to receive(:new).and_return callback_handler
+      allow(Open4).to receive(:popen4).and_return([1, stdin, stdout, stderr])
+      allow(Process).to receive(:waitpid2).and_return([0, process_status])
+      allow(Socket).to receive(:gethostname).and_return("hostname")
     end
   end
 end

data/spec/mini_test_runner_spec.rb

@@ -9,29 +9,29 @@ describe MiniTestRunner do
 
     let(:runner) {double("MiniTestUnitRunner", :run => nil, :report => ["report"])}
     before do
-      Object.stub(:load)
-      MiniTestUnitRunner.stub(:new).and_return(runner)
+      allow(Object).to receive(:load)
+      allow(MiniTestUnitRunner).to receive(:new).and_return(runner)
     end
 
     it "clear test cases previously loaded (when a previous file was loaded), and then loads filename" do
-      MiniTest::Unit::TestCase.should_receive(:reset).ordered
-      Object.should_receive(:load).with("file_test.rb").ordered
+      expect(MiniTest::Unit::TestCase).to receive(:reset).ordered
+      expect(Object).to receive(:load).with("file_test.rb").ordered
       MiniTestRunner.run_file "file_test.rb"
     end
 
     it "runs the MiniTestUnitRunner" do
-      runner.should_receive(:run)
+      expect(runner).to receive(:run)
       MiniTestRunner.run_file "file_test.rb"
     end
 
     it "returns runner's report" do
-      MiniTestRunner.run_file("file_test.rb").should == ["report"]
+      expect(MiniTestRunner.run_file("file_test.rb")).to eq(["report"])
     end
   end
 
   describe ".runner" do
     it "returns :minitest" do
-      MiniTestRunner.runner.should == :minitest
+      expect(MiniTestRunner.runner).to eq(:minitest)
     end
   end
 end

data/spec/originator_logger_spec.rb

@@ -1,11 +1,11 @@
 require 'gorgon/originator_logger'
 
-describe OriginatorLogger do
+describe Gorgon::OriginatorLogger do
   before do
-    OriginatorLogger.any_instance.stub(:initialize_logger)
+    allow_any_instance_of(Gorgon::OriginatorLogger).to receive(:initialize_logger)
   end
 
-  let (:originator_logger) { OriginatorLogger.new "" }
+  let (:originator_logger) { Gorgon::OriginatorLogger.new "" }
 
   describe "#log_message" do
     it "prints start messages" do
@@ -13,7 +13,7 @@ describe OriginatorLogger do
                  :hostname => "host",
                  :filename => "filename",
                  :worker_id => "a_worker_id"}
-      originator_logger.should_receive(:log).with("Started running 'filename' at 'host:a_worker_id'")
+      expect(originator_logger).to receive(:log).with("Started running 'filename' at 'host:a_worker_id'")
       originator_logger.log_message(payload)
     end
 
@@ -22,7 +22,7 @@ describe OriginatorLogger do
                  :hostname => "host",
                  :filename => "filename",
                  :worker_id => "a_worker_id"}
-      originator_logger.should_receive(:log).with("Finished running 'filename' at 'host:a_worker_id'")
+      expect(originator_logger).to receive(:log).with("Finished running 'filename' at 'host:a_worker_id'")
       originator_logger.log_message(payload)
     end
 
@@ -36,7 +36,7 @@ describe OriginatorLogger do
                    "failure"
                  ]}
 
-      originator_logger.should_receive(:log).with("Finished running 'filename' at 'host:a_worker_id'failure\n")
+      expect(originator_logger).to receive(:log).with("Finished running 'filename' at 'host:a_worker_id'failure\n")
       originator_logger.log_message(payload)
     end
   end

data/spec/originator_protocol_spec.rb

@@ -1,6 +1,6 @@
 require 'gorgon/originator_protocol'
 
-describe OriginatorProtocol do
+describe Gorgon::OriginatorProtocol do
   let(:connection) { double("Connection", :disconnect => nil, :on_closed => nil)}
   let(:queue) { double("Queue", :bind => nil, :subscribe => nil, :name => "queue", :purge => nil,
                      :delete => nil) }
@@ -10,43 +10,43 @@ describe OriginatorProtocol do
   let(:logger){ double("Logger", :log => nil)}
 
   before do
-    AMQP.stub(:connect).and_return connection
-    AMQP::Channel.stub(:new).and_return channel
-    @originator_p = OriginatorProtocol.new logger
+    allow(AMQP).to receive(:connect).and_return connection
+    allow(AMQP::Channel).to receive(:new).and_return channel
+    @originator_p = Gorgon::OriginatorProtocol.new logger
     @conn_information = {:host => "host"}
   end
 
   describe "#connect" do
     it "opens AMQP connection" do
-      AMQP.should_receive(:connect).with(@conn_information)
+      expect(AMQP).to receive(:connect).with(@conn_information)
       @originator_p.connect(@conn_information)
     end
 
     it "opens a new channel" do
-      AMQP::Channel.should_receive(:new).with(connection)
+      expect(AMQP::Channel).to receive(:new).with(connection)
       @originator_p.connect @conn_information
     end
 
     it "sets Connection#on_close callbacks" do
       on_disconnect_called = false
       on_disconnect = Proc.new { on_disconnect_called = true }
-      connection.should_receive(:on_closed).and_yield
+      expect(connection).to receive(:on_closed).and_yield
 
       @originator_p.connect @conn_information, :on_closed => on_disconnect
       @originator_p.disconnect
-      on_disconnect_called.should be_true
+      expect(on_disconnect_called).to be_truthy
     end
 
     it "opens a reply and exchange queue" do
-      UUIDTools::UUID.stub(:timestamp_create).and_return 1
-      channel.should_receive(:queue).once.with("reply_queue_1", :auto_delete => true)
+      allow(UUIDTools::UUID).to receive(:timestamp_create).and_return 1
+      expect(channel).to receive(:queue).once.with("reply_queue_1", :auto_delete => true)
       @originator_p.connect @conn_information
     end
 
     it "opens a reply exchange and binds reply queue to it" do
-      UUIDTools::UUID.stub(:timestamp_create).and_return 1
-      channel.should_receive(:direct).with("reply_exchange_1", :auto_delete => true)
-      queue.should_receive(:bind).with(exchange)
+      allow(UUIDTools::UUID).to receive(:timestamp_create).and_return 1
+      expect(channel).to receive(:direct).with("reply_exchange_1", :auto_delete => true)
+      expect(queue).to receive(:bind).with(exchange)
       @originator_p.connect @conn_information
     end
   end
@@ -58,9 +58,9 @@ describe OriginatorProtocol do
 
     it "publish each file using channel's default_exchange" do
       files = ["file1", "file2"]
-      channel.should_receive(:default_exchange)
-      exchange.should_receive(:publish).once.ordered.with("file1", :routing_key => "queue")
-      exchange.should_receive(:publish).once.ordered.with("file2", :routing_key => "queue")
+      expect(channel).to receive(:default_exchange)
+      expect(exchange).to receive(:publish).once.ordered.with("file1", :routing_key => "queue")
+      expect(exchange).to receive(:publish).once.ordered.with("file2", :routing_key => "queue")
       @originator_p.publish_files files
     end
   end
@@ -71,21 +71,21 @@ describe OriginatorProtocol do
     end
 
     it "adds queue's names to job_definition and fanout using 'gorgon.jobs' exchange" do
-      channel.should_receive(:fanout).with("gorgon.jobs")
-      expected_job_definition = JobDefinition.new
+      expect(channel).to receive(:fanout).with("gorgon.jobs")
+      expected_job_definition = Gorgon::JobDefinition.new
       expected_job_definition.file_queue_name = "queue"
       expected_job_definition.reply_exchange_name = "exchange"
 
-      exchange.should_receive(:publish).with(expected_job_definition.to_json)
-      @originator_p.publish_job_to_all JobDefinition.new
+      expect(exchange).to receive(:publish).with(expected_job_definition.to_json)
+      @originator_p.publish_job_to_all Gorgon::JobDefinition.new
     end
 
     it "uses cluster_id in job_queue_name, when it is specified" do
-      originator_p = connect_and_publish_files(OriginatorProtocol.new(logger, "cluster1"))
+      originator_p = connect_and_publish_files(Gorgon::OriginatorProtocol.new(logger, "cluster1"))
 
-      channel.should_receive(:fanout).with("gorgon.jobs.cluster1")
+      expect(channel).to receive(:fanout).with("gorgon.jobs.cluster1")
 
-      originator_p.publish_job_to_all JobDefinition.new
+      originator_p.publish_job_to_all Gorgon::JobDefinition.new
     end
   end
 
@@ -96,13 +96,13 @@ describe OriginatorProtocol do
 
     it "publishes the job to the specified listener queue" do
       expected_listener_queue_name = "abcd1234"
-      expected_job_definition = JobDefinition.new
+      expected_job_definition = Gorgon::JobDefinition.new
       expected_job_definition.file_queue_name = "queue"
       expected_job_definition.reply_exchange_name = "exchange"
 
-      exchange.should_receive(:publish).with(expected_job_definition.to_json, {:routing_key => expected_listener_queue_name})
+      expect(exchange).to receive(:publish).with(expected_job_definition.to_json, {:routing_key => expected_listener_queue_name})
 
-      @originator_p.publish_job_to_one(JobDefinition.new, expected_listener_queue_name)
+      @originator_p.publish_job_to_one(Gorgon::JobDefinition.new, expected_listener_queue_name)
     end
   end
 
@@ -114,9 +114,9 @@ describe OriginatorProtocol do
     it "adds type and reply_exchange_name to message and fanouts it using 'gorgon.jobs' exchange" do
       expected_msg = {:type => :msg_type, :reply_exchange_name => "exchange",
         :body => {:data => 'data'}}
-      Yajl::Encoder.should_receive(:encode).with(expected_msg).and_return :msg
-      channel.should_receive(:fanout).once.ordered.with("gorgon.jobs")
-      exchange.should_receive(:publish).once.ordered.with(:msg)
+      expect(Yajl::Encoder).to receive(:encode).with(expected_msg).and_return :msg
+      expect(channel).to receive(:fanout).once.ordered.with("gorgon.jobs")
+      expect(exchange).to receive(:publish).once.ordered.with(:msg)
       @originator_p.send_message_to_listeners :msg_type, :data => 'data'
     end
   end
@@ -128,13 +128,13 @@ describe OriginatorProtocol do
 
     it "subscribe to reply_queue and yield payload" do
       payload = {:key => "info"}
-      queue.should_receive(:subscribe).and_yield(payload)
+      expect(queue).to receive(:subscribe).and_yield(payload)
       yielded = false
       @originator_p.receive_payloads do |p|
         yielded = true
-        p.should == payload
+        expect(p).to eq(payload)
       end
-      yielded.should be_true
+      expect(yielded).to be_truthy
     end
   end
 
@@ -145,14 +145,14 @@ describe OriginatorProtocol do
 
     it "purges file_queue" do
       @originator_p.publish_files ['file1']
-      queue.should_receive(:purge)
+      expect(queue).to receive(:purge)
       @originator_p.cancel_job
     end
 
     it "fanout 'cancel' message using 'gorgon.worker_managers' exchange" do
       msg = Yajl::Encoder.encode({:action => "cancel_job"})
-      channel.should_receive(:fanout).with("gorgon.worker_managers")
-      exchange.should_receive(:publish).with(msg)
+      expect(channel).to receive(:fanout).with("gorgon.worker_managers")
+      expect(exchange).to receive(:publish).with(msg)
       @originator_p.cancel_job
     end
   end
@@ -164,13 +164,13 @@ describe OriginatorProtocol do
 
     it "deletes reply_exchange and reply and file queues" do
       @originator_p.publish_files []
-      queue.should_receive(:delete).exactly(3).times
-      exchange.should_receive(:delete)
+      expect(queue).to receive(:delete).exactly(3).times
+      expect(exchange).to receive(:delete)
       @originator_p.disconnect
     end
 
     it "disconnects connection" do
-      connection.should_receive(:disconnect)
+      expect(connection).to receive(:disconnect)
       @originator_p.disconnect
     end
   end