model2data 1.8.0__tar.gz → 1.9.0__tar.gz

{model2data-1.8.0/model2data.egg-info → model2data-1.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: model2data
-Version: 1.8.0
+Version: 1.9.0
 Summary: Generate analytics-ready datasets from DBML models
 Author: JB Analytica
 License-Expression: MIT
@@ -132,7 +132,7 @@ access required.
 ## The model file
 
 A model is one YAML document, `<name>.model2data.yml` — or the same document as JSON. Its format
-is [spec 0.2.0](https://github.com/JB-Analytica/model2data/blob/main/model2data/spec/README.md), with a JSON Schema your editor can autocomplete and
+is [spec 0.3.0](https://github.com/JB-Analytica/model2data/blob/main/model2data/spec/README.md), with a JSON Schema your editor can autocomplete and
 check against:
 
 ```yaml
@@ -330,6 +330,55 @@ days[3].tables["orders"].updated    # rows day 3 changed, with their new values
 days[3].tables["orders"].state      # the table after day 3
 ```
 
+### Break the data on purpose
+
+A dbt test you have never seen fail is a test you hope works. `--defects` puts deliberate,
+counted defects in the generated data, so `dbt build` fails exactly the tests it should — for
+teaching dbt, or for proving a project's tests fire:
+
+```bash
+model2data --file examples/ecommerce.model2data.yml --seed 42 --defects training
+cd dbt_ecommerce && dbt build    # fails unique, not_null, relationships, accepted_values once each
+```
+
+`training` breaks each kind of standard dbt test once; `messy` puts a small share of every defect
+on every table; `clean` (the default) is the data as it always was, byte for byte; `none` also
+ignores the defects a model's tables list, for the clean data of a training model. A table can
+also list its own defects in the model (spec 0.3.0):
+
+```yaml
+orders:
+  defects:
+    - {type: duplicate_keys, count: 3}                               # fails unique
+    - {type: orphan_foreign_keys, column: customer_id, share: 0.02}  # fails relationships
+    - {type: nulls, column: order_date, count: 5}                    # fails not_null
+```
+
+The types are `duplicate_keys`, `orphan_foreign_keys`, `nulls`, `invalid_values` (fails
+`accepted_values`), `messy_text` (whitespace and casing to clean in staging), and, with `--days`,
+`late_arriving` (rows an incremental model filtering on `updated_at > max(updated_at)` skips) and
+`late_updates` (versions a `strategy: timestamp` snapshot misses) and `overlapping_history` (see
+below). Every run with defects writes
+`defects_report.json` (each defect, the rows it broke, the tests it breaks) and
+`EXPECTED_FAILURES.md` into the project, so a test that does not fire is visible. Defects are applied
+after the clean data, from their own random stream: the same seed gives the same bytes, and a
+defect on one table moves nothing in another. From Python, `model2data.defects.planned_defects`
+says what a run will break, `model2data.output.finish_run` applies it (and builds the histories)
+after `generate_days`, and `write_defects_report` / `write_expected_failures` write the two files.
+
+### A source that keeps its history
+
+`history: true` in a table's `incremental` (spec 0.3.0) also writes `<table>_history`: every
+version of every row over the generated days, with `valid_from`, `valid_to` (null for the current
+version) and `is_current` — an SCD type 2 source to build snapshots and point-in-time joins
+against. The project tests it with two package-free tests, one current row per key and no
+overlapping versions; the `overlapping_history` defect breaks the second.
+
+```yaml
+orders:
+  incremental: {new_per_day: 20, update_rate: 0.1, updated_at: updated_at, history: true}
+```
+
 ## Generated dbt project structure
 
 The generated dbt project includes:

{model2data-1.8.0 → model2data-1.9.0}/README.md

@@ -123,7 +123,7 @@ flowchart LR
 ## The model file
 
 A model is one YAML document, `<name>.model2data.yml` — or the same document as JSON. Its
-format is [spec 0.2.0](model2data/spec/README.md), with a JSON Schema
+format is [spec 0.3.0](model2data/spec/README.md), with a JSON Schema
 ([`model.schema.json`](model2data/spec/model.schema.json)) your editor can autocomplete and check
 against:
 
@@ -473,6 +473,55 @@ they describe intent and should not break a first `dbt build` on real data); the
 same YAML as before. To call the mapping from Python, `model2data.dbt.hint_tests.hint_tests_for(model)`
 returns the tests as data.
 
+### Break the data on purpose
+
+A dbt test you have never seen fail is a test you hope works. `--defects` puts deliberate,
+counted defects in the generated data, so `dbt build` fails exactly the tests it should — for
+teaching dbt, or for proving a project's tests fire:
+
+```bash
+model2data --file examples/ecommerce.model2data.yml --seed 42 --defects training
+cd dbt_ecommerce && dbt build    # fails unique, not_null, relationships, accepted_values once each
+```
+
+`training` breaks each kind of standard dbt test once; `messy` puts a small share of every defect
+on every table; `clean` (the default) is the data as it always was, byte for byte; `none` also
+ignores the defects a model's tables list, for the clean data of a training model. A table can
+also list its own defects in the model (spec 0.3.0):
+
+```yaml
+orders:
+  defects:
+    - {type: duplicate_keys, count: 3}                               # fails unique
+    - {type: orphan_foreign_keys, column: customer_id, share: 0.02}  # fails relationships
+    - {type: nulls, column: order_date, count: 5}                    # fails not_null
+```
+
+The types are `duplicate_keys`, `orphan_foreign_keys`, `nulls`, `invalid_values` (fails
+`accepted_values`), `messy_text` (whitespace and casing to clean in staging), and, with `--days`,
+`late_arriving` (rows an incremental model filtering on `updated_at > max(updated_at)` skips) and
+`late_updates` (versions a `strategy: timestamp` snapshot misses) and `overlapping_history` (see
+below). Every run with defects writes
+`defects_report.json` (each defect, the rows it broke, the tests it breaks) and
+`EXPECTED_FAILURES.md` into the project, so a test that does not fire is visible. Defects are applied
+after the clean data, from their own random stream: the same seed gives the same bytes, and a
+defect on one table moves nothing in another. From Python, `model2data.defects.planned_defects`
+says what a run will break, `model2data.output.finish_run` applies it (and builds the histories)
+after `generate_days`, and `write_defects_report` / `write_expected_failures` write the two files.
+
+### A source that keeps its history
+
+`history: true` in a table's `incremental` (spec 0.3.0) also writes `<table>_history`: every
+version of every row over the generated days, with `valid_from`, `valid_to` (null for the current
+version) and `is_current` — an SCD type 2 source to build snapshots and point-in-time joins
+against. The project tests it with two package-free tests, one current row per key and no
+overlapping versions; the `overlapping_history` defect breaks the second.
+
+```yaml
+orders:
+  incremental: {new_per_day: 20, update_rate: 0.1, updated_at: updated_at, history: true}
+```
+
 ---
 
 ## Generated dbt project structure

{model2data-1.8.0 → model2data-1.9.0}/README_PYPI.md

@@ -85,7 +85,7 @@ access required.
 ## The model file
 
 A model is one YAML document, `<name>.model2data.yml` — or the same document as JSON. Its format
-is [spec 0.2.0](https://github.com/JB-Analytica/model2data/blob/main/model2data/spec/README.md), with a JSON Schema your editor can autocomplete and
+is [spec 0.3.0](https://github.com/JB-Analytica/model2data/blob/main/model2data/spec/README.md), with a JSON Schema your editor can autocomplete and
 check against:
 
 ```yaml
@@ -283,6 +283,55 @@ days[3].tables["orders"].updated    # rows day 3 changed, with their new values
 days[3].tables["orders"].state      # the table after day 3
 ```
 
+### Break the data on purpose
+
+A dbt test you have never seen fail is a test you hope works. `--defects` puts deliberate,
+counted defects in the generated data, so `dbt build` fails exactly the tests it should — for
+teaching dbt, or for proving a project's tests fire:
+
+```bash
+model2data --file examples/ecommerce.model2data.yml --seed 42 --defects training
+cd dbt_ecommerce && dbt build    # fails unique, not_null, relationships, accepted_values once each
+```
+
+`training` breaks each kind of standard dbt test once; `messy` puts a small share of every defect
+on every table; `clean` (the default) is the data as it always was, byte for byte; `none` also
+ignores the defects a model's tables list, for the clean data of a training model. A table can
+also list its own defects in the model (spec 0.3.0):
+
+```yaml
+orders:
+  defects:
+    - {type: duplicate_keys, count: 3}                               # fails unique
+    - {type: orphan_foreign_keys, column: customer_id, share: 0.02}  # fails relationships
+    - {type: nulls, column: order_date, count: 5}                    # fails not_null
+```
+
+The types are `duplicate_keys`, `orphan_foreign_keys`, `nulls`, `invalid_values` (fails
+`accepted_values`), `messy_text` (whitespace and casing to clean in staging), and, with `--days`,
+`late_arriving` (rows an incremental model filtering on `updated_at > max(updated_at)` skips) and
+`late_updates` (versions a `strategy: timestamp` snapshot misses) and `overlapping_history` (see
+below). Every run with defects writes
+`defects_report.json` (each defect, the rows it broke, the tests it breaks) and
+`EXPECTED_FAILURES.md` into the project, so a test that does not fire is visible. Defects are applied
+after the clean data, from their own random stream: the same seed gives the same bytes, and a
+defect on one table moves nothing in another. From Python, `model2data.defects.planned_defects`
+says what a run will break, `model2data.output.finish_run` applies it (and builds the histories)
+after `generate_days`, and `write_defects_report` / `write_expected_failures` write the two files.
+
+### A source that keeps its history
+
+`history: true` in a table's `incremental` (spec 0.3.0) also writes `<table>_history`: every
+version of every row over the generated days, with `valid_from`, `valid_to` (null for the current
+version) and `is_current` — an SCD type 2 source to build snapshots and point-in-time joins
+against. The project tests it with two package-free tests, one current row per key and no
+overlapping versions; the `overlapping_history` defect breaks the second.
+
+```yaml
+orders:
+  incremental: {new_per_day: 20, update_rate: 0.1, updated_at: updated_at, history: true}
+```
+
 ## Generated dbt project structure
 
 The generated dbt project includes:

{model2data-1.8.0 → model2data-1.9.0}/model2data/cli.py

@@ -1,7 +1,6 @@
 import random
-import re
 import shutil
-from dataclasses import replace
+from collections.abc import Iterable
 from datetime import date, datetime
 from pathlib import Path
 from typing import Any, Optional
@@ -13,12 +12,19 @@ from typer.core import TyperGroup
 from typer.models import ParameterInfo
 
 from model2data.dbt.hint_tests import DEFAULT_TOLERANCE, SEVERITIES
+from model2data.dbt.naming import dbt_names, for_dbt
 from model2data.dbt.project import (
     create_profiles_yml,
     create_project_scaffold,
     create_staging_models,
 )
 from model2data.dbt.tests import generate_dbt_yml, generate_unit_tests
+from model2data.defects import (
+    DefectsReport,
+    planned_defects,
+    write_defects_report,
+    write_expected_failures,
+)
 from model2data.generate.core import (
     generate_data_from_dbml,
     get_cyclic_tables,
@@ -36,8 +42,10 @@ from model2data.generate.faker import (
     get_unmapped_columns,
     reset_stats,
 )
+from model2data.generate.history import history_tables
 from model2data.generate.options import TimeProfile
 from model2data.model import (
+    DEFECT_PRESETS,
     Issue,
     Model,
     ModelError,
@@ -47,7 +55,7 @@ from model2data.model import (
     to_engine,
     validate,
 )
-from model2data.parse.dbml import TableDef
+from model2data.output import finish_run
 from model2data.utils import normalize_identifier
 
 SUPPORTED_ADAPTERS = ("duckdb", "postgres")
@@ -155,7 +163,7 @@ app = typer.Typer(
     cls=_GenerateByDefault,
     help=(
         "model2data: Generate analytics-ready datasets from a data model.\n\n"
-        "Given a model -- a .model2data.yml document (spec 0.2.0), the same as JSON,\n"
+        "Given a model -- a .model2data.yml document (spec 0.3.0), the same as JSON,\n"
         "or a DBML file -- this tool produces:\n"
         "• Synthetic but realistic data\n"
         "• A runnable dbt project scaffold\n"
@@ -211,37 +219,13 @@ def _model_stem(file: Path) -> str:
     return file.stem
 
 
-def _dbt_identifier(key: str) -> str:
-    """A table key as the seed and model name it gets in the dbt project.
-
-    Spec 0.2.0 leaves a name as written (`user accounts`, `raw.orders`) and has
-    a consumer normalise it where it reaches a file or a dbt identifier, to
-    `[a-z0-9_]`. Underscores are kept as they are, so `_dlt_loads` and
-    `stories__kids` stay what they were.
-    """
-    cleaned = re.sub(r"[^0-9a-z_]+", "_", key.lower())
-    if cleaned.strip("_") == "":
-        cleaned = "table"
-    elif cleaned[0].isdigit():
-        cleaned = f"t_{cleaned}"
-    return cleaned
-
-
-def _dbt_names(tables: dict[str, TableDef]) -> dict[str, str]:
+def _dbt_names(tables: Iterable[str]) -> dict[str, str]:
     """Each table key's dbt identifier, refusing two keys that normalise alike."""
-    names: dict[str, str] = {}
-    owners: dict[str, str] = {}
-    for key in tables:
-        name = _dbt_identifier(key)
-        if name in owners:
-            typer.echo(
-                f"❌ Tables {owners[name]!r} and {key!r} would both be the dbt seed {name!r}. "
-                "Rename one of them."
-            )
-            raise typer.Exit(1)
-        owners[name] = key
-        names[key] = name
-    return names
+    try:
+        return dbt_names(tables)
+    except ValueError as exc:
+        typer.echo(f"❌ {exc}")
+        raise typer.Exit(1) from None
 
 
 @app.command(
@@ -420,6 +404,18 @@ def main(
         "--next",
         help="Shorthand for --days 1.",
     ),
+    defects_preset: Optional[str] = typer.Option(
+        None,
+        "--defects",
+        metavar="PRESET",
+        help=(
+            "Break the data on purpose: 'clean' (no preset, the default), 'messy' (a mix on\n"
+            "every table) or 'training' (each kind of dbt test fails once); a table's own\n"
+            "`defects` still apply. 'none' ignores every defect, the tables' own too.\n"
+            "Overrides the model's run.defects. Writes defects_report.json and\n"
+            "EXPECTED_FAILURES.md into the project."
+        ),
+    ),
     days_format: str = typer.Option(
         "batches",
         "--days-format",
@@ -463,6 +459,14 @@ def main(
     tolerance = _given(test_tolerance)
     tolerance = DEFAULT_TOLERANCE if tolerance is None else float(tolerance)
 
+    preset = _given(defects_preset)
+    if preset is not None:
+        preset = preset.lower()
+        if preset not in DEFECT_PRESETS:
+            raise typer.BadParameter(
+                f"Choose one of: {', '.join(DEFECT_PRESETS)}.", param_hint="--defects"
+            )
+
     # -------------------------
     # Read the model (names untouched)
     # -------------------------
@@ -537,7 +541,11 @@ def main(
     if table_seeds:
         rolled = ", ".join(f"{key}={value}" for key, value in sorted(table_seeds.items()))
         typer.echo(f"🎲 Re-rolling with a table seed of its own: {rolled}")
-    dbt_names = _dbt_names(tables)
+    names = _dbt_names([*tables, *history_tables(inputs)])
+    plan = planned_defects(model, preset, days=days or 0)
+    preset = preset or (run.defects if run.defects is not None else None)
+    if preset in ("messy", "training") and not plan:
+        typer.echo(f"ℹ️  The {preset} preset finds nothing to break in this model: no defects.")
 
     project_name = normalize_identifier(_given(name) or model.name or _model_stem(file))
     dest = Path.cwd() / f"dbt_{project_name}"
@@ -596,22 +604,33 @@ def main(
         typer.echo(f"❌ {exc}")
         raise typer.Exit(1) from None
 
+    # -------------------------
+    # Defects: broken on purpose, after the clean data, and reported
+    # -------------------------
+    if plan:
+        typer.echo("🧨 Breaking the data on purpose (defects)...")
+    out = finish_run(
+        inputs,
+        day_results or generated_tables,
+        plan,
+        seed=seed,
+        preset=preset,
+        as_of=anchor,
+        hint_tests=hint_tests,
+        test_tolerance=tolerance,
+        names=names,
+    )
+    report = out.report
+    generated_tables = out.frames
+    if day_results:
+        day_results = out.days
+
     # -------------------------
     # dbt names: a table key becomes a [a-z0-9_] seed and model name here,
     # once, so the CSV's stem, `stg_<name>` and every `ref()` agree.
     # -------------------------
-    dbt_tables = {
-        dbt_names[key]: replace(table, name=dbt_names[key]) for key, table in tables.items()
-    }
-    dbt_refs = [
-        {
-            **ref,
-            "source_table": dbt_names.get(ref["source_table"], ref["source_table"]),
-            "target_table": dbt_names.get(ref["target_table"], ref["target_table"]),
-        }
-        for ref in refs
-    ]
-    dbt_frames = {dbt_names.get(key, key): df for key, df in generated_tables.items()}
+    dbt_tables, dbt_refs = for_dbt(out.tables, refs, names)
+    dbt_frames = {names.get(key, key): df for key, df in generated_tables.items()}
 
     # -------------------------
     # Write dbt seeds (normalized names)
@@ -623,7 +642,7 @@ def main(
 
     if day_results and days_format != "final":
         write = write_batches if days_format == "batches" else write_changelog
-        write(dest, day_results, dbt_names)
+        write(dest, day_results, names)
 
     # -------------------------
     # Build dbt assets
@@ -651,6 +670,10 @@ def main(
     # Keep the original model file for reference
     shutil.copy(file, dest / file.name)
 
+    if report is not None:
+        write_defects_report(report, dest)
+        write_expected_failures(report, dest)
+
     # -------------------------
     # Summary
     # -------------------------
@@ -698,6 +721,9 @@ def main(
         for label in duplicate_unique:
             typer.echo(f"    - {label}")
 
+    if report is not None:
+        _print_defects(report)
+
     # -------------------------
     # Done
     # -------------------------
@@ -707,6 +733,29 @@ def main(
     typer.echo("  dbt build   # loads the seeds, builds the models, runs every test")
 
 
+def _spec_of(file: Path) -> str:
+    """The spec a conforming model is written against: 0.3.0, or 0.2.0 (DBML included)."""
+    return "0.3.0" if str(load(file).version).startswith("0.3") else "0.2.0"
+
+
+def _print_defects(report: DefectsReport) -> None:
+    typer.echo("\n🧨 Defects (defects_report.json, EXPECTED_FAILURES.md)")
+    for defect in report.defects:
+        column = defect.column if not isinstance(defect.column, list) else ", ".join(defect.column)
+        on = f".{column}" if column else ""
+        typer.echo(
+            f"  {defect.table}{on}: {defect.defect}, {defect.applied} "
+            f"row{'' if defect.applied == 1 else 's'}"
+        )
+        if defect.note and not defect.applied:
+            typer.echo(f"    ⚠️  {defect.note}")
+    count = len(report.expected_failures)
+    typer.echo(f"  dbt build should fail {count} test{'' if count == 1 else 's'}:")
+    for failure in report.expected_failures:
+        warn = " (warn)" if failure.severity == "warn" else ""
+        typer.echo(f"    - {failure.test}{warn}")
+
+
 @app.command("validate")
 def validate_command(
     file: Path = typer.Argument(  # noqa: B008
@@ -718,7 +767,7 @@ def validate_command(
         help="The model: a .model2data.yml / .yaml / .json document, or a .dbml file.",
     ),
 ):
-    """Check that a model conforms to spec 0.2.0, printing every issue with its path.
+    """Check that a model conforms to spec 0.3.0 (or 0.2.x), printing every issue with its path.
 
     Exits 1 when there is an error; warnings are printed, and the model conforms.
     """
@@ -726,7 +775,7 @@ def validate_command(
     _print_issues(file, issues)
     if any(issue.is_error for issue in issues):
         raise typer.Exit(1)
-    typer.echo(f"✅ {file.name} conforms to spec 0.2.0.")
+    typer.echo(f"✅ {file.name} conforms to spec {_spec_of(file)}.")
 
 
 @app.command("convert")
@@ -748,7 +797,8 @@ def convert_command(
     ),
     force: bool = typer.Option(False, "--force", help="Overwrite the output file if it exists."),
 ):
-    """Convert a model -- DBML, typically -- to a spec 0.2.0 .model2data.yml document."""
+    """Convert a model -- DBML, typically -- to a .model2data.yml document (spec 0.2.0, or
+    0.3.0 when it has defects)."""
     try:
         model = load(file)
     except ModelError as error:

model2data-1.9.0/model2data/dbt/naming.py

@@ -0,0 +1,61 @@
+"""A model's table keys as the seed and model names they get in a dbt project.
+
+The CLI and `model2data.defects` both name tables this way, so a test name the
+defects report predicts is the one dbt gives the test in the generated project.
+"""
+
+from __future__ import annotations
+
+import re
+from collections.abc import Iterable, Mapping
+from dataclasses import replace
+
+from model2data.parse.dbml import TableDef
+
+
+def dbt_identifier(key: str) -> str:
+    """A table key as the seed and model name it gets in the dbt project.
+
+    Spec 0.2.0 leaves a name as written (`user accounts`, `raw.orders`) and has
+    a consumer normalise it where it reaches a file or a dbt identifier, to
+    `[a-z0-9_]`. Underscores are kept as they are, so `_dlt_loads` and
+    `stories__kids` stay what they were.
+    """
+    cleaned = re.sub(r"[^0-9a-z_]+", "_", key.lower())
+    if cleaned.strip("_") == "":
+        cleaned = "table"
+    elif cleaned[0].isdigit():
+        cleaned = f"t_{cleaned}"
+    return cleaned
+
+
+def dbt_names(keys: Iterable[str]) -> dict[str, str]:
+    """Each table key's dbt identifier; ValueError when two keys normalise alike."""
+    names: dict[str, str] = {}
+    owners: dict[str, str] = {}
+    for key in keys:
+        name = dbt_identifier(key)
+        if name in owners:
+            raise ValueError(
+                f"Tables {owners[name]!r} and {key!r} would both be the dbt seed {name!r}. "
+                "Rename one of them."
+            )
+        owners[name] = key
+        names[key] = name
+    return names
+
+
+def for_dbt(
+    tables: Mapping[str, TableDef], refs: list[dict], names: Mapping[str, str]
+) -> tuple[dict[str, TableDef], list[dict]]:
+    """`(tables, refs)` renamed to their dbt names, as `generate_dbt_yml` takes them."""
+    dbt_tables = {names[key]: replace(table, name=names[key]) for key, table in tables.items()}
+    dbt_refs = [
+        {
+            **ref,
+            "source_table": names.get(ref["source_table"], ref["source_table"]),
+            "target_table": names.get(ref["target_table"], ref["target_table"]),
+        }
+        for ref in refs
+    ]
+    return dbt_tables, dbt_refs

model2data-1.9.0/model2data/dbt/templates/history_macros/model2data_history_tests.sql

@@ -0,0 +1,38 @@
+{#-
+  Generic tests of a history table (`incremental.history`): one row per version
+  of each key, valid from `valid_from` until `valid_to` (null for the current
+  version). Written only into a project that has a history table. Plain SQL, no
+  dbt package. Each test returns the keys (or versions) that break it.
+-#}
+
+{% test model2data_one_current_row(model, key, current) %}
+{%- set keys = [] -%}
+{%- for column in key -%}{%- do keys.append(adapter.quote(column)) -%}{%- endfor %}
+select {{ keys | join(', ') }},
+  sum(case when {{ adapter.quote(current) }} then 1 else 0 end) as current_rows
+from {{ model }}
+group by {{ keys | join(', ') }}
+having sum(case when {{ adapter.quote(current) }} then 1 else 0 end) <> 1
+{% endtest %}
+
+
+{#-
+  A version overlaps the next one of its key when it is still valid when the
+  next begins: no `valid_to`, or one after the next version's `valid_from`.
+-#}
+{% test model2data_no_overlapping_ranges(model, key, valid_from, valid_to) %}
+{%- set keys = [] -%}
+{%- for column in key -%}{%- do keys.append(adapter.quote(column)) -%}{%- endfor %}
+select *
+from (
+  select {{ keys | join(', ') }},
+    {{ adapter.quote(valid_from) }} as version_from,
+    {{ adapter.quote(valid_to) }} as version_to,
+    lead({{ adapter.quote(valid_from) }}) over (
+      partition by {{ keys | join(', ') }} order by {{ adapter.quote(valid_from) }}
+    ) as next_from
+  from {{ model }}
+) as versions
+where next_from is not null
+  and (version_to is null or version_to > next_from)
+{% endtest %}