add option_given method to BasicProcessor

Author: dale-wahl

backend/lib/processor.py

@@ -200,12 +200,16 @@ def work(self):
 
         # build the single runtime view of this dataset's parameters: every
         # stored parameter, plus the declared default for any option that was
-        # not stored. Worker code should read options from self.parameters
-        # only, and not re-read them from the dataset mid-run — stored
-        # parameters may change during a run, but this dictionary stays
-        # complete and stable.
+        # not stored, so worker code can read any declared option without
+        # checking whether it exists. The stored parameters themselves are
+        # kept as self.given_parameters: they hold only the options that were
+        # actually part of the submission (see option_given()). Worker code
+        # should read options from self.parameters, and not re-read them from
+        # the dataset mid-run — stored parameters may change during a run,
+        # but these dictionaries stay stable.
         given_parameters = self.dataset.parameters.copy()
         all_parameters = self.get_options(self.source_dataset, config=self.config)
+        self.given_parameters = given_parameters
         self.parameters = {
             param: given_parameters.get(param, all_parameters.get(param, {}).get("default"))
             for param in [*all_parameters.keys(), *given_parameters.keys()]
@@ -438,6 +442,29 @@ def after_process(self):
                 except (SMTPException, ConnectionRefusedError, socket.timeout):
                     self.log.error("Error sending email to %s" % owner)
 
+    def option_given(self, option):
+        """
+        Check whether an option was actually part of this dataset's submission
+
+        `self.parameters` always contains every option this worker declares,
+        with defaults filled in for anything that was not stored. That is
+        convenient for reading values, but it cannot tell you whether the
+        option was really part of the submission. This method can: it checks
+        the parameters as they were stored when the dataset was created. For
+        datasets queued via the web interface, an option is only stored if
+        the user could see it when submitting (i.e. its `requires` condition
+        was met); for datasets queued by other code (e.g. presets), an option
+        is only stored if the calling code explicitly set it.
+
+        Note that a stored option may still hold its default value: a user
+        who saw an option and left it untouched still counts as having been
+        given it.
+
+        :param str option:  Option name, as used in `get_options()`
+        :return bool:  Whether the option was part of the stored parameters
+        """
+        return option in self.given_parameters
+
     def clean_up_on_error(self):
         try:
             # ensure proxied requests are stopped
@@ -1087,7 +1114,8 @@ def validate_query(query, request, config):
         marked `sensitive` are removed from the stored record when the dataset
         starts running. At run time, the worker reads all of this back through
         `self.parameters`, with declared option defaults filled in for any
-        missing keys.
+        missing keys; `option_given()` tells a worker whether an option was
+        really part of the stored submission.
 
         By default nothing is checked and the input is stored as-is. Search
         workers must define their own version: doing so is what makes a

tests/test_modules.py

@@ -485,6 +485,39 @@ def test_option_declarations(logger, fourcat_modules, mock_dataset, mock_basic_c
         logger.info("All option declarations look consistent.")
 
 
+def test_parse_all_gated_options():
+    """
+    Options with a "requires" condition are only part of the parsed input when
+    their condition is met - whether or not the (hidden) form field was
+    submitted. This keeps the stored parameters honest: a missing key means
+    the user never saw the option, a present key means they chose a value or
+    its default applies. At run time, self.parameters fills every declared
+    option regardless (so plain reads are always safe); the stored honesty is
+    exposed to workers through BasicProcessor.option_given().
+    """
+    from common.lib.user_input import UserInput
+
+    options = {
+        "gate": {"type": UserInput.OPTION_TOGGLE, "default": False},
+        "gated": {"type": UserInput.OPTION_TEXT, "default": ",", "requires": "gate==true"},
+        "gated_toggle": {"type": UserInput.OPTION_TOGGLE, "default": True, "requires": "gate==true"},
+        "plain": {"type": UserInput.OPTION_TEXT, "default": "x"},
+    }
+
+    # gate off, gated fields not submitted: gated options are absent, not defaulted
+    parsed = UserInput.parse_all(options, {"option-plain": "y"})
+    assert parsed == {"gate": False, "plain": "y"}
+
+    # gate off, gated field submitted anyway (e.g. hidden field still posts):
+    # still absent
+    parsed = UserInput.parse_all(options, {"option-gated": ";"})
+    assert "gated" not in parsed and "gated_toggle" not in parsed
+
+    # gate on: gated options are parsed (submitted value) or defaulted (absent)
+    parsed = UserInput.parse_all(options, {"option-gate": "on", "option-gated": ";"})
+    assert parsed["gated"] == ";" and parsed["gated_toggle"] is False and parsed["gate"] is True
+
+
 def test_dataset_finish_raises_on_double_finish(mock_dataset):
     """
     Regression guard for common/lib/dataset.py:986.