adhearsion 2.6.4 → 3.0.0.beta1

data/spec/adhearsion/logging_spec.rb

@@ -57,18 +57,8 @@ describe Adhearsion::Logging do
     expect(::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::Stdout)}.length).to eql(1)
   end
 
-  it "initializes properly a Logging object with appenders as parameter" do
-    Adhearsion::Logging.start([::Logging.appenders.stdout, ::Logging.appenders.file('example.log')])
-    expect(::Logging.logger.root.appenders.length).to eql(2)
-    expect(::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::Stdout)}.length).to eql(1)
-    expect(::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::File)}.length).to eql(1)
-  end
-
-  it "initializes properly a Logging object with appenders and log level as parameter" do
-    Adhearsion::Logging.start([::Logging.appenders.stdout, ::Logging.appenders.file('example.log')], :debug)
-    expect(::Logging.logger.root.appenders.length).to eql(2)
-    expect(::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::Stdout)}.length).to eql(1)
-    expect(::Logging.logger.root.appenders.select{|a| a.is_a?(::Logging::Appenders::File)}.length).to eql(1)
+  it "initializes properly a Logging object with log level as parameter" do
+    Adhearsion::Logging.start(:debug)
     expect(::Logging.logger.root.level).to eql(::Logging::LEVELS["debug"])
   end
 
@@ -85,20 +75,15 @@ describe Adhearsion::Logging do
     expect(_foo_logger.object_id).not_to eql(_bar_logger)
   end
 
-  it 'should reopen logfiles' do
-    expect(::Logging).to receive(:reopen).once
-    Adhearsion::Logging.reopen_logs
-  end
-
   it 'should toggle between :trace and the configured log level' do
-    orig_level = Adhearsion.config.platform.logging['level']
-    Adhearsion.config.platform.logging['level'] = :warn
+    orig_level = Adhearsion.config.core.logging['level']
+    Adhearsion.config.core.logging['level'] = :warn
     Adhearsion::Logging.level = :warn
     Adhearsion::Logging.toggle_trace!
     expect(Adhearsion::Logging.level).to eq(0)
     Adhearsion::Logging.toggle_trace!
     expect(Adhearsion::Logging.level).to eq(3)
-    Adhearsion.config.platform.logging['level'] = orig_level
+    Adhearsion.config.core.logging['level'] = orig_level
   end
 
   describe 'level changing' do

data/spec/adhearsion/outbound_call_spec.rb

@@ -16,10 +16,10 @@ module Adhearsion
       it { is_expected.to eq({}) }
     end
 
-    let(:mock_client) { double 'Punchblock Client', execute_command: true, new_call_uri: call_uri }
+    let(:mock_client) { double 'Rayo Client', execute_command: true, new_call_uri: call_uri }
 
     before do
-      PunchblockPlugin::Initializer.client = mock_client
+      Adhearsion::Rayo::Initializer.client = mock_client
       Adhearsion.active_calls.clear
     end
 
@@ -67,7 +67,7 @@ module Adhearsion
 
         expect(Adhearsion.router).to receive(:handle).once.with(mock_call)
 
-        OutboundCall.originate(to) << Punchblock::Event::Answered.new
+        OutboundCall.originate(to) << Adhearsion::Event::Answered.new
       end
 
       context "when a controller class is specified for the call" do
@@ -77,7 +77,7 @@ module Adhearsion
           expect(mock_call).to receive(:dial).once.with(to, {})
           expect(mock_call).to receive(:execute_controller).once.with kind_of(controller), kind_of(Proc)
           call = OutboundCall.originate to, :controller => controller
-          call << Punchblock::Event::Answered.new
+          call << Adhearsion::Event::Answered.new
         end
 
         it "should hangup the call after all controllers have executed" do
@@ -85,7 +85,7 @@ module Adhearsion
           expect(mock_call).to receive(:hangup).once
 
           call = OutboundCall.originate to, :controller => controller
-          call << Punchblock::Event::Answered.new
+          call << Adhearsion::Event::Answered.new
           sleep 0.5
         end
 
@@ -95,7 +95,7 @@ module Adhearsion
             expected_controller = controller.new mock_call, foo: 'bar'
             expect(mock_call).to receive(:execute_controller).with(expected_controller, kind_of(Proc)).once
             call = OutboundCall.originate to, :controller => controller, :controller_metadata => {:foo => 'bar'}
-            call << Punchblock::Event::Answered.new
+            call << Adhearsion::Event::Answered.new
           end
         end
       end
@@ -110,14 +110,14 @@ module Adhearsion
           call = OutboundCall.originate to do
             :foobar
           end
-          call << Punchblock::Event::Answered.new
+          call << Adhearsion::Event::Answered.new
         end
       end
 
       context "when the dial fails" do
         before do
           expect(subject.wrapped_object).to receive(:write_command)
-          expect_any_instance_of(Punchblock::Command::Dial).to receive(:response).and_return StandardError.new("User not registered")
+          expect_any_instance_of(Adhearsion::Rayo::Command::Dial).to receive(:response).and_return StandardError.new("User not registered")
         end
 
         after do
@@ -140,7 +140,7 @@ module Adhearsion
       let(:response) { double 'Response' }
 
       describe "for answered events" do
-        let(:event) { Punchblock::Event::Answered.new }
+        let(:event) { Adhearsion::Event::Answered.new }
 
         it "should trigger any on_answer callbacks set" do
           expect(response).to receive(:call).once.with(event)
@@ -173,12 +173,12 @@ module Adhearsion
       def expect_message_waiting_for_response(message, uri = call_uri)
         expect(subject.wrapped_object).to receive(:write_and_await_response).once.with(message, 60, true) do |real_message|
           real_message.request!
-          real_message.response = Punchblock::Ref.new(uri: uri)
+          real_message.response = Adhearsion::Rayo::Ref.new(uri: uri)
           real_message
         end
       end
 
-      let(:expected_dial_command) { Punchblock::Command::Dial.new(:to => to, :from => from, :uri => call_uri) }
+      let(:expected_dial_command) { Adhearsion::Rayo::Command::Dial.new(:to => to, :from => from, :uri => call_uri) }
 
       context "while waiting for a response" do
         before do
@@ -221,7 +221,7 @@ module Adhearsion
 
         it "should set the dial command" do
           subject.dial to, :from => from
-          expect(subject.dial_command).to eq(Punchblock::Command::Dial.new(:to => to, :from => from, :uri => call_uri, target_call_id: call_id, domain: domain, transport: transport))
+          expect(subject.dial_command).to eq(Adhearsion::Rayo::Command::Dial.new(:to => to, :from => from, :uri => call_uri, target_call_id: call_id, domain: domain, transport: transport))
         end
 
         it "should set the URI from the reference" do
@@ -296,7 +296,7 @@ module Adhearsion
       context "when the dial fails" do
         before do
           expect(subject.wrapped_object).to receive(:write_command)
-          expect_any_instance_of(Punchblock::Command::Dial).to receive(:response).and_return StandardError.new("User not registered")
+          expect_any_instance_of(Adhearsion::Rayo::Command::Dial).to receive(:response).and_return StandardError.new("User not registered")
         end
 
         after do

data/spec/adhearsion/plugin_spec.rb

@@ -12,7 +12,7 @@ describe Adhearsion::Plugin do
   end
 
   before do
-    allow(Adhearsion::PunchblockPlugin::Initializer).to receive_messages :start => true
+    allow(Adhearsion::Rayo::Initializer).to receive_messages :start => true
   end
 
   describe "inheritance" do
@@ -147,8 +147,7 @@ describe Adhearsion::Plugin do
       it "should do nothing with a Plugin that has no init method call" do
         FooBar = Class.new Adhearsion::Plugin
 
-        # 1 => Punchblock. Must be empty once punchblock initializer is an external Plugin
-        expect(Adhearsion::Plugin.initializers.size).to eq(1)
+        expect(Adhearsion::Plugin.initializers.size).to eq(0)
         Adhearsion::Plugin.init_plugins
       end
 
@@ -243,7 +242,7 @@ describe Adhearsion::Plugin do
       it "should do nothing with a Plugin that has no run method call" do
         FooBar = Class.new Adhearsion::Plugin
 
-        # May become 1 if Punchblock defines a runner.
+        # May become 1 if Rayo defines a runner.
         expect(Adhearsion::Plugin.runners.size).to eq(0)
         Adhearsion::Plugin.run_plugins
       end

data/spec/adhearsion/protocol_error_spec.rb

@@ -0,0 +1,91 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Adhearsion::ProtocolError do
+  let(:name)          { :item_not_found }
+  let(:text)          { 'Could not find call [id=f6d437f4-1e18-457b-99f8-b5d853f50347]' }
+  let(:call_id)       { 'f6d437f4-1e18-457b-99f8-b5d853f50347' }
+  let(:component_id)  { 'abc123' }
+  subject { described_class.new.setup name, text, call_id, component_id }
+
+  describe '#inspect' do
+    subject { super().inspect }
+    it { is_expected.to eq('#<Adhearsion::ProtocolError: name=:item_not_found text="Could not find call [id=f6d437f4-1e18-457b-99f8-b5d853f50347]" call_id="f6d437f4-1e18-457b-99f8-b5d853f50347" component_id="abc123">') }
+  end
+
+  describe ".exception" do
+    context "with no arguments" do
+      it "returns the original object" do
+        expect(described_class.exception).to eq(described_class.new)
+      end
+    end
+
+    context "with self as the argument" do
+      it "returns the original object" do
+        expect(described_class.exception(subject)).to eq(described_class.new(subject.to_s))
+      end
+    end
+
+    context "with other values" do
+      it "returns a new object with the appropriate values" do
+        e = described_class.exception 'FooBar'
+        expect(e.name).to eq(nil)
+        expect(e.text).to eq(nil)
+        expect(e.call_id).to eq(nil)
+        expect(e.component_id).to eq(nil)
+      end
+    end
+  end
+
+  describe "#exception" do
+    context "with no arguments" do
+      it "returns the original object" do
+        expect(subject.exception).to be subject
+      end
+    end
+
+    context "with self as the argument" do
+      it "returns the original object" do
+        expect(subject.exception(subject)).to be subject
+      end
+    end
+
+    context "with other values" do
+      it "returns a new object with the appropriate values" do
+        e = subject.exception("Boo")
+        expect(e.name).to eq(name)
+        expect(e.text).to eq(text)
+        expect(e.call_id).to eq(call_id)
+        expect(e.component_id).to eq(component_id)
+      end
+    end
+  end
+
+  describe "comparison" do
+    context "with the same name, text, call ID and component ID" do
+      let(:comparison) { described_class.new.setup name, text, call_id, component_id }
+      it { is_expected.to eq(comparison) }
+    end
+
+    context "with a different name" do
+      let(:comparison) { described_class.new.setup :foo, text, call_id, component_id }
+      it { is_expected.not_to eq(comparison) }
+    end
+
+    context "with a different text" do
+      let(:comparison) { described_class.new.setup name, 'foo', call_id, component_id }
+      it { is_expected.not_to eq(comparison) }
+    end
+
+    context "with a different call ID" do
+      let(:comparison) { described_class.new.setup name, text, 'foo', component_id }
+      it { is_expected.not_to eq(comparison) }
+    end
+
+    context "with a different component ID" do
+      let(:comparison) { described_class.new.setup name, text, call_id, 'foo' }
+      it { is_expected.not_to eq(comparison) }
+    end
+  end
+end

data/spec/adhearsion/rayo/client/component_registry_spec.rb

@@ -0,0 +1,26 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+module Adhearsion
+  module Rayo
+    class Client
+      describe ComponentRegistry do
+        let(:uri)       { 'abc123' }
+        let(:component) { double 'Component', source_uri: uri }
+
+        it 'should store components and allow lookup by ID' do
+          subject << component
+          expect(subject.find_by_uri(uri)).to be component
+        end
+
+        it 'should allow deletion of components' do
+          subject << component
+          expect(subject.find_by_uri(uri)).to be component
+          subject.delete component
+          expect(subject.find_by_uri(uri)).to be_nil
+        end
+      end
+    end
+  end
+end

data/spec/adhearsion/rayo/client_spec.rb

@@ -0,0 +1,134 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Adhearsion::Rayo::Client do
+  let(:connection) { Adhearsion::Rayo::Connection::XMPP.new :username => '1@call.rayo.net', :password => 1 }
+
+  subject { described_class.new :connection => connection }
+
+  describe '#connection' do
+    subject { super().connection }
+    it { is_expected.to be connection }
+  end
+
+  describe '#component_registry' do
+    subject { super().component_registry }
+    it { is_expected.to be_a described_class::ComponentRegistry }
+  end
+
+  let(:call_id)         { 'abc123' }
+  let(:mock_event)      { double('Event').as_null_object }
+  let(:component_id)    { 'abc123' }
+  let(:component_uri)   { 'callid@server/abc123' }
+  let(:mock_component)  { double 'Component', source_uri: component_uri }
+  let(:mock_command)    { double 'Command' }
+
+  describe '#run' do
+    it 'should start up the connection' do
+      expect(connection).to receive(:run).once
+      subject.run
+    end
+  end
+
+  describe '#stop' do
+    it 'should stop the connection' do
+      expect(connection).to receive(:stop).once
+      subject.stop
+    end
+  end
+
+  describe '#send_message' do
+    it 'should send a message' do
+      args = [ "someone", "example.org", "Hello World!" ]
+      expect(connection).to receive(:send_message).with(*args).once
+      subject.send_message *args
+    end
+  end
+
+  describe '#new_call_uri' do
+    it 'should return the connection-specific fresh call ID' do
+      stub_uuids 'foobar'
+      expect(subject.new_call_uri).to eq('xmpp:foobar@call.rayo.net')
+    end
+  end
+
+  it 'should handle connection events' do
+    expect(subject).to receive(:handle_event).with(mock_event).once
+    connection.event_handler.call mock_event
+  end
+
+  describe '#handle_event' do
+    it "sets the event's client" do
+      event = Adhearsion::Event::Offer.new
+      subject.handle_event event
+      expect(event.client).to be subject
+    end
+
+    context 'if the event can be associated with a source component' do
+      before do
+        allow(mock_event).to receive_messages :source => mock_component
+        expect(mock_component).to receive(:add_event).with mock_event
+      end
+
+      it 'should not call event handlers' do
+        handler = double 'handler'
+        expect(handler).to receive(:call).never
+        subject.register_event_handler do |event|
+          handler.call event
+        end
+        subject.handle_event mock_event
+      end
+    end
+
+    context 'if the event cannot be associated with a source component' do
+      before do
+        allow(mock_event).to receive_messages :source => nil
+      end
+
+      it 'should call registered event handlers' do
+        handler = double 'handler'
+        expect(handler).to receive(:call).once.with mock_event
+        subject.register_event_handler do |event|
+          handler.call event
+        end
+        subject.handle_event mock_event
+      end
+    end
+  end
+
+  it 'should be able to register and retrieve components' do
+    subject.register_component mock_component
+    expect(subject.find_component_by_uri(component_uri)).to be mock_component
+  end
+
+  describe '#execute_command' do
+    let(:component) { Adhearsion::Rayo::Component::Output.new }
+    let(:event)     { Adhearsion::Event::Complete.new }
+
+    before do
+      expect(connection).to receive(:write).once.with component, :call_id => call_id
+    end
+
+    let :execute_command do
+      subject.execute_command component, :call_id => call_id
+    end
+
+    it 'should write the command to the connection' do
+      execute_command
+    end
+
+    it "should set the command's client" do
+      execute_command
+      expect(component.client).to be subject
+    end
+
+    it "should handle a component's events" do
+      expect(subject).to receive(:trigger_handler).with(:event, event).once
+      execute_command
+      component.request!
+      component.execute!
+      component.add_event event
+    end
+  end
+end

data/spec/adhearsion/rayo/command/accept_spec.rb

@@ -0,0 +1,63 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Adhearsion::Rayo::Command::Accept do
+  it 'registers itself' do
+    expect(Adhearsion::Rayo::RayoNode.class_from_registration(:accept, 'urn:xmpp:rayo:1')).to eq(described_class)
+  end
+
+  describe "from a stanza" do
+    let(:stanza) do
+      <<-STANZA
+        <accept xmlns="urn:xmpp:rayo:1">
+          <header name="X-skill" value="agent" />
+          <header name="X-customer-id" value="8877" />
+        </accept>
+      STANZA
+    end
+
+    subject { Adhearsion::Rayo::RayoNode.from_xml parse_stanza(stanza).root, '9f00061', '1' }
+
+    it { is_expected.to be_instance_of described_class }
+
+    describe '#headers' do
+      subject { super().headers }
+      it { is_expected.to eq({ 'X-skill' => 'agent', 'X-customer-id' => '8877' }) }
+    end
+
+    context "with no headers provided" do
+      let(:stanza) { '<accept xmlns="urn:xmpp:rayo:1"/>' }
+
+      describe '#headers' do
+        subject { super().headers }
+        it { is_expected.to eq({}) }
+      end
+    end
+  end
+
+  describe "when setting options in initializer" do
+    subject { described_class.new headers: { 'X-skill' => 'agent', 'X-customer-id' => '8877' } }
+
+    describe '#headers' do
+      subject { super().headers }
+      it { is_expected.to eq({ 'X-skill' => 'agent', 'X-customer-id' => '8877' }) }
+    end
+
+    describe "exporting to Rayo" do
+      it "should export to XML that can be understood by its parser" do
+        new_instance = Adhearsion::Rayo::RayoNode.from_xml subject.to_rayo
+        expect(new_instance).to be_instance_of described_class
+        expect(new_instance.headers).to eq({ 'X-skill' => 'agent', 'X-customer-id' => '8877' })
+      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)
+        expect(rayo_doc).to eq(parent)
+      end
+    end
+  end
+end