Semi-deterministic testing

Author: Paul Prescod

docs/index.md

@@ -1954,7 +1954,7 @@ granularity), `0.05` (nickle), `0.10` (dime), `0.25` (quarter) and
         total: 100
         min: 10
         max: 50
-        step: 0.1
+        step: 0.01
   fields:
     Amount: ${{current_value}}
 ```

examples/sum_pennies.yml

@@ -8,6 +8,6 @@
         total: 100
         min: 10
         max: 50
-        step: 0.1
+        step: 0.01
   fields:
     Amount: ${{current_value}}

snowfakery/api.py

@@ -151,6 +151,7 @@ def generate_data(
     update_passthrough_fields: T.Sequence[
         str
     ] = (),  # pass through these fields from input to output
+    seed: T.Optional[int] = None,
 ) -> None:
     stopping_criteria = stopping_criteria_from_target_number(target_number)
     dburls = dburls or ([dburl] if dburl else [])
@@ -193,6 +194,7 @@ def open_with_cleanup(file, mode, **kwargs):
             plugin_options=plugin_options,
             update_input_file=open_update_input_file,
             update_passthrough_fields=update_passthrough_fields,
+            seed=seed,
         )
 
         if open_cci_mapping_file:

snowfakery/data_generator.py

@@ -131,6 +131,7 @@ def generate(
     plugin_options: dict = None,
     update_input_file: OpenFileLike = None,
     update_passthrough_fields: T.Sequence[str] = (),
+    seed: T.Optional[int] = None,
 ) -> ExecutionSummary:
     """The main entry point to the package for Python applications."""
     from .api import SnowfakeryApplication
@@ -188,6 +189,7 @@ def generate(
             parse_result=parse_result,
             globals=globls,
             continuing=bool(continuation_data),
+            seed=seed,
         ) as interpreter:
             runtime_context = interpreter.execute()
 

snowfakery/data_generator_runtime.py

@@ -3,6 +3,7 @@
 from collections import defaultdict, ChainMap
 from datetime import date, datetime, timezone
 from contextlib import contextmanager
+from random import Random
 
 from typing import Optional, Dict, Sequence, Mapping, NamedTuple, Set
 import typing as T
@@ -300,6 +301,7 @@ def __init__(
         snowfakery_plugins: Optional[Mapping[str, callable]] = None,
         faker_providers: Sequence[object] = (),
         continuing=False,
+        seed: Optional[int] = None,
     ):
         self.output_stream = output_stream
         self.options = options or {}
@@ -354,6 +356,7 @@ def __init__(
             self.globals.nicknames_and_tables,
         )
         self.resave_objects_from_continuation(globals, self.tables_to_keep_history_for)
+        self.random_number_generator = Random(seed)
 
     def resave_objects_from_continuation(
         self, globals: Globals, tables_to_keep_history_for: T.Iterable[str]

snowfakery/plugins.py

@@ -1,3 +1,4 @@
+from random import Random
 import sys
 
 from typing import Any, Callable, Mapping, Union, NamedTuple, List, Tuple
@@ -141,8 +142,8 @@ def current_filename(self):
         return self.interpreter.current_context.current_template.filename
 
     @property
-    def current_filename(self):
-        return self.interpreter.current_context.current_template.filename
+    def random_number_generator(self) -> Random:
+        return self.interpreter.random_number_generator
 
 
 def lazy(func: Any) -> Callable:

snowfakery/standard_plugins/_math.py

@@ -1,5 +1,5 @@
 import math
-from random import randint, shuffle
+from random import Random
 from types import SimpleNamespace
 from typing import List, Optional, Union
 from snowfakery.plugins import SnowfakeryPlugin, memorable, PluginResultIterator
@@ -17,9 +17,12 @@ def random_partition(
                 *,
                 min: int = 1,
                 max: Optional[int] = None,
-                step: int = 1,
+                step: float = 1,
             ):
-                return GenericPluginResultIterator(False, parts(total, min, max, step))
+                random = self.context.random_number_generator
+                return GenericPluginResultIterator(
+                    False, parts(total, min, max, step, random)
+                )
 
         mathns = MathNamespace()
         mathns.__dict__.update(math.__dict__.copy())
@@ -38,7 +41,13 @@ def __init__(self, repeat, iterable):
         self.next = iter(iterable).__next__
 
 
-def parts(total: int, min_: int = 1, max_=None, step=1) -> List[Union[int, float]]:
+def parts(
+    total: int,
+    min_: int = 1,
+    max_: Optional[int] = None,
+    requested_step: float = 1,
+    rand: Optional[Random] = None,
+) -> List[Union[int, float]]:
     """Split a number into a randomized set of 'pieces'.
     The pieces add up to the `total`. E.g.
 
@@ -56,50 +65,75 @@ def parts(total: int, min_: int = 1, max_=None, step=1) -> List[Union[int, float
     of `step`.
     """
     max_ = max_ or total
-    factor = 0
-
-    if step < 1:
-        assert step in [0.01, 0.5, 0.1, 0.20, 0.25, 0.50], step
-        factor = step
-        total = int(total / factor)
-        step = int(total / factor)
-        min_ = int(total / factor)
-        max_ = int(total / factor)
+    rand = rand or Random()
+
+    if requested_step < 1:
+        allowed_steps = [0.01, 0.5, 0.1, 0.20, 0.25, 0.50]
+        assert (
+            requested_step in allowed_steps
+        ), f"`step` must be one of {', '.join(str(f) for f in allowed_steps)}, not {requested_step}"
+        # multiply up into the integer range so we don't need to do float math
+        total = int(total / requested_step)
+        step = 1
+        min_ = int(min_ / requested_step)
+        max_ = int(max_ / requested_step)
+    else:
+        step = int(requested_step)
+        assert step == requested_step, f"`step` should be an integer, not {step}"
 
     pieces = []
 
     while sum(pieces) < total:
         remaining = total - sum(pieces)
         smallest = max(min_, step)
         if remaining < smallest:
-            # try to add it to a random other piece
-            for i, val in enumerate(pieces):
-                if val + remaining <= max_:
-                    pieces[i] += remaining
-                    remaining = 0
-                    break
-
-            # just tack it on the end despite
-            # it being too small...our
-            # constraints must have been impossible
-            # to fulfil
-            if remaining:
-                pieces.append(remaining)
+            # mutates pieces
+            handle_last_bit(pieces, rand, remaining, min_, max_)
 
         else:
-            part = randint(smallest, min(remaining, max_))
-            round_up = part + step - (part % step)
-            if round_up <= min(remaining, max_) and randint(0, 1):
-                part = round_up
-            else:
-                part -= part % step
-
-            pieces.append(part)
+            pieces.append(generate_piece(pieces, rand, smallest, remaining, max_, step))
 
     assert sum(pieces) == total, pieces
     assert 0 not in pieces, pieces
 
-    shuffle(pieces)
-    if factor:
-        pieces = [round(p * factor, 2) for p in pieces]
+    if requested_step != step:
+        pieces = [round(p * requested_step, 2) for p in pieces]
     return pieces
+
+
+def handle_last_bit(
+    pieces: List[int], rand: Random, remaining: int, min_: int, max_: int
+):
+    """If the piece is big enough, add it.
+    Otherwise, try to add it to another piece."""
+
+    if remaining > min_:
+        pos = rand.randint(0, len(pieces))
+        pieces.insert(pos, remaining)
+        return
+
+    # try to add it to some other piece
+    for i, val in enumerate(pieces):
+        if val + remaining <= max_:
+            pieces[i] += remaining
+            remaining = 0
+            return
+
+    # just insert it despite it being too small...our
+    # constraints must have been impossible to fulfill
+    if remaining:
+        pos = rand.randint(0, len(pieces))
+        pieces.insert(pos, remaining)
+
+
+def generate_piece(
+    pieces: List[int], rand: Random, smallest: int, remaining: int, max_: int, step: int
+):
+    part = rand.randint(smallest, min(remaining, max_))
+    round_up = part + step - (part % step)
+    if round_up <= min(remaining, max_) and rand.randint(0, 1):
+        part = round_up
+    else:
+        part -= part % step
+
+    return part

tests/test_bad_step.recipe.yml

@@ -0,0 +1,10 @@
+- plugin: snowfakery.standard_plugins.Math
+- object: Obj
+  for_each:
+    var: child_value
+    value:
+      Math.random_partition:
+        total: 28
+        step: 0.3
+  fields:
+    Amount: ${{child_value}}

tests/test_summation.py

@@ -1,36 +1,40 @@
 import pytest
+from random import randint
 from io import StringIO
 from snowfakery import generate_data
+from snowfakery.data_gen_exceptions import DataGenError
 
 REPS = 1
 
 
-@pytest.mark.parametrize("_", range(REPS))
+@pytest.mark.parametrize("seed", [randint(0, 2 ** 32) for r in range(REPS)])
 class TestSummation:
-    def test_example(self, generated_rows, _):
-        generate_data("examples/math_partition_simple.recipe.yml")
+    def test_example(self, generated_rows, seed):
+        generate_data("examples/math_partition_simple.recipe.yml", seed=seed)
         parents = generated_rows.table_values("ParentObject__c")
         children = generated_rows.table_values("ChildObject__c")
         assert sum(p["TotalAmount__c"] for p in parents) == sum(
             c["Amount__c"] for c in children
         ), (parents, children)
 
-    def test_example_pennies(self, generated_rows, _):
-        generate_data("examples/sum_pennies.yml")
+    def test_example_pennies(self, generated_rows, seed):
+        generate_data("examples/sum_pennies.yml", seed=seed)
         objs = generated_rows.table_values("Values")
         assert round(sum(p["Amount"] for p in objs)) == 100, sum(
             p["Amount"] for p in objs
         )
 
     @pytest.mark.parametrize("step", [0.01, 0.5, 0.1, 0.20, 0.25, 0.50])
-    def test_example_pennies_param(self, generated_rows, _, step: int):
-        generate_data("examples/sum_pennies_param.yml", user_options={"step": step})
+    def test_example_pennies_param(self, generated_rows, seed, step: int):
+        generate_data(
+            "examples/sum_pennies_param.yml", user_options={"step": step}, seed=1
+        )
         objs = generated_rows.table_values("Values")
         assert round(sum(p["Amount"] for p in objs)) == 100, sum(
             p["Amount"] for p in objs
         )
 
-    def test_step(self, generated_rows, _):
+    def test_step(self, generated_rows, seed):
         yaml = """
     - plugin: snowfakery.standard_plugins.Math
     - object: Obj
@@ -43,14 +47,14 @@ def test_step(self, generated_rows, _):
       fields:
         Amount: ${{child_value}}
         """
-        generate_data(StringIO(yaml))
+        generate_data(StringIO(yaml), seed=seed)
         values = generated_rows.table_values("Obj")
         assert 1 <= len(values) <= 6
         amounts = [r["Amount"] for r in values]
         assert sum(amounts) == 60, amounts
         assert sum([r % 10 for r in amounts]) == 0, amounts
 
-    def test_min(self, generated_rows, _):
+    def test_min(self, generated_rows, seed):
         yaml = """
     - plugin: snowfakery.standard_plugins.Math
     - object: Obj
@@ -63,13 +67,13 @@ def test_min(self, generated_rows, _):
       fields:
         Amount: ${{child_value}}
         """
-        generate_data(StringIO(yaml))
+        generate_data(StringIO(yaml), seed=seed)
         values = generated_rows.table_values("Obj")
         results = [r["Amount"] for r in values]
         assert sum(results) == 60, results
         assert not [r for r in results if r < 5], results
 
-    def test_min_not_factor_of_total(self, generated_rows, _):
+    def test_min_not_factor_of_total(self, generated_rows, seed):
         yaml = """
     - plugin: snowfakery.standard_plugins.Math
     - object: Obj
@@ -82,13 +86,13 @@ def test_min_not_factor_of_total(self, generated_rows, _):
       fields:
         Amount: ${{child_value}}
         """
-        generate_data(StringIO(yaml))
+        generate_data(StringIO(yaml), seed=seed)
         values = generated_rows.table_values("Obj")
         results = [r["Amount"] for r in values]
         assert sum(results) == 63
         assert not [r for r in results if r < 5], results
 
-    def test_step_not_factor_of_total(self, generated_rows, _):
+    def test_step_not_factor_of_total(self, generated_rows, seed):
         yaml = """
     - plugin: snowfakery.standard_plugins.Math
     - object: Obj
@@ -101,13 +105,13 @@ def test_step_not_factor_of_total(self, generated_rows, _):
       fields:
         Amount: ${{child_value}}
         """
-        generate_data(StringIO(yaml))
+        generate_data(StringIO(yaml), seed=seed)
         values = generated_rows.table_values("Obj")
         results = [r["Amount"] for r in values]
         assert sum(results) == 63, results
         assert len([r for r in results if r < 5]) <= 1, results
 
-    def test_max(self, generated_rows, _):
+    def test_max(self, generated_rows, seed):
         yaml = """
     - plugin: snowfakery.standard_plugins.Math
     - object: Obj
@@ -121,9 +125,25 @@ def test_max(self, generated_rows, _):
       fields:
         Amount: ${{child_value}}
         """
-        generate_data(StringIO(yaml))
+        generate_data(StringIO(yaml), seed=seed)
         values = generated_rows.table_values("Obj")
         results = [r["Amount"] for r in values]
         assert sum(results) == 28, results
         assert not [r for r in results if r % 2], results
         assert not [r for r in results if r > 6], results
+
+    def test_bad_step(self, generated_rows, seed):
+        yaml = """
+    - plugin: snowfakery.standard_plugins.Math
+    - object: Obj
+      for_each:
+        var: child_value
+        value:
+          Math.random_partition:
+            total: 28
+            step: 0.3
+      fields:
+        Amount: ${{child_value}}
+        """
+        with pytest.raises(DataGenError, match="step.*0.3"):
+            generate_data(StringIO(yaml), seed=seed)