Make cvox2 output feedback more robust when focusing a text field.

chrome/browser/resources/chromeos/chromevox/testing/mock_tts.js

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * Mock tts class.
  * @constructor
  * @extends {cvox.TtsInterface}
  */
 var MockTts = function() {
 };
 
 MockTts.prototype = {
   /**
    * A list of predicate, start, and end callbacks for a pending expectation.
    * @type {!Array<{{predicate: function(string) : boolean,
    *     startCallback: function() : void,
    *     endCallback: function() : void}>}
    * @private
    */
   expectations_: [],
 
   /**
    * A list of strings stored whenever there are no expectations.
    * @type {!Array<string}
    * @private
    */
   idleUtterances_: [],
 
+  /**
+   * Whether we should skip non-matching utterances. Initially it's set
+   * to true, but after the first matching utterance it's set to false
+   * so that we can assert that no extra unrelated speech is generated.

[David Tseng, 2015/08/19 17:19:25]

I think this is called a strict mock.

+   */

[David Tseng, 2015/08/19 17:19:25]

nit: @private

+  skipNonMatchingUtterances_: true,

[Peter Lundblad, 2015/08/20 08:30:06]

I support this in principal, but it has the potential to be flaky.  In end
to end tests like this there are some things we don't have control over.  When
running these tests locally, I always get a system alert about 'connected
to eth1' and I don't think we can be sure those happen first.  Perhaps we need
to whitelist a few unrelated utterances to be able to enable more strictness.

+
   /** @override */
   speak: function(textString, queueMode, properties) {
     this.process_(textString, false, properties);
   },
 
   /**
    * Adds an expectation for the given string to be spoken. If satisfied,
    * |opt_callback| is called.
    * @param {string} expectedText
    * @param {function() : void=} opt_callback
@@ skipping 32 matching lines @@
   /**
    * @private
    * @param {string} expectedText Text expected spoken.
    * @param {{startCallback: function() : void,
    *     endCallback: function() : void}=} opt_expectation
    * @param {boolean=} opt_exact Expects an exact match.
    */
   addExpectation_: function(expectedText, opt_expectation, opt_exact) {
     var expectation = opt_expectation ? opt_expectation : {};
 
+    expectation.text = expectedText;
     expectation.predicate = function(actualText) {
       if (opt_exact)
         return actualText === expectedText;
       return actualText.indexOf(expectedText) != -1;
     };
 
     this.expectations_.push(expectation);
 
     // Process any idleUtterances.
     this.idleUtterances_.forEach(function(utterance) {
@@ skipping 11 matching lines @@
     var utterance = {text: textString, properties: opt_properties};
     if (this.expectations_.length == 0) {
       if (!opt_manual) {
         this.idleUtterances_.push(utterance);
       }
       return;
     }
 
     var allUtterances = this.idleUtterances_.concat([utterance]);
     var targetExpectation = this.expectations_.shift();
-    allUtterances = allUtterances.filter(function(u) {
-      return targetExpectation.predicate(u.text);
-    });
+
+    if (this.skipNonMatchingUtterances_) {
+      allUtterances = allUtterances.filter(function(u) {
+        return targetExpectation.predicate(u.text);
+      });
+    } else if (allUtterances.length > 0 &&
+               !targetExpectation.predicate(allUtterances[0].text)) {
+      throw new Error('Mock TTS expected ' + targetExpectation.text +
+                      ' but got ' + allUtterances[0].text);
+      return;
+    }
+
     if (allUtterances.length > 0) {
+      // We got a match. Don't skip any more non-matching utterances
+      // anymore.

[Peter Lundblad, 2015/08/20 08:30:06]

nit: any more, anymore

+      this.skipNonMatchingUtterances_ = false;
+
       var matchingProperties = allUtterances[0].properties;
       this.idleUtterances_.length = 0;
       if (targetExpectation.endCallback)
         targetExpectation.endCallback();
       if (matchingProperties && matchingProperties.endCallback) {
         matchingProperties.endCallback();
       }
       var nextExpectation = this.expectations_[0];
       if (nextExpectation && nextExpectation.startCallback)
         nextExpectation.startCallback();
     } else {
       this.expectations_.unshift(targetExpectation);
     }
   },
 };