spec/adhearsion/events_spec.rb in adhearsion-2.5.4 vs spec/adhearsion/events_spec.rb in adhearsion-2.6.0

@@ -11,45 +11,45 @@
     before do
       Events.refresh!
     end
 
     it "should have a GirlFriday::Queue to handle events" do
-      Events.queue.should be_a GirlFriday::WorkQueue
+      expect(Events.queue).to be_a GirlFriday::WorkQueue
     end
 
     it "should allow adding events to the queue and handle them appropriately" do
       t = nil
       o = nil
       latch = CountDownLatch.new 1
 
-      Events.instance.should_receive(:handle_message).and_return do |message|
+      expect(Events.instance).to receive(:handle_message) do |message|
         t = message.type
         o = message.object
         latch.countdown!
       end
 
       Events.trigger :event, :foo
 
-      latch.wait(2).should be_true
-      t.should be == :event
-      o.should be == :foo
+      expect(latch.wait(2)).to be_truthy
+      expect(t).to eq(:event)
+      expect(o).to eq(:foo)
     end
 
     it "should allow executing events immediately" do
       t = nil
       o = nil
 
-      Events.instance.should_receive(:handle_message).and_return do |message|
+      expect(Events.instance).to receive(:handle_message) do |message|
         sleep 0.25
         t = message.type
         o = message.object
       end
 
       Events.trigger_immediately :event, :foo
 
-      t.should be == :event
-      o.should be == :foo
+      expect(t).to eq(:event)
+      expect(o).to eq(:foo)
     end
 
     it "should handle events using registered guarded handlers" do
       result = nil
 
@@ -57,17 +57,17 @@
         result = :foo
       end
 
       Events.trigger_immediately :event, EventClass.new
 
-      result.should be == :foo
+      expect(result).to eq(:foo)
 
       Events.clear_handlers :event, EventClass
     end
 
     it "should handle exceptions in event processing by raising the exception as an event" do
-      Events.instance.should_receive(:trigger).with(:exception, kind_of(ExceptionClass)).once
+      expect(Events.instance).to receive(:trigger).with(:exception, kind_of(ExceptionClass)).once
 
       Events.register_handler :event, EventClass do |event|
         raise ExceptionClass
       end
 
@@ -86,21 +86,21 @@
         result = :bar
       end
 
       Events.trigger_immediately :event, EventClass.new
 
-      result.should be == :bar
+      expect(result).to eq(:bar)
 
       Events.clear_handlers :event, EventClass
     end
 
     it "should respond_to? any methods corresponding to classes for which handlers are defined" do
       Events.register_handler :event_type_1 do |event|
       end
 
-      Events.should respond_to(:event_type_1)
-      Events.should_not respond_to(:event_type_2)
+      expect(Events).to respond_to(:event_type_1)
+      expect(Events).not_to respond_to(:event_type_2)
     end
 
     describe '#draw' do
       it "should allow registering handlers by type" do
         result = nil
@@ -110,10 +110,10 @@
           end
         end
 
         Events.trigger_immediately :event
 
-        result.should be == :foo
+        expect(result).to eq(:foo)
 
         Events.clear_handlers :event
       end
     end