spec/punchblock/client_spec.rb in punchblock-2.5.2 vs spec/punchblock/client_spec.rb in punchblock-2.5.3

@@ -6,70 +6,77 @@
   describe Client do
     let(:connection) { Connection::XMPP.new :username => '[e-mail]', :password => 1 }
 
     subject { Client.new :connection => connection }
 
-    its(:connection)          { should be connection }
-    its(:component_registry)  { should be_a Client::ComponentRegistry }
+    describe '#connection' do
+      subject { super().connection }
+      it { should be connection }
+    end
 
+    describe '#component_registry' do
+      subject { super().component_registry }
+      it { should be_a Client::ComponentRegistry }
+    end
+
     let(:call_id)         { 'abc123' }
     let(:mock_event)      { double('Event').as_null_object }
     let(:component_id)    { 'abc123' }
     let(:component_uri)   { 'callid@server/abc123' }
     let(:mock_component)  { double 'Component', source_uri: component_uri }
     let(:mock_command)    { double 'Command' }
 
     describe '#run' do
       it 'should start up the connection' do
-        connection.should_receive(:run).once
+        expect(connection).to receive(:run).once
         subject.run
       end
     end
 
     describe '#stop' do
       it 'should stop the connection' do
-        connection.should_receive(:stop).once
+        expect(connection).to receive(:stop).once
         subject.stop
       end
     end
 
     describe '#send_message' do
       it 'should send a message' do
         args = [ "someone", "example.org", "Hello World!" ]
-        connection.should_receive(:send_message).with(*args).once
+        expect(connection).to receive(:send_message).with(*args).once
         subject.send_message *args
       end
     end
 
     describe '#new_call_uri' do
       it 'should return the connection-specific fresh call ID' do
         stub_uuids 'foobar'
-        subject.new_call_uri.should == 'xmpp:[e-mail]'
+        expect(subject.new_call_uri).to eq('xmpp:[e-mail]')
       end
     end
 
     it 'should handle connection events' do
-      subject.should_receive(:handle_event).with(mock_event).once
+      expect(subject).to receive(:handle_event).with(mock_event).once
       connection.event_handler.call mock_event
     end
 
     describe '#handle_event' do
       it "sets the event's client" do
         event = Event::Offer.new
         subject.handle_event event
-        event.client.should be subject
+        expect(event.client).to be subject
       end
 
       context 'if the event can be associated with a source component' do
         before do
           mock_event.stub :source => mock_component
-          mock_component.should_receive(:add_event).with mock_event
+          expect(mock_component).to receive(:add_event).with mock_event
         end
 
         it 'should not call event handlers' do
           handler = double 'handler'
-          handler.should_receive(:call).never
+          expect(handler).to receive(:call).never
           subject.register_event_handler do |event|
             handler.call event
           end
           subject.handle_event mock_event
         end
@@ -80,30 +87,30 @@
           mock_event.stub :source => nil
         end
 
         it 'should call registered event handlers' do
           handler = double 'handler'
-          handler.should_receive(:call).once.with mock_event
+          expect(handler).to receive(:call).once.with mock_event
           subject.register_event_handler do |event|
             handler.call event
           end
           subject.handle_event mock_event
         end
       end
     end
 
     it 'should be able to register and retrieve components' do
       subject.register_component mock_component
-      subject.find_component_by_uri(component_uri).should be mock_component
+      expect(subject.find_component_by_uri(component_uri)).to be mock_component
     end
 
     describe '#execute_command' do
       let(:component) { Component::Output.new }
       let(:event)     { Event::Complete.new }
 
       before do
-        connection.should_receive(:write).once.with component, :call_id => call_id
+        expect(connection).to receive(:write).once.with component, :call_id => call_id
       end
 
       let :execute_command do
         subject.execute_command component, :call_id => call_id
       end
@@ -112,14 +119,14 @@
         execute_command
       end
 
       it "should set the command's client" do
         execute_command
-        component.client.should be subject
+        expect(component.client).to be subject
       end
 
       it "should handle a component's events" do
-        subject.should_receive(:trigger_handler).with(:event, event).once
+        expect(subject).to receive(:trigger_handler).with(:event, event).once
         execute_command
         component.request!
         component.execute!
         component.add_event event
       end