adhearsion 2.6.4 → 3.0.0.beta1

data/spec/adhearsion/calls_spec.rb

@@ -12,7 +12,7 @@ module Adhearsion
     end
 
     def new_offer(call_id = nil, headers = {})
-      Punchblock::Event::Offer.new domain: 'example.com', transport: 'xmpp', :target_call_id => call_id || random_call_id, :headers => headers
+      Adhearsion::Event::Offer.new domain: 'example.com', transport: 'xmpp', :target_call_id => call_id || random_call_id, :headers => headers
     end
 
     it 'can add a call to the collection' do
@@ -155,8 +155,8 @@ module Adhearsion
 
       it "is sends a hangup command for the call" do
         call_id = call.id
-        allow(PunchblockPlugin).to receive_messages :client => double('Client')
-        expect(PunchblockPlugin.client).to receive(:execute_command).once.with(Punchblock::Command::Hangup.new, :async => true, :call_id => call_id)
+        allow(Adhearsion).to receive_messages :client => double('Client')
+        expect(Adhearsion.client).to receive(:execute_command).once.with(Adhearsion::Rayo::Command::Hangup.new, :async => true, :call_id => call_id)
 
         subject << call
 

data/spec/adhearsion/configuration_spec.rb

@@ -10,31 +10,31 @@ describe Adhearsion::Configuration do
       Adhearsion::Configuration.new
     end
 
-    it "should have an empty configuration for the platform" do
-      expect(subject).to respond_to :platform
+    it "should have an empty configuration for the core" do
+      expect(subject).to respond_to :core
     end
 
-    it "should have a platform configuration object" do
-      expect(subject.platform).to be_instance_of Loquacious::Configuration
+    it "should have a core configuration object" do
+      expect(subject.core).to be_instance_of Loquacious::Configuration
     end
 
     it "should initialize root to nil" do
-      expect(subject.platform.root).to be_nil
+      expect(subject.core.root).to be_nil
     end
 
     it "should initialize logging to level info" do
-      expect(subject.platform.logging.level).to eq(:info)
+      expect(subject.core.logging.level).to eq(:info)
     end
 
     it "should allow to update a config value" do
-      expect(subject.platform.environment).to eq(:development)
-      subject.platform.environment = :production
-      expect(subject.platform.environment).to eq(:production)
+      expect(subject.core.logging.level).to eq(:info)
+      subject.core.logging.level = :error
+      expect(subject.core.logging.level).to eq(:error)
     end
 
     it "should allow to create new config values" do
-      subject.platform.bar = "foo"
-      expect(subject.platform.bar).to eq("foo")
+      subject.core.bar = "foo"
+      expect(subject.core.bar).to eq("foo")
     end
   end
 
@@ -42,31 +42,26 @@ describe Adhearsion::Configuration do
     subject do
       Adhearsion::Configuration.new do
         root "foo", :desc => "Adhearsion application root folder"
-        environment :development, :desc => "Active environment. Supported values: development, production, staging, test"
       end
     end
 
     it "should return the root value" do
-      expect(subject.platform.root).to eq("foo")
+      expect(subject.core.root).to eq("foo")
     end
 
-    it "should return the environment value" do
-      expect(subject.platform.environment).to eq(:development)
-    end
-
-    it "should return a description for the platform configuration" do
-      expect(Adhearsion.config.description(:platform)).to be_instance_of String
+    it "should return a description for the core configuration" do
+      expect(Adhearsion.config.description(:core)).to be_instance_of String
     end
 
     it "should allow to update a config value" do
-      expect(subject.platform.environment).to eq(:development)
-      subject.platform.environment = :production
-      expect(subject.platform.environment).to eq(:production)
+      expect(subject.core.root).to eq("foo")
+      subject.core.root = "bar"
+      expect(subject.core.root).to eq("bar")
     end
 
     it "should allow to create new config values" do
-      subject.platform.bar = "bazz"
-      expect(subject.platform.bar).to eq("bazz")
+      subject.core.bar = "bazz"
+      expect(subject.core.bar).to eq("bazz")
     end
   end
 
@@ -78,64 +73,61 @@ describe Adhearsion::Configuration do
     end
   end
 
-  describe "when accessing the platform configuration" do
+  describe "when accessing the core configuration" do
     after do
       Adhearsion.config = nil
     end
 
-    subject{ Adhearsion.config[:platform] }
+    subject{ Adhearsion.config[:core] }
 
-    it "should return the valid platform configuration object" do
+    it "should return the valid core configuration object" do
       expect(subject).to be_instance_of ::Loquacious::Configuration
     end
 
-    it "should allow to retrieve any platform configuration value" do
-      expect(subject.environment).to eq(:development)
+    it "should allow to retrieve any core configuration value" do
+      expect(subject.type).to eq(:xmpp)
     end
 
     describe "if configuration has a named environment" do
+      let(:env) { :development }
 
-      let :config_obj do
-        Adhearsion::Configuration.new
-      end
-
-      let :env_values do
-        config_obj.valid_environments.inject({}) do |hash, k|
-          hash[k] = hash.keys.length
-          hash
-        end
-      end
-
-      let :config_object do
-        config_obj do
+      subject do
+        Adhearsion::Configuration.new env do
           my_level(-1, :desc => "An index to check the environment value is being retrieved")
         end
       end
 
-      subject do
-        config_object.production do |env|
-          env.platform.my_level = 0
+      before do
+        subject.production do |env|
+          env.core.my_level = 0
         end
-        config_object.development do |env|
-          env.platform.my_level = 1
+        subject.development do |env|
+          env.core.my_level = 1
         end
-        config_object.staging do |env|
-          env.platform.my_level = 2
+        subject.staging do |env|
+          env.core.my_level = 2
         end
-        config_object.test do |env|
-          env.platform.my_level = 3
+        subject.test do |env|
+          env.core.my_level = 3
         end
-        config_object
       end
 
       it "should return by default the development value" do
-        expect(subject.platform.my_level).to eq(1)
+        expect(subject.core.my_level).to eq(1)
       end
 
-      [:staging, :production, :test].each do |env|
-        it "should return the #{env.to_s} value when environment set to #{env.to_s}" do
-          config_object.platform.environment = env
-          expect(subject.platform.my_level).to eq(env_values[env])
+      {
+        production: 0,
+        development: 1,
+        staging: 2,
+        test: 3,
+      }.each do |env, value|
+        describe "in #{env} environment" do
+          let(:env) { env }
+
+          it "should return the #{env} value" do
+            expect(subject.core.my_level).to eq(value)
+          end
         end
       end
     end
@@ -143,35 +135,21 @@ describe Adhearsion::Configuration do
 
   describe "while defining the environment" do
 
-    after do
-      ENV['AHN_ENV'] = nil
+    before do
       Adhearsion.config = nil
     end
 
-    it "should return 'development' by default" do
-      expect(Adhearsion.config.platform.environment).to eq(:development)
+    after do
+      Adhearsion.environment = nil
+      Adhearsion.config = nil
     end
 
     [:development, :production, :staging, :test].each do |env|
-      it "should respond to #{env.to_s}" do
+      it "should respond to #{env}" do
         expect(Adhearsion.config).to respond_to(env)
       end
     end
 
-    context "when the ENV value is valid" do
-      [:production, :staging, :test].each do |env|
-        it "should override the environment value with #{env.to_s} when set in ENV value" do
-          ENV['AHN_ENV'] = env.to_s
-          expect(Adhearsion.config.platform.environment).to eq(env)
-        end
-      end
-    end
-
-    it "should not override the default environment with the ENV value if valid" do
-      ENV['AHN_ENV'] = "invalid_value"
-      expect(Adhearsion.config.platform.environment).to eq(:development)
-    end
-
     it "should allow to add a new environment" do
       expect(Adhearsion.config.valid_environment?(:another_environment)).to eq(false)
       Adhearsion.environments << :another_environment
@@ -187,17 +165,16 @@ describe Adhearsion::Configuration do
 
     subject { Adhearsion.config }
 
-    it "should retrieve a string with the platform configuration" do
-      desc = subject.description :platform, :show_values => false
+    it "should retrieve a string with the core configuration" do
+      desc = subject.description :core, :show_values => false
       expect(desc.length).to be > 0
-      expect(desc).to match(/^.*environment.*$/)
       expect(desc).to match(/^.*root.*$/)
     end
 
-    it "should retrieve a string with the platform configuration and values" do
-      desc = subject.description :platform
+    it "should retrieve a string with the core configuration and values" do
+      desc = subject.description :core
       expect(desc.length).to be > 0
-      expect(desc).to match(/^.*environment.*:development.*$/)
+      expect(desc).to match(/^.*type.*:xmpp.*$/)
       expect(desc).to match(/^.*root.*$/)
     end
 
@@ -236,33 +213,44 @@ describe Adhearsion::Configuration do
         end
 
         context "when config has named environments" do
-          subject do
-            Adhearsion.config do |c|
-              c.production do |env|
-                env.my_plugin.name = "production"
-              end
-              c.development do |env|
-                env.my_plugin.name = "development"
-              end
-              c.staging do |env|
-                env.my_plugin.name = "staging"
-              end
-              c.test do |env|
-                env.my_plugin.name = "test"
-              end
+          let(:env) { :development }
+
+          let(:config) do
+            Adhearsion::Configuration.new env do
+              my_level(-1, :desc => "An index to check the environment value is being retrieved")
             end
-            Adhearsion.config[:my_plugin]
           end
 
-          it "should return the development value by default" do
-            Adhearsion.config # initialize
+          before do
+            config.production do |env|
+              env.my_plugin.name = "production"
+            end
+            config.development do |env|
+              env.my_plugin.name = "development"
+            end
+            config.staging do |env|
+              env.my_plugin.name = "staging"
+            end
+            config.test do |env|
+              env.my_plugin.name = "test"
+            end
+          end
+
+          subject do
+            config.my_plugin
+          end
+
+          it "should return by default the development value" do
             expect(subject.name).to eq("development")
           end
 
-          [:development, :staging, :production, :test].each do |env|
-            it "should return the #{env.to_s} value when environment is set to #{env.to_s}" do
-              Adhearsion.config.platform.environment = env
-              expect(subject.name).to eq(env.to_s)
+          [:production, :development, :staging, :test].each do |env, value|
+            describe "in #{env} environment" do
+              let(:env) { env }
+
+              it "should return the #{env} value" do
+                expect(subject.name).to eq(env.to_s)
+              end
             end
           end
         end
@@ -284,21 +272,19 @@ describe Adhearsion::Configuration do
         expect(desc).to match(/^.*host.*$/)
       end
 
-      it "should retrieve both platform and plugin configuration" do
+      it "should retrieve both core and plugin configuration" do
         desc = subject.description :all
         expect(desc.length).to be > 0
-        expect(desc).to match(/^.*environment.*:development.*$/)
         expect(desc).to match(/^.*root.*$/)
         expect(desc).to match(/^.*name.*user.*$/)
         expect(desc).to match(/^.*password.*password.*$/)
         expect(desc).to match(/^.*host.*localhost.*$/)
       end
 
-      it "should retrieve both platform and plugin configuration with no values" do
+      it "should retrieve both core and plugin configuration with no values" do
         desc = subject.description :all, :show_values => false
         expect(desc.length).to be > 0
-        expect(desc).to match(/^.*Configuration for platform.*$/)
-        expect(desc).to match(/^.*environment.*$/)
+        expect(desc).to match(/^.*Configuration for core.*$/)
         expect(desc).to match(/^.*root.*$/)
         expect(desc).to match(/^.*Configuration for my_plugin.*$/)
         expect(desc).to match(/^.*name.*$/)

data/spec/adhearsion/event/answered_spec.rb

@@ -0,0 +1,50 @@
+# encoding: utf-8
+
+require 'spec_helper'
+
+describe Adhearsion::Event::Answered do
+  it 'registers itself' do
+    expect(Adhearsion::Rayo::RayoNode.class_from_registration(:answered, 'urn:xmpp:rayo:1')).to eq(described_class)
+  end
+
+  describe "from a stanza" do
+    let :stanza do
+      <<-MESSAGE
+<answered xmlns='urn:xmpp:rayo:1'>
+  <!-- Signaling (e.g. SIP) Headers -->
+  <header name="X-skill" value="agent" />
+  <header name="X-customer-id" value="8877" />
+</answered>
+      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) { '<answered 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/asterisk/Find Results

@@ -0,0 +1,402 @@
+Searching 326 files for "< Adhearsion::Event" (case sensitive)
+
+/Users/ben/code/adhearsion/lib/adhearsion/event/asterisk/ami.rb:
+    4    class Event
+    5      module Asterisk
+    6:       class AMI < Adhearsion::Event
+    7          register :event, :ami
+    8
+
+/Users/ben/code/adhearsion/spec/adhearsion/call_controller_spec.rb:
+  440          end
+  441          expect(latch.wait(1)).to be false
+  442:         subject.call << Adhearsion::Event::Joined.new(call_uri: 'call1')
+  443          expect(latch.wait(1)).to be false
+  444:         subject.call << Adhearsion::Event::Unjoined.new(call_uri: 'call1')
+  445          expect(latch.wait(1)).to be true
+  446        end
+  ...
+  456            end
+  457            expect(latch.wait(1)).to be false
+  458:           subject.call << Adhearsion::Event::Joined.new(:mixer_name => 'foobar')
+  459            expect(latch.wait(1)).to be false
+  460:           subject.call << Adhearsion::Event::Unjoined.new(:mixer_name => 'foobar')
+  461            expect(latch.wait(1)).to be true
+  462          end
+  ...
+  473            end
+  474            expect(latch.wait(1)).to be false
+  475:           subject.call << Adhearsion::Event::Joined.new(call_uri: 'call1')
+  476            expect(latch.wait(1)).to be true
+  477          end
+  ...
+  487              end
+  488              expect(latch.wait(1)).to be false
+  489:             subject.call << Adhearsion::Event::Joined.new(:mixer_name => 'foobar')
+  490              expect(latch.wait(1)).to be true
+  491            end
+
+/Users/ben/code/adhearsion/spec/adhearsion/call_spec.rb:
+ 1126              expect(result[:joined_condition].wait(0.5)).to be_falsey
+ 1127
+ 1128:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1129              expect(result[:joined_condition].wait(0.5)).to be_truthy
+ 1130            end
+ ....
+ 1136              expect(result[:unjoined_condition].wait(0.5)).to be_falsey
+ 1137
+ 1138:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1139              expect(result[:unjoined_condition].wait(0.5)).to be_falsey
+ 1140
+ 1141:             subject << Adhearsion::Event::Unjoined.new(call_uri: uri)
+ 1142              expect(result[:unjoined_condition].wait(0.5)).to be_truthy
+ 1143            end
+ ....
+ 1150              expect(result[:unjoined_condition].wait(0.5)).to be_falsey
+ 1151
+ 1152:             subject << Adhearsion::Event::End.new
+ 1153              expect(result[:joined_condition].wait(0.5)).to be_truthy
+ 1154              expect(result[:unjoined_condition].wait(0.5)).to be_truthy
+ ....
+ 1159              result = subject.join target, :media => :bridge, :direction => :recv
+ 1160
+ 1161:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1162:             subject << Adhearsion::Event::Unjoined.new(call_uri: uri)
+ 1163
+ 1164:             subject << Adhearsion::Event::End.new
+ 1165            end
+ 1166
+ ....
+ 1169              result = subject.join target, :media => :bridge, :direction => :recv
+ 1170
+ 1171:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1172:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1173
+ 1174              expect(subject).to be_alive
+ ....
+ 1207              expect(result[:joined_condition].wait(0.5)).to be_falsey
+ 1208
+ 1209:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1210              expect(result[:joined_condition].wait(0.5)).to be_truthy
+ 1211            end
+ ....
+ 1217              expect(result[:unjoined_condition].wait(0.5)).to be_falsey
+ 1218
+ 1219:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1220              expect(result[:unjoined_condition].wait(0.5)).to be_falsey
+ 1221
+ 1222:             subject << Adhearsion::Event::Unjoined.new(call_uri: uri)
+ 1223              expect(result[:unjoined_condition].wait(0.5)).to be_truthy
+ 1224            end
+ ....
+ 1231              expect(result[:unjoined_condition].wait(0.5)).to be_falsey
+ 1232
+ 1233:             subject << Adhearsion::Event::End.new
+ 1234              expect(result[:joined_condition].wait(0.5)).to be_truthy
+ 1235              expect(result[:unjoined_condition].wait(0.5)).to be_truthy
+ ....
+ 1240              result = subject.join target, :media => :bridge, :direction => :recv
+ 1241
+ 1242:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1243:             subject << Adhearsion::Event::Unjoined.new(call_uri: uri)
+ 1244
+ 1245:             subject << Adhearsion::Event::End.new
+ 1246            end
+ 1247
+ ....
+ 1250              result = subject.join target, :media => :bridge, :direction => :recv
+ 1251
+ 1252:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1253:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1254
+ 1255              expect(subject).to be_alive
+ ....
+ 1289              expect(result[:joined_condition].wait(0.5)).to be_falsey
+ 1290
+ 1291:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1292              expect(result[:joined_condition].wait(0.5)).to be_truthy
+ 1293            end
+ ....
+ 1299              expect(result[:unjoined_condition].wait(0.5)).to be_falsey
+ 1300
+ 1301:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1302              expect(result[:unjoined_condition].wait(0.5)).to be_falsey
+ 1303
+ 1304:             subject << Adhearsion::Event::Unjoined.new(call_uri: uri)
+ 1305              expect(result[:unjoined_condition].wait(0.5)).to be_truthy
+ 1306            end
+ ....
+ 1313              expect(result[:unjoined_condition].wait(0.5)).to be_falsey
+ 1314
+ 1315:             subject << Adhearsion::Event::End.new
+ 1316              expect(result[:joined_condition].wait(0.5)).to be_truthy
+ 1317              expect(result[:unjoined_condition].wait(0.5)).to be_truthy
+ ....
+ 1322              result = subject.join target.merge({:media => :bridge, :direction => :recv})
+ 1323
+ 1324:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1325:             subject << Adhearsion::Event::Unjoined.new(call_uri: uri)
+ 1326
+ 1327:             subject << Adhearsion::Event::End.new
+ 1328            end
+ 1329
+ ....
+ 1332              result = subject.join target.merge({:media => :bridge, :direction => :recv})
+ 1333
+ 1334:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1335:             subject << Adhearsion::Event::Joined.new(call_uri: uri)
+ 1336
+ 1337              expect(subject).to be_alive
+ ....
+ 1370              expect(result[:joined_condition].wait(0.5)).to be_falsey
+ 1371
+ 1372:             subject << Adhearsion::Event::Joined.new(mixer_name: mixer_name)
+ 1373              expect(result[:joined_condition].wait(0.5)).to be_truthy
+ 1374            end
+ ....
+ 1380              expect(result[:unjoined_condition].wait(0.5)).to be_falsey
+ 1381
+ 1382:             subject << Adhearsion::Event::Joined.new(mixer_name: mixer_name)
+ 1383              expect(result[:unjoined_condition].wait(0.5)).to be_falsey
+ 1384
+ 1385:             subject << Adhearsion::Event::Unjoined.new(mixer_name: mixer_name)
+ 1386              expect(result[:unjoined_condition].wait(0.5)).to be_truthy
+ 1387            end
+ ....
+ 1394              expect(result[:unjoined_condition].wait(0.5)).to be_falsey
+ 1395
+ 1396:             subject << Adhearsion::Event::End.new
+ 1397              expect(result[:joined_condition].wait(0.5)).to be_truthy
+ 1398              expect(result[:unjoined_condition].wait(0.5)).to be_truthy
+ ....
+ 1403              result = subject.join target.merge({:media => :bridge, :direction => :recv})
+ 1404
+ 1405:             subject << Adhearsion::Event::Joined.new(mixer_name: mixer_name)
+ 1406:             subject << Adhearsion::Event::Unjoined.new(mixer_name: mixer_name)
+ 1407
+ 1408:             subject << Adhearsion::Event::End.new
+ 1409            end
+ 1410
+ ....
+ 1413              result = subject.join target.merge({:media => :bridge, :direction => :recv})
+ 1414
+ 1415:             subject << Adhearsion::Event::Joined.new(mixer_name: mixer_name)
+ 1416:             subject << Adhearsion::Event::Joined.new(mixer_name: mixer_name)
+ 1417
+ 1418              expect(subject).to be_alive
+
+/Users/ben/code/adhearsion/spec/adhearsion/outbound_call_spec.rb:
+   68          expect(Adhearsion.router).to receive(:handle).once.with(mock_call)
+   69
+   70:         OutboundCall.originate(to) << Adhearsion::Event::Answered.new
+   71        end
+   72
+   ..
+   78            expect(mock_call).to receive(:execute_controller).once.with kind_of(controller), kind_of(Proc)
+   79            call = OutboundCall.originate to, :controller => controller
+   80:           call << Adhearsion::Event::Answered.new
+   81          end
+   82
+   ..
+   86
+   87            call = OutboundCall.originate to, :controller => controller
+   88:           call << Adhearsion::Event::Answered.new
+   89            sleep 0.5
+   90          end
+   ..
+   96              expect(mock_call).to receive(:execute_controller).with(expected_controller, kind_of(Proc)).once
+   97              call = OutboundCall.originate to, :controller => controller, :controller_metadata => {:foo => 'bar'}
+   98:             call << Adhearsion::Event::Answered.new
+   99            end
+  100          end
+  ...
+  111              :foobar
+  112            end
+  113:           call << Adhearsion::Event::Answered.new
+  114          end
+  115        end
+
+/Users/ben/code/adhearsion/spec/adhearsion/call_controller/dial_spec.rb:
+  267                expect(call).to receive(:answer).once
+  268                expect(other_mock_call).to receive(:join).once.with(call, {}) do
+  269:                 call << Adhearsion::Event::Joined.new(call_uri: other_mock_call.id)
+  270:                 other_mock_call << Adhearsion::Event::Joined.new(call_uri: call.id)
+  271                end
+  272
+  ...
+  291                expect(call).to receive(:answer).once
+  292                expect(other_mock_call).to receive(:join).once.with(call, {}) do
+  293:                 call << Adhearsion::Event::Joined.new(call_uri: other_mock_call.id)
+  294:                 other_mock_call << Adhearsion::Event::Joined.new(call_uri: call.id)
+  295                end
+  296                allow(other_mock_call).to receive_messages hangup: true
+  ...
+  307                base_time = Time.local(2008, 9, 1, 12, 0, 37)
+  308                Timecop.freeze base_time
+  309:               other_mock_call << Adhearsion::Event::Unjoined.new(call_uri: call.id)
+  310                other_mock_call << mock_end
+  311
+  ...
+  325                  expect(call).to receive(:answer).once
+  326                  expect(other_mock_call).to receive(:join).once.with(call, media: :direct) do
+  327:                   call << Adhearsion::Event::Joined.new(call_uri: other_mock_call.id)
+  328:                   other_mock_call << Adhearsion::Event::Joined.new(call_uri: call.id)
+  329                  end
+  330                  allow(other_mock_call).to receive_messages hangup: true
+  ...
+  336                  other_mock_call << mock_answered
+  337
+  338:                 other_mock_call << Adhearsion::Event::Unjoined.new(call_uri: call.id)
+  339                  other_mock_call << mock_end
+  340
+  ...
+  352                expect(call).to receive(:answer).once
+  353                expect(other_mock_call).to receive(:join).once.with(join_target, join_options) do
+  354:                 call << Adhearsion::Event::Joined.new(call_uri: other_mock_call.id)
+  355:                 other_mock_call << Adhearsion::Event::Joined.new(call_uri: call.id)
+  356                end
+  357                allow(other_mock_call).to receive(:unjoin) do
+  358:                 call << Adhearsion::Event::Unjoined.new(call_uri: other_mock_call.id)
+  359:                 other_mock_call << Adhearsion::Event::Unjoined.new(call_uri: call.id)
+  360                end
+  361              end
+  ...
+  363              it "should unjoin the calls" do
+  364                expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
+  365:                 call << Adhearsion::Event::Unjoined.new(call_uri: other_mock_call.id)
+  366:                 other_mock_call << Adhearsion::Event::Unjoined.new(call_uri: call.id)
+  367                end
+  368
+  ...
+  504                it "should rejoin the calls" do
+  505                  expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
+  506:                   call << Adhearsion::Event::Unjoined.new(call_uri: other_mock_call.id)
+  507:                   other_mock_call << Adhearsion::Event::Unjoined.new(call_uri: call.id)
+  508                  end
+  509
+  ...
+  523
+  524                  expect(other_mock_call).to receive(:join).once.ordered.with(call, {}) do
+  525:                   call << Adhearsion::Event::Joined.new(call_uri: other_mock_call.id)
+  526:                   other_mock_call << Adhearsion::Event::Joined.new(call_uri: call.id)
+  527                  end
+  528                  dial.rejoin
+  ...
+  550
+  551                    expect(other_mock_call).to receive(:join).once.ordered.with(call, media: :direct) do
+  552:                     call << Adhearsion::Event::Joined.new(call_uri: other_mock_call.id)
+  553:                     other_mock_call << Adhearsion::Event::Joined.new(call_uri: call.id)
+  554                    end
+  555                    dial.rejoin
+  ...
+  569
+  570                    expect(other_mock_call).to receive(:join).once.ordered.with(call, media: :direct) do
+  571:                     call << Adhearsion::Event::Joined.new(call_uri: other_mock_call.id)
+  572:                     other_mock_call << Adhearsion::Event::Joined.new(call_uri: call.id)
+  573                    end
+  574                    dial.rejoin nil, media: :direct
+  ...
+  584                    expect(other_mock_call).to receive(:unjoin).once.ordered.with(join_target)
+  585                    expect(call).to receive(:unjoin).once.ordered.with(join_target) do
+  586:                     call << Adhearsion::Event::Unjoined.new(join_target)
+  587:                     other_mock_call << Adhearsion::Event::Unjoined.new(join_target)
+  588                    end
+  589
+  ...
+  620                  it "should join all calls to the mixer" do
+  621                    expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
+  622:                     call << Adhearsion::Event::Unjoined.new(call_uri: other_mock_call.id)
+  623:                     other_mock_call << Adhearsion::Event::Unjoined.new(call_uri: call.id)
+  624                    end
+  625
+  ...
+  652                  it "#split should then unjoin calls from the mixer" do
+  653                    expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
+  654:                     call << Adhearsion::Event::Unjoined.new(call_uri: other_mock_call.id)
+  655:                     other_mock_call << Adhearsion::Event::Unjoined.new(call_uri: call.id)
+  656                    end
+  657
+  ...
+  675
+  676                    expect(other_mock_call).to receive(:unjoin).once.ordered.with(mixer_name: mixer) do
+  677:                     other_mock_call << Adhearsion::Event::Unjoined.new(mixer_name: mixer)
+  678                    end
+  679                    expect(call).to receive(:unjoin).once.ordered.with(mixer_name: mixer) do
+  680:                     call << Adhearsion::Event::Unjoined.new(mixer_name: mixer)
+  681                    end
+  682                    dial.split
+  ...
+  718                it "should split calls, rejoin to a mixer, and rejoin other calls to mixer" do
+  719                  expect(other_mock_call).to receive(:unjoin).once.ordered.with(call) do
+  720:                   call << Adhearsion::Event::Unjoined.new(call_uri: other_mock_call.id)
+  721:                   other_mock_call << Adhearsion::Event::Unjoined.new(call_uri: call.id)
+  722                  end
+  723                  expect(second_other_mock_call).to receive(:unjoin).once.ordered.with(second_root_call) do
+  724:                   second_root_call << Adhearsion::Event::Unjoined.new(call_uri: second_other_mock_call.id)
+  725:                   second_other_mock_call << Adhearsion::Event::Unjoined.new(call_uri: second_root_call.id)
+  726                  end
+  727
+  ...
+  857                  [call, second_root_call, second_other_mock_call].each do |call|
+  858                    expect(call).to receive(:unjoin).once.with(mixer_name: mixer) do
+  859:                     call << Adhearsion::Event::Unjoined.new(mixer_name: mixer)
+  860                    end
+  861                  end
+  ...
+  865                  [call, other_mock_call, second_root_call, second_other_mock_call].each do |call|
+  866                    expect(call).to receive(:join).once.with({mixer_name: mixer}, {}) do
+  867:                     call << Adhearsion::Event::Joined.new(mixer_name: mixer)
+  868                    end
+  869                  end
+  ...
+  965                    [call, second_root_call, second_other_mock_call].each do |call|
+  966                      expect(call).to receive(:unjoin).once.with(mixer_name: mixer) do
+  967:                       call << Adhearsion::Event::Unjoined.new(mixer_name: mixer)
+  968                      end
+  969                    end
+  ...
+  978                    [call, second_root_call, second_other_mock_call].each do |call|
+  979                      expect(call).to receive(:join).once.with({mixer_name: mixer}, {}) do
+  980:                       call << Adhearsion::Event::Joined.new(mixer_name: mixer)
+  981                      end
+  982                    end
+  ...
+ 1095
+ 1096              other_mock_call << mock_answered
+ 1097:             other_mock_call << Adhearsion::Event::Unjoined.new(call_uri: call.id)
+ 1098
+ 1099              expect(latch.wait(2)).to be_truthy
+ ....
+ 1354                expect(call).to receive(:answer).once
+ 1355                expect(other_mock_call).to receive(:join).once.with(call, {}) do
+ 1356:                 call << Adhearsion::Event::Joined.new(call_uri: other_mock_call.id)
+ 1357:                 other_mock_call << Adhearsion::Event::Joined.new(call_uri: call.id)
+ 1358                end
+ 1359
+ ....
+ 1369                base_time = Time.local(2008, 9, 1, 12, 0, 42)
+ 1370                Timecop.freeze base_time
+ 1371:               other_mock_call << Adhearsion::Event::Unjoined.new(call_uri: call.id)
+ 1372
+ 1373                expect(latch.wait(2)).to be_truthy
+ ....
+ 1444                  expect(other_mock_call).to receive(:dial).once.with(to, from: nil)
+ 1445                  expect(other_mock_call).to receive(:join).once.with(call, {}) do
+ 1446:                   call << Adhearsion::Event::Joined.new(call_uri: other_mock_call.id)
+ 1447:                   other_mock_call << Adhearsion::Event::Joined.new(call_uri: call.id)
+ 1448                  end
+ 1449                  expect(other_mock_call).to receive(:hangup).once do
+
+92 matches across 5 files
+
+
+Searching 326 files for " < Adhearsion::Event" (case sensitive)
+
+/Users/ben/code/adhearsion/lib/adhearsion/event/asterisk/ami.rb:
+    4    class Event
+    5      module Asterisk
+    6:       class AMI < Adhearsion::Event
+    7          register :event, :ami
+    8
+
+1 match in 1 file