github.com/sercand/please@v13.4.0+incompatible/src/test/coverage_test.go (about)

     1  package test
     2  
     3  import (
     4  	"testing"
     5  
     6  	"github.com/stretchr/testify/assert"
     7  	"golang.org/x/tools/cover"
     8  
     9  	"github.com/thought-machine/please/src/core"
    10  )
    11  
    12  var target = &core.BuildTarget{Label: core.BuildLabel{PackageName: "src/test", Name: "coverage_test"}}
    13  
    14  const (
    15  	pythonCoverageFile    = "src/test/test_data/python-coverage.xml"
    16  	goCoverageFile        = "src/test/test_data/go_coverage.txt"
    17  	goCoverageFile2       = "src/test/test_data/go_coverage_2.txt"
    18  	goCoverageFile3       = "src/test/test_data/go_coverage_3.txt"
    19  	gcovCoverageFile      = "src/test/test_data/gcov_coverage.gcov"
    20  	istanbulCoverageFile  = "src/test/test_data/istanbul_coverage.json"
    21  	istanbulCoverageFile2 = "src/test/test_data/istanbul_coverage_2.json"
    22  )
    23  
    24  // Test that tests aren't required to produce coverage, ie. it's not an error if the file doesn't exist.
    25  func TestCoverageNotRequired(t *testing.T) {
    26  	coverage, err := parseTestCoverage(target, "src/test/test_data/blah.xml")
    27  	if err != nil {
    28  		t.Errorf("Incorrectly produced error attempting to read missing coverage file: %s", err)
    29  	}
    30  	if len(coverage.Files) != 0 {
    31  		t.Errorf("Incorrectly reported some coverage results when there should be none.")
    32  	}
    33  }
    34  
    35  // Test that the target is recorded in the file list.
    36  func TestTargetIsRecorded(t *testing.T) {
    37  	coverage, err := parseTestCoverage(target, pythonCoverageFile)
    38  	if err != nil {
    39  		t.Errorf("Failed to read coverage file %s", pythonCoverageFile)
    40  	}
    41  	if len(coverage.Tests) != 1 {
    42  		t.Errorf("Expected exactly one test label recorded (got %d)", len(coverage.Tests))
    43  	}
    44  }
    45  
    46  // Test the sample Python test output file.
    47  func TestPythonResults(t *testing.T) {
    48  	coverage, err := parseTestCoverage(target, pythonCoverageFile)
    49  	if err != nil {
    50  		t.Errorf("Failed to read coverage file %s", pythonCoverageFile)
    51  	}
    52  	if len(coverage.Files) != 4 {
    53  		t.Errorf("Expected exactly four files covered by this test")
    54  	}
    55  	lines, present := coverage.Files["src/build/python/pex_test.py"]
    56  	if !present {
    57  		t.Errorf("Coverage info for src/build/python/pex_test.py not recorded.")
    58  	}
    59  	if len(lines) != 24 {
    60  		t.Errorf("Expected exactly 24 lines of coverage information, was %d.", len(lines))
    61  	}
    62  	outputStr := core.TestCoverageString(lines)
    63  	expected := "NNCNNCNCNCNCNNUNCNNCNNCU"
    64  	if outputStr != expected {
    65  		t.Errorf("Incorrect coverage output; was %s, expected %s", outputStr, expected)
    66  	}
    67  }
    68  
    69  // Test the sample Go test output file.
    70  func TestGoResults(t *testing.T) {
    71  	coverage, err := parseTestCoverage(target, goCoverageFile)
    72  	if err != nil {
    73  		t.Errorf("Failed to read coverage file %s", goCoverageFile)
    74  	}
    75  	if len(coverage.Files) != 7 {
    76  		t.Errorf("Expected exactly seven files covered by this test")
    77  	}
    78  	lines, present := coverage.Files["src/core/file_label.go"]
    79  	if !present {
    80  		t.Errorf("Coverage info for src/core/file_label.go not recorded.")
    81  	}
    82  	if len(lines) != 55 {
    83  		t.Errorf("Expected exactly 55 lines of coverage information, was %d.", len(lines))
    84  	}
    85  	outputStr := core.TestCoverageString(lines)
    86  	expected := "NNNNNNNNNNNNNNNUUUNUUUNUUUNUUUNNNNNNNNNNUUUNUUUNUUUNUUU"
    87  	if len(expected) != 55 {
    88  		t.Errorf("oops, expected string is wrong")
    89  	}
    90  	if outputStr != expected {
    91  		t.Errorf("Incorrect coverage output; was %s, expected %s", outputStr, expected)
    92  	}
    93  }
    94  
    95  // Test another sample Go file which has been observed to be wrong.
    96  func TestGoResults2(t *testing.T) {
    97  	coverage, err := parseTestCoverage(target, goCoverageFile2)
    98  	if err != nil {
    99  		t.Errorf("Failed to read coverage file %s", goCoverageFile2)
   100  	}
   101  	if len(coverage.Files) != 1 {
   102  		t.Errorf("Expected exactly one file covered by this test")
   103  	}
   104  	lines, present := coverage.Files["src/core/state.go"]
   105  	if !present {
   106  		t.Errorf("Coverage info for src/core/file_label.go not recorded.")
   107  	}
   108  	if len(lines) != 273 {
   109  		t.Errorf("Expected exactly 273 lines of coverage information, was %d.", len(lines))
   110  	}
   111  
   112  	assertLine(t, lines, 231, core.NotExecutable)
   113  	assertLine(t, lines, 232, core.Covered)
   114  	assertLine(t, lines, 233, core.Covered)
   115  	assertLine(t, lines, 234, core.Covered)
   116  	assertLine(t, lines, 235, core.Covered)
   117  	assertLine(t, lines, 236, core.Covered)
   118  	assertLine(t, lines, 237, core.Covered)
   119  	assertLine(t, lines, 238, core.Covered)
   120  	assertLine(t, lines, 239, core.Covered)
   121  	assertLine(t, lines, 240, core.Covered)
   122  }
   123  
   124  func TestGoResults3(t *testing.T) {
   125  	coverage, err := parseTestCoverage(target, goCoverageFile3)
   126  	if err != nil {
   127  		t.Errorf("Failed to read coverage file %s", goCoverageFile3)
   128  	}
   129  	if len(coverage.Files) != 1 {
   130  		t.Errorf("Expected exactly one file covered by this test")
   131  	}
   132  	lines, present := coverage.Files["src/misc/plz_diff_graphs.go"]
   133  	if !present {
   134  		t.Errorf("Coverage info for src/misc/plz_diff_graphs.go not recorded.")
   135  	}
   136  	if len(lines) != 127 {
   137  		t.Errorf("Expected exactly 127 lines of coverage information, was %d.", len(lines))
   138  	}
   139  
   140  	assertLine(t, lines, 67, core.NotExecutable)
   141  	assertLine(t, lines, 68, core.Covered)
   142  	assertLine(t, lines, 69, core.Covered)
   143  	assertLine(t, lines, 81, core.NotExecutable)
   144  }
   145  
   146  // Direct test on the block-parsing function.
   147  func TestParseBlocks(t *testing.T) {
   148  	lines := parseBlocks([]cover.ProfileBlock{
   149  		{StartLine: 2, EndLine: 3, Count: 1},
   150  	})
   151  	if len(lines) != 3 {
   152  		t.Errorf("Wrong number of lines, should have been %d, was %d", 3, len(lines))
   153  	}
   154  	assertLine(t, lines, 1, core.NotExecutable)
   155  	assertLine(t, lines, 2, core.Covered)
   156  	assertLine(t, lines, 3, core.Covered)
   157  }
   158  
   159  func assertLine(t *testing.T, lines []core.LineCoverage, i int, expected core.LineCoverage) {
   160  	i-- // 1-indexed
   161  	if lines[i] != expected {
   162  		t.Errorf("Line %d incorrect, should be %d, was %d", i, expected, lines[i])
   163  	}
   164  }
   165  
   166  func TestGcovParsing(t *testing.T) {
   167  	target := &core.BuildTarget{Label: core.BuildLabel{PackageName: "test", Name: "gcov_test"}}
   168  	coverage, err := parseTestCoverage(target, gcovCoverageFile)
   169  	assert.NoError(t, err)
   170  	assert.Contains(t, coverage.Files, "test/cc_rules/deps_test.cc")
   171  	lines := coverage.Files["test/cc_rules/deps_test.cc"]
   172  	assertLine(t, lines, 1, core.NotExecutable)
   173  	assertLine(t, lines, 2, core.NotExecutable)
   174  	assertLine(t, lines, 9, core.NotExecutable)
   175  	assertLine(t, lines, 10, core.Covered)
   176  	assertLine(t, lines, 11, core.Covered)
   177  	assertLine(t, lines, 12, core.Covered)
   178  	assertLine(t, lines, 13, core.NotExecutable)
   179  	assertLine(t, lines, 14, core.Covered)
   180  	assertLine(t, lines, 15, core.Covered)
   181  	assertLine(t, lines, 16, core.Covered)
   182  	assertLine(t, lines, 17, core.NotExecutable)
   183  	assertLine(t, lines, 18, core.Covered)
   184  }
   185  
   186  func TestIstanbulCoverage(t *testing.T) {
   187  	target := &core.BuildTarget{Label: core.BuildLabel{PackageName: "common/js/components/ActionButton", Name: "test"}}
   188  	coverage, err := parseTestCoverage(target, istanbulCoverageFile)
   189  	assert.NoError(t, err)
   190  	assert.Contains(t, coverage.Files, "common/js/components/ActionButton/ActionButton.js")
   191  	assert.Contains(t, coverage.Files, "common/js/components/LoadingSpinner/LoadingSpinner.js")
   192  	lines := coverage.Files["common/js/components/LoadingSpinner/LoadingSpinner.js"]
   193  	assertLine(t, lines, 3, core.NotExecutable)
   194  	assertLine(t, lines, 4, core.Covered)
   195  	assertLine(t, lines, 5, core.Covered)
   196  	assertLine(t, lines, 6, core.Covered)
   197  	assertLine(t, lines, 7, core.Covered)
   198  	assertLine(t, lines, 8, core.NotExecutable)
   199  	assertLine(t, lines, 22, core.NotExecutable)
   200  	assertLine(t, lines, 23, core.Uncovered)
   201  	assertLine(t, lines, 24, core.NotExecutable)
   202  }
   203  
   204  func TestIstanbulCoverage2(t *testing.T) {
   205  	target := &core.BuildTarget{Label: core.BuildLabel{PackageName: "common/js/components/Table", Name: "test"}}
   206  	coverage, err := parseTestCoverage(target, istanbulCoverageFile2)
   207  	assert.NoError(t, err)
   208  	assert.Contains(t, coverage.Files, "common/js/components/Table/Table.js")
   209  	lines := coverage.Files["common/js/components/Table/Table.js"]
   210  	// This exercises a slightly more complex example with multiple overlapping statements.
   211  	assertLine(t, lines, 15, core.Covered)
   212  	assertLine(t, lines, 16, core.Covered)
   213  	assertLine(t, lines, 17, core.Covered)
   214  	assertLine(t, lines, 18, core.Covered)
   215  	assertLine(t, lines, 19, core.Covered)
   216  	assertLine(t, lines, 20, core.Covered)
   217  	assertLine(t, lines, 21, core.Covered)
   218  	assertLine(t, lines, 22, core.Covered)
   219  	assertLine(t, lines, 23, core.Covered)
   220  }