adhearsion 2.5.4 → 2.6.0

data/spec/adhearsion/events_spec.rb

@@ -13,7 +13,7 @@ module Adhearsion
     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
@@ -21,7 +21,7 @@ module Adhearsion
       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!
@@ -29,16 +29,16 @@ module Adhearsion
 
       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
@@ -46,8 +46,8 @@ module Adhearsion
 
       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
@@ -59,13 +59,13 @@ module Adhearsion
 
       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
@@ -88,7 +88,7 @@ module Adhearsion
 
       Events.trigger_immediately :event, EventClass.new
 
-      result.should be == :bar
+      expect(result).to eq(:bar)
 
       Events.clear_handlers :event, EventClass
     end
@@ -97,8 +97,8 @@ module Adhearsion
       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
@@ -112,7 +112,7 @@ module Adhearsion
 
         Events.trigger_immediately :event
 
-        result.should be == :foo
+        expect(result).to eq(:foo)
 
         Events.clear_handlers :event
       end

data/spec/adhearsion/generators_spec.rb

@@ -12,7 +12,7 @@ module Adhearsion
         DummyGenerator = Class.new
 
         Generators.add_generator generator_key, DummyGenerator
-        Generators.mappings[generator_key].should be == DummyGenerator
+        expect(Generators.mappings[generator_key]).to eq(DummyGenerator)
       end
     end
   end

data/spec/adhearsion/initializer_spec.rb

@@ -12,8 +12,8 @@ describe Adhearsion::Initializer do
   describe "#start" do
     before do
       ::Logging.reset
-      Adhearsion::Logging.should_receive(:start).once.and_return('')
-      ::Logging::Appenders.stub(:file => nil)
+      expect(Adhearsion::Logging).to receive(:start).once.and_return('')
+      allow(::Logging::Appenders).to receive_messages(:file => nil)
       Adhearsion.config = nil
     end
 
@@ -34,7 +34,7 @@ describe Adhearsion::Initializer do
     end
 
     it "should start the stats aggregator" do
-      Adhearsion.should_receive(:statistics).at_least(:once)
+      expect(Adhearsion).to receive(:statistics).at_least(:once)
       stub_behavior_for_initializer_with_no_path_changing_behavior do
         Adhearsion::Initializer.start
       end
@@ -42,33 +42,33 @@ describe Adhearsion::Initializer do
 
     it "should create a pid file in the app's path when given 'true' as the pid_file hash key argument" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
+        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
         ahn = Adhearsion::Initializer.start :pid_file => true
-        ahn.pid_file[0, path.length].should be == path
+        expect(ahn.pid_file[0, path.length]).to eq(path)
       end
     end
 
     it "should NOT create a pid file in the app's path when given 'false' as the pid_file hash key argument" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
         ahn = Adhearsion::Initializer.start :pid_file => false
-        ahn.pid_file.should be nil
+        expect(ahn.pid_file).to be nil
       end
     end
 
     it "should create a pid file in the app's path by default when daemonizing" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        Adhearsion::CustomDaemonizer.should_receive(:daemonize).and_yield '123'
-        File.should_receive(:open).once.with(File.join(path, 'adhearsion.pid'), 'w')
+        expect(Adhearsion::CustomDaemonizer).to receive(:daemonize).and_yield '123'
+        expect(File).to receive(:open).once.with(File.join(path, 'adhearsion.pid'), 'w')
         ahn = Adhearsion::Initializer.start :mode => :daemon
-        ahn.pid_file[0, path.size].should be == path
+        expect(ahn.pid_file[0, path.size]).to eq(path)
       end
     end
 
     it "should NOT create a pid file in the app's path when daemonizing and :pid_file is given as false" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        Adhearsion::CustomDaemonizer.should_receive(:daemonize).and_yield '123'
+        expect(Adhearsion::CustomDaemonizer).to receive(:daemonize).and_yield '123'
         ahn = Adhearsion::Initializer.start :mode => :daemon, :pid_file => false
-        ahn.pid_file.should be nil
+        expect(ahn.pid_file).to be nil
       end
     end
 
@@ -76,63 +76,63 @@ describe Adhearsion::Initializer do
       random_file = "/tmp/AHN_TEST_#{rand 100000}.pid"
       stub_behavior_for_initializer_with_no_path_changing_behavior do
         ahn = Adhearsion::Initializer.start :pid_file => random_file
-        ahn.pid_file.should be == random_file
-        File.exists?(random_file).should be true
+        expect(ahn.pid_file).to eq(random_file)
+        expect(File.exists?(random_file)).to be true
         File.delete random_file
       end
     end
 
     it "should resolve the log file path to daemonize" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
+        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
         ahn = Adhearsion::Initializer.start :pid_file => true
-        ahn.resolve_log_file_path.should be == path + Adhearsion.config.platform.logging.outputters[0]
+        expect(ahn.resolve_log_file_path).to eq(path + Adhearsion.config.platform.logging.outputters[0])
       end
     end
 
     it "should resolve the log file path to daemonize when outputters is an Array" do
       Adhearsion.config.platform.logging.outputters = ["log/my_application.log", "log/adhearsion.log"]
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
+        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
         ahn = Adhearsion::Initializer.start :pid_file => true
-        ahn.resolve_log_file_path.should be == path + Adhearsion.config.platform.logging.outputters[0]
+        expect(ahn.resolve_log_file_path).to eq(path + Adhearsion.config.platform.logging.outputters[0])
       end
     end
 
     it "should return a valid appenders array" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
+        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
         ahn = Adhearsion::Initializer.start :pid_file => true
         appenders = ahn.init_get_logging_appenders
-        appenders.should have(2).items
-        appenders[1].should be_instance_of Logging::Appenders::Stdout
+        expect(appenders.size).to eq(2)
+        expect(appenders[1]).to be_instance_of Logging::Appenders::Stdout
       end
     end
 
     it "should initialize properly the log paths" do
       ahn = stub_behavior_for_initializer_with_no_path_changing_behavior do
-        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
+        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
         Adhearsion::Initializer.start :pid_file => true
       end
-      Dir.should_receive(:mkdir).with("log/")
+      expect(Dir).to receive(:mkdir).with("log/")
       ahn.initialize_log_paths
     end
 
     it "should initialize properly the log paths when outputters is an array" do
       Adhearsion.config.platform.logging.outputters = ["log/my_application.log", "log/test/adhearsion.log"]
       ahn = stub_behavior_for_initializer_with_no_path_changing_behavior do
-        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
+        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
         Adhearsion::Initializer.start :pid_file => true
       end
-      Dir.should_receive(:mkdir).with("log/").twice
-      Dir.should_receive(:mkdir).with("log/test/").once
+      expect(Dir).to receive(:mkdir).with("log/").twice
+      expect(Dir).to receive(:mkdir).with("log/test/").once
       ahn.initialize_log_paths
     end
 
     it "should set the adhearsion proc name" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
-        Adhearsion::LinuxProcName.should_receive(:set_proc_name).with(Adhearsion.config.platform.process_name)
+        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
+        expect(Adhearsion::LinuxProcName).to receive(:set_proc_name).with(Adhearsion.config.platform.process_name)
         Adhearsion::Initializer.start :pid_file => true
       end
     end
@@ -141,14 +141,14 @@ describe Adhearsion::Initializer do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
         Adhearsion::Initializer.start :pid_file => true
       end
-      $0.should be == Adhearsion.config.platform.process_name
+      expect($0).to eq(Adhearsion.config.platform.process_name)
     end
   end
 
   describe "Initializing logger" do
     before do
       ::Logging.reset
-      ::Logging::Appenders.should_receive(:file).and_return(nil)
+      expect(::Logging::Appenders).to receive(:file).and_return(nil)
       Adhearsion.config = nil
     end
 
@@ -161,8 +161,8 @@ describe Adhearsion::Initializer do
 
     it "should start logging with valid parameters" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        File.should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
-        Adhearsion::Logging.should_receive(:start).once.with(kind_of(Array), :info, nil).and_return('')
+        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
+        expect(Adhearsion::Logging).to receive(:start).once.with(kind_of(Array), :info, nil).and_return('')
         Adhearsion::Initializer.start :pid_file => true
       end
     end
@@ -174,24 +174,24 @@ describe Adhearsion::Initializer do
     end
 
     it "should load the contents of lib directory" do
-      Dir.should_receive(:chdir).with(File.join(path, "lib")).and_return []
+      expect(Dir).to receive(:chdir).with(File.join(path, "lib")).and_return []
       Adhearsion::Initializer.new.load_lib_folder
     end
 
     it "should return false if folder does not exist" do
       Adhearsion.config.platform.lib = "my_random_lib_directory"
-      Adhearsion::Initializer.new.load_lib_folder.should be == false
+      expect(Adhearsion::Initializer.new.load_lib_folder).to eq(false)
     end
 
     it "should return false and not load any file if config folder is set to nil" do
       Adhearsion.config.platform.lib = nil
-      Adhearsion::Initializer.new.load_lib_folder.should be == false
+      expect(Adhearsion::Initializer.new.load_lib_folder).to eq(false)
     end
 
     it "should load the contents of the preconfigured directory" do
       Adhearsion.config.platform.lib = "foo"
-      File.stub directory?: true
-      Dir.should_receive(:chdir).with(File.join(path, "foo")).and_return []
+      allow(File).to receive_messages directory?: true
+      expect(Dir).to receive(:chdir).with(File.join(path, "foo")).and_return []
       Adhearsion::Initializer.new.load_lib_folder
     end
   end
@@ -202,8 +202,8 @@ describe "Updating RAILS_ENV variable" do
 
   before do
     ::Logging.reset
-    Adhearsion::Logging.should_receive(:start).once.and_return('')
-    ::Logging::Appenders.should_receive(:file).and_return(nil)
+    expect(Adhearsion::Logging).to receive(:start).once.and_return('')
+    expect(::Logging::Appenders).to receive(:file).and_return(nil)
     Adhearsion.config = nil
   end
 
@@ -226,7 +226,7 @@ describe "Updating RAILS_ENV variable" do
           ahn = Adhearsion::Initializer.start
         end
         ahn.update_rails_env_var
-        ENV['RAILS_ENV'].should be == env.to_s
+        expect(ENV['RAILS_ENV']).to eq(env.to_s)
       end
     end
   end
@@ -244,7 +244,7 @@ describe "Updating RAILS_ENV variable" do
           ahn = Adhearsion::Initializer.start
         end
         ahn.update_rails_env_var
-        ENV['RAILS_ENV'].should be == "test"
+        expect(ENV['RAILS_ENV']).to eq("test")
       end
     end
 
@@ -255,7 +255,7 @@ describe "Updating RAILS_ENV variable" do
           ahn = Adhearsion::Initializer.start
         end
         ahn.update_rails_env_var
-        ENV['RAILS_ENV'].should be == "test"
+        expect(ENV['RAILS_ENV']).to eq("test")
       end
     end
   end
@@ -271,7 +271,7 @@ describe "Updating RAILS_ENV variable" do
         ahn = Adhearsion::Initializer.start
       end
       ahn.update_rails_env_var
-      ENV['RAILS_ENV'].should be == "production"
+      expect(ENV['RAILS_ENV']).to eq("production")
     end
   end
 

data/spec/adhearsion/logging_spec.rb

@@ -20,73 +20,73 @@ describe Adhearsion::Logging do
   end
 
   it 'should be added to any Object' do
-    Foo.should respond_to(:logger)
+    expect(Foo).to respond_to(:logger)
   end
 
   it 'should be added to any Object instance' do
-    Foo.new.should respond_to :logger
+    expect(Foo.new).to respond_to :logger
   end
 
   it 'should create the predefined set of log levels' do
-    ::Logging::LEVELS.keys.should be == Adhearsion::Logging::LOG_LEVELS.map(&:downcase)
+    expect(::Logging::LEVELS.keys).to eq(Adhearsion::Logging::LOG_LEVELS.map(&:downcase))
   end
 
   it "should log to the Object logger when given arguments" do
     message = "o hai. ur home erly."
     foo = Foo.new
-    ::Logging.logger[Foo].should_receive(:info).once.with(message)
+    expect(::Logging.logger[Foo]).to receive(:info).once.with(message)
     foo.logger.info message
   end
 
   it "should log to the Object logger when given arguments (II)" do
     message = "o hai. ur home erly."
     bar = Foo::Bar.new
-    ::Logging.logger[Foo::Bar].should_receive(:info).once.with(message)
+    expect(::Logging.logger[Foo::Bar]).to receive(:info).once.with(message)
     bar.logger.info message
   end
 
   it 'should create a new logger when given method_missing' do
     FooBar = Class.new Foo
-    ::Logging::Repository.instance[FooBar].should be_nil
+    expect(::Logging::Repository.instance[FooBar]).to be_nil
     FooBar.logger.info "o hai. ur home erly."
-    ::Logging::Repository.instance[FooBar].should_not be_nil
+    expect(::Logging::Repository.instance[FooBar]).not_to be_nil
   end
 
     it "initializes properly a Logging object" do
-    ::Logging.logger.root.appenders.length.should eql(1)
-    ::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::Stdout)}.length.should eql(1)
+    expect(::Logging.logger.root.appenders.length).to eql(1)
+    expect(::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::Stdout)}.length).to eql(1)
   end
 
   it "initializes properly a Logging object with appenders as parameter" do
     Adhearsion::Logging.start([::Logging.appenders.stdout, ::Logging.appenders.file('example.log')])
-    ::Logging.logger.root.appenders.length.should eql(2)
-    ::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::Stdout)}.length.should eql(1)
-    ::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::File)}.length.should eql(1)
+    expect(::Logging.logger.root.appenders.length).to eql(2)
+    expect(::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::Stdout)}.length).to eql(1)
+    expect(::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::File)}.length).to eql(1)
   end
 
   it "initializes properly a Logging object with appenders and log level as parameter" do
     Adhearsion::Logging.start([::Logging.appenders.stdout, ::Logging.appenders.file('example.log')], :debug)
-    ::Logging.logger.root.appenders.length.should eql(2)
-    ::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::Stdout)}.length.should eql(1)
-    ::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::File)}.length.should eql(1)
-    ::Logging.logger.root.level.should eql(::Logging::LEVELS["debug"])
+    expect(::Logging.logger.root.appenders.length).to eql(2)
+    expect(::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::Stdout)}.length).to eql(1)
+    expect(::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::File)}.length).to eql(1)
+    expect(::Logging.logger.root.level).to eql(::Logging::LEVELS["debug"])
   end
 
   it "should create only a Logging object per Class (reuse per all the instances)" do
     _logger = Foo.new.logger
     10.times do
-      Foo.new.logger.object_id.should eql(_logger.object_id)
+      expect(Foo.new.logger.object_id).to eql(_logger.object_id)
     end
   end
 
   it "should reuse a Logging instance in all Class instances but not with child instances" do
     _foo_logger = Foo.new.logger
     _bar_logger = Foo::Bar.new.logger
-    _foo_logger.object_id.should_not eql(_bar_logger)
+    expect(_foo_logger.object_id).not_to eql(_bar_logger)
   end
 
   it 'should reopen logfiles' do
-    ::Logging.should_receive(:reopen).once
+    expect(::Logging).to receive(:reopen).once
     Adhearsion::Logging.reopen_logs
   end
 
@@ -95,9 +95,9 @@ describe Adhearsion::Logging do
     Adhearsion.config.platform.logging['level'] = :warn
     Adhearsion::Logging.level = :warn
     Adhearsion::Logging.toggle_trace!
-    Adhearsion::Logging.level.should be == 0
+    expect(Adhearsion::Logging.level).to eq(0)
     Adhearsion::Logging.toggle_trace!
-    Adhearsion::Logging.level.should be == 3
+    expect(Adhearsion::Logging.level).to eq(3)
     Adhearsion.config.platform.logging['level'] = orig_level
   end
 
@@ -108,40 +108,40 @@ describe Adhearsion::Logging do
 
     it 'changing the logging level should affect all loggers' do
       loggers = [::Foo.logger, ::Foo::Bar.logger]
-      loggers.map(&:level).should_not be == [Adhearsion::Logging::DEBUG] * 2
-      loggers.map(&:level).should be == [Adhearsion::Logging::INFO] * 2
+      expect(loggers.map(&:level)).not_to eq([Adhearsion::Logging::DEBUG] * 2)
+      expect(loggers.map(&:level)).to eq([Adhearsion::Logging::INFO] * 2)
       Adhearsion::Logging.logging_level = :warn
-      loggers.map(&:level).should be == [Adhearsion::Logging::WARN] * 2
+      expect(loggers.map(&:level)).to eq([Adhearsion::Logging::WARN] * 2)
     end
 
     it 'changing the logging level, using level=, should affect all loggers' do
       loggers = [Foo.logger, ::Foo::Bar.logger]
-      loggers.map(&:level).should_not be == [::Logging::LEVELS["debug"]] * 2
-      loggers.map(&:level).should be == [::Logging::LEVELS["info"]] * 2
+      expect(loggers.map(&:level)).not_to eq([::Logging::LEVELS["debug"]] * 2)
+      expect(loggers.map(&:level)).to eq([::Logging::LEVELS["info"]] * 2)
       Adhearsion::Logging.level = :warn
-      loggers.map(&:level).should be == [::Logging::LEVELS["warn"]] * 2
+      expect(loggers.map(&:level)).to eq([::Logging::LEVELS["warn"]] * 2)
     end
 
     it 'should change all the Logger instance level' do
-      Foo.logger.level.should be Adhearsion::Logging::INFO
+      expect(Foo.logger.level).to be Adhearsion::Logging::INFO
       Adhearsion::Logging.logging_level = :fatal
-      Foo.logger.level.should be Adhearsion::Logging::FATAL
+      expect(Foo.logger.level).to be Adhearsion::Logging::FATAL
     end
 
     it 'a new logger should have the :root logging level' do
-      Foo.logger.level.should be Adhearsion::Logging::INFO
+      expect(Foo.logger.level).to be Adhearsion::Logging::INFO
       Adhearsion::Logging.logging_level = :fatal
-      Foo::Bar.logger.level.should be Adhearsion::Logging::FATAL
+      expect(Foo::Bar.logger.level).to be Adhearsion::Logging::FATAL
     end
 
     it '#silence! should change the level to be FATAL' do
       Adhearsion::Logging.silence!
-      Adhearsion::Logging.logging_level.should be(Adhearsion::Logging::FATAL)
+      expect(Adhearsion::Logging.logging_level).to be(Adhearsion::Logging::FATAL)
     end
 
     it '#unsilence! should change the level to be INFO' do
       Adhearsion::Logging.unsilence!
-      Adhearsion::Logging.logging_level.should be(Adhearsion::Logging::INFO)
+      expect(Adhearsion::Logging.logging_level).to be(Adhearsion::Logging::INFO)
     end
 
   end