adhearsion 1.2.6 → 2.0.0.alpha1

data/spec/adhearsion/menu_dsl/range_match_calculator_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+module Adhearsion
+  module MenuDSL
+
+    describe RangeMatchCalculator do
+      it "matching with a Range should handle the case of two potential matches in the range" do
+        digits_that_begin_with_eleven = [110..119, 1100..1111].map { |x| Array(x) }.flatten
+        calculator = RangeMatchCalculator.new 11..1111, :match_payload_doesnt_matter
+        match = calculator.match 11
+        match.exact_matches.should == [11]
+        match.potential_matches.should == digits_that_begin_with_eleven
+      end
+
+      it "return values of #match should be an instance of CalculatedMatch" do
+        calculator = RangeMatchCalculator.new 1..9, :match_payload_doesnt_matter
+        calculator.match(0).should be_an_instance_of CalculatedMatch
+        calculator.match(1000).should be_an_instance_of CalculatedMatch
+      end
+
+      it "returns a failed match if the query is not numeric or coercible to numeric" do
+        calculator = RangeMatchCalculator.new 1..9, :match_payload_doesnt_matter
+        calculator.match("ABC").should be_an_instance_of CalculatedMatch
+      end
+    end
+
+  end
+end

data/spec/adhearsion/menu_dsl/string_match_calculator_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+module Adhearsion
+  module MenuDSL
+    describe StringMatchCalculator do
+
+      let(:match_payload) { :doesnt_matter }
+
+      it "numerical digits mixed with special digits" do
+        %w[5*11#3 5*** ###].each do |str|
+          calculator = StringMatchCalculator.new str, match_payload
+
+          match_case = calculator.match str[0,2]
+          match_case.exact_match?.should_not be true
+          match_case.potential_match?.should be true
+          match_case.potential_matches.should == [str]
+
+          match_case = calculator.match str
+          match_case.exact_match?.should be true
+          match_case.potential_match?.should_not be true
+          match_case.exact_matches.should == [str]
+        end
+      end
+
+      it "matching the special DTMF characters such as * and #" do
+        %w[* #].each do |special_digit|
+          calculator = StringMatchCalculator.new(special_digit, match_payload)
+          match_case = calculator.match special_digit
+          match_case.potential_match?.should_not be true
+          match_case.exact_match?.should be true
+          match_case.exact_matches.first.should == special_digit
+        end
+      end
+    end
+  end
+end

data/spec/adhearsion/menu_dsl_spec.rb

@@ -0,0 +1,12 @@
+require 'spec_helper'
+
+module Adhearsion
+  describe MenuDSL do
+    it "should accept hash options"
+
+    it "should accept hash options and block"
+
+    it "should accept hash options and block and evaluate block"
+  end
+end
+

data/spec/adhearsion/outbound_call_spec.rb

@@ -0,0 +1,174 @@
+require 'spec_helper'
+
+module Adhearsion
+  describe OutboundCall do
+    it { should be_a Call }
+
+    its(:id) { should be_nil }
+    its(:variables) { should == {} }
+
+    let(:mock_client) { flexmock 'Punchblock Client' }
+
+    before do
+      PunchblockPlugin::Initializer.client = mock_client
+    end
+
+    its(:client) { should be mock_client }
+
+    describe ".originate" do
+      let(:to) { 'sip:foo@bar.com' }
+
+      let(:mock_call)     { OutboundCall.new }
+
+      def mock_dial
+        flexmock(OutboundCall).new_instances.should_receive(:dial).and_return true
+      end
+
+      it "should create a new call and return it" do
+        mock_dial
+        OutboundCall.originate(to).should be_a OutboundCall
+      end
+
+      it "should dial the call to the correct endpoint" do
+        mock_call
+        flexmock(OutboundCall).should_receive(:new).and_return mock_call
+        flexmock(mock_call).should_receive(:dial).with(to, :from => 'foo').once
+        OutboundCall.originate to, :from => 'foo'
+      end
+
+      it "should run through the router when the call is answered" do
+        mock_call
+
+        flexmock(OutboundCall).should_receive(:new).and_return mock_call
+        flexmock(mock_call).should_receive(:dial).once
+
+        mock_dispatcher = flexmock 'dispatcher'
+        mock_dispatcher.should_receive(:call).once.with mock_call
+        flexmock(Adhearsion.router).should_receive(:handle).once.with(mock_call).and_return mock_dispatcher
+
+        OutboundCall.originate(to).deliver_message Punchblock::Event::Answered.new
+      end
+    end
+
+    describe "event handlers" do
+      let(:response) { flexmock 'Response' }
+
+      describe "for answered events" do
+        let(:event) { Punchblock::Event::Answered.new }
+
+        it "should trigger any on_answer callbacks set" do
+          response.should_receive(:call).once.with(event)
+          subject.on_answer { |event| response.call event }
+          subject << event
+        end
+      end
+    end
+
+    describe "#dial" do
+      def expect_message_waiting_for_response(message)
+        flexmock(subject).should_receive(:write_and_await_response).once.with(message).and_return do
+          message.call_id = call_id
+          message
+        end
+      end
+
+      let(:call_id) { 'abc123' }
+      let(:to)      { '+1800 555-0199' }
+      let(:from)    { '+1800 555-0122' }
+
+      let(:expected_dial_command) { Punchblock::Command::Dial.new(:to => to, :from => from) }
+
+      before do
+        expect_message_waiting_for_response expected_dial_command
+      end
+
+      it "should send a dial stanza, wait for the response" do
+        subject.dial to, :from => from
+      end
+
+      it "should set the dial command" do
+        subject.dial to, :from => from
+        subject.dial_command.should == expected_dial_command
+      end
+
+      it "should set the call ID from the dial command" do
+        subject.dial to, :from => from
+        subject.id.should == call_id
+      end
+
+      it "should add the call to the active calls registry" do
+        Adhearsion.active_calls.clear!
+        subject.dial to, :from => from
+        Adhearsion.active_calls[call_id].should be subject
+      end
+    end
+
+    describe "basic control commands" do
+      def expect_no_message_waiting_for_response
+        flexmock(subject).should_receive(:write_and_await_response).never
+      end
+
+      describe '#accept' do
+        describe "with no headers" do
+          it 'should not send any message' do
+            expect_no_message_waiting_for_response
+            subject.accept
+          end
+        end
+
+        describe "with headers set" do
+          it 'should not send any message' do
+            expect_no_message_waiting_for_response
+            subject.accept :foo => 'bar'
+          end
+        end
+      end
+
+      describe '#answer' do
+        describe "with no headers" do
+          it 'should not send any message' do
+            expect_no_message_waiting_for_response
+            subject.answer
+          end
+        end
+
+        describe "with headers set" do
+          it 'should not send any message' do
+            expect_no_message_waiting_for_response
+            subject.answer :foo => 'bar'
+          end
+        end
+      end
+
+      describe '#reject' do
+        describe "with a reason given" do
+          it 'should not send any message' do
+            expect_no_message_waiting_for_response
+            subject.reject :decline
+          end
+        end
+
+        describe "with no reason given" do
+          it 'should not send any message' do
+            expect_no_message_waiting_for_response
+            subject.reject
+          end
+        end
+
+        describe "with no headers" do
+          it 'should not send any message' do
+            expect_no_message_waiting_for_response
+            subject.reject
+          end
+        end
+
+        describe "with headers set" do
+          it 'should not send any message' do
+            expect_no_message_waiting_for_response
+            subject.reject nil, :foo => 'bar'
+          end
+        end
+      end
+    end
+  end
+end

data/spec/adhearsion/plugin_spec.rb

@@ -0,0 +1,489 @@
+require 'spec_helper'
+
+include InitializerStubs
+
+describe Adhearsion::Plugin do
+
+  describe "inheritance" do
+    after do
+      defined?(FooBar) and Object.send(:remove_const, :"FooBar")
+    end
+
+    it "should provide the plugin name in a plugin class" do
+      ::FooBar = Class.new Adhearsion::Plugin
+      ::FooBar.plugin_name.should == "foo_bar"
+    end
+
+    it "should provide the plugin name in a plugin instance" do
+      ::FooBar = Class.new Adhearsion::Plugin
+      ::FooBar.new.plugin_name.should == "foo_bar"
+    end
+
+    it "should provide a setter for plugin name" do
+      ::FooBar = Class.new Adhearsion::Plugin do
+        self.plugin_name = "bar_foo"
+      end
+
+      ::FooBar.plugin_name.should == "bar_foo"
+    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")
+    end
+
+    subject {
+      Class.new Adhearsion::Plugin do
+        config :bar_foo do
+          name     "user"     , :desc => "name to authenticate user"
+          password "password" , :desc => "authentication password"
+          host     "localhost", :desc => "valid IP or hostname"
+        end
+      end
+    }
+
+    its(:plugin_name) { should == :bar_foo }
+
+    its(:config) { should be_instance_of Loquacious::Configuration }
+
+    it "should keep a default configuration and a description" do
+      [:name, :password, :host].each do |value|
+        subject.config.should respond_to value
+      end
+
+      subject.config.name.should     == "user"
+      subject.config.password.should == "password"
+      subject.config.host.should     == "localhost"
+    end
+
+    it "should return a description of configuration options" do
+      subject.show_description.should be_kind_of Loquacious::Configuration::Help
+    end
+
+    describe "while updating config values" do
+      it "should return the updated value" do
+        subject.config.name = "usera"
+        subject.config.name.should == "usera"
+      end
+    end
+
+  end
+
+  describe "add and delete on the air" do
+    AhnPluginDemo = Class.new Adhearsion::Plugin
+
+    it "should add plugins on the air" do
+      Adhearsion::Plugin.delete_all
+      Adhearsion::Plugin.add AhnPluginDemo
+      Adhearsion::Plugin.count.should eql 1
+    end
+
+    it "should delete plugins on the air" do
+      Adhearsion::Plugin.delete_all
+      Adhearsion::Plugin.add AhnPluginDemo
+      Adhearsion::Plugin.count.should eql 1
+      Adhearsion::Plugin.delete AhnPluginDemo
+      Adhearsion::Plugin.count.should eql 0
+    end
+  end
+
+  describe "#count" do
+    after(:each) do
+      defined?(FooBar) and Object.send(:remove_const, :"FooBar")
+    end
+
+    it "should count the number of registered plugins" do
+      number = Adhearsion::Plugin.count
+      FooBar = Class.new Adhearsion::Plugin
+      Adhearsion::Plugin.count.should eql(number + 1)
+    end
+  end
+
+  describe "Adhearsion::Plugin.load_plugins" do
+    before do
+      Adhearsion::Plugin.class_eval do
+        def self.reset_methods_scope
+          @methods_scope = Hash.new { |hash, key| hash[key] = Module.new }
+        end
+
+        def self.reset_subclasses
+          @subclasses = nil
+        end
+      end
+
+      Adhearsion::Plugin.reset_methods_scope
+      Adhearsion::Plugin.reset_subclasses
+    end
+
+    after do
+      Adhearsion::Plugin.initializers.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")
+    end
+
+    describe "while registering plugins initializers" do
+      it "should do nothing with a Plugin that has no init method call" do
+        FooBar = Class.new Adhearsion::Plugin
+
+        # 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
+      end
+
+      it "should add a initializer when Plugin defines it" do
+        FooBar = Class.new Adhearsion::Plugin do
+          init :foo_bar do
+            FooBar.log "foo bar"
+          end
+          def self.log
+          end
+        end
+
+        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
+      end
+
+      it "should initialize all Plugin childs, including deep childs" do
+        FooBar = Class.new Adhearsion::Plugin do
+          init :foo_bar do
+            FooBar.log "foo bar"
+          end
+
+          def self.log
+          end
+        end
+
+        FooBarBaz = Class.new FooBar do
+          init :foo_bar_baz do
+            FooBar.log "foo bar baz"
+          end
+        end
+        FooBarBazz = Class.new FooBar do
+          init :foo_bar_bazz do
+            FooBar.log "foo bar bazz"
+          end
+        end
+
+        flexmock(FooBar).should_receive(:log).times(3)
+        flexmock(Adhearsion::PunchblockPlugin::Initializer).should_receive(:start).and_return true
+        Adhearsion::Plugin.load_plugins
+      end
+
+      it "should allow to include an initializer before another one" do
+        FooBar = Class.new Adhearsion::Plugin do
+          init :foo_bar do
+            FooBar.log "foo bar"
+          end
+
+          def self.log
+          end
+        end
+
+        FooBarBaz = Class.new FooBar do
+          init :foo_bar_baz, :before => :foo_bar do
+            FooBar.log "foo bar baz"
+          end
+        end
+
+        Adhearsion::Plugin.initializers.tsort.first.name.should eql :foo_bar_baz
+        Adhearsion::Plugin.initializers.tsort.last.name.should eql :foo_bar
+      end
+
+      it "should allow to include an initializer after another one" do
+        FooBar = Class.new Adhearsion::Plugin do
+          init :foo_bar do
+            FooBar.log "foo bar"
+          end
+
+          def self.log
+          end
+        end
+
+        FooBarBaz = Class.new FooBar do
+          init :foo_bar_baz, :after => :foo_bar_bazz do
+            FooBar.log "foo bar baz"
+          end
+        end
+
+        FooBarBazz = Class.new FooBar do
+          init :foo_bar_bazz do
+            FooBar.log "foo bar bazz"
+          end
+        end
+
+        Adhearsion::Plugin.initializers.length.should eql 3
+        Adhearsion::Plugin.initializers.tsort.first.name.should eql :foo_bar
+        Adhearsion::Plugin.initializers.tsort.last.name.should eql :foo_bar_baz
+      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
+
+          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 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)
+          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
+          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
+
+            def self.bar(call)
+              "foo"
+            end
+          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
+          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
+          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
+        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
+
+            def bar(call)
+              call
+            end
+          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
+        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
+          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
+      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
+        FooBar = Class.new Adhearsion::Plugin do
+          rpc :foo
+          dialplan :foo
+
+          def self.foo(call)
+            "bar"
+          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
+        end
+      end
+    end
+  end
+
+  describe "while loading rake tasks" do
+
+    after do
+      Adhearsion::Plugin.reset_rake_tasks
+      defined?(FooBar) and Object.send(:remove_const, :"FooBar")
+    end
+
+    subject { Adhearsion::Plugin.tasks }
+
+    it "should return an Array" do
+      subject.should be_instance_of Array
+    end
+
+    its(:length) { should == 0 }
+
+    it "should not load a new task when there is no block in the method call" do
+      subject.length.should == 0
+      FooBar = Class.new Adhearsion::Plugin do
+        tasks
+      end
+
+      subject.length.should == 0
+    end
+
+    it "should load a new task when there is a block in the method call" do
+      subject.length.should == 0
+      FooBar = Class.new Adhearsion::Plugin do
+        tasks do
+          puts "foo bar"
+        end
+      end
+      Adhearsion::Plugin.tasks.length.should == 1
+    end
+
+    it "should execute the tasks blocks while loading rake tasks" do
+      subject.length.should == 0
+      FooBar = Class.new Adhearsion::Plugin do
+        tasks do
+          FooBar.foo
+        end
+        def self.foo
+        end
+      end
+      flexmock(FooBar).should_receive(:foo).once
+      Adhearsion::Plugin.load_tasks
+    end
+
+  end
+
+end