punchblock 1.9.4 → 2.0.0.beta1

data/spec/punchblock/component/record_spec.rb

@@ -6,27 +6,55 @@ module Punchblock
   module Component
     describe Record do
       it 'registers itself' do
-        RayoNode.class_from_registration(:record, 'urn:xmpp:rayo:record:1').should be == Record
+        RayoNode.class_from_registration(:record, 'urn:xmpp:rayo:record:1').should be == described_class
       end
 
       describe "when setting options in initializer" do
         subject do
           Record.new :format          => 'WAV',
                      :start_beep      => true,
+                     :stop_beep       => true,
                      :start_paused    => false,
                      :max_duration    => 500000,
                      :initial_timeout => 10000,
                      :final_timeout   => 30000,
-                     :direction       => :duplex
+                     :direction       => :duplex,
+                     :mix             => true
         end
 
         its(:format)          { should be == 'WAV' }
         its(:start_beep)      { should be == true }
+        its(:stop_beep)       { should be == true }
         its(:start_paused)    { should be == false }
         its(:max_duration)    { should be == 500000 }
         its(:initial_timeout) { should be == 10000 }
         its(:final_timeout)   { should be == 30000 }
         its(:direction)       { should be == :duplex }
+        its(:mix)             { should be == true }
+
+        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.format.should be == 'WAV'
+            new_instance.start_beep.should be == true
+            new_instance.stop_beep.should be == true
+            new_instance.start_paused.should be == false
+            new_instance.max_duration.should be == 500000
+            new_instance.initial_timeout.should be == 10000
+            new_instance.final_timeout.should be == 30000
+            new_instance.direction.should be == :duplex
+            new_instance.mix.should be == true
+          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
@@ -35,31 +63,35 @@ module Punchblock
 <record xmlns="urn:xmpp:rayo:record:1"
         format="WAV"
         start-beep="true"
+        stop-beep="true"
         start-paused="false"
         max-duration="500000"
         initial-timeout="10000"
         direction="duplex"
+        mix="true"
         final-timeout="30000"/>
           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 Record }
 
         its(:format)          { should be == 'WAV' }
         its(:start_beep)      { should be == true }
+        its(:stop_beep)       { should be == true }
         its(:start_paused)    { should be == false }
         its(:max_duration)    { should be == 500000 }
         its(:initial_timeout) { should be == 10000 }
         its(:final_timeout)   { should be == 30000 }
         its(:direction)       { should be == :duplex }
+        its(:mix)             { should be == true }
       end
 
       describe "with a direction" do
         [nil, :duplex, :send, :recv].each do |direction|
           describe direction do
-            subject { Record.new :direction => direction }
+            subject { described_class.new :direction => direction }
 
             its(:direction) { should be == direction }
           end
@@ -73,14 +105,14 @@ module Punchblock
 
         describe "blahblahblah" do
           it "should raise an error" do
-            expect { Record.new(:direction => :blahblahblah) }.to raise_error ArgumentError
+            expect { described_class.new(:direction => :blahblahblah) }.to raise_error ArgumentError
           end
         end
       end
 
       describe "actions" do
-        let(:mock_client) { mock 'Client' }
-        let(:command) { Record.new }
+        let(:mock_client) { double 'Client' }
+        let(:command) { described_class.new }
 
         before do
           command.component_id = 'abc123'
@@ -185,7 +217,7 @@ module Punchblock
 </complete>
           MESSAGE
             end
-            let(:event) { RayoNode.import(parse_stanza(stanza).root) }
+            let(:event) { RayoNode.from_xml(parse_stanza(stanza).root) }
 
             before do
               subject.request!
@@ -235,31 +267,37 @@ module Punchblock
         end
       end
 
-      describe Record::Complete::Success do
-        let :stanza do
-          <<-MESSAGE
-<complete xmlns='urn:xmpp:rayo:ext:1'>
-<success xmlns='urn:xmpp:rayo:record:complete:1'/>
-<recording xmlns='urn:xmpp:rayo:record:complete:1' uri="file:/tmp/rayo7451601434771683422.mp3" duration="34000" size="23450"/>
-</complete>
-          MESSAGE
-        end
+      {
+        Record::Complete::MaxDuration => :'max-duration',
+        Record::Complete::InitialTimeout => :'initial-timeout',
+        Record::Complete::FinalTimeout => :'final-timeout',
+      }.each do |klass, element_name|
+        describe klass do
+          let :stanza do
+            <<-MESSAGE
+  <complete xmlns='urn:xmpp:rayo:ext:1'>
+  <#{element_name} xmlns='urn:xmpp:rayo:record:complete:1'/>
+  <recording xmlns='urn:xmpp:rayo:record:complete:1' uri="file:/tmp/rayo7451601434771683422.mp3" duration="34000" size="23450"/>
+  </complete>
+            MESSAGE
+          end
 
-        describe "#reason" do
-          subject { RayoNode.import(parse_stanza(stanza).root).reason }
+          describe "#reason" do
+            subject { RayoNode.from_xml(parse_stanza(stanza).root).reason }
 
-          it { should be_instance_of Record::Complete::Success }
+            it { should be_instance_of klass }
 
-          its(:name)  { should be == :success }
-        end
+            its(:name)  { should be == element_name }
+          end
 
-        describe "#recording" do
-          subject { RayoNode.import(parse_stanza(stanza).root).recording }
+          describe "#recording" do
+            subject { RayoNode.from_xml(parse_stanza(stanza).root).recording }
 
-          it { should be_instance_of Record::Recording }
-          its(:uri)       { should be == "file:/tmp/rayo7451601434771683422.mp3" }
-          its(:duration)  { should be == 34000 }
-          its(:size)      { should be == 23450 }
+            it { should be_instance_of Record::Recording }
+            its(:uri)       { should be == "file:/tmp/rayo7451601434771683422.mp3" }
+            its(:duration)  { should be == 34000 }
+            its(:size)      { should be == 23450 }
+          end
         end
       end
 
@@ -274,7 +312,7 @@ module Punchblock
         end
 
         describe "#reason" do
-          subject { RayoNode.import(parse_stanza(stanza).root).reason }
+          subject { RayoNode.from_xml(parse_stanza(stanza).root).reason }
 
           it { should be_instance_of Event::Complete::Stop }
 
@@ -282,7 +320,7 @@ module Punchblock
         end
 
         describe "#recording" do
-          subject { RayoNode.import(parse_stanza(stanza).root).recording }
+          subject { RayoNode.from_xml(parse_stanza(stanza).root).recording }
 
           it { should be_instance_of Record::Recording }
           its(:uri) { should be == "file:/tmp/rayo7451601434771683422.mp3" }
@@ -300,7 +338,7 @@ module Punchblock
         end
 
         describe "#reason" do
-          subject { RayoNode.import(parse_stanza(stanza).root).reason }
+          subject { RayoNode.from_xml(parse_stanza(stanza).root).reason }
 
           it { should be_instance_of Event::Complete::Hangup }
 
@@ -308,7 +346,7 @@ module Punchblock
         end
 
         describe "#recording" do
-          subject { RayoNode.import(parse_stanza(stanza).root).recording }
+          subject { RayoNode.from_xml(parse_stanza(stanza).root).recording }
 
           it { should be_instance_of Record::Recording }
           its(:uri) { should be == "file:/tmp/rayo7451601434771683422.mp3" }

data/spec/punchblock/connection/asterisk_spec.rb

@@ -15,7 +15,7 @@ module Punchblock
         }
       end
 
-      let(:mock_event_handler) { stub('Event Handler').as_null_object }
+      let(:mock_event_handler) { double('Event Handler').as_null_object }
 
       let(:connection) { Asterisk.new options }
 
@@ -25,7 +25,8 @@ module Punchblock
         subject.event_handler = mock_event_handler
       end
 
-      its(:ami_client) { should be_a RubyAMI::Stream }
+      its(:ami_client) { should be_a RubyAMIStreamProxy }
+      its('ami_client.stream') { should be_a RubyAMI::Stream }
 
       it 'should set the connection on the translator' do
         subject.translator.connection.should be subject
@@ -42,6 +43,19 @@ module Punchblock
           end
           lambda { subject.run }.should raise_error DisconnectedError
         end
+
+        it 'rebuilds the RubyAMI::Stream if dead' do
+          subject.ami_client.async.should_receive(:run).once do
+            subject.ami_client.terminate
+          end
+          lambda { subject.run }.should raise_error DisconnectedError
+          subject.ami_client.alive?.should be_false
+          subject.should_receive(:new_ami_stream).once do
+            subject.ami_client.alive?.should be_true
+            subject.ami_client.async.should_receive(:run).once
+          end
+          lambda { subject.run }.should_not raise_error DisconnectedError
+        end
       end
 
       describe '#stop' do
@@ -65,7 +79,7 @@ module Punchblock
 
       describe '#write' do
         it 'sends a command to the translator' do
-          command = mock 'Command'
+          command = double 'Command'
           options = {:foo => :bar}
           subject.translator.async.should_receive(:execute_command).once.with command, options
           subject.write command, options

data/spec/punchblock/connection/freeswitch_spec.rb

@@ -17,11 +17,11 @@ module Punchblock
         }
       end
 
-      let(:mock_event_handler) { stub('Event Handler').as_null_object }
+      let(:mock_event_handler) { double('Event Handler').as_null_object }
 
       let(:connection) { described_class.new options }
 
-      let(:mock_stream) { mock 'RubyFS::Stream' }
+      let(:mock_stream) { double 'RubyFS::Stream' }
 
       subject { connection }
 
@@ -62,7 +62,7 @@ module Punchblock
       end
 
       it 'sends events from RubyFS to the translator' do
-        event = mock 'RubyFS::Event'
+        event = double 'RubyFS::Event'
         subject.translator.async.should_receive(:handle_es_event).once.with event
         subject.translator.async.should_receive(:handle_es_event).once.with RubyFS::Stream::Disconnected.new
         subject.stream.fire_event event
@@ -70,7 +70,7 @@ module Punchblock
 
       describe '#write' do
         it 'sends a command to the translator' do
-          command = mock 'Command'
+          command = double 'Command'
           options = {:foo => :bar}
           subject.translator.async.should_receive(:execute_command).once.with command, options
           subject.write command, options

data/spec/punchblock/connection/xmpp_spec.rb

@@ -8,7 +8,7 @@ module Punchblock
       let(:options)     { { :root_domain => 'rayo.net' } }
       let(:connection)  { XMPP.new({:username => '1@app.rayo.net', :password => 1}.merge(options)) }
 
-      let(:mock_event_handler) { stub('Event Handler').as_null_object }
+      let(:mock_event_handler) { double('Event Handler').as_null_object }
 
       before do
         connection.event_handler = mock_event_handler
@@ -21,40 +21,18 @@ module Punchblock
           let(:options) { { :username => '1@app.rayo.net' } }
 
           its(:root_domain)   { should be == 'app.rayo.net' }
-          its(:calls_domain)  { should be == 'calls.app.rayo.net' }
-          its(:mixers_domain) { should be == 'mixers.app.rayo.net' }
         end
 
         context "with only a rayo domain set" do
           let(:options) { { :rayo_domain => 'rayo.org' } }
 
           its(:root_domain)   { should be == 'rayo.org' }
-          its(:calls_domain)  { should be == 'calls.rayo.org' }
-          its(:mixers_domain) { should be == 'mixers.rayo.org' }
         end
 
         context "with only a root domain set" do
           let(:options) { { :root_domain => 'rayo.org' } }
 
           its(:root_domain)   { should be == 'rayo.org' }
-          its(:calls_domain)  { should be == 'calls.rayo.org' }
-          its(:mixers_domain) { should be == 'mixers.rayo.org' }
-        end
-
-        context "with a root domain and calls domain set" do
-          let(:options) { { :root_domain => 'rayo.org', :calls_domain => 'phone_calls.rayo.org' } }
-
-          its(:root_domain)   { should be == 'rayo.org' }
-          its(:calls_domain)  { should be == 'phone_calls.rayo.org' }
-          its(:mixers_domain) { should be == 'mixers.rayo.org' }
-        end
-
-        context "with a root domain and mixers domain set" do
-          let(:options) { { :root_domain => 'rayo.org', :mixers_domain => 'conferences.rayo.org' } }
-
-          its(:root_domain)   { should be == 'rayo.org' }
-          its(:calls_domain)  { should be == 'calls.rayo.org' }
-          its(:mixers_domain) { should be == 'conferences.rayo.org' }
         end
       end
 
@@ -185,15 +163,10 @@ module Punchblock
                 event.should be_instance_of Event::Offer
                 event.target_call_id.should be == '9f00061'
                 event.domain.should be == 'call.rayo.net'
+                event.transport.should be == 'xmpp'
               end
               handle_presence
             end
-
-            it "should populate the call map with the domain for the call ID" do
-              handle_presence
-              callmap = connection.instance_variable_get(:'@callmap')
-              callmap['9f00061'].should be == 'call.rayo.net'
-            end
           end
 
           describe "from something that's not a real event" do
@@ -220,7 +193,7 @@ module Punchblock
         let(:component_id)  { 'abc123' }
         let :error_xml do
           <<-MSG
-<iq type="error" id="blather000e" from="f6d437f4-1e18-457b-99f8-b5d853f50347@10.0.1.11/abc123" to="usera@10.0.1.11/voxeo">
+<iq type="error" id="blather000e" from="f6d437f4-1e18-457b-99f8-b5d853f50347@call.rayo.net/abc123" to="usera@rayo.net">
   <output xmlns="urn:xmpp:rayo:output:1"/>
   <error type="cancel">
     <item-not-found xmlns="urn:ietf:params:xml:ns:xmpp-stanzas"/>
@@ -271,17 +244,26 @@ module Punchblock
         end
 
         context "with a call command" do
-          let(:command)       { Command::Answer.new.tap { |a| a.target_call_id = 'abc123' } }
-          let(:expected_jid)  { 'abc123@calls.rayo.net' }
+          let(:command)       { Command::Answer.new target_call_id: 'abc123' }
+          let(:expected_jid)  { 'abc123@rayo.net' }
 
           it "should use the correct JID" do
             stanza.to.should be == expected_jid
           end
+
+          context "with a domain specified" do
+            let(:expected_jid)  { 'abc123@calls.rayo.net' }
+
+            it "should use the specified domain in the JID" do
+              stanza = subject.prep_command_for_execution command, domain: 'calls.rayo.net'
+              stanza.to.should be == expected_jid
+            end
+          end
         end
 
         context "with a call component" do
           let(:command)       { Component::Output.new :target_call_id => 'abc123' }
-          let(:expected_jid)  { 'abc123@calls.rayo.net' }
+          let(:expected_jid)  { 'abc123@rayo.net' }
 
           it "should use the correct JID" do
             stanza.to.should be == expected_jid
@@ -290,7 +272,7 @@ module Punchblock
 
         context "with a call component command" do
           let(:command)       { Component::Stop.new :target_call_id => 'abc123', :component_id => 'foobar' }
-          let(:expected_jid)  { 'abc123@calls.rayo.net/foobar' }
+          let(:expected_jid)  { 'abc123@rayo.net/foobar' }
 
           it "should use the correct JID" do
             stanza.to.should be == expected_jid
@@ -299,7 +281,7 @@ module Punchblock
 
         context "with a mixer component" do
           let(:command)       { Component::Output.new :target_mixer_name => 'abc123' }
-          let(:expected_jid)  { 'abc123@mixers.rayo.net' }
+          let(:expected_jid)  { 'abc123@rayo.net' }
 
           it "should use the correct JID" do
             stanza.to.should be == expected_jid
@@ -308,7 +290,7 @@ module Punchblock
 
         context "with a mixer component command" do
           let(:command)       { Component::Stop.new :target_mixer_name => 'abc123', :component_id => 'foobar' }
-          let(:expected_jid)  { 'abc123@mixers.rayo.net/foobar' }
+          let(:expected_jid)  { 'abc123@rayo.net/foobar' }
 
           it "should use the correct JID" do
             stanza.to.should be == expected_jid
@@ -325,7 +307,7 @@ module Punchblock
 
           let :active_speaker_xml do
             <<-MSG
-<presence to='16577@app.rayo.net/1' from='foomixer@mixers.rayo.net'>
+<presence to='16577@app.rayo.net/1' from='foomixer@rayo.net'>
   <started-speaking xmlns="urn:xmpp:rayo:1" call-id="foocall"/>
 </presence>
             MSG
@@ -338,7 +320,7 @@ module Punchblock
               event.should be_instance_of Event::StartedSpeaking
               event.target_mixer_name.should be == 'foomixer'
               event.target_call_id.should be nil
-              event.domain.should be == 'mixers.rayo.net'
+              event.domain.should be == 'rayo.net'
             end
             connection.__send__ :handle_presence, active_speaker_event
           end

data/spec/punchblock/event/answered_spec.rb

@@ -6,7 +6,7 @@ module Punchblock
   class Event
     describe Answered do
       it 'registers itself' do
-        RayoNode.class_from_registration(:answered, 'urn:xmpp:rayo:1').should be == Answered
+        RayoNode.class_from_registration(:answered, 'urn:xmpp:rayo:1').should be == described_class
       end
 
       describe "from a stanza" do
@@ -20,23 +20,25 @@ 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 Answered }
+        it { should be_instance_of described_class }
 
         it_should_behave_like 'event'
-        it_should_behave_like 'event_headers'
+        its(:headers) { should == { 'X-skill' => 'agent', 'X-customer-id' => '8877' } }
 
-        its(:xmlns) { should be == 'urn:xmpp:rayo:1' }
+        context "with no headers provided" do
+          let(:stanza) { '<answered xmlns="urn:xmpp:rayo:1"/>' }
+
+          its(:headers) { should == {} }
+        end
       end
 
       describe "when setting options in initializer" do
-        subject do
-          Answered.new :headers => { :x_skill => "agent", :x_customer_id => "8877" }
-        end
+        subject { described_class.new headers: { 'X-skill' => 'agent', 'X-customer-id' => '8877' } }
 
-        it_should_behave_like 'command_headers'
+        its(:headers) { should == { 'X-skill' => 'agent', 'X-customer-id' => '8877' } }
       end
     end
   end
-end # Punchblock
+end

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

@@ -8,7 +8,7 @@ module Punchblock
       module AMI
         describe Event do
           it 'registers itself' do
-            RayoNode.class_from_registration(:event, 'urn:xmpp:rayo:asterisk:ami:1').should be == Event
+            RayoNode.class_from_registration(:event, 'urn:xmpp:rayo:asterisk:ami:1').should be == described_class
           end
 
           describe "from a stanza" do
@@ -17,46 +17,51 @@ module Punchblock
 <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' }
+            subject { RayoNode.from_xml parse_stanza(stanza).root, '9f00061', '1' }
 
             it { should be_instance_of Event }
 
             it_should_behave_like 'event'
 
-            its(:name)            { should be == 'Newchannel' }
-            its(:attributes)      { should be == [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 be == {:channel => 'SIP/101-3f3f', :state => 'Ring', :callerid => '101', :uniqueid => '1094154427.10'} }
+            its(:name)    { should be == 'Newchannel' }
+            its(:headers) { should be == {'Channel' => 'SIP/101-3f3f', 'State' => 'Ring'} }
+            its(:attributes) { should be == {'Channel' => 'SIP/101-3f3f', 'State' => 'Ring'} } # For BC
           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'}
+              described_class.new name: 'Newchannel',
+                                  headers: {'Channel' => 'SIP/101-3f3f', 'State' => 'Ring'}
             end
 
-            its(:name)            { should be == 'Newchannel' }
-            its(:attributes)      { should be == [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 be == {:channel => 'SIP/101-3f3f', :state => 'Ring', :callerid => '101', :uniqueid => '1094154427.10'} }
-          end
+            its(:name)    { should be == 'Newchannel' }
+            its(:headers) { should be == {'Channel' => 'SIP/101-3f3f', 'State' => 'Ring'} }
+            its(:attributes) { should be == {'Channel' => 'SIP/101-3f3f', 'State' => 'Ring'} } # For BC
+
+            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 == 'Newchannel'
+                new_instance.headers.should == {'Channel' => 'SIP/101-3f3f', 'State' => 'Ring'}
+                new_instance.attributes.should == {'Channel' => 'SIP/101-3f3f', 'State' => 'Ring'} # For BC
+              end
 
-          class Event
-            describe Attribute do
-              let(:class_name)    { Attribute }
-              let(:element_name)  { 'attribute' }
-              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
         end
       end
     end
   end
-end # Punchblock
+end

data/spec/punchblock/event/complete_spec.rb

@@ -6,11 +6,11 @@ module Punchblock
   class Event
     describe Complete do
       it 'registers itself' do
-        RayoNode.class_from_registration(:complete, 'urn:xmpp:rayo:ext:1').should be == Complete
+        RayoNode.class_from_registration(:complete, 'urn:xmpp:rayo:ext:1').should be == described_class
       end
 
       describe "setting a reason" do
-        let(:reason) { Punchblock::Component::Asterisk::AGI::Command::Complete::Success.new }
+        let(:reason) { Complete::Stop.new }
 
         subject { described_class.new }
 
@@ -21,19 +21,15 @@ module Punchblock
 
       describe "comparing for equality" do
         subject do
-          Complete.new.tap do |c|
-            c.reason          = Complete::Stop.new
-            c.target_call_id  = '1234'
-            c.component_id    = 'abcd'
-          end
+          described_class.new reason: Complete::Stop.new,
+            target_call_id: '1234',
+            component_id: 'abcd'
         end
 
         let :other_complete do
-          Complete.new.tap do |c|
-            c.reason          = reason
-            c.target_call_id  = call_id
-            c.component_id    = component_id
-          end
+          described_class.new reason: reason,
+            target_call_id: call_id,
+            component_id: component_id
         end
 
         context 'with reason, call id and component id the same' do
@@ -81,18 +77,18 @@ module Punchblock
         let :stanza do
           <<-MESSAGE
 <complete xmlns='urn:xmpp:rayo:ext:1'>
-  <success xmlns='urn:xmpp:rayo:output:complete:1' />
+  <stop xmlns='urn:xmpp:rayo:ext:complete:1' />
 </complete>
           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 Complete }
+        it { should be_instance_of described_class }
 
         it_should_behave_like 'event'
 
-        its(:reason) { should be_instance_of Component::Output::Complete::Success }
+        its(:reason) { should be_instance_of Complete::Stop }
       end
     end
 
@@ -105,7 +101,7 @@ 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 Complete::Stop }
 
@@ -121,7 +117,7 @@ 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 Complete::Hangup }
 
@@ -139,7 +135,7 @@ 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 Complete::Error }