adhearsion-asterisk 1.3.1 → 1.4.0

data/spec/adhearsion/asterisk/config_generators/agents_spec.rb

@@ -250,8 +250,8 @@ describe "AgentsConfigGeneratorTestHelper" do
 
   it "generated_config_has_pair() works properly with two pairs" do
     @agents = mock "A fake agents with just one pair"
-    @agents.expects(:conf).twice.returns("[general]\n\nqaz=qwerty\nagent => 1,2,3")
- 
+    @agents.should_receive(:conf).twice.and_return("[general]\n\nqaz=qwerty\nagent => 1,2,3")
+
     generated_config_has_pair(:qaz => "qwerty").should be true
     generated_config_has_pair(:foo => "bar").should be false
   end

data/spec/adhearsion/asterisk/config_generators/queues_spec.rb

@@ -135,8 +135,8 @@ describe "The private, helper methods in QueueDefinition" do
 
   it '#boolean should convert a boolean into "yes" or "no"' do
     mock_of_properties = mock "mock of the properties instance variable of a QueueDefinition"
-    mock_of_properties.expects(:[]=).once.with("icanhascheezburger", "yes")
-    queue.expects(:properties).returns mock_of_properties
+    mock_of_properties.should_receive(:[]=).once.with("icanhascheezburger", "yes")
+    queue.should_receive(:properties).and_return mock_of_properties
     queue.send(:boolean, "icanhascheezburger" => true)
   end
 
@@ -148,39 +148,39 @@ describe "The private, helper methods in QueueDefinition" do
 
   it '#int should coerce a String into a Numeric if possible' do
     mock_of_properties = mock "mock of the properties instance variable of a QueueDefinition"
-    mock_of_properties.expects(:[]=).once.with("chimpanzee", 1337)
-    queue.expects(:properties).returns mock_of_properties
+    mock_of_properties.should_receive(:[]=).once.with("chimpanzee", 1337)
+    queue.should_receive(:properties).and_return mock_of_properties
     queue.send(:int, "chimpanzee" => "1337")
   end
 
   it '#string should add the argument directly to the properties' do
     mock_of_properties = mock "mock of the properties instance variable of a QueueDefinition"
-    mock_of_properties.expects(:[]=).once.with("eins", "zwei")
-    queue.expects(:properties).returns mock_of_properties
+    mock_of_properties.should_receive(:[]=).once.with("eins", "zwei")
+    queue.should_receive(:properties).and_return mock_of_properties
     queue.send(:string, "eins" => "zwei")
   end
 
   it '#one_of() should add its successful match to the properties attribute' do
     mock_properties = mock "mock of the properties instance variable of a QueueDefinition"
-    mock_properties.expects(:[]=).once.with(:doesnt_matter, 5)
-    queue.expects(:properties).once.returns mock_properties
+    mock_properties.should_receive(:[]=).once.with(:doesnt_matter, 5)
+    queue.should_receive(:properties).once.and_return mock_properties
     queue.send(:one_of, 1..100, :doesnt_matter => 5)
   end
 
   it "one_of() should convert booleans to yes/no" do
     mock_properties = mock "mock of the properties instance variable of a QueueDefinition"
-    mock_properties.expects(:[]=).once.with(:doesnt_matter, 'yes')
-    queue.expects(:properties).once.returns mock_properties
+    mock_properties.should_receive(:[]=).once.with(:doesnt_matter, 'yes')
+    queue.should_receive(:properties).once.and_return mock_properties
     queue.send(:one_of, [true, false, :strict], :doesnt_matter => true)
 
     mock_properties = mock "mock of the properties instance variable of a QueueDefinition"
-    mock_properties.expects(:[]=).once.with(:doesnt_matter, :strict)
-    queue.expects(:properties).once.returns mock_properties
+    mock_properties.should_receive(:[]=).once.with(:doesnt_matter, :strict)
+    queue.should_receive(:properties).once.and_return mock_properties
     queue.send(:one_of, [true, false, :strict], :doesnt_matter => :strict)
 
     mock_properties = mock "mock of the properties instance variable of a QueueDefinition"
-    mock_properties.expects(:[]=).once.with(:doesnt_matter, 'no')
-    queue.expects(:properties).once.returns mock_properties
+    mock_properties.should_receive(:[]=).once.with(:doesnt_matter, 'no')
+    queue.should_receive(:properties).once.and_return mock_properties
     queue.send(:one_of, [true, false, :strict], :doesnt_matter => false)
   end
 
@@ -315,7 +315,7 @@ describe "ConfigGeneratorTestHelper" do
     generated_config_has_pair(:foo => "bar").should be true
 
     @queues = mock "A fake queues with just one pair"
-    @queues.expects(:to_s).twice.returns("[general]\n\nqaz=qwerty\nagent => 1,2,3")
+    @queues.should_receive(:to_s).twice.and_return("[general]\n\nqaz=qwerty\nagent => 1,2,3")
     generated_config_has_pair(:qaz => "qwerty").should be true
     generated_config_has_pair(:foo => "bar").should be false
   end

data/spec/adhearsion/asterisk/config_manager_spec.rb

@@ -8,7 +8,7 @@ module ConfigurationManagerTestHelper
 
   def mock_config_manager_for(config_string)
     new_config_manager_with("bogus filename").tap do |manager|
-      File.expects(:open).returns config_string
+      File.should_receive(:open).and_return config_string
     end
   end
 

data/spec/adhearsion/asterisk/plugin_spec.rb

@@ -4,7 +4,7 @@ module Adhearsion::Asterisk
   describe 'plugin loading' do
     before(:all) { Adhearsion::Plugin.init_plugins }
 
-    let(:mock_call) { stub_everything 'Call' }
+    let(:mock_call) { mock(:call).as_null_object }
 
     it 'should extend Adhearsion::CallController with Asterisk methods' do
       Adhearsion::CallController.new(mock_call).should respond_to :play_time

data/spec/adhearsion/asterisk/queue_proxy/agent_proxy_spec.rb

@@ -5,7 +5,7 @@ module Adhearsion::Asterisk
     describe AgentProxy do
       let(:queue_name)  { 'foobar' }
       let(:mock_ee)     { mock 'Adhearsion::DialPlan::ExecutionEnvironment' }
-      let(:mock_queue)  { stub_everything 'QueueProxy', :environment => mock_ee, :name => queue_name }
+      let(:mock_queue)  { mock('QueueProxy', :environment => mock_ee, :name => queue_name).as_null_object }
 
       let(:agent_id) { 123 }
 
@@ -13,15 +13,15 @@ module Adhearsion::Asterisk
 
       it 'should properly retrieve metadata' do
         metadata_name = 'status'
-        mock_ee.expects(:variable).once.with("AGENT(#{agent_id}:#{metadata_name})")
+        mock_ee.should_receive(:variable).once.with("AGENT(#{agent_id}:#{metadata_name})")
         subject.send :agent_metadata, metadata_name
       end
 
       it '#logged_in? should return true if the "state" of an agent == LOGGEDIN' do
-        subject.expects(:agent_metadata).once.with('status').returns 'LOGGEDIN'
+        subject.should_receive(:agent_metadata).once.with('status').and_return 'LOGGEDIN'
         subject.logged_in?.should be true
 
-        subject.expects(:agent_metadata).once.with('status').returns 'LOGGEDOUT'
+        subject.should_receive(:agent_metadata).once.with('status').and_return 'LOGGEDOUT'
         subject.logged_in?.should_not be true
       end
 
@@ -32,55 +32,55 @@ module Adhearsion::Asterisk
       end
 
       it 'should pause an agent properly from a certain queue' do
-        mock_ee.expects(:get_variable).once.with("PQMSTATUS").returns "PAUSED"
-        mock_ee.expects(:execute).once.with("PauseQueueMember", queue_name, "Agent/#{agent_id}")
+        mock_ee.should_receive(:get_variable).once.with("PQMSTATUS").and_return "PAUSED"
+        mock_ee.should_receive(:execute).once.with("PauseQueueMember", queue_name, "Agent/#{agent_id}")
 
         subject.pause!.should be true
       end
 
       it 'should pause an agent properly from a certain queue and return false when the agent did not exist' do
-        mock_ee.expects(:get_variable).once.with("PQMSTATUS").returns "NOTFOUND"
-        mock_ee.expects(:execute).once.with("PauseQueueMember", queue_name, "Agent/#{agent_id}")
+        mock_ee.should_receive(:get_variable).once.with("PQMSTATUS").and_return "NOTFOUND"
+        mock_ee.should_receive(:execute).once.with("PauseQueueMember", queue_name, "Agent/#{agent_id}")
 
         subject.pause!.should be false
       end
 
       it 'should pause an agent globally properly' do
-        mock_ee.expects(:get_variable).once.with("PQMSTATUS").returns "PAUSED"
-        mock_ee.expects(:execute).once.with "PauseQueueMember", nil, "Agent/#{agent_id}"
+        mock_ee.should_receive(:get_variable).once.with("PQMSTATUS").and_return "PAUSED"
+        mock_ee.should_receive(:execute).once.with "PauseQueueMember", nil, "Agent/#{agent_id}"
 
         subject.pause! :everywhere => true
       end
 
       it 'should unpause an agent properly' do
-        mock_ee.expects(:get_variable).once.with("UPQMSTATUS").returns "UNPAUSED"
-        mock_ee.expects(:execute).once.with("UnpauseQueueMember", queue_name, "Agent/#{agent_id}")
+        mock_ee.should_receive(:get_variable).once.with("UPQMSTATUS").and_return "UNPAUSED"
+        mock_ee.should_receive(:execute).once.with("UnpauseQueueMember", queue_name, "Agent/#{agent_id}")
 
         subject.unpause!.should be true
       end
 
       it 'should unpause an agent globally properly' do
-        mock_ee.expects(:get_variable).once.with("UPQMSTATUS").returns "UNPAUSED"
-        mock_ee.expects(:execute).once.with("UnpauseQueueMember", nil, "Agent/#{agent_id}")
+        mock_ee.should_receive(:get_variable).once.with("UPQMSTATUS").and_return "UNPAUSED"
+        mock_ee.should_receive(:execute).once.with("UnpauseQueueMember", nil, "Agent/#{agent_id}")
 
         subject.unpause!(:everywhere => true).should be true
       end
 
       it 'should remove an agent properly' do
-        mock_ee.expects(:execute).once.with('RemoveQueueMember', queue_name, "Agent/#{agent_id}")
-        mock_ee.expects(:get_variable).once.with("RQMSTATUS").returns "REMOVED"
+        mock_ee.should_receive(:execute).once.with('RemoveQueueMember', queue_name, "Agent/#{agent_id}")
+        mock_ee.should_receive(:get_variable).once.with("RQMSTATUS").and_return "REMOVED"
         subject.remove!.should be true
       end
 
       it 'should remove an agent properly' do
-        mock_ee.expects(:execute).once.with('RemoveQueueMember', queue_name, "Agent/#{agent_id}")
-        mock_ee.expects(:get_variable).once.with("RQMSTATUS").returns "NOTINQUEUE"
+        mock_ee.should_receive(:execute).once.with('RemoveQueueMember', queue_name, "Agent/#{agent_id}")
+        mock_ee.should_receive(:get_variable).once.with("RQMSTATUS").and_return "NOTINQUEUE"
         subject.remove!.should be false
       end
 
       it "should raise a QueueDoesNotExistError when removing an agent from a queue that doesn't exist" do
-        mock_ee.expects(:execute).once.with("RemoveQueueMember", queue_name, "Agent/#{agent_id}")
-        mock_ee.expects(:get_variable).once.with("RQMSTATUS").returns "NOSUCHQUEUE"
+        mock_ee.should_receive(:execute).once.with("RemoveQueueMember", queue_name, "Agent/#{agent_id}")
+        mock_ee.should_receive(:get_variable).once.with("RQMSTATUS").and_return "NOSUCHQUEUE"
         lambda {
           subject.remove!
         }.should raise_error QueueDoesNotExistError

data/spec/adhearsion/asterisk/queue_proxy/queue_agents_list_proxy_spec.rb

@@ -6,27 +6,27 @@ module Adhearsion::Asterisk
       let(:queue_name)    { 'foobar' }
       let(:agent_channel) { "Agent/123" }
       let(:mock_ee)       { mock 'Adhearsion::DialPlan::ExecutionEnvironment' }
-      let(:mock_queue)    { stub_everything 'QueueProxy', :environment => mock_ee, :name => queue_name }
+      let(:mock_queue)    { mock('QueueProxy', :environment => mock_ee, :name => queue_name).as_null_object }
 
       subject { QueueAgentsListProxy.new mock_queue, true }
 
       it 'should fetch the members with the queue name' do
-        mock_ee.expects(:get_variable).once.with("QUEUE_MEMBER_COUNT(#{queue_name})").returns 5
+        mock_ee.should_receive(:get_variable).once.with("QUEUE_MEMBER_COUNT(#{queue_name})").and_return 5
         subject.size.should == 5
       end
 
       it 'should not fetch a QUEUE_MEMBER_COUNT each time #count is called when caching is enabled' do
-        mock_ee.expects(:get_variable).once.with("QUEUE_MEMBER_COUNT(#{queue_name})").returns 0
+        mock_ee.should_receive(:get_variable).once.with("QUEUE_MEMBER_COUNT(#{queue_name})").and_return 0
         10.times { subject.size }
       end
 
       it 'when fetching agents, it should properly split by the supported delimiters' do
-        mock_ee.expects(:get_variable).with("QUEUE_MEMBER_LIST(#{queue_name})").returns('Agent/007,Agent/003,Zap/2')
+        mock_ee.should_receive(:get_variable).with("QUEUE_MEMBER_LIST(#{queue_name})").and_return('Agent/007,Agent/003,Zap/2')
         subject.to_a.size.should == 3
       end
 
       it 'when fetching agents, each array index should be an instance of AgentProxy' do
-        mock_ee.expects(:get_variable).with("QUEUE_MEMBER_LIST(#{queue_name})").returns('Agent/007,Agent/003,Zap/2')
+        mock_ee.should_receive(:get_variable).with("QUEUE_MEMBER_LIST(#{queue_name})").and_return('Agent/007,Agent/003,Zap/2')
         agents = subject.to_a
         agents.size.should > 0
         agents.each do |agent|
@@ -35,30 +35,30 @@ module Adhearsion::Asterisk
       end
 
       it '#<< should new the channel driver given as the argument to the system' do
-        mock_ee.expects(:execute).once.with("AddQueueMember", queue_name, agent_channel, "", "", "", "")
-        mock_ee.expects(:get_variable).once.with('AQMSTATUS').returns('ADDED')
-        mock_ee.expects(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").returns "Agent/007,SIP/2302,Local/2510@from-internal"
+        mock_ee.should_receive(:execute).once.with("AddQueueMember", queue_name, agent_channel, "", "", "", "")
+        mock_ee.should_receive(:get_variable).once.with('AQMSTATUS').and_return('ADDED')
+        mock_ee.should_receive(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").and_return "Agent/007,SIP/2302,Local/2510@from-internal"
         subject.new agent_channel
       end
 
       it 'when a queue agent is dynamically added and the queue does not exist, a QueueDoesNotExistError should be raised' do
-        mock_ee.expects(:execute).once.with("AddQueueMember", queue_name, agent_channel, "", "", "", "")
-        mock_ee.expects(:get_variable).once.with('AQMSTATUS').returns('NOSUCHQUEUE')
+        mock_ee.should_receive(:execute).once.with("AddQueueMember", queue_name, agent_channel, "", "", "", "")
+        mock_ee.should_receive(:get_variable).once.with('AQMSTATUS').and_return('NOSUCHQUEUE')
         lambda {
           subject.new agent_channel
         }.should raise_error QueueDoesNotExistError
       end
 
       it 'when a queue agent is dynamiaclly added and the adding was successful, an AgentProxy should be returned' do
-        mock_ee.expects(:get_variable).once.with("AQMSTATUS").returns("ADDED")
-        mock_ee.expects(:execute).once.with("AddQueueMember", queue_name, agent_channel, "", "", "", "")
-        mock_ee.expects(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").returns "Agent/007,SIP/2302,Local/2510@from-internal"
+        mock_ee.should_receive(:get_variable).once.with("AQMSTATUS").and_return("ADDED")
+        mock_ee.should_receive(:execute).once.with("AddQueueMember", queue_name, agent_channel, "", "", "", "")
+        mock_ee.should_receive(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").and_return "Agent/007,SIP/2302,Local/2510@from-internal"
         subject.new(agent_channel).should be_a AgentProxy
       end
 
       it 'when a queue agent is dynamiaclly added and the adding was unsuccessful, a false should be returned' do
-        mock_ee.expects(:get_variable).once.with("AQMSTATUS").returns("MEMBERALREADY")
-        mock_ee.expects(:execute).once.with("AddQueueMember", queue_name, agent_channel, "", "", "", "")
+        mock_ee.should_receive(:get_variable).once.with("AQMSTATUS").and_return("MEMBERALREADY")
+        mock_ee.should_receive(:execute).once.with("AddQueueMember", queue_name, agent_channel, "", "", "", "")
         subject.new(agent_channel).should be false
       end
 
@@ -69,61 +69,61 @@ module Adhearsion::Asterisk
       end
 
       it 'should execute AddQueueMember with the penalty properly' do
-        mock_ee.expects(:execute).once.with('AddQueueMember', queue_name, agent_channel, 10, '', '','')
-        mock_ee.expects(:get_variable).once.with('AQMSTATUS').returns('ADDED')
-        mock_ee.expects(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").returns "Agent/007,SIP/2302,Local/2510@from-internal"
+        mock_ee.should_receive(:execute).once.with('AddQueueMember', queue_name, agent_channel, 10, '', '','')
+        mock_ee.should_receive(:get_variable).once.with('AQMSTATUS').and_return('ADDED')
+        mock_ee.should_receive(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").and_return "Agent/007,SIP/2302,Local/2510@from-internal"
         subject.new agent_channel, :penalty => 10
       end
 
       it 'should execute AddQueueMember with the state_interface properly' do
-        mock_ee.expects(:execute).once.with('AddQueueMember', queue_name, agent_channel, '', '', '','SIP/2302')
-        mock_ee.expects(:get_variable).once.with('AQMSTATUS').returns('ADDED')
-        mock_ee.expects(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").returns "Agent/007,SIP/2302,Local/2510@from-internal"
+        mock_ee.should_receive(:execute).once.with('AddQueueMember', queue_name, agent_channel, '', '', '','SIP/2302')
+        mock_ee.should_receive(:get_variable).once.with('AQMSTATUS').and_return('ADDED')
+        mock_ee.should_receive(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").and_return "Agent/007,SIP/2302,Local/2510@from-internal"
         subject.new agent_channel, :state_interface => 'SIP/2302'
       end
 
       it 'should execute AddQueueMember properly when the name is given' do
         agent_name = 'Jay Phillips'
-        mock_ee.expects(:execute).once.with('AddQueueMember', queue_name, agent_channel, '', '', agent_name,'')
-        mock_ee.expects(:get_variable).once.with('AQMSTATUS').returns('ADDED')
-        mock_ee.expects(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").returns "Agent/007,SIP/2302,Local/2510@from-internal"
+        mock_ee.should_receive(:execute).once.with('AddQueueMember', queue_name, agent_channel, '', '', agent_name,'')
+        mock_ee.should_receive(:get_variable).once.with('AQMSTATUS').and_return('ADDED')
+        mock_ee.should_receive(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").and_return "Agent/007,SIP/2302,Local/2510@from-internal"
         subject.new agent_channel, :name => agent_name
       end
 
       it 'should execute AddQueueMember properly when the name, penalty, and interface is given' do
         agent_name, penalty = 'Jay Phillips', 4
-        mock_ee.expects(:execute).once.with('AddQueueMember', queue_name, agent_channel, penalty, '', agent_name,'')
-        mock_ee.expects(:get_variable).once.with('AQMSTATUS').returns('ADDED')
-        mock_ee.expects(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").returns "Agent/007,SIP/2302,Local/2510@from-internal"
+        mock_ee.should_receive(:execute).once.with('AddQueueMember', queue_name, agent_channel, penalty, '', agent_name,'')
+        mock_ee.should_receive(:get_variable).once.with('AQMSTATUS').and_return('ADDED')
+        mock_ee.should_receive(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").and_return "Agent/007,SIP/2302,Local/2510@from-internal"
         subject.new agent_channel, :name => agent_name, :penalty => penalty
       end
 
       it 'should execute AddQueueMember properly when the name, penalty, interface, and state_interface is given' do
         agent_name, penalty, state_interface = 'Jay Phillips', 4, 'SIP/2302'
-        mock_ee.expects(:execute).once.with('AddQueueMember', queue_name, agent_channel, penalty, '', agent_name, state_interface)
-        mock_ee.expects(:get_variable).once.with('AQMSTATUS').returns('ADDED')
-        mock_ee.expects(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").returns "Agent/007,SIP/2302,Local/2510@from-internal"
+        mock_ee.should_receive(:execute).once.with('AddQueueMember', queue_name, agent_channel, penalty, '', agent_name, state_interface)
+        mock_ee.should_receive(:get_variable).once.with('AQMSTATUS').and_return('ADDED')
+        mock_ee.should_receive(:get_variable).once.with("QUEUE_MEMBER_LIST(#{queue_name})").and_return "Agent/007,SIP/2302,Local/2510@from-internal"
         subject.new agent_channel, :name => agent_name, :penalty => penalty, :state_interface => state_interface
       end
 
       it "should log an agent in properly with no agent id given" do
-        mock_ee.expects(:execute).once.with('AgentLogin', nil, 's')
+        mock_ee.should_receive(:execute).once.with('AgentLogin', nil, 's')
         subject.login!
       end
 
       it 'should remove "Agent/" before the agent ID given if necessary when logging an agent in' do
-        mock_ee.expects(:execute).once.with('AgentLogin', '007', 's')
+        mock_ee.should_receive(:execute).once.with('AgentLogin', '007', 's')
         subject.login! 'Agent/007'
 
-        mock_ee.expects(:execute).once.with('AgentLogin', '007', 's')
+        mock_ee.should_receive(:execute).once.with('AgentLogin', '007', 's')
         subject.login! '007'
       end
 
       it 'should add an agent silently properly' do
-        mock_ee.expects(:execute).once.with('AgentLogin', '007', '')
+        mock_ee.should_receive(:execute).once.with('AgentLogin', '007', '')
         subject.login! 'Agent/007', :silent => false
 
-        mock_ee.expects(:execute).once.with('AgentLogin', '008', 's')
+        mock_ee.should_receive(:execute).once.with('AgentLogin', '008', 's')
         subject.login! 'Agent/008', :silent => true
       end
 

data/spec/adhearsion/asterisk/queue_proxy_spec.rb

@@ -19,82 +19,82 @@ module Adhearsion::Asterisk
 
     describe '#join' do
       it 'should properly join a queue' do
-        mock_ee.expects(:execute).once.with("queue", queue_name, "", '', '', '', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "FULL"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "", '', '', '', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "FULL"
         subject.join!
       end
 
       it 'should return a symbol representing the result of joining the queue' do
-        mock_ee.expects(:execute).once.with("queue", queue_name, "", '', '', '', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "TIMEOUT"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "", '', '', '', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "TIMEOUT"
         subject.join!.should be :timeout
       end
 
       it 'should return :completed after joining the queue and being connected' do
-        mock_ee.expects(:execute).once.with("queue", queue_name, "", '', '', '', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns nil
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "", '', '', '', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return nil
         subject.join!.should be :completed
       end
 
       it 'should join a queue with a timeout properly' do
-        mock_ee.expects(:execute).once.with("queue", queue_name, "", '', '', '60', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "JOINEMPTY"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "", '', '', '60', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "JOINEMPTY"
         subject.join! :timeout => 1.minute
       end
 
       it 'should join a queue with an announcement file properly' do
-        mock_ee.expects(:execute).once.with("queue", queue_name, "", '', 'custom_announcement_file_here', '', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "JOINEMPTY"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "", '', 'custom_announcement_file_here', '', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "JOINEMPTY"
         subject.join! :announce => 'custom_announcement_file_here'
       end
 
       it 'should join a queue with an agi script properly' do
-        mock_ee.expects(:execute).once.with("queue", queue_name, '', '', '', '','agi://localhost/queue_agi_test')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "JOINUNAVAIL"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, '', '', '', '','agi://localhost/queue_agi_test')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "JOINUNAVAIL"
         subject.join! :agi => 'agi://localhost/queue_agi_test'
       end
 
       it 'should join a queue with allow_transfer properly' do
-        mock_ee.expects(:execute).once.with("queue", queue_name, "Tt", '', '', '', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "JOINEMPTY"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "Tt", '', '', '', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "JOINEMPTY"
         subject.join! :allow_transfer => :everyone
 
-        mock_ee.expects(:execute).once.with("queue", queue_name, "T", '', '', '', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "JOINEMPTY"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "T", '', '', '', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "JOINEMPTY"
         subject.join! :allow_transfer => :caller
 
-        mock_ee.expects(:execute).once.with("queue", queue_name, "t", '', '', '', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "JOINEMPTY"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "t", '', '', '', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "JOINEMPTY"
         subject.join! :allow_transfer => :agent
       end
 
       it 'should join a queue with allow_hangup properly' do
-        mock_ee.expects(:execute).once.with("queue", queue_name, "Hh", '', '', '', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "JOINEMPTY"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "Hh", '', '', '', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "JOINEMPTY"
         subject.join! :allow_hangup => :everyone
 
-        mock_ee.expects(:execute).once.with("queue", queue_name, "H", '', '', '', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "JOINEMPTY"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "H", '', '', '', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "JOINEMPTY"
         subject.join! :allow_hangup => :caller
 
-        mock_ee.expects(:execute).once.with("queue", queue_name, "h", '', '', '', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "JOINEMPTY"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "h", '', '', '', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "JOINEMPTY"
         subject.join! :allow_hangup => :agent
       end
 
       it 'should join a queue properly with the :play argument' do
-        mock_ee.expects(:execute).once.with("queue", queue_name, "r", '', '', '', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "JOINEMPTY"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "r", '', '', '', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "JOINEMPTY"
         subject.join! :play => :ringing
 
-        mock_ee.expects(:execute).once.with("queue", queue_name, "", '', '', '', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "JOINEMPTY"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "", '', '', '', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "JOINEMPTY"
         subject.join! :play => :music
       end
 
       it 'joining a queue with many options specified' do
-        mock_ee.expects(:execute).once.with("queue", queue_name, "rtHh", '', '', '120', '')
-        mock_ee.expects(:get_variable).once.with("QUEUESTATUS").returns "JOINEMPTY"
+        mock_ee.should_receive(:execute).once.with("queue", queue_name, "rtHh", '', '', '120', '')
+        mock_ee.should_receive(:get_variable).once.with("QUEUESTATUS").and_return "JOINEMPTY"
         subject.join! :allow_transfer => :agent, :timeout => 2.minutes,
                       :play => :ringing, :allow_hangup => :everyone
       end
@@ -115,41 +115,41 @@ module Adhearsion::Asterisk
     end
 
     it 'should return a correct boolean for #exists?' do
-      mock_ee.expects(:execute).once.with("RemoveQueueMember", queue_name, "SIP/AdhearsionQueueExistenceCheck")
-      mock_ee.expects(:get_variable).once.with("RQMSTATUS").returns "NOTINQUEUE"
+      mock_ee.should_receive(:execute).once.with("RemoveQueueMember", queue_name, "SIP/AdhearsionQueueExistenceCheck")
+      mock_ee.should_receive(:get_variable).once.with("RQMSTATUS").and_return "NOTINQUEUE"
       subject.exists?.should be true
 
-      mock_ee.expects(:execute).once.with("RemoveQueueMember", queue_name, "SIP/AdhearsionQueueExistenceCheck")
-      mock_ee.expects(:get_variable).once.with("RQMSTATUS").returns "NOSUCHQUEUE"
+      mock_ee.should_receive(:execute).once.with("RemoveQueueMember", queue_name, "SIP/AdhearsionQueueExistenceCheck")
+      mock_ee.should_receive(:get_variable).once.with("RQMSTATUS").and_return "NOSUCHQUEUE"
       subject.exists?.should be false
     end
 
     it 'waiting_count for a queue that does exist' do
-      mock_ee.expects(:get_variable).once.with("QUEUE_WAITING_COUNT(#{queue_name})").returns "50"
-      subject.expects(:exists?).once.returns true
+      mock_ee.should_receive(:get_variable).once.with("QUEUE_WAITING_COUNT(#{queue_name})").and_return "50"
+      subject.should_receive(:exists?).once.and_return true
       subject.waiting_count.should == 50
     end
 
     it 'waiting_count for a queue that does not exist' do
       lambda {
-        subject.expects(:exists?).once.returns false
+        subject.should_receive(:exists?).once.and_return false
         subject.waiting_count
       }.should raise_error Adhearsion::Asterisk::QueueProxy::QueueDoesNotExistError
     end
 
     it 'empty? should call waiting_count' do
-      subject.expects(:waiting_count).once.returns 0
+      subject.should_receive(:waiting_count).once.and_return 0
       subject.empty?.should be true
 
-      subject.expects(:waiting_count).once.returns 99
+      subject.should_receive(:waiting_count).once.and_return 99
       subject.empty?.should_not be true
     end
 
     it 'any? should call waiting_count' do
-      subject.expects(:waiting_count).once.returns 0
+      subject.should_receive(:waiting_count).once.and_return 0
       subject.any?.should be false
 
-      subject.expects(:waiting_count).once.returns 99
+      subject.should_receive(:waiting_count).once.and_return 99
       subject.any?.should be true
     end
   end