telephony 1.0.3

data/spec/javascripts/helpers/mock-ajax.js

@@ -0,0 +1,207 @@
+/*
+ Jasmine-Ajax : a set of helpers for testing AJAX requests under the Jasmine
+ BDD framework for JavaScript.
+
+ Supports both Prototype.js and jQuery.
+
+ http://github.com/pivotal/jasmine-ajax
+
+ Jasmine Home page: http://pivotal.github.com/jasmine
+
+ Copyright (c) 2008-2010 Pivotal Labs
+
+ Permission is hereby granted, free of charge, to any person obtaining
+ a copy of this software and associated documentation files (the
+ "Software"), to deal in the Software without restriction, including
+ without limitation the rights to use, copy, modify, merge, publish,
+ distribute, sublicense, and/or sell copies of the Software, and to
+ permit persons to whom the Software is furnished to do so, subject to
+ the following conditions:
+
+ The above copyright notice and this permission notice shall be
+ included in all copies or substantial portions of the Software.
+
+ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+ MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+ LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+ OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+ WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+ */
+
+// Jasmine-Ajax interface
+var ajaxRequests = [];
+
+function mostRecentAjaxRequest() {
+  if (ajaxRequests.length > 0) {
+    return ajaxRequests[ajaxRequests.length - 1];
+  } else {
+    return null;
+  }
+}
+
+function clearAjaxRequests() {
+  ajaxRequests = [];
+}
+
+// Fake XHR for mocking Ajax Requests & Responses
+function FakeXMLHttpRequest() {
+  var extend = Object.extend || $.extend;
+  extend(this, {
+    requestHeaders: {},
+
+    open: function() {
+      this.method = arguments[0];
+      this.url = arguments[1];
+      this.readyState = 1;
+    },
+
+    setRequestHeader: function(header, value) {
+      this.requestHeaders[header] = value;
+    },
+
+    abort: function() {
+      this.readyState = 0;
+    },
+
+    readyState: 0,
+
+    onreadystatechange: function(isTimeout) {
+    },
+
+    status: null,
+
+    send: function(data) {
+      this.params = data;
+      this.readyState = 2;
+    },
+
+    getResponseHeader: function(name) {
+      return this.responseHeaders[name];
+    },
+
+    getAllResponseHeaders: function() {
+      var responseHeaders = [];
+      for (var i in this.responseHeaders) {
+        if (this.responseHeaders.hasOwnProperty(i)) {
+          responseHeaders.push(i + ': ' + this.responseHeaders[i]);
+        }
+      }
+      return responseHeaders.join('\r\n');
+    },
+
+    responseText: null,
+
+    response: function(response) {
+      this.status = response.status;
+      this.responseText = response.responseText || "";
+      this.readyState = 4;
+      this.responseHeaders = response.responseHeaders ||
+      {"Content-type": response.contentType || "application/json" };
+      // uncomment for jquery 1.3.x support
+      // jasmine.Clock.tick(20);
+
+      this.onreadystatechange();
+    },
+    responseTimeout: function() {
+      this.readyState = 4;
+      jasmine.Clock.tick(jQuery.ajaxSettings.timeout || 30000);
+      this.onreadystatechange('timeout');
+    }
+  });
+
+  return this;
+}
+
+
+jasmine.Ajax = {
+
+  isInstalled: function() {
+    return jasmine.Ajax.installed == true;
+  },
+
+  assertInstalled: function() {
+    if (!jasmine.Ajax.isInstalled()) {
+      throw new Error("Mock ajax is not installed, use jasmine.Ajax.useMock()")
+    }
+  },
+
+  useMock: function() {
+    if (!jasmine.Ajax.isInstalled()) {
+      var spec = jasmine.getEnv().currentSpec;
+      spec.after(jasmine.Ajax.uninstallMock);
+
+      jasmine.Ajax.installMock();
+    }
+  },
+
+  installMock: function() {
+    if (typeof jQuery != 'undefined') {
+      jasmine.Ajax.installJquery();
+    } else if (typeof Prototype != 'undefined') {
+      jasmine.Ajax.installPrototype();
+    } else {
+      throw new Error("jasmine.Ajax currently only supports jQuery and Prototype");
+    }
+    jasmine.Ajax.installed = true;
+  },
+
+  installJquery: function() {
+    jasmine.Ajax.mode = 'jQuery';
+    jasmine.Ajax.real = jQuery.ajaxSettings.xhr;
+    jQuery.ajaxSettings.xhr = jasmine.Ajax.jQueryMock;
+
+  },
+
+  installPrototype: function() {
+    jasmine.Ajax.mode = 'Prototype';
+    jasmine.Ajax.real = Ajax.getTransport;
+
+    Ajax.getTransport = jasmine.Ajax.prototypeMock;
+  },
+
+  uninstallMock: function() {
+    jasmine.Ajax.assertInstalled();
+    if (jasmine.Ajax.mode == 'jQuery') {
+      jQuery.ajaxSettings.xhr = jasmine.Ajax.real;
+    } else if (jasmine.Ajax.mode == 'Prototype') {
+      Ajax.getTransport = jasmine.Ajax.real;
+    }
+    jasmine.Ajax.reset();
+  },
+
+  reset: function() {
+    jasmine.Ajax.installed = false;
+    jasmine.Ajax.mode = null;
+    jasmine.Ajax.real = null;
+  },
+
+  jQueryMock: function() {
+    var newXhr = new FakeXMLHttpRequest();
+    ajaxRequests.push(newXhr);
+    return newXhr;
+  },
+
+  prototypeMock: function() {
+    return new FakeXMLHttpRequest();
+  },
+
+  installed: false,
+  mode: null
+}
+
+
+// Jasmine-Ajax Glue code for Prototype.js
+if (typeof Prototype != 'undefined' && Ajax && Ajax.Request) {
+  Ajax.Request.prototype.originalRequest = Ajax.Request.prototype.request;
+  Ajax.Request.prototype.request = function(url) {
+    this.originalRequest(url);
+    ajaxRequests.push(this);
+  };
+
+  Ajax.Request.prototype.response = function(responseOptions) {
+    return this.transport.response(responseOptions);
+  };
+}

data/spec/javascripts/support/jasmine.yml

@@ -0,0 +1,80 @@
+# src_files
+#
+# Return an array of filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# src_files:
+#   - lib/source1.js
+#   - lib/source2.js
+#   - dist/**/*.js
+#
+src_files:
+  - telephony/vendor/test_dependencies.js
+  - telephony/application.js
+
+# stylesheets
+#
+# Return an array of stylesheet filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# stylesheets:
+#   - css/style.css
+#   - stylesheets/*.css
+#
+stylesheets:
+  # - stylesheets/**/*.css
+
+# helpers
+#
+# Return an array of filepaths relative to spec_dir to include before jasmine specs.
+# Default: ["helpers/**/*.js"]
+#
+# EXAMPLE:
+#
+# helpers:
+#   - helpers/**/*.js
+#
+helpers:
+  - 'helpers/**/*.js'
+
+# spec_files
+#
+# Return an array of filepaths relative to spec_dir to include.
+# Default: ["**/*[sS]pec.js"]
+#
+# EXAMPLE:
+#
+# spec_files:
+#   - '**/*[sS]pec.js'
+#
+spec_files:
+  - '**/*[sS]pec.js'
+
+# src_dir
+#
+# Source directory path. Your src_files must be returned relative to this path. Will use root if left blank.
+# Default: project root
+#
+# EXAMPLE:
+#
+# src_dir: public
+#
+src_dir: 'app/assets/javascripts'
+
+# spec_dir
+#
+# Spec directory path. Your spec_files must be returned relative to this path.
+# Default: spec/javascripts
+#
+# EXAMPLE:
+#
+# spec_dir: spec/javascripts
+#
+spec_dir: spec/javascripts
+
+asset_paths:
+ - "vendor/assets/javascripts"

data/spec/javascripts/telephony/models/agent_spec.js

@@ -0,0 +1,40 @@
+describe("Zest.Telephony.Models.Agent", function() {
+  describe("#status", function() {
+    it("defaults to 'offline'", function() {
+      var agent = new Zest.Telephony.Models.Agent();
+      expect(agent.status()).toBe("loading...");
+    });
+  });
+
+  describe("#url", function() {
+    it("uses the correct path", function() {
+      var agent = new Zest.Telephony.Models.Agent({csr_id: 123});
+      expect(agent.url()).toBe("/zestphone/agents/123");
+    });
+  });
+
+  describe("#toggleAvailable", function() {
+    var agent;
+    var request;
+    var data;
+
+    beforeEach(function() {
+      jasmine.Ajax.useMock();
+      agent = new Zest.Telephony.Models.Agent({csr_id: 123});
+      spyOn(agent, 'done');
+
+      agent.toggleAvailable();
+      request = mostRecentAjaxRequest();
+      data = { status: "available" };
+      request.response({status: 200, responseText: JSON.stringify(data)});
+    })
+
+    it("trigger an event", function() {
+      expect(agent.done).toHaveBeenCalled();
+      expect(agent.done.mostRecentCall.args[0]).toEqual(data);
+      expect(request.method).toEqual('PUT');
+      expect(request.params).toEqual('event=toggle_available');
+      expect(request.url).toEqual('/zestphone/agents/123/status');
+    });
+  });
+});

data/spec/javascripts/telephony/models/conversation_spec.js

@@ -0,0 +1,515 @@
+describe("Zest.Telephony.Models.Conversation", function() {
+  var conversation;
+
+  beforeEach(function() {
+    conversation = new Zest.Telephony.Models.Conversation();
+  });
+
+  describe("#url", function() {
+    it("uses the correct path", function() {
+      var convo = new Zest.Telephony.Models.Conversation();
+      expect(convo.url()).toEqual('/zestphone/conversations');
+    });
+  });
+
+  describe("#create", function() {
+    describe("when succeeds", function() {
+      it("creates a conversation remotely", function() {
+        jasmine.Ajax.useMock();
+
+        var convo = new Zest.Telephony.Models.Conversation();
+        spyOn(convo, 'createSuccess');
+        convo.set({
+          loanId: '123',
+          to: "3003004002",
+          toId: '9',
+          toType: 'borrower',
+          from: "3003004000",
+          fromId: '1'
+        });
+        convo.create();
+
+        var request = mostRecentAjaxRequest();
+        var response = { id: 100, caller_call_id: 200, callee_call_id: 201 };
+        request.response({status: 200, responseText: JSON.stringify(response)});
+
+        expect(convo.createSuccess).toHaveBeenCalled();
+        expect(request.method).toEqual('POST');
+        var data = {
+          loan_id: '123',
+          from: '3003004000',
+          from_id: '1',
+          from_type: 'csr',
+          to: '3003004002',
+          to_id: '9',
+          to_type: 'borrower'
+        };
+        expect(request.params).toEqual($.param(data));
+      });
+    });
+
+    describe("when fails", function() {
+      var failHandler;
+
+      beforeEach(function() {
+        failHandler = jasmine.createSpy('fail');
+        $(document).bind('callFailed', failHandler);
+      });
+
+      it("returns an error message", function() {
+        jasmine.Ajax.useMock();
+
+        var convo = new Zest.Telephony.Models.Conversation();
+        convo.create();
+
+        var request = mostRecentAjaxRequest();
+        var response = { errors: ['some error'] };
+        request.response({status: 500, responseText: JSON.stringify(response)});
+
+        expect(failHandler).toHaveBeenCalled();
+        expect(failHandler.mostRecentCall.args[1]).toEqual('some error');
+      });
+    });
+  });
+
+  describe('#hold', function() {
+    it("changes state to 'initiating_hold'", function() {
+      jasmine.Ajax.useMock();
+
+      conversation.hold();
+      expect(conversation.get('state')).toEqual('initiating_hold');
+    });
+  });
+
+  describe('#resume', function() {
+    it("changes state to 'initiating_resume'", function() {
+      jasmine.Ajax.useMock();
+
+      conversation.resume();
+      expect(conversation.get('state')).toEqual('initiating_resume');
+    });
+  });
+
+  describe('#uiDisableCall', function() {
+    describe('given a new conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'not_initiated' });
+      });
+
+      it('enables the button', function() {
+        expect(conversation.uiDisableCall()).toEqual('');
+      });
+    });
+
+    describe('given a terminated conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'terminated' });
+      });
+
+      it('returns true', function() {
+        expect(conversation.uiDisableCall()).toEqual('');
+      });
+    });
+
+    describe('given a conversation in progress', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'in_progress' });
+      });
+
+      it('disables the call controls', function() {
+        expect(conversation.uiDisableCall()).toEqual('disabled');
+      });
+    });
+
+    describe('given a conversation with calling disabled', function() {
+      beforeEach(function() {
+        conversation.set({ callingDisabled: true });
+      });
+
+      it('disables the call controls', function() {
+        expect(conversation.uiDisableCall()).toEqual('disabled');
+      });
+    });
+  });
+
+  describe('#uiShowCall', function() {
+    describe('given a new conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'not_initiated' });
+      });
+
+      it('returns true', function() {
+        expect(conversation.uiShowCall()).toEqual('');
+      });
+    });
+
+    describe('given a connecting conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'connecting' });
+      });
+
+      it('returns true', function() {
+        expect(conversation.uiShowCall()).toEqual('');
+      });
+    });
+
+    describe('given a terminated conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'terminated' });
+      });
+
+      it('returns true', function() {
+        expect(conversation.uiShowCall()).toEqual('');
+      });
+    });
+
+    describe('given a conversation in progress', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'in_progress' });
+      });
+
+      it('hides the button', function() {
+        expect(conversation.uiShowCall()).toEqual('hidden');
+      });
+    });
+  });
+
+  describe("#uiShowHold", function() {
+    describe("given the 'in_progress' coversation", function() {
+      it("shows the hold button", function() {
+        conversation.set({state: "in_progress"});
+
+        expect(conversation.uiShowHold()).toEqual("");
+      });
+    });
+
+    describe("given the 'in_progress_two_step_transfer' coversation", function() {
+      it("shows the hold button", function() {
+        conversation.set({state: "in_progress_two_step_transfer"});
+
+        expect(conversation.uiShowHold()).toEqual("");
+      });
+    });
+
+    describe("given the 'initiating_hold' coversation", function() {
+      it("shows the hold button", function() {
+        conversation.set({state: "initiating_hold"});
+
+        expect(conversation.uiShowHold()).toEqual("");
+      });
+    });
+  });
+
+  describe('#uiDisableTransfer', function() {
+    describe('given an in progress conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'in_progress' });
+      });
+
+      it('enables the button', function() {
+        expect(conversation.uiDisableTransfer()).toEqual('');
+      });
+    });
+
+    describe('given an "initiating_hold" conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'initiating_hold' });
+      });
+
+      it('disables the button', function() {
+        expect(conversation.uiDisableTransfer()).toEqual('disabled');
+      });
+    });
+
+    describe('given a "on-hold" conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'in_progress_hold' });
+      });
+
+      it('enables the button', function() {
+        expect(conversation.uiDisableTransfer()).toEqual('');
+      });
+    });
+
+    describe('given a "initiating_resume" conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'initiating_resume' });
+      });
+
+      it('disables the button', function() {
+        expect(conversation.uiDisableTransfer()).toEqual('disabled');
+      });
+    });
+
+    describe('given a not in progress conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'connecting'});
+      });
+
+      it('returns true', function() {
+        expect(conversation.uiDisableTransfer()).toEqual('disabled');
+      });
+    });
+  });
+
+  describe('#uiShowTransfer', function() {
+    describe('given a cancelable conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'in_progress', isCancelable: true });
+      });
+
+      it('hides the button', function() {
+        expect(conversation.uiShowTransfer()).toEqual('hidden');
+      });
+    });
+
+    describe('given a transferable conversation', function() {
+      var displayableStates;
+
+      beforeEach(function() {
+        displayableStates = ['in_progress', 'one_step_transferring',
+          'in_progress_hold', 'two_step_transferring', 'in_progress_two_step_transfer',
+          'initiating_hold', 'initiating_resume'];
+      });
+
+      it('shows the button', function() {
+        _.each(displayableStates, function(state) {
+          conversation.set({ state: state });
+          expect(conversation.uiShowTransfer()).toEqual('');
+        });
+      });
+    });
+
+    describe('given a non-transferable conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'connecting'});
+      });
+
+      it('hides the button', function() {
+        expect(conversation.uiShowTransfer()).toEqual('hidden');
+      });
+    });
+  });
+
+  describe("#uiDisableResume", function() {
+    describe("given an 'initiating_resume' conversation", function() {
+      it("disables the button", function() {
+        conversation.set({state: 'initiating_resume', owner: true});
+
+        expect(conversation.uiDisableResume()).toEqual("disabled");
+      });
+    });
+
+    describe("given an 'in_progress' conversation", function() {
+      describe("for the conversation owner", function() {
+        it("enables the button", function() {
+          conversation.set({state: 'in_progress', owner: true});
+
+          expect(conversation.uiDisableResume()).toEqual("");
+        });
+      });
+
+      describe("for the conversation non-owner", function() {
+        it("disables the button", function() {
+          conversation.set({state: 'in_progress', owner: false});
+
+          expect(conversation.uiDisableResume()).toEqual("disabled");
+        });
+      });
+    });
+  });
+
+  describe("#uiDisableHold", function() {
+    describe("given an 'initiating_hold' conversation", function() {
+      it("disables the button", function() {
+        conversation.set({state: 'initiating_hold', owner: true});
+
+        expect(conversation.uiDisableHold()).toEqual("disabled");
+      });
+    });
+
+    describe("given an 'in_progress' conversation", function() {
+      describe("for the conversation owner", function() {
+        it("enables the button", function() {
+          conversation.set({state: 'in_progress', owner: true});
+
+          expect(conversation.uiDisableHold()).toEqual("");
+        });
+      });
+
+      describe("for the conversation non-owner", function() {
+        it("disables the button", function() {
+          conversation.set({state: 'in_progress', owner: false});
+
+          expect(conversation.uiDisableHold()).toEqual("disabled");
+        });
+      });
+    });
+  });
+
+  describe("#uiShowResume", function() {
+    describe("given an 'in_progress_hold' conversation", function() {
+      it("shows the button", function() {
+        conversation.set({state: 'in_progress_hold'});
+
+        expect(conversation.uiShowResume()).toEqual("");
+      });
+    });
+
+    describe("given an 'initiating_resume' conversation", function() {
+      it("shows the button", function() {
+        conversation.set({state: 'initiating_resume'});
+
+        expect(conversation.uiShowResume()).toEqual("");
+      });
+    });
+
+    describe("given an 'in_progress' conversation", function() {
+      it("hides the button", function() {
+        conversation.set({state: 'in_progress'});
+
+        expect(conversation.uiShowResume()).toEqual("hidden");
+      });
+    });
+  });
+
+  describe('#uiShowCancelTransfer', function() {
+    describe('given a cancelable conversation', function() {
+      beforeEach(function() {
+        conversation.set({ isCancelable: true });
+      });
+
+      it('returns true', function() {
+        expect(conversation.uiShowCancelTransfer()).toEqual('');
+      });
+    });
+
+    describe('given a not-cancelable conversation', function() {
+      beforeEach(function() {
+        conversation.set({ isCancelable: false });
+      });
+
+      it('hides the button', function() {
+        expect(conversation.uiShowCancelTransfer()).toEqual('hidden');
+      });
+    });
+  });
+
+  describe('#uiShowCallSpinner', function() {
+    describe('given a connecting conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'connecting' });
+      });
+
+      it('returns true', function() {
+        expect(conversation.uiShowCallSpinner()).toEqual('display');
+      });
+    });
+
+    describe('given a not-connecting conversation', function() {
+      beforeEach(function() {
+        conversation.set({ state: 'in_progress' });
+      });
+
+      it('shows the button', function() {
+        expect(conversation.uiShowCallSpinner()).toEqual('');
+      });
+    });
+  });
+
+  describe("#uiShowHoldSpinner", function() {
+    describe("given 'intiating_hold' conversation", function() {
+      it("shows the spinner", function() {
+        conversation.set({ state: 'initiating_hold' });
+
+        expect(conversation.uiShowHoldSpinner()).toEqual('display');
+      });
+    });
+
+    describe("given an 'in_progress' conversation", function() {
+      it("doesn't show the spinner", function() {
+        conversation.set({ state: 'in_progress' });
+
+        expect(conversation.uiShowHoldSpinner()).toEqual('');
+      });
+    });
+  });
+
+  describe("#uiShowResumeSpinner", function() {
+    describe("given 'intiating_resume' conversation", function() {
+      it("shows the spinner", function() {
+        conversation.set({ state: 'initiating_resume' });
+
+        expect(conversation.uiShowResumeSpinner()).toEqual('display');
+      });
+    });
+
+    describe("given an 'in_progress' conversation", function() {
+      it("doesn't show the spinner", function() {
+        conversation.set({ state: 'in_progress' });
+
+        expect(conversation.uiShowResumeSpinner()).toEqual('');
+      });
+    });
+  });
+
+  describe('#isValid', function() {
+    var conversation;
+
+    describe('given a conversation with a valid phone number', function() {
+      var validPhoneNumbers;
+
+      beforeEach(function() {
+        validPhoneNumbers = ['555-111-1111', '+1 222-222-2222'];
+      });
+
+      it('returns true', function() {
+        _.each(validPhoneNumbers, function(phoneNumber) {
+          conversation = new Zest.Telephony.Models.Conversation({
+            from: '222-333-4444',
+            to: phoneNumber
+          });
+          expect(conversation.isValid()).toBeTruthy(phoneNumber + ' is not valid');
+        });
+      });
+    });
+
+    describe('given a conversation with an invalid phone number', function() {
+      var invalidPhoneNumbers;
+
+      beforeEach(function() {
+        invalidPhoneNumbers = [null, '', 111, '(111)', '111-111-1111', '+2 333-333-3333'];
+      });
+
+      it('returns false', function() {
+        _.each(invalidPhoneNumbers, function(phoneNumber) {
+          conversation = new Zest.Telephony.Models.Conversation({
+            from: '222-333-4444',
+            to: phoneNumber
+          });
+          expect(conversation.isValid()).toBeFalsy(phoneNumber + ' is valid');
+          expect(conversation.errorMessage).toEqual('Please enter a 10-digit phone number');
+        });
+      });
+    });
+
+    describe('given a conversation from and to the same number', function() {
+      var agentNumber;
+
+      beforeEach(function() {
+        agentNumber = '222-333-4444';
+      });
+
+      it('returns false', function() {
+        _.each(['222-333-4444', '2223334444', '(222) 333-4444'], function(callee) {
+          conversation = new Zest.Telephony.Models.Conversation({
+            from: agentNumber,
+            to: callee
+          });
+          expect(conversation.isValid()).toBeFalsy();
+          expect(conversation.errorMessage).toEqual('Please input a customer phone number');
+        });
+      });
+    });
+  });
+});