adhearsion 2.5.4 → 2.6.0

data/spec/adhearsion/process_spec.rb

@@ -13,23 +13,23 @@ module Adhearsion
     end
 
     it 'should trigger :stop_requested events on #shutdown' do
-      Events.should_receive(:trigger_immediately).once.with(:stop_requested).ordered
-      Events.should_receive(:trigger_immediately).once.with(:shutdown).ordered
+      expect(Events).to receive(:trigger_immediately).once.with(:stop_requested).ordered
+      expect(Events).to receive(:trigger_immediately).once.with(:shutdown).ordered
       Adhearsion::Process.booted
       Adhearsion::Process.shutdown
       sleep 0.2
     end
 
     it '#stop_when_zero_calls should wait until the list of active calls reaches 0' do
-      pending
+      skip
       calls = ThreadSafeArray.new
       3.times do
         fake_call = Object.new
-        fake_call.should_receive(:hangup).once
+        expect(fake_call).to receive(:hangup).once
         calls << fake_call
       end
-      Adhearsion.should_receive(:active_calls).and_return calls
-      Adhearsion::Process.instance.should_receive(:final_shutdown).once
+      expect(Adhearsion).to receive(:active_calls).and_return calls
+      expect(Adhearsion::Process.instance).to receive(:final_shutdown).once
       calls = []
       3.times do
         calls << Thread.new do
@@ -42,7 +42,7 @@ module Adhearsion
     end
 
     it 'should terminate the process immediately on #force_stop' do
-      ::Process.should_receive(:exit).with(1).once.and_return true
+      expect(::Process).to receive(:exit).with(1).once.and_return true
       Adhearsion::Process.force_stop
     end
 
@@ -50,8 +50,8 @@ module Adhearsion
       it "should hang up active calls" do
         3.times do
           fake_call = Call.new
-          fake_call.stub :id => random_call_id
-          fake_call.should_receive(:hangup).once
+          allow(fake_call).to receive_messages :id => random_call_id
+          expect(fake_call).to receive(:hangup).once
           Adhearsion.active_calls << fake_call
         end
 
@@ -63,9 +63,9 @@ module Adhearsion
       it "should trigger shutdown handlers synchronously" do
         foo = lambda { |b| b }
 
-        foo.should_receive(:[]).once.with(:a).ordered
-        foo.should_receive(:[]).once.with(:b).ordered
-        foo.should_receive(:[]).once.with(:c).ordered
+        expect(foo).to receive(:[]).once.with(:a).ordered
+        expect(foo).to receive(:[]).once.with(:b).ordered
+        expect(foo).to receive(:[]).once.with(:c).ordered
 
         Events.shutdown { sleep 2; foo[:a] }
         Events.shutdown { sleep 1; foo[:b] }
@@ -75,37 +75,37 @@ module Adhearsion
       end
 
       it "should stop the console" do
-        Console.should_receive(:stop).once
+        expect(Console).to receive(:stop).once
         Adhearsion::Process.final_shutdown
       end
     end
 
     it 'should handle subsequent :shutdown events in the correct order' do
       Adhearsion::Process.booted
-      Adhearsion::Process.state_name.should be :running
+      expect(Adhearsion::Process.state_name).to be :running
       Adhearsion::Process.shutdown
-      Adhearsion::Process.state_name.should be :stopping
+      expect(Adhearsion::Process.state_name).to be :stopping
       Adhearsion::Process.shutdown
-      Adhearsion::Process.state_name.should be :rejecting
+      expect(Adhearsion::Process.state_name).to be :rejecting
       Adhearsion::Process.shutdown
-      Adhearsion::Process.state_name.should be :stopped
-      Adhearsion::Process.instance.should_receive(:die_now!).once
+      expect(Adhearsion::Process.state_name).to be :stopped
+      expect(Adhearsion::Process.instance).to receive(:die_now!).once
       Adhearsion::Process.shutdown
       sleep 0.2
     end
 
     it 'should forcibly kill the Adhearsion process on :force_stop' do
-      ::Process.should_receive(:exit).once.with(1)
+      expect(::Process).to receive(:exit).once.with(1)
       Adhearsion::Process.force_stop
     end
 
     describe "#fqdn" do
       it "should be a string" do
-        Adhearsion::Process.fqdn.should be_a String
+        expect(Adhearsion::Process.fqdn).to be_a String
       end
 
       context "when networking issues crop up" do
-        before { Socket.stub(:gethostbyname).and_raise(SocketError) }
+        before { allow(Socket).to receive(:gethostbyname).and_raise(SocketError) }
 
         it "should raise SocketError" do
           expect { Adhearsion::Process.fqdn }.to raise_error(SocketError)

data/spec/adhearsion/punchblock_plugin/initializer_spec.rb

@@ -23,7 +23,7 @@ module Adhearsion
 
       def initialize_punchblock(options = {})
         reset_default_config
-        Initializer.stub(:connect)
+        allow(Initializer).to receive(:connect)
         Adhearsion.config.punchblock do |config|
           config.platform           = options[:platform] if options.has_key?(:platform)
           config.username           = options[:username] if options.has_key?(:username)
@@ -47,71 +47,71 @@ module Adhearsion
       let(:mock_client) { double 'Client' }
 
       before do
-        mock_call.stub :id => call_id
+        allow(mock_call).to receive_messages :id => call_id
         mock_client.as_null_object
-        mock_client.stub :event_handler= => true
+        allow(mock_client).to receive_messages :event_handler= => true
         Events.refresh!
-        Adhearsion::Process.stub :fqdn => 'hostname'
-        ::Process.stub :pid => 1234
+        allow(Adhearsion::Process).to receive_messages :fqdn => 'hostname'
+        allow(::Process).to receive_messages :pid => 1234
       end
 
       describe "starts the client with the default values" do
         subject { initialize_punchblock }
 
         it "should set properly the username value" do
-          subject.username.should be == 'usera@127.0.0.1'
+          expect(subject.username).to eq('usera@127.0.0.1')
         end
 
         it "should set properly the password value" do
-          subject.password.should be == '1'
+          expect(subject.password).to eq('1')
         end
 
         it "should set properly the host value" do
-          subject.host.should be_nil
+          expect(subject.host).to be_nil
         end
 
         it "should set properly the port value" do
-          subject.port.should be_nil
+          expect(subject.port).to be_nil
         end
 
         it "should set properly the certs_directory value" do
-          subject.certs_directory.should be_nil
+          expect(subject.certs_directory).to be_nil
         end
 
         it "should set properly the root_domain value" do
-          subject.root_domain.should be_nil
+          expect(subject.root_domain).to be_nil
         end
 
         it "should properly set the reconnect_attempts value" do
-          subject.reconnect_attempts.should be == 1.0/0.0
+          expect(subject.reconnect_attempts).to eq(1.0/0.0)
         end
 
         it "should properly set the reconnect_timer value" do
-          subject.reconnect_timer.should be == 5
+          expect(subject.reconnect_timer).to eq(5)
         end
       end
 
       it "starts the client with the correct resource" do
         username = "usera@127.0.0.1/hostname-1234"
 
-        Punchblock::Connection::XMPP.should_receive(:new).once.with(hash_including :username => username).and_return mock_client
+        expect(Punchblock::Connection::XMPP).to receive(:new).once.with(hash_including :username => username).and_return mock_client
         initialize_punchblock
       end
 
       context "when the fqdn is not available" do
         it "should use the local hostname instead" do
-          Adhearsion::Process.stub(:fqdn).and_raise SocketError
-          Socket.stub(:gethostname).and_return 'local_hostname'
+          allow(Adhearsion::Process).to receive(:fqdn).and_raise SocketError
+          allow(Socket).to receive(:gethostname).and_return 'local_hostname'
 
           username = "usera@127.0.0.1/local_hostname-1234"
 
-          Punchblock::Connection::XMPP.should_receive(:new).once.with(hash_including :username => username).and_return mock_client
+          expect(Punchblock::Connection::XMPP).to receive(:new).once.with(hash_including :username => username).and_return mock_client
           initialize_punchblock
         end
       end
 
       it "starts the client with any overridden settings" do
-        Punchblock::Connection::XMPP.should_receive(:new).once.with(username: 'userb@127.0.0.1/foo', password: '123', host: 'foo.bar.com', port: 200, certs: '/foo/bar', connection_timeout: 20, root_domain: 'foo.com').and_return mock_client
+        expect(Punchblock::Connection::XMPP).to receive(:new).once.with(username: 'userb@127.0.0.1/foo', password: '123', host: 'foo.bar.com', port: 200, certs: '/foo/bar', connection_timeout: 20, root_domain: 'foo.com').and_return mock_client
         initialize_punchblock username: 'userb@127.0.0.1/foo', password: '123', host: 'foo.bar.com', port: 200, certs_directory: '/foo/bar', connection_timeout: 20, root_domain: 'foo.com'
       end
 
@@ -119,12 +119,12 @@ module Adhearsion
         it 'should block until the connection is established' do
           reset_default_config
           mock_connection = double :mock_connection
-          mock_connection.should_receive(:register_event_handler).once
-          Punchblock::Client.should_receive(:new).once.and_return mock_connection
-          mock_connection.should_receive(:run).once
+          expect(mock_connection).to receive(:register_event_handler).once
+          expect(Punchblock::Client).to receive(:new).once.and_return mock_connection
+          expect(mock_connection).to receive(:run).once
           t = Thread.new { Initializer.init; Initializer.run }
           t.join 5
-          t.status.should be == "sleep"
+          expect(t.status).to eq("sleep")
           Events.trigger_immediately :punchblock, Punchblock::Connection::Connected.new
           t.join
         end
@@ -135,8 +135,8 @@ module Adhearsion
           Adhearsion::Process.reset
           Initializer.config = reset_default_config
           Initializer.config.reconnect_attempts = 1
-          Adhearsion::Logging.get_logger(Initializer).should_receive(:fatal).at_most(:once)
-          Initializer.stub(:client).and_return mock_client
+          expect(Adhearsion::Logging.get_logger(Initializer)).to receive(:fatal).at_most(:once)
+          allow(Initializer).to receive(:client).and_return mock_client
         end
 
         after :each do
@@ -145,29 +145,29 @@ module Adhearsion
 
         it 'should reset the Adhearsion process state to "booting"' do
           Adhearsion::Process.booted
-          Adhearsion::Process.state_name.should be == :running
-          mock_client.stub(:run).and_raise Punchblock::DisconnectedError
-          Adhearsion::Process.should_receive(:reset).at_least(:once)
+          expect(Adhearsion::Process.state_name).to eq(:running)
+          allow(mock_client).to receive(:run).and_raise Punchblock::DisconnectedError
+          expect(Adhearsion::Process).to receive(:reset).at_least(:once)
           Initializer.connect_to_server
         end
 
         it 'should retry the connection the specified number of times' do
           Initializer.config.reconnect_attempts = 3
-          mock_client.stub(:run).and_raise Punchblock::DisconnectedError
+          allow(mock_client).to receive(:run).and_raise Punchblock::DisconnectedError
           Initializer.connect_to_server
-          Initializer.attempts.should be == 3
+          expect(Initializer.attempts).to eq(3)
         end
 
         it 'should preserve a Punchblock::ProtocolError exception and give up' do
-          mock_client.stub(:run).and_raise Punchblock::ProtocolError
+          allow(mock_client).to receive(:run).and_raise Punchblock::ProtocolError
           expect { Initializer.connect_to_server }.to raise_error Punchblock::ProtocolError
         end
 
         it 'should not attempt to reconnect if Adhearsion is shutting down' do
           Adhearsion::Process.booted
           Adhearsion::Process.shutdown
-          mock_client.stub(:run).and_raise Punchblock::DisconnectedError
-          Initializer.should_not raise_error Punchblock::DisconnectedError
+          allow(mock_client).to receive(:run).and_raise Punchblock::DisconnectedError
+          expect { Initializer.connect_to_server }.not_to raise_error
         end
       end
 
@@ -175,7 +175,7 @@ module Adhearsion
         let(:overrides) { {:username => 'test', :password => '123', :host => 'foo.bar.com', :port => 200, :certs => nil, :connection_timeout => 20, :root_domain => 'foo.com'} }
 
         it 'should start an Asterisk PB connection' do
-          Punchblock::Connection::Asterisk.should_receive(:new).once.with(overrides).and_return mock_client
+          expect(Punchblock::Connection::Asterisk).to receive(:new).once.with(overrides).and_return mock_client
           initialize_punchblock overrides.merge(:platform => :asterisk)
         end
       end
@@ -184,13 +184,13 @@ module Adhearsion
         let(:overrides) { {:username => 'test', :password => '123', :host => 'foo.bar.com', :port => 200, :certs => nil, :connection_timeout => 20, :root_domain => 'foo.com'} }
 
         it 'should start a FreeSWITCH PB connection' do
-          Punchblock::Connection::Freeswitch.should_receive(:new).once.with(overrides).and_return mock_client
+          expect(Punchblock::Connection::Freeswitch).to receive(:new).once.with(overrides).and_return mock_client
           initialize_punchblock overrides.merge(:platform => :freeswitch)
         end
       end
 
       it 'should place events from Punchblock into the event handler' do
-        Events.instance.should_receive(:trigger).once.with(:punchblock, offer)
+        expect(Events.instance).to receive(:trigger).once.with(:punchblock, offer)
         initialize_punchblock
         Initializer.client.handle_event offer
       end
@@ -198,15 +198,15 @@ module Adhearsion
       describe "dispatching an offer" do
         before do
           initialize_punchblock
-          Adhearsion::Process.should_receive(:state_name).once.and_return process_state
-          Adhearsion::Call.should_receive(:new).once.and_return mock_call
+          expect(Adhearsion::Process).to receive(:state_name).once.and_return process_state
+          expect(Adhearsion::Call).to receive(:new).once.and_return mock_call
         end
 
         context "when the Adhearsion::Process is :booting" do
           let(:process_state) { :booting }
 
           it 'should reject a call with cause :declined' do
-            mock_call.should_receive(:reject).once.with(:decline)
+            expect(mock_call).to receive(:reject).once.with(:decline)
           end
         end
 
@@ -218,7 +218,7 @@ module Adhearsion
               Adhearsion.router do
                 route 'foobar', Class.new
               end
-              Adhearsion.router.should_receive(:handle).once.with mock_call
+              expect(Adhearsion.router).to receive(:handle).once.with mock_call
             end
           end
         end
@@ -227,7 +227,7 @@ module Adhearsion
           let(:process_state) { :rejecting }
 
           it 'should reject a call with cause :declined' do
-            mock_call.should_receive(:reject).once.with(:decline)
+            expect(mock_call).to receive(:reject).once.with(:decline)
           end
         end
 
@@ -235,7 +235,7 @@ module Adhearsion
           let(:process_state) { :foobar }
 
           it 'should reject a call with cause :error' do
-            mock_call.should_receive(:reject).once.with(:error)
+            expect(mock_call).to receive(:reject).once.with(:error)
           end
         end
 
@@ -246,14 +246,14 @@ module Adhearsion
         let(:component)   { double 'ComponentNode' }
         let(:mock_event)  { double 'Event' }
 
-        before { mock_event.stub target_call_id: call_id, source: component }
+        before { allow(mock_event).to receive_messages target_call_id: call_id, source: component }
 
         before do
           initialize_punchblock
         end
 
         it "should place the event in the call's inbox" do
-          component.should_receive(:trigger_event_handler).once.with mock_event
+          expect(component).to receive(:trigger_event_handler).once.with mock_event
           Events.trigger_immediately :punchblock, mock_event
         end
       end
@@ -261,7 +261,7 @@ module Adhearsion
       describe "dispatching a call event" do
         let(:mock_event)  { double 'Event' }
 
-        before { mock_event.stub target_call_id: call_id }
+        before { allow(mock_event).to receive_messages target_call_id: call_id }
 
         describe "with an active call" do
           before do
@@ -269,15 +269,31 @@ module Adhearsion
             Adhearsion.active_calls << mock_call
           end
 
-          it "should place the event in the call's inbox" do
-            mock_call.async.should_receive(:deliver_message).once.with(mock_event)
+          it "should forward the event to the call actor" do
+            events = []
+            mock_call.register_event_handler do |event|
+              events << event
+            end
+            Initializer.dispatch_call_event mock_event
+            sleep 0.5
+            expect(events).to eql([mock_event])
+          end
+
+          it "should not block on the call handling the event" do
+
+            mock_call.register_event_handler do |event|
+              sleep 5
+            end
+            start_time = Time.now
             Initializer.dispatch_call_event mock_event
+            sleep 0.5
+            expect(Time.now - start_time).to be < 1
           end
         end
 
         describe "with an inactive call" do
           it "should log a warning" do
-            Adhearsion::Logging.get_logger(Initializer).should_receive(:warn).once.with("Event received for inactive call #{call_id}: #{mock_event.inspect}")
+            expect(Adhearsion::Logging.get_logger(Initializer)).to receive(:warn).once.with("Event received for inactive call #{call_id}: #{mock_event.inspect}")
             Initializer.dispatch_call_event mock_event
           end
         end
@@ -289,7 +305,7 @@ module Adhearsion
           end
 
           it "should log a warning" do
-            Adhearsion::Logging.get_logger(Initializer).should_receive(:warn).once.with("Event received for inactive call #{call_id}: #{mock_event.inspect}")
+            expect(Adhearsion::Logging.get_logger(Initializer)).to receive(:warn).once.with("Event received for inactive call #{call_id}: #{mock_event.inspect}")
             Initializer.dispatch_call_event mock_event
           end
         end
@@ -309,11 +325,11 @@ module Adhearsion
           end
 
           it "should set properly the username value" do
-            subject.username.should be == 'userb@127.0.0.1'
+            expect(subject.username).to eq('userb@127.0.0.1')
           end
 
           it "should set properly the password value" do
-            subject.password.should be == 'abc123'
+            expect(subject.password).to eq('abc123')
           end
         end
       end
@@ -332,8 +348,8 @@ module Adhearsion
 
         Initializer.handle_event ami_event
 
-        latch.wait(1).should be true
-        result.should be ami_event
+        expect(latch.wait(1)).to be true
+        expect(result).to be ami_event
       end
     end
   end

data/spec/adhearsion/punchblock_plugin_spec.rb

@@ -6,7 +6,7 @@ module Adhearsion
   describe PunchblockPlugin do
     it "should make the client accessible from the Initializer" do
       PunchblockPlugin::Initializer.client = :foo
-      PunchblockPlugin.client.should be :foo
+      expect(PunchblockPlugin.client).to be :foo
       PunchblockPlugin::Initializer.client = nil
     end
 
@@ -15,11 +15,11 @@ module Adhearsion
       let(:response)    { :foo }
       let(:mock_client) { double 'Client' }
 
-      let(:execute_expectation) { PunchblockPlugin.client.should_receive(:execute_command).once }
+      let(:execute_expectation) { expect(PunchblockPlugin.client).to receive(:execute_command).once }
 
       before do
         PunchblockPlugin::Initializer.client = mock_client
-        message.stub :execute! => true
+        allow(message).to receive_messages :execute! => true
         message.response = response
         execute_expectation
       end
@@ -38,12 +38,12 @@ module Adhearsion
           slow_command.response = response
         end
         PunchblockPlugin.execute_component slow_command
-        (Time.now - starting_time).should >= 0.4
+        expect(Time.now - starting_time).to be >= 0.4
       end
 
       describe "with a successful response" do
         it "returns the executed command" do
-          PunchblockPlugin.execute_component(message).should be message
+          expect(PunchblockPlugin.execute_component(message)).to be message
         end
       end
 
@@ -51,7 +51,7 @@ module Adhearsion
         let(:response) { Exception.new }
 
         it "raises the error" do
-          lambda { PunchblockPlugin.execute_component message }.should raise_error Exception
+          expect { PunchblockPlugin.execute_component message }.to raise_error Exception
         end
       end
     end