sqlmesh 0.193.1.dev4__tar.gz → 0.193.1.dev6__tar.gz

{sqlmesh-0.193.1.dev4 → sqlmesh-0.193.1.dev6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sqlmesh
-Version: 0.193.1.dev4
+Version: 0.193.1.dev6
 Summary: Next-generation data transformation framework
 Author-email: "TobikoData Inc." <engineering@tobikodata.com>
 License:                                  Apache License
@@ -233,7 +233,7 @@ Requires-Dist: pydantic>=2.0.0
 Requires-Dist: requests
 Requires-Dist: rich[jupyter]
 Requires-Dist: ruamel.yaml
-Requires-Dist: sqlglot[rs]~=26.27.1
+Requires-Dist: sqlglot[rs]~=26.29.0
 Requires-Dist: tenacity
 Requires-Dist: time-machine
 Requires-Dist: json-stream

{sqlmesh-0.193.1.dev4 → sqlmesh-0.193.1.dev6}/pyproject.toml

@@ -22,7 +22,7 @@ dependencies = [
     "requests",
     "rich[jupyter]",
     "ruamel.yaml",
-    "sqlglot[rs]~=26.27.1",
+    "sqlglot[rs]~=26.29.0",
     "tenacity",
     "time-machine",
     "json-stream"

{sqlmesh-0.193.1.dev4 → sqlmesh-0.193.1.dev6}/sqlmesh/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.193.1.dev4'
-__version_tuple__ = version_tuple = (0, 193, 1, 'dev4')
+__version__ = version = '0.193.1.dev6'
+__version_tuple__ = version_tuple = (0, 193, 1, 'dev6')

{sqlmesh-0.193.1.dev4 → sqlmesh-0.193.1.dev6}/sqlmesh/core/console.py

@@ -7,6 +7,7 @@ import unittest
 import uuid
 import logging
 import textwrap
+from itertools import zip_longest
 from pathlib import Path
 from hyperscript import h
 from rich.console import Console as RichConsole
@@ -26,6 +27,7 @@ from rich.table import Table
 from rich.tree import Tree
 from sqlglot import exp
 
+from sqlmesh.core.test.result import ModelTextTestResult
 from sqlmesh.core.environment import EnvironmentNamingInfo, EnvironmentSummary
 from sqlmesh.core.linter.rule import RuleViolation
 from sqlmesh.core.model import Model
@@ -46,6 +48,7 @@ from sqlmesh.utils.errors import (
     NodeAuditsErrors,
     format_destructive_change_msg,
 )
+from sqlmesh.utils.rich import strip_ansi_codes
 
 if t.TYPE_CHECKING:
     import ipywidgets as widgets
@@ -316,6 +319,17 @@ class PlanBuilderConsole(BaseConsole, abc.ABC):
         """Display a destructive change error or warning to the user."""
 
 
+class UnitTestConsole(abc.ABC):
+    @abc.abstractmethod
+    def log_test_results(self, result: ModelTextTestResult, target_dialect: str) -> None:
+        """Display the test result and output.
+
+        Args:
+            result: The unittest test result that contains metrics like num success, fails, ect.
+            target_dialect: The dialect that tests were run against. Assumes all tests run against the same dialect.
+        """
+
+
 class Console(
     PlanBuilderConsole,
     LinterConsole,
@@ -327,6 +341,7 @@ class Console(
     DifferenceConsole,
     TableDiffConsole,
     BaseConsole,
+    UnitTestConsole,
     abc.ABC,
 ):
     """Abstract base class for defining classes used for displaying information to the user and also interact
@@ -460,18 +475,6 @@ class Console(
                 fail. Default: False
         """
 
-    @abc.abstractmethod
-    def log_test_results(
-        self, result: unittest.result.TestResult, output: t.Optional[str], target_dialect: str
-    ) -> None:
-        """Display the test result and output.
-
-        Args:
-            result: The unittest test result that contains metrics like num success, fails, ect.
-            output: The generated output from the unittest.
-            target_dialect: The dialect that tests were run against. Assumes all tests run against the same dialect.
-        """
-
     @abc.abstractmethod
     def show_sql(self, sql: str) -> None:
         """Display to the user SQL."""
@@ -668,9 +671,7 @@ class NoopConsole(Console):
         if auto_apply:
             plan_builder.apply()
 
-    def log_test_results(
-        self, result: unittest.result.TestResult, output: t.Optional[str], target_dialect: str
-    ) -> None:
+    def log_test_results(self, result: ModelTextTestResult, target_dialect: str) -> None:
         pass
 
     def show_sql(self, sql: str) -> None:
@@ -1952,10 +1953,12 @@ class TerminalConsole(Console):
         ):
             plan_builder.apply()
 
-    def log_test_results(
-        self, result: unittest.result.TestResult, output: t.Optional[str], target_dialect: str
-    ) -> None:
+    def log_test_results(self, result: ModelTextTestResult, target_dialect: str) -> None:
         divider_length = 70
+
+        self._log_test_details(result)
+        self._print("\n")
+
         if result.wasSuccessful():
             self._print("=" * divider_length)
             self._print(
@@ -1972,9 +1975,13 @@ class TerminalConsole(Console):
             )
             for test, _ in result.failures + result.errors:
                 if isinstance(test, ModelTest):
-                    self._print(f"Failure Test: {test.model.name} {test.test_name}")
+                    self._print(f"Failure Test: {test.path}::{test.test_name}")
             self._print("=" * divider_length)
-            self._print(output)
+
+    def _captured_unit_test_results(self, result: ModelTextTestResult) -> str:
+        with self.console.capture() as capture:
+            self._log_test_details(result)
+        return strip_ansi_codes(capture.get())
 
     def show_sql(self, sql: str) -> None:
         self._print(Syntax(sql, "sql", word_wrap=True), crop=False)
@@ -2492,6 +2499,63 @@ class TerminalConsole(Console):
         else:
             self.log_warning(msg)
 
+    def _log_test_details(self, result: ModelTextTestResult) -> None:
+        """
+        This is a helper method that encapsulates the logic for logging the relevant unittest for the result.
+        The top level method (`log_test_results`) reuses `_log_test_details` differently based on the console.
+
+        Args:
+            result: The unittest test result that contains metrics like num success, fails, ect.
+        """
+        tests_run = result.testsRun
+        errors = result.errors
+        failures = result.failures
+        skipped = result.skipped
+        is_success = not (errors or failures)
+
+        infos = []
+        if failures:
+            infos.append(f"failures={len(failures)}")
+        if errors:
+            infos.append(f"errors={len(errors)}")
+        if skipped:
+            infos.append(f"skipped={skipped}")
+
+        self._print("\n", end="")
+
+        for (test_case, failure), test_failure_tables in zip_longest(  # type: ignore
+            failures, result.failure_tables
+        ):
+            self._print(unittest.TextTestResult.separator1)
+            self._print(f"FAIL: {test_case}")
+
+            if test_description := test_case.shortDescription():
+                self._print(test_description)
+            self._print(f"{unittest.TextTestResult.separator2}")
+
+            if not test_failure_tables:
+                self._print(failure)
+            else:
+                for failure_table in test_failure_tables:
+                    self._print(failure_table)
+                    self._print("\n", end="")
+
+        for test_case, error in errors:
+            self._print(unittest.TextTestResult.separator1)
+            self._print(f"ERROR: {test_case}")
+            self._print(f"{unittest.TextTestResult.separator2}")
+            self._print(error)
+
+        # Output final report
+        self._print(unittest.TextTestResult.separator2)
+        test_duration_msg = f" in {result.duration:.3f}s" if result.duration else ""
+        self._print(
+            f"\nRan {tests_run} {'tests' if tests_run > 1 else 'test'}{test_duration_msg} \n"
+        )
+        self._print(
+            f"{'OK' if is_success else 'FAILED'}{' (' + ', '.join(infos) + ')' if infos else ''}"
+        )
+
 
 def _cells_match(x: t.Any, y: t.Any) -> bool:
     """Helper function to compare two cells and returns true if they're equal, handling array objects."""
@@ -2763,9 +2827,7 @@ class NotebookMagicConsole(TerminalConsole):
         )
         self.display(radio)
 
-    def log_test_results(
-        self, result: unittest.result.TestResult, output: t.Optional[str], target_dialect: str
-    ) -> None:
+    def log_test_results(self, result: ModelTextTestResult, target_dialect: str) -> None:
         import ipywidgets as widgets
 
         divider_length = 70
@@ -2781,12 +2843,14 @@ class NotebookMagicConsole(TerminalConsole):
                 h(
                     "span",
                     {"style": {**shared_style, **success_color}},
-                    f"Successfully Ran {str(result.testsRun)} Tests Against {target_dialect}",
+                    f"Successfully Ran {str(result.testsRun)} tests against {target_dialect}",
                 )
             )
             footer = str(h("span", {"style": shared_style}, "=" * divider_length))
             self.display(widgets.HTML("<br>".join([header, message, footer])))
         else:
+            output = self._captured_unit_test_results(result)
+
             fail_color = {"color": "#db3737"}
             fail_shared_style = {**shared_style, **fail_color}
             header = str(h("span", {"style": fail_shared_style}, "-" * divider_length))
@@ -3137,21 +3201,22 @@ class MarkdownConsole(CaptureTerminalConsole):
     def log_success(self, message: str) -> None:
         self._print(message)
 
-    def log_test_results(
-        self, result: unittest.result.TestResult, output: t.Optional[str], target_dialect: str
-    ) -> None:
+    def log_test_results(self, result: ModelTextTestResult, target_dialect: str) -> None:
         if result.wasSuccessful():
             self._print(
                 f"**Successfully Ran `{str(result.testsRun)}` Tests Against `{target_dialect}`**\n\n"
             )
         else:
+            self._print("```")
+            self._log_test_details(result)
+            self._print("```\n\n")
+
             self._print(
                 f"**Num Successful Tests: {result.testsRun - len(result.failures) - len(result.errors)}**\n\n"
             )
             for test, _ in result.failures + result.errors:
                 if isinstance(test, ModelTest):
                     self._print(f"* Failure Test: `{test.model.name}` - `{test.test_name}`\n\n")
-            self._print(f"```{output}```\n\n")
 
     def log_skipped_models(self, snapshot_names: t.Set[str]) -> None:
         if snapshot_names:
@@ -3530,9 +3595,7 @@ class DebuggerTerminalConsole(TerminalConsole):
         for modified in context_diff.modified_snapshots:
             self._write(f"  Modified: {modified}")
 
-    def log_test_results(
-        self, result: unittest.result.TestResult, output: t.Optional[str], target_dialect: str
-    ) -> None:
+    def log_test_results(self, result: ModelTextTestResult, target_dialect: str) -> None:
         self._write("Test Results:", result)
 
     def show_sql(self, sql: str) -> None:

{sqlmesh-0.193.1.dev4 → sqlmesh-0.193.1.dev6}/sqlmesh/core/context.py

@@ -40,7 +40,6 @@ import sys
 import time
 import traceback
 import typing as t
-import unittest.result
 from functools import cached_property
 from io import StringIO
 from itertools import chain
@@ -2061,7 +2060,7 @@ class GenericContext(BaseContext, t.Generic[C]):
 
         test_meta = self.load_model_tests(tests=tests, patterns=match_patterns)
 
-        return run_tests(
+        result = run_tests(
             model_test_metadata=test_meta,
             models=self._models,
             config=self.config,
@@ -2074,6 +2073,13 @@ class GenericContext(BaseContext, t.Generic[C]):
             default_catalog_dialect=self.config.dialect or "",
         )
 
+        self.console.log_test_results(
+            result,
+            self.test_connection_config._engine_adapter.DIALECT,
+        )
+
+        return result
+
     @python_api_analytics
     def audit(
         self,
@@ -2496,28 +2502,20 @@ class GenericContext(BaseContext, t.Generic[C]):
 
     def _run_tests(
         self, verbosity: Verbosity = Verbosity.DEFAULT
-    ) -> t.Tuple[unittest.result.TestResult, str]:
+    ) -> t.Tuple[ModelTextTestResult, str]:
         test_output_io = StringIO()
         result = self.test(stream=test_output_io, verbosity=verbosity)
         return result, test_output_io.getvalue()
 
-    def _run_plan_tests(
-        self, skip_tests: bool = False
-    ) -> t.Tuple[t.Optional[unittest.result.TestResult], t.Optional[str]]:
+    def _run_plan_tests(self, skip_tests: bool = False) -> t.Optional[ModelTextTestResult]:
         if not skip_tests:
-            result, test_output = self._run_tests()
-            if result.testsRun > 0:
-                self.console.log_test_results(
-                    result,
-                    test_output,
-                    self.test_connection_config._engine_adapter.DIALECT,
-                )
+            result = self.test()
             if not result.wasSuccessful():
                 raise PlanError(
                     "Cannot generate plan due to failing test(s). Fix test(s) and run again."
                 )
-            return result, test_output
-        return None, None
+            return result
+        return None
 
     @property
     def _model_tables(self) -> t.Dict[str, str]:

{sqlmesh-0.193.1.dev4 → sqlmesh-0.193.1.dev6}/sqlmesh/core/test/definition.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import sys
+
 import datetime
 import threading
 import typing as t
@@ -10,6 +12,7 @@ from itertools import chain
 from pathlib import Path
 from unittest.mock import patch
 
+
 from io import StringIO
 from sqlglot import Dialect, exp
 from sqlglot.optimizer.annotate_types import annotate_types
@@ -24,6 +27,8 @@ from sqlmesh.utils import UniqueKeyDict, random_id, type_is_known, yaml
 from sqlmesh.utils.date import date_dict, pandas_timestamp_to_pydatetime, to_datetime
 from sqlmesh.utils.errors import ConfigError, TestError
 from sqlmesh.utils.yaml import load as yaml_load
+from sqlmesh.utils import Verbosity
+from sqlmesh.utils.rich import df_to_table
 
 if t.TYPE_CHECKING:
     import pandas as pd
@@ -60,6 +65,7 @@ class ModelTest(unittest.TestCase):
         preserve_fixtures: bool = False,
         default_catalog: str | None = None,
         concurrency: bool = False,
+        verbosity: Verbosity = Verbosity.DEFAULT,
     ) -> None:
         """ModelTest encapsulates a unit test for a model.
 
@@ -83,6 +89,7 @@ class ModelTest(unittest.TestCase):
         self.default_catalog = default_catalog
         self.dialect = dialect
         self.concurrency = concurrency
+        self.verbosity = verbosity
 
         self._fixture_table_cache: t.Dict[str, exp.Table] = {}
         self._normalized_column_name_cache: t.Dict[str, str] = {}
@@ -134,6 +141,11 @@ class ModelTest(unittest.TestCase):
 
         super().__init__()
 
+    def defaultTestResult(self) -> unittest.TestResult:
+        from sqlmesh.core.test.result import ModelTextTestResult
+
+        return ModelTextTestResult(stream=sys.stdout, descriptions=True, verbosity=self.verbosity)
+
     def shortDescription(self) -> t.Optional[str]:
         return self.body.get("description")
 
@@ -290,23 +302,53 @@ class ModelTest(unittest.TestCase):
                 check_like=True,  # Ignore column order
             )
         except AssertionError as e:
+            # There are 2 concepts at play here:
+            # 1. The Exception args will contain the error message plus the diff dataframe table stringified
+            #    (backwards compatibility with existing tests, possible to serialize/send over network etc)
+            # 2. Each test will also transform these diff dataframes into Rich tables, which will be the ones that'll
+            #    be surfaced to the user through Console for better UX (versus stringified dataframes)
+            #
+            # This is a bit of a hack, but it's a way to get the best of both worlds.
+            args: t.List[t.Any] = []
             if expected.shape != actual.shape:
                 _raise_if_unexpected_columns(expected.columns, actual.columns)
 
-                error_msg = "Data mismatch (rows are different)"
+                args.append("Data mismatch (rows are different)")
 
                 missing_rows = _row_difference(expected, actual)
                 if not missing_rows.empty:
-                    error_msg += f"\n\nMissing rows:\n\n{missing_rows}"
+                    args[0] += f"\n\nMissing rows:\n\n{missing_rows}"
+                    args.append(df_to_table("Missing rows", missing_rows))
 
                 unexpected_rows = _row_difference(actual, expected)
+
                 if not unexpected_rows.empty:
-                    error_msg += f"\n\nUnexpected rows:\n\n{unexpected_rows}"
+                    args[0] += f"\n\nUnexpected rows:\n\n{unexpected_rows}"
+                    args.append(df_to_table("Unexpected rows", unexpected_rows))
 
-                e.args = (error_msg,)
             else:
                 diff = expected.compare(actual).rename(columns={"self": "exp", "other": "act"})
-                e.args = (f"Data mismatch (exp: expected, act: actual)\n\n{diff}",)
+
+                args.append(f"Data mismatch (exp: expected, act: actual)\n\n{diff}")
+
+                diff.rename(columns={"exp": "Expected", "act": "Actual"}, inplace=True)
+                if self.verbosity == Verbosity.DEFAULT:
+                    args.extend(
+                        df_to_table("Data mismatch", df) for df in _split_df_by_column_pairs(diff)
+                    )
+                else:
+                    from pandas import MultiIndex
+
+                    levels = t.cast(MultiIndex, diff.columns).levels[0]
+                    for col in levels:
+                        col_diff = diff[col]
+                        if not col_diff.empty:
+                            table = df_to_table(
+                                f"[bold red]Column '{col}' mismatch[/bold red]", col_diff
+                            )
+                            args.append(table)
+
+            e.args = (*args,)
 
             raise e
 
@@ -328,6 +370,7 @@ class ModelTest(unittest.TestCase):
         preserve_fixtures: bool = False,
         default_catalog: str | None = None,
         concurrency: bool = False,
+        verbosity: Verbosity = Verbosity.DEFAULT,
     ) -> t.Optional[ModelTest]:
         """Create a SqlModelTest or a PythonModelTest.
 
@@ -373,6 +416,7 @@ class ModelTest(unittest.TestCase):
                 preserve_fixtures,
                 default_catalog,
                 concurrency,
+                verbosity,
             )
         except Exception as e:
             raise TestError(f"Failed to create test {test_name} ({path})\n{str(e)}")
@@ -692,6 +736,7 @@ class PythonModelTest(ModelTest):
         preserve_fixtures: bool = False,
         default_catalog: str | None = None,
         concurrency: bool = False,
+        verbosity: Verbosity = Verbosity.DEFAULT,
     ) -> None:
         """PythonModelTest encapsulates a unit test for a Python model.
 
@@ -718,6 +763,7 @@ class PythonModelTest(ModelTest):
             preserve_fixtures,
             default_catalog,
             concurrency,
+            verbosity,
         )
 
         self.context = TestExecutionContext(
@@ -951,3 +997,43 @@ def _normalize_df_value(value: t.Any) -> t.Any:
             return {k: _normalize_df_value(v) for k, v in zip(value["key"], value["value"])}
         return {k: _normalize_df_value(v) for k, v in value.items()}
     return value
+
+
+def _split_df_by_column_pairs(df: pd.DataFrame, pairs_per_chunk: int = 4) -> t.List[pd.DataFrame]:
+    """Split a dataframe into chunks of column pairs.
+
+    Args:
+        df: The dataframe to split
+        pairs_per_chunk: Number of column pairs per chunk (default: 4)
+
+    Returns:
+        List of dataframes, each containing an even number of columns
+    """
+    total_columns = len(df.columns)
+
+    # If we have fewer columns than pairs_per_chunk * 2, return the original df
+    if total_columns <= pairs_per_chunk * 2:
+        return [df]
+
+    # Calculate number of chunks needed to split columns evenly
+    num_chunks = (total_columns + (pairs_per_chunk * 2 - 1)) // (pairs_per_chunk * 2)
+
+    # Calculate columns per chunk to ensure equal distribution
+    # We round down to nearest even number to ensure each chunk has even columns
+    columns_per_chunk = (total_columns // num_chunks) & ~1  # Round down to nearest even number
+    remainder = total_columns - (columns_per_chunk * num_chunks)
+
+    chunks = []
+    start_idx = 0
+
+    # Distribute columns evenly across chunks
+    for i in range(num_chunks):
+        # Add 2 columns to early chunks if there's a remainder
+        # This ensures we always add pairs of columns
+        extra = 2 if i < remainder // 2 else 0
+        end_idx = start_idx + columns_per_chunk + extra
+        chunk = df.iloc[:, start_idx:end_idx]
+        chunks.append(chunk)
+        start_idx = end_idx
+
+    return chunks

{sqlmesh-0.193.1.dev4 → sqlmesh-0.193.1.dev6}/sqlmesh/core/test/result.py

@@ -15,10 +15,13 @@ class ModelTextTestResult(unittest.TextTestResult):
     successes: t.List[unittest.TestCase]
 
     def __init__(self, *args: t.Any, **kwargs: t.Any):
+        self.console = kwargs.pop("console", None)
         super().__init__(*args, **kwargs)
         self.successes = []
         self.original_failures: t.List[t.Tuple[unittest.TestCase, ErrorType]] = []
+        self.failure_tables: t.List[t.Tuple[t.Any, ...]] = []
         self.original_errors: t.List[t.Tuple[unittest.TestCase, ErrorType]] = []
+        self.duration: t.Optional[float] = None
 
     def addSubTest(
         self,
@@ -41,6 +44,12 @@ class ModelTextTestResult(unittest.TextTestResult):
 
         super().addSubTest(test, subtest, err)
 
+    def _print_char(self, char: str) -> None:
+        from sqlmesh.core.console import TerminalConsole
+
+        if isinstance(self.console, TerminalConsole):
+            self.console._print(char, end="")
+
     def addFailure(self, test: unittest.TestCase, err: ErrorType) -> None:
         """Called when the test case test signals a failure.
 
@@ -51,7 +60,18 @@ class ModelTextTestResult(unittest.TextTestResult):
             err: A tuple of the form returned by sys.exc_info(), i.e., (type, value, traceback).
         """
         exctype, value, _ = err
+
+        if value and value.args:
+            exception_msg, rich_tables = value.args[:1], value.args[1:]
+            value.args = exception_msg
+
+            if rich_tables:
+                self.failure_tables.append(rich_tables)
+
+        self._print_char("F")
+
         self.original_failures.append((test, err))
+
         # Intentionally ignore the traceback to hide it from the user
         return super().addFailure(test, (exctype, value, None))  # type: ignore
 
@@ -64,6 +84,9 @@ class ModelTextTestResult(unittest.TextTestResult):
         """
         exctype, value, _ = err
         self.original_errors.append((test, err))
+
+        self._print_char("E")
+
         # Intentionally ignore the traceback to hide it from the user
         return super().addError(test, (exctype, value, None))  # type: ignore
 
@@ -74,52 +97,24 @@ class ModelTextTestResult(unittest.TextTestResult):
             test: The test case
         """
         super().addSuccess(test)
-        self.successes.append(test)
 
-    def log_test_report(self, test_duration: float) -> None:
-        """
-        Log the test report following unittest's conventions.
+        self._print_char(".")
 
-        Args:
-            test_duration: The duration of the tests.
-        """
-        tests_run = self.testsRun
-        errors = self.errors
-        failures = self.failures
-        skipped = self.skipped
-
-        is_success = not (errors or failures)
-
-        infos = []
-        if failures:
-            infos.append(f"failures={len(failures)}")
-        if errors:
-            infos.append(f"errors={len(errors)}")
-        if skipped:
-            infos.append(f"skipped={skipped}")
-
-        stream = self.stream
-
-        stream.write("\n")
-
-        for test_case, failure in failures:
-            stream.writeln(unittest.TextTestResult.separator1)
-            stream.writeln(f"FAIL: {test_case}")
-            if test_description := test_case.shortDescription():
-                stream.writeln(test_description)
-            stream.writeln(unittest.TextTestResult.separator2)
-            stream.writeln(failure)
-
-        for test_case, error in errors:
-            stream.writeln(unittest.TextTestResult.separator1)
-            stream.writeln(f"ERROR: {test_case}")
-            stream.writeln(error)
-
-        # Output final report
-        stream.writeln(unittest.TextTestResult.separator2)
-        stream.writeln(
-            f"Ran {tests_run} {'tests' if tests_run > 1 else 'test'} in {test_duration:.3f}s \n"
-        )
-        stream.writeln(
-            f"{'OK' if is_success else 'FAILED'}{' (' + ', '.join(infos) + ')' if infos else ''}"
-        )
+        self.successes.append(test)
+
+    def merge(self, other: ModelTextTestResult) -> None:
+        if other.successes:
+            self.addSuccess(other.successes[0])
+        elif other.errors:
+            for error_test, error in other.original_errors:
+                self.addError(error_test, error)
+        elif other.failures:
+            for failure_test, failure in other.original_failures:
+                self.addFailure(failure_test, failure)
+
+            self.failure_tables.extend(other.failure_tables)
+        elif other.skipped:
+            skipped_args = other.skipped[0]
+            self.addSkip(skipped_args[0], skipped_args[1])
+
+        self.testsRun += 1