Get rid of usage of old Swarming API in tests.

appengine/swarming/handlers_bot_test.py

 #!/usr/bin/env python
 # coding: utf-8
 # Copyright 2015 The Swarming Authors. All rights reserved.
 # Use of this source code is governed by the Apache v2.0 license that can be
 # found in the LICENSE file.
 
 import base64
 import datetime
 import logging
 import os
 import random
 import StringIO
 import sys
 import unittest
 import zipfile
 
 # Setups environment.
 import test_env_handlers
 
 from google.appengine.api import datastore_errors
 from google.appengine.ext import ndb
 
 import webapp2
 import webtest
 
-import handlers_api
 import handlers_bot
 from components import ereporter2
-from components import utils
 from server import bot_archive
 from server import bot_management
 from server import task_result
 
 
+DATETIME_FORMAT = u'%Y-%m-%dT%H:%M:%S'
+
+
 class BotApiTest(test_env_handlers.AppTestBase):
   def setUp(self):
     super(BotApiTest, self).setUp()
     # By default requests in tests are coming from bot with fake IP.
-    routes = handlers_bot.get_routes() + handlers_api.get_routes()
+    routes = handlers_bot.get_routes()
     app = webapp2.WSGIApplication(routes, debug=True)
     self.app = webtest.TestApp(
         app,
         extra_environ={
           'REMOTE_ADDR': self.source_ip,
           'SERVER_SOFTWARE': os.environ['SERVER_SOFTWARE'],
         })
     self.mock(
         ereporter2, 'log_request',
         lambda *args, **kwargs: self.fail('%s, %s' % (args, kwargs)))
@@ skipping 167 matching lines @@
       u'cmd': u'restart',
       u'message': 'Mocked restart message',
     }
     self.assertEqual(expected, response)
 
   def test_poll_task_raw(self):
     # Successfully poll a task.
     self.mock(random, 'getrandbits', lambda _: 0x88)
     now = datetime.datetime(2010, 1, 2, 3, 4, 5)
     self.mock_now(now)
-    str_now = unicode(now.strftime(utils.DATETIME_FORMAT))
+    str_now = unicode(now.strftime(DATETIME_FORMAT))
     # A bot polls, gets a task, updates it, completes it.
     token, params = self.get_bot_token()
     # Enqueue a task.
     _, task_id = self.client_create_task_raw()
     self.assertEqual('0', task_id[-1])
     # Convert TaskResultSummary reference to TaskRunResult.
     task_id = task_id[:-1] + '1'
     response = self.post_with_token('/swarming/api/v1/bot/poll', params, token)
     expected = {
       u'cmd': u'run',
       u'manifest': {
         u'bot_id': u'bot1',
         u'command': [u'python', u'run_test.py'],
         u'data': [],
         u'dimensions': {u'os': u'Amiga'},
         u'env': {},
         u'extra_args': [],
         u'grace_period': 30,
         u'hard_timeout': 3600,
         u'host': u'http://localhost:8080',
         u'inputs_ref': None,
         u'io_timeout': 1200,
         u'task_id': task_id,
       },
     }
     self.assertEqual(expected, response)
     response = self.client_get_results(task_id)
     expected = {
-      u'abandoned_ts': None,
-      u'bot_dimensions': {u'id': [u'bot1'], u'os': [u'Amiga']},
+      u'bot_dimensions': [
+        {u'key': u'id', u'value': [u'bot1']},
+        {u'key': u'os', u'value': [u'Amiga']},
+      ],
       u'bot_id': u'bot1',
       u'bot_version': self.bot_version,
-      u'children_task_ids': [],
-      u'completed_ts': None,
-      u'cost_usd': 0.,
-      u'durations': [],
-      u'exit_codes': [],
+      u'costs_usd': [0.],
+      u'created_ts': str_now,
       u'failure': False,
-      u'id': u'5cee488008811',
       u'internal_failure': False,
       u'modified_ts': str_now,
-      u'outputs_ref': None,
+      u'name': u'hi',
       u'server_versions': [u'v1a'],
       u'started_ts': str_now,
-      u'state': task_result.State.RUNNING,
-      u'try_number': 1,
+      u'state': u'RUNNING',
+      u'task_id': u'5cee488008811',
+      u'try_number': u'1',
     }
     self.assertEqual(expected, response)
 
   def test_poll_task_isolated(self):
     # Successfully poll a task.
     self.mock(random, 'getrandbits', lambda _: 0x88)
     now = datetime.datetime(2010, 1, 2, 3, 4, 5)
     self.mock_now(now)
-    str_now = unicode(now.strftime(utils.DATETIME_FORMAT))
+    str_now = unicode(now.strftime(DATETIME_FORMAT))
     # A bot polls, gets a task, updates it, completes it.
     token, params = self.get_bot_token()
     # Enqueue a task.
     _, task_id = self.client_create_task_isolated()
     self.assertEqual('0', task_id[-1])
     # Convert TaskResultSummary reference to TaskRunResult.
     task_id = task_id[:-1] + '1'
     response = self.post_with_token('/swarming/api/v1/bot/poll', params, token)
     expected = {
       u'cmd': u'run',
@@ skipping 12 matching lines @@
           u'isolatedserver': u'http://localhost:1',
           u'namespace': u'default-gzip',
         },
         u'io_timeout': 1200,
         u'task_id': task_id,
       },
     }
     self.assertEqual(expected, response)
     response = self.client_get_results(task_id)
     expected = {
-      u'abandoned_ts': None,
-      u'bot_dimensions': {u'id': [u'bot1'], u'os': [u'Amiga']},
+      u'bot_dimensions': [
+        {u'key': u'id', u'value': [u'bot1']},
+        {u'key': u'os', u'value': [u'Amiga']},
+      ],
       u'bot_id': u'bot1',
       u'bot_version': self.bot_version,
-      u'children_task_ids': [],
-      u'completed_ts': None,
-      u'cost_usd': 0.,
-      u'durations': [],
-      u'exit_codes': [],
+      u'costs_usd': [0.],
+      u'created_ts': str_now,
       u'failure': False,
-      u'id': u'5cee488008811',
       u'internal_failure': False,
       u'modified_ts': str_now,
-      u'outputs_ref': None,
+      u'name': u'hi',
       u'server_versions': [u'v1a'],
       u'started_ts': str_now,
-      u'state': task_result.State.RUNNING,
-      u'try_number': 1,
+      u'state': u'RUNNING',
+      u'task_id': u'5cee488008811',
+      u'try_number': u'1',
     }
     self.assertEqual(expected, response)
 
   def test_bot_ereporter2_error(self):
     # ereporter2's //client/utils/on_error.py traps unhandled exceptions
     # automatically.
     self.mock(random, 'getrandbits', lambda _: 0x88)
     errors = []
     self.mock(
         ereporter2, 'log_request',
@@ skipping 143 matching lines @@
         'version': u'123',
       },
     ]
     self.assertEqual(expected, actual)
 
   def test_task_complete(self):
     # Runs a task with 2 commands up to completion.
     self.mock(random, 'getrandbits', lambda _: 0x88)
     now = datetime.datetime(2010, 1, 2, 3, 4, 5)
     self.mock_now(now)
-    str_now = unicode(now.strftime(utils.DATETIME_FORMAT))
+    str_now = unicode(now.strftime(DATETIME_FORMAT))
     token, params = self.get_bot_token()
     self.client_create_task_raw(
-        properties=dict(commands=[['python', 'runtest.py']]))
+        properties=dict(command=['python', 'runtest.py']))
 
     def _params(**kwargs):
       out = {
         'cost_usd': 0.1,
         'duration': None,
         'exit_code': None,
         'id': 'bot1',
         'output': None,
         'output_chunk_start': 0,
         'task_id': task_id,
       }
       out.update(**kwargs)
       return out
 
     def _expected(**kwargs):
       out = {
-        u'abandoned_ts': None,
-        u'bot_dimensions': {u'id': [u'bot1'], u'os': [u'Amiga']},
+        u'bot_dimensions': [
+          {u'key': u'id', u'value': [u'bot1']},
+          {u'key': u'os', u'value': [u'Amiga']},
+        ],
         u'bot_id': u'bot1',
         u'bot_version': self.bot_version,
-        u'children_task_ids': [],
-        u'completed_ts': None,
-        u'cost_usd': 0.1,
-        u'durations': [],
-        u'exit_codes': [],
+        u'costs_usd': [0.1],
+        u'created_ts': str_now,
         u'failure': False,
-        u'id': u'5cee488008811',
         u'internal_failure': False,
         u'modified_ts': str_now,
-        u'outputs_ref': None,
+        u'name': u'hi',
         u'server_versions': [u'v1a'],
         u'started_ts': str_now,
-        u'state': task_result.State.RUNNING,
-        u'try_number': 1,
+        u'state': u'RUNNING',
+        u'task_id': u'5cee488008811',
+        u'try_number': u'1',
       }
       out.update(**kwargs)
       return out
 
     def _cycle(params, expected):
       response = self.post_with_token(
           '/swarming/api/v1/bot/task_update', params, token)
       self.assertEqual({u'ok': True}, response)
       response = self.client_get_results(task_id)
       self.assertEqual(expected, response)
@@ skipping 16 matching lines @@
     # 3. Task update with some more output.
     params = _params(output=base64.b64encode('hi'), output_chunk_start=3)
     expected = _expected()
     _cycle(params, expected)
 
     # 4. Task update with completion of the command.
     params = _params(
         duration=0.1, exit_code=23, output=base64.b64encode('Ahahah'))
     expected = _expected(
         completed_ts=str_now,
-        durations=[0.1],
-        exit_codes=[23],
+        duration=0.1,
+        exit_code=u'23',
         failure=True,
-        state=task_result.State.COMPLETED)
+        state=u'COMPLETED')
     _cycle(params, expected)
 
   def test_task_update_db_failure(self):
     # The error is caught in task_scheduler.bot_update_task().
     self.client_create_task_raw(
-        properties=dict(commands=[['python', 'runtest.py']]))
+        properties=dict(command=['python', 'runtest.py']))
 
     token, params = self.get_bot_token()
     response = self.post_with_token(
         '/swarming/api/v1/bot/poll', params, token)
     task_id = response['manifest']['task_id']
 
     def r(*_):
       raise datastore_errors.Timeout('Sorry!')
     self.mock(ndb, 'put_multi', r)
     params = {
       'cost_usd': 0.1,
       'duration': 0.1,
       'exit_code': 0,
       'id': 'bot1',
       'output': base64.b64encode('result string'),
       'output_chunk_start': 0,
       'task_id': task_id,
     }
     response = self.post_with_token(
         '/swarming/api/v1/bot/task_update', params, token, status=500)
     self.assertEqual({u'error': u'Failed to update, please retry'}, response)
 
   def test_task_update_failure(self):
-    # The error is caught in handlers_api.BotTaskUpdateHandler.post().
     self.client_create_task_raw(
-        properties=dict(commands=[['python', 'runtest.py']]))
+        properties=dict(command=['python', 'runtest.py']))
 
     token, params = self.get_bot_token()
     response = self.post_with_token(
         '/swarming/api/v1/bot/poll', params, token)
     task_id = response['manifest']['task_id']
 
     class NewError(Exception):
       pass
 
     def r(*_):
       raise NewError('Sorry!')
     self.mock(ndb, 'put_multi', r)
     params = {
       'cost_usd': 0.1,
       'duration': 0.1,
       'exit_code': 0,
       'id': 'bot1',
       'output': base64.b64encode('result string'),
       'output_chunk_start': 0,
       'task_id': task_id,
     }
     response = self.post_with_token(
         '/swarming/api/v1/bot/task_update', params, token, status=500)
     self.assertEqual({u'error': u'Sorry!'}, response)
 
   def test_task_failure(self):
     self.mock(random, 'getrandbits', lambda _: 0x88)
     now = datetime.datetime(2010, 1, 2, 3, 4, 5)
     self.mock_now(now)
-    str_now = unicode(now.strftime(utils.DATETIME_FORMAT))
+    str_now = unicode(now.strftime(DATETIME_FORMAT))
     token, params = self.get_bot_token()
     self.client_create_task_raw()
     response = self.post_with_token(
         '/swarming/api/v1/bot/poll', params, token)
     task_id = response['manifest']['task_id']
 
     params = {
       'cost_usd': 0.1,
       'duration': 0.1,
       'exit_code': 1,
       'id': 'bot1',
       'output': base64.b64encode('result string'),
       'output_chunk_start': 0,
       'task_id': task_id,
     }
     response = self.post_with_token(
         '/swarming/api/v1/bot/task_update', params, token)
     response = self.client_get_results(task_id)
     expected = {
-      u'abandoned_ts': None,
-      u'bot_dimensions': {u'id': [u'bot1'], u'os': [u'Amiga']},
+      u'bot_dimensions': [
+        {u'key': u'id', u'value': [u'bot1']},
+        {u'key': u'os', u'value': [u'Amiga']},
+      ],
       u'bot_id': u'bot1',
       u'bot_version': self.bot_version,
-      u'children_task_ids': [],
       u'completed_ts': str_now,
-      u'cost_usd': 0.1,
-      u'durations': [0.1],
-      u'exit_codes': [1],
+      u'costs_usd': [0.1],
+      u'created_ts': str_now,
+      u'duration': 0.1,
+      u'exit_code': u'1',
       u'failure': True,
-      u'id': u'5cee488008811',
       u'internal_failure': False,
       u'modified_ts': str_now,
-      u'outputs_ref': None,
+      u'name': u'hi',
       u'server_versions': [u'v1a'],
       u'started_ts': str_now,
-      u'state': task_result.State.COMPLETED,
-      u'try_number': 1,
+      u'state': u'COMPLETED',
+      u'task_id': u'5cee488008811',
+      u'try_number': u'1',
     }
     self.assertEqual(expected, response)
 
   def test_task_internal_failure(self):
     # E.g. task_runner blew up.
     self.mock(random, 'getrandbits', lambda _: 0x88)
     now = datetime.datetime(2010, 1, 2, 3, 4, 5)
     self.mock_now(now)
-    str_now = unicode(now.strftime(utils.DATETIME_FORMAT))
+    str_now = unicode(now.strftime(DATETIME_FORMAT))
     errors = []
     self.mock(
         ereporter2, 'log_request',
         lambda *args, **kwargs: errors.append((args, kwargs)))
     token, params = self.get_bot_token()
     self.client_create_task_raw()
     response = self.post_with_token(
         '/swarming/api/v1/bot/poll', params, token)
     task_id = response['manifest']['task_id']
 
     # Let's say it failed to start task_runner because the new bot code is
     # broken. The end result is still BOT_DIED. The big change is that it
     # doesn't need to wait for a cron job to set this status.
     params = {
       'id': params['dimensions']['id'][0],
       'message': 'Oh',
       'task_id': task_id,
     }
     response = self.post_with_token(
         '/swarming/api/v1/bot/task_error', params, token)
 
     response = self.client_get_results(task_id)
     expected = {
       u'abandoned_ts': str_now,
-      u'bot_dimensions': {u'id': [u'bot1'], u'os': [u'Amiga']},
+      u'bot_dimensions': [
+        {u'key': u'id', u'value': [u'bot1']},
+        {u'key': u'os', u'value': [u'Amiga']},
+      ],
       u'bot_id': u'bot1',
       u'bot_version': self.bot_version,
-      u'children_task_ids': [],
-      u'completed_ts': None,
-      u'cost_usd': 0.,
-      u'durations': [],
-      u'exit_codes': [],
+      u'costs_usd': [0.],
+      u'created_ts': str_now,
       u'failure': False,
-      u'id': u'5cee488008811',
       u'internal_failure': True,
       u'modified_ts': str_now,
-      u'outputs_ref': None,
+      u'name': u'hi',
       u'server_versions': [u'v1a'],
       u'started_ts': str_now,
-      u'state': task_result.State.BOT_DIED,
-      u'try_number': 1,
+      u'state': u'BOT_DIED',
+      u'task_id': u'5cee488008811',
+      u'try_number': u'1',
     }
     self.assertEqual(expected, response)
     self.assertEqual(1, len(errors))
     expected = [
       {
         'message':
           u'Bot: https://None/restricted/bot/bot1\n'
           'Task failed: https://None/user/task/5cee488008811\nOh',
         'source': 'bot',
       },
     ]
     self.assertEqual(expected, [e[1] for e in errors])
 
   def test_bot_code(self):
     code = self.app.get('/bot_code')
     expected = {'config/bot_config.py', 'config/config.json'}.union(
         bot_archive.FILES)
     with zipfile.ZipFile(StringIO.StringIO(code.body), 'r') as z:
       self.assertEqual(expected, set(z.namelist()))
 
 
 if __name__ == '__main__':
   if '-v' in sys.argv:
     unittest.TestCase.maxDiff = None
   logging.basicConfig(
       level=logging.DEBUG if '-v' in sys.argv else logging.CRITICAL,
       format='%(levelname)-7s %(filename)s:%(lineno)3d %(message)s')
   unittest.main()