tools/android/loading: Properly detect page loading failures

tools/android/loading/request_track_unittest.py

 # Copyright 2016 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import copy
 import json
 import sys
 import unittest
 
 from request_track import (TimeBetween, Request, CachingPolicy, RequestTrack,
@@ skipping 382 matching lines @@
           "encodedDataLength": 1326,
           "requestId": "32493.1",
           "timestamp": 5571441.867347}}
   _DATA_RECEIVED_2 = {
       "method": "Network.dataReceived",
       "params": {
           "dataLength": 32768,
           "encodedDataLength": 32768,
           "requestId": "32493.1",
           "timestamp": 5571441.893121}}
+  _SERVED_FROM_CACHE = {
+      "method": "Network.requestServedFromCache",
+      "params": {
+          "requestId": "32493.1"}}
   _LOADING_FINISHED = {'method': 'Network.loadingFinished',
                        'params': {
                            'encodedDataLength': 101829,
                            'requestId': '32493.1',
                            'timestamp': 5571441.891189}}
+  _LOADING_FAILED = {'method': 'Network.loadingFailed',
+                     'params': {
+                         'canceled': False,
+                         'blockedReason': None,
+                         'encodedDataLength': 101829,
+                         'errorText': 'net::ERR_TOO_MANY_REDIRECTS',
+                         'requestId': '32493.1',
+                         'timestamp': 5571441.891189,
+                         'type': 'Document'}}
 
   def setUp(self):
     self.request_track = RequestTrack(None)
 
   def testParseRequestWillBeSent(self):
     msg = RequestTrackTestCase._REQUEST_WILL_BE_SENT
     request_id = msg['params']['requestId']
     self.request_track.Handle('Network.requestWillBeSent', msg)
     self.assertTrue(request_id in self.request_track._requests_in_flight)
     (_, status) = self.request_track._requests_in_flight[request_id]
@@ skipping 54 matching lines @@
     request['params']['initiator']['type'] = 'script'
     self.request_track.Handle('Network.requestWillBeSent', request)
     self.assertEquals(1, self.request_track.inconsistent_initiators_count)
 
   def testRejectDuplicates(self):
     msg = RequestTrackTestCase._REQUEST_WILL_BE_SENT
     self.request_track.Handle('Network.requestWillBeSent', msg)
     with self.assertRaises(AssertionError):
       self.request_track.Handle('Network.requestWillBeSent', msg)
 
+  def testSequenceOfGeneratedResponse(self):
+    self.request_track.Handle('Network.requestServedFromCache',
+                              RequestTrackTestCase._SERVED_FROM_CACHE)
+    self.request_track.Handle('Network.loadingFinished',
+                              RequestTrackTestCase._LOADING_FINISHED)
+    self.assertEquals(0, len(self.request_track.GetEvents()))
+
   def testInvalidSequence(self):
     msg1 = RequestTrackTestCase._REQUEST_WILL_BE_SENT
     msg2 = RequestTrackTestCase._LOADING_FINISHED
     self.request_track.Handle('Network.requestWillBeSent', msg1)
     with self.assertRaises(AssertionError):
       self.request_track.Handle('Network.loadingFinished', msg2)
 
   def testValidSequence(self):
     self._ValidSequence(self.request_track)
     self.assertEquals(1, len(self.request_track.GetEvents()))
@@ skipping 50 matching lines @@
     msg2_different = copy.deepcopy(msg2)
     msg2_different['params']['response']['encodedDataLength'] += 1
     self.request_track.Handle('Network.requestWillBeSent', msg1)
     self.request_track.Handle('Network.responseReceived', msg2)
     # Should not raise an AssertionError.
     self.request_track.Handle('Network.responseReceived', msg2)
     self.assertEquals(1, self.request_track.duplicates_count)
     with self.assertRaises(AssertionError):
       self.request_track.Handle('Network.responseReceived', msg2_different)
 
+  def testLoadingFailed(self):
+    self.request_track.Handle('Network.requestWillBeSent',
+                              RequestTrackTestCase._REQUEST_WILL_BE_SENT)
+    self.request_track.Handle('Network.responseReceived',
+                              RequestTrackTestCase._RESPONSE_RECEIVED)
+    self.request_track.Handle('Network.loadingFailed',
+                              RequestTrackTestCase._LOADING_FAILED)
+    r = self.request_track.GetEvents()[0]
+    self.assertTrue(r.failed)
+    self.assertEquals('net::ERR_TOO_MANY_REDIRECTS', r.error_text)
+
   def testCanSerialize(self):
     self._ValidSequence(self.request_track)
     json_dict = self.request_track.ToJsonDict()
     _ = json.dumps(json_dict)  # Should not raise an exception.
 
   def testCanDeserialize(self):
     self._ValidSequence(self.request_track)
     self.request_track.duplicates_count = 142
     self.request_track.inconsistent_initiators_count = 123
     json_dict = self.request_track.ToJsonDict()
@@ skipping 23 matching lines @@
   def _ValidSequence(cls, request_track):
     request_track.Handle(
         'Network.requestWillBeSent', cls._REQUEST_WILL_BE_SENT)
     request_track.Handle('Network.responseReceived', cls._RESPONSE_RECEIVED)
     request_track.Handle('Network.dataReceived', cls._DATA_RECEIVED_1)
     request_track.Handle('Network.dataReceived', cls._DATA_RECEIVED_2)
     request_track.Handle('Network.loadingFinished', cls._LOADING_FINISHED)
 
 if __name__ == '__main__':
   unittest.main()