Move url_open with dependencies to utils.net module.

tests/swarming_test.py

 #!/usr/bin/env python
 # Copyright 2013 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 json
 import logging
 import os
 import StringIO
 import sys
 import threading
 import unittest
 import urllib2
 
 import auto_stub
 
 ROOT_DIR = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 sys.path.insert(0, ROOT_DIR)
 
-import run_isolated
 import swarming
+from utils import net
 
 
 FILE_NAME = u'test.isolated'
 FILE_HASH = u'1' * 40
 TEST_NAME = u'unit_tests'
 STDOUT_FOR_TRIGGER_LEN = 188
 
 
 TEST_CASE_SUCCESS = (
   '[----------] 2 tests from StaticCookiePolicyTest\n'
@@ skipping 109 matching lines @@
   """
   return list(swarming.yield_results('http://host:9001', keys, 10., None))
 
 
 class TestCase(auto_stub.TestCase):
   """Base class that defines the url_open mock."""
   def setUp(self):
     super(TestCase, self).setUp()
     self._lock = threading.Lock()
     self.requests = []
-    self.mock(swarming.run_isolated, 'url_open', self._url_open)
+    self.mock(swarming.net, 'url_open', self._url_open)
 
   def tearDown(self):
     try:
       if not self.has_failed():
         self.assertEqual([], self.requests)
     finally:
       super(TestCase, self).tearDown()
 
   def _url_open(self, url, **kwargs):
     logging.info('url_open(%s)', url)
@@ skipping 10 matching lines @@
 
 
 class TestGetTestKeys(TestCase):
   def test_no_keys(self):
     self.mock(swarming.time, 'sleep', lambda x: x)
     self.requests = [
       (
         'http://host:9001/get_matching_test_cases?name=my_test',
         {'retry_404': True},
         StringIO.StringIO('No matching Test Cases'),
-      ) for _ in range(run_isolated.URL_OPEN_MAX_ATTEMPTS)
+      ) for _ in range(net.URL_OPEN_MAX_ATTEMPTS)
     ]
     try:
       swarming.get_test_keys('http://host:9001', 'my_test')
       self.fail()
     except swarming.Failure as e:
       msg = (
           'Error: Unable to find any tests with the name, my_test, on swarm '
           'server')
       self.assertEqual(msg, e.args[0])
 
@@ skipping 64 matching lines @@
     expected = [gen_yielded_data(0, SWARM_OUTPUT_WITH_NO_TEST_OUTPUT, '0, 0')]
     actual = get_swarm_results(['key1'])
     self.assertEqual(expected, actual)
 
   def test_no_keys(self):
     actual = get_swarm_results([])
     self.assertEqual([], actual)
 
   def test_url_errors(self):
     # NOTE: get_swarm_results() hardcodes timeout=10. range(12) is because of an
-    # additional time.time() call deep in run_isolated.url_open().
+    # additional time.time() call deep in net.url_open().
     now = {}
     lock = threading.Lock()
     def get_now():
       t = threading.current_thread()
       with lock:
         return now.setdefault(t, range(12)).pop(0)
     self.mock(
-        swarming.run_isolated.HttpService,
+        swarming.net.HttpService,
         'sleep_before_retry',
         staticmethod(lambda _x, _y: None))
     self.mock(swarming, 'now', get_now)
     # The actual number of requests here depends on 'now' progressing to 10
     # seconds. It's called twice per loop.
     self.requests = [
       (
         'http://host:9001/get_result?r=key1',
         {'retry_404': False, 'retry_50x': False},
         None,
@@ skipping 70 matching lines @@
       gen_yielded_data(2, TEST_SHARD_OUTPUT_3, '0, 0'),
     ]
     actual = get_swarm_results(['key1', 'key1-repeat', 'key2', 'key3'])
     self.assertEqual(expected, sorted(actual))
 
 
 def chromium_tasks(retrieval_url):
   return [
     {
       u'action': [
-        u'python', u'run_isolated.py',
+        u'python', u'run_isolated.zip',
         u'--hash', FILE_HASH,
         u'--remote', retrieval_url + u'default-gzip/',
       ],
       u'decorate_output': False,
       u'test_name': u'Run Test',
       u'time_out': 600,
     },
     {
       u'action' : [
           u'python', u'swarm_cleanup.py',
@@ skipping 33 matching lines @@
     u'priority': 101,
   }
   if shards > 1:
     expected[u'env_vars'][u'GTEST_SHARD_INDEX'] = u'%(instance_index)s'
     expected[u'env_vars'][u'GTEST_TOTAL_SHARDS'] = u'%(num_instances)s'
   if profile:
     expected[u'tests'][0][u'action'].append(u'--verbose')
   return expected
 
 
-class MockZipFile(object):
-  def __init__(self, filename, mode):
-    pass
-
-  def write(self, source, dest=None):
-    pass
-
-  def close(self):
-    pass
-
-
 def MockUrlOpen(url, _data, has_return_value):
   if '/content/contains' in url:
     return StringIO.StringIO(has_return_value)
   return StringIO.StringIO('{}')
 
 
 def MockUrlOpenHasZip(url, data=None, content_type=None):
   assert content_type in (None, 'application/json', 'application/octet-stream')
   return MockUrlOpen(url, data, has_return_value=chr(1))
 
 
 def MockUrlOpenNoZip(url, data=None, content_type=None):
   assert content_type in (None, 'application/json', 'application/octet-stream')
   return MockUrlOpen(url, data, has_return_value=chr(0))
 
 
 class ManifestTest(auto_stub.TestCase):
   def setUp(self):
     self.mock(swarming.time, 'sleep', lambda x: None)
-    self.mock(swarming.zipfile, 'ZipFile', MockZipFile)
     self.mock(sys, 'stdout', StringIO.StringIO())
     self.mock(sys, 'stderr', StringIO.StringIO())
 
   def tearDown(self):
     if not self.has_failed():
       self._check_output('', '')
     super(ManifestTest, self).tearDown()
 
   def _check_output(self, out, err):
     self.assertEqual(out, sys.stdout.getvalue())
@@ skipping 72 matching lines @@
 
     expected = generate_expected_json(
         shards=1,
         slave_os='linux2',
         working_dir='swarm_tests',
         isolate_server='http://localhost:8081',
         profile=True)
     self.assertEqual(expected, manifest_json)
 
   def test_process_manifest_success(self):
-    self.mock(swarming.run_isolated, 'url_open', MockUrlOpenNoZip)
+    self.mock(swarming.net, 'url_open', MockUrlOpenNoZip)
 
     result = swarming.process_manifest(
         file_sha1_or_isolated=FILE_HASH,
         test_name=TEST_NAME,
         shards=1,
         test_filter='*',
         slave_os='linux2',
         working_dir='swarm_tests',
         isolate_server='http://localhost:8081',
         swarming='http://localhost:8082',
         verbose=False,
         profile=False,
         priority=101)
     self.assertEqual(0, result)
 
     # Just assert it printed enough, since it contains variable output.
     out = sys.stdout.getvalue()
     self.assertTrue(
         len(out) > STDOUT_FOR_TRIGGER_LEN,
         (out, sys.stderr.getvalue()))
     self.assertTrue('Zip file not on server, starting uploading.' in out)
     self.mock(sys, 'stdout', StringIO.StringIO())
 
   def test_process_manifest_success_zip_already_uploaded(self):
-    self.mock(swarming.run_isolated, 'url_open', MockUrlOpenHasZip)
+    self.mock(swarming.net, 'url_open', MockUrlOpenHasZip)
 
     result = swarming.process_manifest(
         file_sha1_or_isolated=FILE_HASH,
         test_name=TEST_NAME,
         shards=1,
         test_filter='*',
         slave_os='linux2',
         working_dir='swarm_tests',
         isolate_server='http://localhost:8081',
         swarming='http://localhost:8082',
@@ skipping 19 matching lines @@
           'Usage: swarming.py trigger [options]\n\n'
           'swarming.py: error: At least one --task is required.\n')
 
 
 if __name__ == '__main__':
   logging.basicConfig(
       level=logging.DEBUG if '-v' in sys.argv else logging.ERROR)
   if '-v' in sys.argv:
     unittest.TestCase.maxDiff = None
   unittest.main()