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;
11 * Test fixture for history WebUI testing.
13 * @extends {testing.Test}
15 function HistoryUIBrowserTest() {}
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.
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] : '';
29 dateTimeOfDay: d.getHours() + ':' + d.getMinutes(),
30 dateRelativeDay: d.toDateString(),
31 allTimestamps: [timestamp],
34 title: d.toString(), // Use the stringified date as the title.
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.
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);
57 * Asynchronously execute the global function named |functionName|. This
58 * should be used for all calls from backend stubs to the frontend.
60 function callFrontendAsync(functionName) {
61 var args = Array.prototype.slice.call(arguments, 1);
62 setTimeout(function() {
63 window[functionName].apply(window, args);
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
73 * @param {Number} start The starting checkbox id.
74 * @param {Number} end The ending checkbox id.
76 function checkInterval(checked, start, end) {
77 for (var i = start; i <= end; i++)
78 expectEquals('checkbox-' + i, checked[i - start].id);
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
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
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);
125 return {'endTime': endTime, 'beginTime': beginTime};
129 * Base fixture for History WebUI testing.
130 * @extends {testing.Test}
133 function BaseHistoryWebUITest() {}
135 BaseHistoryWebUITest.prototype = {
136 __proto__: testing.Test.prototype,
139 * Browse to the history page & call our preLoad().
141 browsePreload: 'chrome://history-frame',
144 typedefCppFixture: 'HistoryUIBrowserTest',
147 runAccessibilityChecks: true,
150 accessibilityIssuesAreErrors: 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}
163 function HistoryWebUIFakeBackendTest() {
166 HistoryWebUIFakeBackendTest.prototype = {
167 __proto__: BaseHistoryWebUITest.prototype,
170 * Register handlers to stub out calls to the history backend.
173 preLoad: function() {
174 this.registerMockHandler_(
175 'queryHistory', this.queryHistoryStub_.bind(this));
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.
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
188 var savedArgs = new SaveMockArguments();
190 this.makeAndRegisterMockHandler([handlerName]);
191 this.mockHandler.stubs()[handlerName](savedArgs.match(ANYTHING)).will(
192 callFunctionWithSavedArgs(savedArgs, handler));
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.
201 queryHistoryStub_: function(args) {
203 'historyResult', { term: args[0], finished: true }, []);
207 function queryHistoryImpl(args, beginTime, history) {
208 var searchText = args[0];
209 var offset = args[1];
211 var endTime = args[3] || Number.MAX_VALUE;
212 var maxCount = args[4];
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]);
225 // Advance past all entries newer than the specified end time.
227 // Finished is set from the history database so this behavior may not be
228 // completely identical.
230 while (i < results.length && results[i].time >= endTime)
235 while (j < results.length && results[j].time >= beginTime)
238 finished = (j == results.length);
239 results = results.slice(i, j);
241 results = results.slice(i);
245 finished = (maxCount >= results.length);
246 results = results.slice(0, maxCount);
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);
264 queryStartTime: queryStartTime,
265 queryEndTime: queryEndTime
271 * Fixture for History WebUI testing which returns some fake history results
273 * @extends {HistoryWebUIFakeBackendTest}
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.
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.
305 queryHistoryStub_: function(args) {
306 var searchText = args[0];
307 var offset = args[1];
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_);
315 if (range == HistoryModel.Range.WEEK)
316 var interval = setQueryTimeInWeeks(offset, this.today);
318 var interval = setQueryTimeInMonths(offset, this.today);
320 args[3] = interval.endTime.getTime();
321 queryHistoryImpl(args, interval.beginTime.getTime(), this.fakeHistory_);
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.
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]));
337 callFrontendAsync('deleteComplete');
341 * Removes any visits to |url| on the same day as |date| from the fake
343 * @param {string} url
346 removeVisitsToUrl_: function(url, date) {
347 var day = date.toDateString();
349 for (var i = 0, visit; visit = this.fakeHistory_[i]; ++i) {
350 if (url != visit.url || visit.dateRelativeDay != day)
351 newHistory.push(visit);
353 this.fakeHistory_ = newHistory;
358 * Examines the time column of every entry on the page, and ensure that they
359 * are all the same width.
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);
369 TEST_F('HistoryWebUIFakeBackendTest', 'emptyHistory', function() {
370 expectTrue($('newest-button').hidden);
371 expectTrue($('newer-button').hidden);
372 expectTrue($('older-button').hidden);
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.
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);
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());
419 // Check that there are 3 page navigation links and that only the "Older"
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);
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);
468 * Test bulk deletion of history entries.
469 * Disabled because it is currently very flaky on the Windows XP bot.
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) {
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);
515 * Test selecting multiple entries using shift click.
516 * Disabled due to time out on all platforms: crbug/375910
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'));
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 }));
535 shiftClick($('checkbox-4'));
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);
561 checkInterval(checked.slice(11), 19, 24);
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);
578 TEST_F('HistoryWebUITest', 'DISABLED_searchHistory', function() {
579 var getResultCount = function() {
580 return document.querySelectorAll('.entry').length;
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());
593 $('search-field').value = '';
594 $('search-button').click();
595 waitForCallback('historyResult', function() {
596 expectEquals(RESULTS_PER_PAGE, getResultCount());
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,
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 = [
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
630 var visitInDay = Math.floor(d.getHours() / 6);
631 return 'http://google' + domainSuffixByDay[day][visitInDay] + '.com/' +
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
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
644 for (var i = 0; i < 4 * 32; i++) {
645 this.fakeHistory_.push(
646 createHistoryEntry(timestamp, buildDomainUrl(timestamp)));
647 timestamp -= 6 * 60 * 60 * 1000;
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;
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);
671 * Disabled due intermitent failures on multiple OSes http://crbug.com/377338
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);
683 * Checks whether the domains in a day are ordered decreasingly.
684 * @param {Element} element Ordered list containing the grouped domains for a
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
691 var getNumberVisits = function(element) {
692 return parseInt(element.textContent.replace(/\D/g, ''), 10);
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;
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();
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();
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));
755 * Fixture for History WebUI tests using the real history backend.
756 * @extends {BaseHistoryWebUITest}
759 function HistoryWebUIRealBackendTest() {}
761 HistoryWebUIRealBackendTest.prototype = {
762 __proto__: BaseHistoryWebUITest.prototype,
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");');
777 * Simple test that verifies that the correct entries are retrieved from the
778 * history database and displayed in the UI.
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);
788 TEST_F('HistoryWebUIRealBackendTest', 'atLeastOneFocusable', function() {
789 var results = document.querySelectorAll('#results-display [tabindex="0"]');
790 expectGE(results.length, 1);
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);
814 * Test individual deletion of history entries.
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);
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']);
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);
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);
882 TEST_F('HistoryWebUIRealBackendTest', 'showConfirmDialogAndCancel', function() {
883 waitForCallback('deleteComplete', function() {
884 testDone([false, "history deleted when it shouldn't have been"]);
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'));
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'));
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'));
971 * Fixture for History WebUI testing when deletions are prohibited.
972 * @extends {HistoryWebUIRealBackendTest}
975 function HistoryWebUIDeleteProhibitedTest() {}
977 HistoryWebUIDeleteProhibitedTest.prototype = {
978 __proto__: HistoryWebUIRealBackendTest.prototype,
981 testGenPreamble: function() {
982 HistoryWebUIRealBackendTest.prototype.testGenPreamble.call(this);
983 GEN(' SetDeleteAllowed(false);');
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);
1005 TEST_F('HistoryWebUIDeleteProhibitedTest', 'atLeastOneFocusable', function() {
1006 var results = document.querySelectorAll('#results-display [tabindex="0"]');
1007 expectGE(results.length, 1);
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);
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);
1052 * Fixture for History WebUI testing IDN.
1053 * @extends {BaseHistoryWebUITest}
1056 function HistoryWebUIIDNTest() {}
1058 HistoryWebUIIDNTest.prototype = {
1059 __proto__: BaseHistoryWebUITest.prototype,
1062 testGenPreamble: function() {
1063 // Add some visits to the history database.
1064 GEN(' AddPageToHistory(0, "http://xn--d1abbgf6aiiy.xn--p1ai/",' +
1067 // Clear AcceptLanguages to get domain in unicode.
1068 GEN(' ClearAcceptLanguages();');
1073 * Simple test that verifies that the correct entries are retrieved from the
1074 * history database and displayed in the UI.
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);
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}
1090 function HistoryWebUIWithSchemesTest() {}
1092 HistoryWebUIWithSchemesTest.prototype = {
1093 __proto__: HistoryWebUIRealBackendTest.prototype,
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", "");');
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);
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);