adhearsion 2.5.4 → 2.6.0

data/spec/adhearsion/calls_spec.rb

@@ -16,18 +16,18 @@ module Adhearsion
     end
 
     it 'can add a call to the collection' do
-      subject.any?.should be == false
+      expect(subject.any?).to eq(false)
       call = Call.new new_offer
       subject << call
-      call.should be_a Adhearsion::Call
-      subject.size.should be == 1
-      subject[call.id].should be call
+      expect(call).to be_a Adhearsion::Call
+      expect(subject.size).to eq(1)
+      expect(subject[call.id]).to be call
     end
 
     it '#size should return the number of calls in the collection' do
-      subject.size.should be == 0
+      expect(subject.size).to eq(0)
       subject << call
-      subject.size.should be == 1
+      expect(subject.size).to eq(1)
     end
 
     describe "removing a call" do
@@ -39,9 +39,9 @@ module Adhearsion
         before { subject.remove_inactive_call deleted_call }
 
         it "should remove the call from the collection" do
-          subject.size.should be == number_of_calls - 1
-          subject[deleted_call.id].should be_nil
-          subject.with_uri(deleted_call.uri).should be_nil
+          expect(subject.size).to eq(number_of_calls - 1)
+          expect(subject[deleted_call.id]).to be_nil
+          expect(subject.with_uri(deleted_call.uri)).to be_nil
         end
       end
 
@@ -50,14 +50,14 @@ module Adhearsion
           @call_id = deleted_call.id
           @call_uri = deleted_call.uri
           Celluloid::Actor.kill deleted_call
-          deleted_call.should_not be_alive
+          expect(deleted_call.alive?).to be false
           subject.remove_inactive_call deleted_call
         end
 
         it "should remove the call from the collection" do
-          subject.size.should be == number_of_calls - 1
-          subject[@call_id].should be_nil
-          subject.with_uri(@call_uri).should be_nil
+          expect(subject.size).to eq(number_of_calls - 1)
+          expect(subject[@call_id]).to be_nil
+          expect(subject.with_uri(@call_uri)).to be_nil
         end
       end
 
@@ -65,9 +65,9 @@ module Adhearsion
         before { subject.remove_inactive_call deleted_call.id }
 
         it "should remove the call from the collection" do
-          subject.size.should be == number_of_calls - 1
-          subject[deleted_call.id].should be_nil
-          subject.with_uri(deleted_call.uri).should be_nil
+          expect(subject.size).to eq(number_of_calls - 1)
+          expect(subject[deleted_call.id]).to be_nil
+          expect(subject.with_uri(deleted_call.uri)).to be_nil
         end
       end
     end
@@ -79,7 +79,7 @@ module Adhearsion
         tagged_call = calls.last
         tagged_call.tag :moderator
 
-        subject.with_tag(:moderator).should be == [tagged_call]
+        expect(subject.with_tag(:moderator)).to eq([tagged_call])
       end
 
       it "when a call is dead, ignore it in the search" do
@@ -89,20 +89,20 @@ module Adhearsion
         tagged_call.tag :moderator
         Celluloid::Actor.kill tagged_call
 
-        subject.with_tag(:moderator).should be == []
+        expect(subject.with_tag(:moderator)).to eq([])
       end
     end
 
     it "finding calls by uri" do
       calls.each { |call| subject << call }
 
-      subject.with_uri(calls.last.uri).should be == calls.last
+      expect(subject.with_uri(calls.last.uri)).to eq(calls.last)
     end
 
     describe "#<<" do
       it "should allow chaining" do
         subject << Call.new(new_offer) << Call.new(new_offer)
-        subject.size.should be == 2
+        expect(subject.size).to eq(2)
       end
     end
 
@@ -117,9 +117,9 @@ module Adhearsion
 
         sleep 0.1
 
-        subject.size.should be == size_before
-        subject[call_id].should be_nil
-        subject.with_uri(call_uri).should be_nil
+        expect(subject.size).to eq(size_before)
+        expect(subject[call_id]).to be_nil
+        expect(subject.with_uri(call_uri)).to be_nil
       end
     end
 
@@ -133,7 +133,7 @@ module Adhearsion
       end
 
       def crash
-        lambda { call.crash_me }.should raise_error(StandardError, "Someone crashed me")
+        expect { call.crash_me }.to raise_error(StandardError, "Someone crashed me")
         sleep 0.5
       end
 
@@ -143,20 +143,20 @@ module Adhearsion
         size_before = subject.size
 
         subject << call
-        subject.size.should be > size_before
-        subject[call_id].should be call
-        subject.with_uri(call_uri).should be call
+        expect(subject.size).to be > size_before
+        expect(subject[call_id]).to be call
+        expect(subject.with_uri(call_uri)).to be call
 
         crash
-        subject.size.should be == size_before
-        subject[call_id].should be_nil
-        subject.with_uri(call_uri).should be_nil
+        expect(subject.size).to eq(size_before)
+        expect(subject[call_id]).to be_nil
+        expect(subject.with_uri(call_uri)).to be_nil
       end
 
       it "is sends a hangup command for the call" do
         call_id = call.id
-        PunchblockPlugin.stub :client => double('Client')
-        PunchblockPlugin.client.should_receive(:execute_command).once.with(Punchblock::Command::Hangup.new, :async => true, :call_id => call_id)
+        allow(PunchblockPlugin).to receive_messages :client => double('Client')
+        expect(PunchblockPlugin.client).to receive(:execute_command).once.with(Punchblock::Command::Hangup.new, :async => true, :call_id => call_id)
 
         subject << call
 
@@ -165,7 +165,7 @@ module Adhearsion
 
       it "shuts down the actor" do
         crash
-        call.should_not be_alive
+        expect(call.alive?).to be false
       end
     end
   end

data/spec/adhearsion/configuration_spec.rb

@@ -11,30 +11,30 @@ describe Adhearsion::Configuration do
     end
 
     it "should have an empty configuration for the platform" do
-      subject.should respond_to :platform
+      expect(subject).to respond_to :platform
     end
 
     it "should have a platform configuration object" do
-      subject.platform.should be_instance_of Loquacious::Configuration
+      expect(subject.platform).to be_instance_of Loquacious::Configuration
     end
 
     it "should initialize root to nil" do
-      subject.platform.root.should be_nil
+      expect(subject.platform.root).to be_nil
     end
 
     it "should initialize logging to level info" do
-      subject.platform.logging.level.should be == :info
+      expect(subject.platform.logging.level).to eq(:info)
     end
 
     it "should allow to update a config value" do
-      subject.platform.environment.should be == :development
+      expect(subject.platform.environment).to eq(:development)
       subject.platform.environment = :production
-      subject.platform.environment.should be == :production
+      expect(subject.platform.environment).to eq(:production)
     end
 
     it "should allow to create new config values" do
       subject.platform.bar = "foo"
-      subject.platform.bar.should be == "foo"
+      expect(subject.platform.bar).to eq("foo")
     end
   end
 
@@ -47,34 +47,34 @@ describe Adhearsion::Configuration do
     end
 
     it "should return the root value" do
-      subject.platform.root.should be == "foo"
+      expect(subject.platform.root).to eq("foo")
     end
 
     it "should return the environment value" do
-      subject.platform.environment.should be == :development
+      expect(subject.platform.environment).to eq(:development)
     end
 
     it "should return a description for the platform configuration" do
-      Adhearsion.config.description(:platform).should be_instance_of String
+      expect(Adhearsion.config.description(:platform)).to be_instance_of String
     end
 
     it "should allow to update a config value" do
-      subject.platform.environment.should be == :development
+      expect(subject.platform.environment).to eq(:development)
       subject.platform.environment = :production
-      subject.platform.environment.should be == :production
+      expect(subject.platform.environment).to eq(:production)
     end
 
     it "should allow to create new config values" do
       subject.platform.bar = "bazz"
-      subject.platform.bar.should be == "bazz"
+      expect(subject.platform.bar).to eq("bazz")
     end
   end
 
   describe "when configuring a non existing object" do
     it "should raise a ConfigurationError" do
-      lambda {
+      expect {
         Adhearsion.config.foo.bar = "bazz"
-      }.should raise_error Adhearsion::Configuration::ConfigurationError, "Invalid plugin foo"
+      }.to raise_error Adhearsion::Configuration::ConfigurationError, "Invalid plugin foo"
     end
   end
 
@@ -86,11 +86,11 @@ describe Adhearsion::Configuration do
     subject{ Adhearsion.config[:platform] }
 
     it "should return the valid platform configuration object" do
-      subject.should be_instance_of ::Loquacious::Configuration
+      expect(subject).to be_instance_of ::Loquacious::Configuration
     end
 
     it "should allow to retrieve any platform configuration value" do
-      subject.environment.should be == :development
+      expect(subject.environment).to eq(:development)
     end
 
     describe "if configuration has a named environment" do
@@ -129,13 +129,13 @@ describe Adhearsion::Configuration do
       end
 
       it "should return by default the development value" do
-        subject.platform.my_level.should be == 1
+        expect(subject.platform.my_level).to eq(1)
       end
 
       [:staging, :production, :test].each do |env|
         it "should return the #{env.to_s} value when environment set to #{env.to_s}" do
           config_object.platform.environment = env
-          subject.platform.my_level.should be == env_values[env]
+          expect(subject.platform.my_level).to eq(env_values[env])
         end
       end
     end
@@ -149,12 +149,12 @@ describe Adhearsion::Configuration do
     end
 
     it "should return 'development' by default" do
-      Adhearsion.config.platform.environment.should be == :development
+      expect(Adhearsion.config.platform.environment).to eq(:development)
     end
 
     [:development, :production, :staging, :test].each do |env|
       it "should respond to #{env.to_s}" do
-        Adhearsion.config.should respond_to(env)
+        expect(Adhearsion.config).to respond_to(env)
       end
     end
 
@@ -162,20 +162,20 @@ describe Adhearsion::Configuration do
       [:production, :staging, :test].each do |env|
         it "should override the environment value with #{env.to_s} when set in ENV value" do
           ENV['AHN_ENV'] = env.to_s
-          Adhearsion.config.platform.environment.should be == env
+          expect(Adhearsion.config.platform.environment).to eq(env)
         end
       end
     end
 
     it "should not override the default environment with the ENV value if valid" do
       ENV['AHN_ENV'] = "invalid_value"
-      Adhearsion.config.platform.environment.should be == :development
+      expect(Adhearsion.config.platform.environment).to eq(:development)
     end
 
     it "should allow to add a new environment" do
-      Adhearsion.config.valid_environment?(:another_environment).should be == false
+      expect(Adhearsion.config.valid_environment?(:another_environment)).to eq(false)
       Adhearsion.environments << :another_environment
-      Adhearsion.config.valid_environment?(:another_environment).should be == true
+      expect(Adhearsion.config.valid_environment?(:another_environment)).to eq(true)
     end
 
   end
@@ -189,16 +189,16 @@ describe Adhearsion::Configuration do
 
     it "should retrieve a string with the platform configuration" do
       desc = subject.description :platform, :show_values => false
-      desc.length.should be > 0
-      desc.should match(/^.*environment.*$/)
-      desc.should match(/^.*root.*$/)
+      expect(desc.length).to be > 0
+      expect(desc).to match(/^.*environment.*$/)
+      expect(desc).to match(/^.*root.*$/)
     end
 
     it "should retrieve a string with the platform configuration and values" do
       desc = subject.description :platform
-      desc.length.should be > 0
-      desc.should match(/^.*environment.*:development.*$/)
-      desc.should match(/^.*root.*$/)
+      expect(desc.length).to be > 0
+      expect(desc).to match(/^.*environment.*:development.*$/)
+      expect(desc).to match(/^.*root.*$/)
     end
 
     describe "if there are plugins installed" do
@@ -219,9 +219,9 @@ describe Adhearsion::Configuration do
           subject { Adhearsion.config.my_plugin }
 
           it "should have the correct values" do
-            subject[:name].should be == 'user'
-            subject[:password].should be == 'password'
-            subject[:host].should be == 'localhost'
+            expect(subject[:name]).to eq('user')
+            expect(subject[:password]).to eq('password')
+            expect(subject[:host]).to eq('localhost')
           end
         end
 
@@ -229,9 +229,9 @@ describe Adhearsion::Configuration do
           subject { Adhearsion.config[:my_plugin] }
 
           it "should have the correct values" do
-            subject[:name].should be == 'user'
-            subject[:password].should be == 'password'
-            subject[:host].should be == 'localhost'
+            expect(subject[:name]).to eq('user')
+            expect(subject[:password]).to eq('password')
+            expect(subject[:host]).to eq('localhost')
           end
         end
 
@@ -256,13 +256,13 @@ describe Adhearsion::Configuration do
 
           it "should return the development value by default" do
             Adhearsion.config # initialize
-            subject.name.should be == "development"
+            expect(subject.name).to eq("development")
           end
 
           [:development, :staging, :production, :test].each do |env|
             it "should return the #{env.to_s} value when environment is set to #{env.to_s}" do
               Adhearsion.config.platform.environment = env
-              subject.name.should be == env.to_s
+              expect(subject.name).to eq(env.to_s)
             end
           end
         end
@@ -270,40 +270,40 @@ describe Adhearsion::Configuration do
 
       it "should retrieve a valid plugin description" do
         desc = subject.description :my_plugin
-        desc.length.should be > 0
-        desc.should match(/^.*name.*user.*$/)
-        desc.should match(/^.*password.*password.*$/)
-        desc.should match(/^.*host.*localhost.*$/)
+        expect(desc.length).to be > 0
+        expect(desc).to match(/^.*name.*user.*$/)
+        expect(desc).to match(/^.*password.*password.*$/)
+        expect(desc).to match(/^.*host.*localhost.*$/)
       end
 
       it "should retrieve a valid plugin description with no values" do
         desc = subject.description :my_plugin, :show_values => false
-        desc.length.should be > 0
-        desc.should match(/^.*name.*$/)
-        desc.should match(/^.*password.*$/)
-        desc.should match(/^.*host.*$/)
+        expect(desc.length).to be > 0
+        expect(desc).to match(/^.*name.*$/)
+        expect(desc).to match(/^.*password.*$/)
+        expect(desc).to match(/^.*host.*$/)
       end
 
       it "should retrieve both platform and plugin configuration" do
         desc = subject.description :all
-        desc.length.should be > 0
-        desc.should match(/^.*environment.*:development.*$/)
-        desc.should match(/^.*root.*$/)
-        desc.should match(/^.*name.*user.*$/)
-        desc.should match(/^.*password.*password.*$/)
-        desc.should match(/^.*host.*localhost.*$/)
+        expect(desc.length).to be > 0
+        expect(desc).to match(/^.*environment.*:development.*$/)
+        expect(desc).to match(/^.*root.*$/)
+        expect(desc).to match(/^.*name.*user.*$/)
+        expect(desc).to match(/^.*password.*password.*$/)
+        expect(desc).to match(/^.*host.*localhost.*$/)
       end
 
       it "should retrieve both platform and plugin configuration with no values" do
         desc = subject.description :all, :show_values => false
-        desc.length.should be > 0
-        desc.should match(/^.*Configuration for platform.*$/)
-        desc.should match(/^.*environment.*$/)
-        desc.should match(/^.*root.*$/)
-        desc.should match(/^.*Configuration for my_plugin.*$/)
-        desc.should match(/^.*name.*$/)
-        desc.should match(/^.*password.*$/)
-        desc.should match(/^.*host.*$/)
+        expect(desc.length).to be > 0
+        expect(desc).to match(/^.*Configuration for platform.*$/)
+        expect(desc).to match(/^.*environment.*$/)
+        expect(desc).to match(/^.*root.*$/)
+        expect(desc).to match(/^.*Configuration for my_plugin.*$/)
+        expect(desc).to match(/^.*name.*$/)
+        expect(desc).to match(/^.*password.*$/)
+        expect(desc).to match(/^.*host.*$/)
       end
     end
 

data/spec/adhearsion/console_spec.rb

@@ -5,26 +5,26 @@ require 'spec_helper'
 module Adhearsion
   describe Console do
     before do
-      Console.instance.stub :pry => nil
+      allow(Console.instance).to receive_messages :pry => nil
     end
 
     describe "providing hooks to include console functionality" do
       it "should allow mixing in a module globally on all CallController classes" do
         Console.mixin TestBiscuit
-        Console.throwadogabone.should be true
+        expect(Console.throwadogabone).to be true
       end
     end
 
     unless defined? JRUBY_VERSION # These tests are not valid on JRuby
       describe 'testing for readline' do
         it 'should return false when detecting readline' do
-          Readline.should_receive(:emacs_editing_mode).once.and_return true
-          Console.cruby_with_readline?.should be true
+          expect(Readline).to receive(:emacs_editing_mode).once.and_return true
+          expect(Console.cruby_with_readline?).to be true
         end
 
         it 'should return true when detecting libedit' do
-          Readline.should_receive(:emacs_editing_mode).once.and_raise NotImplementedError
-          Console.cruby_with_readline?.should be false
+          expect(Readline).to receive(:emacs_editing_mode).once.and_raise NotImplementedError
+          expect(Console.cruby_with_readline?).to be false
         end
       end
     end
@@ -32,7 +32,7 @@ module Adhearsion
     describe "#log_level" do
       context "with a value" do
         it "should set the log level via Adhearsion::Logging" do
-          Adhearsion::Logging.should_receive(:level=).once.with(:foo)
+          expect(Adhearsion::Logging).to receive(:level=).once.with(:foo)
           Console.log_level :foo
         end
       end
@@ -40,28 +40,28 @@ module Adhearsion
       context "without a value" do
         it "should return the current level as a symbol" do
           Adhearsion::Logging.level = :fatal
-          Console.log_level.should be == :fatal
+          expect(Console.log_level).to eq(:fatal)
         end
       end
     end
 
     describe "#silence!" do
       it "should delegate to Adhearsion::Logging" do
-        Adhearsion::Logging.should_receive(:silence!).once
+        expect(Adhearsion::Logging).to receive(:silence!).once
         Console.silence!
       end
     end
 
     describe "#unsilence!" do
       it "should delegate to Adhearsion::Logging" do
-        Adhearsion::Logging.should_receive(:unsilence!).once
+        expect(Adhearsion::Logging).to receive(:unsilence!).once
         Console.unsilence!
       end
     end
 
     describe "#shutdown!" do
       it "should tell the process to shutdown" do
-        Adhearsion::Process.should_receive(:shutdown!).once
+        expect(Adhearsion::Process).to receive(:shutdown!).once
         Console.shutdown!
       end
     end
@@ -69,9 +69,9 @@ module Adhearsion
     describe "#originate" do
       it "should be an alias for Adhearsion::OutboundCall.originate" do
         foo = nil
-        Adhearsion::OutboundCall.should_receive(:originate).once.with(:foo, :bar).and_yield
+        expect(Adhearsion::OutboundCall).to receive(:originate).once.with(:foo, :bar).and_yield
         Console.originate(:foo, :bar) { foo = :bar}
-        foo.should == :bar
+        expect(foo).to eq(:bar)
       end
     end
 
@@ -81,12 +81,12 @@ module Adhearsion
 
       before do
         Adhearsion.active_calls.clear
-        call.stub(:id => call_id)
+        allow(call).to receive_messages(:id => call_id)
       end
 
       context "with a call" do
         it "should interact with the call" do
-          Console.instance.should_receive(:interact_with_call).once.with call
+          expect(Console.instance).to receive(:interact_with_call).once.with call
           Console.take call
         end
       end
@@ -98,7 +98,7 @@ module Adhearsion
           end
 
           it "should interact with the current call" do
-            Console.instance.should_receive(:interact_with_call).once.with call
+            expect(Console.instance).to receive(:interact_with_call).once.with call
             Console.take
           end
         end
@@ -107,15 +107,15 @@ module Adhearsion
           let(:call2) { Call.new }
 
           before do
-            call2.stub :id => rand.to_s
+            allow(call2).to receive_messages :id => rand.to_s
             Adhearsion.active_calls << call << call2
           end
 
           it "should allow selection of the call to use" do
             mock_io = StringIO.new
             Console.input = mock_io
-            mock_io.should_receive(:gets).once.and_return "1\n"
-            Console.instance.should_receive(:interact_with_call).once.with call2
+            expect(mock_io).to receive(:gets).once.and_return "1\n"
+            expect(Console.instance).to receive(:interact_with_call).once.with call2
             Console.take
           end
         end
@@ -128,15 +128,15 @@ module Adhearsion
           end
 
           it "should interact with that call" do
-            Console.instance.should_receive(:interact_with_call).once.with call
+            expect(Console.instance).to receive(:interact_with_call).once.with call
             Console.take call_id
           end
         end
 
         context "if an active call with that ID does not exist" do
           it "should log an error explaining that the call does not exist" do
-            Console.logger.should_receive(:error).once.with(/does not exist/)
-            Console.instance.should_receive(:interact_with_call).never
+            expect(Console.logger).to receive(:error).once.with(/does not exist/)
+            expect(Console.instance).to receive(:interact_with_call).never
             Console.take call_id
           end
         end
@@ -147,16 +147,16 @@ module Adhearsion
       let(:call) { Call.new }
 
       it "should pause the call's controllers, and unpause even if the interactive controller raises" do
-        call.should_receive(:pause_controllers).once.ordered
-        CallController.should_receive(:exec).once.ordered.and_raise StandardError
-        call.should_receive(:resume_controllers).once.ordered
-        lambda { Console.interact_with_call call }.should raise_error StandardError
+        expect(call).to receive(:pause_controllers).once.ordered
+        expect(CallController).to receive(:exec).once.ordered.and_raise StandardError
+        expect(call).to receive(:resume_controllers).once.ordered
+        expect { Console.interact_with_call call }.to raise_error StandardError
       end
 
       it "should execute an interactive call controller on the call" do
-        CallController.should_receive(:exec).once do |c|
-          c.should be_a Console::InteractiveController
-          c.call.should be call
+        expect(CallController).to receive(:exec).once do |c|
+          expect(c).to be_a Console::InteractiveController
+          expect(c.call).to be call
         end
         Console.interact_with_call call
       end