adhearsion 2.6.4 → 3.0.0.beta1

data/spec/adhearsion/event/offer_spec.rb

@@ -0,0 +1,106 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Adhearsion::Event::Offer do
+  it 'registers itself' do
+    expect(Adhearsion::Rayo::RayoNode.class_from_registration(:offer, 'urn:xmpp:rayo:1')).to eq(described_class)
+  end
+
+  describe "from a stanza" do
+    let :stanza do
+      <<-MESSAGE
+<offer xmlns='urn:xmpp:rayo:1'
+    to='tel:+18003211212'
+    from='tel:+13058881212'>
+  <!-- Signaling (e.g. SIP) Headers -->
+  <header name="X-skill" value="agent" />
+  <header name="X-customer-id" value="8877" />
+</offer>
+      MESSAGE
+    end
+
+    subject { Adhearsion::Rayo::RayoNode.from_xml parse_stanza(stanza).root, '9f00061', '1' }
+
+    it { is_expected.to be_instance_of described_class }
+
+    it_should_behave_like 'event'
+
+    describe '#to' do
+      subject { super().to }
+      it { is_expected.to eq('tel:+18003211212') }
+    end
+
+    describe '#from' do
+      subject { super().from }
+      it { is_expected.to eq('tel:+13058881212') }
+    end
+
+    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) { '<offer xmlns="urn:xmpp:rayo:1"/>' }
+
+      describe '#headers' do
+        subject { super().headers }
+        it { is_expected.to eq({}) }
+      end
+    end
+
+    context "with multiple headers of the same name" do
+      let :stanza do
+        <<-MESSAGE
+<offer xmlns='urn:xmpp:rayo:1'
+    to='tel:+18003211212'
+    from='tel:+13058881212'>
+  <!-- Signaling (e.g. SIP) Headers -->
+  <header name="X-skill" value="sales" />
+  <header name="X-skill" value="complaints" />
+</offer>
+        MESSAGE
+      end
+
+      describe '#headers' do
+        subject { super().headers }
+        it { is_expected.to eq({'X-skill' => ['sales', 'complaints']}) }
+      end
+    end
+  end
+
+  describe "when setting options in initializer" do
+    subject do
+      described_class.new to:      'tel:+18003211212',
+                          from:    'tel:+13058881212',
+                          headers: { 'X-skill' => 'agent', 'X-customer-id' => '8877' }
+    end
+
+    describe '#to' do
+      subject { super().to }
+      it { is_expected.to eq('tel:+18003211212') }
+    end
+
+    describe '#from' do
+      subject { super().from }
+      it { is_expected.to eq('tel:+13058881212') }
+    end
+
+    describe '#headers' do
+      subject { super().headers }
+      it { is_expected.to eq({ 'X-skill' => 'agent', 'X-customer-id' => '8877' }) }
+    end
+
+    context "with headers set to nil" do
+      subject do
+        described_class.new headers: nil
+      end
+
+      describe '#headers' do
+        subject { super().headers }
+        it { is_expected.to eq({}) }
+      end
+    end
+  end
+end

data/spec/adhearsion/event/ringing_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Adhearsion::Event::Ringing do
+  it 'registers itself' do
+    expect(Adhearsion::Rayo::RayoNode.class_from_registration(:ringing, 'urn:xmpp:rayo:1')).to eq(described_class)
+  end
+
+  describe "from a stanza" do
+    let :stanza do
+      <<-MESSAGE
+<ringing xmlns='urn:xmpp:rayo:1'>
+  <!-- Signaling (e.g. SIP) Headers -->
+  <header name="X-skill" value="agent" />
+  <header name="X-customer-id" value="8877" />
+</ringing>
+      MESSAGE
+    end
+
+    subject { Adhearsion::Rayo::RayoNode.from_xml parse_stanza(stanza).root, '9f00061', '1' }
+
+    it { is_expected.to be_instance_of described_class }
+
+    it_should_behave_like 'event'
+
+    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) { '<ringing 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
+  end
+end

data/spec/adhearsion/event/started_speaking_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Adhearsion::Event::StartedSpeaking do
+  it 'registers itself' do
+    expect(Adhearsion::Rayo::RayoNode.class_from_registration(:'started-speaking', 'urn:xmpp:rayo:1')).to eq(described_class)
+  end
+
+  describe "from a stanza" do
+    let :stanza do
+      '<started-speaking xmlns="urn:xmpp:rayo:1" call-id="x0yz4ye-lx7-6ai9njwvw8nsb"/>'
+    end
+
+    subject { Adhearsion::Rayo::RayoNode.from_xml parse_stanza(stanza).root, '9f00061', '1' }
+
+    it { is_expected.to be_instance_of described_class }
+
+    it_should_behave_like 'event'
+
+    describe '#call_id' do
+      subject { super().call_id }
+      it { is_expected.to eq("x0yz4ye-lx7-6ai9njwvw8nsb") }
+    end
+  end
+
+  describe "when setting options in initializer" do
+    subject do
+      described_class.new :call_id => 'abc123'
+    end
+
+    describe '#call_id' do
+      subject { super().call_id }
+      it { is_expected.to eq('abc123') }
+    end
+  end
+end

data/spec/adhearsion/event/stopped_speaking_spec.rb

@@ -0,0 +1,37 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Adhearsion::Event::StoppedSpeaking do
+  it 'registers itself' do
+    expect(Adhearsion::Rayo::RayoNode.class_from_registration(:'stopped-speaking', 'urn:xmpp:rayo:1')).to eq(described_class)
+  end
+
+  describe "from a stanza" do
+    let :stanza do
+      '<stopped-speaking xmlns="urn:xmpp:rayo:1" call-id="x0yz4ye-lx7-6ai9njwvw8nsb"/>'
+    end
+
+    subject { Adhearsion::Rayo::RayoNode.from_xml parse_stanza(stanza).root, '9f00061', '1' }
+
+    it { is_expected.to be_instance_of described_class }
+
+    it_should_behave_like 'event'
+
+    describe '#call_id' do
+      subject { super().call_id }
+      it { is_expected.to eq("x0yz4ye-lx7-6ai9njwvw8nsb") }
+    end
+  end
+
+  describe "when setting options in initializer" do
+    subject do
+      described_class.new :call_id => 'abc123'
+    end
+
+    describe '#call_id' do
+      subject { super().call_id }
+      it { is_expected.to eq('abc123') }
+    end
+  end
+end

data/spec/adhearsion/event/unjoined_spec.rb

@@ -0,0 +1,48 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Adhearsion::Event::Unjoined do
+  it 'registers itself' do
+    expect(Adhearsion::Rayo::RayoNode.class_from_registration(:unjoined, 'urn:xmpp:rayo:1')).to eq(described_class)
+  end
+
+  describe "from a stanza" do
+    let(:stanza) { '<unjoined xmlns="urn:xmpp:rayo:1" call-uri="b" mixer-name="m" />' }
+
+    subject { Adhearsion::Rayo::RayoNode.from_xml parse_stanza(stanza).root, '9f00061', '1' }
+
+    it { is_expected.to be_instance_of described_class }
+
+    it_should_behave_like 'event'
+
+    describe '#call_uri' do
+      subject { super().call_uri }
+      it { is_expected.to eq('b') }
+    end
+
+    describe '#call_id' do
+      subject { super().call_id }
+      it { is_expected.to eq('b') }
+    end
+
+    describe '#mixer_name' do
+      subject { super().mixer_name }
+      it { is_expected.to eq('m') }
+    end
+  end
+
+  describe "when setting options in initializer" do
+    subject { described_class.new :call_uri => 'abc123', :mixer_name => 'blah' }
+
+    describe '#call_id' do
+      subject { super().call_id }
+      it { is_expected.to eq('abc123') }
+    end
+
+    describe '#mixer_name' do
+      subject { super().mixer_name }
+      it { is_expected.to eq('blah') }
+    end
+  end
+end

data/spec/adhearsion/events_spec.rb

@@ -12,67 +12,52 @@ module Adhearsion
       Events.refresh!
     end
 
-    it "should have a GirlFriday::Queue to handle events" do
-      expect(Events.queue).to be_a GirlFriday::WorkQueue
-    end
-
     it "should allow adding events to the queue and handle them appropriately" do
-      t = nil
-      o = nil
+      e = nil
       latch = CountDownLatch.new 1
 
-      expect(Events.instance).to receive(:handle_message) do |message|
-        t = message.type
-        o = message.object
+      Events.register_handler :event do |event|
+        logger.info "Received an event!"
+        e = event
         latch.countdown!
       end
 
       Events.trigger :event, :foo
 
       expect(latch.wait(2)).to be_truthy
-      expect(t).to eq(:event)
-      expect(o).to eq(:foo)
+      expect(e).to eq(:foo)
     end
 
     it "should allow executing events immediately" do
-      t = nil
-      o = nil
+      e = nil
 
-      expect(Events.instance).to receive(:handle_message) do |message|
+      Events.register_handler :event do |event|
         sleep 0.25
-        t = message.type
-        o = message.object
+        e = event
       end
 
       Events.trigger_immediately :event, :foo
 
-      expect(t).to eq(:event)
-      expect(o).to eq(:foo)
+      expect(e).to eq(:foo)
     end
 
-    it "should handle events using registered guarded handlers" do
-      result = nil
+    it "should handle exceptions in event processing by raising the exception as an event" do
+      e = nil
+      latch = CountDownLatch.new 1
 
-      Events.register_handler :event, EventClass do |event|
-        result = :foo
+      Events.register_handler :exception do |event|
+        e = event
+        latch.countdown!
       end
 
-      Events.trigger_immediately :event, EventClass.new
-
-      expect(result).to eq(:foo)
-
-      Events.clear_handlers :event, EventClass
-    end
-
-    it "should handle exceptions in event processing by raising the exception as an event" do
-      expect(Events.instance).to receive(:trigger).with(:exception, kind_of(ExceptionClass)).once
-
       Events.register_handler :event, EventClass do |event|
         raise ExceptionClass
       end
 
       Events.trigger_immediately :event, EventClass.new
-      Events.clear_handlers :event, EventClass
+
+      expect(latch.wait(2)).to be_truthy
+      expect(e).to be_a(ExceptionClass)
     end
 
     it "should implicitly pass on all handlers" do
@@ -89,16 +74,6 @@ module Adhearsion
       Events.trigger_immediately :event, EventClass.new
 
       expect(result).to eq(:bar)
-
-      Events.clear_handlers :event, EventClass
-    end
-
-    it "should respond_to? any methods corresponding to classes for which handlers are defined" do
-      Events.register_handler :event_type_1 do |event|
-      end
-
-      expect(Events).to respond_to(:event_type_1)
-      expect(Events).not_to respond_to(:event_type_2)
     end
 
     describe '#draw' do
@@ -106,6 +81,7 @@ module Adhearsion
         result = nil
         Events.draw do
           event do
+            logger.info "Got an event!"
             result = :foo
           end
         end
@@ -113,8 +89,6 @@ module Adhearsion
         Events.trigger_immediately :event
 
         expect(result).to eq(:foo)
-
-        Events.clear_handlers :event
       end
     end
 

data/spec/adhearsion/initializer_spec.rb

@@ -18,7 +18,7 @@ describe Adhearsion::Initializer do
     end
 
     after do
-      Adhearsion::Events.reinitialize_queue!
+      Adhearsion::Events.refresh!
     end
 
     after :all do
@@ -40,115 +40,24 @@ describe Adhearsion::Initializer do
       end
     end
 
-    it "should create a pid file in the app's path when given 'true' as the pid_file hash key argument" do
-      stub_behavior_for_initializer_with_no_path_changing_behavior do
-        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
-        ahn = Adhearsion::Initializer.start :pid_file => true
-        expect(ahn.pid_file[0, path.length]).to eq(path)
-      end
-    end
-
-    it "should NOT create a pid file in the app's path when given 'false' as the pid_file hash key argument" do
-      stub_behavior_for_initializer_with_no_path_changing_behavior do
-        ahn = Adhearsion::Initializer.start :pid_file => false
-        expect(ahn.pid_file).to be nil
-      end
-    end
-
-    it "should create a pid file in the app's path by default when daemonizing" do
-      stub_behavior_for_initializer_with_no_path_changing_behavior do
-        expect(Adhearsion::CustomDaemonizer).to receive(:daemonize).and_yield '123'
-        expect(File).to receive(:open).once.with(File.join(path, 'adhearsion.pid'), 'w')
-        ahn = Adhearsion::Initializer.start :mode => :daemon
-        expect(ahn.pid_file[0, path.size]).to eq(path)
-      end
-    end
-
-    it "should NOT create a pid file in the app's path when daemonizing and :pid_file is given as false" do
-      stub_behavior_for_initializer_with_no_path_changing_behavior do
-        expect(Adhearsion::CustomDaemonizer).to receive(:daemonize).and_yield '123'
-        ahn = Adhearsion::Initializer.start :mode => :daemon, :pid_file => false
-        expect(ahn.pid_file).to be nil
-      end
-    end
-
-    it "should create a designated pid file when supplied a String path as :pid_file" do
-      random_file = "/tmp/AHN_TEST_#{rand 100000}.pid"
-      stub_behavior_for_initializer_with_no_path_changing_behavior do
-        ahn = Adhearsion::Initializer.start :pid_file => random_file
-        expect(ahn.pid_file).to eq(random_file)
-        expect(File.exists?(random_file)).to be true
-        File.delete random_file
-      end
-    end
-
-    it "should resolve the log file path to daemonize" do
-      stub_behavior_for_initializer_with_no_path_changing_behavior do
-        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
-        ahn = Adhearsion::Initializer.start :pid_file => true
-        expect(ahn.resolve_log_file_path).to eq(path + Adhearsion.config.platform.logging.outputters[0])
-      end
-    end
-
-    it "should resolve the log file path to daemonize when outputters is an Array" do
-      Adhearsion.config.platform.logging.outputters = ["log/my_application.log", "log/adhearsion.log"]
-      stub_behavior_for_initializer_with_no_path_changing_behavior do
-        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
-        ahn = Adhearsion::Initializer.start :pid_file => true
-        expect(ahn.resolve_log_file_path).to eq(path + Adhearsion.config.platform.logging.outputters[0])
-      end
-    end
-
-    it "should return a valid appenders array" do
-      stub_behavior_for_initializer_with_no_path_changing_behavior do
-        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
-        ahn = Adhearsion::Initializer.start :pid_file => true
-        appenders = ahn.init_get_logging_appenders
-        expect(appenders.size).to eq(2)
-        expect(appenders[1]).to be_instance_of Logging::Appenders::Stdout
-      end
-    end
-
-    it "should initialize properly the log paths" do
-      ahn = stub_behavior_for_initializer_with_no_path_changing_behavior do
-        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
-        Adhearsion::Initializer.start :pid_file => true
-      end
-      expect(Dir).to receive(:mkdir).with("log/")
-      ahn.initialize_log_paths
-    end
-
-    it "should initialize properly the log paths when outputters is an array" do
-      Adhearsion.config.platform.logging.outputters = ["log/my_application.log", "log/test/adhearsion.log"]
-      ahn = stub_behavior_for_initializer_with_no_path_changing_behavior do
-        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
-        Adhearsion::Initializer.start :pid_file => true
-      end
-      expect(Dir).to receive(:mkdir).with("log/").twice
-      expect(Dir).to receive(:mkdir).with("log/test/").once
-      ahn.initialize_log_paths
-    end
-
     it "should set the adhearsion proc name" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
-        expect(Adhearsion::LinuxProcName).to receive(:set_proc_name).with(Adhearsion.config.platform.process_name)
-        Adhearsion::Initializer.start :pid_file => true
+        expect(Adhearsion::LinuxProcName).to receive(:set_proc_name).with(Adhearsion.config.core.process_name)
+        Adhearsion::Initializer.start
       end
     end
 
     it "should update the adhearsion proc name" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        Adhearsion::Initializer.start :pid_file => true
+        Adhearsion::Initializer.start
       end
-      expect($0).to eq(Adhearsion.config.platform.process_name)
+      expect($0).to eq(Adhearsion.config.core.process_name)
     end
   end
 
   describe "Initializing logger" do
     before do
       ::Logging.reset
-      expect(::Logging::Appenders).to receive(:file).and_return(nil)
       Adhearsion.config = nil
     end
 
@@ -156,21 +65,20 @@ describe Adhearsion::Initializer do
       ::Logging.reset
       Adhearsion::Logging.start
       Adhearsion::Logging.silence!
-      Adhearsion::Events.reinitialize_queue!
+      Adhearsion::Events.refresh!
     end
 
     it "should start logging with valid parameters" do
       stub_behavior_for_initializer_with_no_path_changing_behavior do
-        expect(File).to receive(:open).with(File.join(path, 'adhearsion.pid'), 'w').at_least(:once)
-        expect(Adhearsion::Logging).to receive(:start).once.with(kind_of(Array), :info, nil).and_return('')
-        Adhearsion::Initializer.start :pid_file => true
+        expect(Adhearsion::Logging).to receive(:start).once.with(:info, nil).and_return('')
+        Adhearsion::Initializer.start
       end
     end
   end
 
   describe "#load_lib_folder" do
     before do
-      Adhearsion.ahn_root = path
+      Adhearsion.root = path
     end
 
     it "should load the contents of lib directory" do
@@ -179,100 +87,20 @@ describe Adhearsion::Initializer do
     end
 
     it "should return false if folder does not exist" do
-      Adhearsion.config.platform.lib = "my_random_lib_directory"
+      Adhearsion.config.core.lib = "my_random_lib_directory"
       expect(Adhearsion::Initializer.new.load_lib_folder).to eq(false)
     end
 
     it "should return false and not load any file if config folder is set to nil" do
-      Adhearsion.config.platform.lib = nil
+      Adhearsion.config.core.lib = nil
       expect(Adhearsion::Initializer.new.load_lib_folder).to eq(false)
     end
 
     it "should load the contents of the preconfigured directory" do
-      Adhearsion.config.platform.lib = "foo"
+      Adhearsion.config.core.lib = "foo"
       allow(File).to receive_messages directory?: true
       expect(Dir).to receive(:chdir).with(File.join(path, "foo")).and_return []
       Adhearsion::Initializer.new.load_lib_folder
     end
   end
 end
-
-describe "Updating RAILS_ENV variable" do
-  include InitializerStubs
-
-  before do
-    ::Logging.reset
-    expect(Adhearsion::Logging).to receive(:start).once.and_return('')
-    expect(::Logging::Appenders).to receive(:file).and_return(nil)
-    Adhearsion.config = nil
-  end
-
-  before do
-    ENV['RAILS_ENV'] = nil
-    ENV['AHN_ENV'] = nil
-  end
-
-  after :all do
-    ENV['RAILS_ENV'] = nil
-    ENV['AHN_ENV'] = nil
-  end
-
-  describe "when neither RAILS_ENV nor AHN_ENV are set" do
-    [:development, :production, :staging, :test].each do |env|
-      it "should set the RAILS_ENV to #{env.to_s} when Adhearsion environment is set to #{env.to_s}" do
-        ahn = nil
-        stub_behavior_for_initializer_with_no_path_changing_behavior do
-          Adhearsion.config.platform.environment = env
-          ahn = Adhearsion::Initializer.start
-        end
-        ahn.update_rails_env_var
-        expect(ENV['RAILS_ENV']).to eq(env.to_s)
-      end
-    end
-  end
-
-  context "when RAILS_ENV is set" do
-    before do
-      ENV['RAILS_ENV'] = "test"
-    end
-
-    context "if AHN_ENV is set" do
-      it "should preserve the RAILS_ENV value" do
-        ENV['AHN_ENV'] = "production"
-        ahn = nil
-        stub_behavior_for_initializer_with_no_path_changing_behavior do
-          ahn = Adhearsion::Initializer.start
-        end
-        ahn.update_rails_env_var
-        expect(ENV['RAILS_ENV']).to eq("test")
-      end
-    end
-
-    context "if AHN_ENV is unset" do
-      it "should preserve the RAILS_ENV value" do
-        ahn = nil
-        stub_behavior_for_initializer_with_no_path_changing_behavior do
-          ahn = Adhearsion::Initializer.start
-        end
-        ahn.update_rails_env_var
-        expect(ENV['RAILS_ENV']).to eq("test")
-      end
-    end
-  end
-
-  context "when RAILS_ENV is unset and AHN_ENV is set" do
-    before do
-      ENV['AHN_ENV'] = "production"
-    end
-
-    it "should define the RAILS_ENV value with the AHN_ENV value" do
-      ahn = nil
-      stub_behavior_for_initializer_with_no_path_changing_behavior do
-        ahn = Adhearsion::Initializer.start
-      end
-      ahn.update_rails_env_var
-      expect(ENV['RAILS_ENV']).to eq("production")
-    end
-  end
-
-end