# 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 json
import unittest

import mock
import webapp2
import webtest

from google.appengine.ext import ndb

from dashboard import graph_json
from dashboard import testing_common
from dashboard import utils
from dashboard.models import anomaly
from dashboard.models import graph_data


class GraphJsonTest(testing_common.TestCase):

  def setUp(self):
    super(GraphJsonTest, self).setUp()
    app = webapp2.WSGIApplication(
        [('/graph_json', graph_json.GraphJsonHandler)])
    self.testapp = webtest.TestApp(app)
    self.PatchDatastoreHooksRequest()

  # TODO(qyearsley): graph_json_test is very slow (it takes 60+ seconds
  # to run sometimes), and I have a hypothesis that most of the time is
  # spent in _AddTestColumns. Investigate this hypothesis and make changes
  # accordingly.
  def _AddTestColumns(self, start_rev=15000, end_rev=16500, step=3):
    """Adds a bunch of test data to the mock datastore.

    In particular, add Rows with revisions in the given range (but skipping
    some numbers, so the revisions are non-contiguous) under the dromaeo/dom
    test for winXP, win7, mac.

    Args:
      start_rev: Starting revision number.
      end_rev: Ending revision number.
      step: Difference between adjacent revisions.
    """
    master = graph_data.Master(id='ChromiumGPU')
    master.put()
    bots = []
    rows = []
    for name in ['winXP', 'win7', 'mac']:
      bot = graph_data.Bot(id=name, parent=master.key)
      bot.put()
      bots.append(bot)
      test = graph_data.Test(id='dromaeo', parent=bot.key)
      test.put()
      for sub_name in ['dom', 'jslib']:
        sub_test = graph_data.Test(id=sub_name, parent=test.key,
                                   improvement_direction=anomaly.UP,
                                   has_rows=True).put()
        test_container_key = utils.GetTestContainerKey(sub_test)
        for i in range(start_rev, end_rev, step):
          # Add Rows for one bot with revision numbers that aren't lined up
          # with the other bots.
          rev = i + 1 if name == 'mac' else i
          row = graph_data.Row(
              parent=test_container_key, id=rev, value=float(i * 2),
              r_webkit=int(i * 0.25), a_str='some_string',
              buildnumber=i - start_rev,
              a_tracing_uri='http://trace/%d' % i,
              a_trace_rerun_options={'foo': '--foo'})
          rows.append(row)
    ndb.put_multi(rows)

  def _AddLongTestColumns(self, start_rev=15000, end_rev=16500, step=3):
    """Adds test data with long nested sub test to the mock datastore.

    Args:
      start_rev: Starting revision number.
      end_rev: Ending revision number.
      step: Difference between adjacent revisions.
    """
    master = graph_data.Master(id='master')
    master.put()
    bot = graph_data.Bot(id='bot', parent=master.key)
    bot.put()
    test = graph_data.Test(id='suite', parent=bot.key)
    test.put()

    rows = []
    for sub_name in ['sub1', 'sub2', 'sub3', 'sub4', 'sub5']:
      test = graph_data.Test(id=sub_name, parent=test.key,
                             improvement_direction=anomaly.UP,
                             has_rows=True)
      test.put()
      test_container_key = utils.GetTestContainerKey(test.key)
      for i in range(start_rev, end_rev, step):
        row = graph_data.Row(
            parent=test_container_key, id=i, value=float(i * 2),
            r_webkit=int(i * 0.25), a_str='some_string',
            buildnumber=i - start_rev,
            a_tracing_uri='http://trace/%d' % i,
            a_trace_rerun_options={'foo': '--foo'})
        rows.append(row)
    ndb.put_multi(rows)

  def _GetSeriesIndex(self, flot, test_path):
    series = flot['annotations']['series']
    for index in series:
      if series[index]['path'] == test_path:
        return index
    return None

  def CheckFlotJson(
      self, json_str, num_rows, num_cols, start_rev, end_rev, step=3):
    """Checks whether a JSON string output by GetGraphJson is correct.

    It's assumed that data should match data that might be added by the
    _AddTestColumns method above.

    In general, the Flot JSON should at contain a dict with the key 'data'
    which is mapped to a list of dicts (which represent data series), each of
    which also has a key called 'data', which is mapped to a list of 2-element
    lists (which represent points). For example:

        {data: {data: [[1, 10], [2, 20]]}, {data: [[3, 30], [4, 40]]}}

    Args:
      json_str: The JSON string to check.
      num_rows: The expected number of points in each trace.
      num_cols: The expected number of trace lines.
      start_rev: Starting revision number.
      end_rev: End revision number.
      step: Expected difference between adjacent revision numbers.
    """
    try:
      flot = json.loads(json_str)
    except ValueError:
      self.fail('GetGraphJson returned invalid JSON')

    data = flot.get('data')
    if not data:
      self.fail('No flot data generated by GetGraphJson')
    self.assertEqual(num_cols, len(data))
    for key in data:
      col = data[key]
      if not col.get('data'):
        self.fail('No flot columns generated by GetGraphJson')
      self.assertEqual(num_rows, len(col['data']))
      for index, rev in enumerate(range(start_rev, end_rev, step)):
        self.assertEqual(rev, col['data'][index][0])
        self.assertEqual(rev * 2, col['data'][index][1])

  def testPost_ValidRequest(self):
    self._AddTestColumns(start_rev=15700, end_rev=16000, step=1)
    graphs = {
        'test_path_dict': {
            'ChromiumGPU/winXP/dromaeo/dom': [],
            'ChromiumGPU/winXP/dromaeo/jslib': [],
        }
    }
    # If the request is valid, a valid response will be returned.
    response = self.testapp.post(
        '/graph_json', {'graphs': json.dumps(graphs)})
    flot_json_str = response.body
    self.CheckFlotJson(flot_json_str, 150, 2, 15850, 16000, step=1)
    self.assertEqual('*', response.headers.get('Access-Control-Allow-Origin'))

  def testPost_InvalidRequest_ReportsError(self):
    self.testapp.post('/graph_json', {}, status=500)
    self.testapp.post('/graph_json', {'graphs': ''}, status=500)
    self.testapp.post('/graph_json', {'graphs': '{}'}, status=500)

  def testPost_LongTestPathWithSelected(self):
    self._AddLongTestColumns(start_rev=15700, end_rev=16000, step=1)
    graphs = {
        'test_path_dict': {
            'master/bot/suite/sub1/sub2/sub3/sub4/sub5': ['sub5']
        },
        'is_selected': True
    }
    # If the request is valid, a valid response will be returned.
    response = self.testapp.post(
        '/graph_json', {'graphs': json.dumps(graphs)})
    flot_json_str = response.body
    self.CheckFlotJson(flot_json_str, 150, 1, 15850, 16000, step=1)

  def testPost_LongTestPathWithUnSelected(self):
    self._AddLongTestColumns(start_rev=15700, end_rev=16000, step=1)
    graphs = {
        'test_path_dict': {
            'master/bot/suite/sub1/sub2/sub3/sub4': ['sub4']
        }
    }
    # If the request is valid, a valid response will be returned.
    response = self.testapp.post(
        '/graph_json', {'graphs': json.dumps(graphs)})
    flot_json_str = response.body
    self.CheckFlotJson(flot_json_str, 150, 1, 15850, 16000, step=1)

  def testPost_LongTestPathWithUnSelectedAndNoSubTest_NoGraphData(self):
    self._AddLongTestColumns(start_rev=15700, end_rev=16000, step=1)
    graphs = {
        'test_path_dict': {
            'master/bot/suite/sub1/sub2/sub3/sub4/sub5': ['sub5']
        },
    }
    # If the request is valid, a valid response will be returned.
    response = self.testapp.post(
        '/graph_json', {'graphs': json.dumps(graphs)})
    flot_json_str = response.body
    flot = json.loads(flot_json_str)
    self.assertEqual(0, len(flot['data']))

  def testRequest_NoSubTest_ShowsSummaryTests(self):
    """Tests the post method of the request handler."""
    self._AddTestColumns(start_rev=15700, end_rev=16000, step=1)
    graphs = {
        'test_path_dict': {
            'ChromiumGPU/winXP/dromaeo': [],
        }
    }
    # If the request is valid, a valid response will be returned.
    response = self.testapp.post(
        '/graph_json', {'graphs': json.dumps(graphs)})
    flot_json_str = response.body
    self.CheckFlotJson(flot_json_str, 150, 2, 15850, 16000, step=1)

  def testGetGraphJsonNoArgs(self):
    self._AddTestColumns(start_rev=16047)
    flot_json_str = graph_json.GetGraphJson(
        {'ChromiumGPU/win7/dromaeo/dom': []})
    self.CheckFlotJson(flot_json_str, 150, 1, 16050, 16500)

  def testGetGraphJsonRevisionStart(self):
    self._AddTestColumns(end_rev=15500)
    flot_json_str = graph_json.GetGraphJson(
        {'ChromiumGPU/win7/dromaeo/dom': []}, rev=15000)
    self.CheckFlotJson(flot_json_str, 76, 1, 15000, 15228)

  def testGetGraphJsonRevisionMiddle(self):
    self._AddTestColumns(end_rev=15600)
    flot_json_str = graph_json.GetGraphJson(
        {'ChromiumGPU/win7/dromaeo/dom': []}, rev=15300)
    self.CheckFlotJson(flot_json_str, 151, 1, 15075, 15525)

  def testGetGraphJsonNumPoints(self):
    self._AddTestColumns(end_rev=15500)
    flot_json_str = graph_json.GetGraphJson(
        {'ChromiumGPU/win7/dromaeo/dom': []}, rev=15300, num_points=8)
    self.CheckFlotJson(flot_json_str, 9, 1, 15288, 15315)

  def testGetGraphJsonStartEndRev(self):
    self._AddTestColumns(start_rev=15991)
    flot_json_str = graph_json.GetGraphJson(
        {'ChromiumGPU/win7/dromaeo/dom': []}, start_rev=16000,
        end_rev=16030)
    self.CheckFlotJson(flot_json_str, 11, 1, 16000, 16030)

  def testGetGraphJsonMultipleBots(self):
    self._AddTestColumns(start_rev=16047)
    flot_json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/dom': [],
            'ChromiumGPU/winXP/dromaeo/dom': [],
        })
    self.CheckFlotJson(flot_json_str, 150, 2, 16050, 16500)

  def testGetGraphJsonMultipleTests(self):
    self._AddTestColumns(start_rev=16047)
    flot_json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/dom': [],
            'ChromiumGPU/win7/dromaeo/jslib': [],
        })
    self.CheckFlotJson(flot_json_str, 150, 2, 16050, 16500)

  def testGetGraphJsonError(self):
    self._AddTestColumns(start_rev=15000, end_rev=15015)

    rows = graph_data.Row.query(
        graph_data.Row.parent_test == ndb.Key(
            'Master', 'ChromiumGPU', 'Bot', 'win7',
            'Test', 'dromaeo', 'Test', 'dom')).fetch()
    for row in rows:
      row.error = 1 + ((row.revision - 15000) * 0.25)
    ndb.put_multi(rows)
    flot_json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/dom': [],
        })
    flot = json.loads(flot_json_str)
    self.assertEqual(1, len(flot['error_bars'].keys()))
    rev = 0
    for col_dom, col_top, col_bottom in zip(
        flot['data']['0']['data'],
        flot['error_bars']['0'][1]['data'],
        flot['error_bars']['0'][0]['data']):
      error = 1 + (rev * 0.25)
      self.assertEqual(rev + 15000, col_top[0])
      self.assertEqual(col_dom[1] + error, col_top[1])
      self.assertEqual(rev + 15000, col_bottom[0])
      self.assertEqual(col_dom[1] - error, col_bottom[1])
      rev += 3

  def testGetGraphJsonSkewedRevisions(self):
    self._AddTestColumns(end_rev=15500)
    json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/dom': [],
            'ChromiumGPU/mac/dromaeo/dom': [],
        },
        rev=15000, num_points=8)
    flot = json.loads(json_str)
    data = flot.get('data')
    win7_index = self._GetSeriesIndex(flot, 'ChromiumGPU/win7/dromaeo/dom')
    mac_index = self._GetSeriesIndex(flot, 'ChromiumGPU/mac/dromaeo/dom')

    if not data:
      self.fail('No flot data generated by GetGraphJson')
    self.assertEqual(2, len(data))
    self.assertEqual(
        [[15000, 30000.0], [15003, 30006.0], [15006, 30012.0]],
        data[win7_index].get('data'))
    self.assertEqual(
        [[15001, 30000.0], [15004, 30006.0]],
        data[mac_index].get('data'))

  def testGetGraphJson_ClampsRevisions(self):
    self._AddTestColumns(end_rev=15500)
    # No revision specified, clamps to the last 9 rows.
    json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/dom': [],
            'ChromiumGPU/mac/dromaeo/dom': [],
        },
        num_points=8)
    flot = json.loads(json_str)

    data = flot.get('data')
    win7_index = self._GetSeriesIndex(flot, 'ChromiumGPU/win7/dromaeo/dom')
    mac_index = self._GetSeriesIndex(flot, 'ChromiumGPU/mac/dromaeo/dom')

    # Two columns
    self.assertEqual(2, len(data))
    # Clamped from 15487-15499 by 3 steps.  First row doesn't contain 15487.
    self.assertEqual(
        [
            [15489, 30978.0],
            [15492, 30984.0],
            [15495, 30990.0],
            [15498, 30996.0]
        ],
        data[win7_index].get('data'))
    self.assertEqual(
        [
            [15487, 30972.0],
            [15490, 30978.0],
            [15493, 30984.0],
            [15496, 30990.0],
            [15499, 30996.0]
        ],
        data[mac_index].get('data'))

    # Revision 100 (way before data starts) specified, clamp to the first 8 rows
    json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/dom': [],
            'ChromiumGPU/mac/dromaeo/dom': [],
        },
        rev=100, num_points=8)
    flot = json.loads(json_str)
    data = flot.get('data')
    win7_index = self._GetSeriesIndex(flot, 'ChromiumGPU/win7/dromaeo/dom')
    mac_index = self._GetSeriesIndex(flot, 'ChromiumGPU/mac/dromaeo/dom')

    # Two columns
    self.assertEqual(2, len(data))
    # 15000-15012.
    self.assertEqual(
        [
            [15000, 30000.0],
            [15003, 30006.0],
            [15006, 30012.0],
            [15009, 30018.0]
        ],
        data[win7_index].get('data'))
    self.assertEqual(
        [
            [15001, 30000.0],
            [15004, 30006.0],
            [15007, 30012.0],
            [15010, 30018.0]
        ],
        data[mac_index].get('data'))

    # Revision 15530 (valid) specified, clamp 4 rows before/after
    json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/dom': [],
            'ChromiumGPU/mac/dromaeo/dom': [],
        },
        rev=15030, num_points=8)
    flot = json.loads(json_str)
    data = flot.get('data')
    win7_index = self._GetSeriesIndex(flot, 'ChromiumGPU/win7/dromaeo/dom')
    mac_index = self._GetSeriesIndex(flot, 'ChromiumGPU/mac/dromaeo/dom')

    # Two columns
    self.assertEqual(2, len(data))
    # 15524-15536.
    self.assertEqual(
        [
            [15024, 30048.0],
            [15027, 30054.0],
            [15030, 30060.0],
            [15033, 30066.0],
            [15036, 30072.0]
        ],
        data[win7_index].get('data'))
    self.assertEqual(
        [
            [15025, 30048.0],
            [15028, 30054.0],
            [15031, 30060.0],
            [15034, 30066.0]
        ],
        data[mac_index].get('data'))

    # Revision 15498 specified, clamp 4 rows before and after is cut off
    json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/dom': [],
            'ChromiumGPU/mac/dromaeo/dom': [],
        },
        rev=15498, num_points=7)
    flot = json.loads(json_str)
    data = flot.get('data')
    win7_index = self._GetSeriesIndex(flot, 'ChromiumGPU/win7/dromaeo/dom')
    mac_index = self._GetSeriesIndex(flot, 'ChromiumGPU/mac/dromaeo/dom')

    # Two columns
    self.assertEqual(2, len(data))

    # 15493-15499.
    self.assertEqual(
        [[15495, 30990.0], [15498, 30996.0]],
        data[win7_index].get('data'))
    self.assertEqual(
        [[15493, 30984.0], [15496, 30990.0], [15499, 30996.0]],
        data[mac_index].get('data'))

    # Revision 15001 specified, before is cut off and clamp 4 rows after
    json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/dom': [],
            'ChromiumGPU/mac/dromaeo/dom': [],
        },
        rev=15001, num_points=8)
    flot = json.loads(json_str)
    data = flot.get('data')
    win7_index = self._GetSeriesIndex(flot, 'ChromiumGPU/win7/dromaeo/dom')
    mac_index = self._GetSeriesIndex(flot, 'ChromiumGPU/mac/dromaeo/dom')

    # Two columns
    self.assertEqual(2, len(data))

    # 15493-15499.
    self.assertEqual(
        [[15000, 30000.0], [15003, 30006.0], [15006, 30012.0]],
        data[win7_index].get('data'))
    self.assertEqual(
        [[15001, 30000.0], [15004, 30006.0], [15007, 30012.0]],
        data[mac_index].get('data'))

  def testGetGraphJson_GraphJsonAnnotations(self):
    self._AddTestColumns(end_rev=15500)
    flot_json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/dom': [],
        },
        rev=15000, num_points=8)
    flot = json.loads(flot_json_str)
    annotations = flot['annotations']
    self.assertEqual(5, len(flot['data']['0']['data']))
    for i, _ in enumerate(flot['data']['0']['data']):
      rev = flot['data']['0']['data'][i][0]
      self.assertEqual(int(int(rev) * 0.25),
                       annotations['0'][str(i)]['r_webkit'])

  def testGetGraphJson_WithAnomalies_ReturnsCorrectAnomalyAnnotations(self):
    self._AddTestColumns()

    anomaly1 = anomaly.Anomaly(
        start_revision=14999, end_revision=15000,
        test=utils.TestKey('ChromiumGPU/win7/dromaeo/dom'),
        median_before_anomaly=100,
        median_after_anomaly=200)
    anomaly1.SetIsImprovement()
    key1 = anomaly1.put()

    anomaly2 = anomaly.Anomaly(
        start_revision=15004, end_revision=15006,
        test=utils.TestKey('ChromiumGPU/win7/dromaeo/dom'),
        median_before_anomaly=200,
        median_after_anomaly=100,
        bug_id=12345)
    anomaly2.SetIsImprovement()
    key2 = anomaly2.put()

    test = utils.TestKey('ChromiumGPU/win7/dromaeo/dom').get()
    test.description = 'About this test'
    test.units = 'ms'
    test.buildername = 'Windows 7 (1)'
    test.put()

    flot_json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/dom': [],
        },
        rev=15000, num_points=8)

    flot = json.loads(flot_json_str)
    annotations = flot['annotations']
    self.assertEqual(5, len(annotations['0']))

    # Verify key fields of the annotation dictionary for the first anomaly.
    anomaly_one_annotation = annotations['0']['0']['g_anomaly']
    self.assertEqual(14999, anomaly_one_annotation['start_revision'])
    self.assertEqual(15000, anomaly_one_annotation['end_revision'])
    self.assertEqual('100.0%', anomaly_one_annotation['percent_changed'])
    self.assertIsNone(anomaly_one_annotation['bug_id'])
    self.assertEqual(key1.urlsafe(), anomaly_one_annotation['key'])
    self.assertTrue(anomaly_one_annotation['improvement'])

    # Verify key fields of the annotation dictionary for th second anomaly.
    anomaly_two_annotation = annotations['0']['2']['g_anomaly']
    self.assertEqual(15004, anomaly_two_annotation['start_revision'])
    self.assertEqual(15006, anomaly_two_annotation['end_revision'])
    self.assertEqual('50.0%', anomaly_two_annotation['percent_changed'])
    self.assertEqual(12345, anomaly_two_annotation['bug_id'])
    self.assertEqual(key2.urlsafe(), anomaly_two_annotation['key'])
    self.assertFalse(anomaly_two_annotation['improvement'])

    # Verify the tracing link annotations
    self.assertEqual('http://trace/15000',
                     annotations['0']['0']['a_tracing_uri'])
    self.assertEqual('http://trace/15012',
                     annotations['0']['4']['a_tracing_uri'])

    # Verify the tracing rerun options
    self.assertEqual({'foo': '--foo'},
                     annotations['0']['0']['a_trace_rerun_options'])

    # Verify the series annotations.
    self.assertEqual({
        '0': {
            'name': 'dom',
            'path': 'ChromiumGPU/win7/dromaeo/dom',
            'units': 'ms',
            'better': 'Higher',
            'description': 'About this test'
        }
    }, annotations['series'])

  def testGetGraphJson_SomeDataDeprecated_OmitsDeprecatedData(self):
    self._AddTestColumns(start_rev=15000, end_rev=15050)
    dom = utils.TestKey('ChromiumGPU/win7/dromaeo/dom').get()
    dom.deprecated = True
    dom.put()
    jslib = utils.TestKey('ChromiumGPU/win7/dromaeo/jslib').get()
    jslib.deprecated = True
    jslib.put()

    flot_json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/dom': [],
            'ChromiumGPU/win7/dromaeo/jslib': [],
            'ChromiumGPU/mac/dromaeo/dom': [],
            'ChromiumGPU/mac/dromaeo/jslib': [],
        },
        rev=15000, num_points=8)
    flot = json.loads(flot_json_str)
    # The win7 tests are deprecated and the mac tests are not. So only the mac
    # tests should be returned.
    self.assertEqual(2, len(flot['data']))
    self.assertEqual(2, len(flot['annotations']['series']))
    self.assertIsNotNone(
        self._GetSeriesIndex(flot, 'ChromiumGPU/mac/dromaeo/dom'))
    self.assertIsNotNone(
        self._GetSeriesIndex(flot, 'ChromiumGPU/mac/dromaeo/jslib'))

  def testGetGraphJson_WithSelectedTrace(self):
    self._AddTestColumns(start_rev=15000, end_rev=15050)
    rows = graph_data.Row.query(
        graph_data.Row.parent_test == utils.TestKey(
            'ChromiumGPU/win7/dromaeo/jslib')).fetch()
    for row in rows:
      row.error = 1 + ((row.revision - 15000) * 0.25)
    ndb.put_multi(rows)

    flot_json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/jslib': ['jslib'],
        },
        rev=15000, num_points=8, is_selected=True)
    flot = json.loads(flot_json_str)

    self.assertEqual(1, len(flot['data']))
    self.assertEqual(5, len(flot['data']['0']['data']))
    self.assertEqual(1, len(flot['annotations']['series']))
    self.assertEqual(5, len(flot['annotations'].get('0').keys()))
    self.assertEqual(5, len(flot['error_bars']['0'][0]['data']))
    self.assertEqual(5, len(flot['error_bars']['0'][1]['data']))

  def testGetGraphJson_UnSelectedTrace(self):
    self._AddTestColumns(start_rev=15000, end_rev=15050)
    test_key = ndb.Key(
        'Master', 'ChromiumGPU', 'Bot', 'win7',
        'Test', 'dromaeo', 'Test', 'jslib')
    rows = graph_data.Row.query(graph_data.Row.parent_test == test_key).fetch()
    for row in rows:
      row.error = 1 + ((row.revision - 15000) * 0.25)
    ndb.put_multi(rows)

    # Insert sub tests to jslib.
    rows = []
    start_rev = 15000
    end_rev = 15050
    for name in ['sub_test_a', 'sub_test_b']:
      sub_test = graph_data.Test(id=name, parent=test_key,
                                 improvement_direction=anomaly.UP,
                                 has_rows=True).put()
      sub_test_container_key = utils.GetTestContainerKey(sub_test)
      for i in range(start_rev, end_rev, 3):
        # Add Rows for one bot with revision numbers that aren't lined up
        # with the other bots.
        row = graph_data.Row(
            parent=sub_test_container_key, id=i, value=float(i * 2),
            r_webkit=int(i * 0.25), a_str='some_string',
            buildnumber=i - start_rev,
            a_tracing_uri='http://trace/%d' % i,
            a_trace_rerun_options={'foo': '--foo'})
        rows.append(row)
    ndb.put_multi(rows)

    flot_json_str = graph_json.GetGraphJson(
        {
            'ChromiumGPU/win7/dromaeo/jslib': ['jslib'],
        },
        rev=15000, num_points=8, is_selected=False)
    flot = json.loads(flot_json_str)

    sub_test_a_index = self._GetSeriesIndex(
        flot, 'ChromiumGPU/win7/dromaeo/jslib/sub_test_a')
    sub_test_b_index = self._GetSeriesIndex(
        flot, 'ChromiumGPU/win7/dromaeo/jslib/sub_test_b')

    self.assertEqual(2, len(flot['data']))
    self.assertEqual(5, len(flot['data'][sub_test_a_index]['data']))
    self.assertEqual(2, len(flot['annotations']['series']))
    self.assertEqual(5, len(flot['annotations'].get(sub_test_a_index).keys()))
    self.assertEqual(5, len(flot['annotations'].get(sub_test_b_index).keys()))

  def testGetGraphJson_ManyUnselected_ReturnsNothing(self):
    testing_common.AddTests(
        ['M'], ['b'], {'suite': {str(i): {} for i in range(100)}})
    test_paths = ['M/b/suite/%s' % i for i in range(100)]
    for p in test_paths:
      testing_common.AddRows(p, [1])
    response = graph_json.GetGraphJson(
        test_path_dict={p: [] for p in test_paths}, is_selected=False)
    self.assertEqual(
        {'data': {}, 'annotations': {}, 'error_bars': {}},
        json.loads(response))


class GraphJsonParseRequestArgumentsTest(testing_common.TestCase):

  def _HandlerWithMockRequestParams(self, **params):
    """Returns a GraphJsonHandler object with canned request parameters."""
    request_params = {
        'test_path_dict': {
            'Master/b1/scrolling/frame_times/about.com': [],
            'Master/b2/scrolling/frame_times/about.com': [],
            'Master/linux/dromaeo.domcoremodify/dom': [],
        }
    }
    request_params.update(params)
    handler = graph_json.GraphJsonHandler()
    handler.request = mock.MagicMock()
    handler.request.get = mock.MagicMock(
        return_value=json.dumps(request_params))
    return handler

  def testParseRequestArguments(self):
    # The numerical arguments get converted to integers, and the
    # unspecified arguments get set to None.
    handler = self._HandlerWithMockRequestParams(rev='12345', num_points='123')
    expected = {
        'test_path_dict': {
            'Master/b1/scrolling/frame_times/about.com': [],
            'Master/b2/scrolling/frame_times/about.com': [],
            'Master/linux/dromaeo.domcoremodify/dom': [],
        },
        'rev': 12345,
        'num_points': 123,
        'start_rev': None,
        'end_rev': None,
        'is_selected': None,
    }
    self.assertEqual(expected, handler._ParseRequestArguments())

  def testParseRequestArguments_OnlyTestPathDictSpecified(self):
    # No revision or number of points is specified, so they're set to None.
    handler = self._HandlerWithMockRequestParams()
    expected = {
        'test_path_dict': {
            'Master/b1/scrolling/frame_times/about.com': [],
            'Master/b2/scrolling/frame_times/about.com': [],
            'Master/linux/dromaeo.domcoremodify/dom': [],
        },
        'rev': None,
        'num_points': graph_json._DEFAULT_NUM_POINTS,
        'start_rev': None,
        'end_rev': None,
        'is_selected': None,
    }
    self.assertEqual(expected, handler._ParseRequestArguments())

  def testParseRequestArguments_NegativeRevision(self):
    # Negative revision is invalid; it's the same as no revision.
    handler = self._HandlerWithMockRequestParams(rev='-1')
    expected = {
        'test_path_dict': {
            'Master/b1/scrolling/frame_times/about.com': [],
            'Master/b2/scrolling/frame_times/about.com': [],
            'Master/linux/dromaeo.domcoremodify/dom': [],
        },
        'rev': None,
        'num_points': graph_json._DEFAULT_NUM_POINTS,
        'start_rev': None,
        'end_rev': None,
        'is_selected': None,
    }
    self.assertEqual(expected, handler._ParseRequestArguments())


class GraphJsonHelperFunctionTest(testing_common.TestCase):

  def testPointInfoDict_StdioUriMarkdown(self):
    testing_common.AddTests(['Master'], ['b'], {'my_suite': {}})
    test = utils.TestKey('Master/b/my_suite').get()
    test.buildername = 'MyBuilder'
    test_container_key = utils.GetTestContainerKey(test)
    row = graph_data.Row(id=345, buildnumber=456, parent=test_container_key)
    row.a_stdio_uri = ('[Build stdio](http://build.chromium.org/p/my.master.id/'
                       'builders/MyBuilder/builds/456/steps/my_suite/logs/'
                       'stdio)')
    point_info = graph_json._PointInfoDict(row, {})
    self.assertEqual(row.a_stdio_uri, point_info['a_stdio_uri'])

  def testPointInfoDict_RowHasNoTracingUri_ResultHasNoTracingUri(self):
    testing_common.AddTests(['Master'], ['b'], {'my_suite': {}})
    rows = testing_common.AddRows('Master/b/my_suite', [345])
    # This row has no a_tracing_uri property, so there should be no
    # trace annotation returned by _PointInfoDict.
    point_info = graph_json._PointInfoDict(rows[0], {})
    self.assertFalse(hasattr(rows[0], 'a_tracing_uri'))
    self.assertNotIn('a_tracing_uri', point_info)


if __name__ == '__main__':
  unittest.main()