adhearsion 2.6.4 → 3.0.0.beta1

data/spec/adhearsion/call_controller/menu_dsl/range_match_calculator_spec.rb

@@ -1,32 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Adhearsion
-  class CallController
-    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'
-          expect(match.exact_matches).to eq(['11'])
-          expect(match.potential_matches).to eq(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
-          expect(calculator.match('0')).to be_an_instance_of CalculatedMatch
-          expect(calculator.match('1000')).to 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
-          expect(calculator.match("ABC")).to be_an_instance_of CalculatedMatch
-        end
-      end
-
-    end
-  end
-end

data/spec/adhearsion/call_controller/menu_dsl/string_match_calculator_spec.rb

@@ -1,40 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Adhearsion
-  class CallController
-    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]
-            expect(match_case).not_to be_exact_match
-            expect(match_case).to be_potential_match
-            expect(match_case.potential_matches).to eq([str])
-
-            match_case = calculator.match str
-            expect(match_case).to be_exact_match
-            expect(match_case).not_to be_potential_match
-            expect(match_case.exact_matches).to eq([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
-            expect(match_case.exact_matches.first).to eq(special_digit)
-            expect(match_case).to be_exact_match
-            expect(match_case).not_to be_potential_match
-          end
-        end
-      end
-    end
-  end
-end

data/spec/adhearsion/call_controller/utility_spec.rb

@@ -1,90 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-require 'ruby_speech'
-
-module Adhearsion
-  class CallController
-    describe Utility do
-      include CallControllerTestHelpers
-
-      describe "#grammar_digits" do
-        let(:grxml) {
-          RubySpeech::GRXML.draw :mode => 'dtmf', :root => 'inputdigits' do
-            rule id: 'inputdigits', scope: 'public' do
-              item repeat: '2' do
-                one_of do
-                  0.upto(9) { |d| item { d.to_s } }
-                end
-              end
-            end
-          end
-        }
-
-        it 'generates the correct GRXML grammar' do
-          expect(subject.grammar_digits(2).to_s).to eq(grxml.to_s)
-        end
-
-      end # describe #grammar_digits
-
-      describe "#grammar_accept" do
-        let(:grxml) {
-          RubySpeech::GRXML.draw :mode => 'dtmf', :root => 'inputdigits' do
-            rule id: 'inputdigits', scope: 'public' do
-              one_of do
-                item { '3' }
-                item { '5' }
-              end
-            end
-          end
-        }
-
-        it 'generates the correct GRXML grammar' do
-          expect(subject.grammar_accept('35').to_s).to eq(grxml.to_s)
-        end
-
-        it 'filters meaningless characters out' do
-          expect(subject.grammar_accept('3+5').to_s).to eq(grxml.to_s)
-        end
-      end # grammar_accept
-
-      describe "#parse_dtmf" do
-        context "with a single digit" do
-          it "correctly returns the parsed input" do
-            expect(subject.parse_dtmf("dtmf-3")).to eq('3')
-          end
-
-          it "correctly returns star as *" do
-            expect(subject.parse_dtmf("dtmf-star")).to eq('*')
-          end
-
-          it "correctly returns * as *" do
-            expect(subject.parse_dtmf("*")).to eq('*')
-          end
-
-          it "correctly returns pound as #" do
-            expect(subject.parse_dtmf("dtmf-pound")).to eq('#')
-          end
-
-          it "correctly returns # as #" do
-            expect(subject.parse_dtmf("#")).to eq('#')
-          end
-
-          it "correctly parses digits without the dtmf- prefix" do
-            expect(subject.parse_dtmf('1')).to eq('1')
-          end
-
-          it "correctly returns nil when input is nil" do
-            expect(subject.parse_dtmf(nil)).to eq(nil)
-          end
-        end
-
-        context "with multiple digits separated by spaces" do
-          it "returns the digits without space separation" do
-            expect(subject.parse_dtmf('1 dtmf-5 dtmf-star # 2')).to eq('15*#2')
-          end
-        end
-      end # describe #grammar_accept
-    end
-  end
-end

data/spec/adhearsion/punchblock_plugin/initializer_spec.rb

@@ -1,356 +0,0 @@
-# encoding: utf-8
-
-require 'spec_helper'
-
-module Adhearsion
-  class PunchblockPlugin
-    describe Initializer do
-
-      def reset_default_config
-        Adhearsion.config.punchblock do |config|
-          config.platform           = :xmpp
-          config.username           = "usera@127.0.0.1"
-          config.password           = "1"
-          config.host               = nil
-          config.port               = nil
-          config.certs_directory    = nil
-          config.root_domain        = nil
-          config.connection_timeout = 60
-          config.reconnect_attempts = 1.0/0.0
-          config.reconnect_timer    = 5
-        end
-      end
-
-      def initialize_punchblock(options = {})
-        reset_default_config
-        allow(Initializer).to receive(:connect)
-        Adhearsion.config.punchblock do |config|
-          config.platform           = options[:platform] if options.has_key?(:platform)
-          config.username           = options[:username] if options.has_key?(:username)
-          config.password           = options[:password] if options.has_key?(:password)
-          config.host               = options[:host] if options.has_key?(:host)
-          config.port               = options[:port] if options.has_key?(:port)
-          config.certs_directory    = options[:certs_directory] if options.has_key?(:certs_directory)
-          config.root_domain        = options[:root_domain] if options.has_key?(:root_domain)
-          config.connection_timeout = options[:connection_timeout] if options.has_key?(:connection_timeout)
-          config.reconnect_attempts = options[:reconnect_attempts] if options.has_key?(:reconnect_attempts)
-          config.reconnect_timer    = options[:reconnect_timer] if options.has_key?(:reconnect_timer)
-        end
-
-        Initializer.init
-        Adhearsion.config[:punchblock]
-      end
-
-      let(:call_id)     { rand }
-      let(:offer)       { Punchblock::Event::Offer.new :target_call_id => call_id }
-      let(:mock_call)   { Call.new }
-      let(:mock_client) { double 'Client' }
-
-      before do
-        allow(mock_call).to receive_messages :id => call_id
-        mock_client.as_null_object
-        allow(mock_client).to receive_messages :event_handler= => true
-        Events.refresh!
-        allow(Adhearsion::Process).to receive_messages :fqdn => 'hostname'
-        allow(::Process).to receive_messages :pid => 1234
-      end
-
-      describe "starts the client with the default values" do
-        subject { initialize_punchblock }
-
-        it "should set properly the username value" do
-          expect(subject.username).to eq('usera@127.0.0.1')
-        end
-
-        it "should set properly the password value" do
-          expect(subject.password).to eq('1')
-        end
-
-        it "should set properly the host value" do
-          expect(subject.host).to be_nil
-        end
-
-        it "should set properly the port value" do
-          expect(subject.port).to be_nil
-        end
-
-        it "should set properly the certs_directory value" do
-          expect(subject.certs_directory).to be_nil
-        end
-
-        it "should set properly the root_domain value" do
-          expect(subject.root_domain).to be_nil
-        end
-
-        it "should properly set the reconnect_attempts value" do
-          expect(subject.reconnect_attempts).to eq(1.0/0.0)
-        end
-
-        it "should properly set the reconnect_timer value" do
-          expect(subject.reconnect_timer).to eq(5)
-        end
-      end
-
-      it "starts the client with the correct resource" do
-        username = "usera@127.0.0.1/hostname-1234"
-
-        expect(Punchblock::Connection::XMPP).to receive(:new).once.with(hash_including :username => username).and_return mock_client
-        initialize_punchblock
-      end
-
-      context "when the fqdn is not available" do
-        it "should use the local hostname instead" do
-          allow(Adhearsion::Process).to receive(:fqdn).and_raise SocketError
-          allow(Socket).to receive(:gethostname).and_return 'local_hostname'
-
-          username = "usera@127.0.0.1/local_hostname-1234"
-
-          expect(Punchblock::Connection::XMPP).to receive(:new).once.with(hash_including :username => username).and_return mock_client
-          initialize_punchblock
-        end
-      end
-
-      it "starts the client with any overridden settings" do
-        expect(Punchblock::Connection::XMPP).to receive(:new).once.with(username: 'userb@127.0.0.1/foo', password: '123', host: 'foo.bar.com', port: 200, certs: '/foo/bar', connection_timeout: 20, root_domain: 'foo.com').and_return mock_client
-        initialize_punchblock username: 'userb@127.0.0.1/foo', password: '123', host: 'foo.bar.com', port: 200, certs_directory: '/foo/bar', connection_timeout: 20, root_domain: 'foo.com'
-      end
-
-      describe "#connect" do
-        it 'should block until the connection is established' do
-          reset_default_config
-          mock_connection = double :mock_connection
-          expect(mock_connection).to receive(:register_event_handler).once
-          expect(Punchblock::Client).to receive(:new).once.and_return mock_connection
-          expect(mock_connection).to receive(:run).once
-          t = Thread.new { Initializer.init; Initializer.run }
-          t.join 5
-          expect(t.status).to eq("sleep")
-          Events.trigger_immediately :punchblock, Punchblock::Connection::Connected.new
-          t.join
-        end
-      end
-
-      describe '#connect_to_server' do
-        before :each do
-          Adhearsion::Process.reset
-          Initializer.config = reset_default_config
-          Initializer.config.reconnect_attempts = 1
-          expect(Adhearsion::Logging.get_logger(Initializer)).to receive(:fatal).at_most(:once)
-          allow(Initializer).to receive(:client).and_return mock_client
-        end
-
-        after :each do
-          Adhearsion::Process.reset
-        end
-
-        it 'should reset the Adhearsion process state to "booting"' do
-          Adhearsion::Process.booted
-          expect(Adhearsion::Process.state_name).to eq(:running)
-          allow(mock_client).to receive(:run).and_raise Punchblock::DisconnectedError
-          expect(Adhearsion::Process).to receive(:reset).at_least(:once)
-          Initializer.connect_to_server
-        end
-
-        it 'should retry the connection the specified number of times' do
-          Initializer.config.reconnect_attempts = 3
-          allow(mock_client).to receive(:run).and_raise Punchblock::DisconnectedError
-          Initializer.connect_to_server
-          expect(Initializer.attempts).to eq(3)
-        end
-
-        it 'should preserve a Punchblock::ProtocolError exception and give up' do
-          allow(mock_client).to receive(:run).and_raise Punchblock::ProtocolError
-          expect { Initializer.connect_to_server }.to raise_error Punchblock::ProtocolError
-        end
-
-        it 'should not attempt to reconnect if Adhearsion is shutting down' do
-          Adhearsion::Process.booted
-          Adhearsion::Process.shutdown
-          allow(mock_client).to receive(:run).and_raise Punchblock::DisconnectedError
-          expect { Initializer.connect_to_server }.not_to raise_error
-        end
-      end
-
-      describe 'using Asterisk' do
-        let(:overrides) { {:username => 'test', :password => '123', :host => 'foo.bar.com', :port => 200, :certs => nil, :connection_timeout => 20, :root_domain => 'foo.com'} }
-
-        it 'should start an Asterisk PB connection' do
-          expect(Punchblock::Connection::Asterisk).to receive(:new).once.with(overrides).and_return mock_client
-          initialize_punchblock overrides.merge(:platform => :asterisk)
-        end
-      end
-
-      describe 'using FreeSWITCH' do
-        let(:overrides) { {:username => 'test', :password => '123', :host => 'foo.bar.com', :port => 200, :certs => nil, :connection_timeout => 20, :root_domain => 'foo.com'} }
-
-        it 'should start a FreeSWITCH PB connection' do
-          expect(Punchblock::Connection::Freeswitch).to receive(:new).once.with(overrides).and_return mock_client
-          initialize_punchblock overrides.merge(:platform => :freeswitch)
-        end
-      end
-
-      it 'should place events from Punchblock into the event handler' do
-        expect(Events.instance).to receive(:trigger).once.with(:punchblock, offer)
-        initialize_punchblock
-        Initializer.client.handle_event offer
-      end
-
-      describe "dispatching an offer" do
-        before do
-          initialize_punchblock
-          expect(Adhearsion::Process).to receive(:state_name).once.and_return process_state
-          expect(Adhearsion::Call).to receive(:new).once.and_return mock_call
-        end
-
-        context "when the Adhearsion::Process is :booting" do
-          let(:process_state) { :booting }
-
-          it 'should reject a call with cause :declined' do
-            expect(mock_call).to receive(:reject).once.with(:decline)
-          end
-        end
-
-        [ :running, :stopping ].each do |state|
-          context "when when Adhearsion::Process is in :#{state}" do
-            let(:process_state) { state }
-
-            it "should dispatch via the router" do
-              Adhearsion.router do
-                route 'foobar', Class.new
-              end
-              expect(Adhearsion.router).to receive(:handle).once.with mock_call
-            end
-          end
-        end
-
-        context "when when Adhearsion::Process is in :rejecting" do
-          let(:process_state) { :rejecting }
-
-          it 'should reject a call with cause :declined' do
-            expect(mock_call).to receive(:reject).once.with(:decline)
-          end
-        end
-
-        context "when when Adhearsion::Process is not :running, :stopping or :rejecting" do
-          let(:process_state) { :foobar }
-
-          it 'should reject a call with cause :error' do
-            expect(mock_call).to receive(:reject).once.with(:error)
-          end
-        end
-
-        after { Events.trigger_immediately :punchblock, offer }
-      end
-
-      describe "dispatching a component event" do
-        let(:component)   { double 'ComponentNode' }
-        let(:mock_event)  { double 'Event' }
-
-        before { allow(mock_event).to receive_messages target_call_id: call_id, source: component }
-
-        before do
-          initialize_punchblock
-        end
-
-        it "should place the event in the call's inbox" do
-          expect(component).to receive(:trigger_event_handler).once.with mock_event
-          Events.trigger_immediately :punchblock, mock_event
-        end
-      end
-
-      describe "dispatching a call event" do
-        let(:mock_event)  { double 'Event' }
-
-        before { allow(mock_event).to receive_messages target_call_id: call_id }
-
-        describe "with an active call" do
-          before do
-            initialize_punchblock
-            Adhearsion.active_calls << mock_call
-          end
-
-          it "should forward the event to the call actor" do
-            events = []
-            mock_call.register_event_handler do |event|
-              events << event
-            end
-            Initializer.dispatch_call_event mock_event
-            sleep 0.5
-            expect(events).to eql([mock_event])
-          end
-
-          it "should not block on the call handling the event" do
-
-            mock_call.register_event_handler do |event|
-              sleep 5
-            end
-            start_time = Time.now
-            Initializer.dispatch_call_event mock_event
-            sleep 0.5
-            expect(Time.now - start_time).to be < 1
-          end
-        end
-
-        describe "with an inactive call" do
-          it "should log a warning" do
-            expect(Adhearsion::Logging.get_logger(Initializer)).to receive(:warn).once.with("Event received for inactive call #{call_id}: #{mock_event.inspect}")
-            Initializer.dispatch_call_event mock_event
-          end
-        end
-
-        describe "when the registry contains a dead call" do
-          before do
-            mock_call.terminate
-            Adhearsion.active_calls[mock_call.id] = mock_call
-          end
-
-          it "should log a warning" do
-            expect(Adhearsion::Logging.get_logger(Initializer)).to receive(:warn).once.with("Event received for inactive call #{call_id}: #{mock_event.inspect}")
-            Initializer.dispatch_call_event mock_event
-          end
-        end
-      end
-
-      context "Punchblock configuration" do
-        describe "with config specified" do
-          before do
-            Adhearsion.config.punchblock do |config|
-              config.username = 'userb@127.0.0.1'
-              config.password = 'abc123'
-            end
-          end
-
-          subject do
-            Adhearsion.config[:punchblock]
-          end
-
-          it "should set properly the username value" do
-            expect(subject.username).to eq('userb@127.0.0.1')
-          end
-
-          it "should set properly the password value" do
-            expect(subject.password).to eq('abc123')
-          end
-        end
-      end
-
-      it "should allow easily registering handlers for AMI events" do
-        result = nil
-        ami_event = Punchblock::Event::Asterisk::AMI::Event.new :name => 'foobar'
-        latch = CountDownLatch.new 1
-
-        Events.draw do
-          ami :name => 'foobar' do |event|
-            result = event
-            latch.countdown!
-          end
-        end
-
-        Initializer.handle_event ami_event
-
-        expect(latch.wait(1)).to be true
-        expect(result).to be ami_event
-      end
-    end
-  end
-end