adhearsion 2.0.0.alpha1 → 2.0.0.alpha2

data/spec/adhearsion/calls_spec.rb

@@ -4,11 +4,15 @@ module Adhearsion
   describe Calls do
     before { Adhearsion.active_calls.clear! }
 
-    let(:call) { Adhearsion::Call.new mock_offer }
+    let(:call) { Adhearsion::Call.new new_offer }
+
+    def new_offer(call_id = nil, headers = {})
+      Punchblock::Event::Offer.new :call_id => call_id || rand, :headers => headers
+    end
 
     it 'can create a call and add it to the active calls' do
       Adhearsion.active_calls.any?.should == false
-      call = Adhearsion.active_calls.from_offer mock_offer
+      call = Adhearsion.active_calls.from_offer new_offer
       call.should be_a Adhearsion::Call
       Adhearsion.active_calls.size.should == 1
     end
@@ -21,7 +25,7 @@ module Adhearsion
 
     it '#remove_inactive_call should delete the call in the Hash' do
       number_of_calls = 10
-      calls = Array.new(number_of_calls) { Adhearsion::Call.new mock_offer }
+      calls = Array.new(number_of_calls) { Adhearsion::Call.new new_offer }
       calls.each { |call| subject << call }
 
       deleted_call = calls[number_of_calls / 2]
@@ -35,7 +39,7 @@ module Adhearsion
     end
 
     it "finding calls by a tag" do
-      calls = Array.new(3) { Adhearsion::Call.new mock_offer }
+      calls = Array.new(3) { Adhearsion::Call.new new_offer }
       calls.each { |call| subject << call }
 
       tagged_call = calls.last

data/spec/adhearsion/console_spec.rb

@@ -0,0 +1,24 @@
+require 'spec_helper'
+
+module Adhearsion
+  describe Console do
+    describe "providing hooks to include console functionality" do
+      it "should allow mixing in a module globally on all CallController classes" do
+        Adhearsion::Console.mixin TestBiscuit
+        Adhearsion::Console.throwadogabone.should be true
+      end
+    end
+
+    describe 'testing for libedit vs. readline' do
+      it 'should return true when detecting readline' do
+        flexmock(Readline).should_receive(:emacs_editing_mode).once.and_return true
+        Adhearsion::Console.libedit?.should be false
+      end
+
+      it 'should return false when detecting libedit' do
+        flexmock(Readline).should_receive(:emacs_editing_mode).once.and_raise NotImplementedError
+        Adhearsion::Console.libedit?.should be true
+      end
+    end
+  end
+end

data/spec/adhearsion/initializer/logging_spec.rb

@@ -39,9 +39,6 @@ describe Adhearsion::Initializer::Logging do
     ::Logging.logger.root.level.should eql(::Logging::LEVELS["debug"])
   end
 
-  Foo = Class.new
-  Foo::Bar = Class.new Foo
-
   it "should create only a Logging object per Class (reuse per all the instances)" do
     _logger = Foo.new.logger
     10.times do

data/spec/adhearsion/initializer_spec.rb

@@ -118,6 +118,21 @@ describe Adhearsion::Initializer do
       flexmock(Dir).should_receive(:mkdir).with("log/test/").once
       ahn.initialize_log_paths
     end
+
+    it "should set the adhearsion proc name" do
+      ahn = stub_behavior_for_initializer_with_no_path_changing_behavior do
+        flexmock(File).should_receive(:open).with(File.join(path, 'adhearsion.pid'), 'w', Proc).at_least.once
+        flexmock(Adhearsion::LinuxProcName).should_receive(:set_proc_name).with(Adhearsion.config.platform.process_name)
+        Adhearsion::Initializer.start :pid_file => true
+      end
+    end
+
+    it "should update the adhearsion proc name" do
+      ahn = stub_behavior_for_initializer_with_no_path_changing_behavior do
+        Adhearsion::Initializer.start :pid_file => true
+      end
+      $0.should == Adhearsion.config.platform.process_name
+    end
   end
 
   describe "Initializing logger" do
@@ -183,8 +198,14 @@ describe "Updating RAILS_ENV variable" do
     Adhearsion.config = nil
   end
 
-  after do
+  before do
+    ENV['RAILS_ENV'] = nil
+    ENV['AHN_ENV'] = nil
+  end
+
+  after :all do
     ENV['RAILS_ENV'] = nil
+    ENV['AHN_ENV'] = nil
   end
 
   describe "when neither RAILS_ENV nor AHN_ENV are set" do
@@ -199,51 +220,45 @@ describe "Updating RAILS_ENV variable" do
         ENV['RAILS_ENV'].should == env.to_s
       end
     end
+  end
 
-    context "when RAILS_ENV is set" do
-
-      after do
-        ENV['RAILS_ENV'] = nil
-        ENV['AHN_ENV'] = nil
-      end
+  context "when RAILS_ENV is set" do
+    before do
+      ENV['RAILS_ENV'] = "test"
+    end
 
-      it "should preserve the RAILS_ENV value if AHN_ENV is unset" do
-        ENV['RAILS_ENV'] = "test"
-        ahn = nil
-        stub_behavior_for_initializer_with_no_path_changing_behavior do
-          ahn = Adhearsion::Initializer.start
-        end
-        ahn.update_rails_env_var
-        ENV['RAILS_ENV'].should == "test"
+    it "should preserve the RAILS_ENV value if AHN_ENV is unset" do
+      ahn = nil
+      stub_behavior_for_initializer_with_no_path_changing_behavior do
+        ahn = Adhearsion::Initializer.start
       end
+      ahn.update_rails_env_var
+      ENV['RAILS_ENV'].should == "test"
+    end
 
-      it "should update the RAILS_ENV value with the AHN_ENV value" do
-        ENV['RAILS_ENV'] = "test"
-        ENV['AHN_ENV'] = "production"
-        ahn = nil
-        stub_behavior_for_initializer_with_no_path_changing_behavior do
-          ahn = Adhearsion::Initializer.start
-        end
-        ahn.update_rails_env_var
-        ENV['RAILS_ENV'].should == "production"
+    it "should update the RAILS_ENV value with the AHN_ENV value" do
+      ENV['AHN_ENV'] = "production"
+      ahn = nil
+      stub_behavior_for_initializer_with_no_path_changing_behavior do
+        ahn = Adhearsion::Initializer.start
       end
+      ahn.update_rails_env_var
+      ENV['RAILS_ENV'].should == "production"
     end
+  end
 
-    context "when RAILS_ENV is unset and AHN_ENV is set" do
-      after do
-        ENV['RAILS_ENV'] = nil
-        ENV['AHN_ENV'] = nil
-      end
+  context "when RAILS_ENV is unset and AHN_ENV is set" do
+    before do
+      ENV['AHN_ENV'] = "production"
+    end
 
-      it "should define the RAILS_ENV value with the AHN_ENV value" do
-        ENV['AHN_ENV'] = "production"
-        ahn = nil
-        stub_behavior_for_initializer_with_no_path_changing_behavior do
-          ahn = Adhearsion::Initializer.start
-        end
-        ahn.update_rails_env_var
-        ENV['RAILS_ENV'].should == "production"
+    it "should define the RAILS_ENV value with the AHN_ENV value" do
+      ahn = nil
+      stub_behavior_for_initializer_with_no_path_changing_behavior do
+        ahn = Adhearsion::Initializer.start
       end
+      ahn.update_rails_env_var
+      ENV['RAILS_ENV'].should == "production"
     end
   end
 

data/spec/adhearsion/logging_spec.rb

@@ -1,8 +1,5 @@
 require 'spec_helper'
 
-Foo       = Class.new
-Foo::Bar  = Class.new
-
 describe Adhearsion::Logging do
 
   before do

data/spec/adhearsion/outbound_call_spec.rb

@@ -18,7 +18,7 @@ module Adhearsion
     describe ".originate" do
       let(:to) { 'sip:foo@bar.com' }
 
-      let(:mock_call)     { OutboundCall.new }
+      let(:mock_call) { OutboundCall.new }
 
       def mock_dial
         flexmock(OutboundCall).new_instances.should_receive(:dial).and_return true
@@ -66,7 +66,7 @@ module Adhearsion
 
     describe "#dial" do
       def expect_message_waiting_for_response(message)
-        flexmock(subject).should_receive(:write_and_await_response).once.with(message).and_return do
+        flexmock(subject).should_receive(:write_and_await_response).once.with(message, 60).and_return do
           message.call_id = call_id
           message
         end
@@ -96,6 +96,16 @@ module Adhearsion
         subject.id.should == call_id
       end
 
+      it "should set the to from the dial command" do
+        subject.dial to, :from => from
+        subject.to.should == to
+      end
+
+      it "should set the 'from' from the dial command" do
+        subject.dial to, :from => from
+        subject.from.should == from
+      end
+
       it "should add the call to the active calls registry" do
         Adhearsion.active_calls.clear!
         subject.dial to, :from => from

data/spec/adhearsion/plugin_spec.rb

@@ -4,6 +4,10 @@ include InitializerStubs
 
 describe Adhearsion::Plugin do
 
+  before :all do
+    defined?(FooBar) and Object.send(:remove_const, :"FooBar")
+  end
+
   describe "inheritance" do
     after do
       defined?(FooBar) and Object.send(:remove_const, :"FooBar")
@@ -28,87 +32,6 @@ describe Adhearsion::Plugin do
     end
   end
 
-  describe "metaprogramming" do
-    Adhearsion::Plugin::SCOPE_NAMES.each do |method|
-      it "should respond to #{method.to_s}" do
-        Adhearsion::Plugin.should respond_to method
-      end
-
-      it "should respond to #{method.to_s}_module" do
-        Adhearsion::Plugin.should respond_to "#{method.to_s}_module"
-      end
-    end
-  end
-
-  [:rpc, :dialplan, :console].each do |method|
-
-    describe "extending an object with #{method.to_s} scope methods" do
-
-      before(:all) do
-        A = Class.new do
-          def bar
-            "bar"
-          end
-        end
-      end
-
-      after(:all) do
-        defined?(A) and Object.send(:remove_const, :"A")
-      end
-
-      before do
-        FooBar = Class.new Adhearsion::Plugin do
-          self.method(method).call(:foo) do
-            "foo".concat bar
-          end
-
-        end
-        flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
-        Adhearsion::Plugin.load_plugins
-        Adhearsion::Plugin.send("#{method.to_s}_module".to_sym).instance_methods.map{|x| x.to_s}.include?("foo").should == true
-      end
-
-      after  do
-        defined?(FooBar) and Object.send(:remove_const, :"FooBar")
-      end
-
-      describe "when extending a Class" do
-        it "should respond to any of the #{method.to_s} scope methods and have visibility to the own instance methods" do
-
-          Adhearsion::Plugin.send("add_#{method}_methods".to_sym, A)
-          a = A.new
-          a.should respond_to :foo
-          a.foo.should == "foobar"
-        end
-      end
-
-      describe "when extending an instance" do
-        it "should respond to any of the scope methods and have visibility to the own instance methods" do
-
-          a = A.new
-          Adhearsion::Plugin.send("add_#{method}_methods".to_sym, a)
-          a.should respond_to :foo
-          a.foo.should == "foobar"
-        end
-      end
-    end
-  end
-
-  describe "While adding console methods" do
-
-    it "should add a new method to Console" do
-      FooBar = Class.new Adhearsion::Plugin do
-        console :config do
-          Adhearsion.config
-        end
-      end
-      flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
-      Adhearsion::Plugin.load_plugins
-      Adhearsion::Console.should respond_to(:config)
-      Adhearsion::Console.config.should == Adhearsion.config
-    end
-  end
-
   describe "While configuring plugins" do
     after(:each) do
       defined?(FooBar) and Object.send(:remove_const, :"FooBar")
@@ -181,7 +104,7 @@ describe Adhearsion::Plugin do
     end
   end
 
-  describe "Adhearsion::Plugin.load_plugins" do
+  describe "Adhearsion::Plugin.init_plugins" do
     before do
       Adhearsion::Plugin.class_eval do
         def self.reset_methods_scope
@@ -199,6 +122,7 @@ describe Adhearsion::Plugin do
 
     after do
       Adhearsion::Plugin.initializers.clear
+      Adhearsion::Plugin.runners.clear
       defined?(FooBar) and Object.send(:remove_const, :"FooBar")
       defined?(FooBarBaz) and Object.send(:remove_const, :"FooBarBaz")
       defined?(FooBarBazz) and Object.send(:remove_const, :"FooBarBazz")
@@ -211,7 +135,7 @@ describe Adhearsion::Plugin do
         # 1 => Punchblock. Must be empty once punchblock initializer is an external Plugin
         Adhearsion::Plugin.initializers.should have(1).initializers
         flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
-        Adhearsion::Plugin.load_plugins
+        Adhearsion::Plugin.init_plugins
       end
 
       it "should add a initializer when Plugin defines it" do
@@ -226,10 +150,10 @@ describe Adhearsion::Plugin do
         flexmock(FooBar).should_receive(:log).once
         Adhearsion::Plugin.initializers.length.should be 1
         flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
-        Adhearsion::Plugin.load_plugins
+        Adhearsion::Plugin.init_plugins
       end
 
-      it "should initialize all Plugin childs, including deep childs" do
+      it "should initialize all Plugin children, including deep childs" do
         FooBar = Class.new Adhearsion::Plugin do
           init :foo_bar do
             FooBar.log "foo bar"
@@ -252,7 +176,7 @@ describe Adhearsion::Plugin do
 
         flexmock(FooBar).should_receive(:log).times(3)
         flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
-        Adhearsion::Plugin.load_plugins
+        Adhearsion::Plugin.init_plugins
       end
 
       it "should allow to include an initializer before another one" do
@@ -303,136 +227,102 @@ describe Adhearsion::Plugin do
       end
     end
 
-    [:rpc, :dialplan].each do |method|
-      describe "Plugin subclass with #{method.to_s}_method definition" do
-        it "should add a method defined using #{method.to_s} method" do
-          FooBar = Class.new Adhearsion::Plugin do
-            self.method(method).call(:foo)
-
-            def self.foo(call)
-              "bar"
-            end
-          end
+    describe "while registering plugins runners" do
+      it "should do nothing with a Plugin that has no run method call" do
+        FooBar = Class.new Adhearsion::Plugin
 
-          flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
-          Adhearsion::Plugin.load_plugins
-          Adhearsion::Plugin.methods_scope[method].instance_methods.map{|x| x.to_s}.include?(:foo.to_s).should be true
-        end
+        # May become 1 if Punchblock defines a runner.
+        Adhearsion::Plugin.runners.should have(0).runners
+        flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
+        Adhearsion::Plugin.run_plugins
+      end
 
-        it "should add a method defined using #{method.to_s} method with a block" do
-          FooBar = Class.new Adhearsion::Plugin do
-            block = lambda{|call| "bar"}
-            self.method(method).call(:foo, &block)
+      it "should add a runner when Plugin defines it" do
+        FooBar = Class.new Adhearsion::Plugin do
+          run :foo_bar do
+            FooBar.log "foo bar"
           end
-
-          flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
-          Adhearsion::Plugin.load_plugins
-          Adhearsion::Plugin.methods_scope[method].instance_methods.map{|x| x.to_s}.include?(:foo.to_s).should be true
-        end
-
-        it "should add an instance method defined using #{method.to_s} method" do
-          FooBar = Class.new Adhearsion::Plugin do
-            self.method(method).call(:foo)
-            def foo(call)
-              call
-            end
+          def self.log
           end
-
-          flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
-          Adhearsion::Plugin.load_plugins
-          Adhearsion::Plugin.methods_scope[method].instance_methods.map{|x| x.to_s}.include?(:foo.to_s).should be true
         end
 
-        it "should add an array of methods defined using #{method.to_s} method" do
-          FooBar = Class.new Adhearsion::Plugin do
-            self.method(method).call([:foo, :bar])
-
-            def self.foo(call)
-              call
-            end
+        flexmock(FooBar).should_receive(:log).once
+        Adhearsion::Plugin.runners.length.should be 1
+        flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
+        Adhearsion::Plugin.run_plugins
+      end
 
-            def self.bar(call)
-              "foo"
-            end
+      it "should run all Plugin children, including deep childs" do
+        FooBar = Class.new Adhearsion::Plugin do
+          run :foo_bar do
+            FooBar.log "foo bar"
           end
 
-          flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
-          Adhearsion::Plugin.load_plugins
-          [:foo, :bar].each do |_method|
-            Adhearsion::Plugin.methods_scope[method].instance_methods.map{|x| x.to_s}.include?(_method.to_s).should be true
+          def self.log
           end
-          Adhearsion::Plugin.methods_scope[method].instance_methods.length.should eql 2
         end
 
-        it "should add an array of instance methods defined using #{method.to_s} method" do
-          FooBar = Class.new Adhearsion::Plugin do
-            self.method(method).call([:foo, :bar])
-            def foo(call)
-              call
-            end
-
-            def bar(call)
-              call
-            end
+        FooBarBaz = Class.new FooBar do
+          run :foo_bar_baz do
+            FooBar.log "foo bar baz"
           end
-
-          flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
-          Adhearsion::Plugin.load_plugins
-          [:foo, :bar].each do |_method|
-            Adhearsion::Plugin.methods_scope[method].instance_methods.map{|x| x.to_s}.include?(_method.to_s).should be true
+        end
+        FooBarBazz = Class.new FooBar do
+          run :foo_bar_bazz do
+            FooBar.log "foo bar bazz"
           end
         end
 
-        it "should add an array of instance and singleton methods defined using #{method.to_s} method" do
-          FooBar = Class.new Adhearsion::Plugin do
-            self.method(method).call([:foo, :bar])
-            def self.foo(call)
-              call
-            end
+        flexmock(FooBar).should_receive(:log).times(3)
+        flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
+        Adhearsion::Plugin.run_plugins
+      end
 
-            def bar(call)
-              call
-            end
+      it "should allow to execute one runner before another one" do
+        FooBar = Class.new Adhearsion::Plugin do
+          run :foo_bar do
+            FooBar.log "foo bar"
           end
 
-          flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
-          Adhearsion::Plugin.load_plugins
-          [:foo, :bar].each do |_method|
-            Adhearsion::Plugin.methods_scope[method].instance_methods.map{|x| x.to_s}.include?(_method.to_s).should be true
+          def self.log
           end
         end
 
-        it "should add a method defined using #{method.to_s} method with a specific block" do
-          FooBar = Class.new Adhearsion::Plugin do
-            self.method(method).call(:foo) do
-              "foo"
-            end
+        FooBarBaz = Class.new FooBar do
+          run :foo_bar_baz, :before => :foo_bar do
+            FooBar.log "foo bar baz"
           end
-
-          flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
-          Adhearsion::Plugin.load_plugins
-          Adhearsion::Plugin.methods_scope[method].instance_methods.map{|x| x.to_s}.include?(:foo.to_s).should be true
-          Adhearsion::Plugin.send("#{method.to_s}_module".to_sym).instance_methods.map{|x| x.to_s}.include?(:foo.to_s).should be true
         end
+
+        Adhearsion::Plugin.runners.tsort.first.name.should eql :foo_bar_baz
+        Adhearsion::Plugin.runners.tsort.last.name.should eql :foo_bar
       end
-    end
 
-    describe "Plugin subclass with rpc_method and dialplan_method definitions" do
-      it "should add a method defined using rpc and a method defined using dialplan" do
+      it "should allow to include an runner after another one" do
         FooBar = Class.new Adhearsion::Plugin do
-          rpc :foo
-          dialplan :foo
+          run :foo_bar do
+            FooBar.log "foo bar"
+          end
 
-          def self.foo(call)
-            "bar"
+          def self.log
           end
         end
 
-        flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
-        Adhearsion::Plugin.load_plugins
-        [:dialplan_module, :rpc_module].each do |_module|
-          Adhearsion::Plugin.send(_module).instance_methods.map{|x| x.to_s}.include?(:foo.to_s).should be true
+        FooBarBaz = Class.new FooBar do
+          run :foo_bar_baz, :after => :foo_bar_bazz do
+            FooBar.log "foo bar baz"
+          end
         end
+
+        FooBarBazz = Class.new FooBar do
+          run :foo_bar_bazz do
+            FooBar.log "foo bar bazz"
+          end
+        end
+
+        Adhearsion::Plugin.runners.length.should eql 3
+        Adhearsion::Plugin.runners.tsort.first.name.should eql :foo_bar
+        Adhearsion::Plugin.runners.tsort.last.name.should eql :foo_bar_baz
       end
     end
   end