#!/usr/bin/env vpython3
# Copyright 2016 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.

import copy
import unittest

import results_merger

GOOD_JSON_TEST_RESULT_0 = {
    'tests': {
        'car': {
            'honda': {
                'expected': 'PASS',
                'actual': 'PASS'
            },
            'toyota': {
                'expected': 'FAIL',
                'actual': 'FAIL'
            }
        },
        'computer': {
            'dell': {
                'expected': 'PASS',
                'actual': 'PASS'
            }
        },
    },
    'interrupted': False,
    'version': 3,
    'seconds_since_epoch': 1406662289.76,
    'num_failures_by_type': {
        'FAIL': 0,
        'PASS': 2
    },
    'layout_tests_dir': 'abc'
}

GOOD_JSON_TEST_RESULT_1 = {
    'tests': {
        'car': {
            'tesla': {
                'expected': 'PASS',
                'actual': 'PASS'
            },
        },
        'burger': {
            'mcdonald': {
                'expected': 'PASS',
                'actual': 'PASS'
            }
        },
    },
    'interrupted': False,
    'version': 3,
    'seconds_since_epoch': 1406662283.11,
    'num_failures_by_type': {
        'FAIL': 0,
        'PASS': 2
    },
    'layout_tests_dir': '123'
}

GOOD_JSON_TEST_RESULT_2 = {
    'tests': {
        'car': {
            'mercedes': {
                'expected': 'PASS',
                'actual': 'FAIL'
            },
        },
        'burger': {
            'in n out': {
                'expected': 'PASS',
                'actual': 'PASS'
            }
        },
    },
    'interrupted': True,
    'version': 3,
    'seconds_since_epoch': 1406662200.01,
    'num_failures_by_type': {
        'FAIL': 1,
        'PASS': 1
    }
}

GOOD_JSON_TEST_RESULT_MERGED = {
    'tests': {
        'car': {
            'tesla': {
                'expected': 'PASS',
                'actual': 'PASS'
            },
            'mercedes': {
                'expected': 'PASS',
                'actual': 'FAIL'
            },
            'honda': {
                'expected': 'PASS',
                'actual': 'PASS'
            },
            'toyota': {
                'expected': 'FAIL',
                'actual': 'FAIL'
            }
        },
        'computer': {
            'dell': {
                'expected': 'PASS',
                'actual': 'PASS'
            }
        },
        'burger': {
            'mcdonald': {
                'expected': 'PASS',
                'actual': 'PASS'
            },
            'in n out': {
                'expected': 'PASS',
                'actual': 'PASS'
            }
        }
    },
    'interrupted': True,
    'version': 3,
    'seconds_since_epoch': 1406662200.01,
    'num_failures_by_type': {
        'FAIL': 1,
        'PASS': 5
    },
    'layout_tests_dir': '123'
}


def extend(initial, add):
  out = copy.deepcopy(initial)
  out.update(add)
  return out


def remove(initial, keys):
  out = copy.deepcopy(initial)
  for k in keys:
    del out[k]
  return out


# These unittests are run in PRESUBMIT, but not by recipe_simulation_test, hence
# to avoid false alert on missing coverage by recipe_simulation_test, we mark
# these code as no cover.
class MergingTest(unittest.TestCase):  # pragma: no cover
  maxDiff = None  # Show full diff if assertion fail

  def test_merge_tries(self):
    self.assertEqual({
        'a': 'A',
        'b': {
            'c': 'C'
        }
    }, results_merger.merge_tries({
        'a': 'A',
        'b': {}
    }, {'b': {
        'c': 'C'
    }}))

  def test_merge_tries_unmergable(self):
    with self.assertRaisesRegex(results_merger.MergeException, 'a:b'):
      results_merger.merge_tries({'a': {'b': 'A'}}, {'a': {'b': 'C'}})

  def test_merge_metadata(self):
    metadata1 = {'metadata': {'tags': ['foo', 'bar']}}
    metadata2 = {'metadata': {'tags': ['foo', 'bat']}}
    merged_results = results_merger.merge_test_results([
        extend(GOOD_JSON_TEST_RESULT_0, metadata1),
        extend(GOOD_JSON_TEST_RESULT_1, metadata2)
    ])
    self.assertEqual(merged_results['metadata']['tags'], ['foo', 'bat'])

  def test_merge_json_test_results_nop(self):
    good_json_results = (GOOD_JSON_TEST_RESULT_0, GOOD_JSON_TEST_RESULT_1,
                         GOOD_JSON_TEST_RESULT_2, GOOD_JSON_TEST_RESULT_MERGED)
    for j in good_json_results:
      # Clone so we can check the input dictionaries are not modified
      a = copy.deepcopy(j)
      self.assertEqual(results_merger.merge_test_results([a]), j)
      self.assertEqual(a, j)

  def test_merge_json_test_results_invalid_version(self):
    with self.assertRaises(results_merger.MergeException):
      results_merger.merge_test_results([
          extend(GOOD_JSON_TEST_RESULT_0, {'version': 5}),
      ])

    with self.assertRaises(results_merger.MergeException):
      results_merger.merge_test_results([
          GOOD_JSON_TEST_RESULT_0,
          extend(GOOD_JSON_TEST_RESULT_1, {'version': 5}),
      ])

  def test_merge_json_test_results_missing_version(self):
    with self.assertRaises(results_merger.MergeException):
      results_merger.merge_test_results([
          remove(GOOD_JSON_TEST_RESULT_0, ['version']),
      ])

    with self.assertRaises(results_merger.MergeException):
      results_merger.merge_test_results([
          GOOD_JSON_TEST_RESULT_0,
          remove(GOOD_JSON_TEST_RESULT_1, ['version']),
      ])

  def test_merge_json_test_results_invalid_extra(self):
    with self.assertRaises(results_merger.MergeException):
      results_merger.merge_test_results([
          extend(GOOD_JSON_TEST_RESULT_0, {'extra': True}),
      ])

    with self.assertRaises(results_merger.MergeException):
      results_merger.merge_test_results([
          GOOD_JSON_TEST_RESULT_0,
          extend(GOOD_JSON_TEST_RESULT_1, {'extra': True}),
      ])

  def test_merge_json_test_results_missing_required(self):
    with self.assertRaises(results_merger.MergeException):
      results_merger.merge_test_results([
          remove(GOOD_JSON_TEST_RESULT_0, ['interrupted']),
      ])

    with self.assertRaises(results_merger.MergeException):
      results_merger.merge_test_results([
          GOOD_JSON_TEST_RESULT_0,
          remove(GOOD_JSON_TEST_RESULT_1, ['interrupted']),
      ])

  def test_merge_json_test_results_multiple(self):
    self.assertEqual(
        results_merger.merge_test_results([
            GOOD_JSON_TEST_RESULT_0,
            GOOD_JSON_TEST_RESULT_1,
            GOOD_JSON_TEST_RESULT_2,
        ]), GOOD_JSON_TEST_RESULT_MERGED)

  def test_merge_json_test_results_optional_matches(self):
    self.assertEqual(
        results_merger.merge_test_results([
            extend(GOOD_JSON_TEST_RESULT_0, {'path_delimiter': '.'}),
            extend(GOOD_JSON_TEST_RESULT_1, {'path_delimiter': '.'}),
            extend(GOOD_JSON_TEST_RESULT_2, {'path_delimiter': '.'}),
        ]), extend(GOOD_JSON_TEST_RESULT_MERGED, {'path_delimiter': '.'}))

  def test_merge_json_test_results_optional_differs(self):
    with self.assertRaises(results_merger.MergeException):
      results_merger.merge_test_results([
          extend(GOOD_JSON_TEST_RESULT_0, {'path_delimiter': '.'}),
          extend(GOOD_JSON_TEST_RESULT_1, {'path_delimiter': '.'}),
          extend(GOOD_JSON_TEST_RESULT_2, {'path_delimiter': '/'}),
      ])

  def test_merge_json_test_results_optional_count(self):
    self.assertEqual(
        results_merger.merge_test_results([
            extend(GOOD_JSON_TEST_RESULT_0, {'fixable': 1}),
            extend(GOOD_JSON_TEST_RESULT_1, {'fixable': 2}),
            extend(GOOD_JSON_TEST_RESULT_2, {'fixable': 3}),
        ]), extend(GOOD_JSON_TEST_RESULT_MERGED, {'fixable': 6}))

  def test_merge_nothing(self):
    self.assertEqual(results_merger.merge_test_results([]), {})


# TODO(tansell): Make this test fail properly, currently fails with an
# AttributeError.
#  def test_merge_test_name_conflict(self):
#    self.maxDiff = None  # Show full diff if assertion fail
#    with self.assertRaises(results_merger.MergeException):
#      results_merger.merge_test_results(
#        [GOOD_JSON_TEST_RESULT_0, GOOD_JSON_TEST_RESULT_0])

if __name__ == '__main__':
  unittest.main()  # pragma: no cover
