electric_slide 0.2.0 → 0.3.0

data/lib/electric_slide/version.rb

@@ -1,4 +1,4 @@
 # encoding: utf-8
 class ElectricSlide
-  VERSION = '0.2.0'
+  VERSION = '0.3.0'
 end

data/spec/electric_slide/agent_spec.rb

@@ -6,9 +6,10 @@ describe ElectricSlide::Agent do
   let(:options) { { id: 1, address: '123@foo.com', presence: :available} }
 
   class MyAgent < ElectricSlide::Agent
-    on_connect do
-      foo
-    end
+    on_connect { foo }
+    on_connection_failed { foo }
+    on_disconnect { foo }
+    on_presence_change { foo }
 
     def foo
       :bar
@@ -17,7 +18,32 @@ describe ElectricSlide::Agent do
 
   subject {MyAgent.new options}
 
+  after do
+    [:connect_callback, :disconnect_callback, :connection_failed_callback, :presence_change_callback].each do |callback|
+      ElectricSlide::Agent.instance_variable_set "@#{callback}", nil
+    end
+  end
+
   it 'executes a connect callback' do
     expect(subject.callback(:connect)).to eql :bar
   end
+
+  it 'executes a disconnect callback' do
+    expect(subject.callback(:disconnect)).to eql :bar
+  end
+
+  it 'executes a connection failed callback' do
+    expect(subject.callback(:connection_failed)).to eql :bar
+  end
+
+  it 'executes a presence change callback' do
+    expect(subject.callback(:presence_change, nil, nil, nil, nil)).to eql :bar
+  end
+
+  it 'executes the presence change callback on state change' do
+    called = false
+    ElectricSlide::Agent.on_presence_change { |queue, agent_call, presence| called = true }
+    agent = ElectricSlide::Agent.new presence: :unavailable
+    agent.presence = :busy
+  end
 end

data/spec/electric_slide/agent_strategy/fixed_priority_spec.rb

@@ -5,11 +5,10 @@ require 'electric_slide/agent_strategy/fixed_priority'
 require 'ostruct'
 
 describe ElectricSlide::AgentStrategy::FixedPriority do
-  let(:subject) { ElectricSlide::AgentStrategy::FixedPriority.new }
   it 'should allow adding an agent with a specified priority' do
-    subject.agent_available?.should be false
+    expect(subject.agent_available?).to be false
     subject << OpenStruct.new({ id: 101, priority: 1 })
-    subject.agent_available?.should be true
+    expect(subject.agent_available?).to be true
   end
 
   it 'should allow adding multiple agents at the same priority' do
@@ -17,7 +16,7 @@ describe ElectricSlide::AgentStrategy::FixedPriority do
     agent2 = OpenStruct.new({ id: 102, priority: 2 })
     subject << agent1
     subject << agent2
-    subject.checkout_agent.should == agent1
+    expect(subject.checkout_agent).to eql(agent1)
   end
 
   it 'should return all agents of a higher priority before returning an agent of a lower priority' do
@@ -27,9 +26,9 @@ describe ElectricSlide::AgentStrategy::FixedPriority do
     subject << agent1
     subject << agent2
     subject << agent3
-    subject.checkout_agent.should == agent1
-    subject.checkout_agent.should == agent2
-    subject.checkout_agent.should == agent3
+    expect(subject.checkout_agent).to eql(agent1)
+    expect(subject.checkout_agent).to eql(agent2)
+    expect(subject.checkout_agent).to eql(agent3)
   end
 
   it 'should detect an agent available if one is available at any priority' do
@@ -38,6 +37,6 @@ describe ElectricSlide::AgentStrategy::FixedPriority do
     subject << agent1
     subject << agent2
     subject.checkout_agent
-    subject.agent_available?.should == true
+    expect(subject.agent_available?).to be true
   end
 end

data/spec/electric_slide/call_queue_spec.rb

@@ -1,42 +1,453 @@
 # encoding: utf-8
 require 'spec_helper'
+require 'electric_slide/agent_strategy/fixed_priority'
 
 describe ElectricSlide::CallQueue do
   let(:queue) { ElectricSlide::CallQueue.new }
-  let(:call_a) { dummy_call }
-  let(:call_b) { dummy_call }
-  let(:call_c) { dummy_call }
-  before :each do
-    queue.enqueue call_a
-    queue.enqueue call_b
-    queue.enqueue call_c
+
+  context "enqueuing calls" do
+    let(:call_a) { dummy_call }
+    let(:call_b) { dummy_call }
+    let(:call_c) { dummy_call }
+    before :each do
+      queue.enqueue call_a
+      queue.enqueue call_b
+      queue.enqueue call_c
+    end
+
+    it "should return callers in the same order they were enqueued" do
+      expect(queue.get_next_caller).to be call_a
+      expect(queue.get_next_caller).to be call_b
+      expect(queue.get_next_caller).to be call_c
+    end
+
+    it "should return a priority caller ahead of the queue" do
+      call_d = dummy_call
+      queue.priority_enqueue call_d
+      expect(queue.get_next_caller).to be call_d
+      expect(queue.get_next_caller).to be call_a
+    end
+
+    it "should remove a caller who abandons the queue" do
+      queue.enqueue call_a
+      queue.enqueue call_b
+      call_a << Punchblock::Event::End.new(reason: :hangup)
+      expect(queue.get_next_caller).to be call_b
+    end
+
+    it "records the time in the :electric_slide_enqueued_at call variable on the queued call" do
+      enqueue_time = DateTime.new(2015, 9, 30, 15, 0, 23)
+      Timecop.freeze enqueue_time
+      queue.enqueue call_a
+      expect(call_a[:electric_slide_enqueued_at]).to eq(enqueue_time)
+    end
   end
 
-  it "should return callers in the same order they were enqueued" do
-    expect(queue.get_next_caller).to be call_a
-    expect(queue.get_next_caller).to be call_b
-    expect(queue.get_next_caller).to be call_c
+  it "should raise when given an invalid Agent" do
+    expect { queue.add_agent nil }.to raise_error(ArgumentError)
   end
 
-  it "should return a priority caller ahead of the queue" do
-    call_d = dummy_call
-    queue.priority_enqueue call_d
-    expect(queue.get_next_caller).to be call_d
-    expect(queue.get_next_caller).to be call_a
+  describe 'connecting agents to callers' do
+    let(:agent_return_method) { :auto }
+
+    let(:queue) { ElectricSlide::CallQueue.new(connection_type: connection_type, agent_return_method: agent_return_method) }
+    let(:agent_id) { '123' }
+    let(:agent) { ElectricSlide::Agent.new id: agent_id, address: '123', presence: :available }
+    let!(:agent_call) { Adhearsion::OutboundCall.new }
+    let(:queued_call) { dummy_call }
+    let(:connected_time) { DateTime.now }
+
+    before do
+      allow(Adhearsion::OutboundCall).to receive(:new) { agent_call }
+      allow(agent).to receive(:dial_options_for) {
+        { confirm: double('ConfirmController') }
+      }
+
+      allow(queued_call).to receive(:active?) { true }
+    end
+
+    context "with connection type :call" do
+      let(:connection_type) { :call }
+
+      before do
+        allow(agent_call).to receive(:dial)
+        queue.add_agent agent
+        queue.enqueue queued_call
+      end
+
+      it "sets the agent's `call` attribute" do
+        expect(agent.call).to be agent_call
+      end
+
+      it 'records the agent in the `:agent` call variable on the queued call' do
+        expect(queued_call[:agent]).to eq(agent)
+      end
+
+      context 'when the call ends' do
+        let(:double_agent) { double(ElectricSlide::Agent, presence: :available).as_null_object }
+
+        before do
+          # add another agent so that it gets selected after the
+          # currently-selected agent's call ends; otherwise, the agent just
+          # gets returned and is immediately connected to the queued call,
+          # causing its state to change before the examples have a chance to
+          # check it
+          queue.add_agent double_agent
+        end
+
+        it "unsets the agent's `call` attribute" do
+          expect {
+            agent_call << Punchblock::Event::End.new(reason: :hangup)
+          }.to change(agent, :call).from(agent_call).to(nil)
+        end
+
+        context "when the return strategy is :auto" do
+          let(:agent_return_method) { :auto }
+
+          it "makes the agent available for a call" do
+            agent_call << Punchblock::Event::End.new(reason: :hangup)
+            expect(queue.checkout_agent).to eql(agent)
+          end
+
+          it "sets the agent's presence to :available" do
+            agent_call << Punchblock::Event::End.new(reason: :hangup)
+            expect(queue.get_agent(agent.id).presence).to eql(:available)
+          end
+        end
+
+        context "when the return strategy is :manual" do
+          let(:agent_return_method) { :manual }
+
+          it "does not make the agent available for a call" do
+            agent_call << Punchblock::Event::End.new(reason: :hangup)
+            expect(queue.checkout_agent).to eql(nil)
+          end
+
+          it "sets the agent's presence to :after_call" do
+            agent_call << Punchblock::Event::End.new(reason: :hangup)
+            expect(queue.get_agent(agent.id).presence).to eql(:after_call)
+          end
+        end
+
+        context "when the agent's and caller's calls are not joined" do
+          context 'and the call ends' do
+            before do
+              queue.remove_agent(double_agent)
+
+              # prevent the agent from being returned to the queue so the queued
+              # call isn't grabbed by the agent again, changing queued call state
+              # before the example can check it
+              agent.presence = :unavailable
+            end
+
+            it 'unsets the `:agent` call variable on the queued call' do
+              expect {
+                agent_call << Punchblock::Event::End.new(reason: :hangup)
+              }.to change{ queued_call[:agent] }.from(agent).to(nil)
+            end
+          end
+        end
+
+        context "with callbacks" do
+          after do
+            [:connect_callback, :disconnect_callback, :connection_failed_callback, :presence_change_callback].each do |callback|
+              ElectricSlide::Agent.instance_variable_set "@#{callback}", nil
+            end
+          end
+
+          it "invokes the presence change callback" do
+            called = false
+            ElectricSlide::Agent.on_presence_change { |queue, agent_call, presence| called = true }
+            agent_call << Punchblock::Event::End.new(reason: :hangup)
+            expect(called).to be true
+          end
+        end
+      end
+
+      context "when the agent's and caller's calls are joined" do
+        before do
+          queued_call << Punchblock::Event::Joined.new(timestamp: connected_time)
+          agent_call << Punchblock::Event::Joined.new(timestamp: connected_time)
+        end
+
+        it "records the connection time in the :electric_slide_connected_at call variable on the queued call" do
+          expect(queued_call[:electric_slide_connected_at]).to eq(connected_time)
+        end
+      end
+    end
+
+    context "with connection type :bridge" do
+      let(:connection_type) { :bridge }
+
+      before do
+        allow(agent_call).to receive(:active?) { true }
+        allow(queued_call).to receive(:hangup) { true }
+        agent.call = agent_call
+        queue.add_agent agent
+
+        allow(agent_call).to receive(:join) do
+          agent_call << Punchblock::Event::Joined.new(timestamp: connected_time)
+          queued_call << Punchblock::Event::Joined.new(timestamp: connected_time)
+        end
+        queue.enqueue queued_call
+      end
+
+      it 'records the agent in the `:agent` call variable on the queued call' do
+        expect(queued_call[:agent]).to eq(agent)
+      end
+
+      it "records the connection time in the :electric_slide_connected_at call variable on the queued call" do
+        expect(queued_call[:electric_slide_connected_at]).to eq(connected_time)
+      end
+
+      context 'when the call ends' do
+        it "unsets the agent's `call` attribute" do
+          expect {
+            agent_call << Punchblock::Event::End.new(reason: :hangup)
+          }.to change(agent, :call).from(agent_call).to(nil)
+        end
+
+        it "marks the agent :unavailable" do
+          expect {
+            agent_call << Punchblock::Event::End.new(reason: :hangup)
+          }.to change(agent, :presence).from(:on_call).to(:unavailable)
+        end
+
+        context "when the return strategy is :auto" do
+          let(:agent_return_method) { :auto }
+
+          it "makes the agent available for a call" do
+            agent_call << Punchblock::Event::Unjoined.new
+            expect(queue.checkout_agent).to eql(agent)
+          end
+
+          it "sets the agent's presence to :available" do
+            agent_call << Punchblock::Event::Unjoined.new
+            expect(queue.get_agent(agent.id).presence).to eql(:available)
+          end
+        end
+
+        context "when the return strategy is :manual" do
+          let(:agent_return_method) { :manual }
+
+          it "does not make the agent available for a call" do
+            agent_call << Punchblock::Event::Unjoined.new
+            expect(queue.checkout_agent).to eql(nil)
+          end
+
+          it "sets the agent's presence to :after_call" do
+            agent_call << Punchblock::Event::Unjoined.new
+            expect(queue.get_agent(agent.id).presence).to eql(:after_call)
+          end
+        end
+      end
+    end
   end
 
-  it "should remove a caller who abandons the queue" do
-    queue.enqueue call_a
-    queue.enqueue call_b
-    queue.abandon call_a
-    expect(queue.get_next_caller).to be call_b
+  describe '#add_agent' do
+    let(:queue) { ElectricSlide::CallQueue.new }
+    let(:agent) { ElectricSlide::Agent.new(id: '1', address: 'agent@example.com') }
+
+    before do
+      allow(agent).to receive(:call) { Adhearsion::OutboundCall.new }
+    end
+
+    it "associates the agent with in the queue" do
+      expect {
+        queue.add_agent agent
+      }.to change(queue, :get_agents).from([]).to([agent])
+    end
+
+    it "makes the agent available to take calls" do
+      expect {
+        queue.add_agent agent
+      }.to change(queue, :checkout_agent).from(nil).to(agent)
+    end
+
+    it "connects the agent to waiting queued calls"
+
+    context 'when given an agent already in the queue' do
+      before do
+        queue.add_agent(agent)
+      end
+
+      it 'should raise an error' do
+        expect{
+          queue.add_agent(agent)
+        }.to raise_error(ElectricSlide::CallQueue::DuplicateAgentError)
+      end
+    end
   end
 
-  it "should raise when given an invalid connection type" do
-    expect { ElectricSlide::CallQueue.new connection_type: :blah }.to raise_error
+  describe '#return_agent' do
+    let(:queue) { ElectricSlide::CallQueue.new }
+    let(:agent) { ElectricSlide::Agent.new(id: '1', address: 'agent@example.com', presence: :on_call) }
+
+    before do
+      allow(agent).to receive(:call) { Adhearsion::OutboundCall.new }
+    end
+
+    context 'when the agent is a member of the queue' do
+      before do
+        queue.add_agent agent
+      end
+
+      it "sets the agent presence available" do
+        expect {
+          queue.return_agent agent
+        }.to change(agent, :presence).from(:on_call).to(:available)
+      end
+
+      it "makes the agent available to take calls" do
+        expect {
+          queue.return_agent agent
+        }.to change(queue, :checkout_agent).from(nil).to(agent)
+      end
+
+      context "when returned with some presence other than available" do
+        it "reflects that status on the agent" do
+          expect {
+            queue.return_agent agent, :after_call
+          }.to change(agent, :presence).from(:on_call).to(:after_call)
+        end
+
+        it "does not make the agent available to take calls" do
+          expect {
+            queue.return_agent agent, :after_call
+          }.to_not change { queue.checkout_agent }
+        end
+      end
+    end
+
+    context 'when given an agent not in the queue' do
+      it 'should cleanly return false' do
+        expect(queue.return_agent(agent)).to be(false)
+      end
+
+      context 'when called with a bang' do
+        it 'should raise an error' do
+          expect{
+            queue.return_agent!(agent)
+          }.to raise_error(ElectricSlide::CallQueue::MissingAgentError)
+        end
+      end
+    end
   end
 
-  it "should raise when given an invalid Agent" do
-    expect { queue.add_agent nil }.to raise_error
+  describe '#remove_agent' do
+    let(:queue) { ElectricSlide::CallQueue.new }
+    let(:agent) { ElectricSlide::Agent.new(id: '1', address: 'agent@example.com', presence: :available) }
+
+    before do
+      queue.add_agent agent
+    end
+
+    it 'sets the agent presence to `:unavailable`' do
+      expect {
+        queue.remove_agent agent
+      }.to change(agent, :presence).from(:available).to(:unavailable)
+    end
+
+    it 'invokes the presence change callback' do
+      called = false
+      ElectricSlide::Agent.on_presence_change { |queue, agent_call, presence| called = true }
+      queue.remove_agent agent
+      expect(called).to be
+    end
+
+    it 'takes the agent out of the call rotation' do
+      expect {
+        queue.remove_agent agent
+      }.to change(queue, :checkout_agent).from(agent).to(nil)
+    end
+
+    it 'removes the agent from the queue' do
+      queue.remove_agent agent
+      expect(queue.get_agents).to_not include(agent)
+    end
+  end
+
+  describe '#update' do
+    let(:queue) {
+      ElectricSlide::CallQueue.new(
+        agent_strategy: ElectricSlide::AgentStrategy::LongestIdle,
+        connection_type: :call,
+        agent_return_method: :auto
+      )
+    }
+
+    it 'updates all the given attributes' do
+      queue.update(
+        agent_strategy: ElectricSlide::AgentStrategy::FixedPriority,
+        connection_type: :bridge,
+        agent_return_method: :manual
+      )
+      expect(queue.agent_strategy).to eq(ElectricSlide::AgentStrategy::FixedPriority)
+      expect(queue.connection_type).to eq(:bridge)
+      expect(queue.agent_return_method).to eq(:manual)
+    end
+
+    context 'when given an unrecognized attribute' do
+      it 'does not raise an error' do
+        expect{
+          queue.update(foo: :bar)
+        }.to_not raise_exception
+      end
+    end
+
+    context 'when given `nil`' do
+      it 'does not raise an error' do
+        expect{
+          queue.update(foo: :bar)
+        }.to_not raise_exception
+      end
+    end
+  end
+
+  describe '#agent_strategy=' do
+    let(:queue) {
+      ElectricSlide::CallQueue.new(
+        agent_strategy: ElectricSlide::AgentStrategy::LongestIdle,
+        connection_type: :call,
+        agent_return_method: :auto
+      )
+    }
+
+    it 'returns the given strategy class' do
+      expect(queue.agent_strategy = ElectricSlide::AgentStrategy::FixedPriority).to eq(ElectricSlide::AgentStrategy::FixedPriority)
+    end
+
+    it 'assigns a new strategy' do
+      expect(ElectricSlide::AgentStrategy::FixedPriority).to receive(:new)
+      queue.agent_strategy = ElectricSlide::AgentStrategy::FixedPriority
+    end
+
+    it 'returns all agents to the queue (strategy)' do
+      agent = double(ElectricSlide::Agent, address: '100', presence: :available, priority: 100).as_null_object
+      queue.add_agent(agent)
+
+      queue.agent_strategy = ElectricSlide::AgentStrategy::FixedPriority
+      expect(queue.available_agent_summary).to eq({ total: 1, priorities: { 100 => 1 }})
+    end
+  end
+
+  describe '#connection_type=' do
+    context 'when given an invalid connection type' do
+      it 'raises an `InvalidConnectionType` exception' do
+        expect{
+          queue.connection_type = :party_line
+        }.to raise_exception(ElectricSlide::CallQueue::InvalidConnectionType)
+      end
+    end
+  end
+
+  describe '#agent_return_method=' do
+    context 'when given an invalid agent return method' do
+      it 'raises an `InvalidRequeueMethod` exception' do
+        expect{
+          queue.agent_return_method = :semiauto
+        }.to raise_exception(ElectricSlide::CallQueue::InvalidRequeueMethod)
+      end
+    end
   end
 end