punchblock 0.5.1 → 0.6.0

data/spec/punchblock/command/unmute_spec.rb

@@ -6,6 +6,14 @@ module Punchblock
       it 'registers itself' do
         RayoNode.class_from_registration(:unmute, 'urn:xmpp:rayo:1').should == Unmute
       end
+
+      describe "from a stanza" do
+        let(:stanza) { '<unmute xmlns="urn:xmpp:rayo:1"/>' }
+
+        subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
+
+        it { should be_instance_of Unmute }
+      end
     end
   end
 end # Punchblock

data/spec/punchblock/component/asterisk/agi/command_spec.rb

@@ -0,0 +1,102 @@
+require 'spec_helper'
+
+module Punchblock
+  module Component
+    module Asterisk
+      module AGI
+        describe Command do
+          it 'registers itself' do
+            RayoNode.class_from_registration(:command, 'urn:xmpp:rayo:asterisk:agi:1').should == Command
+          end
+
+          describe "from a stanza" do
+            let :stanza do
+              <<-MESSAGE
+<command xmlns="urn:xmpp:rayo:asterisk:agi:1" name="GET VARIABLE">
+  <param value="UNIQUEID"/>
+</command>
+              MESSAGE
+            end
+
+            subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
+
+            it { should be_instance_of Command }
+
+            it_should_behave_like 'event'
+
+            its(:name)          { should == 'GET VARIABLE' }
+            its(:params)        { should == [Command::Param.new('UNIQUEID')] }
+            its(:params_array)  { should == ['UNIQUEID'] }
+          end
+
+          describe "when setting options in initializer" do
+            subject do
+              Command.new :name => 'GET VARIABLE',
+                          :params => ['UNIQUEID']
+            end
+
+            its(:name)          { should == 'GET VARIABLE' }
+            its(:params)        { should == [Command::Param.new('UNIQUEID')] }
+            its(:params_array)  { should == ['UNIQUEID'] }
+          end
+
+          class Command
+            describe Param do
+              it 'will auto-inherit nodes' do
+                n = parse_stanza "<param value='bah' />"
+                h = Param.new n.root
+                h.value.should == 'bah'
+              end
+
+              it 'has a value attribute' do
+                n = Param.new 'en'
+                n.value.should == 'en'
+                n.value = 'de'
+                n.value.should == 'de'
+              end
+
+              it 'can determine equality' do
+                a = Param.new 'bah'
+                a.should == Param.new('bah')
+                a.should_not == Param.new('boo')
+              end
+            end
+
+            describe Complete::Success do
+              let :stanza do
+                <<-MESSAGE
+<complete xmlns="urn:xmpp:rayo:ext:1">
+  <success xmlns="urn:xmpp:rayo:asterisk:agi:complete:1">
+    <code>200</code>
+    <result>0</result>
+    <data>1187188485.0</data>
+  </success>
+</complete>
+                MESSAGE
+              end
+
+              subject { RayoNode.import(parse_stanza(stanza).root).reason }
+
+              it { should be_instance_of Complete::Success }
+
+              its(:name)    { should == :success }
+              its(:code)    { should == 200 }
+              its(:result)  { should == 0 }
+              its(:data)    { should == '1187188485.0' }
+
+              describe "when setting options in initializer" do
+                subject do
+                  Complete::Success.new :code => 200, :result => 0, :data => '1187188485.0'
+                end
+
+                its(:code)    { should == 200 }
+                its(:result)  { should == 0 }
+                its(:data)    { should == '1187188485.0' }
+              end
+            end
+          end
+        end # Command
+      end # AGI
+    end # Asterisk
+  end # Component
+end # Punchblock

data/spec/punchblock/component/asterisk/ami/action_spec.rb

@@ -0,0 +1,118 @@
+require 'spec_helper'
+
+module Punchblock
+  module Component
+    module Asterisk
+      module AMI
+        describe Action do
+          it 'registers itself' do
+            RayoNode.class_from_registration(:action, 'urn:xmpp:rayo:asterisk:ami:1').should == Action
+          end
+
+          describe "from a stanza" do
+            let :stanza do
+              <<-MESSAGE
+<action xmlns="urn:xmpp:rayo:asterisk:ami:1" name="Originate">
+  <param name="Channel" value="SIP/101test"/>
+  <param name="Context" value="default"/>
+  <param name="Exten" value="8135551212"/>
+  <param name="Priority" value="1"/>
+  <param name="Callerid" value="3125551212"/>
+  <param name="Timeout" value="30000"/>
+  <param name="Variable" value="var1=23|var2=24|var3=25"/>
+  <param name="Async" value="1"/>
+</action>
+              MESSAGE
+            end
+
+            subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
+
+            it { should be_instance_of Action }
+
+            it_should_behave_like 'event'
+
+            its(:name)    { should == 'Originate' }
+            its(:params)  { should == [Action::Param.new(:channel, 'SIP/101test'),
+                                      Action::Param.new(:context, 'default'),
+                                      Action::Param.new(:exten, '8135551212'),
+                                      Action::Param.new(:priority, '1'),
+                                      Action::Param.new(:callerid, '3125551212'),
+                                      Action::Param.new(:timeout, '30000'),
+                                      Action::Param.new(:variable, 'var1=23|var2=24|var3=25'),
+                                      Action::Param.new(:async, '1')
+                                     ]}
+
+            its(:params_hash) { should == {:channel   => 'SIP/101test',
+                                           :context   => 'default',
+                                           :exten     => '8135551212',
+                                           :priority  => '1',
+                                           :callerid  => '3125551212',
+                                           :timeout   => '30000',
+                                           :variable  => 'var1=23|var2=24|var3=25',
+                                           :async     => '1'} }
+          end
+
+          describe "when setting options in initializer" do
+            subject do
+              Action.new :name => 'Originate',
+                         :params => { :channel => 'SIP/101test' }
+            end
+
+            its(:name)        { should == 'Originate' }
+            its(:params)      { should == [Action::Param.new(:channel, 'SIP/101test')]}
+            its(:params_hash) { should == { :channel => 'SIP/101test' } }
+          end
+
+          class Action
+            describe Param do
+              let(:class_name)    { Param }
+              let(:element_name)  { 'param' }
+              it_should_behave_like 'key_value_pairs'
+            end
+
+            class Complete
+              describe Success do
+                let :stanza do
+                  <<-MESSAGE
+<complete xmlns="urn:xmpp:rayo:ext:1">
+  <success xmlns="urn:xmpp:rayo:asterisk:ami:complete:1">
+    <message>Originate successfully queued</message>
+    <attribute name="Channel" value="SIP/101-3f3f"/>
+    <attribute name="State" value="Ring"/>
+  </success>
+</complete>
+                  MESSAGE
+                end
+
+                subject { RayoNode.import(parse_stanza(stanza).root).reason }
+
+                it { should be_instance_of Success }
+
+                its(:name)            { should == :success }
+                its(:message)         { should == "Originate successfully queued" }
+                its(:attributes)      { should == [Attribute.new(:channel, 'SIP/101-3f3f'), Attribute.new(:state, 'Ring')]}
+                its(:attributes_hash) { should == {:channel => 'SIP/101-3f3f', :state => 'Ring'} }
+
+                describe "when setting options in initializer" do
+                  subject do
+                    Success.new :message => 'Originate successfully queued', :attributes => {:channel => 'SIP/101-3f3f', :state => 'Ring'}
+                  end
+
+                  its(:message)         { should == 'Originate successfully queued' }
+                  its(:attributes)      { should == [Attribute.new(:channel, 'SIP/101-3f3f'), Attribute.new(:state, 'Ring')]}
+                  its(:attributes_hash) { should == {:channel => 'SIP/101-3f3f', :state => 'Ring'} }
+                end
+              end
+
+              describe Attribute do
+                let(:class_name)    { Attribute }
+                let(:element_name)  { 'attribute' }
+                it_should_behave_like 'key_value_pairs'
+              end
+            end
+          end
+        end # Action
+      end # AMI
+    end # Asterisk
+  end # Component
+end # Punchblock

data/spec/punchblock/component/input_spec.rb

@@ -37,6 +37,46 @@ module Punchblock
         its(:min_confidence)      { should == 0.5 }
       end
 
+      describe "from a stanza" do
+        let :stanza do
+          <<-MESSAGE
+<input xmlns="urn:xmpp:rayo:input:1"
+       mode="speech"
+       terminator="#"
+       max-digits="10"
+       recognizer="en-US"
+       initial-timeout="2000"
+       inter-digit-timeout="2000"
+       term-timeout="2000"
+       complete-timeout="2000"
+       incomplete-timeout="2000"
+       sensitivity="0.5"
+       min-confidence="0.5">
+  <grammar content-type="application/grammar+custom">
+    <![CDATA[ [5 DIGITS] ]]>
+  </grammar>
+</input>
+          MESSAGE
+        end
+
+        subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
+
+        it { should be_instance_of Input }
+
+        its(:grammar)             { should == Input::Grammar.new(:value => '[5 DIGITS]', :content_type => 'application/grammar+custom') }
+        its(:mode)                { should == :speech }
+        its(:terminator)          { should == '#' }
+        its(:max_digits)          { should == 10 }
+        its(:recognizer)          { should == 'en-US' }
+        its(:initial_timeout)     { should == 2000 }
+        its(:inter_digit_timeout) { should == 2000 }
+        its(:term_timeout)        { should == 2000 }
+        its(:complete_timeout)    { should == 2000 }
+        its(:incomplete_timeout)  { should == 2000 }
+        its(:sensitivity)         { should == 0.5 }
+        its(:min_confidence)      { should == 0.5 }
+      end
+
       describe Input::Grammar do
         describe "when not passing a grammar" do
           subject { Input::Grammar.new :value => '[5 DIGITS]' }

data/spec/punchblock/component/output_spec.rb

@@ -27,6 +27,34 @@ module Punchblock
         its(:voice)            { should == 'allison' }
       end
 
+      describe "from a stanza" do
+        let :stanza do
+          <<-MESSAGE
+<output xmlns='urn:xmpp:rayo:output:1'
+        interrupt-on='speech'
+        start-offset='2000'
+        start-paused='false'
+        repeat-interval='2000'
+        repeat-times='10'
+        max-time='30000'
+        voice='allison'>Hello world</output>
+          MESSAGE
+        end
+
+        subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
+
+        it { should be_instance_of Output }
+
+        its(:interrupt_on)     { should == :speech }
+        its(:start_offset)     { should == 2000 }
+        its(:start_paused)     { should == false }
+        its(:repeat_interval)  { should == 2000 }
+        its(:repeat_times)     { should == 10 }
+        its(:max_time)         { should == 30000 }
+        its(:voice)            { should == 'allison' }
+        its(:text)             { should == 'Hello world' }
+      end
+
       describe "for text" do
         subject { Output.new :text => 'Once upon a time there was a message...', :voice => 'kate' }
 

data/spec/punchblock/component/record_spec.rb

@@ -27,6 +27,33 @@ module Punchblock
         its(:final_timeout)   { should == 30000 }
       end
 
+      describe "from a stanza" do
+        let :stanza do
+          <<-MESSAGE
+<record xmlns="urn:xmpp:rayo:record:1"
+        format="WAV"
+        start-beep="true"
+        start-paused="false"
+        stop-beep="true"
+        max-duration="500000"
+        initial-timeout="10000"
+        final-timeout="30000"/>
+          MESSAGE
+        end
+
+        subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
+
+        it { should be_instance_of Record }
+
+        its(:format)          { should == 'WAV' }
+        its(:start_beep)      { should == true }
+        its(:start_paused)    { should == false }
+        its(:stop_beep)       { should == true }
+        its(:max_duration)    { should == 500000 }
+        its(:initial_timeout) { should == 10000 }
+        its(:final_timeout)   { should == 30000 }
+      end
+
       describe "actions" do
         let(:mock_client) { mock 'Client' }
         let(:command) { Record.new }

data/spec/punchblock/connection/asterisk_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+module Punchblock
+  module Connection
+    describe Asterisk do
+      let :options do
+        {
+          :host     => '127.0.0.1',
+          :port     => 5038,
+          :username => 'test',
+          :password => 'test'
+        }
+      end
+
+      let(:mock_event_handler) { stub_everything 'Event Handler' }
+
+      subject { Asterisk.new options }
+
+      before do
+        subject.event_handler = mock_event_handler
+      end
+
+      its(:ami_client) { should be_a RubyAMI::Client }
+
+      it 'should set the connection on the translator' do
+        subject.translator.connection.should be subject
+      end
+
+      describe '#run' do
+        it 'starts the RubyAMI::Client' do
+          subject.ami_client.expects(:start).once
+          subject.run
+        end
+      end
+
+      describe '#stop' do
+        it 'stops the RubyAMI::Client' do
+          subject.ami_client.expects(:stop).once
+          subject.stop
+        end
+      end
+
+      it 'sends events from RubyAMI to the translator' do
+        event = mock 'RubyAMI::Event'
+        subject.translator.expects(:handle_ami_event!).once.with event
+        subject.ami_client.handle_event event
+      end
+
+      describe '#write' do
+        it 'sends a command to the translator' do
+          command = mock 'Command'
+          options = {:foo => :bar}
+          subject.translator.expects(:execute_command!).once.with command, options
+          subject.write command, options
+        end
+      end
+
+      describe 'when a rayo event is received from the translator' do
+        it 'should call the event handler with the event' do
+          offer = Event::Offer.new
+          offer.call_id = '9f00061'
+
+          mock_event_handler.expects(:call).once.with offer
+          subject.handle_event offer
+        end
+      end
+    end
+  end
+end

data/spec/punchblock/event/asterisk/ami/event_spec.rb

@@ -0,0 +1,60 @@
+require 'spec_helper'
+
+module Punchblock
+  class Event
+    module Asterisk
+      module AMI
+        describe Event do
+          it 'registers itself' do
+            RayoNode.class_from_registration(:event, 'urn:xmpp:rayo:asterisk:ami:1').should == Event
+          end
+
+          describe "from a stanza" do
+            let :stanza do
+              <<-MESSAGE
+<event xmlns="urn:xmpp:rayo:asterisk:ami:1" name="Newchannel">
+  <attribute name="Channel" value="SIP/101-3f3f"/>
+  <attribute name="State" value="Ring"/>
+  <attribute name="Callerid" value="101"/>
+  <attribute name="Uniqueid" value="1094154427.10"/>
+</event>
+              MESSAGE
+            end
+
+            subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
+
+            it { should be_instance_of Event }
+
+            it_should_behave_like 'event'
+
+            its(:name)            { should == 'Newchannel' }
+            its(:attributes)      { should == [Event::Attribute.new(:channel, 'SIP/101-3f3f'), Event::Attribute.new(:state, 'Ring'), Event::Attribute.new(:callerid, '101'), Event::Attribute.new(:uniqueid, '1094154427.10')]}
+            its(:attributes_hash) { should == {:channel => 'SIP/101-3f3f', :state => 'Ring', :callerid => '101', :uniqueid => '1094154427.10'} }
+          end
+
+          describe "when setting options in initializer" do
+            subject do
+              Event.new :name => 'Newchannel',
+                        :attributes => {:channel  => 'SIP/101-3f3f',
+                                        :state    => 'Ring',
+                                        :callerid => '101',
+                                        :uniqueid => '1094154427.10'}
+            end
+
+            its(:name)            { should == 'Newchannel' }
+            its(:attributes)      { should == [Event::Attribute.new(:channel, 'SIP/101-3f3f'), Event::Attribute.new(:state, 'Ring'), Event::Attribute.new(:callerid, '101'), Event::Attribute.new(:uniqueid, '1094154427.10')]}
+            its(:attributes_hash) { should == {:channel => 'SIP/101-3f3f', :state => 'Ring', :callerid => '101', :uniqueid => '1094154427.10'} }
+          end
+
+          class Event
+            describe Attribute do
+              let(:class_name)    { Attribute }
+              let(:element_name)  { 'attribute' }
+              it_should_behave_like 'key_value_pairs'
+            end
+          end
+        end
+      end
+    end
+  end
+end # Punchblock