adhearsion 2.6.4 → 3.0.0.beta1

data/spec/adhearsion/call_controller/record_spec.rb

@@ -17,7 +17,7 @@ module Adhearsion
             :async => async
         end
 
-        let(:component) { Punchblock::Component::Record.new component_options }
+        let(:component) { Adhearsion::Rayo::Component::Record.new component_options }
         let :stopper_grammar do
           RubySpeech::GRXML.draw :mode => 'dtmf', :root => 'inputdigits' do
             rule id: 'inputdigits', scope: 'public' do
@@ -38,7 +38,7 @@ module Adhearsion
             end
           end
         end
-        let(:input_component) { Punchblock::Component::Input.new mode: :dtmf, grammar: { :value => stopper_grammar } }
+        let(:input_component) { Adhearsion::Rayo::Component::Input.new mode: :dtmf, grammar: { :value => stopper_grammar } }
 
         subject { Recorder.new controller, options }
 
@@ -53,7 +53,7 @@ module Adhearsion
           end
 
           let :component do
-            Punchblock::Component::Record.new :max_duration => 5500,
+            Adhearsion::Rayo::Component::Record.new :max_duration => 5500,
               :initial_timeout => 6500,
               :final_timeout => 3200
           end
@@ -102,7 +102,7 @@ module Adhearsion
             end
 
             describe "when the input component completes" do
-              let(:complete_event) { Punchblock::Event::Complete.new }
+              let(:complete_event) { Adhearsion::Event::Complete.new }
 
               before do
                 subject.stopper_component.request!
@@ -148,11 +148,11 @@ module Adhearsion
         end
 
         describe "setting completion handlers" do
-          let(:complete_event) { Punchblock::Event::Complete.new }
+          let(:complete_event) { Adhearsion::Event::Complete.new }
 
           it "should execute those handlers when recording completes" do
             foo = double 'foo'
-            expect(foo).to receive(:call).once.with kind_of(Punchblock::Event::Complete)
+            expect(foo).to receive(:call).once.with kind_of(Adhearsion::Event::Complete)
             subject.handle_record_completion { |e| foo.call e }
             subject.record_component.trigger_event_handler complete_event
           end
@@ -170,13 +170,13 @@ module Adhearsion
         let(:parsed_options) do
           options.merge(max_duration: max_duration * 1000)
         end
-        let(:component) { Punchblock::Component::Record.new parsed_options }
-        let(:response)  { Punchblock::Event::Complete.new }
+        let(:component) { Adhearsion::Rayo::Component::Record.new parsed_options }
+        let(:response)  { Adhearsion::Event::Complete.new }
 
         describe "with :async => true and an :on_complete callback" do
           before do
             component
-            expect(Punchblock::Component::Record).to receive(:new).once.with(parsed_options).and_return component
+            expect(Adhearsion::Rayo::Component::Record).to receive(:new).once.with(parsed_options).and_return component
             expect_message_waiting_for_response component
             @rec = Queue.new
             subject.record(options.merge(async: true)) { |rec| @rec.push rec }
@@ -196,7 +196,7 @@ module Adhearsion
           before do
             TestException = Class.new StandardError
             component
-            expect(Punchblock::Component::Record).to receive(:new).once.with({}).and_return component
+            expect(Adhearsion::Rayo::Component::Record).to receive(:new).once.with({}).and_return component
           end
 
           it "should pass the exception to the events system" do
@@ -212,14 +212,13 @@ module Adhearsion
             component.execute!
             component.trigger_event_handler response
             expect(latch.wait(1)).to be true
-            Adhearsion::Events.clear_handlers :exception
           end
         end
 
         describe "with :async => false" do
           before do
             component
-            expect(Punchblock::Component::Record).to receive(:new).once.with(parsed_options).and_return component
+            expect(Adhearsion::Rayo::Component::Record).to receive(:new).once.with(parsed_options).and_return component
             expect_component_execution component
             @rec = Queue.new
             subject.record(options.merge(:async => false)) { |rec| @rec.push rec }
@@ -236,7 +235,7 @@ module Adhearsion
         end
 
         describe "with :interruptible => false" do
-          let(:input_component) { Punchblock::Component::Input.new }
+          let(:input_component) { Adhearsion::Rayo::Component::Input.new }
           it "does not use an Input component" do
             expect(subject).to receive(:execute_component_and_await_completion).once.with(component)
             expect(subject).to receive(:write_and_await_response).never.with(input_component)
@@ -247,12 +246,12 @@ module Adhearsion
         describe "with :interruptible => true" do
           it "stops the recording" do
             def subject.write_and_await_response(input_component)
-              input_component.trigger_event_handler Punchblock::Event::Complete.new
+              input_component.trigger_event_handler Adhearsion::Event::Complete.new
             end
 
             expect_input_component_complete_event 'dtmf-5'
 
-            expect_any_instance_of(Punchblock::Component::Record).to receive(:stop!)
+            expect_any_instance_of(Adhearsion::Rayo::Component::Record).to receive(:stop!)
             expect(subject).to receive(:execute_component_and_await_completion).once.with(component)
             subject.record(options.merge(:async => false, :interruptible => true)) { |rec| @rec.push rec }
           end
@@ -262,7 +261,7 @@ module Adhearsion
         describe "check for the return value" do
           it "returns a Record component" do
             component
-            expect(Punchblock::Component::Record).to receive(:new).once.with(parsed_options).and_return component
+            expect(Adhearsion::Rayo::Component::Record).to receive(:new).once.with(parsed_options).and_return component
             expect_component_execution component
             expect(subject.record(options.merge(:async => false))).to eq(component)
             component.request!

data/spec/adhearsion/call_controller_spec.rb

@@ -300,7 +300,7 @@ module Adhearsion
           end
 
           context "and some fail to terminate" do
-            before { expect(subject.output1).to receive(:stop!).and_raise(Punchblock::Component::InvalidActionError) }
+            before { expect(subject.output1).to receive(:stop!).and_raise(Adhearsion::Rayo::Component::InvalidActionError) }
 
             it "should terminate the others" do
               expect(subject.output2).to receive(:stop!).once
@@ -310,7 +310,7 @@ module Adhearsion
         end
 
         context "when some have completed" do
-          before { subject.output1.trigger_event_handler Punchblock::Event::Complete.new }
+          before { subject.output1.trigger_event_handler Adhearsion::Event::Complete.new }
 
           it "should not terminate the completed components" do
             expect(subject.output1).to receive(:stop!).never
@@ -360,7 +360,7 @@ module Adhearsion
           end
 
           context "and some fail to terminate" do
-            before { expect(subject.output1).to receive(:stop!).and_raise(Punchblock::Component::InvalidActionError) }
+            before { expect(subject.output1).to receive(:stop!).and_raise(Adhearsion::Rayo::Component::InvalidActionError) }
 
             it "should terminate the others" do
               expect(subject.output2).to receive(:stop!).once
@@ -370,7 +370,7 @@ module Adhearsion
         end
 
         context "when some have completed" do
-          before { subject.output1.trigger_event_handler Punchblock::Event::Complete.new }
+          before { subject.output1.trigger_event_handler Adhearsion::Event::Complete.new }
 
           it "should not terminate the completed components" do
             expect(subject.output1).to receive(:stop!).never
@@ -383,7 +383,7 @@ module Adhearsion
     end
 
     describe "#write_and_await_response" do
-      let(:message) { Punchblock::Command::Accept.new }
+      let(:message) { Adhearsion::Rayo::Command::Accept.new }
 
       it "delegates to the call, blocking first until it is allowed to execute" do
         expect(subject).to receive(:block_until_resumed).once.ordered
@@ -393,12 +393,12 @@ module Adhearsion
 
       it "allows complete events to bubble" do
         bubbled = false
-        message = Punchblock::Component::Output.new
+        message = Adhearsion::Rayo::Component::Output.new
         expect(subject.call).to receive(:write_and_await_response)
         subject.write_and_await_response message
-        message.register_event_handler(Punchblock::Event::Complete) { bubbled = true }
+        message.register_event_handler(Adhearsion::Event::Complete) { bubbled = true }
         expect(bubbled).to be false
-        message.trigger_event_handler Punchblock::Event::Complete.new
+        message.trigger_event_handler Adhearsion::Event::Complete.new
         expect(bubbled).to be true
       end
     end
@@ -432,32 +432,32 @@ module Adhearsion
     describe "#join" do
       it "delegates to the call, blocking first until it is allowed to execute, and unblocking when an unjoined event is received" do
         expect(subject).to receive(:block_until_resumed).once.ordered
-        expect(call.wrapped_object).to receive(:write_and_await_response).once.ordered.with(Punchblock::Command::Join.new(call_uri: 'call1'))
+        expect(call.wrapped_object).to receive(:write_and_await_response).once.ordered.with(Adhearsion::Rayo::Command::Join.new(call_uri: 'call1'))
         latch = CountDownLatch.new 1
         Thread.new do
           subject.join 'call1', :foo => :bar
           latch.countdown!
         end
         expect(latch.wait(1)).to be false
-        subject.call << Punchblock::Event::Joined.new(call_uri: 'call1')
+        subject.call << Adhearsion::Event::Joined.new(call_uri: 'call1')
         expect(latch.wait(1)).to be false
-        subject.call << Punchblock::Event::Unjoined.new(call_uri: 'call1')
+        subject.call << Adhearsion::Event::Unjoined.new(call_uri: 'call1')
         expect(latch.wait(1)).to be true
       end
 
       context "with a mixer" do
         it "delegates to the call, blocking first until it is allowed to execute, and unblocking when an unjoined event is received" do
           expect(subject).to receive(:block_until_resumed).once.ordered
-          expect(call.wrapped_object).to receive(:write_and_await_response).once.ordered.with(Punchblock::Command::Join.new(mixer_name: 'foobar'))
+          expect(call.wrapped_object).to receive(:write_and_await_response).once.ordered.with(Adhearsion::Rayo::Command::Join.new(mixer_name: 'foobar'))
           latch = CountDownLatch.new 1
           Thread.new do
             subject.join :mixer_name => 'foobar', :foo => :bar
             latch.countdown!
           end
           expect(latch.wait(1)).to be false
-          subject.call << Punchblock::Event::Joined.new(:mixer_name => 'foobar')
+          subject.call << Adhearsion::Event::Joined.new(:mixer_name => 'foobar')
           expect(latch.wait(1)).to be false
-          subject.call << Punchblock::Event::Unjoined.new(:mixer_name => 'foobar')
+          subject.call << Adhearsion::Event::Unjoined.new(:mixer_name => 'foobar')
           expect(latch.wait(1)).to be true
         end
       end
@@ -465,28 +465,28 @@ module Adhearsion
       context "with :async => true" do
         it "delegates to the call, blocking first until it is allowed to execute, and unblocking when the joined event is received" do
           expect(subject).to receive(:block_until_resumed).once.ordered
-          expect(call.wrapped_object).to receive(:write_and_await_response).once.ordered.with(Punchblock::Command::Join.new(call_uri: 'call1'))
+          expect(call.wrapped_object).to receive(:write_and_await_response).once.ordered.with(Adhearsion::Rayo::Command::Join.new(call_uri: 'call1'))
           latch = CountDownLatch.new 1
           Thread.new do
             subject.join 'call1', :foo => :bar, :async => true
             latch.countdown!
           end
           expect(latch.wait(1)).to be false
-          subject.call << Punchblock::Event::Joined.new(call_uri: 'call1')
+          subject.call << Adhearsion::Event::Joined.new(call_uri: 'call1')
           expect(latch.wait(1)).to be true
         end
 
         context "with a mixer" do
           it "delegates to the call, blocking first until it is allowed to execute, and unblocking when the joined event is received" do
             expect(subject).to receive(:block_until_resumed).once.ordered
-            expect(call.wrapped_object).to receive(:write_and_await_response).once.ordered.with(Punchblock::Command::Join.new(mixer_name: 'foobar'))
+            expect(call.wrapped_object).to receive(:write_and_await_response).once.ordered.with(Adhearsion::Rayo::Command::Join.new(mixer_name: 'foobar'))
             latch = CountDownLatch.new 1
             Thread.new do
               subject.join :mixer_name => 'foobar', :foo => :bar, :async => true
               latch.countdown!
             end
             expect(latch.wait(1)).to be false
-            subject.call << Punchblock::Event::Joined.new(:mixer_name => 'foobar')
+            subject.call << Adhearsion::Event::Joined.new(:mixer_name => 'foobar')
             expect(latch.wait(1)).to be true
           end
         end
@@ -529,8 +529,8 @@ module Adhearsion
     end
 
     describe "#execute_component_and_await_completion" do
-      let(:component) { Punchblock::Component::Output.new }
-      let(:response)  { Punchblock::Event::Complete.new }
+      let(:component) { Adhearsion::Rayo::Component::Output.new }
+      let(:response)  { Adhearsion::Event::Complete.new }
 
       before do
         expect_message_of_type_waiting_for_response component
@@ -557,11 +557,11 @@ module Adhearsion
 
       describe "with an error response" do
         let(:response) do
-          Punchblock::Event::Complete.new :reason => error
+          Adhearsion::Event::Complete.new :reason => error
         end
 
         let(:error) do
-          Punchblock::Event::Complete::Error.new :details => details
+          Adhearsion::Event::Complete::Error.new :details => details
         end
 
         let(:details) { "Oh noes, it's all borked" }
@@ -571,24 +571,8 @@ module Adhearsion
         end
       end
 
-      describe "with complete event with reason hangup" do
-
-        let(:response) do
-          Punchblock::Event::Complete.new :reason => complete_reason
-        end
-
-        let(:complete_reason) do
-          Punchblock::Event::Complete::Hangup.new
-        end
-
-        it "raises the hangup" do
-          expect { subject.execute_component_and_await_completion component }.to raise_error(Call::Hangup)
-        end
-
-      end
-
       it "blocks until the component receives a complete event" do
-        slow_component = Punchblock::Component::Output.new
+        slow_component = Adhearsion::Rayo::Component::Output.new
         slow_component.request!
         slow_component.execute!
         Thread.new do
@@ -701,7 +685,6 @@ describe ExampleCallController do
     end
     subject.exec
     expect(latch.wait(1)).to be true
-    Adhearsion::Events.clear_handlers :exception
   end
 
   it "should call the requested method when an exception is encountered" do

data/spec/adhearsion/call_spec.rb

@@ -20,7 +20,7 @@ module Adhearsion
     let(:transport) { 'footransport' }
     let(:base_time) { Time.local(2008, 9, 1, 12, 0, 0) }
     let :offer do
-      Punchblock::Event::Offer.new target_call_id: call_id,
+      Adhearsion::Event::Offer.new target_call_id: call_id,
                                    domain: domain,
                                    transport: transport,
                                    to: to,
@@ -158,7 +158,7 @@ module Adhearsion
           end
 
           context "when receiving an event with headers" do
-            let(:event) { Punchblock::Event::End.new :headers => {'X-bar' => 'foo'} }
+            let(:event) { Adhearsion::Event::End.new :headers => {'X-bar' => 'foo'} }
 
             it "should merge later headers" do
               subject << event
@@ -166,7 +166,7 @@ module Adhearsion
             end
 
             context "with have symbol names" do
-              let(:event) { Punchblock::Event::End.new :headers => {:x_bar => 'foo'} }
+              let(:event) { Adhearsion::Event::End.new :headers => {:x_bar => 'foo'} }
 
               it "should merge later headers" do
                 subject << event
@@ -176,7 +176,7 @@ module Adhearsion
           end
 
           context "when sending a command with headers" do
-            let(:command) { Punchblock::Command::Accept.new :headers => {'X-bar' => 'foo'} }
+            let(:command) { Adhearsion::Rayo::Command::Accept.new :headers => {'X-bar' => 'foo'} }
 
             it "should merge later headers" do
               subject.write_command command
@@ -251,7 +251,7 @@ module Adhearsion
       describe "for joined events" do
         context "joined to another call" do
           let :event do
-            Punchblock::Event::Joined.new call_uri: 'footransport:foobar@rayo.net'
+            Adhearsion::Event::Joined.new call_uri: 'footransport:foobar@rayo.net'
           end
 
           it "should trigger any on_joined callbacks set for the matching call ID" do
@@ -289,7 +289,7 @@ module Adhearsion
 
         context "joined to a mixer" do
           let :event do
-            Punchblock::Event::Joined.new :mixer_name => 'foobar'
+            Adhearsion::Event::Joined.new :mixer_name => 'foobar'
           end
 
           it "should trigger on_joined callbacks for the matching mixer name" do
@@ -329,7 +329,7 @@ module Adhearsion
       describe "for unjoined events" do
         context "unjoined from another call" do
           let :event do
-            Punchblock::Event::Unjoined.new call_uri: 'footransport:foobar@rayo.net'
+            Adhearsion::Event::Unjoined.new call_uri: 'footransport:foobar@rayo.net'
           end
 
           it "should trigger any on_unjoined callbacks set for the matching call ID" do
@@ -367,7 +367,7 @@ module Adhearsion
 
         context "unjoined from a mixer" do
           let :event do
-            Punchblock::Event::Unjoined.new :mixer_name => 'foobar'
+            Adhearsion::Event::Unjoined.new :mixer_name => 'foobar'
           end
 
           it "should trigger on_unjoined callbacks for the matching mixer name" do
@@ -406,7 +406,7 @@ module Adhearsion
 
       describe "for end events" do
         let :event do
-          Punchblock::Event::End.new :reason => :hangup
+          Adhearsion::Event::End.new :reason => :hangup
         end
 
         it "should trigger any on_end callbacks set" do
@@ -434,7 +434,6 @@ module Adhearsion
           subject.register_event_handler { |e| raise 'foo' }
           expect { subject << :foo }.not_to raise_error
           expect(latch.wait(3)).to be true
-          Adhearsion::Events.clear_handlers :exception
         end
       end
     end
@@ -446,11 +445,11 @@ module Adhearsion
       before { allow(other_call).to receive_messages uri: other_call_uri }
 
       let :joined_event do
-        Punchblock::Event::Joined.new call_uri: other_call_uri
+        Adhearsion::Event::Joined.new call_uri: other_call_uri
       end
 
       let :unjoined_event do
-        Punchblock::Event::Unjoined.new call_uri: other_call_uri
+        Adhearsion::Event::Unjoined.new call_uri: other_call_uri
       end
 
       context "when we know about the joined call" do
@@ -552,25 +551,9 @@ module Adhearsion
     end
 
     describe "#<<" do
-      describe "with a Punchblock Complete Event and Reason Hangup" do
-        let :complete_event do
-          Punchblock::Event::Complete.new :reason => Punchblock::Event::Complete::Hangup.new
-        end
-
-        it "should mark the call as terminating" do
-          subject << complete_event
-          expect(subject.terminating?).to be true
-        end
-      end
-
-      describe "with a Punchblock End" do
+      describe "with an End event" do
         let :end_event do
-          Punchblock::Event::End.new :reason => :hangup, :platform_code => 'arbitrary_code'
-        end
-
-        it "should mark the call as terminating" do
-          subject << end_event
-          expect(subject.terminating?).to be true
+          Adhearsion::Event::End.new :reason => :hangup, :platform_code => 'arbitrary_code'
         end
 
         it "should mark the call as ended" do
@@ -618,7 +601,7 @@ module Adhearsion
         end
 
         it "should instruct the command registry to terminate" do
-          command = Punchblock::Command::Answer.new
+          command = Adhearsion::Rayo::Command::Answer.new
           command.request!
           subject.future.write_and_await_response command
           subject << end_event
@@ -637,16 +620,16 @@ module Adhearsion
 
         context "with no custom lifetime" do
           around do |example|
-            old_val = Adhearsion.config.platform.after_hangup_lifetime
+            old_val = Adhearsion.config.core.after_hangup_lifetime
             begin
               example.run
             rescue
-              Adhearsion.config.platform.after_hangup_lifetime = old_val
+              Adhearsion.config.core.after_hangup_lifetime = old_val
             end
           end
 
           it "shuts down the actor using platform config" do
-            Adhearsion.config.platform.after_hangup_lifetime = 2
+            Adhearsion.config.core.after_hangup_lifetime = 2
             subject << end_event
             sleep 2.1
             expect(subject.alive?).to be false
@@ -656,16 +639,16 @@ module Adhearsion
 
         context "with a custom lifetime" do
           around do |example|
-            old_val = Adhearsion.config.platform.after_hangup_lifetime
+            old_val = Adhearsion.config.core.after_hangup_lifetime
             begin
               example.run
             rescue
-              Adhearsion.config.platform.after_hangup_lifetime = old_val
+              Adhearsion.config.core.after_hangup_lifetime = old_val
             end
           end
 
           it "shuts down the actor using the Call#after_hangup_lifetime" do
-            Adhearsion.config.platform.after_hangup_lifetime = 1
+            Adhearsion.config.core.after_hangup_lifetime = 1
             subject.after_hangup_lifetime = 2
             subject << end_event
             sleep 1.1
@@ -680,7 +663,7 @@ module Adhearsion
 
     describe "#wait_for_end" do
       let :end_event do
-        Punchblock::Event::End.new reason: :hangup
+        Adhearsion::Event::End.new reason: :hangup
       end
 
       context "when the call has already ended" do
@@ -702,6 +685,18 @@ module Adhearsion
 
           expect(fut.value).to eq(:hangup)
         end
+
+        it "should unblock after a timeout" do
+          fut = subject.future.wait_for_end 1
+
+          sleep 0.5
+          expect(fut).not_to be_ready
+
+          sleep 0.5
+
+          expect { fut.value }.to raise_error(Celluloid::ConditionError)
+          expect(subject.alive?).to be(true)
+        end
       end
     end
 
@@ -753,11 +748,11 @@ module Adhearsion
     end
 
     describe "#write_command" do
-      let(:command) { Punchblock::Command::Answer.new }
+      let(:command) { Adhearsion::Rayo::Command::Answer.new }
 
-      it "should write the command to the Punchblock connection" do
+      it "should write the command to the Rayo connection" do
         expect(subject.wrapped_object).to receive(:client).once.and_return mock_client
-        expect(mock_client).to receive(:execute_command).once.with(Punchblock::Command::Answer.new(target_call_id: call_id, domain: domain)).and_return true
+        expect(mock_client).to receive(:execute_command).once.with(Adhearsion::Rayo::Command::Answer.new(target_call_id: call_id, domain: domain)).and_return true
         subject.write_command command
       end
 
@@ -771,7 +766,7 @@ module Adhearsion
         end
 
         describe "if the command is a Hangup" do
-          let(:command) { Punchblock::Command::Hangup.new }
+          let(:command) { Adhearsion::Rayo::Command::Hangup.new }
 
           it "should not raise a Hangup exception" do
             expect { subject.write_command command }.not_to raise_error
@@ -781,7 +776,7 @@ module Adhearsion
     end
 
     describe '#write_and_await_response' do
-      let(:message) { Punchblock::Command::Accept.new }
+      let(:message) { Adhearsion::Rayo::Command::Accept.new }
       let(:response) { :foo }
 
       before do
@@ -800,7 +795,7 @@ module Adhearsion
       end
 
       it "blocks until a response is received" do
-        slow_command = Punchblock::Command::Dial.new
+        slow_command = Adhearsion::Rayo::Command::Dial.new
         slow_command.request!
         Thread.new do
           sleep 0.5
@@ -812,7 +807,7 @@ module Adhearsion
       end
 
       context "while waiting for a response" do
-        let(:slow_command) { Punchblock::Command::Dial.new }
+        let(:slow_command) { Adhearsion::Rayo::Command::Dial.new }
 
         before { slow_command.request! }
 
@@ -838,7 +833,7 @@ module Adhearsion
       end
 
       describe "with an error response" do
-        let(:new_exception) { Punchblock::ProtocolError }
+        let(:new_exception) { Adhearsion::ProtocolError }
         let(:response) { new_exception.new }
 
         it "raises the error" do
@@ -872,7 +867,7 @@ module Adhearsion
     end
 
     describe "#send_message" do
-      it "should send a message through the Punchblock connection using the call ID and domain" do
+      it "should send a message through the Rayo connection using the call ID and domain" do
         expect(subject.wrapped_object).to receive(:client).once.and_return mock_client
         expect(mock_client).to receive(:send_message).once.with(subject.id, subject.domain, "Hello World!", {})
         subject.send_message "Hello World!"
@@ -899,7 +894,7 @@ module Adhearsion
       describe '#accept' do
         describe "with no headers" do
           it 'should send an Accept message' do
-            expect_message_waiting_for_response Punchblock::Command::Accept.new
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Accept.new
             subject.accept
           end
         end
@@ -907,14 +902,14 @@ module Adhearsion
         describe "with headers set" do
           it 'should send an Accept message with the correct headers' do
             headers = {:foo => 'bar'}
-            expect_message_waiting_for_response Punchblock::Command::Accept.new(:headers => headers)
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Accept.new(:headers => headers)
             subject.accept headers
           end
         end
 
         describe "a second time" do
           it "should only send one Accept message" do
-            expect_message_waiting_for_response Punchblock::Command::Accept.new
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Accept.new
             subject.accept
             subject.accept
           end
@@ -922,8 +917,8 @@ module Adhearsion
 
         context "with a failure response" do
           it 'should raise the error but not crash the actor' do
-            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
-            expect_message_waiting_for_response Punchblock::Command::Accept.new, error
+            error = Adhearsion::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Accept.new, error
             expect { subject.accept }.to raise_error error
             sleep 0.2
             expect(subject.alive?).to be true
@@ -934,7 +929,7 @@ module Adhearsion
       describe '#answer' do
         describe "with no headers" do
           it 'should send an Answer message' do
-            expect_message_waiting_for_response Punchblock::Command::Answer.new
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Answer.new
             subject.answer
           end
         end
@@ -942,15 +937,15 @@ module Adhearsion
         describe "with headers set" do
           it 'should send an Answer message with the correct headers' do
             headers = {:foo => 'bar'}
-            expect_message_waiting_for_response Punchblock::Command::Answer.new(:headers => headers)
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Answer.new(:headers => headers)
             subject.answer headers
           end
         end
 
         context "with a failure response" do
           it 'should raise the error but not crash the actor' do
-            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
-            expect_message_waiting_for_response Punchblock::Command::Answer.new, error
+            error = Adhearsion::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Answer.new, error
             expect { subject.answer }.to raise_error error
             sleep 0.2
             expect(subject.alive?).to be true
@@ -961,14 +956,14 @@ module Adhearsion
       describe '#reject' do
         describe "with a reason given" do
           it 'should send a Reject message with the correct reason' do
-            expect_message_waiting_for_response Punchblock::Command::Reject.new(:reason => :decline)
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Reject.new(:reason => :decline)
             subject.reject :decline
           end
         end
 
         describe "with no reason given" do
           it 'should send a Reject message with the reason busy' do
-            expect_message_waiting_for_response Punchblock::Command::Reject.new(:reason => :busy)
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Reject.new(:reason => :busy)
             subject.reject
           end
         end
@@ -976,7 +971,7 @@ module Adhearsion
         describe "with no headers" do
           it 'should send a Reject message' do
             expect_message_waiting_for_response do |c|
-              c.is_a?(Punchblock::Command::Reject) && c.headers == {}
+              c.is_a?(Adhearsion::Rayo::Command::Reject) && c.headers == {}
             end
             subject.reject
           end
@@ -986,22 +981,22 @@ module Adhearsion
           it 'should send a Hangup message with the correct headers' do
             headers = {:foo => 'bar'}
             expect_message_waiting_for_response do |c|
-              c.is_a?(Punchblock::Command::Reject) && c.headers == headers
+              c.is_a?(Adhearsion::Rayo::Command::Reject) && c.headers == headers
             end
             subject.reject nil, headers
           end
         end
 
         it "should immediately fire the :call_rejected event giving the call and the reason" do
-          expect_message_waiting_for_response kind_of(Punchblock::Command::Reject)
+          expect_message_waiting_for_response kind_of(Adhearsion::Rayo::Command::Reject)
           expect(Adhearsion::Events).to receive(:trigger_immediately).once.with(:call_rejected, :call => subject, :reason => :decline)
           subject.reject :decline
         end
 
         context "with a failure response" do
           it 'should raise the error but not crash the actor' do
-            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
-            expect_message_waiting_for_response Punchblock::Command::Reject.new(reason: :busy), error
+            error = Adhearsion::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Reject.new(reason: :busy), error
             expect { subject.reject }.to raise_error error
             sleep 0.2
             expect(subject.alive?).to be true
@@ -1012,7 +1007,7 @@ module Adhearsion
       describe '#redirect' do
         describe "with a target given" do
           it 'should send a Redirect message with the correct target' do
-            expect_message_waiting_for_response Punchblock::Command::Redirect.new(to: 'sip:foo@bar.com')
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Redirect.new(to: 'sip:foo@bar.com')
             subject.redirect 'sip:foo@bar.com'
           end
         end
@@ -1026,7 +1021,7 @@ module Adhearsion
         describe "with no headers" do
           it 'should send a Redirect message' do
             expect_message_waiting_for_response do |c|
-              c.is_a?(Punchblock::Command::Redirect) && c.headers == {}
+              c.is_a?(Adhearsion::Rayo::Command::Redirect) && c.headers == {}
             end
             subject.redirect 'sip:foo@bar.com'
           end
@@ -1036,7 +1031,7 @@ module Adhearsion
           it 'should send a Redirect message with the correct headers' do
             headers = {:foo => 'bar'}
             expect_message_waiting_for_response do |c|
-              c.is_a?(Punchblock::Command::Redirect) && c.headers == headers
+              c.is_a?(Adhearsion::Rayo::Command::Redirect) && c.headers == headers
             end
             subject.redirect 'sip:foo@bar.com', headers
           end
@@ -1044,8 +1039,8 @@ module Adhearsion
 
         context "with a failure response" do
           it 'should raise the error but not crash the actor' do
-            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
-            expect_message_waiting_for_response Punchblock::Command::Redirect.new(to: 'sip:foo@bar.com'), error
+            error = Adhearsion::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Redirect.new(to: 'sip:foo@bar.com'), error
             expect { subject.redirect 'sip:foo@bar.com' }.to raise_error error
             sleep 0.2
             expect(subject.alive?).to be true
@@ -1067,14 +1062,14 @@ module Adhearsion
 
         describe "if the call is active" do
           it "should mark the call inactive" do
-            expect_message_waiting_for_response Punchblock::Command::Hangup.new
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Hangup.new
             subject.hangup
             expect(subject).not_to be_active
           end
 
           describe "with no headers" do
             it 'should send a Hangup message' do
-              expect_message_waiting_for_response Punchblock::Command::Hangup.new
+              expect_message_waiting_for_response Adhearsion::Rayo::Command::Hangup.new
               subject.hangup
             end
           end
@@ -1082,7 +1077,7 @@ module Adhearsion
           describe "with headers set" do
             it 'should send a Hangup message with the correct headers' do
               headers = {:foo => 'bar'}
-              expect_message_waiting_for_response Punchblock::Command::Hangup.new(:headers => headers)
+              expect_message_waiting_for_response Adhearsion::Rayo::Command::Hangup.new(:headers => headers)
               subject.hangup headers
             end
           end
@@ -1090,8 +1085,8 @@ module Adhearsion
 
         context "with a failure response" do
           it 'should raise the error but not crash the actor' do
-            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
-            expect_message_waiting_for_response Punchblock::Command::Hangup.new, error
+            error = Adhearsion::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Hangup.new, error
             expect { subject.hangup }.to raise_error error
             sleep 0.2
             expect(subject.alive?).to be true
@@ -1101,7 +1096,7 @@ module Adhearsion
 
       describe "#join" do
         def expect_join_with_options(options = {})
-          Punchblock::Command::Join.new(options).tap do |join|
+          Adhearsion::Rayo::Command::Join.new(options).tap do |join|
             expect_message_waiting_for_response join
           end
         end
@@ -1129,7 +1124,7 @@ module Adhearsion
           it "should return the command" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
-            expect(result[:command]).to be_a Punchblock::Command::Join
+            expect(result[:command]).to be_a Adhearsion::Rayo::Command::Join
             expect(result[:command].call_uri).to eql(uri)
             expect(result[:command].media).to eql(:bridge)
             expect(result[:command].direction).to eql(:recv)
@@ -1141,7 +1136,7 @@ module Adhearsion
 
             expect(result[:joined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
             expect(result[:joined_condition].wait(0.5)).to be_truthy
           end
 
@@ -1151,10 +1146,10 @@ module Adhearsion
 
             expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
             expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::Unjoined.new(call_uri: uri)
+            subject << Adhearsion::Event::Unjoined.new(call_uri: uri)
             expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
 
@@ -1165,7 +1160,7 @@ module Adhearsion
             expect(result[:joined_condition].wait(0.5)).to be_falsey
             expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::End.new
+            subject << Adhearsion::Event::End.new
             expect(result[:joined_condition].wait(0.5)).to be_truthy
             expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
@@ -1174,18 +1169,18 @@ module Adhearsion
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
 
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
-            subject << Punchblock::Event::Unjoined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Unjoined.new(call_uri: uri)
 
-            subject << Punchblock::Event::End.new
+            subject << Adhearsion::Event::End.new
           end
 
           it "should not error if multiple joined events are received for the same join" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
 
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
 
             expect(subject).to be_alive
           end
@@ -1210,7 +1205,7 @@ module Adhearsion
           it "should return the command" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
-            expect(result[:command]).to be_a Punchblock::Command::Join
+            expect(result[:command]).to be_a Adhearsion::Rayo::Command::Join
             expect(result[:command].call_uri).to eql(uri)
             expect(result[:command].media).to eql(:bridge)
             expect(result[:command].direction).to eql(:recv)
@@ -1222,7 +1217,7 @@ module Adhearsion
 
             expect(result[:joined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
             expect(result[:joined_condition].wait(0.5)).to be_truthy
           end
 
@@ -1232,10 +1227,10 @@ module Adhearsion
 
             expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
             expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::Unjoined.new(call_uri: uri)
+            subject << Adhearsion::Event::Unjoined.new(call_uri: uri)
             expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
 
@@ -1246,7 +1241,7 @@ module Adhearsion
             expect(result[:joined_condition].wait(0.5)).to be_falsey
             expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::End.new
+            subject << Adhearsion::Event::End.new
             expect(result[:joined_condition].wait(0.5)).to be_truthy
             expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
@@ -1255,18 +1250,18 @@ module Adhearsion
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
 
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
-            subject << Punchblock::Event::Unjoined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Unjoined.new(call_uri: uri)
 
-            subject << Punchblock::Event::End.new
+            subject << Adhearsion::Event::End.new
           end
 
           it "should not error if multiple joined events are received for the same join" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target, :media => :bridge, :direction => :recv
 
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
 
             expect(subject).to be_alive
           end
@@ -1292,7 +1287,7 @@ module Adhearsion
           it "should return the command" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
-            expect(result[:command]).to be_a Punchblock::Command::Join
+            expect(result[:command]).to be_a Adhearsion::Rayo::Command::Join
             expect(result[:command].call_uri).to eql(uri)
             expect(result[:command].media).to eql(:bridge)
             expect(result[:command].direction).to eql(:recv)
@@ -1304,7 +1299,7 @@ module Adhearsion
 
             expect(result[:joined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
             expect(result[:joined_condition].wait(0.5)).to be_truthy
           end
 
@@ -1314,10 +1309,10 @@ module Adhearsion
 
             expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
             expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::Unjoined.new(call_uri: uri)
+            subject << Adhearsion::Event::Unjoined.new(call_uri: uri)
             expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
 
@@ -1328,7 +1323,7 @@ module Adhearsion
             expect(result[:joined_condition].wait(0.5)).to be_falsey
             expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::End.new
+            subject << Adhearsion::Event::End.new
             expect(result[:joined_condition].wait(0.5)).to be_truthy
             expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
@@ -1337,18 +1332,18 @@ module Adhearsion
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
 
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
-            subject << Punchblock::Event::Unjoined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Unjoined.new(call_uri: uri)
 
-            subject << Punchblock::Event::End.new
+            subject << Adhearsion::Event::End.new
           end
 
           it "should not error if multiple joined events are received for the same join" do
             expect_join_with_options :call_id => uri, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
 
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
-            subject << Punchblock::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
+            subject << Adhearsion::Event::Joined.new(call_uri: uri)
 
             expect(subject).to be_alive
           end
@@ -1373,7 +1368,7 @@ module Adhearsion
           it "should return the command" do
             expect_join_with_options :mixer_name => mixer_name, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
-            expect(result[:command]).to be_a Punchblock::Command::Join
+            expect(result[:command]).to be_a Adhearsion::Rayo::Command::Join
             expect(result[:command].mixer_name).to eql(mixer_name)
             expect(result[:command].media).to eql(:bridge)
             expect(result[:command].direction).to eql(:recv)
@@ -1385,7 +1380,7 @@ module Adhearsion
 
             expect(result[:joined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::Joined.new(mixer_name: mixer_name)
+            subject << Adhearsion::Event::Joined.new(mixer_name: mixer_name)
             expect(result[:joined_condition].wait(0.5)).to be_truthy
           end
 
@@ -1395,10 +1390,10 @@ module Adhearsion
 
             expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::Joined.new(mixer_name: mixer_name)
+            subject << Adhearsion::Event::Joined.new(mixer_name: mixer_name)
             expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::Unjoined.new(mixer_name: mixer_name)
+            subject << Adhearsion::Event::Unjoined.new(mixer_name: mixer_name)
             expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
 
@@ -1409,7 +1404,7 @@ module Adhearsion
             expect(result[:joined_condition].wait(0.5)).to be_falsey
             expect(result[:unjoined_condition].wait(0.5)).to be_falsey
 
-            subject << Punchblock::Event::End.new
+            subject << Adhearsion::Event::End.new
             expect(result[:joined_condition].wait(0.5)).to be_truthy
             expect(result[:unjoined_condition].wait(0.5)).to be_truthy
           end
@@ -1418,18 +1413,18 @@ module Adhearsion
             expect_join_with_options :mixer_name => mixer_name, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
 
-            subject << Punchblock::Event::Joined.new(mixer_name: mixer_name)
-            subject << Punchblock::Event::Unjoined.new(mixer_name: mixer_name)
+            subject << Adhearsion::Event::Joined.new(mixer_name: mixer_name)
+            subject << Adhearsion::Event::Unjoined.new(mixer_name: mixer_name)
 
-            subject << Punchblock::Event::End.new
+            subject << Adhearsion::Event::End.new
           end
 
           it "should not error if multiple joined events are received for the same join" do
             expect_join_with_options :mixer_name => mixer_name, :media => :bridge, :direction => :recv
             result = subject.join target.merge({:media => :bridge, :direction => :recv})
 
-            subject << Punchblock::Event::Joined.new(mixer_name: mixer_name)
-            subject << Punchblock::Event::Joined.new(mixer_name: mixer_name)
+            subject << Adhearsion::Event::Joined.new(mixer_name: mixer_name)
+            subject << Adhearsion::Event::Joined.new(mixer_name: mixer_name)
 
             expect(subject).to be_alive
           end
@@ -1447,8 +1442,8 @@ module Adhearsion
 
         context "with a failure response" do
           it 'should raise the error but not crash the actor' do
-            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
-            expect_message_waiting_for_response Punchblock::Command::Join.new(call_id: 'footransport:foo@rayo.net'), error
+            error = Adhearsion::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Join.new(call_id: 'footransport:foo@rayo.net'), error
             expect { subject.join 'foo' }.to raise_error error
             sleep 0.2
             expect(subject.alive?).to be true
@@ -1458,7 +1453,7 @@ module Adhearsion
 
       describe "#unjoin" do
         def expect_unjoin_with_options(options = {})
-          Punchblock::Command::Unjoin.new(options).tap do |unjoin|
+          Adhearsion::Rayo::Command::Unjoin.new(options).tap do |unjoin|
             expect_message_waiting_for_response unjoin
           end
         end
@@ -1525,8 +1520,8 @@ module Adhearsion
 
         context "with a failure response" do
           it 'should raise the error but not crash the actor' do
-            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
-            expect_message_waiting_for_response Punchblock::Command::Unjoin.new(call_id: 'footransport:foo@rayo.net'), error
+            error = Adhearsion::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Unjoin.new(call_id: 'footransport:foo@rayo.net'), error
             expect { subject.unjoin 'foo' }.to raise_error error
             sleep 0.2
             expect(subject.alive?).to be true
@@ -1536,14 +1531,14 @@ module Adhearsion
 
       describe "#mute" do
         it 'should send a Mute message' do
-          expect_message_waiting_for_response Punchblock::Command::Mute.new
+          expect_message_waiting_for_response Adhearsion::Rayo::Command::Mute.new
           subject.mute
         end
 
         context "with a failure response" do
           it 'should raise the error but not crash the actor' do
-            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
-            expect_message_waiting_for_response Punchblock::Command::Mute.new, error
+            error = Adhearsion::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Mute.new, error
             expect { subject.mute }.to raise_error error
             sleep 0.2
             expect(subject.alive?).to be true
@@ -1553,14 +1548,14 @@ module Adhearsion
 
       describe "#unmute" do
         it 'should send a Mute message' do
-          expect_message_waiting_for_response Punchblock::Command::Unmute.new
+          expect_message_waiting_for_response Adhearsion::Rayo::Command::Unmute.new
           subject.unmute
         end
 
         context "with a failure response" do
           it 'should raise the error but not crash the actor' do
-            error = Punchblock::ProtocolError.new.setup(:service_unavailable)
-            expect_message_waiting_for_response Punchblock::Command::Unmute.new, error
+            error = Adhearsion::ProtocolError.new.setup(:service_unavailable)
+            expect_message_waiting_for_response Adhearsion::Rayo::Command::Unmute.new, error
             expect { subject.unmute }.to raise_error error
             sleep 0.2
             expect(subject.alive?).to be true
@@ -1604,7 +1599,6 @@ module Adhearsion
           end
           subject.execute_controller BrokenController.new(subject), lambda { |call| latch.countdown! }
           expect(latch.wait(3)).to be true
-          Adhearsion::Events.clear_handlers :exception
         end
 
         it "should execute a callback after the controller executes" do
@@ -1687,13 +1681,13 @@ module Adhearsion
       describe "#terminate" do
         let :commands do
           [
-            Punchblock::Command::Answer.new,
-            Punchblock::Command::Answer.new
+            Adhearsion::Rayo::Command::Answer.new,
+            Adhearsion::Rayo::Command::Answer.new
           ]
         end
 
         it "should set each command's response to an instance of Adhearsion::Hangup if it doesn't already have a response" do
-          finished_command = Punchblock::Command::Answer.new
+          finished_command = Adhearsion::Rayo::Command::Answer.new
           finished_command.request!
           finished_command.response = :foo
           subject << finished_command