1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
|
# Copyright 2020 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Helper methods for unittests."""
from typing import Generator, Iterable, List, Optional, Set, Tuple, Type
# vpython-provided modules.
import pandas # pylint: disable=import-error
# //testing imports.
from unexpected_passes_common import builders
from unexpected_passes_common import expectations
from unexpected_passes_common import data_types
from unexpected_passes_common import queries as queries_module
def CreateStatsWithPassFails(passes: int, fails: int) -> data_types.BuildStats:
stats = data_types.BuildStats()
for _ in range(passes):
stats.AddPassedBuild(frozenset())
for i in range(fails):
stats.AddFailedBuild('build_id%d' % i, frozenset())
return stats
# id_ is used instead of id since id is a python built-in.
def FakeQueryResult(builder_name: str, id_: str, test_id: str, status: str,
typ_tags: Iterable[str], step_name: str) -> pandas.Series:
return pandas.Series(
data={
'builder_name': builder_name,
'id': id_,
'test_id': test_id,
'status': status,
'typ_tags': list(typ_tags),
'step_name': step_name,
})
class SimpleBigQueryQuerier(queries_module.BigQueryQuerier):
def __init__(self, *args, **kwargs):
super().__init__(*args, **kwargs)
self.query_results = []
def _GetSeriesForQuery(self, _) -> Generator[pandas.Series, None, None]:
for r in self.query_results:
yield r
def _GetRelevantExpectationFilesForQueryResult(self, _) -> None:
return None
def _StripPrefixFromTestId(self, test_id: str) -> str:
return test_id.split('.')[-1]
def _GetPublicCiQuery(self) -> str:
return 'public_ci'
def _GetInternalCiQuery(self) -> str:
return 'internal_ci'
def _GetPublicTryQuery(self) -> str:
return 'public_try'
def _GetInternalTryQuery(self) -> str:
return 'internal_try'
def CreateGenericQuerier(
suite: Optional[str] = None,
project: Optional[str] = None,
num_samples: Optional[int] = None,
keep_unmatched_results: bool = False,
cls: Optional[Type[queries_module.BigQueryQuerier]] = None
) -> queries_module.BigQueryQuerier:
suite = suite or 'pixel'
project = project or 'project'
num_samples = num_samples or 5
cls = cls or SimpleBigQueryQuerier
return cls(suite, project, num_samples, keep_unmatched_results)
def GetArgsForMockCall(call_args_list: List[tuple],
call_number: int) -> Tuple[tuple, dict]:
"""Helper to more sanely get call args from a mocked method.
Args:
call_args_list: The call_args_list member from the mock in question.
call_number: The call number to pull args from, starting at 0 for the first
call to the method.
Returns:
A tuple (args, kwargs). |args| is a list of arguments passed to the method.
|kwargs| is a dict containing the keyword arguments padded to the method.
"""
args = call_args_list[call_number][0]
kwargs = call_args_list[call_number][1]
return args, kwargs
class GenericBuilders(builders.Builders):
#pylint: disable=useless-super-delegation
def __init__(self,
suite: Optional[str] = None,
include_internal_builders: bool = False):
super().__init__(suite, include_internal_builders)
#pylint: enable=useless-super-delegation
def _BuilderRunsTestOfInterest(self, _test_map) -> bool:
return True
def GetIsolateNames(self) -> Set[str]:
return set()
def GetFakeCiBuilders(self) -> dict:
return {}
def GetNonChromiumBuilders(self) -> Set[data_types.BuilderEntry]:
return set()
def RegisterGenericBuildersImplementation() -> None:
builders.RegisterInstance(GenericBuilders())
class GenericExpectations(expectations.Expectations):
def GetExpectationFilepaths(self) -> list:
return []
def _GetExpectationFileTagHeader(self, _) -> str:
return """\
# tags: [ linux mac win ]
# tags: [ amd intel nvidia ]
# results: [ Failure RetryOnFailure Skip Pass ]
"""
def _GetKnownTags(self) -> Set[str]:
return set(['linux', 'mac', 'win', 'amd', 'intel', 'nvidia'])
def CreateGenericExpectations() -> GenericExpectations:
return GenericExpectations()
def RegisterGenericExpectationsImplementation() -> None:
expectations.RegisterInstance(CreateGenericExpectations())
|
