Move outcome handling to backend

Author: BeyondEvil

src/pytest_html/nextgen.py

@@ -36,6 +36,7 @@ def __init__(self, title, duration_format):
  self._data = {
  "title": title,
  "collectedItems": 0,
+ "runningState": "not_started",
  "durationFormat": duration_format,
  "environment": {},
  "tests": [],
@@ -165,20 +166,23 @@ def pytest_sessionstart(self, session):
  if hasattr(config, "_metadata") and config._metadata:
  self._report.data["environment"] = self._generate_environment()
 
- self._generate_report()
  session.config.hook.pytest_html_report_title(report=self._report)
 
  header_cells = self.Cells()
  session.config.hook.pytest_html_results_table_header(cells=header_cells)
  self._report.set_data("resultsTableHeader", header_cells.html)
 
+ self._report.data["runningState"] = "Started"
+ self._generate_report()
+
  @pytest.hookimpl(trylast=True)
  def pytest_sessionfinish(self, session):
  session.config.hook.pytest_html_results_summary(
  prefix=self._report.data["additionalSummary"]["prefix"],
  summary=self._report.data["additionalSummary"]["summary"],
  postfix=self._report.data["additionalSummary"]["postfix"],
  )
+ self._report.data["runningState"] = "Finished"
  self._generate_report()
 
  @pytest.hookimpl(trylast=True)
@@ -193,6 +197,8 @@ def pytest_runtest_logreport(self, report):
 
  test_id = report.nodeid.encode("utf-8").decode("unicode_escape")
 
+ data["outcome"] = _process_outcome(report)
+
  row_cells = self.Cells()
  self._config.hook.pytest_html_results_table_row(report=report, cells=row_cells)
  data.update({"resultsTableRow": row_cells.html})
@@ -287,3 +293,15 @@ def _media_content(self, content, mime_type, *args, **kwargs):
 
  def _generate_report(self, *args, **kwargs):
  super()._generate_report(self_contained=True)
+
+
+def _process_outcome(report):
+ if report.when in ["setup", "teardown"] and report.outcome == "failed":
+ return "Error"
+ if hasattr(report, "wasxfail"):
+ if report.outcome in ["passed", "failed"]:
+ return "XPassed"
+ if report.outcome == "skipped":
+ return "XFailed"
+
+ return report.outcome.capitalize()

src/pytest_html/scripts/datamanager.js

@@ -30,6 +30,9 @@ class DataManager {
  get durationFormat() {
  return this.renderData.durationFormat
  }
+ get runningState() {
+ return this.renderData.runningState
+ }
 }
 
 module.exports = {

src/pytest_html/scripts/dom.js

@@ -64,14 +64,14 @@ const dom = {
  return header
  },
  getListHeaderEmpty: () => listHeaderEmpty.content.cloneNode(true),
- getResultTBody: ({ nodeid, longrepr, duration, extras, resultsTableRow, tableHtml }, outcome) => {
+ getResultTBody: ({ nodeid, longrepr, duration, extras, resultsTableRow, tableHtml, outcome}) => {
  const outcomeLower = outcome.toLowerCase()
  const resultBody = templateResult.content.cloneNode(true)
  resultBody.querySelector('tbody').classList.add(outcomeLower)
  resultBody.querySelector('.col-result').innerText = outcome
  resultBody.querySelector('.col-name').innerText = nodeid
  resultBody.querySelector('.col-duration').innerText = `${formatDuration(duration)}s`
- if (['failed', 'error', 'skipped', 'xfailed', 'xpassed'].includes(outcomeLower)) {
+ if (['failed', 'error', 'xfailed', 'xpassed'].includes(outcomeLower)) {
  resultBody.querySelector('.log').innerText = longrepr ?
  longrepr.reprtraceback.reprentries[0].data.lines.join('\n') : ''
  } else {

src/pytest_html/scripts/main.js

@@ -11,21 +11,6 @@ const removeChildren = (node) => {
  }
 }
 
-const getOutcome = ({ nodeid, wasxfail }, tests) => {
- const relatedOutcome = tests
- .filter((test) => test.nodeid === nodeid)
- .map(({ outcome }) => outcome)
- if (relatedOutcome.includes('failed')) {
- return typeof wasxfail === 'undefined' ? 'Failed' : 'XPassed'
- } else if (relatedOutcome.includes('error')) {
- return 'Error'
- } else if (relatedOutcome.includes('skipped')) {
- return typeof wasxfail === 'undefined' ? 'Skipped' : 'XFailed'
- } else {
- return typeof wasxfail === 'undefined' ? 'Passed' : 'XPassed'
- }
-}
-
 const renderStatic = () => {
  const title = manager.title
  const environment = manager.environment
@@ -41,10 +26,10 @@ const renderStatic = () => {
 }
 
 const renderContent = (tests) => {
- const renderSet = tests.filter(({ when }) => when === 'call')
+ const renderSet = tests.filter(({ when, outcome }) => when === 'call' || outcome === "Error" )
 
  const rows = renderSet.map((test) =>
-  dom.getResultTBody(test, getOutcome(test, tests))
+ dom.getResultTBody(test)
  )
 
  const table = document.querySelector('#results-table')
@@ -63,8 +48,8 @@ const renderContent = (tests) => {
  })
 }
 
-const renderDerived = (tests, collectedItems) => {
- const renderSet = tests.filter(({ when }) => when === 'call')
+const renderDerived = (tests, collectedItems, runningState) => {
+ const renderSet = tests.filter(({ when, outcome }) => when === 'call' || outcome === 'Error')
 
  const possibleOutcomes = [
  { outcome: 'passed', label: 'Passed' },
@@ -78,31 +63,26 @@ const renderDerived = (tests, collectedItems) => {
 
  const currentFilter = getFilter()
  possibleOutcomes.forEach(({ outcome, label }) => {
- const count = renderSet.filter((test) => {
- const wasXpassed = outcome === 'xpassed' && ['passed', 'failed'].includes(test.outcome)
- const wasXfailed = outcome === 'xfailed' && test.outcome === 'skipped'
- if (typeof test.wasxfail !== 'undefined') {
- return wasXpassed || wasXfailed
- } else {
- return test.outcome === outcome
- }
- }).length
+ const count = renderSet.filter((test) => test.outcome.toLowerCase() === outcome).length
  const input = document.querySelector(`input[data-test-result="${outcome}"]`)
  document.querySelector(`.${outcome}`).innerText = `${count} ${label}`
 
  input.disabled = !count
  input.checked = !currentFilter.includes(outcome)
  })
 
- if (collectedItems === renderSet.length) {
+ const numberOfTests = renderSet.filter(({outcome}) =>
+ ["Passed", "Failed", "XPassed", "XFailed"].includes(outcome)
+ ).length
+ if (runningState === "Finished") {
  const accTime = tests.reduce((prev, { duration }) => prev + duration, 0)
  const formattedAccTime = formatDuration(accTime)
- const testWord = renderSet.length > 1 ? 'tests' : 'test'
- const innerText = `${renderSet.length} ${testWord} ran in ${formattedAccTime} seconds.`
+ const testWord = numberOfTests > 1 ? 'tests' : 'test'
+ const innerText = `${numberOfTests} ${testWord} ran in ${formattedAccTime} seconds.`
  document.querySelector('.run-count').innerText = innerText
  document.querySelector('.summary__reload__button').classList.add('hidden')
  } else {
- document.querySelector('.run-count').innerText = `${renderSet.length} / ${collectedItems} tests done`
+ document.querySelector('.run-count').innerText = `${numberOfTests} / ${collectedItems} tests done`
  }
 }
 
@@ -131,10 +111,11 @@ const renderPage = () => {
  const filteredTests = manager.testSubset
  const allTests = manager.allTests
  const collectedItems = manager.collectedItems
+ const runningState = manager.runningState
 
  renderStatic()
  renderContent(filteredTests)
- renderDerived(allTests, collectedItems)
+ renderDerived(allTests, collectedItems, runningState)
 }
 
 const redraw = () => {