History UI: Apply the pref that prohibits deleting browsing and download history.

chrome/test/data/webui/history_browsertest.js

 // Copyright (c) 2012 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.
 
+GEN('#include "chrome/test/data/webui/history_ui_browsertest.h"');
+
 /** @const */ var TOTAL_RESULT_COUNT = 160;
 /** @const */ var WAIT_TIMEOUT = 200;
 
 /**
+ * Test fixture for history WebUI testing.
+ * @constructor
+ * @extends {testing.Test}
+ */
+function HistoryUIBrowserTest() {}
+
+/**
  * Create a fake history result with the given timestamp.
  * @param {Number} timestamp Timestamp of the entry, in ms since the epoch.
  * @param {String} url The URL to set on this entry.
  * @return {Object} An object representing a history entry.
  */
 function createHistoryEntry(timestamp, url) {
   var d = new Date(timestamp);
   return {
     dateTimeOfDay: d.getHours() + ':' + d.getMinutes(),
     dateRelativeDay: d.toDateString(),
@@ skipping 101 matching lines @@
 function BaseHistoryWebUITest() {}
 
 BaseHistoryWebUITest.prototype = {
   __proto__: testing.Test.prototype,
 
   /**
    * Browse to the history page & call our preLoad().
    */
   browsePreload: 'chrome://history-frame',
 
+  /** @override */
+  typedefCppFixture: 'HistoryUIBrowserTest',

[Patrick Dubroy, 2013/04/18 14:15:19]

Sweeeet! Thanks for figuring out how to do this. This will be very helpful when
writing future tests.

+
   isAsync: true,
 
   /**
    * Register handlers to stub out calls to the history backend.
    * @override
    */
   preLoad: function() {
     this.registerMockHandler_(
         'queryHistory', this.queryHistoryStub_.bind(this));
   },
@@ skipping 97 matching lines @@
  * @constructor
  */
 function HistoryWebUITest() {}
 
 HistoryWebUITest.prototype = {
   __proto__: BaseHistoryWebUITest.prototype,
 
   preLoad: function() {
     BaseHistoryWebUITest.prototype.preLoad.call(this);
 
-    this.registerMockHandler_(
-        'removeVisits', this.removeVisitsStub_.bind(this));
+    this.registerRemoveVisitsStub_();
 
     // Prepare a list of fake history results. The entries will begin at
     // 1:00 AM on Sept 2, 2008, and will be spaced two minutes apart.
     var timestamp = new Date(2008, 9, 2, 1, 0).getTime();
     this.fakeHistory_ = [];
 
     for (var i = 0; i < TOTAL_RESULT_COUNT; i++) {
       this.fakeHistory_.push(
           createHistoryEntry(timestamp, 'http://google.com/' + timestamp));
       timestamp -= 2 * 60 * 1000;  // Next visit is two minutes earlier.
     }
   },
 
   /**
+   * Register a mock handler for the 'removeVisits' message. This is pulled out
+   * into a separate method so subclasses can override it.
+   */
+   registerRemoveVisitsStub_: function() {
+     this.registerMockHandler_(
+         'removeVisits', this.removeVisitsStub_.bind(this));
+  },
+
+  /**
    * Stub for the 'queryHistory' message to the history backend.
    * Simulates a history database using the fake history data that is
    * initialized in preLoad().
    * @param {Array} arguments The original arguments to queryHistory.
    */
   queryHistoryStub_: function(args) {
     var searchText = args[0];
     var offset = args[1];
     var range = args[2];
     var endTime = args[3] || Number.MAX_VALUE;
@@ skipping 140 matching lines @@
 /**
  * Test deletion of history entries.
  */
 TEST_F('HistoryWebUITest', 'deletion', function() {
   var checkboxes = document.querySelectorAll(
       '#results-display input[type=checkbox]');
 
   // Confirm all the things!!!
   window.confirm = function() { return true; };
 
-  // The "remote" button should be initially selected.
+  // The "remove" button should be initially disabled.

[Patrick Dubroy, 2013/04/18 14:15:19]

Haha, I don't know what happened here. Thanks for fixing.

   var removeButton = $('remove-selected');
   expectTrue(removeButton.disabled);
 
   checkboxes[0].click();
   expectFalse(removeButton.disabled);
 
   var firstEntry = document.querySelector('.title a').textContent;
   removeButton.click();
 
   // After deletion, expect the results to be reloaded.
@@ skipping 269 matching lines @@
 
   waitForCallback('historyResult', function() {
     // See if the correct number of days is shown.
     var resultsDisplay = $('results-display');
     assertEquals(0, resultsDisplay.querySelectorAll('.months-results').length);
     assertEquals(1, resultsDisplay.querySelectorAll('div').length);
 
     testDone();
   });
 });
+
+/**
+ * Fixture for History WebUI testing when deletions are prohibited.
+ * @extends {BaseHistoryWebUITest}
+ * @constructor
+ */
+function HistoryWebUIDeleteProhibitedTest() {}
+
+HistoryWebUIDeleteProhibitedTest.prototype = {
+  __proto__: HistoryWebUITest.prototype,
+
+  /**
+   * Don't stub out the 'removeVisits' call in this class.
+   * @override
+   */
+  registerRemoveVisitsStub_: function() {},
+
+  /** @override */
+  testGenPreamble: function() {
+    GEN('  SetDeleteAllowed(false);');
+  },
+};
+
+// Test UI when removing entries is prohibited.
+TEST_F('HistoryWebUIDeleteProhibitedTest', 'deleteProhibited', function() {
+  // No checkboxes should be created.
+  var checkboxes = document.querySelectorAll(
+      '#results-display input[type=checkbox]');
+  expectEquals(0, checkboxes.length);
+
+  // The "remove" button should be disabled.
+  var removeButton = $('remove-selected');
+  expectTrue(removeButton.disabled);
+
+  // The "Remove from history" drop-down item should be disabled.
+  var removeVisit = $('remove-visit');
+  expectTrue(removeVisit.disabled);
+
+  // Attempting to remove items anyway should fail.
+  waitForCallback('deleteFailed', testDone);
+  var model = new HistoryModel();

[Patrick Dubroy, 2013/04/18 14:15:19]

Why are you creating a new HistoryModel here? Why not use the one that's already
created? It's in a global var named "historyModel".

+  model.removeVisitsFromHistory(this.fakeHistory_.slice(0, 2), function () {
+    // The callback is only called on success.
+    throw new Error('Delete succeeded even though it was prohibited.');
+    testDone();

[Patrick Dubroy, 2013/04/18 14:15:19]

Hmmm, won't the test hang on failure then?

[Pam (message me for reviews), 2013/04/18 14:41:44]

In principle (I thought), if it "succeeds" (which is a failure), it throws the
error and ends the test. In practice, as you say, it times out. I thought it was
because I'm not stubbing out the history back-end call, so that gets wedged
somewhere. I couldn't figure out how to fix that. Or am I missing something
simpler?

Or do you mean on "failure", which is success for this test?
removeVisitsFromHistory calls its own callback on success, and deleteFailed on
failure. So the waitForCallback just above catches the case we expect.

[Patrick Dubroy, 2013/04/18 14:55:53]

All of these tests are required to call testDone() at the end of a successful
test. That's due to the "isAsync: true" at the top. I believe it's needed
exactly for cases like this, because control would hit the end of the test
function before the callback is called, so the test could never fail.

I think you can just do waitForCallback('deleteFailed', testDone) and it will do
what you want.

+  });
+});