adhearsion 2.0.0.alpha1 → 2.0.0.alpha2

data/lib/adhearsion/tasks/configuration.rb

@@ -1,26 +1,9 @@
-require 'adhearsion/punchblock_plugin'
-
-begin
-  Adhearsion.config # load default config vlaues
-  require "#{Dir.pwd}/config/adhearsion.rb"
-rescue Exception => ex
-  STDERR.puts "\nError while loading application configuration file: #{ex}"
-end
-
-namespace :adhearsion do
-
-  namespace :config do
-
-    desc "Show configuration values in STDOUT; it accepts a parameter: [nil|platform|<plugin-name>|all]"
-    task :show, :name do |t, args|
-      name = args.name.nil? ? :all : args.name.to_sym
-      puts Adhearsion.config.description name, :show_values => true
-    end
-
-    desc "Show configuration description in STDOUT; it accepts a parameter: [nil|platform|<plugin-name>|all]"
-    task :desc, :name do |t, args|
-      name = args.name.nil? ? :all : args.name.to_sym
-      puts Adhearsion.config.description name, :show_values => false
-    end
+namespace :config do
+  desc "Show configuration values; accepts a parameter: [nil|platform|<plugin-name>|all]"
+  task :show, :name, :needs => :environment do |t, args|
+    name = args.name.nil? ? :all : args.name.to_sym
+    puts "\nAdhearsion.config do |config|\n\n"
+    puts Adhearsion.config.description name, :show_values => true
+    puts "end"
   end
 end

data/lib/adhearsion/tasks/environment.rb

@@ -0,0 +1,12 @@
+task :environment do
+  require 'adhearsion/punchblock_plugin'
+
+  begin
+    Adhearsion.config # load default config vlaues
+    initializer = Adhearsion::Initializer.new
+    initializer.load_lib_folder
+    initializer.load_config
+  rescue Exception => ex
+    STDERR.puts "\nError while loading application configuration file: #{ex}"
+  end
+end

data/lib/adhearsion/tasks/plugins.rb

@@ -1,17 +1,12 @@
-require 'adhearsion/punchblock_plugin'
-
-namespace :adhearsion do
-
-  desc "List the configured plugins"
-  task :plugins do |t,args|
-    if Adhearsion::Plugin.subclasses.length > 0
-      puts "You have #{Adhearsion::Plugin.subclasses.length} plugin(s) in your Adhearsion application:\n"
-      Adhearsion::Plugin.subclasses.each do |plugin|
-        puts "* #{plugin.plugin_name}: #{plugin.name}"
-      end
-    else
-      puts "There is no Adhearsion plugin used in your application"
+desc "List the configured plugins"
+task :plugins => :environment do |t,args|
+  if Adhearsion::Plugin.subclasses.length > 0
+    puts "You have #{Adhearsion::Plugin.subclasses.length} plugin(s) in your Adhearsion application:\n"
+    Adhearsion::Plugin.subclasses.each do |plugin|
+      puts "* #{plugin.plugin_name}: #{plugin.name}"
     end
-    puts "\n"
+  else
+    puts "There is no Adhearsion plugin used in your application"
   end
+  puts "\n"
 end

data/lib/adhearsion/version.rb

@@ -1,5 +1,5 @@
 module Adhearsion #:nodoc:
-  VERSION = '2.0.0.alpha1'
+  VERSION = '2.0.0.alpha2'
 
   class PkgVersion
     include Comparable

data/spec/adhearsion/call_controller/dial_spec.rb

@@ -6,17 +6,17 @@ module Adhearsion
       include CallControllerTestHelpers
 
       let(:to) { 'sip:foo@bar.com' }
-
-      let(:other_call_id) { rand }
+      let(:other_call_id)   { rand }
       let(:other_mock_call) { flexmock OutboundCall.new, :id => other_call_id }
 
-      let(:mock_end) { flexmock Punchblock::Event::End.new, :reason => :hangup }
+      let(:second_to)               { 'sip:baz@bar.com' }
+      let(:second_other_call_id)    { rand }
+      let(:second_other_mock_call)  { flexmock OutboundCall.new, :id => second_other_call_id }
+
+      let(:mock_end)      { flexmock Punchblock::Event::End.new, :reason => :hangup }
       let(:mock_answered) { Punchblock::Event::Answered.new }
 
-      #added for multiple dial testing
-      let(:second_to) { 'sip:baz@bar.com' }
-      let(:second_other_call_id) { rand }
-      let(:second_other_mock_call) { flexmock OutboundCall.new, :id => second_other_call_id }
+      let(:latch) { CountDownLatch.new 1 }
 
       def mock_dial
         flexmock(OutboundCall).new_instances.should_receive(:dial).and_return true
@@ -25,10 +25,11 @@ module Adhearsion
       describe "#dial" do
         it "should create a new call and return it" do
           mock_dial
-          Thread.new do
-            subject.dial(to).should be_a OutboundCall
+          t = Thread.new do
+            subject.dial(to, {}, latch).should be_a OutboundCall
           end
-          other_mock_call << mock_end
+          latch.countdown!
+          t.join
         end
 
         it "should dial the call to the correct endpoint" do
@@ -44,7 +45,7 @@ module Adhearsion
         end
 
         describe "without a block" do
-          it "blocks the original dialplan until the new call ends" do
+          it "blocks the original controller until the new call ends" do
             other_mock_call
 
             flexmock(other_mock_call).should_receive(:dial).once
@@ -68,7 +69,7 @@ module Adhearsion
             other_mock_call
 
             flexmock(other_mock_call).should_receive(:dial).once
-            flexmock(other_mock_call).should_receive(:join).once.with(call_id)
+            flexmock(other_mock_call).should_receive(:join).once.with(call)
             flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
 
             latch = CountDownLatch.new 1
@@ -93,19 +94,19 @@ module Adhearsion
             second_other_mock_call
 
             flexmock(other_mock_call).should_receive(:dial).once
-            flexmock(other_mock_call).should_receive(:join).once.with(call_id)
+            flexmock(other_mock_call).should_receive(:join).once.with(call)
             flexmock(other_mock_call).should_receive(:hangup!).never
 
             flexmock(second_other_mock_call).should_receive(:dial).once
             flexmock(second_other_mock_call).should_receive(:hangup!).once
 
-
             flexmock(OutboundCall).should_receive(:new).and_return other_mock_call, second_other_mock_call
             latch = CountDownLatch.new 1
 
-            Thread.new do
-              subject.dial [to, second_to]
+            t = Thread.new do
+              calls = subject.dial [to, second_to]
               latch.countdown!
+              calls
             end
 
             latch.wait(1).should be_false
@@ -113,20 +114,43 @@ module Adhearsion
             other_mock_call << mock_answered
             other_mock_call << mock_end
 
-            latch.wait(1).should be_true
+            latch.wait(2).should be_true
+
+            t.join
+            calls = t.value
+            calls.should have(2).calls
+            calls.each { |c| c.should be_a OutboundCall }
           end
         end
 
         describe "with a timeout specified" do
-          it "should abort the dial after the specified timeout"
-        end
+          let(:timeout) { 3 }
 
-        describe "with a from specified" do
-          it "originates the call from the specified caller ID"
+          it "should abort the dial after the specified timeout" do
+            other_mock_call
+
+            flexmock(other_mock_call).should_receive(:dial).once
+            flexmock(OutboundCall).should_receive(:new).and_return other_mock_call
+
+            latch = CountDownLatch.new 1
+
+            value = nil
+            time = Time.now
+
+            Thread.new do
+              value = subject.dial to, :timeout => timeout
+              latch.countdown!
+            end
+
+            latch.wait
+            time = Time.now - time
+            time.to_i.should == timeout
+            value.should == false
+          end
         end
 
       	describe "with a block" do
-          it "uses the block as the dialplan for the new call"
+          it "uses the block as the controller for the new call"
 
           it "joins the new call to the existing call once the block returns"
 

data/spec/adhearsion/call_controller_spec.rb

@@ -1,5 +1,8 @@
 require 'spec_helper'
 
+class FinancialWizard < Adhearsion::CallController
+end
+
 module Adhearsion
   describe CallController do
     include CallControllerTestHelpers
@@ -20,10 +23,6 @@ module Adhearsion
       end
     end
 
-    it "should add plugin dialplan methods" do
-      subject.should respond_to :foo
-    end
-
     its(:logger)    { should be call.logger }
     its(:variables) { should be call.variables }
 
@@ -78,6 +77,20 @@ module Adhearsion
         flexmock(Events).should_receive(:trigger).once.with(:exception, StandardError).ordered
         subject.execute!
       end
+
+      context "when a block is specified" do
+        let :block do
+          Proc.new { foo value }
+        end
+
+        its(:block) { should be block }
+
+        it "should execute the block in the context of the controller" do
+          flexmock subject, :value => :bar
+          subject.should_receive(:foo).once.with(:bar)
+          subject.run
+        end
+      end
     end
 
     class SecondController < CallController
@@ -285,45 +298,52 @@ module Adhearsion
 
     describe '#accept' do
       it "should delegate to the call" do
-        flexmock(subject.call).should_receive(:accept).once.with(:foo)
+        flexmock(call).should_receive(:accept).once.with(:foo)
         subject.accept :foo
       end
     end
 
     describe '#answer' do
       it "should delegate to the call" do
-        flexmock(subject.call).should_receive(:answer).once.with(:foo)
+        flexmock(call).should_receive(:answer).once.with(:foo)
         subject.answer :foo
       end
     end
 
     describe '#reject' do
       it "should delegate to the call" do
-        flexmock(subject.call).should_receive(:reject).once.with(:foo, :bar)
+        flexmock(call).should_receive(:reject).once.with(:foo, :bar)
         subject.reject :foo, :bar
       end
     end
 
     describe '#hangup' do
       it "should delegate to the call" do
-        flexmock(subject.call).should_receive(:hangup!).once.with(:foo)
+        flexmock(call).should_receive(:hangup!).once.with(:foo)
         subject.hangup :foo
       end
     end
 
     describe '#mute' do
-      it 'should send a Mute message' do
-        expect_message_waiting_for_response Punchblock::Command::Mute.new
+      it 'should delegate to the call' do
+        flexmock(call).should_receive(:mute).once
         subject.mute
       end
     end
 
     describe '#unmute' do
-      it 'should send an Unmute message' do
-        expect_message_waiting_for_response Punchblock::Command::Unmute.new
+      it 'should delegate to the call' do
+        flexmock(call).should_receive(:unmute).once
         subject.unmute
       end
     end
+
+    describe '#join' do
+      it 'should delegate to the call' do
+        flexmock(call).should_receive(:join).once.with(:foo)
+        subject.join :foo
+      end
+    end
   end
 end
 
@@ -383,7 +403,7 @@ describe ExampleCallController do
     subject.execute!
   end
 
-  context "when the controller finishes without a hangup" do
+  describe "when the controller finishes without a hangup" do
     it "should execute the after_call callbacks" do
       subject[:skip_hangup] = true
       subject.should_receive(:join_to_conference).once.ordered
@@ -392,4 +412,19 @@ describe ExampleCallController do
       subject.execute!
     end
   end
+
+  describe "providing hooks to include call functionality" do
+    let(:call) { Adhearsion::Call.new mock_offer(nil, :x_foo => 'bar') }
+
+    it "should allow mixing in a module globally on all CallController classes" do
+      Adhearsion::CallController.mixin TestBiscuit
+      Adhearsion::CallController.new(call).should respond_to :throwadogabone
+    end
+
+    it "should allow mixing in a module on a single CallController class" do
+      FinancialWizard.mixin MarmaladeIsBetterThanJam
+      FinancialWizard.new(call).should respond_to :sobittersweet
+      Adhearsion::CallController.new(call).should_not respond_to :sobittersweet
+    end
+  end
 end

data/spec/adhearsion/call_spec.rb

@@ -2,10 +2,25 @@ require 'spec_helper'
 
 module Adhearsion
   describe Call do
+    let(:mock_client) { flexmock('Client').tap &:should_ignore_missing }
+
+    let(:call_id) { rand }
     let(:headers) { nil }
-    let(:offer)   { mock_offer nil, headers }
+    let(:to)      { 'sip:you@there.com' }
+    let(:from)    { 'sip:me@here.com' }
+    let :offer do
+      Punchblock::Event::Offer.new :call_id => call_id,
+                                   :to      => to,
+                                   :from    => from,
+                                   :headers => headers
+    end
+
     subject { Adhearsion::Call.new offer }
 
+    before do
+      flexmock(offer).should_receive(:client).and_return(mock_client)
+    end
+
     after do
       Adhearsion.active_calls.clear!
     end
@@ -18,10 +33,43 @@ module Adhearsion
     its(:commands) { should be_a Call::CommandRegistry }
     its(:commands) { should be_empty }
 
+    its(:id)      { should == call_id }
+    its(:to)      { should == to }
+    its(:from)    { should == from }
+    its(:offer)   { should be offer }
+    its(:client)  { should be mock_client }
+
     describe "its variables" do
       context "with an offer with headers" do
         let(:headers)   { {:x_foo => 'bar'} }
         its(:variables) { should == headers }
+
+        it "should be made available via []" do
+          subject[:x_foo].should == 'bar'
+        end
+
+        it "should be alterable using []=" do
+          subject[:x_foo] = 'baz'
+          subject[:x_foo].should == 'baz'
+        end
+
+        context "when receiving an event with headers" do
+          let(:event) { Punchblock::Event::End.new :headers => {:x_bar => 'foo'} }
+
+          it "should merge later headers" do
+            subject << event
+            subject.variables.should == {:x_foo => 'bar', :x_bar => 'foo'}
+          end
+        end
+
+        context "when sending a command with headers" do
+          let(:command) { Punchblock::Command::Accept.new :headers => {:x_bar => 'foo'} }
+
+          it "should merge later headers" do
+            subject.write_command command
+            subject.variables.should == {:x_foo => 'bar', :x_bar => 'foo'}
+          end
+        end
       end
 
       context "with an offer without headers" do
@@ -35,33 +83,16 @@ module Adhearsion
       end
     end
 
-    it '#id should return the ID from the Offer' do
-      offer = mock_offer
-      Adhearsion::Call.new(offer).id.should == offer.call_id
-    end
-
-    it 'should store the original offer' do
-      offer = mock_offer
-      Adhearsion::Call.new(offer).offer.should == offer
-    end
-
     describe 'without an offer' do
       it 'should not raise an exception' do
         lambda { Adhearsion::Call.new }.should_not raise_error
       end
     end
 
-    it "should store the Punchblock client from the Offer" do
-      offer = mock_offer
-      client = flexmock('Client')
-      offer.should_receive(:client).once.and_return(client)
-      Adhearsion::Call.new(offer).client.should == client
-    end
-
     it 'a hungup call removes itself from the active calls' do
       size_before = Adhearsion.active_calls.size
 
-      call = Adhearsion.active_calls.from_offer mock_offer
+      call = Adhearsion.active_calls.from_offer offer
       Adhearsion.active_calls.size.should > size_before
       call.hangup
       Adhearsion.active_calls.size.should == size_before
@@ -350,11 +381,101 @@ module Adhearsion
       end
 
       describe "#join" do
-        let(:other_call_id) { rand }
+        def expect_join_with_options(options = {})
+          Punchblock::Command::Join.new(options).tap do |join|
+            expect_message_waiting_for_response join
+          end
+        end
+
+        context "with a call" do
+          let(:call_id) { rand.to_s }
+          let(:target)  { flexmock Call.new, :id => call_id }
+
+          it "should send a join command joining to the provided call ID" do
+            expect_join_with_options :other_call_id => call_id
+            subject.join target
+          end
+
+          context "and direction/media options" do
+            it "should send a join command with the correct options" do
+              expect_join_with_options :other_call_id => call_id, :media => :bridge, :direction => :recv
+              subject.join target, :media => :bridge, :direction => :recv
+            end
+          end
+        end
+
+        context "with a call ID" do
+          let(:target) { rand.to_s }
+
+          it "should send a join command joining to the provided call ID" do
+            expect_join_with_options :other_call_id => target
+            subject.join target
+          end
+
+          context "and direction/media options" do
+            it "should send a join command with the correct options" do
+              expect_join_with_options :other_call_id => target, :media => :bridge, :direction => :recv
+              subject.join target, :media => :bridge, :direction => :recv
+            end
+          end
+        end
+
+        context "with a call ID as a hash key" do
+          let(:call_id) { rand.to_s }
+          let(:target)  { { :call_id => call_id } }
+
+          it "should send a join command joining to the provided call ID" do
+            expect_join_with_options :other_call_id => call_id
+            subject.join target
+          end
+
+          context "and direction/media options" do
+            it "should send a join command with the correct options" do
+              expect_join_with_options :other_call_id => call_id, :media => :bridge, :direction => :recv
+              subject.join target.merge({:media => :bridge, :direction => :recv})
+            end
+          end
+        end
+
+        context "with a mixer name as a hash key" do
+          let(:mixer_name)  { rand.to_s }
+          let(:target)      { { :mixer_name => mixer_name } }
+
+          it "should send a join command joining to the provided call ID" do
+            expect_join_with_options :mixer_name => mixer_name
+            subject.join target
+          end
+
+          context "and direction/media options" do
+            it "should send a join command with the correct options" do
+              expect_join_with_options :mixer_name => mixer_name, :media => :bridge, :direction => :recv
+              subject.join target.merge({:media => :bridge, :direction => :recv})
+            end
+          end
+        end
+
+        context "with a call ID and a mixer name as hash keys" do
+          let(:call_id)     { rand.to_s }
+          let(:mixer_name)  { rand.to_s }
+          let(:target)      { { :call_id => call_id, :mixer_name => mixer_name } }
+
+          it "should raise an ArgumentError" do
+            lambda { subject.join target }.should raise_error ArgumentError, /call ID and mixer name/
+          end
+        end
+      end
+
+      describe "#mute" do
+        it 'should send a Mute message' do
+          expect_message_waiting_for_response Punchblock::Command::Mute.new
+          subject.mute
+        end
+      end
 
-        it "should mark the call inactive" do
-          expect_message_waiting_for_response Punchblock::Command::Join.new :other_call_id => other_call_id
-          subject.join other_call_id
+      describe "#unmute" do
+        it 'should send a Mute message' do
+          expect_message_waiting_for_response Punchblock::Command::Unmute.new
+          subject.unmute
         end
       end