gae_ts_mon: instrument Cloud Endpoint methods

appengine_module/gae_ts_mon/test/config_test.py

 # Copyright 2015 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 datetime
 import os
 import time
 import unittest
 
+import endpoints
 import gae_ts_mon
 import mock
 import webapp2
 
 from infra_libs.ts_mon import config
 from infra_libs.ts_mon import shared
 from infra_libs.ts_mon.common import http_metrics
 from infra_libs.ts_mon.common import interface
 from infra_libs.ts_mon.common import monitors
 from infra_libs.ts_mon.common import targets
 from infra_libs.ts_mon.common.test import stubs
+from protorpc import message_types
+from protorpc import remote
 from testing_utils import testing
 
 
 class InitializeTest(testing.AppengineTestCase):
   def setUp(self):
     super(InitializeTest, self).setUp()
 
     config.reset_for_unittest()
     target = targets.TaskTarget('test_service', 'test_job',
                                 'test_region', 'test_host')
@@ skipping 309 matching lines @@
 
     app = webapp2.WSGIApplication([('/', Handler)])
     config.instrument_wsgi_application(app)
 
     app.get_response('/', POST='foo')
 
     fields = {'name': '^/$', 'status': 200, 'is_robot': False}
     self.assertEqual(1, http_metrics.server_response_status.get(fields))
     self.assertEqual(
         len('foo'), http_metrics.server_request_bytes.get(fields).sum)
+

[dsansome, 2016/03/15 02:01:20]

nit: delete 1 \n

[Sergey Berezin, 2016/03/17 22:14:04]

Done.

+
+
+class FakeTime(object):
+  def __init__(self):
+    self.timestamp_now = 1000.0
+
+  def time_fn(self):
+    self.timestamp_now += 0.2
+    return self.timestamp_now
+
+
+@endpoints.api(name='testapi', version='v1')
+class TestEndpoint(remote.Service):
+
+  @gae_ts_mon.instrument_endpoint(time_fn=FakeTime().time_fn)
+  @endpoints.method(message_types.VoidMessage, message_types.VoidMessage,
+                    name='method_good')
+  def do_good(self, request):
+    return request
+
+  @gae_ts_mon.instrument_endpoint(time_fn=FakeTime().time_fn)
+  @endpoints.method(message_types.VoidMessage, message_types.VoidMessage,
+                    name='method_bad')
+  def do_bad(self, request):
+    raise Exception
+
+  @gae_ts_mon.instrument_endpoint(time_fn=FakeTime().time_fn)
+  @endpoints.method(message_types.VoidMessage, message_types.VoidMessage,
+                    name='method_400')
+  def do_400(self, request):
+    raise endpoints.BadRequestException('Bad request')
+
+
+class InstrumentEndpointTest(testing.EndpointsTestCase):
+  api_service_cls = TestEndpoint
+
+  def setUp(self):
+    super(InstrumentEndpointTest, self).setUp()
+
+    config.reset_for_unittest()
+    target = targets.TaskTarget('test_service', 'test_job',
+                                'test_region', 'test_host')
+    self.mock_state = interface.State(target=target)
+    self.mock_state.metrics = copy.copy(interface.state.metrics)
+    mock.patch('infra_libs.ts_mon.common.interface.state',
+        new=self.mock_state).start()
+
+    mock.patch('infra_libs.ts_mon.common.monitors.PubSubMonitor',
+               autospec=True).start()
+
+  def tearDown(self):
+    config.reset_for_unittest()
+    self.assertEqual([], list(shared.global_metrics_callbacks))
+    mock.patch.stopall()
+    super(InstrumentEndpointTest, self).tearDown()
+
+  def test_good(self):
+    self.call_api('do_good')
+    fields = {'name': 'method_good', 'status': 200, 'is_robot': False}
+    self.assertEqual(1, http_metrics.server_response_status.get(fields))
+    self.assertEqual(200, http_metrics.server_durations.get(fields).sum)
+
+  def test_bad(self):
+    with self.call_should_fail('500 Internal Server Error'):
+      self.call_api('do_bad')
+    fields = {'name': 'method_bad', 'status': 500, 'is_robot': False}
+    self.assertEqual(1, http_metrics.server_response_status.get(fields))
+    self.assertEqual(200, http_metrics.server_durations.get(fields).sum)
+
+  def test_400(self):
+    with self.call_should_fail('400 Bad Request'):
+      self.call_api('do_400')
+    fields = {'name': 'method_400', 'status': 400, 'is_robot': False}
+    self.assertEqual(1, http_metrics.server_response_status.get(fields))
+    self.assertEqual(200, http_metrics.server_durations.get(fields).sum)