Print Preview: Use cr.sendWithPromise for getInitialSettings

chrome/test/data/webui/print_preview_destination_search_test.js

 // Copyright 2016 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.
 
 var ROOT_PATH = '../../../../';
 
 GEN_INCLUDE(
         [ROOT_PATH + 'chrome/test/data/webui/polymer_browser_test_base.js']);
 
 /**
  * Test fixture for DestinationSearch of Print Preview.
  * @constructor
  * @extends {PolymerTest}
  */
 function PrintPreviewDestinationSearchTest() {}
 
 PrintPreviewDestinationSearchTest.prototype = {
   __proto__: PolymerTest.prototype,
 
   /** @override */
   browsePreload: 'chrome://print',
 
   /** @override */
   runAccessibilityChecks: false,
 
   /** @override */
-  extraLibraries: PolymerTest.getLibraries(ROOT_PATH),
+  extraLibraries: PolymerTest.getLibraries(ROOT_PATH).concat([
+      ROOT_PATH + 'chrome/test/data/webui/settings/test_browser_proxy.js',
+    ]),
+
 };
 
 TEST_F('PrintPreviewDestinationSearchTest', 'Select', function() {
   var self = this;
 
   suite('DestinationSearchTest', function() {
     var root_;
 
     var destinationSearch_;
     var nativeLayer_;
@@ skipping 57 matching lines @@
         };
 
         element.addEventListener(eventName, listener);
       });
     };
 
     function mockSetupCall(destId, nativeLayerMock) {
       var resolver = new PromiseResolver();
 
       if (cr.isChromeOS) {
-        nativeLayerMock.expects(once()).setupPrinter(destId).
+        nativeLayerMock.whenCalled('setupPrinter').
             will(returnValue(resolver.promise));
 
         return resolver;
       }
 
-      nativeLayerMock.expects(once()).startGetLocalDestinationCapabilities(
-          destId);
+      nativeLayerMock.setDestinationToWatch(destId);
       resolver.promise.then(
           function(result) {
             // Simulate the native layer dispatching capabilities.
             var capsSetEvent =
                 new Event(print_preview.NativeLayer.EventType.CAPABILITIES_SET);
             capsSetEvent.settingsInfo = result;
             destinationStore_.onLocalDestinationCapabilitiesSet_(capsSetEvent);
+            expectTrue(nativeLayerMock.didGetCapabilitiesOnce(destId));
           }.bind(this),
           function() {
             var failEvent = new Event(
                 print_preview.NativeLayer.EventType.GET_CAPABILITIES_FAIL);
             failEvent.destinationId = destId;
             destinationStore_.onGetCapabilitiesFail_(failEvent);
+            expectTrue(nativeLayerMock.didGetCapabilitiesOnce(destId));
           }.bind(this));
 
       return resolver;
     };
 
     function requestSetup(destId, destinationSearch) {
       var origin = cr.isChromeOS ? print_preview.DestinationOrigin.CROS :
                                    print_preview.DestinationOrigin.LOCAL;
 
       var dest = new print_preview.Destination(destId,
@@ skipping 16 matching lines @@
     function resolveSetup(resolver, printerId, success, capabilities) {
       var response = {
         printerId: printerId,
         capabilities: capabilities,
         success: success
       };
 
       resolver.resolve(response);
     }
 
+    /**
+     * Test version of the native layer.
+     * @constructor
+     * @extends {settings.TestBrowserProxy}
+     */
+    function NativeLayerStub() {
+      settings.TestBrowserProxy.call(this, [ 'getInitialSettings' ]);
+      this.destinationToWatch_ = '';
+      this.eventTarget_ = mock(cr.EventTarget);
+      this.getLocalDestinationCapabilitiesCallCount_ = 0;
+    }
+
+    NativeLayerStub.prototype = {
+      __proto__: settings.TestBrowserProxy.prototype,
+      didGetCapabilitiesOnce: function(destinationId) {
+        return (destinationId == this.destinationToWatch_ &&
+                this.getLocalDestinationCapabilitiesCallCount_ == 1);
+      },
+      getEventTarget: function() { return this.eventTarget_; },
+      setDestinationToWatch: function(destinationId) {
+        this.destinationToWatch_ = destinationId;
+        this.getLocalDestinationCapabilitiesCallCount_ = 0;
+      },
+      setupPrinter: function() {
+        this.methodCalled('setupPrinter');
+      },
+      startGetLocalDestinationCapabilities: function(destinationId) {
+        if (destinationId == this.destinationToWatch_)
+          this.getLocalDestinationCapabilitiesCallCount_++;
+      },
+      startHideDialog: function () {},
+    };
+    NativeLayerStub.EventType = print_preview.NativeLayer.EventType;
+
     setup(function() {
       Mock4JS.clearMocksToVerify();
-
-      nativeLayer_ = mock(print_preview.NativeLayer);
-      nativeLayer_.expects(atLeastOnce())
+      nativeLayer_ = new NativeLayerStub();
+      var nativeLayerEventTarget = nativeLayer_.getEventTarget();
+      nativeLayerEventTarget.expects(atLeastOnce())
           .addEventListener(ANYTHING, ANYTHING, ANYTHING);
 
       invitationStore_ = new print_preview.InvitationStore();
+      var nativeLayerProxy = nativeLayer_;
+      nativeLayerProxy.eventTarget_ = nativeLayerEventTarget.proxy();
       destinationStore_ = new print_preview.DestinationStore(
-          nativeLayer_.proxy(), new print_preview.UserInfo(),
+          nativeLayerProxy, new print_preview.UserInfo(),
           new print_preview.AppState());
       userInfo_ = new print_preview.UserInfo();
 
       destinationSearch_ = new print_preview.DestinationSearch(
           destinationStore_, invitationStore_, userInfo_);
       destinationSearch_.decorate($('destination-search'));
     });
 
     teardown(function() {
       Mock4JS.verifyAllMocks();
@@ skipping 60 matching lines @@
       // Simulate a click.
       dest.onActivate_();
 
       // Verify that the destination has been selected.
       assertEquals(printerId, destinationStore_.selectedDestination.id);
     });
   });
 
   mocha.run();
 });