pytest-flakefighters 0.2.3__tar.gz → 0.3.0__tar.gz

{pytest_flakefighters-0.2.3 → pytest_flakefighters-0.3.0}/.github/workflows/ci-tests-drafts.yaml

@@ -24,9 +24,7 @@ jobs:
       run: |
           python --version
           python -m pip install --upgrade pip
-          pip install -e .
-          pip install -e .[test]
-          pip install pytest pytest-cov
+          pip install -e .[dev]
     - name: Test with pytest
       run: |
         pytest -p no:flakefighters --cov=src --cov-report=xml

{pytest_flakefighters-0.2.3 → pytest_flakefighters-0.3.0}/.github/workflows/ci-tests.yaml

@@ -29,9 +29,7 @@ jobs:
       run: |
           python --version
           python -m pip install --upgrade pip
-          pip install -e .
-          pip install -e .[test]
-          pip install pytest pytest-cov
+          pip install -e .[dev]
     - name: Test with pytest
       run: |
         pytest -p no:flakefighters --cov=src --cov-report=xml

{pytest_flakefighters-0.2.3/src/pytest_flakefighters.egg-info → pytest_flakefighters-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-flakefighters
-Version: 0.2.3
+Version: 0.3.0
 Summary: Pytest plugin implementing flaky test failure detection and classification.
 Author: TestFLARE Team
 Project-URL: Documentation, https://pytest-flakefighters.readthedocs.io

{pytest_flakefighters-0.2.3 → pytest_flakefighters-0.3.0}/docs/source/_static/css/custom.css

@@ -11,6 +11,10 @@ The CSS below will only work if 'logo_only':True in conf.py, but will require ad
     width:auto;
 }
 
+.wy-side-nav-search > a:hover {
+    background: transparent !important;
+}
+
 .wy-nav-content {
     background-color: white;
 }

pytest_flakefighters-0.3.0/docs/source/ci_cd.rst

@@ -0,0 +1,38 @@
+CI/CD Integration
+=================
+
+The `TestFLARE <https://test-flare.github.io/>`__ project is motivated by the fact that flaky tests can be particularly problematic for CI/CD pipelines.
+The :code:`flakefighers` extension is therefore developed to integrate seamlessly with your existing pipelines and testing workflows.
+If you already have a workflow that uses :code:`pytest`, all you need to do is include :code:`pytest-flakefighers` as a dependency.
+The extension will then automatically be run as part of :code:`pytest`.
+
+.. _remote-databases:
+
+Remote Databases
+----------------
+
+When you run :code:`pytest`, the :code:`flakefighers` extension automatically saves the details of each run, including the classification result from each active flakefighter for each test.
+This historical data can then be used on subsequent runs to inform flaky classification.
+By default, this data is stored locally in an SQlite database called :code:`flakefighters.db`.
+However, this is configurable using the :code:`--database-url` parameter, so you are free to save your data wherever you like.
+
+If you are using the extension as part of your CI/CD pipeline and want to preserve the data between runs, you will need to use external service such as `Supabase <https://supabase.com/>`__ to host your database.
+Fortunately, this is very straightforward as these services make make setup and connection very easy.
+All you need to do is set up the database using your service of choice and pass the database URL into the :code:`--database-url` parameter.
+You don't even need to create the tables yourself, as this will be done by the extension automatically on the first run!
+Of course, for security reasons, we suggest making your URL a `secret <https://docs.github.com/en/actions/reference/security/secrets>`__ rather than including the raw string in your github workflow.
+
+.. tip::
+  If you don't need to preserve the data between CI/CD runs, but do want to inspect it, you can include it as an `artifact <https://docs.github.com/en/actions/concepts/workflows-and-actions/workflow-artifacts>`__.
+
+Hybrid Databases
+----------------
+
+There may be situations where you sometimes want to store data locally and sometimes want to store it remotely.
+For example, you may want your CI/CD runs to go into the remote database hosted externally, but your local runs to use a local database so that you don't clog up the remote database during debugging.
+Depending on your workflow, you may even want to keep a local clone of your database and occasionally synchronise this with the remote database.
+Fortunately, database providers such as Supabase make this a `relatively straightforward process <https://supabase.com/docs/guides/local-development/overview>`__.
+
+.. warning::
+  As with any such setting, synchronisation may result in conflicts or inconsistent behaviour if entries have been made into the remote database after you have cloned your local copy and before you have resynchronised.
+  In particular, the results of flakefighters that examine historical runs can be confusing if historical runs that were performed before a particular :code:`pytest` run were not added until afterwards.

{pytest_flakefighters-0.2.3 → pytest_flakefighters-0.3.0}/docs/source/configuration.rst

@@ -4,15 +4,17 @@ Configuration
 The flakefighters plugin implements several cutting edge flaky test detection tools from the research community.
 Each one is individually configurable and can be run individually or with other flakefighters.
 You can control which flakefighters to run and provide additional configuration options from your :code:`pyproject.toml` file by including sections of the following form for each flakefighter you want to run.
-Here, :code:`<FlakeFighterName>` is the class name of the flakefighter you wish to configure, assuming the class is in the :code:`pytest-flakefighters/flakefighters` directory.
-::
-[tool.pytest.ini_options.pytest_flakefighters.<FlakeFighterName>]
-run_live=[true/false]
-option1=value1
-option2=value2
-...
+Here, :code:`<FlakeFighterClass>` is the class of the flakefighter you wish to configure as if you were going to import it into a source code file.
 
-Every flakefighter will have a :code:`run_live` option, which can be set to :code:`true` to classify each test execution as flaky immediately after it is run, or :code:`false` to clasify all tests at once at the end, although individual flakefighters may only support one particular option.
+..  code-block:: ini
+
+  [tool.pytest.ini_options.pytest_flakefighters.<FlakeFighterClass>]
+  run_live=[true/false]
+  option1=value1
+  option2=value2
+  ...
+
+Every flakefighter has a :code:`run_live` option, which can be set to :code:`true` to classify each test execution as flaky immediately after it is run, or :code:`false` to clasify all tests at once at the end, although individual flakefighters may only support one of these.
 Individual flakefighters have their own configurable options.
 These are detailed below.
 

pytest_flakefighters-0.3.0/docs/source/custom_flakefighters.rst

@@ -0,0 +1,88 @@
+Custom Flakefighters
+====================
+
+In addition to the flakefighters that are distributed with the extension, you can also define your own custom flakefighter classes.
+To do this, you simply need to extensd the :code:`Flakefighter` class and implement the abstract methods.
+For example, see below
+
+..  code-block:: python
+
+  from pytest_flakefighters.flakefighters.abstract_flakefighter import(
+    FlakeFighter,
+    FlakefighterResult
+  )
+  from pytest_flakefighters.database_management import Run, TestExecution
+
+
+  class CustomFlakefighter(FlakeFighter):
+
+      def __init__(self, run_live: bool, custom_arg: str):
+          super().__init__(run_live)
+          self.custom_arg = custom_arg
+
+      @classmethod
+      def from_config(cls, config: dict):
+          """
+          Factory method to create a new instance from a pytest configuration.
+          """
+          return CustomFlakefighter(
+              run_live=config.get("run_live", True),
+              custom_arg=config.get("custom_arg", ""),
+          )
+
+      def params(self):
+          """
+          Convert the key parameters into a dictionary so that the object can be replicated.
+          :return A dictionary of the parameters used to create the object.
+          """
+          return {"custom_arg": self.custom_arg}
+
+      def flaky_test_live(self, execution: TestExecution):
+          """
+          Detect whether a given test execution is flaky and append the result to its
+          `flakefighter_results` attribute.
+          :param execution: The test execution to classify.
+          """
+          execution.flakefighter_results.append(
+              FlakefighterResult(
+                  name=self.__class__.__name__,
+                  # Implement logic to determine this result at *execution level*
+                  flaky=True,
+              )
+          )
+
+      def flaky_tests_post(self, run: Run):
+          """
+          Go through each test in the test suite and append the result to its
+          `flakefighter_results` attribute.
+          :param run: Run object representing the pytest run, with tests
+          accessible through run.tests.
+          """
+          for test in run.tests:
+              test.flakefighter_results.append(
+                  FlakefighterResult(
+                      name=self.__class__.__name__,
+                      # Implement logic to determine this result at *test level*
+                      # In many cases, it will be sufficient to test whether
+                      # any executions are flaky
+                      flaky=True
+                  )
+              )
+
+Once you have implemented your flakefighter class, you will need to register it as an extra entry point in your :code:`pyproject.toml` file so that the plugin can find it.
+For example, if you had defined your :code:`CustomFlakefighter` class in a module called :code:`custom_flakefighter`, you would register it as follows.
+
+..  code-block:: ini
+
+  [project.entry-points."pytest_flakefighters"]
+  CustomFlakefighter = "custom_flakefighter:CustomFlakefighter"
+
+Of course, for this to work, your module needs to be discoverable on your python path.
+That is, you should be able to execute :code:`from custom_flakefighter import CustomFlakefighter` successfully from within the same directory as where you are running :code:`pytest`.
+You can then configure it just like any other flakefighter.
+
+..  code-block:: ini
+
+  [tool.pytest.ini_options.pytest_flakefighters.flakefighters.custom_flakefighter.CustomFlakefighter]
+  run_live=true
+  custom_arg=0.1

{pytest_flakefighters-0.2.3 → pytest_flakefighters-0.3.0}/docs/source/index.rst

@@ -21,10 +21,11 @@ Motivation
 :term:`Flaky tests` intermittently pass and fail without changes to test or project source code, often without an obvious cause.
 When flaky tests proliferate, developers may loose faith in their test suites, potentially exposing end-users to the consequences of software failures.
 
-The Extension
--------------
+Pytest Extension
+----------------
 
-Flakefighters is a pytest extension that provides a "Swiss army knife" of techniques to detect flaky tests.
+Flakefighters is a pytest extension developed as part of the `TestFLARE <https://test-flare.github.io/>`__ project.
+The extension provides a "Swiss army knife" of techniques (called flakefighters) to detect flaky tests.
 The extension incorporates several cutting edge flaky test detection techniques from research to automatically classify test failures as either genuine: indicating either a fault in the code or a mis-specified test case, or flaky: indicating a test with a nondeterministic outcome.
 Flaky tests are then reported separately in the test report, and can be optionally suppressed so they don't block CI/CD pipelines.
 
@@ -40,6 +41,9 @@ Flaky tests are then reported separately in the test report, and can be optional
 
    installation
    configuration
+   custom_flakefighters
+   reports
+   ci_cd
 
 
 .. toctree::

{pytest_flakefighters-0.2.3 → pytest_flakefighters-0.3.0}/docs/source/installation.rst

@@ -5,14 +5,14 @@ Installation
 -----------------
 * We currently support Python versions 3.10, 3.11, 3.12, and 3.13.
 
-* The Flakefighters plugin can be installed through the `Python Package Index (PyPI)`_ (recommended), or directly from source (recommended for contributors).
+* The Flakefighters plugin can be installed through the `Python Package Index (PyPI)`_ (recommended for normal use), or directly from source (recommended for contributors).
 
 .. _Python Package Index (PyPI): https://pypi.org/project/pytest-flakefighters
 
 Method 1: Installing via pip
 ..............................
 
-To install the Causal Testing Framework using :code:`pip` for the latest stable version::
+To install the extension using :code:`pip` for the latest stable version::
 
     pip install pytest-flakefighters
 
@@ -23,6 +23,16 @@ If you also want to install the framework with (optional) development packages/t
     pip install pytest-flakefighters[dev]
 
 
+.. note::
+  If you plan to use the extension using a PostgreSQL database (see :ref:`remote-databases`), then you will need to install PostgreSQL on your system, have :code:`pg_config` on your path, and then install using the :code:`pg` option.
+
+  ..  code-block:: python
+
+    pip install pytest-flakefighters[pg]
+
+  If you wish to use `other dialects <https://docs.sqlalchemy.org/en/20/dialects/>`_, you may need to install additional packages to support this.
+
+
 Method 2: Installing via Source (For Developers/Contributors)
 ...............................................................
 

pytest_flakefighters-0.3.0/docs/source/reports.rst

@@ -0,0 +1,98 @@
+Reporting and Logging
+=====================
+
+The extension supports a range of reporting formats.
+By default, flaky tests will be flagged in the short test summary info in the console output as shown below.
+Genuine failures will show as :code:`FAILED` as normal.
+Failures which have been classified as flaky by at least one active flakefighter will show as :code:`FLAKY`.
+
+..  code-block:: ini
+
+  ================================== short test summary info ==================================
+  FLAKY test_flaky_reruns.py::TestFlakyRuns::test_create_or_delete - assert not True
+  FAILED test_flaky_reruns.py::TestFlakyRuns::test_fail - assert False
+  ================================ 2 failed, 1 passed in 1.13s ================================
+
+Writing to JSON
+---------------
+
+The extension is designed to work with `pytest-json-report <https://pypi.org/project/pytest-json-report>`_ to create test reports as JSON.
+To do this, you will need to :code:`pip install pytest-json-report`, after which you can run :code:`pytest` with the :code:`--json-report` option to save the test report to :code:`.report.json` by default.
+The target path to save JSON report can be changed using the :code:`--json-report-file=PATH` option.
+Each test :code:`call` will be assigned a :code:`metadata` field that records the execution-level flakefighter results for each (repeated) execution.
+Each test will be assigned a :code:`metadata` field to record the test-level results.
+
+In the example below, :code:`pytest` was called with the :code:`DeFlaker`, :code:`TracebackMatching` (at execution level), and :code:`CoverageIndependence` (at test level) flakefighters.
+On the first execution of :code:`TestFlaky::test_flaky_example`, :code:`DeFlaker` classified the test failure as flaky, but :code:`TracebackMatching` classified it as genuine.
+On the rerun, the outcome of :code:`DeFlaker` did not change, but :code:`TracebackMatching` classified it as flaky.
+Finally, :code:`CoverageIndependence` classified the overall test as flaky.
+
+..  code-block:: ini
+
+  {
+    "nodeid": "test_flaky.py::TestFlaky::test_flaky_example",
+    "lineno": 5,
+    "outcome": "failed",
+    "setup": {"duration": 0.00024656900131958537, "outcome": "passed"},
+    "call": {
+      "duration": 0.000256097000601585,
+      "outcome": "failed",
+      "metadata": {
+      "executions": [{
+        "start_time": "2026-01-19 11:19:06.214221",
+        "end_time": "2026-01-19 11:19:06.214703",
+        "outcome": failed,
+        "flakefighter_results": {"DeFlaker": "flaky", "TracebackMatching": "genuine"}
+      }, {
+        "start_time": "2026-01-19 11:19:06.264956",
+        "end_time": "2026-01-19 11:19:06.265155",
+        "outcome": failed,
+        "flakefighter_results": {"DeFlaker": "flaky", "TracebackMatching": "flaky"}
+      }
+        ]
+      }
+    },
+    "teardown": {"duration": 6.307100011326838e-05, "outcome": "passed"},
+    "metadata": {
+      "flakefighter_results": {"CoverageIndependence": "flaky"}
+    }
+  }
+
+.. note::
+  The :code:`pytest-json` extension is not officially supported, but the execution-level flakefighter results will be printed in a similar manner if you use this extension instead of the newer :code:`pytest-json-report`.
+  Test-level flakefighter results will not be saved.
+
+Writing to XML
+--------------
+
+The extension is designed to export results to JUnitXML when you run :code:`pytest` with the :code:`--junitxml` option.
+The results will be saved in a :code:`<flakefighterresults>` element as a child of each :code:`<testcase>`.
+Each execution-level result will be saved in an :code:`<execution>` element.
+The test-level results will be saved in a :code:`<test>` element.
+
+..  code-block:: ini
+
+  <testcase classname="test_flaky_reruns.TestFlakyRuns" name="test_pass" time="0.001">
+    <flakefighterresults>
+      <execution outcome="failed" starttime="2026-01-19T11:44:58.123723" endtime="2026-01-19T11:44:58.124223">
+        <DeFlaker>flaky</DeFlaker>
+        <TracebackMatching>genuine</TracebackMatching>
+      </execution>
+      <execution outcome="failed" starttime="2026-01-19T11:44:58.173746" endtime="2026-01-19T11:44:58.173929">
+        <DeFlaker>flaky</DeFlaker>
+        <TracebackMatching>flaky</TracebackMatching>
+      </execution>
+      <test>
+        <CoverageIndependence>flaky</CoverageIndependence>
+      </test>
+    </flakefighterresults>
+  </testcase>
+
+Writing to HTML
+---------------
+
+The extension is designed to work with :code:`pytest-html` to export results to HTML when you run :code:`pytest` with the :code:`--html` option.
+Test-level flakefighter results are shown just underneath the summary.
+Execution-level flakefighter results are shown with the details of each individual test.
+
+.. image:: _static/images/html_summary.png

{pytest_flakefighters-0.2.3 → pytest_flakefighters-0.3.0}/src/_version.py

@@ -28,7 +28,7 @@ version_tuple: VERSION_TUPLE
 commit_id: COMMIT_ID
 __commit_id__: COMMIT_ID
 
-__version__ = version = '0.2.3'
-__version_tuple__ = version_tuple = (0, 2, 3)
+__version__ = version = '0.3.0'
+__version_tuple__ = version_tuple = (0, 3, 0)
 
-__commit_id__ = commit_id = 'g00e29e6af'
+__commit_id__ = commit_id = 'gfae51daf6'

pytest_flakefighters-0.3.0/src/pytest_flakefighters/config.py

@@ -0,0 +1,90 @@
+"""
+This module defines all the configuration options in a dictionary.
+Keys should be of the form `(--long-name, -L)` or just `(--long-name,)`.
+Options can then be specified on the commandline as `--long-name` or in a configuration file as `long_name`.
+Options specified on the commandline will override those specified in configuration files.
+"""
+
+import os
+
+from pytest_flakefighters.rerun_strategies import All, FlakyFailure, PreviouslyFlaky
+
+rerun_strategies = {"ALL": All, "FLAKY_FAILURE": FlakyFailure, "PREVIOUSLY_FLAKY": PreviouslyFlaky}
+
+
+options = {
+    ("--root",): {
+        "dest": "root",
+        "action": "store",
+        "default": os.getcwd(),
+        "help": "The root directory of the project. Defaults to the current working directory.",
+    },
+    ("--suppress-flaky-failures-exit-code",): {
+        "dest": "suppress_flaky",
+        "action": "store_true",
+        "default": False,
+        "help": "Return OK exit code if the only failures are flaky failures.",
+    },
+    ("--no-save",): {
+        "action": "store_true",
+        "default": False,
+        "help": "Do not save this run to the database of previous flakefighters runs.",
+    },
+    ("--function-coverage",): {
+        "action": "store_true",
+        "default": False,
+        "help": "Use function-level coverage instead of line coverage.",
+    },
+    ("--load-max-runs", "-M"): {
+        "action": "store",
+        "default": None,
+        "help": "The maximum number of previous runs to consider.",
+    },
+    ("--database-url", "-D"): {
+        "action": "store",
+        "default": "sqlite:///flakefighters.db",
+        "help": "The database URL. Defaults to 'flakefighters.db' in current working directory.",
+    },
+    ("--store-max-runs",): {
+        "action": "store",
+        "default": None,
+        "type": int,
+        "help": "The maximum number of previous flakefighters runs to store. Default is to store all.",
+    },
+    ("--max-reruns",): {
+        "action": "store",
+        "default": 0,
+        "type": int,
+        "help": "The maximum number of times to rerun tests. "
+        "By default, only failing tests marked as flaky will be rerun. "
+        "This can be changed with the --rerun-strategy parameter.",
+    },
+    ("--rerun-strategy",): {
+        "action": "store",
+        "type": str,
+        "choices": list(rerun_strategies),
+        "default": "FLAKY_FAILURE",
+        "help": "The strategy used to determine which tests to rerun. Supported options are:\n  "
+        + "\n  ".join(f"{name} - {strat.help()}" for name, strat in rerun_strategies.items()),
+    },
+    ("--time-immemorial",): {
+        "action": "store",
+        "default": None,
+        "help": "How long to store flakefighters runs for, specified as `days:hours:minutes`. "
+        "E.g. to store tests for one week, use 7:0:0.",
+    },
+    ("--display-outcomes", "-O"): {
+        "action": "store",
+        "type": int,
+        "nargs": "?",  # Allows 0 or 1 arguments
+        "const": 0,  # Value used if -O is present but no value is provided
+        "default": 0,  # Value used if -O is not present at all
+        "help": "Display historical test outcomes of the specified number of previous runs."
+        "If no value is specified, then display only the current verdict.",
+    },
+    ("--display-verdicts",): {
+        "action": "store_true",
+        "default": False,
+        "help": "Display the flaky classification verdicts alongside test outcomes.",
+    },
+}

{pytest_flakefighters-0.2.3 → pytest_flakefighters-0.3.0}/src/pytest_flakefighters/database_management.py

@@ -34,10 +34,12 @@ from sqlalchemy.orm import (
 class Base(DeclarativeBase):
     """
     Declarative base class for data objects.
+
+    :ivar id: Unique autoincrementing ID for the object.
     """
 
     id: Mapped[int] = Column(Integer, primary_key=True)  # pylint: disable=C0103
-    # @pytest, these are not the tests you're looking for...
+    # Explicitly flag that we don't want pytest to collect our Test, TestExecution, etc. classes.
     __test__ = False  # pylint: disable=C0103
 
     @declared_attr
@@ -49,8 +51,16 @@ class Base(DeclarativeBase):
 class Run(Base):
     """
     Class to store attributes of a flakefighters run.
+    :ivar start_time: The time the test run was begun.
+    :ivar created_at: The time the entry was added to the database.
+    This is not necessarily equivalent to start_time if the test suite took a long time to run or
+    if the entry was migrated from a separate database.
+    :ivar root: The root directory of the project.
+    :ivar tests: The test suite.
+    :ivar active_flakefighters: The flakefighters that are active on the run.
     """
 
+    start_time = Column(DateTime)
     created_at = Column(DateTime, default=func.now())
     root: Mapped[str] = Column(String)
     tests = relationship("Test", backref="run", lazy="subquery", cascade="all, delete", passive_deletes=True)
@@ -63,6 +73,10 @@ class Run(Base):
 class ActiveFlakeFighter(Base):
     """
     Store relevant information about the active flakefighters.
+
+    :ivar run_id: Foreign key of the related run.
+    :ivar name: Class name of the flakefighter.
+    :ivar params: The parameterss of the flakefighter.
     """
 
     run_id: Mapped[int] = Column(Integer, ForeignKey("run.id"), nullable=False)
@@ -74,6 +88,17 @@ class ActiveFlakeFighter(Base):
 class Test(Base):
     """
     Class to store attributes of a test case.
+
+    :ivar run_id: Foreign key of the related run.
+    :ivar fspath: File system path of the file containing the test definition.
+    :ivar line_no: Line number of the test definition.
+    :ivar name: Name of the test case.
+    :ivar skipped: Boolean true if the test was skipped, else false.
+    :ivar executions: List of execution attempts.
+    :ivar flakefighter_results: List of test-level flakefighter results.
+
+    .. note::
+      Execution-level flakefighter results will be stored inside the individual TestExecution objects
     """
 
     run_id: Mapped[int] = Column(Integer, ForeignKey("run.id"), nullable=False)
@@ -104,6 +129,16 @@ class Test(Base):
 class TestExecution(Base):  # pylint: disable=R0902
     """
     Class to store attributes of a test outcome.
+
+    :ivar test_id: Foreign key of the related test.
+    :ivar outcome: Outcome of the test. One of "passed", "failed", or "skipped".
+    :ivar stdout: The captured stdout string.
+    :ivar stedrr: The captured stderr string.
+    :ivar start_time: The start time of the test.
+    :ivar end_time: The end time of the test.
+    :ivar coverage: The line coverage of the test.
+    :ivar flakefighter_results: The execution-level flakefighter results.
+    :ivar exception: The exception associated with the test if one was thrown.
     """
 
     __tablename__ = "test_execution"
@@ -140,6 +175,10 @@ class TestExecution(Base):  # pylint: disable=R0902
 class TestException(Base):  # pylint: disable=R0902
     """
     Class to store information about the exceptions that cause tests to fail.
+
+    :ivar execution_id: Foreign key of the related execution.
+    :ivar name: Name of the exception.
+    :traceback: The full stack of traceback entries.
     """
 
     __tablename__ = "test_exception"
@@ -155,6 +194,13 @@ class TestException(Base):  # pylint: disable=R0902
 class TracebackEntry(Base):  # pylint: disable=R0902
     """
     Class to store attributes of entries in the stack trace.
+
+    :ivar exception_id: Foreign key of the related exception.
+    :ivar path: Filepath of the source file.
+    :ivar lineno: Line number of the executed statement.
+    :ivar colno: Column number of the executed statement.
+    :ivar statement: The executed statement.
+    :ivar source: The surrounding source code.
     """
 
     exception_id: Mapped[int] = Column(Integer, ForeignKey("test_exception.id"), nullable=False)
@@ -169,6 +215,11 @@ class TracebackEntry(Base):  # pylint: disable=R0902
 class FlakefighterResult(Base):  # pylint: disable=R0902
     """
     Class to store flakefighter results.
+
+    :ivar test_execution_id: Foreign key of the related test execution. Should not be set if test_id is present.
+    :ivar test_id: Foreign key of the related test. Should not be set if test_execution_id is present.
+    :ivar name: Name of the flakefighter.
+    :ivar flaky: Boolean true if the test (execution) was classified as flaky.
     """
 
     __tablename__ = "flakefighter_result"
@@ -182,10 +233,25 @@ class FlakefighterResult(Base):  # pylint: disable=R0902
         CheckConstraint("NOT (test_execution_id IS NULL AND test_id IS NULL)", name="check_test_id_not_null"),
     )
 
+    @property
+    def classification(self):
+        """
+        Return the classification as a string.
+        "flaky" if the test was classified as flaky, else "genuine".
+        """
+        return "flaky" if self.flaky else "genuine"
+
 
 class Database:
     """
     Class to handle database setup and interaction.
+
+    :ivar engine: The database engine.
+    :ivar store_max_runs: The maximum number of previous runs that should be stored. If the database exceeds this size,
+                          older runs will be pruned to make space for newer ones.
+    :ivar time_immemorial: Time before which runs should not be considered. Runs before this date will be pruned when
+                           saving new runs.
+    :ivar previous_runs: List of previous flakefighter runs with most recent first.
     """
 
     def __init__(
@@ -230,4 +296,4 @@ class Database:
         :param limit: The maximum number of runs to return (these will be most recent runs).
         """
         with Session(self.engine) as session:
-            return session.scalars(select(Run).order_by(desc(Run.id)).limit(limit)).all()
+            return session.scalars(select(Run).order_by(desc(Run.start_time)).limit(limit)).all()

{pytest_flakefighters-0.2.3 → pytest_flakefighters-0.3.0}/src/pytest_flakefighters/flakefighters/deflaker.py

@@ -68,7 +68,10 @@ class DeFlaker(FlakeFighter):
         self.method_declarations = {}
         for file, lines in self.lines_changed.items():
             with open(file) as f:
-                tree = ast.parse(f.read())
+                try:
+                    tree = ast.parse(f.read())
+                except SyntaxError:
+                    continue
 
             self.method_declarations[file] = [
                 node.lineno
@@ -133,9 +136,5 @@ class DeFlaker(FlakeFighter):
         :param run: Run object representing the pytest run, with tests accessible through run.tests.
         """
         for test in run.tests:
-            test.flakefighter_results.append(
-                FlakefighterResult(
-                    name=self.__class__.__name__,
-                    flaky=any(self._flaky_execution(execution) for execution in test.executions),
-                )
-            )
+            for execution in test.executions:
+                self.flaky_test_live(execution)