telephony 1.0.3

data/spec/javascripts/telephony/views/status_view_spec.js

@@ -0,0 +1,30 @@
+describe("Zest.Telephony.Views.StatusView", function() {
+  describe("toggle status", function() {
+    var view;
+
+    beforeEach(function() {
+      setFixtures('<div id="status"></div>');
+      view = new Zest.Telephony.Views.StatusView({csrId: 200, el: $("#status")});
+      view.render();
+    })
+
+    it("handles status change via the button click", function() {
+      spyOn(view.agent, 'toggleAvailable');
+      view.$("button").click();
+
+      expect(view.agent.toggleAvailable).toHaveBeenCalled();
+    });
+
+    it("handles status change from Pusher event", function() {
+      $(document).trigger("telephony:csrDidChangeStatus", [{status: "some_status"}]);
+      expect(view.$("button")).toHaveText("Some status");
+    });
+
+    describe("on a call", function() {
+      it("disbales the button", function() {
+        $(document).trigger("telephony:csrDidChangeStatus", [{status: "on_a_call"}]);
+        expect(view.$('button')).toBeDisabled();
+      });
+    });
+  });
+});

data/spec/javascripts/telephony/views/transfer_view_spec.js

@@ -0,0 +1,187 @@
+describe("Zest.Telephony.Views.TransferView", function() {
+  var view;
+  var request;
+
+  beforeEach(function() {
+    setFixtures('<div id="transfer"></div>');
+    view = new Zest.Telephony.Views.TransferView({
+      el: $("#transfer")
+    });
+
+    jasmine.Ajax.useMock();
+
+    view.render();
+
+    request = mostRecentAjaxRequest();
+    var data = [
+      {
+        id: 123,
+        name: 'abc',
+        csr_id: 1000,
+        csr_type: 'A'
+      },
+      {
+        id: 456,
+        name: 'xyz',
+        csr_id: 1001,
+        csr_type: 'B'
+      }
+    ];
+    request.response({status: 200, responseText: JSON.stringify(data)});
+  });
+
+  describe("selecting agent by pressing the enter key", function() {
+    it("selects the best matched agent", function() {
+      $('form').submit();
+
+      expect($('input[name=selected_agent]').val()).toMatch(/abc/);
+    });
+  });
+
+  describe("agents list", function() {
+    describe("when agent is not selected", function() {
+      it("does not show the initial transfer button", function() {
+        expect($('#telephony-transfer')).toContain("span.controls.hidden");
+      });
+
+      it("shows the list of agents", function() {
+        var $agents = $("li", view.el);
+        expect($agents[0].innerHTML).toMatch(/abc/);
+        expect($agents[1].innerHTML).toMatch(/xyz/);
+      });
+    });
+
+    describe("when agent is selected", function() {
+      var agent;
+
+      beforeEach(function() {
+        agent = new Zest.Telephony.Models.Agent({
+          name: "Bruce",
+          status: "available",
+          phone_ext: "14"
+        });
+      });
+
+      it("displays the selected agent's info", function() {
+        $('#transfer').trigger("agentDidSelect", agent);
+
+        expect(view.$('input[name=selected_agent]')).toHaveValue(agent.displayText());
+      });
+
+      it("disables the filter", function() {
+        $('#transfer').trigger("agentDidSelect", agent);
+
+        expect(view.$('input[name=selected_agent]')).toBeDisabled();
+      });
+
+      it("display agent status", function() {
+        $('#transfer').trigger("agentDidSelect", agent);
+        expect(view.$('form .agent-input span')).toHaveClass('icon-user available');
+      });
+
+      describe("agent is available", function() {
+        it("defaults to two-step", function() {
+          $('#transfer').trigger("agentDidSelect", agent);
+
+          expect(view.$('#transfer_type_two_step')).toBeChecked();
+          expect(view.$('#transfer_type_two_step')).not.toBeDisabled();
+          expect(view.$('#transfer_type_one_step')).not.toBeChecked();
+        });
+      });
+
+      describe("agent is not available", function() {
+        it("disables the 2-step radio", function() {
+          agent.set({status: "not_available"});
+
+          $('#transfer').trigger("agentDidSelect", agent);
+
+          expect(view.$('#transfer_type_one_step')).toBeChecked();
+          expect(view.$('#transfer_type_two_step')).toBeDisabled();
+          expect(view.$('#transfer_type_two_step')).not.toBeChecked();
+        });
+      });
+    });
+
+    describe("backspace button", function() {
+      var agent;
+
+      beforeEach(function() {
+        agent = new Zest.Telephony.Models.Agent({
+          name: "Bruce",
+          status: "available",
+          phone_ext: "14"
+        });
+      });
+
+      it("is not shown when agent is not selected", function() {
+        expect(view.$('form span.backspace')).toHaveClass('hidden');
+      });
+
+      it("is visible when agent is selected", function() {
+        $('#transfer').trigger("agentDidSelect", agent);
+        expect(view.$('form span.backspace')).not.toHaveClass('hidden');
+      });
+
+      it("handles click event", function() {
+        $('#transfer').trigger("agentDidSelect", agent);
+
+        spyOn(view, 'render');
+        $('span.backspace').click();
+        expect(view.transfer.get("selectedAgent")).toBeNull();
+        expect(view.render).toHaveBeenCalled();
+      });
+    });
+  });
+
+  describe("when initiating a transfer", function() {
+    describe('to an transferrable agent', function() {
+      beforeEach(function() {
+        var agent = new Zest.Telephony.Models.Agent({
+          name: "Bruce",
+          status: "available",
+          phone_ext: "14"
+        });
+        $('#transfer').trigger("agentDidSelect", agent);
+
+        view.$('form #transfer_type_one_step').click();
+        view.$('button.initiate-transfer').click();
+      });
+
+      it("saves the transfer", function() {
+        expect(view.transfer.get('transferType')).toEqual('one_step');
+      });
+    });
+
+    describe('to an untransferrable agent', function() {
+      var transferFailedSpy;
+
+      beforeEach(function() {
+        var agent = new Zest.Telephony.Models.Agent({
+          name: "Bruce",
+          status: "available",
+          phone_ext: "14"
+        });
+        $('#transfer').trigger("agentDidSelect", agent);
+
+        transferFailedSpy = jasmine.createSpy('transferFailed');
+        $(document).bind('transferFailed', transferFailedSpy);
+
+        view.$('form #transfer_type_one_step').click();
+        view.$('button.initiate-transfer').click();
+      });
+
+      it("triggers a transfer failed event", function() {
+        var transferRequest = mostRecentAjaxRequest();
+        var responseBody = {
+          errors: ['Agent is unavailable']
+        }
+        transferRequest.response({ status: 422,
+                                   responseText: JSON.stringify(responseBody)});
+        expect(transferFailedSpy).toHaveBeenCalled();
+        var call = transferFailedSpy.mostRecentCall;
+        expect(call.args[1]).toMatch(/agent is unavailable/i);
+      });
+    });
+  });
+});
+

data/spec/javascripts/telephony/views/twilio_client_view_spec.js

@@ -0,0 +1,77 @@
+describe("Zest.Telephony.Views.TwilioClientView", function() {
+  describe("#initialize", function() {
+    var view;
+
+    beforeEach(function() {
+      jasmine.Ajax.useMock();
+      setFixtures("<div class='wrapper'> </div>");
+      view = new Zest.Telephony.Views.TwilioClientView({
+        csrId: 123
+      });
+    });
+
+    it("retrieves a twilio token for an agent", function() {
+      var request = mostRecentAjaxRequest();
+      expect(request.url).toBe('/zestphone/twilio_client/token?csr_id=123');
+    });
+  });
+
+  describe("#deviceAnswer", function() {
+    var view;
+    var conn = { accept: function(){} };
+
+    beforeEach(function() {
+      jasmine.Ajax.useMock();
+      setFixtures("<div class='wrapper'> </div>");
+      //agent = { onACall: function() {} };
+      view = new Zest.Telephony.Views.TwilioClientView({
+        csrId: 123
+      });
+      view.connection = conn;
+    });
+
+    it("registers a function to confirm a page reload", function() {
+      spyOn(view, 'disallowBrowserReload');
+      view.deviceAnswer();
+
+      expect(view.disallowBrowserReload).toHaveBeenCalled();
+    });
+
+    it("disables the answer button", function() {
+      view.deviceAnswer();
+
+      expect(view.$('button.answer')).toBeDisabled();
+      expect(view.$('button.answer')).not.toHaveClass('hidden');
+    });
+  });
+
+  describe("#deviceHangup", function() {
+    var view;
+
+    beforeEach(function() {
+      window.Twilio = { Device: { disconnectAll: function() {} } };
+      jasmine.Ajax.useMock();
+      setFixtures("<div class='wrapper'> </div>");
+      view = new Zest.Telephony.Views.TwilioClientView({
+        csrId: 123
+      });
+    });
+
+    afterEach(function() {
+      window.Twilio = null;
+    });
+
+    it("unregisters a function to confirm a page reload", function() {
+      spyOn(view, 'allowBrowserReload');
+      view.deviceHangup();
+
+      expect(view.allowBrowserReload).toHaveBeenCalled();
+    });
+
+    it("hides the hangup button", function() {
+      view.deviceHangup();
+
+      expect(view.$('button.hangup')).toHaveClass('hidden');
+    });
+  });
+});

data/spec/javascripts/telephony/views/widget_view_spec.js

@@ -0,0 +1,20 @@
+describe('Zest.Telephony.Views.WidgetView', function () {
+  describe('#render', function () {
+    var widgetView;
+
+    beforeEach(function () {
+      widgetView = new Zest.Telephony.Views.WidgetView();
+      widgetView.render();
+    });
+
+    it('adds the widget CSS styles', function() {
+      var widgetCss = _.last($('head link'));
+      expect($(widgetCss)).toHaveAttr('href', '/assets/telephony/widget.css');
+    });
+
+    it('adds the conversation view', function() {
+      expect($(widgetView.el)).toContain('.conversation-wrapper');
+    });
+  });
+});
+

data/spec/lib/telephony/concerns/controllers/twilio_request_verifier_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+module Telephony::Concerns::Controllers
+  describe TwilioRequestVerifier, :type => :controller do
+    let(:token) { '123456789' }
+    let(:signature) { '3ugjK9yQlIvxbBwmdF/7BfDG5Uk=' }
+
+    controller do
+      include TwilioRequestVerifier
+
+      def index
+        head :ok
+      end
+    end
+
+    it 'verifies twilio request' do
+      twilio_params = {
+        'ToState' => 'California',
+        'CalledState' => 'California',
+        'Direction' => 'inbound',
+        'FromState' => 'CA',
+        'AccountSid' => 'ACFAKEACCOUNTSID',
+        'Caller' => '+15555551235',
+        'CallerZip' => '94108',
+        'CallerCountry' => 'US',
+        'From' => '+15555551235',
+        'FromCity' => 'SAN FRANCISCO',
+        'CallerCity' => 'SAN FRANCISCO',
+        'To' => '+15555551235',
+        'FromZip' => '94108',
+        'FromCountry' => 'US',
+        'ToCity' => '',
+        'CallStatus' => 'ringing',
+        'CalledCity' => '',
+        'CallerState' => 'CA',
+        'CalledZip' => '',
+        'ToZip' => '',
+        'ToCountry' => 'US',
+        'CallSid' => 'CAFAKECALLSID',
+        'CalledCountry' => 'US',
+        'Called' => '+15555551234',
+        'ApiVersion' => '2010-04-01',
+        'ApplicationSid' => 'APFAKEAPPLICATIONSID'
+      }
+
+      controller.stub(:twilio_config).and_return({
+        :auth_token => token,
+        :callback_domain => "example.com",
+        :use_twilio_digest_auth => true
+      })
+
+      request.stub(:fullpath).and_return("/validate/voice")
+      request.stub_chain(:headers, :[]).with('HTTP_X_TWILIO_SIGNATURE')
+        .and_return(signature)
+      post :index, twilio_params
+
+      response.code.should == "200"
+    end
+
+    context "with invalid params" do
+      before do
+        request.stub_chain(:headers, :[]).with('HTTP_X_TWILIO_SIGNATURE')
+          .and_return(signature)
+        controller.stub(:twilio_config).and_return({
+          :auth_token => token,
+          :use_twilio_digest_auth => true
+        })
+      end
+
+      it "returns a 401" do
+        get :index, { :foo => 'bar' }
+        response.code.should == "401"
+        response.body.should == "Twilio request signature verification failed."
+      end
+    end
+  end
+end

data/spec/lib/telephony/conversation_data_spec.rb

@@ -0,0 +1,342 @@
+require 'spec_helper'
+
+module Telephony
+  describe ConversationData do
+    describe '.filter' do
+      before do
+        create :conversation, created_at: 5.days.ago
+        create_list :terminated_conversation, 2, created_at: 4.days.ago
+        create :terminated_conversation
+        create_list :in_progress_conversation, 3
+        create :connecting_conversation
+      end
+
+      context 'given no parameters' do
+        it 'returns all conversations' do
+          ConversationData.filter.should have(8).items
+        end
+      end
+
+      context 'given a state parameter' do
+        it 'returns conversations with that state' do
+          ConversationData.filter(state: 'terminated').should have(3).items
+        end
+      end
+
+      context 'given a since parameter' do
+        it 'returns all conversations that were created after that date' do
+          ConversationData.filter(since: 2.days.ago.to_param).should have(5).items
+        end
+      end
+
+      context 'given a combination of parameters' do
+        it 'returns all conversations that match all parameters' do
+          ConversationData.filter(since: 2.days.ago.to_param, state: 'terminated').should have(1).item
+        end
+      end
+
+      context 'any other parameters' do
+        it 'ignores them' do
+          ConversationData.filter(foo: 'bar').should have(8).items
+        end
+      end
+    end
+
+    describe '.search' do
+      context 'by default' do
+        before do
+          4.times do |n|
+            create :conversation, created_at: n.days.from_now
+          end
+          create :call_with_recording, conversation: Conversation.last
+          create :call_with_recording, conversation: Conversation.last
+          create :conversation_connect_event, conversation: Conversation.last
+
+          @conversations = ConversationData.search
+          @calls  = @conversations.first.calls
+          @events  = @conversations.first.events
+          @recordings = @calls.first.recordings
+        end
+
+        it 'returns conversations, events, calls and recordings' do
+          @conversations.count.should == 4
+          @calls.count.should == 2
+          @events.count.should == 1
+          @recordings.count.should == 1
+        end
+
+        it 'returns conversations paginated' do
+          @conversations.should respond_to(:total_pages)
+        end
+
+        it 'returns call most recently created first' do
+          @conversations.should have_at_least(2).calls
+          @conversations.each_with_index do |call, index|
+            if @conversations[index.succ].present?
+              call.created_at.should be > @conversations[index.succ].created_at
+            end
+          end
+        end
+      end
+
+      context 'given a csr id' do
+        before do
+          agent = create :agent, csr_id: 321
+          conversation = create :conversation
+          create :conversation
+          create :conversation_connect_event, conversation: conversation
+
+          create :call_with_recording,
+            conversation: conversation,
+            agent: agent
+
+          @conversations = ConversationData.search csr_id: 321
+        end
+
+        it 'returns only their conversations' do
+          @conversations.count.should == 1
+        end
+      end
+
+      context 'given query with a loan id value' do
+        before do
+          create :outbound_conversation, loan_id: 123
+          create :outbound_conversation, loan_id: 123
+          create :outbound_conversation
+
+          @conversations = ConversationData.search q: 123
+        end
+
+        it 'returns only conversations with that exact loan id' do
+          @conversations.count.should == 2
+        end
+      end
+
+      context 'given query with a phone number value' do
+        before do
+          conversation = create :conversation
+          create :call,
+            conversation: conversation,
+            number: '555-555-1111'
+          create :call,
+            conversation: conversation,
+            number: '333-333-1111'
+          create :conversation
+
+          @conversations = ConversationData.search q: '555-555-1111'
+        end
+
+        it 'returns only conversations with that phone number' do
+          @conversations.count.should == 1
+          @conversations.first.calls.size.should == 2
+        end
+      end
+
+      context 'given query with a conversation id value' do
+        before do
+          create :outbound_conversation
+          create :outbound_conversation
+          @find_me = create :outbound_conversation
+
+          @conversations = ConversationData.search q: @find_me.id
+        end
+
+        it 'returns only conversations with that id' do
+          @conversations.should == [@find_me]
+        end
+      end
+
+      context 'given query with a phone number and an agent csr id' do
+        before do
+          agent = create :agent, csr_id: 123
+          conversation = create :conversation
+          create :call,
+            conversation: conversation,
+            number: '555-555-1111',
+            agent: agent
+          create :call,
+            conversation: conversation,
+            number: '333-333-1111'
+          other_conversation = create :conversation
+          create :call,
+            conversation: other_conversation,
+            number: '555-555-1111'
+
+
+          @conversations = ConversationData.search q: '555-555-1111', csr_id: 123
+        end
+
+        it 'returns only conversations with that phone number and agent csr id' do
+          @conversations.count.should == 1
+          @conversations.first.calls.size.should == 2
+        end
+      end
+
+      context 'given a datetime range' do
+        before do
+          start_date = Time.utc(2012, 12, 2, 19, 30, 0).to_s
+          end_date = Time.utc(2012, 12, 11, 19, 30, 0).to_s
+
+          create :conversation,
+            created_at: Time.utc(2012, 12, 1, 19, 30, 0)
+          create :conversation,
+            created_at: Time.utc(2012, 12, 3, 5, 31, 0)
+          create :conversation,
+            created_at: Time.utc(2012, 12, 10, 20, 31, 0)
+          create :conversation,
+            created_at: Time.utc(2012, 12, 11, 0, 32, 0)
+
+          @conversations = ConversationData.search start_date: start_date,
+            end_date: end_date
+        end
+
+        it 'returns conversations in a datetime range' do
+          @conversations.count.should == 3
+        end
+      end
+
+      context 'given a start date' do
+        before do
+          start_date = Time.utc(2012, 12, 11, 0, 32, 0).to_s
+
+          create :conversation,
+            created_at: Time.utc(2012, 12, 1, 19, 30, 0)
+          create :conversation,
+            created_at: Time.utc(2012, 12, 3, 5, 31, 0)
+          create :conversation,
+            created_at: Time.utc(2012, 12, 10, 20, 31, 0)
+          create :conversation,
+            created_at: Time.utc(2012, 12, 11, 0, 32, 0)
+
+          @conversations = ConversationData.search start_date: start_date
+        end
+
+        it 'returns conversations from that date until now' do
+          @conversations.count.should == 1
+        end
+      end
+
+      context 'given a page' do
+        before do
+          create_list :call, 3
+
+          @page = 2
+          @conversations = ConversationData.search page: @page
+        end
+
+        it 'returns that page of conversations' do
+          @conversations.current_page.should == @page
+        end
+      end
+    end
+
+    describe '.counts' do
+      before do
+        Timecop.travel(Time.local(2012, 12, 10, 19, 30, 0))
+      end
+
+      context 'by default' do
+        before do
+          FactoryGirl.create_list :conversation, 2, :initiator_id => 1
+          FactoryGirl.create_list :conversation, 3, :initiator_id => 2
+          conversation_without_an_initiator = FactoryGirl.create :conversation,
+            :initiator_id => nil
+
+          FactoryGirl.create_list :conversation, 1, :initiator_id => 3
+          FactoryGirl.create :conversation,
+            :initiator_id => 3,
+            :created_at => 31.days.ago
+
+          @counts = ConversationData.counts
+        end
+
+        it 'returns the total number of conversations in the last 30 days per agent' do
+          @counts.keys.sort.should == [1, 2, 3]
+        end
+      end
+
+      context 'given a datetime range' do
+        before do
+          start_date = 1.week.ago.strftime('%m/%d/%Y 00:00:00 PST')
+          end_date = Date.today.strftime('%m/%d/%Y 23:59:59 PST')
+          FactoryGirl.create :conversation,
+                             :created_at => Time.utc(2012, 12, 1, 19, 30, 0),
+                             :initiator_id => 5
+          FactoryGirl.create :conversation,
+                             :created_at => Time.utc(2012, 12, 3, 5, 31, 0),
+                             :initiator_id => 10
+          FactoryGirl.create :conversation,
+                             :created_at => Time.utc(2012, 12, 10, 20, 31, 0),
+                             :initiator_id => 20
+          FactoryGirl.create :conversation,
+                             :created_at => Time.utc(2012, 12, 11, 0, 32, 0),
+                             :initiator_id => 30
+
+          @counts = ConversationData.counts :start_date => start_date,
+            :end_date => end_date
+        end
+
+        it 'returns the total number of conversations in the date range per agent' do
+          @counts.should == { 20 => 1, 30 =>1 }
+        end
+      end
+
+      context 'given a datetime but without time zone' do
+        before do
+          start_date = 1.week.ago.strftime('%m/%d/%Y 00:00:00')
+          end_date = Date.today.strftime('%m/%d/%Y 00:00:00')
+          FactoryGirl.create :conversation,
+                             :created_at => Time.utc(2012, 12, 1, 19, 30, 0),
+                             :initiator_id => 5
+          FactoryGirl.create :conversation,
+                             :created_at => Time.utc(2012, 12, 3, 5, 31, 0),
+                             :initiator_id => 10
+          FactoryGirl.create :conversation,
+                             :created_at => Time.utc(2012, 12, 10, 20, 31, 0),
+                             :initiator_id => 20
+          FactoryGirl.create :conversation,
+                             :created_at => Time.utc(2012, 12, 11, 0, 32, 0),
+                             :initiator_id => 30
+
+          @counts = ConversationData.counts :start_date => start_date,
+                                        :end_date => end_date
+        end
+
+        it 'uses treat the default timezone as UTC and returns the total number of conversations in the date range per agent' do
+          @counts.should == { 10 =>1 }
+        end
+      end
+
+
+      context 'given a date only range' do
+        before do
+          start_date = 1.week.ago.strftime('%m/%d/%Y')
+          end_date = Date.today.strftime('%m/%d/%Y')
+          FactoryGirl.create :conversation,
+                             :created_at => Time.utc(2012, 12, 1, 19, 30, 0),
+                             :initiator_id => 5
+          FactoryGirl.create :conversation,
+                             :created_at => Time.utc(2012, 12, 3, 5, 31, 0),
+                             :initiator_id => 10
+          FactoryGirl.create :conversation,
+                             :created_at => Time.utc(2012, 12, 9, 23, 50, 40),
+                             :initiator_id => 20
+          FactoryGirl.create :conversation,
+                             :created_at => Time.utc(2012, 12, 11, 0, 32, 0),
+                             :initiator_id => 30
+
+          @counts = ConversationData.counts :start_date => start_date,
+                                        :end_date => end_date
+        end
+
+        it 'uses treat the default timezone as UTC and returns the total number of conversations in the date range per agent' do
+          @counts.should == { 10 =>1, 20 => 1}
+        end
+      end
+
+      after do
+        Timecop.return
+      end
+    end
+  end
+end