Sdch view for net-internals

chrome/test/data/webui/net_internals/sdch_view.js

Index: chrome/test/data/webui/net_internals/sdch_view.js
diff --git a/chrome/test/data/webui/net_internals/sdch_view.js b/chrome/test/data/webui/net_internals/sdch_view.js
new file mode 100644
index 0000000000000000000000000000000000000000..100a7e5fd3f007e596a3c3a29175722c4ab81711
--- /dev/null
+++ b/chrome/test/data/webui/net_internals/sdch_view.js
@@ -0,0 +1,212 @@
+// 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.
+
+// Include test fixture.
+GEN_INCLUDE(['net_internals_test.js']);
+
+// Anonymous namespace
+(function() {
+
+/**
+ * Checks the display on the SDCH tab against the information it should be
+ * displaying.
+ * @param {object} sdchInfo Results from a sdch manager info query.
+ */
+function checkDisplay(sdchInfo) {
+  var tab = $(SdchView.MAIN_BOX_ID);
+  var stateLis =  tab.querySelectorAll('ul>li');

[Randy Smith (Not in Mondays), 2014/10/29 16:15:46]

I don't think of this selector as being as "future proof" as it could be; if
anyone adds a second unordered list to the tab, this'll break.  Maybe better to
add a name and refer to it by the name?

[baranovich, 2014/10/29 18:28:43]

Done.

+  expectEquals(2, stateLis.length);
+  expectEquals(sdchInfo.sdch_enabled,
+               stateLis[0].querySelector('span').innerText === 'true');
+  expectEquals(sdchInfo.secure_scheme_support,
+               stateLis[1].querySelector('span').innerText === 'true');
+  NetInternalsTest.checkTbodyRows(SdchView.BLACKLIST_TBODY_ID,
+                                  sdchInfo.blacklisted.length);
+  NetInternalsTest.checkTbodyRows(SdchView.DICTIONARIES_TBODY_ID,
+                                  sdchInfo.dictionaries.length);
+
+  // Rather than check the exact string in every position, just make sure every
+  // entry does not have 'undefined' anywhere, which should find a fair number
+  // of potential output errors.
+  for (var row = 0; row < sdchInfo.blacklisted.length; ++row) {
+    for (column = 0; column < 3; ++column) {
+      var text = NetInternalsTest.getTbodyText(
+          SdchView.BLACKLIST_TBODY_ID, row, column);
+      expectFalse(/undefined/i.test(text));
+    }
+  }
+
+  for (var row = 0; row < sdchInfo.dictionaries.length; ++row) {
+    for (column = 0; column < 6; ++column) {
+      var text = NetInternalsTest.getTbodyText(
+          SdchView.DICTIONARIES_TBODY_ID, row, column);
+      expectFalse(/undefined/i.test(text));
+    }
+  }
+}
+
+/**
+ * A Task that loads provided page and waits for the SDCH dictionary to be
+ * downloaded. The page response headers should provide Get-Dictionary header.
+ * @extends {NetInternalsTest.Task}
+ */
+function LoadSdchDictionaryTask() {
+  NetInternalsTest.Task.call(this);
+}
+
+LoadSdchDictionaryTask.prototype = {
+  __proto__: NetInternalsTest.Task.prototype,
+
+  /**
+   * Navigates to the page and starts waiting to receive the results from
+   * the browser process.
+   */
+  start: function(url) {
+    g_browser.addSdchInfoObserver(this, false)
+    NetInternalsTest.switchToView('sdch');
+    // 127.0.0.1 is not allowed to be an SDCH domain, so we need another one.
+    url = url.replace('127.0.0.1', 'testdomain.com');
+    this.url_ = url;
+    console.log(url);
+    chrome.send('loadPage', [url]);
+  },
+
+  /**
+   * Callback from the BrowserBridge. Checks if |sdchInfo| has the SDCH
+   * dictionary info for the dictionary the page has advertised. If so,
+   * validates it and completes the task.  If not, continues running.
+   * @param {object} sdchInfo Results a SDCH manager info query.
+   */
+  onSdchInfoChanged: function(sdchInfo) {
+    if (this.isDone())
+      return;
+
+    checkDisplay(sdchInfo);
+
+    if (sdchInfo.dictionaries.length > 0) {

[Randy Smith (Not in Mondays), 2014/10/29 16:15:46]

There's an anti-pattern here I want to call out, though I don't see a way to
avoid it: If the dictionary never shows up in the sdchInfo, the test will fail
by timing out, which is sub-ideal (means the test suite takes longer to run,
looks like flakiness rather than a real failure).  A better pattern is to wait
for an event that you know will happen, and that if the dictionary does get
loaded, that will happen first, then assert that the dictionary load should have
happened.  I don't actually see a way to do that, but I wanted to call out my
concern, in case you do.

[baranovich, 2014/10/29 18:28:43]

I don't like that either, but this approach is used everywhere else in
net-internals tests. The last hope is that Matt may know some secret =)

[mmenke, 2014/10/29 22:03:21]

This is a valid point.  I suppose we could wait on the NetLog URLRequest events
to complete.  But we may get that event before the updated dictionary list, so
to make sure that doesn't happen, we'd have to wait for that events, and then
wait to receive updated SDCH info...Of course, if it matches the previous info,
we'd need to hook into the browser bridge, as it won't send us non-updated info.
 And then we're relying on the dictionary list being updated synchronously
relative the end URLRequest REQUEST_ALIVE event...  I think that would all work
out, but it's depending on code far enough removed from net-internals that it
seems like an even worse anti-pattern than timing out on tests.

Waiting for something not to happen and then failing (Or passing, depending on
the test) is a pretty general problem we run into a lot, but there's not a
general solution, unless there's another thing we can also wait on, as Randy
suggest (Of course, if we don't get *that* event either, we still timeout,
unless we have yet another event to wait on....)

Anyhow, I agree that it's a problem, but not sure there's a reasonable solution
to it here.

[mmenke, 2014/10/29 22:51:14]

Thinking about it a bit more, waiting on the NetLog event may not be safe - we
may be able to get a dictionary older than a NetLog event after we see the
event, I'm not sure.  Navigation, on the other hand, should not have that issue,
and it should be fairly safe to depend on that.

There's also an option to receive notifications even when the value didn't
actually change, I believe, so we could wait for load to complete on tests that
expect errors, though it still makes me a little nervous.  That wouldn't work
for tests that expect to get dictionaries successfully, though.

+      var testDict = sdchInfo.dictionaries.filter(function(e) {

[mmenke, 2014/10/29 22:03:21]

nit:  Per the style guide, don't use single-letter variable names.  Write out a
full word (dictionary?).  Does mean this will take up an extra line, but not the
end of the world.

[baranovich, 2014/10/30 00:33:22]

Done.

+        return e.domain === 'testdomain.com';
+      });
+      if (testDict.length === 0)
+        return;
+
+      expectEquals(1, testDict.length);
+      var dict = testDict[0];
+      expectEquals('/', dict.path);
+      expectTrue(dict.url.indexOf('/files/sdch/dict') !== -1);
+
+      var tableId = SdchView.DICTIONARIES_TBODY_ID;
+      var domain = NetInternalsTest.getTbodyText(tableId, 0, 0);
+      var path = NetInternalsTest.getTbodyText(tableId, 0, 1);
+      var url = NetInternalsTest.getTbodyText(tableId, 0, 5);
+
+      expectEquals(dict.domain, domain);
+      expectEquals(dict.path, path);
+      expectEquals(dict.url, url);
+
+      this.onTaskDone(this.url_);
+    }
+  }
+};
+
+/**
+ * A Task that loads provided page and waits for its domain to appear in SDCH
+ * blacklist with the specified reason.
+ * @param {string} reason Blacklist reason we're waiting for.
+ * @extends {NetInternalsTest.Task}
+ */
+function LoadPageWithDecodeErrorTask(reason) {
+  NetInternalsTest.Task.call(this);
+  this.reason_ = reason;
+}
+
+LoadPageWithDecodeErrorTask.prototype = {
+  __proto__: NetInternalsTest.Task.prototype,
+
+  /**
+   * Navigates to the page and starts waiting to receive the results from
+   * the browser process.
+   */
+  start: function(url) {
+    g_browser.addSdchInfoObserver(this, false)
+    NetInternalsTest.switchToView('sdch');
+    // 127.0.0.1 is not allowed to be an SDCH domain, so we need another one.
+    url = url.replace('127.0.0.1', 'testdomain.com');
+    console.log(url);
+    chrome.send('loadPage', [url]);
+  },
+
+  /**
+   * Callback from the BrowserBridge. Checks if |sdchInfo.blacklisted| contains
+   * the test domain with the reason specified on creation. If so, validates it
+   * and completes the task.  If not, continues running.
+   * @param {object} sdchInfo Results a SDCH manager info query.
+   */
+  onSdchInfoChanged: function(sdchInfo) {
+    if (this.isDone())
+      return;
+
+    checkDisplay(sdchInfo);
+
+    if (sdchInfo.blacklisted.length > 0) {

[Randy Smith (Not in Mondays), 2014/10/29 16:15:46]

Might there be a way to avoid the anti-pattern I mention above here?  Once the
page loads, the blacklisting should have been done; can you wait for the page
load, then assert that the blacklist has been set?

[mmenke, 2014/10/29 22:03:21]

The blacklist is pulled, not pushed, so not quite that simple.  Also, the
dictionaries go IO->UI->IO->renderer...  The main request goes
IO->Renderer->IO->UI, so that is presumably a race it's impossible to win,
but...ergh.  I don't want to have to think about that when reading this test.

+      var testDomains = sdchInfo.blacklisted.filter(function(e) {
+        return e.domain === 'testdomain.com';
+      });
+      if (testDomains.length === 0)
+        return;
+
+      expectEquals(1, testDomains.length);
+      var entry = testDomains[0];
+      expectEquals(this.reason_,
+                   sdchProblemCodeToString(entry.reason));

[Randy Smith (Not in Mondays), 2014/10/29 16:15:46]

nit: Looks like these two lines could fit in one line in 80 chars?

[baranovich, 2014/10/29 18:28:43]

Done.

+      var tableId = SdchView.BLACKLIST_TBODY_ID;
+      var domain = NetInternalsTest.getTbodyText(tableId, 0, 0);
+      var reason = NetInternalsTest.getTbodyText(tableId, 0, 1);
+      expectEquals(entry.domain, domain);
+      expectEquals(this.reason_, reason);
+      this.onTaskDone();
+    }
+  }
+};
+
+/**
+ * Load a page, which provide SDCH dictionary. Make sure we have its data
+ * displayed.
+ */
+TEST_F('NetInternalsTest', 'netInternalsSdchViewFetchDictionary', function() {
+  var taskQueue = new NetInternalsTest.TaskQueue(true);
+  taskQueue.addTask(
+      new NetInternalsTest.GetTestServerURLTask('files/sdch/page.html'));
+  taskQueue.addTask(new LoadSdchDictionaryTask());
+  taskQueue.run();
+});
+
+/**
+ * Load a page, get the dictionary for it, and get decoding error to see
+ * the blacklist in action.
+ */
+TEST_F('NetInternalsTest', 'netInternalsSdchViewBlacklistMeta', function() {
+  var taskQueue = new NetInternalsTest.TaskQueue(true);
+  taskQueue.addTask(
+      new NetInternalsTest.GetTestServerURLTask('files/sdch/page.html'));
+  taskQueue.addTask(new LoadSdchDictionaryTask());
+  taskQueue.addTask(
+      new NetInternalsTest.GetTestServerURLTask('files/sdch/non-sdch.html'));
+  taskQueue.addTask(new LoadPageWithDecodeErrorTask('META_REFRESH_RECOVERY'));
+  taskQueue.run();
+});
+
+/**
+ * Load a page, which is said to be SDCH-encoded, though we don't expect it.
+ */
+TEST_F('NetInternalsTest', 'netInternalsSdchViewBlacklistNonSdch', function() {
+  var taskQueue = new NetInternalsTest.TaskQueue(true);
+  taskQueue.addTask(
+      new NetInternalsTest.GetTestServerURLTask('files/sdch/non-sdch.html'));
+  taskQueue.addTask(
+      new LoadPageWithDecodeErrorTask('PASSING_THROUGH_NON_SDCH'));
+  taskQueue.run();
+});
+
+})();  // Anonymous namespace