From c68683efbcb18ebc4ce62e563c3d98e6324ce0f6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Milo=C5=A1=20Prchl=C3=ADk?= <mprchlik@redhat.com>
Date: Fri, 9 Jan 2026 10:14:45 +0100
Subject: [PATCH 1/5] Plugin envvars take effect even when plugin is not
 mentioned on CLI

This was a major drawback when using envvars to populate or change
phases' configuration: plugin-specific envvars had no effect unless the
plugin was invoked via command line. This was caused by Click consuming
them, and without mentioning the plugin on command line, Click was not
invoked, therefore nothing consumed said envvars.

The patch adds one more pass into the application of CLI invocations
where we collect all these envvars, and then we use Click to process
them. The produced values are then added into raw step data.

We do not use custom parsers or type casting, we identify the plugin in
question from the envvar name, and use its Click command and its
parameters to perform the necessary steps for us. This should be
equivalent to what Click does when crunching the command line.
---
 tmt/steps/__init__.py | 104 ++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 104 insertions(+)

diff --git a/tmt/steps/__init__.py b/tmt/steps/__init__.py
index 22fe13c46b..e248484eaf 100644
--- a/tmt/steps/__init__.py
+++ b/tmt/steps/__init__.py
@@ -61,6 +61,7 @@
     Command,
     CommandOutput,
     Environment,
+    EnvVarName,
     EnvVarValue,
     GeneralError,
     HasPhaseWorkdir,
@@ -132,6 +133,11 @@
 
 CODE_BLOCK_REGEXP = re.compile(r"^\s*\.\. code-block::.*$\n", re.MULTILINE)
 
+#: A regular expression to cut the special, plugin-specific environment
+#: variable names into their components: step, plugin, and option names.
+PLUGIN_ENVIRONMENT_VARIABLE_NAME_PATTERN = re.compile(
+    r'TMT_PLUGIN_(?P<step>[A-Z]+)_(?P<plugin>[A-Z]+)_(?P<option>[A-Z_]+)'
+)
 
 PHASE_OPTIONS = tmt.options.create_options_decorator(
     [
@@ -1026,6 +1032,37 @@ def _iter_options() -> Iterator[tuple[str, Any]]:
         # and we will get back to them once we're done with those we can apply immediately.
         postponed_invocations: list[tmt.cli.CliInvocation] = []
 
+        # A container of all plugin-specific environment variables. Here we collect all
+        # plugin-specific environment variables, and separate them into buckets per plugin. Note
+        # that we do not care about *phases* - there is no way to apply environment variable to
+        # one specific phase, they are very strong and affect all phases spawned from the same
+        # plugin, i.e. with the same `how`.
+        environment_invocations: dict[str, dict[str, tuple[EnvVarName, EnvVarValue]]] = (
+            collections.defaultdict(dict)
+        )
+
+        for envvar_name, envvar_value in Environment.from_environ().items():
+            # Skip all environment variables not matching the special pattern...
+            match = PLUGIN_ENVIRONMENT_VARIABLE_NAME_PATTERN.match(envvar_name)
+
+            if not match:
+                continue
+
+            # ... or for different step. Neither of these groups is interesting here and now.
+            step_name = match.group(1).lower()
+
+            if step_name != self.step_name:
+                continue
+
+            # Since the environment variable names are upper-cased only, plugin and field names
+            # require a bit of character manipulation. Note that the field name does not need the
+            # `_` -> `-` swap: fmf keys use `-`, Python fields and Click option names use `_` we
+            # already have.
+            plugin_name: str = match.group(2).lower().replace('_', '-')
+            param_name: str = match.group(3).lower()
+
+            environment_invocations[plugin_name][param_name] = (envvar_name, envvar_value)
+
         name_generator = DefaultNameGenerator.from_raw_phases(raw_data)
 
         def _ensure_name(raw_datum: _RawStepData) -> _RawStepData:
@@ -1243,6 +1280,73 @@ def _patch_raw_datum(
 
             raw_data = pruned_raw_data
 
+        # Third pass, apply environment variables
+        for i, (how, plugin_environment) in enumerate(environment_invocations.items()):
+            debug2(f'environment invocation #{i}', f'{how}: {plugin_environment}')
+
+            original_environment_variable_names = [
+                envvar_name for (envvar_name, _) in plugin_environment.values()
+            ]
+
+            # We do not want to invent our custom parsers. Instead, we need to reach the Click
+            # command of our plugin, because that command already knows how to handle its input.
+            # This requires a bit of traversal. Get the right plugin class, then its command, and
+            # then its parameters.
+            plugin_class = self._plugin_base_class._supported_methods.get_plugin(how)
+
+            if plugin_class is None:
+                self.warn(
+                    f"Found environment variables for plugin '{self.step_name}/{how}',"
+                    " but the plugin was not found. The following environment variables"
+                    " will have no effect:"
+                )
+
+                self.warn(fmf.utils.listed(original_environment_variable_names))
+
+                continue
+
+            plugin_command = plugin_class.class_.command()
+            plugin_context = plugin_command.make_context(info_name=None, args=[])
+
+            # Apparently, Click does not offer a mapping between option names and their
+            # `click.Parameter` descriptions. We shall build our own then, we will need it.
+            plugin_params = {param.name: param for param in plugin_command.params}
+
+            # Now, traverse all raw data, skip those for different plugins, and update the suitable
+            # ones with values coming from the environment variables.
+            for j, raw_datum in enumerate(raw_data):
+                debug3(f'raw step datum #{j}', str(raw_datum))
+
+                compatible_raw_data = [
+                    raw_datum for raw_datum in raw_data if raw_datum.get('how') == how
+                ]
+
+                if not compatible_raw_data:
+                    self.warn(
+                        f"Found environment variables for plugin '{self.step_name}/{how}',"
+                        f" but the plugin is not used by the plan '{self.plan.name}'. The"
+                        " following environment variables will have no effect:"
+                    )
+
+                    self.warn(fmf.utils.listed(original_environment_variable_names))
+
+                    continue
+
+                for param_name, (envvar_name, envvar_value) in plugin_environment.items():
+                    debug4('raw environment variable', f'{envvar_name}={envvar_value}')
+
+                    plugin_param = plugin_params.get(param_name)
+
+                    if plugin_param is None:
+                        raise GeneralError(
+                            f"Failed to find the key '{param_name.replace('_', '-')}'"
+                            " of the '{self.step_name}/{how}' plugin."
+                        )
+
+                    raw_datum[param_name] = plugin_param.type_cast_value(  # type: ignore[literal-required]
+                        plugin_context, str(envvar_value)
+                    )
+
         # And bit of logging after re're done with CLI invocations
         for i, raw_datum in enumerate(raw_data):
             debug2(f'updated raw step datum #{i}', str(raw_datum))

From e32fcaba6bf32c0a18f41c3566f9a4b2a3bc6bc3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Milo=C5=A1=20Prchl=C3=ADk?= <mprchlik@redhat.com>
Date: Fri, 9 Jan 2026 12:07:05 +0100
Subject: [PATCH 2/5] squash: test and refactoring

---
 docs/overview.rst                          |  24 +--
 tests/cli/plugin-envvars/data/.fmf/version |   1 +
 tests/cli/plugin-envvars/data/main.fmf     |  10 ++
 tests/cli/plugin-envvars/main.fmf          |   4 +
 tests/cli/plugin-envvars/test.sh           |  47 ++++++
 tmt/steps/__init__.py                      | 170 +++++++++++----------
 6 files changed, 155 insertions(+), 101 deletions(-)
 create mode 100644 tests/cli/plugin-envvars/data/.fmf/version
 create mode 100644 tests/cli/plugin-envvars/data/main.fmf
 create mode 100644 tests/cli/plugin-envvars/main.fmf
 create mode 100755 tests/cli/plugin-envvars/test.sh

diff --git a/docs/overview.rst b/docs/overview.rst
index bd52ef878e..19da2b135f 100644
--- a/docs/overview.rst
+++ b/docs/overview.rst
@@ -734,7 +734,7 @@ belongs to, and the option name:
 
     ``TMT_PLUGIN_${STEP}_${PLUGIN}_${OPTION}``
 
-All values are upper-cased, with dashes (``-``) replaced by
+All names are upper-cased, with dashes (``-``) replaced by
 underscores (``_``).
 
 For example, an execute plugin "tmt" would run with verbosity
@@ -762,29 +762,11 @@ The following commands would override the URL::
 
     TMT_PLUGIN_DISCOVER_FMF_URL=https://actual.org/ tmt run ...
 
-For setting flag-like option, 0 and 1 are the expected value. For
-example, an interactive mode would be enabled in this run::
+For setting flag-like option, ``0`` and ``1`` are the expected values.
+For example, an interactive mode would be enabled in this run::
 
     TMT_PLUGIN_EXECUTE_TMT_INTERACTIVE=1 tmt run ... execute -h tmt ...
 
-.. note::
-
-   The following applies to situations when a plugin is specified
-   on the command line only. Keys of plugins specified in fmf files
-   would not be modified. This is a limit of the current implementation,
-   and will be addressed in the future::
-
-      # Here the verbosity will not be increased since the plugin is
-      # not mentioned on the command line:
-      $ TMT_PLUGIN_DISCOVER_FMF_VERBOSE=2 tmt run -a
-
-      # Here the environment variable will take effect:
-      $ TMT_PLUGIN_DISCOVER_FMF_VERBOSE=2 tmt run -a discover -h fmf ...
-
-   Several plugins (``report -h reportportal``, ``report -h polarion``,
-   ``execute -h tmt``) allow selected variables to be processed,
-   even when plugin is not specified on the command line.
-
 .. _regular-expressions:
 
 Regular Expressions
diff --git a/tests/cli/plugin-envvars/data/.fmf/version b/tests/cli/plugin-envvars/data/.fmf/version
new file mode 100644
index 0000000000..d00491fd7e
--- /dev/null
+++ b/tests/cli/plugin-envvars/data/.fmf/version
@@ -0,0 +1 @@
+1
diff --git a/tests/cli/plugin-envvars/data/main.fmf b/tests/cli/plugin-envvars/data/main.fmf
new file mode 100644
index 0000000000..2944d6e72b
--- /dev/null
+++ b/tests/cli/plugin-envvars/data/main.fmf
@@ -0,0 +1,10 @@
+provision:
+  how: local
+
+execute:
+  script: /bin/true
+
+report:
+  - how: html
+    absolute-paths: false
+    display-guest: auto
diff --git a/tests/cli/plugin-envvars/main.fmf b/tests/cli/plugin-envvars/main.fmf
new file mode 100644
index 0000000000..fbc7d6aa54
--- /dev/null
+++ b/tests/cli/plugin-envvars/main.fmf
@@ -0,0 +1,4 @@
+summary: Verify some basic output of `tmt about`
+
+tag+:
+  - provision-local
diff --git a/tests/cli/plugin-envvars/test.sh b/tests/cli/plugin-envvars/test.sh
new file mode 100755
index 0000000000..70bac92227
--- /dev/null
+++ b/tests/cli/plugin-envvars/test.sh
@@ -0,0 +1,47 @@
+#!/bin/bash
+. /usr/share/beakerlib/beakerlib.sh || exit 1
+
+rlJournalStart
+    rlPhaseStartSetup
+        rlRun "set -o pipefail"
+        rlRun "export LANG=C"
+        rlRun "rundir=$(mktemp -d)"
+
+        rlRun "pushd data"
+    rlPhaseEnd
+
+    rlPhaseStartTest "Foo"
+        rlRun "run_tmt=\"tmt -vvv --feeling-safe --log-topic=cli-invocations run --id $rundir --scratch\""
+
+        rlRun -s "$run_tmt"
+        rlAssertGrep "ReportPlugin.delegate\(step=report, data=None, raw_data=\{'how': 'html', 'absolute-paths': False, 'display-guest': 'auto', 'name': 'default-0'\}\)" $rundir/log.txt -E
+
+        rlRun -s "TMT_PLUGIN_REPORT_HTML_ABSOLUTE_PATHS=1 TMT_PLUGIN_REPORT_HTML_FILE=/tmp/foo TMT_PLUGIN_REPORT_HTML_DISPLAY_GUEST=never $run_tmt"
+        rlAssertGrep "ReportPlugin.delegate\(step=report, data=None, raw_data=\{'how': 'html', 'absolute-paths': True, 'display-guest': 'never', 'name': 'default-0', 'file': '/tmp/foo'\}\)" $rundir/log.txt -E
+    rlPhaseEnd
+
+    rlPhaseStartTest "Verify unknown plugins are reported"
+        rlRun -s "TMT_PLUGIN_REPORT_XHTML_DISPLAY_GUEST=never $run_tmt"
+
+        rlAssertGrep "warn: Found environment variables for plugin 'report/xhtml', but the plugin was not found. The following environment variables will have no effect:" $rlRun_LOG
+        rlAssertGrep "warn: TMT_PLUGIN_REPORT_XHTML_DISPLAY_GUEST" $rlRun_LOG
+    rlPhaseEnd
+
+    rlPhaseStartTest "Verify unused envvars are reported"
+        rlRun -s "TMT_PLUGIN_REPORT_DISPLAY_DISPLAY_GUEST=never $run_tmt"
+
+        rlAssertGrep "warn: Found environment variables for plugin 'report/display', but the plugin is not used by the plan '/'. The following environment variables will have no effect:" $rlRun_LOG
+        rlAssertGrep "warn: TMT_PLUGIN_REPORT_DISPLAY_DISPLAY_GUEST" $rlRun_LOG
+    rlPhaseEnd
+
+    rlPhaseStartTest "Verify unknown options are reported"
+        rlRun -s "TMT_PLUGIN_REPORT_HTML_HIDE_GUEST=never $run_tmt" 2
+
+        rlAssertGrep "Failed to find the 'hide-guest' key of the 'report/html' plugin." $rlRun_LOG
+    rlPhaseEnd
+
+    rlPhaseStartCleanup
+        rlRun "popd"
+        rlRun "rm -rf $rundir"
+    rlPhaseEnd
+rlJournalEnd
diff --git a/tmt/steps/__init__.py b/tmt/steps/__init__.py
index e248484eaf..4b4bacbd3d 100644
--- a/tmt/steps/__init__.py
+++ b/tmt/steps/__init__.py
@@ -1055,13 +1055,11 @@ def _iter_options() -> Iterator[tuple[str, Any]]:
                 continue
 
             # Since the environment variable names are upper-cased only, plugin and field names
-            # require a bit of character manipulation. Note that the field name does not need the
-            # `_` -> `-` swap: fmf keys use `-`, Python fields and Click option names use `_` we
-            # already have.
+            # require a bit of character manipulation.
             plugin_name: str = match.group(2).lower().replace('_', '-')
-            param_name: str = match.group(3).lower()
+            option_name: str = key_to_option(match.group(3).lower())
 
-            environment_invocations[plugin_name][param_name] = (envvar_name, envvar_value)
+            environment_invocations[plugin_name][option_name] = (envvar_name, envvar_value)
 
         name_generator = DefaultNameGenerator.from_raw_phases(raw_data)
 
@@ -1133,10 +1131,88 @@ def _patch_raw_datum(
             self.plan._applied_cli_invocations.append(invocation)
 
         # A bit of logging before we start messing with step data
-        for i, raw_datum in enumerate(raw_data):
-            debug2(f'raw step datum #{i}', str(raw_datum))
+        def _log_raw_data(stage: str, raw_data: list[_RawStepData]) -> None:
+            debug2(f'stage {stage}')
+
+            for i, raw_datum in enumerate(raw_data):
+                debug3(f'raw step datum #{i}', str(raw_datum))
+
+        how: Optional[str]
+
+        _log_raw_data('before', raw_data)
+
+        # First pass, apply environment variables
+        for i, (how, plugin_environment) in enumerate(environment_invocations.items()):
+            debug2(f'environment invocation #{i}', f'{how}: {plugin_environment}')
+
+            original_environment_variable_names = [
+                envvar_name for (envvar_name, _) in plugin_environment.values()
+            ]
+
+            # We do not want to invent our custom parsers. Instead, we need to reach the Click
+            # command of our plugin, because that command already knows how to handle its input.
+            # This requires a bit of traversal. Get the right plugin class, then its command, and
+            # then its parameters.
+            plugin_class = self._plugin_base_class._supported_methods.get_plugin(how)
+
+            if plugin_class is None:
+                self.warn(
+                    f"Found environment variables for plugin '{self.step_name}/{how}',"
+                    " but the plugin was not found. The following environment variables"
+                    " will have no effect:"
+                )
+
+                self.warn(fmf.utils.listed(original_environment_variable_names))
+
+                continue
+
+            plugin_command = plugin_class.class_.command()
+            plugin_context = plugin_command.make_context(info_name=None, args=[])
+
+            # Apparently, Click does not offer a mapping between option names and their
+            # `click.Parameter` descriptions. We shall build our own then, we will need it.
+            plugin_params = {param.name: param for param in plugin_command.params}
+
+            # Now, traverse all raw data, skip those for different plugins, and update the suitable
+            # ones with values coming from the environment variables.
+            for j, raw_datum in enumerate(raw_data):
+                debug3(f'raw step datum #{j}', str(raw_datum))
+
+                compatible_raw_data = [
+                    raw_datum for raw_datum in raw_data if raw_datum.get('how') == how
+                ]
+
+                if not compatible_raw_data:
+                    self.warn(
+                        f"Found environment variables for plugin '{self.step_name}/{how}',"
+                        f" but the plugin is not used by the plan '{self.plan.name}'. The"
+                        " following environment variables will have no effect:"
+                    )
+
+                    self.warn(fmf.utils.listed(original_environment_variable_names))
+
+                    continue
+
+                for option_name, (envvar_name, envvar_value) in plugin_environment.items():
+                    debug4('raw environment variable', f'{envvar_name}={envvar_value}')
+
+                    param_name = option_to_key(option_name)
+
+                    plugin_param = plugin_params.get(param_name)
+
+                    if plugin_param is None:
+                        raise GeneralError(
+                            f"Failed to find the '{param_name.replace('_', '-')}' key"
+                            f" of the '{self.step_name}/{how}' plugin."
+                        )
+
+                    raw_datum[key_to_option(param_name)] = plugin_param.type_cast_value(  # type: ignore[literal-required]
+                        plugin_context, str(envvar_value)
+                    )
+
+        _log_raw_data('after environment invocations', raw_data)
 
-        # The first pass, apply CLI invocations that can be applied
+        # Second pass, apply CLI invocations that can be applied
         for i, invocation in enumerate(self.__class__.cli_invocations):
             debug2(f'invocation #{i}', str(invocation.options))
 
@@ -1144,7 +1220,7 @@ def _patch_raw_datum(
                 debug3('already applied')
                 continue
 
-            how: Optional[str] = invocation.options.get('how')
+            how = cast(Optional[str], invocation.options.get('how'))
 
             if how is None:
                 debug3('how-less phase (postponed)')
@@ -1220,7 +1296,9 @@ def _patch_raw_datum(
 
                 postponed_invocations.append(invocation)
 
-        # The second pass, evaluate postponed CLI invocations
+        _log_raw_data('after targeted CLI invocations', raw_data)
+
+        # Third pass, evaluate postponed CLI invocations
         for i, invocation in enumerate(postponed_invocations):
             debug2(f'postponed invocation #{i}', str(invocation.options))
 
@@ -1231,7 +1309,7 @@ def _patch_raw_datum(
             # preferred image name without specifying the provision
             # method, thus the 'how' key can be unset and we respect the
             # provision method specified in the plan.
-            how = invocation.options.get('how')
+            how = cast(Optional[str], invocation.options.get('how'))
 
             for j, raw_datum in enumerate(raw_data):
                 debug2(f'raw step datum #{j}', str(raw_datum))
@@ -1280,76 +1358,8 @@ def _patch_raw_datum(
 
             raw_data = pruned_raw_data
 
-        # Third pass, apply environment variables
-        for i, (how, plugin_environment) in enumerate(environment_invocations.items()):
-            debug2(f'environment invocation #{i}', f'{how}: {plugin_environment}')
-
-            original_environment_variable_names = [
-                envvar_name for (envvar_name, _) in plugin_environment.values()
-            ]
-
-            # We do not want to invent our custom parsers. Instead, we need to reach the Click
-            # command of our plugin, because that command already knows how to handle its input.
-            # This requires a bit of traversal. Get the right plugin class, then its command, and
-            # then its parameters.
-            plugin_class = self._plugin_base_class._supported_methods.get_plugin(how)
-
-            if plugin_class is None:
-                self.warn(
-                    f"Found environment variables for plugin '{self.step_name}/{how}',"
-                    " but the plugin was not found. The following environment variables"
-                    " will have no effect:"
-                )
-
-                self.warn(fmf.utils.listed(original_environment_variable_names))
-
-                continue
-
-            plugin_command = plugin_class.class_.command()
-            plugin_context = plugin_command.make_context(info_name=None, args=[])
-
-            # Apparently, Click does not offer a mapping between option names and their
-            # `click.Parameter` descriptions. We shall build our own then, we will need it.
-            plugin_params = {param.name: param for param in plugin_command.params}
-
-            # Now, traverse all raw data, skip those for different plugins, and update the suitable
-            # ones with values coming from the environment variables.
-            for j, raw_datum in enumerate(raw_data):
-                debug3(f'raw step datum #{j}', str(raw_datum))
-
-                compatible_raw_data = [
-                    raw_datum for raw_datum in raw_data if raw_datum.get('how') == how
-                ]
-
-                if not compatible_raw_data:
-                    self.warn(
-                        f"Found environment variables for plugin '{self.step_name}/{how}',"
-                        f" but the plugin is not used by the plan '{self.plan.name}'. The"
-                        " following environment variables will have no effect:"
-                    )
-
-                    self.warn(fmf.utils.listed(original_environment_variable_names))
-
-                    continue
-
-                for param_name, (envvar_name, envvar_value) in plugin_environment.items():
-                    debug4('raw environment variable', f'{envvar_name}={envvar_value}')
-
-                    plugin_param = plugin_params.get(param_name)
-
-                    if plugin_param is None:
-                        raise GeneralError(
-                            f"Failed to find the key '{param_name.replace('_', '-')}'"
-                            " of the '{self.step_name}/{how}' plugin."
-                        )
-
-                    raw_datum[param_name] = plugin_param.type_cast_value(  # type: ignore[literal-required]
-                        plugin_context, str(envvar_value)
-                    )
-
         # And bit of logging after re're done with CLI invocations
-        for i, raw_datum in enumerate(raw_data):
-            debug2(f'updated raw step datum #{i}', str(raw_datum))
+        _log_raw_data('after general CLI invocations', raw_data)
 
         raw_data = self._set_default_names(raw_data)
         return self._set_default_how(raw_data)

From 6f4570da84e1f9bf78d5480aaf9e155cdb747d07 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Milo=C5=A1=20Prchl=C3=ADk?= <mprchlik@redhat.com>
Date: Fri, 9 Jan 2026 13:10:37 +0100
Subject: [PATCH 3/5] squash: fix issue

---
 tmt/steps/__init__.py | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/tmt/steps/__init__.py b/tmt/steps/__init__.py
index 4b4bacbd3d..73e8596a46 100644
--- a/tmt/steps/__init__.py
+++ b/tmt/steps/__init__.py
@@ -1173,25 +1173,25 @@ def _log_raw_data(stage: str, raw_data: list[_RawStepData]) -> None:
             # `click.Parameter` descriptions. We shall build our own then, we will need it.
             plugin_params = {param.name: param for param in plugin_command.params}
 
-            # Now, traverse all raw data, skip those for different plugins, and update the suitable
+            # Now, traverse the raw data, skip those for different plugins, and update the suitable
             # ones with values coming from the environment variables.
-            for j, raw_datum in enumerate(raw_data):
-                debug3(f'raw step datum #{j}', str(raw_datum))
+            compatible_raw_data = [
+                raw_datum for raw_datum in raw_data if raw_datum.get('how') == how
+            ]
 
-                compatible_raw_data = [
-                    raw_datum for raw_datum in raw_data if raw_datum.get('how') == how
-                ]
+            if not compatible_raw_data:
+                self.warn(
+                    f"Found environment variables for plugin '{self.step_name}/{how}',"
+                    f" but the plugin is not used by the plan '{self.plan.name}'. The"
+                    " following environment variables will have no effect:"
+                )
 
-                if not compatible_raw_data:
-                    self.warn(
-                        f"Found environment variables for plugin '{self.step_name}/{how}',"
-                        f" but the plugin is not used by the plan '{self.plan.name}'. The"
-                        " following environment variables will have no effect:"
-                    )
+                self.warn(fmf.utils.listed(original_environment_variable_names))
 
-                    self.warn(fmf.utils.listed(original_environment_variable_names))
+                continue
 
-                    continue
+            for j, raw_datum in enumerate(compatible_raw_data):
+                debug3(f'raw step datum #{j}', str(raw_datum))
 
                 for option_name, (envvar_name, envvar_value) in plugin_environment.items():
                     debug4('raw environment variable', f'{envvar_name}={envvar_value}')

From 25eecb3d9e4a68dc488556056fa3bdcfdbc9bc5f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Milo=C5=A1=20Prchl=C3=ADk?= <mprchlik@redhat.com>
Date: Fri, 9 Jan 2026 15:42:43 +0100
Subject: [PATCH 4/5] squash; fixing tests

---
 docs/releases/pending/4472.fmf        | 8 ++++++++
 tests/execute/ignore-duration/test.sh | 8 ++------
 2 files changed, 10 insertions(+), 6 deletions(-)
 create mode 100644 docs/releases/pending/4472.fmf

diff --git a/docs/releases/pending/4472.fmf b/docs/releases/pending/4472.fmf
new file mode 100644
index 0000000000..6b6c4999a2
--- /dev/null
+++ b/docs/releases/pending/4472.fmf
@@ -0,0 +1,8 @@
+description: |
+  tmt now correctly applies :ref:`/overview/plugin-variables` even when
+  plugin is not mentioned on the command line. This has been a limit
+  imposed by tmt implementation, where only phases of plugins explicitly
+  mentioned were modified by environment. For example, ``tmt run report
+  -h html`` would ignore every ``TMT_PLUGIN_REPORT_*`` environment
+  variable except those for the ``html`` plugin, ``TMT_PLUGIN_REPORT_HTML_*``.
+  This limitation has been removed.
diff --git a/tests/execute/ignore-duration/test.sh b/tests/execute/ignore-duration/test.sh
index a9bdc808c9..14f9dc6e48 100755
--- a/tests/execute/ignore-duration/test.sh
+++ b/tests/execute/ignore-duration/test.sh
@@ -25,17 +25,13 @@ rlJournalStart
         export TMT_PLUGIN_EXECUTE_TMT_IGNORE_DURATION=1
         rlRun "tmt run -vv plan -n /no-option"
         rlRun "tmt run -vv plan -n /via-plan-true"
-        # ENV should win over CLI or file values, but to be consistent with
-        # reporportal/polarion plugin envar is weaker than plan.fmf
-        rlRun "tmt run -vv plan -n /via-plan-false" "2"
+        rlRun "tmt run -vv plan -n /via-plan-false"
     rlPhaseEnd
 
     rlPhaseStartTest "With IGNORE_DURATION=0"
         export TMT_PLUGIN_EXECUTE_TMT_IGNORE_DURATION=0
         rlRun "tmt run -vv plan -n /no-option" "2"
-        # ENV should win over CLI or file values, but to be consistent with
-        # reporportal/polarion plugin envar is weaker than plan.fmf
-        rlRun "tmt run -vv plan -n /via-plan-true"
+        rlRun "tmt run -vv plan -n /via-plan-true" "2"
         rlRun "tmt run -vv plan -n /via-plan-false" "2"
     rlPhaseEnd
 

From 569e2adddb8c52d7a54cd54c80840a420f94847d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Milo=C5=A1=20Prchl=C3=ADk?= <mprchlik@redhat.com>
Date: Fri, 9 Jan 2026 15:55:16 +0100
Subject: [PATCH 5/5] squash: fix docs

---
 docs/releases/pending/4472.fmf | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/docs/releases/pending/4472.fmf b/docs/releases/pending/4472.fmf
index 6b6c4999a2..6077963bf9 100644
--- a/docs/releases/pending/4472.fmf
+++ b/docs/releases/pending/4472.fmf
@@ -1,5 +1,5 @@
 description: |
-  tmt now correctly applies :ref:`/overview/plugin-variables` even when
+  tmt now correctly applies :ref:`plugin-variables` even when
   plugin is not mentioned on the command line. This has been a limit
   imposed by tmt implementation, where only phases of plugins explicitly
   mentioned were modified by environment. For example, ``tmt run report