Fix bad copypasta.
[open-adventure.git] / tests / coverage_dungeon.py
1 #!/usr/bin/env python3
2
3 # This is the open-adventure dungeon text coverage report generator. It
4 # consumes a YAML description of the dungeon and determines whether the
5 # various strings contained are present within the test check files.
6 #
7 # The default HTML output is appropriate for use with Gitlab CI.
8 # You can override it with a command-line argument.
9 #
10 # The DANGLING list is for actions that should be considered always found
11 # even if the checkfile search doesn't find them. Typically this will because
12 # they emit a templated message that can't be regression-tested by equality.
13
14 import os
15 import sys
16 import yaml
17 import re
18
19 TEST_DIR = "."
20 YAML_PATH = "../adventure.yaml"
21 HTML_TEMPLATE_PATH = "../templates/coverage_dungeon.html.tpl"
22 DEFAULT_HTML_OUTPUT_PATH = "../coverage/adventure.yaml.html"
23 DANGLING = ["ACT_VERSION"]
24
25 STDOUT_REPORT_CATEGORY = "  {name:.<19}: {percent:5.1f}% covered ({covered} of {total})\n"
26
27 HTML_SUMMARY_ROW = '''
28     <tr>
29         <td class="headerItem"><a href="#{name}">{name}:</a></td>
30         <td class="headerCovTableEntry">{total}</td>
31         <td class="headerCovTableEntry">{covered}</td>
32         <td class="headerCovTableEntry">{percent:.1f}%</td>
33     </tr>
34 '''
35
36 HTML_CATEGORY_SECTION = '''
37     <tr id="{id}"></tr>
38     {rows}
39     <tr>
40         <td>&nbsp;</td>
41     </tr>
42 '''
43
44 HTML_CATEGORY_HEADER = '''
45     <tr>
46         <td class="tableHead" width="60%" colspan="{colspan}">{label}</td>
47         {cells}
48     </tr>
49 '''
50
51 HTML_CATEGORY_HEADER_CELL = '<td class="tableHead" width="15%">{}</td>\n'
52
53 HTML_CATEGORY_COVERAGE_CELL = '<td class="{}">&nbsp;</td>\n'
54
55 HTML_CATEGORY_ROW = '''
56     <tr>
57         <td class="coverFile" colspan="{colspan}">{id}</td>
58         {cells}
59     </tr>
60 '''
61
62 def search(needle, haystack):
63     # Search for needle in haystack, first escaping needle for regex, then
64     # replacing %s, %d, etc. with regex wildcards, so the variable messages
65     # within the dungeon definition will actually match
66         
67     if needle == None or needle == "" or needle == "NO_MESSAGE":
68         # if needle is empty, assume we're going to find an empty string
69         return True
70     
71     needle_san = re.escape(needle) \
72              .replace("\\n", "\n") \
73              .replace("\\t", "\t") \
74              .replace("\%S", ".*") \
75              .replace("\%s", ".*") \
76              .replace("\%d", ".*") \
77              .replace("\%V", ".*")
78
79     return re.search(needle_san, haystack)
80
81 def obj_coverage(objects, text, report):
82     # objects have multiple descriptions based on state
83     for i, objouter in enumerate(objects):
84         (obj_name, obj) = objouter
85         if obj["descriptions"]:
86             for j, desc in enumerate(obj["descriptions"]):
87                 name = "{}[{}]".format(obj_name, j)
88                 if name not in report["messages"]:
89                     report["messages"][name] = {"covered" : False}
90                     report["total"] += 1
91                 if report["messages"][name]["covered"] != True and search(desc, text):
92                     report["messages"][name]["covered"] = True
93                     report["covered"] += 1
94
95 def loc_coverage(locations, text, report):
96     # locations have a long and a short description, that each have to
97     # be checked seperately
98     for name, loc in locations:
99         desc = loc["description"]
100         if name not in report["messages"]:
101             report["messages"][name] = {"long" : False, "short": False}
102             report["total"] += 2
103         if report["messages"][name]["long"] != True and search(desc["long"], text):
104             report["messages"][name]["long"] = True
105             report["covered"] += 1
106         if report["messages"][name]["short"] != True and search(desc["short"], text):
107             report["messages"][name]["short"] = True
108             report["covered"] += 1
109
110 def hint_coverage(obituaries, text, report):
111     # hints have a "question" where the hint is offered, followed
112     # by the actual hint if the player requests it
113     for i, hintouter in enumerate(obituaries):
114         hint = hintouter["hint"]
115         name = hint["name"]
116         if name not in report["messages"]:
117             report["messages"][name] = {"question" : False, "hint": False}
118             report["total"] += 2
119         if report["messages"][name]["question"] != True and search(hint["question"], text):
120             report["messages"][name]["question"] = True
121             report["covered"] += 1
122         if report["messages"][name]["hint"] != True and search(hint["hint"], text):
123             report["messages"][name]["hint"] = True
124             report["covered"] += 1
125
126 def obit_coverage(obituaries, text, report):
127     # obituaries have a "query" where it asks the player for a resurrection,
128     # followed by a snarky comment if the player says yes
129     for name, obit in enumerate(obituaries):
130         if name not in report["messages"]:
131             report["messages"][name] = {"query" : False, "yes_response": False}
132             report["total"] += 2
133         if report["messages"][name]["query"] != True and search(obit["query"], text):
134             report["messages"][name]["query"] = True
135             report["covered"] += 1
136         if report["messages"][name]["yes_response"] != True and search(obit["yes_response"], text):
137             report["messages"][name]["yes_response"] = True
138             report["covered"] += 1
139
140 def threshold_coverage(classes, text, report):
141     # works for class thresholds and turn threshold, which have a "message"
142     # property
143     for name, item in enumerate(classes):
144         if name not in report["messages"]:
145             report["messages"][name] = {"covered" : "False"}
146             report["total"] += 1
147         if report["messages"][name]["covered"] != True and search(item["message"], text):
148             report["messages"][name]["covered"] = True
149             report["covered"] += 1
150
151 def arb_coverage(arb_msgs, text, report):
152     for name, message in arb_msgs:
153         if name not in report["messages"]:
154             report["messages"][name] = {"covered" : False}
155             report["total"] += 1
156         if report["messages"][name]["covered"] != True and search(message, text):
157             report["messages"][name]["covered"] = True
158             report["covered"] += 1
159
160 def actions_coverage(items, text, report):
161     # works for actions
162     for name, item in items:
163         if name not in report["messages"]:
164             report["messages"][name] = {"covered" : False}
165             report["total"] += 1
166         if report["messages"][name]["covered"] != True and (search(item["message"], text) or name in DANGLING):
167             report["messages"][name]["covered"] = True
168             report["covered"] += 1
169
170 def coverage_report(db, check_file_contents):
171     # Create report for each catagory, including total items,  number of items
172     # covered, and a list of the covered messages
173     report = {}
174     for name in db.keys():
175         # initialize each catagory
176         report[name] = {
177             "name" : name, # convenience for string formatting
178             "total" : 0,
179             "covered" : 0,
180             "messages" : {}
181         }
182
183     # search for each message in every test check file
184     for chk in check_file_contents:
185         arb_coverage(db["arbitrary_messages"], chk, report["arbitrary_messages"])
186         hint_coverage(db["hints"], chk, report["hints"])
187         loc_coverage(db["locations"], chk, report["locations"])
188         obit_coverage(db["obituaries"], chk, report["obituaries"])
189         obj_coverage(db["objects"], chk, report["objects"])
190         actions_coverage(db["actions"], chk, report["actions"])
191         threshold_coverage(db["classes"], chk, report["classes"])
192         threshold_coverage(db["turn_thresholds"], chk, report["turn_thresholds"])
193
194     return report
195
196 if __name__ == "__main__":
197     # load DB
198     try:
199         with open(YAML_PATH, "r") as f:
200             db = yaml.load(f)
201     except IOError as e:
202         print('ERROR: could not load {} ({}})'.format(YAML_PATH, e.strerror))
203         exit(-1)
204
205     # get contents of all the check files
206     check_file_contents = []
207     for filename in os.listdir(TEST_DIR):
208         if filename.endswith(".chk"):
209             with open(filename, "r") as f:
210                 check_file_contents.append(f.read())
211
212     # run coverage analysis report on dungeon database
213     report = coverage_report(db, check_file_contents)
214
215     # render report output
216     categories_html = ""
217     summary_html = ""
218     summary_stdout = "adventure.yaml coverage rate:\n"
219     for name, category in sorted(report.items()):
220         # ignore categories with zero entries
221         if category["total"] > 0:
222             # Calculate percent coverage
223             category["percent"] = (category["covered"] / float(category["total"])) * 100
224
225             # render section header
226             cat_messages = list(category["messages"].items())
227             cat_keys = cat_messages[0][1].keys()
228             headers_html = ""
229             colspan = 10 - len(cat_keys)
230             for key in cat_keys:
231                 headers_html += HTML_CATEGORY_HEADER_CELL.format(key)
232             category_html = HTML_CATEGORY_HEADER.format(colspan=colspan, label=category["name"], cells=headers_html)
233
234             # render message coverage row
235             for message_id, covered in cat_messages:
236                 category_html_row = ""
237                 for key, value in covered.items():
238                     category_html_row += HTML_CATEGORY_COVERAGE_CELL.format("uncovered" if value != True else "covered")
239                 category_html += HTML_CATEGORY_ROW.format(id=message_id,colspan=colspan, cells=category_html_row)
240             categories_html += HTML_CATEGORY_SECTION.format(id=name, rows=category_html)
241
242             # render category summaries
243             summary_stdout += STDOUT_REPORT_CATEGORY.format(**category)
244             summary_html += HTML_SUMMARY_ROW.format(**category)
245
246     # output some quick report stats
247     print(summary_stdout)
248
249     if len(sys.argv) > 1:
250         html_output_path = sys.argv[1]
251     else:
252         html_output_path = DEFAULT_HTML_OUTPUT_PATH
253
254     # render HTML report
255     try:
256         with open(HTML_TEMPLATE_PATH, "r") as f:
257             # read in HTML template
258             html_template = f.read()
259     except IOError as e:
260         print('ERROR: reading HTML report template failed ({})'.format(e.strerror))
261         exit(-1)
262
263     # parse template with report and write it out
264     try:
265         with open(html_output_path, "w") as f:
266             f.write(html_template.format(categories=categories_html, summary=summary_html))
267     except IOError as e:
268         print('ERROR: writing HTML report failed ({})'.format(e.strerror))