Handle missing EMMA files.

build/android/emma_coverage_stats_test.py

 #!/usr/bin/python
 # 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 os
 import sys
 import unittest
 from xml.etree import ElementTree
 
 import emma_coverage_stats
 from pylib import constants
 
 sys.path.append(os.path.join(
     constants.DIR_SOURCE_ROOT, 'third_party', 'pymock'))
@@ skipping 209 matching lines @@
     calls = [mock.call('fake/dir/index.html'),
              mock.call('fake/dir/_files/1.html'),
              mock.call('fake/dir/_files/0.html')]
     mock_open.assert_has_calls(calls)
 
   def testGetPackageNameToEmmaFileDict_noPackageElements(self):
     self.parser._FindElements = mock.Mock(return_value=[])
     return_dict = self.parser.GetPackageNameToEmmaFileDict()
     self.assertDictEqual({}, return_dict)
 
-  def testGetPackageNameToEmmaFileDict_badFilePath(self):
-    self.parser._FindElements = mock.Mock(return_value=[])
-    return_dict = self.parser.GetPackageNameToEmmaFileDict()
-    self.assertEqual(return_dict, {})
-
   def testGetLineCoverage_status_basic(self):
     line_coverage = self.GetLineCoverageWithFakeElements([self.covered_tr_html])
     self.assertEqual(line_coverage[0].covered_status,
                      emma_coverage_stats.COVERED)
 
   def testGetLineCoverage_status_statusMissing(self):
     line_coverage = self.GetLineCoverageWithFakeElements(
         [self.not_executable_tr_html])
     self.assertEqual(line_coverage[0].covered_status,
                      emma_coverage_stats.NOT_EXECUTABLE)
@@ skipping 23 matching lines @@
     self.assertEqual(line_coverage[0].source,
                      '        if (mSelectors.get(index) != null) {')
 
   def testGetLineCoverage_multipleElements(self):
     line_coverage = self.GetLineCoverageWithFakeElements(
         [self.covered_tr_html, self.partially_covered_tr_html,
          self.tr_with_extra_a_tag])
     self.assertEqual(len(line_coverage), 3)
 
   def GetLineCoverageWithFakeElements(self, html_elements):
-    """Wraps GetLineCoverage to work with extra whitespace characters.
-
-    The test HTML strings include extra whitespace characters to make the HTML
-    human readable. This isn't the case with EMMA HTML files, so we need to
-    remove all the unnecessary whitespace.
+    """Wraps GetLineCoverage so mock HTML can easily be used.
 
     Args:
       html_elements: List of strings each representing an HTML element.
 
     Returns:
       A list of LineCoverage objects.
     """
     elements = [ElementTree.fromstring(string) for string in html_elements]
     with mock.patch('emma_coverage_stats._EmmaHtmlParser._FindElements',
                     return_value=elements):
@@ skipping 87 matching lines @@
     }
     with mock.patch('os.path.exists', return_value=True):
       coverage_stats = self.simple_coverage
       coverage_stats._emma_parser.GetPackageNameToEmmaFileDict = mock.MagicMock(
           return_value=package_to_emma)
       coverage_stats.GetPackageNameFromFile = lambda x: package_names[x]
       result_dict = coverage_stats._GetSourceFileToEmmaFileDict(
           package_names.keys())
     self.assertDictEqual(result_dict, self.good_source_to_emma)
 
-  def testGetLineCoverageForFile_basic(self):
-    java_file_path = '/path/to/1/File1.java'
-    line_coverage = emma_coverage_stats.LineCoverage(
-        1, '', emma_coverage_stats.COVERED, 1.0)
-    expected_line_coverage = list(line_coverage)
-    coverage_stats = self.simple_coverage
-    coverage_stats._source_to_emma = self.good_source_to_emma
-    coverage_stats._emma_parser.GetLineCoverage = mock.MagicMock(
-        return_value=expected_line_coverage)
-    coverage_info = coverage_stats._GetLineCoverageForFile(java_file_path)
-    self.assertListEqual(coverage_info, expected_line_coverage)
-
-  def testGetLineCoverageForFile_noInfo(self):
-    with mock.patch('os.path.exists', return_value=False):
-      coverage_info = self.simple_coverage._GetLineCoverageForFile('fake_path')
-    self.assertIsNone(coverage_info)
-
   def testGetCoverageDictForFile(self):
     line_coverage = self.line_coverage
-    self.simple_coverage._GetLineCoverageForFile = mock.Mock(
-        return_value=line_coverage)
+    self.simple_coverage._emma_parser.GetLineCoverage = lambda x: line_coverage
+    self.simple_coverage._source_to_emma = {'/fake/src': 'fake/emma'}
     lines = self.lines_for_coverage
     expected_dict = {
       'absolute': {
         'covered': 3.05,
         'total': 5
       },
       'incremental': {
         'covered': 2.05,
         'total': 3
       },
@@ skipping 24 matching lines @@
           'changed': True
         },
         {
           'line': line_coverage[5].source,
           'coverage': line_coverage[5].covered_status,
           'changed': True
         }
       ]
     }
     result_dict = self.simple_coverage.GetCoverageDictForFile(
-        line_coverage, lines)
+        '/fake/src', lines)
     self.assertDictEqual(result_dict, expected_dict)
 
   def testGetCoverageDictForFile_emptyCoverage(self):
     expected_dict = {
-    'absolute': {'covered': 0, 'total': 0},
-    'incremental': {'covered': 0, 'total': 0},
-    'source': []
+      'absolute': {'covered': 0, 'total': 0},
+      'incremental': {'covered': 0, 'total': 0},
+      'source': []
     }
-    self.simple_coverage._GetLineCoverageForFile = mock.Mock(return_value=[])
+    self.simple_coverage._emma_parser.GetLineCoverage = lambda x: []
+    self.simple_coverage._source_to_emma = {'fake_dir': 'fake/emma'}
     result_dict = self.simple_coverage.GetCoverageDictForFile('fake_dir', {})
     self.assertDictEqual(result_dict, expected_dict)
 
-  def testGetCoverageDictFor_basic(self):
+  def testGetCoverageDictForFile_missingCoverage(self):
+    self.simple_coverage._source_to_emma = {}
+    result_dict = self.simple_coverage.GetCoverageDictForFile('fake_file', {})
+    self.assertIsNone(result_dict)
+
+  def testGetCoverageDict_basic(self):
     files_for_coverage = {
       '/path/to/1/File1.java': [1, 3, 4],
       '/path/2/File2.java': [1, 2]
     }
+    self.simple_coverage._source_to_emma = {
+      '/path/to/1/File1.java': 'emma_1',
+      '/path/2/File2.java': 'emma_2'
+    }
     coverage_info = {
-      '/path/to/1/File1.java': [
+      'emma_1': [
         emma_coverage_stats.LineCoverage(
             1, '', emma_coverage_stats.COVERED, 1.0),
         emma_coverage_stats.LineCoverage(
             2, '', emma_coverage_stats.PARTIALLY_COVERED, 0.5),
         emma_coverage_stats.LineCoverage(
             3, '', emma_coverage_stats.NOT_EXECUTABLE, 1.0),
         emma_coverage_stats.LineCoverage(
             4, '', emma_coverage_stats.COVERED, 1.0)
       ],
-      '/path/2/File2.java': [
+      'emma_2': [
         emma_coverage_stats.LineCoverage(
             1, '', emma_coverage_stats.NOT_COVERED, 1.0),
         emma_coverage_stats.LineCoverage(
             2, '', emma_coverage_stats.COVERED, 1.0)
       ]
     }
     expected_dict = {
       'files': {
         '/path/2/File2.java': {
           'absolute': {'covered': 1, 'total': 2},
           'incremental': {'covered': 1, 'total': 2},
           'source': [{'changed': True, 'coverage': 0, 'line': ''},
                      {'changed': True, 'coverage': 1, 'line': ''}]
         },
         '/path/to/1/File1.java': {
           'absolute': {'covered': 2.5, 'total': 3},
           'incremental': {'covered': 2, 'total': 2},
           'source': [{'changed': True, 'coverage': 1, 'line': ''},
                      {'changed': False, 'coverage': 2, 'line': ''},
                      {'changed': True, 'coverage': -1, 'line': ''},
                      {'changed': True, 'coverage': 1, 'line': ''}]
         }
       },
       'patch': {'incremental': {'covered': 3, 'total': 4}}
     }
     # Return the relevant coverage info for each file. We aren't testing
     # _GetCoverageStatusForFile here.
-    self.simple_coverage._GetLineCoverageForFile = lambda x: coverage_info[x]
-    result_dict = self.simple_coverage.GetCoverageDict(
-        files_for_coverage)
+    self.simple_coverage._emma_parser.GetLineCoverage = (
+        lambda x: coverage_info[x])
+    result_dict = self.simple_coverage.GetCoverageDict(files_for_coverage)
     self.assertDictEqual(result_dict, expected_dict)
 
   def testGetCoverageDict_noCoverage(self):
     result_dict = self.simple_coverage.GetCoverageDict({})
     self.assertDictEqual(result_dict, EMPTY_COVERAGE_STATS_DICT)
 
 
 class EmmaCoverageStatsGenerateCoverageReport(unittest.TestCase):
   """Tests for GenerateCoverageReport."""
 
@@ skipping 30 matching lines @@
   mock_open = mock.mock_open()
   mock_open.side_effect = [mock.mock_open(read_data=side_effect).return_value
                            for side_effect in side_effects]
   with mock.patch('__builtin__.open', mock_open):
     return func(**kwargs), mock_open
 
 
 if __name__ == '__main__':
   # Suppress logging messages.
   unittest.main(buffer=True)