Merge pull request #6111 from ferjm/805825

Bug 805825 - [MMI] Follow up: handle USSD session expiration; r=arcturus a=arcturus

apps/communications/dialer/js/ussd.js

@@ -101,10 +101,11 @@ var UssdManager = {
       case 'ussdreceived':
         this._pendingRequest = null;
         // Do not notify the UI if no message to show.
-        if (evt.message)
+        if (evt.message != null || evt.sessionEnded)
           message = {
             type: 'ussdreceived',
-            message: evt.message
+            message: evt.message,
+            sessionEnded: evt.sessionEnded
           };
         break;
       case 'voicechange':

apps/communications/dialer/js/ussd_ui.js

@@ -123,10 +123,17 @@ var UssdUI = {
         break;
       case 'error':
         this.showMessage(evt.data.error ?
-          evt.data.result : this._('mmi-error'));
+          evt.data.error : this._('mmi-error'));
         break;
       case 'ussdreceived':
-        this.showResponseForm();
+        if (evt.data.sessionEnded) {
+          this.hideResponseForm();
+          if (evt.data.message == null) {
+            evt.data.message = this._('mmi-session-expired');
+          }
+        } else {
+          this.showResponseForm();
+        }
         this.showMessage(evt.data.message);
         break;
       case 'voicechange':

apps/communications/dialer/test/unit/mock_mozMobileConnection.js

@@ -1,37 +1,67 @@
 'use strict';
 
+requireApp('communications/dialer/js/ussd.js');
+
+const SUCCESS_MMI_NO_MSG = 'sucess_mmi_no_msg';
+const FAILED_MMI_NO_MSG = 'failed_mmi_no_msg';
+const SUCCESS_MMI_MSG = 'success_mmi_msg';
+const FAILED_MMI_MSG = 'failed_mmi_msg';
+const USSD_MSG = 'ussd_msg';
+
 var MockMozMobileConnection = {
-  _ussd_listener_function: null,
-  _ussd_listener_object: null,
-  _ussd_message_sent: false,
-  _ussd_cancelled: false,
+  addEventListener: function mmmc_addEventListener(event_name, listener) {
+  },
+
   sendMMI: function mmmc_sendMMI(message) {
-    this._ussd_message_sent = true;
     var evt = {
-      type: 'ussdreceived',
-      message: message + '- Received'
+      target: {
+        result: null,
+        error: {
+          name: null
+        }
+      }
     };
-    if (this._ussd_listener_object) {
-      this._ussd_listener_object.handleEvent(evt);
-    } else if (this._ussd_listener_function) {
-      this._ussd_listener_function(evt);
+
+    switch (message) {
+      case SUCCESS_MMI_NO_MSG:
+        evt.target.result = null;
+        UssdManager.notifySuccess(evt);
+        break;
+      case SUCCESS_MMI_MSG:
+        evt.target.result = SUCCESS_MMI_MSG;
+        UssdManager.notifySuccess(evt);
+        break;
+      case FAILED_MMI_NO_MSG:
+        evt.target.error.name = null;
+        UssdManager.notifyError(evt);
+        break;
+      case FAILED_MMI_MSG:
+        evt.target.error.name = FAILED_MMI_MSG;
+        UssdManager.notifyError(evt);
+        break;
     }
+
     var domRequest = {};
     return domRequest;
   },
+
   cancelMMI: function mmmc_cancelMMI() {
-    this._ussd_cancelled = true;
+    UssdManager.notifySuccess({
+      target: {
+        result: null
+      }
+    });
   },
-  addEventListener: function mmmc_addEventListener(event_name, listener) {
-    if (event_name === 'ussdreceived') {
-      if (typeof listener === 'object')
-        this._ussd_listener_object = listener;
-      else if (typeof listener === 'function')
-        this._ussd_listener_function = listener;
-    }
+
+  triggerUssdReceived: function mmmc_triggerUssdReceived(message,
+                                                         sessionEnded) {
+    UssdManager.handleEvent({
+      type: 'ussdreceived',
+      message: message,
+      sessionEnded: sessionEnded
+    });
   },
+
   teardown: function mmmc_teardown() {
-    this._ussd_message_sent = false;
-    this._ussd_cancelled = false;
   }
 };

apps/communications/dialer/test/unit/mock_ussd_ui.js

@@ -4,10 +4,23 @@ var MockUssdUI = {
 
   ready: true,
   _messageReceived: null,
+  _sessionEnded: null,
 
   postMessage: function muui_postMessage(message) {
-    if (message.type === 'ussdreceived')
-      this._messageReceived = message.message;
+    switch (message.type) {
+      case 'ussdreceived':
+        this._messageReceived = message.message;
+        this._sessionEnded = message.sessionEnded;
+        break;
+      case 'success':
+        this._messageReceived = message.result;
+        this._sessionEnded = null;
+        break;
+      case 'error':
+        this._messageReceived = message.error;
+        this._sessionEnded = null;
+        break;
+    }
   },
 
   reply: function muui_reply(message) {

apps/communications/dialer/test/unit/ussd_test.js

@@ -29,58 +29,140 @@ suite('dialer/ussd', function() {
       UssdManager._popup.teardown();
   });
 
-  suite('ussd message sending', function() {
+  suite('Successfully send ussd message with result', function() {
+    setup(function() {
+      UssdManager.send(SUCCESS_MMI_MSG);
+    });
+
+    test('Check request result', function() {
+      assert.equal(UssdManager._popup._messageReceived, SUCCESS_MMI_MSG);
+    });
+
+    test('Check sessionEnded null', function() {
+      assert.isNull(UssdManager._popup._sessionEnded);
+    });
+  });
 
+  suite('Successfully send ussd message no result', function() {
     setup(function() {
-      UssdManager.send('This is a message.');
+      UssdManager.send(SUCCESS_MMI_NO_MSG);
     });
 
-    test('ussd message sent', function() {
-      assert.isTrue(UssdManager._conn._ussd_message_sent);
+    test('Check empty request result', function() {
+      assert.isNull(UssdManager._popup._messageReceived);
+    });
+
+    test('Check sessionEnded null', function() {
+      assert.isNull(UssdManager._popup._sessionEnded);
+    });
+  });
+
+  suite('Error sending ussd message with result', function() {
+    setup(function() {
+      UssdManager.send(FAILED_MMI_MSG);
     });
 
-    test('ussd response by server', function() {
-      assert.equal(UssdManager._popup._messageReceived,
-        'This is a message.- Received');
+    test('Check request result', function() {
+      assert.equal(UssdManager._popup._messageReceived, FAILED_MMI_MSG);
     });
 
+    test('Check sessionEnded null', function() {
+      assert.isNull(UssdManager._popup._sessionEnded);
+    });
   });
 
-  suite('ussd message reply via UI', function() {
+  suite('Error sending ussd message no result', function() {
+    setup(function() {
+      UssdManager.send(FAILED_MMI_NO_MSG);
+    });
 
+    test('Check empty request result', function() {
+      assert.isNull(UssdManager._popup._messageReceived);
+    });
+
+    test('Check sessionEnded null', function() {
+      assert.isNull(UssdManager._popup._sessionEnded);
+    });
+  });
+
+  suite('Ussd received with message and session active', function() {
     setup(function() {
-      UssdManager._popup.reply('This is a second message.');
+      UssdManager._conn.triggerUssdReceived(USSD_MSG, false);
+    });
+
+    test('Check request result', function() {
+      assert.equal(UssdManager._popup._messageReceived, USSD_MSG);
     });
 
-    test('ussd reply message sent', function() {
-      assert.isTrue(UssdManager._conn._ussd_message_sent);
+    test('Check sessionEnded false', function() {
+      assert.isFalse(UssdManager._popup._sessionEnded);
     });
+  });
 
-    test('ussd response to reply message by server', function() {
-      assert.equal(UssdManager._popup._messageReceived,
-        'This is a second message.- Received');
+  suite('Ussd received with message and session ended', function() {
+    setup(function() {
+      UssdManager._conn.triggerUssdReceived(USSD_MSG, true);
     });
 
+    test('Check message', function() {
+      assert.equal(UssdManager._popup._messageReceived, USSD_MSG);
+    });
+
+    test('Check sessionEnded true', function() {
+      assert.isTrue(UssdManager._popup._sessionEnded);
+    });
   });
 
-  suite('ussd cancelling via UI', function() {
+  suite('Ussd received with no message and session active', function() {
+    setup(function() {
+      UssdManager._popup._messageReceived = null;
+      UssdManager._popup._sessionEnded = null;
+      UssdManager._conn.triggerUssdReceived(null, false);
+    });
 
+    test('Check no message received', function() {
+      assert.isNull(UssdManager._popup._messageReceived);
+      assert.isNull(UssdManager._popup._sessionEnded);
+    });
+
+  });
+
+  suite('Ussd received with no message and session ended', function() {
     setup(function() {
-      // UssdManager._popup reset to MockUssdUI since
-      // this suite's setup sets it to null via closeWindow().
-      // Otherwise, the second test setup would fail.
-      UssdManager._popup = MockUssdUI;
-      UssdManager._popup.closeWindow();
+      UssdManager._conn.triggerUssdReceived(null, true);
     });
 
-    test('ussd cancelled', function() {
-      assert.isTrue(UssdManager._conn._ussd_cancelled);
+    test('Check no message', function() {
+      assert.isNull(UssdManager._popup._messageReceived);
     });
 
-    test('ussd UI closed', function() {
-      assert.isNull(UssdManager._popup);
+    test('Check sessionEnded true', function() {
+      assert.isTrue(UssdManager._popup._sessionEnded);
     });
+  });
 
+  suite('Ussd message reply via UI', function() {
+    setup(function() {
+      UssdManager._popup.reply(SUCCESS_MMI_MSG);
+    });
+
+    test('Check request result', function() {
+      assert.equal(UssdManager._popup._messageReceived, SUCCESS_MMI_MSG);
+    });
+
+    test('Check sessionEnded null', function() {
+      assert.isNull(UssdManager._popup._sessionEnded);
+    });
   });
 
+  suite('Cancel ussd via UI', function() {
+    setup(function() {
+      UssdManager._popup.closeWindow();
+    });
+
+    test('Check ussd UI closed', function() {
+      assert.isNull(UssdManager._popup);
+    });
+
+  });
 });