Unregister from GCM when the only GCM app is removed
[chromium-blink-merge.git] / chrome / test / data / webui / history_browsertest.js
blob03350b71cc180d4c46e048d6f577cb787de46d2e
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
5 GEN('#include "chrome/test/data/webui/history_ui_browsertest.h"');
7 /** @const */ var TOTAL_RESULT_COUNT = 160;
8 /** @const */ var WAIT_TIMEOUT = 200;
10 /**
11  * Test fixture for history WebUI testing.
12  * @constructor
13  * @extends {testing.Test}
14  */
15 function HistoryUIBrowserTest() {}
17 /**
18  * Create a fake history result with the given timestamp.
19  * @param {Number} timestamp Timestamp of the entry, in ms since the epoch.
20  * @param {String} url The URL to set on this entry.
21  * @return {Object} An object representing a history entry.
22  */
23 function createHistoryEntry(timestamp, url) {
24   var d = new Date(timestamp);
25   // Extract domain from url.
26   var domainMatch = url.replace(/^.+?:\/\//, '').match(/[^/]+/);
27   var domain = domainMatch ? domainMatch[0] : '';
28   return {
29     dateTimeOfDay: d.getHours() + ':' + d.getMinutes(),
30     dateRelativeDay: d.toDateString(),
31     allTimestamps: [timestamp],
32     starred: false,
33     time: timestamp,
34     title: d.toString(),  // Use the stringified date as the title.
35     url: url,
36     domain: domain
37   };
40 /**
41  * Wait for the history backend to call the global function named
42  * |callbackName|, and then execute |afterFunction|. This allows tests to
43  * wait on asynchronous backend operations before proceeding.
44  */
45 function waitForCallback(callbackName, afterFunction) {
46   var originalCallback = window[callbackName];
48   // Install a wrapper that temporarily replaces the original function.
49   window[callbackName] = function() {
50     window[callbackName] = originalCallback;
51     originalCallback.apply(this, arguments);
52     afterFunction();
53   };
56 /**
57  * Asynchronously execute the global function named |functionName|. This
58  * should be used for all calls from backend stubs to the frontend.
59  */
60 function callFrontendAsync(functionName) {
61   var args = Array.prototype.slice.call(arguments, 1);
62   setTimeout(function() {
63     window[functionName].apply(window, args);
64   }, 1);
67 /**
68  * Checks that all the checkboxes in the [|start|, |end|] interval are checked
69  * and that their IDs are properly set. Does that against the checkboxes in
70  * |checked|, starting from the |startInChecked| position.
71  * @param {Array} checked An array of all the relevant checked checkboxes
72  *    on this page.
73  * @param {Number} start The starting checkbox id.
74  * @param {Number} end The ending checkbox id.
75  */
76 function checkInterval(checked, start, end) {
77   for (var i = start; i <= end; i++)
78     expectEquals('checkbox-' + i, checked[i - start].id);
81 /**
82  * Returns a period of 7 days, |offset| weeks back from |today|. The behavior
83  * of this function should be identical to
84  * BrowsingHistoryHandler::SetQueryTimeInWeeks.
85  * @param {Number} offset Number of weeks to go back.
86  * @param {Date} today Which date to consider as "today" (since we're not using
87  *     the actual current date in this case).
88  * @return {Object} An object containing the begin date and the end date of the
89  *     computed period.
90  */
91 function setQueryTimeInWeeks(offset, today) {
92   // Going back one day at a time starting from midnight will make sure that
93   // the other values get updated properly.
94   var endTime = new Date(today);
95   endTime.setHours(24, 0, 0, 0);
96   for (var i = 0; i < 7 * offset; i++)
97     endTime.setDate(endTime.getDate() - 1);
98   var beginTime = new Date(endTime);
99   for (var i = 0; i < 7; i++)
100     beginTime.setDate(beginTime.getDate() - 1);
101   return {'endTime': endTime, 'beginTime': beginTime};
105  * Returns the period of a month, |offset| months back from |today|. The
106  * behavior of this function should be identical to
107  * BrowsingHistoryHandler::SetQueryTimeInMonths.
108  * @param {Number} offset Number of months to go back.
109  * @param {Date} today Which date to consider as "today" (since we're not using
110  *     the actual current date in this case).
111  * @return {Object} An object containing the begin date and the end date of the
112  *     computed period.
113  */
114 function setQueryTimeInMonths(offset, today) {
115   var endTime = new Date(today);
116   var beginTime = new Date(today);
117   // Last day of this month.
118   endTime.setMonth(endTime.getMonth() + 1, 0);
119   // First day of the current month.
120   beginTime.setMonth(beginTime.getMonth(), 1);
121   for (var i = 0; i < offset; i++) {
122     beginTime.setMonth(beginTime.getMonth() - 1);
123     endTime.setMonth(endTime.getMonth() - 1);
124   }
125   return {'endTime': endTime, 'beginTime': beginTime};
129  * Base fixture for History WebUI testing.
130  * @extends {testing.Test}
131  * @constructor
132  */
133 function BaseHistoryWebUITest() {}
135 BaseHistoryWebUITest.prototype = {
136   __proto__: testing.Test.prototype,
138   /**
139    * Browse to the history page & call our preLoad().
140    */
141   browsePreload: 'chrome://history-frame',
143   /** @override */
144   typedefCppFixture: 'HistoryUIBrowserTest',
146   /** @override */
147   runAccessibilityChecks: true,
149   /** @override */
150   accessibilityIssuesAreErrors: true,
152   /** @override */
153   isAsync: true,
157  * Fixture for History WebUI testing which returns some fake history results
158  * to the frontend. Other fixtures that want to stub out calls to the backend
159  * can extend this one.
160  * @extends {BaseHistoryWebUITest}
161  * @constructor
162  */
163 function HistoryWebUIFakeBackendTest() {
166 HistoryWebUIFakeBackendTest.prototype = {
167   __proto__: BaseHistoryWebUITest.prototype,
169   /**
170    * Register handlers to stub out calls to the history backend.
171    * @override
172    */
173   preLoad: function() {
174     this.registerMockHandler_(
175         'queryHistory', this.queryHistoryStub_.bind(this));
176   },
178   /**
179    * Register a mock handler for a message to the history backend.
180    * @param handlerName The name of the message to mock.
181    * @param handler The mock message handler function.
182    */
183   registerMockHandler_: function(handlerName, handler) {
184     // Mock4JS doesn't pass in the actual arguments to the stub, but it _will_
185     // pass the original args to the matcher object. SaveMockArguments acts as
186     // a proxy for another matcher, but keeps track of all the arguments it was
187     // asked to match.
188     var savedArgs = new SaveMockArguments();
190     this.makeAndRegisterMockHandler([handlerName]);
191     this.mockHandler.stubs()[handlerName](savedArgs.match(ANYTHING)).will(
192         callFunctionWithSavedArgs(savedArgs, handler));
193   },
195   /**
196    * Default stub for the queryHistory message to the history backend.
197    * Simulates an empty history database. Override this to customize this
198    * behavior for particular tests.
199    * @param {Array} arguments The original arguments to queryHistory.
200    */
201   queryHistoryStub_: function(args) {
202     callFrontendAsync(
203         'historyResult', { term: args[0], finished: true }, []);
204   }
207 function queryHistoryImpl(args, beginTime, history) {
208   var searchText = args[0];
209   var offset = args[1];
210   var range = args[2];
211   var endTime = args[3] || Number.MAX_VALUE;
212   var maxCount = args[4];
214   var results = [];
215   if (searchText) {
216     for (var k = 0; k < history.length; k++) {
217       // Search only by title in this stub.
218       if (history[k].title.indexOf(searchText) != -1)
219         results.push(history[k]);
220     }
221   } else {
222     results = history;
223   }
225   // Advance past all entries newer than the specified end time.
226   var i = 0;
227   // Finished is set from the history database so this behavior may not be
228   // completely identical.
229   var finished = true;
230   while (i < results.length && results[i].time >= endTime)
231     ++i;
233   if (beginTime) {
234     var j = i;
235     while (j < results.length && results[j].time >= beginTime)
236       ++j;
238     finished = (j == results.length);
239     results = results.slice(i, j);
240   } else {
241     results = results.slice(i);
242   }
244   if (maxCount) {
245     finished = (maxCount >= results.length);
246     results = results.slice(0, maxCount);
247   }
249   var queryStartTime = '';
250   var queryEndTime = '';
251   if (results.length) {
252     queryStartTime = results[results.length - 1].dateRelativeDay;
253     queryEndTime = results[0].dateRelativeDay;
254   } else if (beginTime) {
255     queryStartTime = Date(beginTime);
256     queryEndTime = Date(endTime);
257   }
259   callFrontendAsync(
260       'historyResult',
261       {
262         term: searchText,
263         finished: finished,
264         queryStartTime: queryStartTime,
265         queryEndTime: queryEndTime
266       },
267       results);
271  * Fixture for History WebUI testing which returns some fake history results
272  * to the frontend.
273  * @extends {HistoryWebUIFakeBackendTest}
274  * @constructor
275  */
276 function HistoryWebUITest() {}
278 HistoryWebUITest.prototype = {
279   __proto__: HistoryWebUIFakeBackendTest.prototype,
281   preLoad: function() {
282     HistoryWebUIFakeBackendTest.prototype.preLoad.call(this);
284     this.registerMockHandler_(
285         'removeVisits', this.removeVisitsStub_.bind(this));
287     // Prepare a list of fake history results. The entries will begin at
288     // 1:00 AM on Sept 2, 2008, and will be spaced two minutes apart.
289     var timestamp = new Date(2008, 9, 2, 1, 0).getTime();
290     this.fakeHistory_ = [];
292     for (var i = 0; i < TOTAL_RESULT_COUNT; i++) {
293       this.fakeHistory_.push(
294           createHistoryEntry(timestamp, 'http://google.com/' + timestamp));
295       timestamp -= 2 * 60 * 1000;  // Next visit is two minutes earlier.
296     }
297   },
299   /**
300    * Stub for the 'queryHistory' message to the history backend.
301    * Simulates a history database using the fake history data that is
302    * initialized in preLoad().
303    * @param {Array} arguments The original arguments to queryHistory.
304    */
305   queryHistoryStub_: function(args) {
306     var searchText = args[0];
307     var offset = args[1];
308     var range = args[2];
309     var endTime = args[3] || Number.MAX_VALUE;
310     var maxCount = args[4];
311     if (range == HistoryModel.Range.ALL_TIME) {
312       queryHistoryImpl(args, null, this.fakeHistory_);
313       return;
314     }
315     if (range == HistoryModel.Range.WEEK)
316       var interval = setQueryTimeInWeeks(offset, this.today);
317     else
318       var interval = setQueryTimeInMonths(offset, this.today);
320     args[3] = interval.endTime.getTime();
321     queryHistoryImpl(args, interval.beginTime.getTime(), this.fakeHistory_);
322   },
324   /**
325    * Stub for the 'removeVisits' message to the history backend.
326    * This will modify the fake history data in the test instance, so that
327    * further 'queryHistory' messages will not contain the deleted entries.
328    * @param {Array} arguments The original arguments to removeVisits.
329    */
330   removeVisitsStub_: function(args) {
331     for (var i = 0; i < args.length; ++i) {
332       var url = args[i].url;
333       var timestamps = args[i].timestamps;
334       assertEquals(timestamps.length, 1);
335       this.removeVisitsToUrl_(url, new Date(timestamps[0]));
336     }
337     callFrontendAsync('deleteComplete');
338   },
340   /**
341    * Removes any visits to |url| on the same day as |date| from the fake
342    * history data.
343    * @param {string} url
344    * @param {Date} date
345    */
346   removeVisitsToUrl_: function(url, date) {
347     var day = date.toDateString();
348     var newHistory = [];
349     for (var i = 0, visit; visit = this.fakeHistory_[i]; ++i) {
350       if (url != visit.url || visit.dateRelativeDay != day)
351         newHistory.push(visit);
352     }
353     this.fakeHistory_ = newHistory;
354   }
358  * Examines the time column of every entry on the page, and ensure that they
359  * are all the same width.
360  */
361 function ensureTimeWidthsEqual() {
362   var times = document.querySelectorAll('.entry .time');
363   var timeWidth = times[0].clientWidth;
364   for (var i = 1; i < times.length; ++i) {
365     assertEquals(timeWidth, times[i].clientWidth);
366   }
369 TEST_F('HistoryWebUIFakeBackendTest', 'emptyHistory', function() {
370   expectTrue($('newest-button').hidden);
371   expectTrue($('newer-button').hidden);
372   expectTrue($('older-button').hidden);
373   testDone();
376 // Times out on Win: http://crbug.com/336845
377 TEST_F('HistoryWebUITest', 'DISABLED_basicTest', function() {
378   var resultCount = document.querySelectorAll('.entry').length;
380   // Check that there are two days of entries.
381   var dayHeaders = document.querySelectorAll('.day');
382   assertEquals(2, dayHeaders.length);
383   expectNotEquals(dayHeaders[0].textContent, dayHeaders[1].textContent);
385   // Check that the entries in each day are time-ordered, and that no
386   // duplicate URLs appear on a given day.
387   var urlsByDay = {};
388   var lastDate = new Date();
389   for (var day = 0; day < dayHeaders.length; ++day) {
390     var dayTitle = dayHeaders[day].textContent;
391     var dayResults = document.querySelectorAll('.day-results')[day];
392     var entries = dayResults.querySelectorAll('.entry');
393     expectGT(entries.length, 0);
395     for (var i = 0, entry; entry = entries[i]; ++i) {
396       var time = entry.querySelector('.time').textContent;
397       expectGT(time.length, 0);
399       var date = new Date(dayTitle + ' ' + time);
400       expectGT(lastDate, date);
401       lastDate = date;
403       // Ensure it's not a duplicate URL for this day.
404       var dayAndUrl = day + entry.querySelector('a').href;
405       expectFalse(urlsByDay.hasOwnProperty(dayAndUrl));
406       urlsByDay[dayAndUrl] = dayAndUrl;
408       // Reconstruct the entry date from the title, and ensure that it's
409       // consistent with the date header and with the time.
410       var entryDate = new Date(entry.querySelector('.title').textContent);
411       expectEquals(entryDate.getYear(), date.getYear());
412       expectEquals(entryDate.getMonth(), date.getMonth());
413       expectEquals(entryDate.getDay(), date.getDay());
414       expectEquals(entryDate.getHours(), date.getHours());
415       expectEquals(entryDate.getMinutes(), date.getMinutes());
416     }
417   }
419   // Check that there are 3 page navigation links and that only the "Older"
420   // link is visible.
421   expectEquals(3, document.querySelectorAll('[is="action-link"]').length);
422   expectTrue($('newest-button').hidden);
423   expectTrue($('newer-button').hidden);
424   expectFalse($('older-button').hidden);
426   ensureTimeWidthsEqual();
428   // Go to the next page.
429   $('older-button').click();
430   waitForCallback('historyResult', function() {
431     resultCount += document.querySelectorAll('.entry').length;
433     // Check that the two pages include all of the entries.
434     expectEquals(TOTAL_RESULT_COUNT, resultCount);
436     // Check that the day header was properly continued -- the header for the
437     // last day on the first page should be a substring of the header on the
438     // second page. E.g. "Wed, Oct 8, 2008" and "Web, Oct 8, 2008 - cont'd".
439     var newDayHeaders = document.querySelectorAll('.day');
440     expectEquals(1, newDayHeaders.length);
441     expectEquals(0,
442         newDayHeaders[0].textContent.indexOf(dayHeaders[1].textContent));
444     // Check that the "Newest" and "Newer" links are now visible, but the
445     // "Older" link is hidden.
446     expectEquals(3, document.querySelectorAll('[is="action-link"]').length);
447     expectFalse($('newest-button').hidden);
448     expectFalse($('newer-button').hidden);
449     expectTrue($('older-button').hidden);
451     ensureTimeWidthsEqual();
453     // Go back to the first page, and check that the same day headers are there.
454     $('newest-button').click();
455     var newDayHeaders = document.querySelectorAll('.day');
456     expectEquals(2, newDayHeaders.length);
458     expectNotEquals(newDayHeaders[0].textContent,
459                     newDayHeaders[1].textContent);
460     expectEquals(dayHeaders[0].textContent, newDayHeaders[0].textContent);
461     expectEquals(dayHeaders[1].textContent, newDayHeaders[1].textContent);
463     testDone();
464   });
468  * Test bulk deletion of history entries.
469  * Disabled because it is currently very flaky on the Windows XP bot.
470  */
471 TEST_F('HistoryWebUITest', 'DISABLED_bulkDeletion', function() {
472   var checkboxes = document.querySelectorAll(
473       '#results-display input[type=checkbox]');
475   // Immediately confirm the history deletion.
476   confirmDeletion = function(okCallback, cancelCallback) {
477     okCallback();
478   };
480   // The "remove" button should be initially disabled.
481   var removeButton = $('remove-selected');
482   expectTrue(removeButton.disabled);
484   checkboxes[0].click();
485   expectFalse(removeButton.disabled);
487   var firstEntry = document.querySelector('.title a').textContent;
488   removeButton.click();
490   // After deletion, expect the results to be reloaded.
491   waitForCallback('historyResult', function() {
492     expectNotEquals(document.querySelector('.title a').textContent, firstEntry);
493     expectTrue(removeButton.disabled);
495     // Delete the first 3 entries.
496     checkboxes = document.querySelectorAll(
497         '#results-display input[type=checkbox]');
498     checkboxes[0].click();
499     checkboxes[1].click();
500     checkboxes[2].click();
501     expectFalse(removeButton.disabled);
503     var nextEntry = document.querySelectorAll('.title a')[3];
504     removeButton.click();
505     waitForCallback('historyResult', function() {
506       // The next entry after the deleted ones should now be the first.
507       expectEquals(document.querySelector('.title a').textContent,
508                    nextEntry.textContent);
509       testDone();
510     });
511   });
515  * Test selecting multiple entries using shift click.
516  * Disabled due to time out on all platforms: crbug/375910
517  */
518 TEST_F('HistoryWebUITest', 'DISABLED_multipleSelect', function() {
519   var checkboxes = document.querySelectorAll(
520       '#results-display input[type=checkbox]');
522   var getAllChecked = function() {
523     return Array.prototype.slice.call(document.querySelectorAll(
524         '#results-display input[type=checkbox]:checked'));
525   };
527   // Make sure that nothing is checked.
528   expectEquals(0, getAllChecked().length);
530   var shiftClick = function(el) {
531     el.dispatchEvent(new MouseEvent('click', { shiftKey: true }));
532   };
534   // Check the start.
535   shiftClick($('checkbox-4'));
536   // And the end.
537   shiftClick($('checkbox-9'));
539   // See if they are checked.
540   var checked = getAllChecked();
541   expectEquals(6, checked.length);
542   checkInterval(checked, 4, 9);
544   // Extend the selection.
545   shiftClick($('checkbox-14'));
547   checked = getAllChecked();
548   expectEquals(11, checked.length);
549   checkInterval(checked, 4, 14);
551   // Now do a normal click on a higher ID box and a shift click on a lower ID
552   // one (test the other way around).
553   $('checkbox-24').click();
554   shiftClick($('checkbox-19'));
556   checked = getAllChecked();
557   expectEquals(17, checked.length);
558   // First set of checkboxes (11).
559   checkInterval(checked, 4, 14);
560   // Second set (6).
561   checkInterval(checked.slice(11), 19, 24);
563   // Test deselection.
564   $('checkbox-26').click();
565   shiftClick($('checkbox-20'));
567   checked = getAllChecked();
568   // checkbox-20 to checkbox-24 should be deselected now.
569   expectEquals(12, checked.length);
570   // First set of checkboxes (11).
571   checkInterval(checked, 4, 14);
572   // Only checkbox-19 should still be selected.
573   expectEquals('checkbox-19', checked[11].id);
575   testDone();
578 TEST_F('HistoryWebUITest', 'DISABLED_searchHistory', function() {
579   var getResultCount = function() {
580     return document.querySelectorAll('.entry').length;
581   };
582   // See that all the elements are there.
583   expectEquals(RESULTS_PER_PAGE, getResultCount());
585   // See that the search works.
586   $('search-field').value = 'Thu Oct 02 2008';
587   $('search-button').click();
589   waitForCallback('historyResult', function() {
590     expectEquals(31, getResultCount());
592     // Clear the search.
593     $('search-field').value = '';
594     $('search-button').click();
595     waitForCallback('historyResult', function() {
596       expectEquals(RESULTS_PER_PAGE, getResultCount());
597       testDone();
598     });
599   });
602 function setPageState(searchText, page, groupByDomain, range, offset) {
603   window.location = '#' + PageState.getHashString(
604       searchText, page, groupByDomain, range, offset);
607 function RangeHistoryWebUITest() {}
609 RangeHistoryWebUITest.prototype = {
610   __proto__: HistoryWebUITest.prototype,
612   /** @override */
613   preLoad: function() {
614     HistoryWebUITest.prototype.preLoad.call(this);
615     // Repeat the domain visits every 4 days. The nested lists contain the
616     // domain suffixes for the visits in a day.
617     var domainSuffixByDay = [
618       [1, 2, 3, 4],
619       [1, 2, 2, 3],
620       [1, 2, 1, 2],
621       [1, 1, 1, 1]
622     ];
624     var buildDomainUrl = function(timestamp) {
625       var d = new Date(timestamp);
626       // Repeat the same setup of domains every 4 days.
627       var day = d.getDate() % 4;
628       // Assign an entry for every 6 hours so that we get 4 entries per day
629       // maximum.
630       var visitInDay = Math.floor(d.getHours() / 6);
631       return 'http://google' + domainSuffixByDay[day][visitInDay] + '.com/' +
632           timestamp;
633     };
635     // Prepare a list of fake history results. Start the results on
636     // 11:00 PM on May 2, 2012 and add 4 results every day (one result every 6
637     // hours).
638     var timestamp = new Date(2012, 4, 2, 23, 0).getTime();
639     this.today = new Date(2012, 4, 2);
640     this.fakeHistory_ = [];
642     // Put in 2 days for May and 30 days for April so the results span over
643     // the month limit.
644     for (var i = 0; i < 4 * 32; i++) {
645       this.fakeHistory_.push(
646           createHistoryEntry(timestamp, buildDomainUrl(timestamp)));
647       timestamp -= 6 * 60 * 60 * 1000;
648     }
650     // Leave March empty.
651     timestamp -= 31 * 24 * 3600 * 1000;
653     // Put results in February.
654     for (var i = 0; i < 29 * 4; i++) {
655       this.fakeHistory_.push(
656           createHistoryEntry(timestamp, buildDomainUrl(timestamp)));
657       timestamp -= 6 * 60 * 60 * 1000;
658     }
659   },
661   setUp: function() {
662     // Show the filter controls as if the command line switch was active.
663     $('top-container').hidden = true;
664     $('history-page').classList.add('big-topbar-page');
665     $('filter-controls').hidden = false;
666     expectFalse($('filter-controls').hidden);
667   },
671  * Disabled due intermitent failures on multiple OSes http://crbug.com/377338
672  */
673 TEST_F('RangeHistoryWebUITest', 'DISABLED_allView', function() {
674   // Check that we start off in the all time view.
675   expectTrue($('timeframe-controls').querySelector('input').checked);
676   // See if the correct number of days is shown.
677   var dayHeaders = document.querySelectorAll('.day');
678   assertEquals(Math.ceil(RESULTS_PER_PAGE / 4), dayHeaders.length);
679   testDone();
683  * Checks whether the domains in a day are ordered decreasingly.
684  * @param {Element} element Ordered list containing the grouped domains for a
685  *     day.
686  */
687 function checkGroupedVisits(element) {
688   // The history page contains the number of visits next to a domain in
689   // parentheses (e.g. 'google.com (5)'). This function extracts that number
690   // and returns it.
691   var getNumberVisits = function(element) {
692     return parseInt(element.textContent.replace(/\D/g, ''), 10);
693   };
695   // Read the number of visits from each domain and make sure that it is lower
696   // than or equal to the number of visits from the previous domain.
697   var domainEntries = element.querySelectorAll('.number-visits');
698   var currentNumberOfVisits = getNumberVisits(domainEntries[0]);
699   for (var j = 1; j < domainEntries.length; j++) {
700     var numberOfVisits = getNumberVisits(domainEntries[j]);
701     assertTrue(currentNumberOfVisits >= numberOfVisits);
702     currentNumberOfVisits = numberOfVisits;
703   }
706 TEST_F('RangeHistoryWebUITest', 'weekViewGrouped', function() {
707   // Change to weekly view.
708   setPageState('', 0, HistoryModel.Range.WEEK, 0);
709   waitForCallback('historyResult', function() {
710     // See if the correct number of days is still shown.
711     var dayResults = document.querySelectorAll('.day-results');
712     assertEquals(7, dayResults.length);
714     // Check whether the results are ordered by visits.
715     for (var i = 0; i < dayResults.length; i++)
716       checkGroupedVisits(dayResults[i]);
718     ensureTimeWidthsEqual();
720     testDone();
721   });
724 TEST_F('RangeHistoryWebUITest', 'monthViewGrouped', function() {
725   // Change to monthly view.
726   setPageState('', 0, HistoryModel.Range.MONTH, 0);
727   waitForCallback('historyResult', function() {
728     // See if the correct number of days is shown.
729     var monthResults = document.querySelectorAll('.month-results');
730     assertEquals(1, monthResults.length);
732     checkGroupedVisits(monthResults[0]);
733     ensureTimeWidthsEqual();
735     testDone();
736   });
739 TEST_F('RangeHistoryWebUITest', 'monthViewEmptyMonth', function() {
740   // Change to monthly view.
741   setPageState('', 0, HistoryModel.Range.MONTH, 2);
743   waitForCallback('historyResult', function() {
744     // See if the correct number of days is shown.
745     var resultsDisplay = $('results-display');
746     assertEquals(0, resultsDisplay.querySelectorAll('.months-results').length);
747     var noResults = loadTimeData.getString('noResults');
748     assertNotEquals(-1, $('results-header').textContent.indexOf(noResults));
750     testDone();
751   });
755  * Fixture for History WebUI tests using the real history backend.
756  * @extends {BaseHistoryWebUITest}
757  * @constructor
758  */
759 function HistoryWebUIRealBackendTest() {}
761 HistoryWebUIRealBackendTest.prototype = {
762   __proto__: BaseHistoryWebUITest.prototype,
764   /** @override */
765   testGenPreamble: function() {
766     // Add some visits to the history database.
767     GEN('  AddPageToHistory(0, "http://google.com", "Google");');
768     GEN('  AddPageToHistory(1, "http://example.com", "Example");');
769     GEN('  AddPageToHistory(2, "http://google.com", "Google");');
771     // Add a visit on the next day.
772     GEN('  AddPageToHistory(36, "http://google.com", "Google");');
773   },
777  * Simple test that verifies that the correct entries are retrieved from the
778  * history database and displayed in the UI.
779  */
780 TEST_F('HistoryWebUIRealBackendTest', 'basic', function() {
781   // Check that there are two days of entries, and three entries in total.
782   assertEquals(2, document.querySelectorAll('.day').length);
783   assertEquals(3, document.querySelectorAll('.entry').length);
785   testDone();
788 TEST_F('HistoryWebUIRealBackendTest', 'atLeastOneFocusable', function() {
789   var results = document.querySelectorAll('#results-display [tabindex="0"]');
790   expectGE(results.length, 1);
791   testDone();
794 TEST_F('HistoryWebUIRealBackendTest', 'deleteRemovesEntry', function() {
795   assertTrue(historyModel.deletingHistoryAllowed);
797   var visit = document.querySelector('.entry').visit;
798   visit.titleLink.focus();
799   assertEquals(visit.titleLink, document.activeElement);
801   var deleteKey = document.createEvent('KeyboardEvent');
802   deleteKey.initKeyboardEvent('keydown', true, true, window, 'U+007F');
803   assertEquals('U+007F', deleteKey.keyIdentifier);
805   assertFalse(historyModel.isDeletingVisits());
806   expectFalse(visit.titleLink.dispatchEvent(deleteKey));
807   expectTrue(historyModel.isDeletingVisits());
809   expectNotEquals(visit.dropDown, document.activeElement);
810   testDone();
814  * Test individual deletion of history entries.
815  */
816 TEST_F('HistoryWebUIRealBackendTest', 'singleDeletion', function() {
817   // Deletes the history entry represented by |entryElement|, and calls callback
818   // when the deletion is complete.
819   var removeEntry = function(entryElement, callback) {
820     var dropDownButton = entryElement.querySelector('.drop-down');
821     var removeMenuItem = $('remove-visit');
823     assertFalse(dropDownButton.disabled);
824     assertFalse(removeMenuItem.disabled);
826     waitForCallback('onEntryRemoved', callback);
828     cr.dispatchSimpleEvent(dropDownButton, 'mousedown');
830     var e = new Event('command', {bubbles: true});
831     e.command = removeMenuItem.command;
832     removeMenuItem.dispatchEvent(e);
833   };
835   var secondTitle = document.querySelectorAll('.entry a')[1].textContent;
836   var thirdTitle = document.querySelectorAll('.entry a')[2].textContent;
838   // historyDeleted() should not be called when deleting individual entries
839   // using the drop down.
840   waitForCallback('historyDeleted', function() {
841     testDone([false, 'historyDeleted() called when deleting single entry']);
842   });
844   expectEquals(2, document.querySelectorAll('.day').length);
846   // Delete the first entry. The previous second entry should now be the first.
847   removeEntry(document.querySelector('.entry'), function() {
848     expectEquals(secondTitle, document.querySelector('.entry a').textContent);
850     // After removing the first entry, its day header should also be gone.
851     expectEquals(1, document.querySelectorAll('.day').length);
853     // Delete another entry. The original third entry should now be the first.
854     removeEntry(document.querySelector('.entry'), function() {
855       expectEquals(thirdTitle, document.querySelector('.entry a').textContent);
856       testDone();
857     });
858   });
861 TEST_F('HistoryWebUIRealBackendTest', 'leftRightChangeFocus', function() {
862   var visit = document.querySelector('.entry').visit;
863   visit.titleLink.focus();
864   assertEquals(visit.titleLink, document.activeElement);
866   var right = document.createEvent('KeyboardEvent');
867   right.initKeyboardEvent('keydown', true, true, window, 'Right');
868   assertEquals('Right', right.keyIdentifier);
869   expectFalse(visit.titleLink.dispatchEvent(right));
871   assertEquals(visit.dropDown, document.activeElement);
873   var left = document.createEvent('KeyboardEvent');
874   left.initKeyboardEvent('keydown', true, true, window, 'Left');
875   assertEquals('Left', left.keyIdentifier);
876   expectFalse(visit.dropDown.dispatchEvent(left));
878   expectEquals(visit.titleLink, document.activeElement);
879   testDone();
882 TEST_F('HistoryWebUIRealBackendTest', 'showConfirmDialogAndCancel', function() {
883   waitForCallback('deleteComplete', function() {
884     testDone([false, "history deleted when it shouldn't have been"]);
885   });
887   document.querySelector('input[type=checkbox]').click();
888   $('remove-selected').click();
890   assertTrue($('alertOverlay').classList.contains('showing'));
891   assertFalse($('history-page').contains(document.activeElement));
893   var esc = document.createEvent('KeyboardEvent');
894   esc.initKeyboardEvent('keydown', true, true, window, 'U+001B');
896   document.documentElement.dispatchEvent(esc);
897   assertFalse($('alertOverlay').classList.contains('showing'));
899   testDone();
902 TEST_F('HistoryWebUIRealBackendTest', 'showConfirmDialogAndRemove', function() {
903   document.querySelector('input[type=checkbox]').click();
904   $('remove-selected').click();
906   assertTrue($('alertOverlay').classList.contains('showing'));
907   assertFalse($('history-page').contains(document.activeElement));
909   waitForCallback('deleteComplete', testDone);
911   var enter = document.createEvent('KeyboardEvent');
912   enter.initKeyboardEvent('keydown', true, true, window, 'Enter');
913   document.documentElement.dispatchEvent(enter);
914   assertFalse($('alertOverlay').classList.contains('showing'));
917 TEST_F('HistoryWebUIRealBackendTest', 'menuButtonActivatesOneRow', function() {
918   var entries = document.querySelectorAll('.entry');
919   assertEquals(3, entries.length);
920   assertTrue(entries[0].classList.contains('active'));
921   assertTrue($('action-menu').hidden);
923   // Show the menu via mousedown on the menu button.
924   var menuButton = entries[2].querySelector('.menu-button');
925   menuButton.dispatchEvent(new MouseEvent('mousedown'));
926   expectFalse($('action-menu').hidden);
928   // Check that the 'active' item has changed.
929   expectTrue(entries[2].classList.contains('active'));
930   expectFalse(entries[0].classList.contains('active'));
932   testDone();
935 TEST_F('HistoryWebUIRealBackendTest', 'shiftClickActivatesOneRow', function() {
936   var entries = document.querySelectorAll('.entry');
937   assertEquals(3, entries.length);
938   assertTrue(entries[0].classList.contains('active'));
940   entries[0].visit.checkBox.focus();
941   assertEquals(entries[0].visit.checkBox, document.activeElement);
943   entries[0].visit.checkBox.click();
944   assertTrue(entries[0].visit.checkBox.checked);
946   var entryBox = entries[2].querySelector('.entry-box');
947   entryBox.dispatchEvent(new MouseEvent('click', {shiftKey: true}));
948   assertTrue(entries[1].visit.checkBox.checked);
950   // Focus shouldn't have changed, but the checkbox should toggle.
951   expectEquals(entries[0].visit.checkBox, document.activeElement);
953   expectTrue(entries[0].classList.contains('active'));
954   expectFalse(entries[2].classList.contains('active'));
956   var shiftDown = new MouseEvent('mousedown', {shiftKey: true, bubbles: true});
957   entries[2].visit.checkBox.dispatchEvent(shiftDown);
958   expectEquals(entries[2].visit.checkBox, document.activeElement);
960   // 'focusin' events aren't dispatched while tests are run in batch (e.g.
961   // --test-launcher-jobs=2). Simulate this. TODO(dbeam): fix instead.
962   cr.dispatchSimpleEvent(document.activeElement, 'focusin', true, true);
964   expectFalse(entries[0].classList.contains('active'));
965   expectTrue(entries[2].classList.contains('active'));
967   testDone();
971  * Fixture for History WebUI testing when deletions are prohibited.
972  * @extends {HistoryWebUIRealBackendTest}
973  * @constructor
974  */
975 function HistoryWebUIDeleteProhibitedTest() {}
977 HistoryWebUIDeleteProhibitedTest.prototype = {
978   __proto__: HistoryWebUIRealBackendTest.prototype,
980   /** @override */
981   testGenPreamble: function() {
982     HistoryWebUIRealBackendTest.prototype.testGenPreamble.call(this);
983     GEN('  SetDeleteAllowed(false);');
984   },
987 // Test UI when removing entries is prohibited.
988 TEST_F('HistoryWebUIDeleteProhibitedTest', 'deleteProhibited', function() {
989   // No checkboxes should be created.
990   var checkboxes = document.querySelectorAll(
991       '#results-display input[type=checkbox]');
992   expectEquals(0, checkboxes.length);
994   // The "remove" button should be disabled.
995   var removeButton = $('remove-selected');
996   expectTrue(removeButton.disabled);
998   // The "Remove from history" drop-down item should be disabled.
999   var removeVisit = $('remove-visit');
1000   expectTrue(removeVisit.disabled);
1002   testDone();
1005 TEST_F('HistoryWebUIDeleteProhibitedTest', 'atLeastOneFocusable', function() {
1006   var results = document.querySelectorAll('#results-display [tabindex="0"]');
1007   expectGE(results.length, 1);
1008   testDone();
1011 TEST_F('HistoryWebUIDeleteProhibitedTest', 'leftRightChangeFocus', function() {
1012   var visit = document.querySelector('.entry').visit;
1013   visit.titleLink.focus();
1014   assertEquals(visit.titleLink, document.activeElement);
1016   var right = document.createEvent('KeyboardEvent');
1017   right.initKeyboardEvent('keydown', true, true, window, 'Right');
1018   assertEquals('Right', right.keyIdentifier);
1019   expectFalse(visit.titleLink.dispatchEvent(right));
1021   assertEquals(visit.dropDown, document.activeElement);
1023   var left = document.createEvent('KeyboardEvent');
1024   left.initKeyboardEvent('keydown', true, true, window, 'Left');
1025   assertEquals('Left', left.keyIdentifier);
1026   expectFalse(visit.dropDown.dispatchEvent(left));
1028   expectEquals(visit.titleLink, document.activeElement);
1029   testDone();
1032 TEST_F('HistoryWebUIDeleteProhibitedTest', 'deleteIgnored', function() {
1033   assertFalse(historyModel.deletingHistoryAllowed);
1035   var visit = document.querySelector('.entry').visit;
1036   visit.titleLink.focus();
1037   assertEquals(visit.titleLink, document.activeElement);
1039   var deleteKey = document.createEvent('KeyboardEvent');
1040   deleteKey.initKeyboardEvent('keydown', true, true, window, 'U+007F');
1041   assertEquals('U+007F', deleteKey.keyIdentifier);
1043   assertFalse(historyModel.isDeletingVisits());
1044   expectTrue(visit.titleLink.dispatchEvent(deleteKey));
1045   expectFalse(historyModel.isDeletingVisits());
1047   expectEquals(visit.titleLink, document.activeElement);
1048   testDone();
1052  * Fixture for History WebUI testing IDN.
1053  * @extends {BaseHistoryWebUITest}
1054  * @constructor
1055  */
1056 function HistoryWebUIIDNTest() {}
1058 HistoryWebUIIDNTest.prototype = {
1059   __proto__: BaseHistoryWebUITest.prototype,
1061   /** @override */
1062   testGenPreamble: function() {
1063     // Add some visits to the history database.
1064     GEN('  AddPageToHistory(0, "http://xn--d1abbgf6aiiy.xn--p1ai/",' +
1065         ' "Some");');
1067     // Clear AcceptLanguages to get domain in unicode.
1068     GEN('  ClearAcceptLanguages();');
1069   },
1073  * Simple test that verifies that the correct entries are retrieved from the
1074  * history database and displayed in the UI.
1075  */
1076 TEST_F('HistoryWebUIIDNTest', 'basic', function() {
1077   // Check that there is only one entry and domain is in unicode.
1078   assertEquals(1, document.querySelectorAll('.domain').length);
1079   assertEquals("\u043f\u0440\u0435\u0437\u0438\u0434\u0435\u043d\u0442." +
1080                "\u0440\u0444", document.querySelector('.domain').textContent);
1082   testDone();
1086  * Fixture for a test that uses the real backend and tests how the history
1087  * page deals with odd schemes in URLs.
1088  * @extends {HistoryWebUIRealBackendTest}
1089  */
1090 function HistoryWebUIWithSchemesTest() {}
1092 HistoryWebUIWithSchemesTest.prototype = {
1093   __proto__: HistoryWebUIRealBackendTest.prototype,
1095   /** @override */
1096   testGenPreamble: function() {
1097     // Add a bunch of entries on the same day, including some weird schemes.
1098     GEN('  AddPageToHistory(12, "http://google.com", "Google");');
1099     GEN('  AddPageToHistory(13, "file:///tmp/foo", "");');
1100     GEN('  AddPageToHistory(14, "mailto:chromium@chromium.org", "");');
1101     GEN('  AddPageToHistory(15, "tel:555123456", "");');
1102   },
1104   setUp: function() {
1105     // Show the filter controls as if the command line switch was active.
1106     $('top-container').hidden = true;
1107     $('history-page').classList.add('big-topbar-page');
1108     $('filter-controls').hidden = false;
1109     expectFalse($('filter-controls').hidden);
1110   },
1113 TEST_F('HistoryWebUIWithSchemesTest', 'groupingWithSchemes', function() {
1114   // Switch to the week view.
1115   $('timeframe-controls').querySelectorAll('input')[1].click();
1116   waitForCallback('historyResult', function() {
1117     // Each URL should be organized under a different "domain".
1118     expectEquals(document.querySelectorAll('.entry').length, 4);
1119     expectEquals(document.querySelectorAll('.site-domain-wrapper').length, 4);
1120     testDone();
1121   });