Roll typ v0.9.9 -> v0.9.11 (5822dda0..f6afa2bb).

third_party/typ/typ/tests/main_test.py

 # Copyright 2014 Dirk Pranke. All rights reserved.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
 # you may not use this file except in compliance with the License.
 # You may obtain a copy of the License at
 #
 #    http://www.apache.org/licenses/LICENSE-2.0
 #
 # Unless required by applicable law or agreed to in writing, software
 # distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 604 matching lines @@
                    rout=(r'\[1/1\] pass_test.PassingTest.test_pass passed '
                          r'\d+.\d+s\n'
                          r'1 test run in \d+.\d+s, 0 failures.'))
 
     def test_test_results_server(self):
         server = test_result_server_fake.start()
         self.assertNotEqual(server, None, 'could not start fake server')
 
         try:
             self.check(['--test-results-server',
-                        '%s:%d' % server.server_address,
+                        'http://%s:%d' % server.server_address,
                         '--master-name', 'fake_master',
                         '--builder-name', 'fake_builder',
                         '--test-type', 'typ_tests',
                         '--metadata', 'foo=bar'],
                        files=PASS_TEST_FILES, ret=0, err='',
                        out=('[1/1] pass_test.PassingTest.test_pass passed\n'
                             '1 test run, 0 failures.\n'))
 
         finally:
             posts = server.stop()
 
         self.assertEqual(len(posts), 1)
         payload = posts[0][2].decode('utf8')
-        self.assertIn('"test_pass": {"actual": "PASS", "expected": "PASS"}',
+        self.assertIn('"test_pass": {"actual": "PASS"',
                       payload)
         self.assertTrue(payload.endswith('--\r\n'))
         self.assertNotEqual(server.log.getvalue(), '')
 
     def test_test_results_server_error(self):
         server = test_result_server_fake.start(code=500)
         self.assertNotEqual(server, None, 'could not start fake server')
 
         try:
             self.check(['--test-results-server',
-                        '%s:%d' % server.server_address,
+                        'http://%s:%d' % server.server_address,
                         '--master-name', 'fake_master',
                         '--builder-name', 'fake_builder',
                         '--test-type', 'typ_tests',
                         '--metadata', 'foo=bar'],
                        files=PASS_TEST_FILES, ret=1, err='',
                        out=('[1/1] pass_test.PassingTest.test_pass passed\n'
                             '1 test run, 0 failures.\n'
                             'Uploading the JSON results raised '
                             '"HTTP Error 500: Internal Server Error"\n'))
 
         finally:
             _ = server.stop()
 
     def test_test_results_server_not_running(self):
-        self.check(['--test-results-server', 'localhost:99999',
+        self.check(['--test-results-server', 'http://localhost:99999',
                     '--master-name', 'fake_master',
                     '--builder-name', 'fake_builder',
                     '--test-type', 'typ_tests',
                     '--metadata', 'foo=bar'],
                    files=PASS_TEST_FILES, ret=1, err='',
                    rout=(r'\[1/1\] pass_test.PassingTest.test_pass passed\n'
                          '1 test run, 0 failures.\n'
                          'Uploading the JSON results raised .*\n'))
 
     def test_verbose_2(self):
@@ skipping 23 matching lines @@
     def test_version(self):
         self.check('--version', ret=0, out=(VERSION + '\n'))
 
     def test_write_full_results_to(self):
         _, _, _, files = self.check(['--write-full-results-to',
                                      'results.json'], files=PASS_TEST_FILES)
         self.assertIn('results.json', files)
         results = json.loads(files['results.json'])
         self.assertEqual(results['interrupted'], False)
         self.assertEqual(results['path_delimiter'], '.')
+
+        # The time it takes to run the test varies, so we test that
+        # we got a single entry greater than zero, but then delete it from
+        # the result so we can do an exact match on the rest of the trie.
+        result = results['tests']['pass_test']['PassingTest']['test_pass']
+        self.assertEqual(len(result['times']), 1)
+        self.assertGreater(result['times'][0], 0)
+        result.pop('times')
         self.assertEqual(results['tests'],
                          {u'pass_test': {
                              u'PassingTest': {
                                  u'test_pass': {
                                      u'actual': u'PASS',
                                      u'expected': u'PASS',
                                  }
                              }
                          }})
 
@@ skipping 37 matching lines @@
                     modules_to_unload.append(k)
             for k in modules_to_unload:
                 del sys.modules[k]
             sys.path = orig_sys_path
 
         return ret, out, err
 
     def test_debugger(self):
         # TODO: this test seems to hang under coverage.
         pass