punchblock 1.9.4 → 2.0.0.beta1

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

@@ -8,7 +8,7 @@ module Punchblock
       module AMI
         describe Action do
           it 'registers itself' do
-            RayoNode.class_from_registration(:action, 'urn:xmpp:rayo:asterisk:ami:1').should be == Action
+            RayoNode.class_from_registration(:action, 'urn:xmpp:rayo:asterisk:ami:1').should be == described_class
           end
 
           describe "from a stanza" do
@@ -27,31 +27,21 @@ module Punchblock
               MESSAGE
             end
 
-            subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
+            subject { RayoNode.from_xml parse_stanza(stanza).root, '9f00061', '1' }
 
-            it { should be_instance_of Action }
+            it { should be_instance_of described_class }
 
             it_should_behave_like 'event'
 
             its(:name)    { should be == 'Originate' }
-            its(:params)  { should be == [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 be == {:channel   => 'SIP/101test',
-                                           :context   => 'default',
-                                           :exten     => '8135551212',
-                                           :priority  => '1',
-                                           :callerid  => '3125551212',
-                                           :timeout   => '30000',
-                                           :variable  => 'var1=23|var2=24|var3=25',
-                                           :async     => '1'} }
+            its(:params)  { should be == { 'Channel'   => 'SIP/101test',
+                                           'Context'   => 'default',
+                                           'Exten'     => '8135551212',
+                                           'Priority'  => '1',
+                                           'Callerid'  => '3125551212',
+                                           'Timeout'   => '30000',
+                                           'Variable'  => 'var1=23|var2=24|var3=25',
+                                           'Async'     => '1'} }
           end
 
           describe "testing equality" do
@@ -76,22 +66,32 @@ module Punchblock
 
           describe "when setting options in initializer" do
             subject do
-              Action.new :name => 'Originate',
-                         :params => { :channel => 'SIP/101test' }
+              described_class.new :name => 'Originate',
+                                  :params => { 'Channel' => 'SIP/101test' }
             end
 
-            its(:name)        { should be == 'Originate' }
-            its(:params)      { should be == [Action::Param.new(:channel, 'SIP/101test')]}
-            its(:params_hash) { should be == { :channel => 'SIP/101test' } }
-          end
+            its(:name)    { should be == 'Originate' }
+            its(:params)  { should be == { 'Channel' => 'SIP/101test' } }
+
+            describe "exporting to Rayo" do
+              it "should export to XML that can be understood by its parser" do
+                new_instance = RayoNode.from_xml subject.to_rayo
+                new_instance.should be_instance_of described_class
+                new_instance.name.should == 'Originate'
+                new_instance.params.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'
+              it "should render to a parent node if supplied" do
+                doc = Nokogiri::XML::Document.new
+                parent = Nokogiri::XML::Node.new 'foo', doc
+                doc.root = parent
+                rayo_doc = subject.to_rayo(parent)
+                rayo_doc.should == parent
+              end
             end
+          end
 
+          class Action
             class Complete
               describe Success do
                 let :stanza do
@@ -99,6 +99,7 @@ module Punchblock
 <complete xmlns="urn:xmpp:rayo:ext:1">
   <success xmlns="urn:xmpp:rayo:asterisk:ami:complete:1">
     <message>Originate successfully queued</message>
+    <text-body>Some thing happened</text-body>
     <attribute name="Channel" value="SIP/101-3f3f"/>
     <attribute name="State" value="Ring"/>
   </success>
@@ -106,35 +107,31 @@ module Punchblock
                   MESSAGE
                 end
 
-                subject { RayoNode.import(parse_stanza(stanza).root).reason }
+                subject { RayoNode.from_xml(parse_stanza(stanza).root).reason }
 
-                it { should be_instance_of Success }
+                it { should be_instance_of described_class }
 
-                its(:name)            { should be == :success }
-                its(:message)         { should be == "Originate successfully queued" }
-                its(:attributes)      { should be == [Attribute.new('Channel', 'SIP/101-3f3f'), Attribute.new('State', 'Ring')]}
-                its(:attributes_hash) { should be == {:channel => 'SIP/101-3f3f', :state => 'Ring'} }
+                its(:name)    { should be == :success }
+                its(:message) { should be == "Originate successfully queued" }
+                its(:text_body) { should be == 'Some thing happened' }
+                its(:headers) { should be == {'Channel' => 'SIP/101-3f3f', 'State' => 'Ring'} }
+                its(:attributes) { should be == {'Channel' => 'SIP/101-3f3f', 'State' => 'Ring'} } # For BC
 
                 describe "when setting options in initializer" do
                   subject do
-                    Success.new :message => 'Originate successfully queued', :attributes => {:channel => 'SIP/101-3f3f', :state => 'Ring'}
+                    described_class.new message: 'Originate successfully queued', text_body: 'Some thing happened', headers: {'Channel' => 'SIP/101-3f3f', 'State' => 'Ring'}
                   end
 
-                  its(:message)         { should be == 'Originate successfully queued' }
-                  its(:attributes)      { should be == [Attribute.new(:channel, 'SIP/101-3f3f'), Attribute.new(:state, 'Ring')]}
-                  its(:attributes_hash) { should be == {:channel => 'SIP/101-3f3f', :state => 'Ring'} }
+                  its(:message) { should be == 'Originate successfully queued' }
+                  its(:text_body) { should be == 'Some thing happened' }
+                  its(:headers) { should be == {'Channel' => 'SIP/101-3f3f', 'State' => 'Ring'} }
+                  its(:attributes) { should be == {'Channel' => 'SIP/101-3f3f', 'State' => 'Ring'} } # For BC
                 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
+        end
+      end
+    end
+  end
+end

data/spec/punchblock/component/component_node_spec.rb

@@ -52,7 +52,7 @@ module Punchblock
         end
 
         describe "with an event handler set" do
-          let(:handler) { mock 'Response' }
+          let(:handler) { double 'Response' }
 
           before do
             handler.should_receive(:call).once.with(event)
@@ -74,9 +74,7 @@ module Punchblock
         let(:component_id) { 'abc123' }
 
         let :ref do
-          Ref.new.tap do |ref|
-            ref.id = component_id
-          end
+          Ref.new uri: component_id
         end
 
         it "should set the component ID from the ref" do
@@ -90,7 +88,7 @@ module Punchblock
         before do
           subject.request!
           subject.client = Client.new
-          subject.response = Ref.new id: 'abc'
+          subject.response = Ref.new uri: 'abc'
           subject.client.find_component_by_id('abc').should be subject
         end
 

data/spec/punchblock/component/input_spec.rb

@@ -6,41 +6,101 @@ module Punchblock
   module Component
     describe Input do
       it 'registers itself' do
-        RayoNode.class_from_registration(:input, 'urn:xmpp:rayo:input:1').should be == Input
+        RayoNode.class_from_registration(:input, 'urn:xmpp:rayo:input:1').should be == described_class
       end
 
       describe "when setting options in initializer" do
         subject do
-          Input.new :grammar              => {:value => '[5 DIGITS]', :content_type => 'application/grammar+custom'},
-                    :mode                 => :speech,
+          described_class.new grammar: {value: '[5 DIGITS]', content_type: 'application/grammar+custom'},
+                    :mode                 => :voice,
                     :terminator           => '#',
                     :max_silence          => 1000,
-                    :recognizer           => 'en-US',
+                    :recognizer           => 'default',
+                    :language             => 'en-US',
                     :initial_timeout      => 2000,
                     :inter_digit_timeout  => 2000,
                     :sensitivity          => 0.5,
                     :min_confidence       => 0.5
         end
 
-        its(:grammar)             { should be == Input::Grammar.new(:value => '[5 DIGITS]', :content_type => 'application/grammar+custom') }
-        its(:mode)                { should be == :speech }
+        its(:grammars)            { should be == [Input::Grammar.new(:value => '[5 DIGITS]', :content_type => 'application/grammar+custom')] }
+        its(:mode)                { should be == :voice }
         its(:terminator)          { should be == '#' }
         its(:max_silence)         { should be == 1000 }
-        its(:recognizer)          { should be == 'en-US' }
+        its(:recognizer)          { should be == 'default' }
+        its(:language)            { should be == 'en-US' }
         its(:initial_timeout)     { should be == 2000 }
         its(:inter_digit_timeout) { should be == 2000 }
         its(:sensitivity)         { should be == 0.5 }
         its(:min_confidence)      { should be == 0.5 }
+
+        context "with multiple grammars" do
+          subject do
+            Input.new :grammars => [
+              {:value => '[5 DIGITS]', :content_type => 'application/grammar+custom'},
+              {:value => '[10 DIGITS]', :content_type => 'application/grammar+custom'}
+            ]
+          end
+
+          its(:grammars) { should be == [
+            Input::Grammar.new(:value => '[5 DIGITS]', :content_type => 'application/grammar+custom'),
+            Input::Grammar.new(:value => '[10 DIGITS]', :content_type => 'application/grammar+custom')
+          ]}
+        end
+
+        context "with a nil grammar" do
+          it "removes all grammars" do
+            subject.grammar = nil
+            subject.grammars.should == []
+          end
+        end
+
+        context "without any grammars" do
+          subject { described_class.new }
+
+          its(:grammars) { should == [] }
+        end
+
+        describe "exporting to Rayo" do
+          it "should export to XML that can be understood by its parser" do
+            new_instance = RayoNode.from_xml subject.to_rayo
+            new_instance.should be_instance_of described_class
+            new_instance.grammars.should be == [Input::Grammar.new(value: '[5 DIGITS]', content_type: 'application/grammar+custom')]
+            new_instance.mode.should be == :voice
+            new_instance.terminator.should be == '#'
+            new_instance.max_silence.should be == 1000
+            new_instance.recognizer.should be == 'default'
+            new_instance.language.should be == 'en-US'
+            new_instance.initial_timeout.should be == 2000
+            new_instance.inter_digit_timeout.should be == 2000
+            new_instance.sensitivity.should be == 0.5
+            new_instance.min_confidence.should be == 0.5
+          end
+
+          it "should wrap the grammar value in CDATA" do
+            grammar_node = subject.to_rayo.at_xpath('ns:grammar', ns: described_class.registered_ns)
+            grammar_node.children.first.should be_a Nokogiri::XML::CDATA
+          end
+
+          it "should render to a parent node if supplied" do
+            doc = Nokogiri::XML::Document.new
+            parent = Nokogiri::XML::Node.new 'foo', doc
+            doc.root = parent
+            rayo_doc = subject.to_rayo(parent)
+            rayo_doc.should == parent
+          end
+        end
       end
 
       describe "from a stanza" do
         let :stanza do
           <<-MESSAGE
 <input xmlns="urn:xmpp:rayo:input:1"
-       mode="speech"
+       mode="voice"
        terminator="#"
        max-silence="1000"
-       recognizer="en-US"
+       recognizer="default"
+       language="en-US"
        initial-timeout="2000"
        inter-digit-timeout="2000"
        sensitivity="0.5"
@@ -48,23 +108,32 @@ module Punchblock
   <grammar content-type="application/grammar+custom">
     <![CDATA[ [5 DIGITS] ]]>
   </grammar>
+  <grammar content-type="application/grammar+custom">
+    <![CDATA[ [10 DIGITS] ]]>
+  </grammar>
 </input>
           MESSAGE
         end
 
-        subject { RayoNode.import parse_stanza(stanza).root, '9f00061', '1' }
+        subject { RayoNode.from_xml parse_stanza(stanza).root, '9f00061', '1' }
 
         it { should be_instance_of Input }
 
-        its(:grammar)             { should be == Input::Grammar.new(:value => '[5 DIGITS]', :content_type => 'application/grammar+custom') }
-        its(:mode)                { should be == :speech }
+        its(:grammars)            { should be == [Input::Grammar.new(:value => '[5 DIGITS]', :content_type => 'application/grammar+custom'), Input::Grammar.new(:value => '[10 DIGITS]', :content_type => 'application/grammar+custom')] }
+        its(:mode)                { should be == :voice }
         its(:terminator)          { should be == '#' }
         its(:max_silence)         { should be == 1000 }
-        its(:recognizer)          { should be == 'en-US' }
+        its(:recognizer)          { should be == 'default' }
+        its(:language)            { should be == 'en-US' }
         its(:initial_timeout)     { should be == 2000 }
         its(:inter_digit_timeout) { should be == 2000 }
         its(:sensitivity)         { should be == 0.5 }
         its(:min_confidence)      { should be == 0.5 }
+
+        context "without any grammars" do
+          let(:stanza) { '<input xmlns="urn:xmpp:rayo:input:1"/>' }
+          its(:grammars) { should be == [] }
+        end
       end
 
       def grxml_doc(mode = :dtmf)
@@ -83,37 +152,19 @@ module Punchblock
           its(:content_type) { should be == 'application/srgs+xml' }
         end
 
-        describe 'with a simple grammar' do
-          subject { Input::Grammar.new :value => '[5 DIGITS]', :content_type => 'application/grammar+custom' }
-
-          let(:expected_message) { "<![CDATA[ [5 DIGITS] ]]>" }
-
-          it "should wrap grammar in CDATA" do
-            subject.child.to_xml.should be == expected_message.strip
-          end
-        end
-
         describe 'with a GRXML grammar' do
           subject { Input::Grammar.new :value => grxml_doc, :content_type => 'application/srgs+xml' }
 
           its(:content_type) { should be == 'application/srgs+xml' }
 
-          let(:expected_message) { "<![CDATA[ #{grxml_doc} ]]>" }
-
-          it "should wrap GRXML in CDATA" do
-            subject.child.to_xml.should be == expected_message.strip
-          end
-
           its(:value) { should be == grxml_doc }
 
           describe "comparison" do
-            let(:grammar2) { Input::Grammar.new :value => '<grammar xmlns="http://www.w3.org/2001/06/grammar" version="1.0" xml:lang="en-US" mode="dtmf" root="digits"><rule id="digits"><one-of><item>0</item><item>1</item></one-of></rule></grammar>' }
-            let(:grammar3) { Input::Grammar.new :value => grxml_doc }
-            let(:grammar4) { Input::Grammar.new :value => grxml_doc(:speech) }
+            let(:grammar2) { Input::Grammar.new :value => grxml_doc }
+            let(:grammar3) { Input::Grammar.new :value => grxml_doc(:voice) }
 
             it { should be == grammar2 }
-            it { should be == grammar3 }
-            it { should_not be == grammar4 }
+            it { should_not be == grammar3 }
           end
         end
 
@@ -138,8 +189,8 @@ module Punchblock
       end
 
       describe "actions" do
-        let(:mock_client) { mock 'Client' }
-        let(:command) { Input.new :grammar => '[5 DIGITS]' }
+        let(:mock_client) { double 'Client' }
+        let(:command) { described_class.new grammar: {value: '[5 DIGITS]', content_type: 'application/grammar+custom'} }
 
         before do
           command.component_id = 'abc123'
@@ -176,41 +227,123 @@ module Punchblock
         end
       end
 
-      describe Input::Complete::Success do
+      describe Input::Complete::Match do
+        let :nlsml_string do
+          '''
+<result xmlns="http://www.ietf.org/xml/ns/mrcpv2" grammar="http://flight">
+  <interpretation confidence="0.60">
+    <input mode="voice">I want to go to Pittsburgh</input>
+    <instance>
+      <airline>
+        <to_city>Pittsburgh</to_city>
+      </airline>
+    </instance>
+  </interpretation>
+  <interpretation confidence="0.40">
+    <input>I want to go to Stockholm</input>
+    <instance>
+      <airline>
+        <to_city>Stockholm</to_city>
+      </airline>
+    </instance>
+  </interpretation>
+</result>
+          '''
+        end
+
         let :stanza do
           <<-MESSAGE
 <complete xmlns='urn:xmpp:rayo:ext:1'>
-<success mode="speech" confidence="0.45" xmlns='urn:xmpp:rayo:input:complete:1'>
-  <interpretation>1234</interpretation>
-  <utterance>one two three four</utterance>
-</success>
+  <match xmlns="urn:xmpp:rayo:input:complete:1" content-type="application/nlsml+xml">
+    <![CDATA[#{nlsml_string}]]>
+  </match>
 </complete>
           MESSAGE
         end
 
-        subject { RayoNode.import(parse_stanza(stanza).root).reason }
+        let :expected_nlsml do
+          RubySpeech.parse nlsml_string
+        end
+
+        subject { RayoNode.from_xml(parse_stanza(stanza).root).reason }
 
-        it { should be_instance_of Input::Complete::Success }
+        it { should be_instance_of Input::Complete::Match }
 
-        its(:name)            { should be == :success }
-        its(:mode)            { should be == :speech }
-        its(:confidence)      { should be == 0.45 }
-        its(:interpretation)  { should be == '1234' }
-        its(:utterance)       { should be == 'one two three four' }
+        its(:name)            { should be == :match }
+        its(:content_type)    { should be == 'application/nlsml+xml' }
+        its(:nlsml)           { should be == expected_nlsml }
+        its(:mode)            { should be == :voice }
+        its(:confidence)      { should be == 0.6 }
+        its(:interpretation)  { should be == { airline: { to_city: 'Pittsburgh' } } }
+        its(:utterance)       { should be == 'I want to go to Pittsburgh' }
 
-        describe "when setting options in initializer" do
+        describe "when creating from an NLSML document" do
           subject do
-            Input::Complete::Success.new :mode            => :dtmf,
-                                         :confidence      => 1,
-                                         :utterance       => '123',
-                                         :interpretation  => 'dtmf-1 dtmf-2 dtmf-3'
+            Input::Complete::Match.new :nlsml => expected_nlsml
           end
 
+          its(:content_type)    { should be == 'application/nlsml+xml' }
+          its(:nlsml)           { should be == expected_nlsml }
+          its(:mode)            { should be == :voice }
+          its(:confidence)      { should be == 0.6 }
+          its(:interpretation)  { should be == { airline: { to_city: 'Pittsburgh' } } }
+          its(:utterance)       { should be == 'I want to go to Pittsburgh' }
+        end
 
-          its(:mode)            { should be == :dtmf }
-          its(:confidence)      { should be == 1 }
-          its(:utterance)       { should be == '123' }
-          its(:interpretation)  { should be == 'dtmf-1 dtmf-2 dtmf-3' }
+        context "when not enclosed in CDATA, but escaped" do
+          let :stanza do
+            <<-MESSAGE
+<complete xmlns='urn:xmpp:rayo:ext:1'>
+  <match xmlns="urn:xmpp:rayo:input:complete:1" content-type="application/nlsml+xml">
+    &lt;result xmlns=&quot;http://www.ietf.org/xml/ns/mrcpv2&quot; grammar=&quot;http://flight&quot;/&gt;
+  </match>
+</complete>
+            MESSAGE
+          end
+
+          it "should parse the NLSML correctly" do
+            subject.nlsml.grammar.should == "http://flight"
+          end
+        end
+
+        context "when nested directly" do
+          let :stanza do
+            <<-MESSAGE
+<complete xmlns='urn:xmpp:rayo:ext:1'>
+  <match xmlns="urn:xmpp:rayo:input:complete:1" content-type="application/nlsml+xml">
+    #{nlsml_string}
+  </match>
+</complete>
+            MESSAGE
+          end
+
+          it "should parse the NLSML correctly" do
+            subject.nlsml.grammar.should == "http://flight"
+          end
+        end
+
+        describe "comparison" do
+          context "with the same nlsml" do
+            it "should be equal" do
+              subject.should == RayoNode.from_xml(parse_stanza(stanza).root).reason
+            end
+          end
+
+          context "with different nlsml" do
+            let :other_stanza do
+              <<-MESSAGE
+<complete xmlns='urn:xmpp:rayo:ext:1'>
+  <match xmlns="urn:xmpp:rayo:input:complete:1">
+    <![CDATA[<result xmlns="http://www.ietf.org/xml/ns/mrcpv2" grammar="http://flight"/>]]>
+  </match>
+</complete>
+              MESSAGE
+            end
+
+            it "should not be equal" do
+              subject.should_not == RayoNode.from_xml(parse_stanza(other_stanza).root).reason
+            end
+          end
         end
       end
 
@@ -218,12 +351,12 @@ module Punchblock
         let :stanza do
           <<-MESSAGE
 <complete xmlns='urn:xmpp:rayo:ext:1'>
-<nomatch xmlns='urn:xmpp:rayo:input:complete:1' />
+  <nomatch xmlns='urn:xmpp:rayo:input:complete:1' />
 </complete>
           MESSAGE
         end
 
-        subject { RayoNode.import(parse_stanza(stanza).root).reason }
+        subject { RayoNode.from_xml(parse_stanza(stanza).root).reason }
 
         it { should be_instance_of Input::Complete::NoMatch }
 
@@ -234,12 +367,12 @@ module Punchblock
         let :stanza do
           <<-MESSAGE
 <complete xmlns='urn:xmpp:rayo:ext:1'>
-<noinput xmlns='urn:xmpp:rayo:input:complete:1' />
+  <noinput xmlns='urn:xmpp:rayo:input:complete:1' />
 </complete>
           MESSAGE
         end
 
-        subject { RayoNode.import(parse_stanza(stanza).root).reason }
+        subject { RayoNode.from_xml(parse_stanza(stanza).root).reason }
 
         it { should be_instance_of Input::Complete::NoInput }