Repository: teemtee/tmt (language: python)

Issue:
Enable the full test suite for pull requests
We'd like to move the whole coverage of `/tests/full` into pull request testing. This issue will track the progress of the migration.

Related pull requests:

* #2558
* #2222 
* #2688 
* #2700 
* #2701 

Additional coverage which is run only with `how=full` follows:

### Tagged with `additional_coverage`

* [x] /tests/core/escaping
* [x] /tests/core/spaces
* [x] /tests/discover/distgit
* [x] /tests/discover/libraries
* [x] /tests/execute/duration
* [x] /tests/execute/nonroot
* [x] /tests/execute/reboot/reuse-provision
* [x] /tests/execute/reboot/shorten-timeout
* [x] /tests/execute/rsync
* [x] /tests/execute/tty
* [x] /tests/execute/upgrade/full
* [x] /tests/finish/ansible
* [x] /tests/login/ready
* [x] /tests/multihost/web
* [x] /tests/prepare/ansible
* [x] /tests/prepare/install
* [x] /tests/prepare/recommend
* [x] /tests/provision/reboot
* [x] /tests/provision/ssh-options
* [x] /tests/provision/virtual.testcloud
* [x] /tests/pull/results
* [x] /tests/pull/simple
* [x] /tests/run/shell
* [x] /tests/run/worktree
* [x] /tests/security/ansible
* [x] /tests/test/check/avc
* [x] /tests/test/check/dmesg
* [x] /tests/test/debug

### /plans/features/advanced
* [x] /tests/execute/reboot/reuse-provision
* [x] /tests/execute/reboot/shorten-timeout
* [x] /tests/execute/upgrade/full
* [x] /tests/multihost/web

### /plans/features/steps/discover
* [x] /tests/discover/libraries


### /plans/features/steps/execute
* [x] /tests/execute/nonroot
* [x] /tests/execute/rsync

### /plans/features/steps/the-rest
* [x] /tests/provision/ssh-options
* [x] /tests/provision/virtual.testcloud

### smoke test for provision connect
* [x]  /tests/execute/reboot/reuse-provision


Discussion / hints:

Fix patch:
diff --git a/docs/contribute.rst b/docs/contribute.rst
index c5a8bcf13b..2b5a4a8069 100644
--- a/docs/contribute.rst
+++ b/docs/contribute.rst
@@ -215,11 +215,14 @@ versions. For example:
 Provision Methods
 ------------------------------------------------------------------
 
-Tests which exercise various provision methods should use the
-``PROVISION_METHODS`` environment variable to select which
-provision methods they can utilize during their execution. This
-variable is likely to have ``local`` set as the default value to
-execute directly on the test runner as the default scenario.
+Tests which exercise multiple provision methods should use the
+``PROVISION_HOW`` environment variable to select which provision
+method should be exercised during their execution. This variable
+is likely to have ``local`` set as the default value in the test
+script to execute directly on the test runner as the default
+scenario. If a test does not support the ``local`` provision
+method make sure to use the ``provision-only`` tag so that the
+test in question is excluded from the regular plans.
 
 The following tags can be used to enable given test under the
 respective provision method plan:
diff --git a/plans/features/steps.fmf b/plans/features/steps.fmf
index 1189b69ed8..48ff9b63aa 100644
--- a/plans/features/steps.fmf
+++ b/plans/features/steps.fmf
@@ -14,15 +14,9 @@ discover:
     discover+:
         test: "^/tests/prepare"
     prepare+:
-      - name: Refresh dnf cache to speed up execution
-        how: shell
-        script: |
-            podman run -itd --name fresh-fedora fedora
-            podman exec fresh-fedora dnf makecache
-            podman commit fresh-fedora fedora
-            podman run -itd --name fresh-centos centos:stream8
-            podman exec fresh-centos dnf makecache
-            podman commit fresh-centos centos:stream8
+      - name: dnf-cache
+        summary: Fetch dnf cache to speed up the test execution
+        script: prepare/podman-images.sh
 
 /execute:
     discover+:
diff --git a/plans/provision/container.fmf b/plans/provision/container.fmf
index 16ea66e699..74881431a7 100644
--- a/plans/provision/container.fmf
+++ b/plans/provision/container.fmf
@@ -1,8 +1,24 @@
-summary: Run tests in a container
+summary: Verify the container provision plugin
+
+description: |
+    Run tests which exercise various features of the podman plugin
+    even if not directly related to the provision implementation.
+
+    The plan takes care of fetching the images to speed up the
+    execution. Each test should set the `provision-container` tag
+    to get picked by the plan, consume the `PROVISION_HOW`
+    variable and use `provision --how container` on their own.
+
 discover:
     how: fmf
-    filter: 'tag: container & tier: 1'
-provision:
-    how: container
-#    image: fedora
-#    pull: false
+    filter: 'tag:provision-container'
+
+prepare+:
+  - name: dnf-cache
+    summary: Fetch dnf cache to speed up the test execution
+    script: prepare/podman-images.sh
+
+environment:
+    PROVISION_HOW: container
+
+enabled: true
diff --git a/plans/provision/local.fmf b/plans/provision/local.fmf
new file mode 100644
index 0000000000..47cecf558d
--- /dev/null
+++ b/plans/provision/local.fmf
@@ -0,0 +1,22 @@
+summary: Verify the local provision plugin
+
+description: |
+    Run tests which exercise features of the local provision
+    plugin and need to be run under the root user so they are not
+    suitable to be run by default as part of the tier plans.
+
+    The plan takes care of fetching the images to speed up the
+    execution. Each test should set the `provision-local` tag
+    to get picked by the plan, consume the `PROVISION_HOW`
+    variable and use `provision --how local` on their own.
+
+discover:
+    how: fmf
+    filter: 'tag:provision-local'
+
+environment:
+    PROVISION_HOW: local
+
+adjust+:
+  - enabled: true
+    when: trigger == commit
diff --git a/prepare/podman-images.sh b/prepare/podman-images.sh
new file mode 100755
index 0000000000..70457bf710
--- /dev/null
+++ b/prepare/podman-images.sh
@@ -0,0 +1,36 @@
+#!/bin/bash
+#
+# Fetch dnf cache for the default set of container images
+# (or custom set provided in the IMAGES environment variable).
+# Retry three times to prevent random network issues.
+
+IMAGES=${IMAGES:-fedora centos:stream9}
+
+TOTAL=0
+SUCCESSFULL=0
+
+set -x
+
+for image in $IMAGES; do
+    TOTAL=$((TOTAL + 1))
+
+    for attempt in {1..3}; do
+        echo "Fetch container image '$image' attempt $attempt."
+
+        # Fetch the image, run `dnf makecache`, commit the image
+        podman rm -f fresh --time 0 &&
+        podman run -itd --name fresh --pull always "$image" &&
+        podman exec fresh dnf makecache &&
+        podman commit fresh "$image" &&
+
+        # Count success and break or sleep a bit before the next attempt
+        SUCCESSFULL=$((SUCCESSFULL + 1)) && break
+        sleep 3
+    done
+done
+
+set +x
+
+echo "Total: $TOTAL"
+echo "Successfull: $SUCCESSFULL"
+[[ "$SUCCESSFULL" == "$TOTAL" ]] && exit 0 || exit 1


Test patch:
diff --git a/tests/core/escaping/main.fmf b/tests/core/escaping/main.fmf
index 575391d3c2..4f8c4a8b18 100644
--- a/tests/core/escaping/main.fmf
+++ b/tests/core/escaping/main.fmf
@@ -6,7 +6,6 @@ description:
 test: ./test.sh
 framework: beakerlib
 tag-: [container, virtual]
-tag+: [provision-virtual]
-
-environment:
-    PROVISION_METHODS: local container
+tag+:
+  - provision-container
+  - provision-virtual
diff --git a/tests/core/escaping/test.sh b/tests/core/escaping/test.sh
index 34a2d85db2..f7c86dfa31 100755
--- a/tests/core/escaping/test.sh
+++ b/tests/core/escaping/test.sh
@@ -3,14 +3,13 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-local}"
         rlRun "pushd data"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-local}; do
-        rlPhaseStartTest "Test ($method)"
-            rlRun "tmt run -arvvv provision -h $method"
-        rlPhaseEnd
-    done
+    rlPhaseStartTest "Test ($PROVISION_HOW)"
+        rlRun "tmt run -arvvv provision --how $PROVISION_HOW"
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "popd"
diff --git a/tests/core/spaces/main.fmf b/tests/core/spaces/main.fmf
index fbf599a3a4..3fb78f5790 100644
--- a/tests/core/spaces/main.fmf
+++ b/tests/core/spaces/main.fmf
@@ -2,10 +2,7 @@ summary: Verify paths and names with white-space characters
 description:
     Ensure that test execution including workdir pull and push
     works as expected when file names and paths contain spaces.
-test: ./test.sh
-framework: beakerlib
 tag-: [container, virtual]
-tag+: [provision-virtual]
-
-environment:
-    PROVISION_METHODS: local container
+tag+:
+  - provision-container
+  - provision-virtual
diff --git a/tests/core/spaces/test.sh b/tests/core/spaces/test.sh
index 34a2d85db2..093b175436 100755
--- a/tests/core/spaces/test.sh
+++ b/tests/core/spaces/test.sh
@@ -3,14 +3,13 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-local}"
         rlRun "pushd data"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-local}; do
-        rlPhaseStartTest "Test ($method)"
-            rlRun "tmt run -arvvv provision -h $method"
-        rlPhaseEnd
-    done
+    rlPhaseStartTest "Test ($PROVISION_HOW)"
+        rlRun "tmt run -arvvv provision -h $PROVISION_HOW"
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "popd"
diff --git a/tests/execute/duration/main.fmf b/tests/execute/duration/main.fmf
index a5e309f0d5..b57af7429e 100644
--- a/tests/execute/duration/main.fmf
+++ b/tests/execute/duration/main.fmf
@@ -1,5 +1,5 @@
 summary: Verify that the test duration is correctly handled
-environment:
-    PROVISION_METHODS: "local container"
 duration: 20m
-tag+: [provision-virtual]
+tag+:
+  - provision-container
+  - provision-virtual
diff --git a/tests/execute/duration/test.sh b/tests/execute/duration/test.sh
index a966081839..de92ac5b09 100755
--- a/tests/execute/duration/test.sh
+++ b/tests/execute/duration/test.sh
@@ -3,69 +3,68 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-local}"
         rlRun "tmp=\$(mktemp -d)" 0 "Creating tmp directory"
         rlRun "pushd data"
     rlPhaseEnd
 
     for execute_method in tmt; do
-        for provision_method in ${PROVISION_METHODS:-local container}; do
-            for tty in "tty on default" "tty requested"; do
-                for interactive in "" "--interactive"; do
-                    if [ "$tty" = "tty requested" ]; then
-                        context="-c tty=true"
-                    else
-                        context=""
-                    fi
+        for tty in "tty on default" "tty requested"; do
+            for interactive in "" "--interactive"; do
+                if [ "$tty" = "tty requested" ]; then
+                    context="-c tty=true"
+                else
+                    context=""
+                fi
 
-                    rlPhaseStartTest "Test provision $provision_method, execute $execute_method, $tty, $interactive short tests"
-                        rlRun -s "tmt $context --log-topic=command-events run --scratch -vfi $tmp -a provision -h $provision_method execute -h $execute_method $interactive test --name short" 0
+                rlPhaseStartTest "Test provision $PROVISION_HOW, execute $execute_method, $tty, $interactive short tests"
+                    rlRun -s "tmt $context --log-topic=command-events run --scratch -vfi $tmp -a provision -h $PROVISION_HOW execute -h $execute_method $interactive test --name short" 0
 
-                        rlRun "grep 'duration \"5\" exceeded' $tmp/log.txt" 1
-                    rlPhaseEnd
+                    rlRun "grep 'duration \"5\" exceeded' $tmp/log.txt" 1
+                rlPhaseEnd
 
-                    rlPhaseStartTest "Test provision $provision_method, execute $execute_method, $tty, $interactive long tests"
-                        if [ "$interactive" = "" ]; then
-                            rlRun -s "tmt $context --log-topic=command-events run --scratch -vfi $tmp -a provision -h $provision_method execute -h $execute_method $interactive test --name long" 2
+                rlPhaseStartTest "Test provision $PROVISION_HOW, execute $execute_method, $tty, $interactive long tests"
+                    if [ "$interactive" = "" ]; then
+                        rlRun -s "tmt $context --log-topic=command-events run --scratch -vfi $tmp -a provision -h $PROVISION_HOW execute -h $execute_method $interactive test --name long" 2
 
-                            rlAssertNotGrep "warn: Ignoring requested duration, not supported in interactive mode." $rlRun_LOG
-                        else
-                            rlRun -s "tmt $context --log-topic=command-events run --scratch -vfi $tmp -a provision -h $provision_method execute -h $execute_method $interactive test --name long" 0
+                        rlAssertNotGrep "warn: Ignoring requested duration, not supported in interactive mode." $rlRun_LOG
+                    else
+                        rlRun -s "tmt $context --log-topic=command-events run --scratch -vfi $tmp -a provision -h $PROVISION_HOW execute -h $execute_method $interactive test --name long" 0
 
-                            rlAssertGrep "warn: Ignoring requested duration, not supported in interactive mode." $rlRun_LOG
-                        fi
+                        rlAssertGrep "warn: Ignoring requested duration, not supported in interactive mode." $rlRun_LOG
+                    fi
 
-                        rlAssertNotGrep "00:02:.. errr /test/long/beakerlib (timeout)" $rlRun_LOG
-                        rlAssertNotGrep "00:02:.. errr /test/long/shell (timeout)" $rlRun_LOG
+                    rlAssertNotGrep "00:02:.. errr /test/long/beakerlib (timeout)" $rlRun_LOG
+                    rlAssertNotGrep "00:02:.. errr /test/long/shell (timeout)" $rlRun_LOG
 
-                        if [ "$interactive" = "" ]; then
-                            rlRun -s "tmt --log-topic=command-events run --last report -fvvvv" 2
+                    if [ "$interactive" = "" ]; then
+                        rlRun -s "tmt --log-topic=command-events run --last report -fvvvv" 2
 
-                            rlAssertGrep "Maximum test time '5s' exceeded." $rlRun_LOG
-                            rlAssertGrep "Adjust the test 'duration' attribute" $rlRun_LOG
-                            rlAssertGrep "spec/tests.html#duration" $rlRun_LOG
+                        rlAssertGrep "Maximum test time '5s' exceeded." $rlRun_LOG
+                        rlAssertGrep "Adjust the test 'duration' attribute" $rlRun_LOG
+                        rlAssertGrep "spec/tests.html#duration" $rlRun_LOG
 
-                            rlRun -s "grep -A4 'duration \"5\" exceeded' $tmp/log.txt"
+                        rlRun -s "grep -A4 'duration \"5\" exceeded' $tmp/log.txt"
 
-                            rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ sent SIGKILL signal' $rlRun_LOG"
-                            rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ kill confirmed' $rlRun_LOG"
-                            rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ waiting for stream readers' $rlRun_LOG"
-                            rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ stdout reader done' $rlRun_LOG"
-                        else
-                            rlRun -s "tmt --log-topic=command-events run --last report -fvvvv" 0
+                        rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ sent SIGKILL signal' $rlRun_LOG"
+                        rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ kill confirmed' $rlRun_LOG"
+                        rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ waiting for stream readers' $rlRun_LOG"
+                        rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ stdout reader done' $rlRun_LOG"
+                    else
+                        rlRun -s "tmt --log-topic=command-events run --last report -fvvvv" 0
 
-                            rlAssertNotGrep "Maximum test time '5s' exceeded." $rlRun_LOG
-                            rlAssertNotGrep "Adjust the test 'duration' attribute" $rlRun_LOG
-                            rlAssertNotGrep "spec/tests.html#duration" $rlRun_LOG
+                        rlAssertNotGrep "Maximum test time '5s' exceeded." $rlRun_LOG
+                        rlAssertNotGrep "Adjust the test 'duration' attribute" $rlRun_LOG
+                        rlAssertNotGrep "spec/tests.html#duration" $rlRun_LOG
 
-                            rlAssertNotGrep "duration \"5\" exceeded" $tmp/log.txt
+                        rlAssertNotGrep "duration \"5\" exceeded" $tmp/log.txt
 
-                            rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ sent SIGKILL signal' $rlRun_LOG" 1
-                            rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ kill confirmed' $rlRun_LOG" 1
-                            rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ waiting for stream readers' $rlRun_LOG" 1
-                            rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ stdout reader done' $rlRun_LOG" 1
-                        fi
-                    rlPhaseEnd
-                done
+                        rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ sent SIGKILL signal' $rlRun_LOG" 1
+                        rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ kill confirmed' $rlRun_LOG" 1
+                        rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ waiting for stream readers' $rlRun_LOG" 1
+                        rlRun "grep -E ' [[:digit:]]{1,2}\.[[:digit:]]+ stdout reader done' $rlRun_LOG" 1
+                    fi
+                rlPhaseEnd
             done
         done
     done
diff --git a/tests/execute/reboot/main.fmf b/tests/execute/reboot/main.fmf
index f82cfb1c2f..4dd75e5eb9 100644
--- a/tests/execute/reboot/main.fmf
+++ b/tests/execute/reboot/main.fmf
@@ -8,10 +8,10 @@ tier: 4
 /out-of-session:
     summary: Verify that reboot induced from outside of test session works
     test: ./out-of-session.sh
-    tag+: [provision-virtual]
-
-    environment+:
-        PROVISION_METHODS: container
+    tag+:
+      - provision-only
+      - provision-container
+      - provision-virtual
 
 # Disabled until the testing environment 'hardware specification' can be set.
 # https://tmt.readthedocs.io/en/stable/spec/plans.html#hardware
diff --git a/tests/execute/reboot/out-of-session.sh b/tests/execute/reboot/out-of-session.sh
index f1147a1fed..5eb85e741a 100755
--- a/tests/execute/reboot/out-of-session.sh
+++ b/tests/execute/reboot/out-of-session.sh
@@ -1,78 +1,75 @@
 #!/bin/bash
 . /usr/share/beakerlib/beakerlib.sh || exit 1
 
-PROVISION_METHODS=${PROVISION_METHODS:-container}
-
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-container}"
         rlRun "run=\$(mktemp -d -p /var/tmp)" 0 "Create run directory"
         rlRun "set -o pipefail"
         rlRun "pushd out-of-session"
     rlPhaseEnd
 
-    for method in $PROVISION_METHODS; do
-        rlPhaseStartTest "Out-of-session reboot test ($method)"
-            # Spawn the tmt process, in the background - tmt is expected to run the plan and test,
-            # and reach a `sleep 3600`.
-            tmt run -e TMT_DEBUG=1 --scratch -i $run -dddvvva provision -h $method execute -h tmt $interactive &> tmt.output &
-            tmt_pid="$!"
+    rlPhaseStartTest "Out-of-session reboot test ($PROVISION_HOW)"
+        # Spawn the tmt process, in the background - tmt is expected to run the plan and test,
+        # and reach a `sleep 3600`.
+        tmt run -e TMT_DEBUG=1 --scratch -i $run -dddvvva provision -h $PROVISION_HOW execute -h tmt $interactive &> tmt.output &
+        tmt_pid="$!"
 
-            rlLogInfo "Running \"tmt run -e TMT_DEBUG=1 --scratch -i $run -dddvvva provision -h $method execute -h tmt $interactive &> tmt.output\" in the background"
-            rlLogInfo "Background tmt PID is $tmt_pid"
+        rlLogInfo "Running \"tmt run -e TMT_DEBUG=1 --scratch -i $run -dddvvva provision -h $PROVISION_HOW execute -h tmt $interactive &> tmt.output\" in the background"
+        rlLogInfo "Background tmt PID is $tmt_pid"
 
-            # Now we wait for the test to go to sleep...
-            while true; do
-                rlLogInfo "checking output for 'sleep 3600'..."
+        # Now we wait for the test to go to sleep...
+        while true; do
+            rlLogInfo "checking output for 'sleep 3600'..."
 
-                current_tail="$(tail -n 10 tmt.output)"
+            current_tail="$(tail -n 10 tmt.output)"
 
-                if [[ "$current_tail" == *"Running 'sleep 3600'"* ]]; then
-                    rlLogInfo "found!"
-                    break;
-                fi
+            if [[ "$current_tail" == *"Running 'sleep 3600'"* ]]; then
+                rlLogInfo "found!"
+                break;
+            fi
 
-                sleep 10
-            done
+            sleep 10
+        done
 
-            rlLogInfo "tmt output, before reboot:"
-            rlLogInfo "$(cat tmt.output)"
+        rlLogInfo "tmt output, before reboot:"
+        rlLogInfo "$(cat tmt.output)"
 
-            # When the test is sleeping, we can extract the podman command & container ID from tmt log,
-            # and use it to issue a `tmt-reboot` from outside the direct process tree of the test.
-            set -x
+        # When the test is sleeping, we can extract the podman command & container ID from tmt log,
+        # and use it to issue a `tmt-reboot` from outside the direct process tree of the test.
+        set -x
 
-            tmt_reboot_command="export TMT_TEST_PIDFILE=/var/tmp/tmt-test.pid; export TMT_TEST_PIDFILE_LOCK=/var/tmp/tmt-test.pid.lock; export TMT_DEBUG=1; tmt-reboot"
+        tmt_reboot_command="export TMT_TEST_PIDFILE=/var/tmp/tmt-test.pid; export TMT_TEST_PIDFILE_LOCK=/var/tmp/tmt-test.pid.lock; export TMT_DEBUG=1; tmt-reboot"
 
-            if [ "$method" = "container" ]; then
-                podman_exec="$(sed -nr 's/\s*Run command: (podman exec .*) \/bin\/bash.*cd.*/\1/p' tmt.output)"
+        if [ "$PROVISION_HOW" = "container" ]; then
+            podman_exec="$(sed -nr 's/\s*Run command: (podman exec .*) \/bin\/bash.*cd.*/\1/p' tmt.output)"
 
-                $podman_exec bash -c "$tmt_reboot_command"
+            $podman_exec bash -c "$tmt_reboot_command"
 
-            elif [ "$method" = "virtual" ]; then
-                ssh_exec="$(sed -nr "s/\s*Run command: (ssh .* -tt root@.*) 'export .*/\1/p" tmt.output)"
+        elif [ "$PROVISION_HOW" = "virtual" ]; then
+            ssh_exec="$(sed -nr "s/\s*Run command: (ssh .* -tt root@.*) 'export .*/\1/p" tmt.output)"
 
-                $ssh_exec "$tmt_reboot_command"
-            fi
+            $ssh_exec "$tmt_reboot_command"
+        fi
 
-            set +x
+        set +x
 
-            # Reboot has been issued, wait for tmt to finish: the test should be interrupted, restarted,
-            # and finish successfully.
-            wait "$tmt_pid"
+        # Reboot has been issued, wait for tmt to finish: the test should be interrupted, restarted,
+        # and finish successfully.
+        wait "$tmt_pid"
 
-            rlLogInfo "tmt output. full:"
-            rlLogInfo "$(cat tmt.output)"
+        rlLogInfo "tmt output. full:"
+        rlLogInfo "$(cat tmt.output)"
 
-            rlAssertGrep "TMT_REBOOT_COUNT=0" tmt.output
-            rlAssertGrep "Before reboot" tmt.output
-            rlAssertGrep "Running 'sleep 3600'" tmt.output
+        rlAssertGrep "TMT_REBOOT_COUNT=0" tmt.output
+        rlAssertGrep "Before reboot" tmt.output
+        rlAssertGrep "Running 'sleep 3600'" tmt.output
 
-            rlAssertGrep "TMT_REBOOT_COUNT=1" tmt.output
-            rlAssertGrep "After first reboot" tmt.output
+        rlAssertGrep "TMT_REBOOT_COUNT=1" tmt.output
+        rlAssertGrep "After first reboot" tmt.output
 
-            rlAssertGrep "OVERALL RESULT: PASS" tmt.output
-        rlPhaseEnd
-    done
+        rlAssertGrep "OVERALL RESULT: PASS" tmt.output
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "rm -rf tmt.output $run" 0 "Remove run directory"
diff --git a/tests/execute/tty/main.fmf b/tests/execute/tty/main.fmf
index 0f825fa533..fb5d508c63 100644
--- a/tests/execute/tty/main.fmf
+++ b/tests/execute/tty/main.fmf
@@ -1,6 +1,5 @@
 summary: Verify TTY handling in test environment
-tag+: [provision-virtual]
+tag+:
+  - provision-container
+  - provision-virtual
 duration: 10m
-
-environment:
-    PROVISION_METHODS: local container
diff --git a/tests/execute/tty/test.sh b/tests/execute/tty/test.sh
index e00fef6462..7d0af44205 100755
--- a/tests/execute/tty/test.sh
+++ b/tests/execute/tty/test.sh
@@ -3,102 +3,101 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-local}"
         rlRun "pushd data"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-local}; do
-        rlPhaseStartTest "With $method provision method (tty:false)"
-            rlRun -s "tmt run -avvvvddd provision -h $method"
-
-            rlAssertGrep "out: prepare: stdin: False" $rlRun_LOG
-            rlAssertGrep "out: prepare: stdout: False" $rlRun_LOG
-            rlAssertGrep "out: prepare: stderr: False" $rlRun_LOG
-
-            rlAssertGrep "out: execute: stdin: False" $rlRun_LOG
-            rlAssertGrep "out: execute: stdout: False" $rlRun_LOG
-            rlAssertGrep "out: execute: stderr: False" $rlRun_LOG
-
-            rlAssertGrep "out: finish: stdin: False" $rlRun_LOG
-            rlAssertGrep "out: finish: stdout: False" $rlRun_LOG
-            rlAssertGrep "out: finish: stderr: False" $rlRun_LOG
-
-            rlAssertGrep "out: prepare: stdin: 0" $rlRun_LOG
-            rlAssertGrep "out: prepare: stdout: 0" $rlRun_LOG
-            rlAssertGrep "out: prepare: stderr: 0" $rlRun_LOG
-
-            rlAssertGrep "out: execute: stdin: 0" $rlRun_LOG
-            rlAssertGrep "out: execute: stdout: 0" $rlRun_LOG
-            rlAssertGrep "out: execute: stderr: 0" $rlRun_LOG
-
-            rlAssertGrep "out: finish: stdin: 0" $rlRun_LOG
-            rlAssertGrep "out: finish: stdout: 0" $rlRun_LOG
-            rlAssertGrep "out: finish: stderr: 0" $rlRun_LOG
-
-            # test for #2429, not related to tty
-            rlRun -s "tmt run --last report -vvv"
-            rlAssertNotGrep "Connection to.*closed" $rlRun_LOG
-            rlAssertNotGrep "Shared connection to.*closed" $rlRun_LOG
-        rlPhaseEnd
-
-       # NOTE: Our local provisioner cannot execute commands with a pty allocated
-       if [ "$method" != "local" ]; then
-               rlPhaseStartTest "With $method provision method (tty:true)"
-                   rlRun -s "NO_COLOR=1 ../ptty-wrapper tmt -c tty=true run -avvvvddd provision -h $method"
-
-                   rlAssertGrep "out: prepare: stdin: False" $rlRun_LOG
-                   rlAssertGrep "out: prepare: stdout: False" $rlRun_LOG
-                   rlAssertGrep "out: prepare: stderr: False" $rlRun_LOG
-
-                   rlAssertGrep "out: execute: stdin: True" $rlRun_LOG
-                   rlAssertGrep "out: execute: stdout: True" $rlRun_LOG
-                   rlAssertGrep "out: execute: stderr: True" $rlRun_LOG
-
-                   rlAssertGrep "out: finish: stdin: False" $rlRun_LOG
-                   rlAssertGrep "out: finish: stdout: False" $rlRun_LOG
-                   rlAssertGrep "out: finish: stderr: False" $rlRun_LOG
-
-                   rlAssertGrep "out: prepare: stdin: 0" $rlRun_LOG
-                   rlAssertGrep "out: prepare: stdout: 0" $rlRun_LOG
-                   rlAssertGrep "out: prepare: stderr: 0" $rlRun_LOG
-
-                   rlAssertGrep "out: execute: stdin: 1" $rlRun_LOG
-                   rlAssertGrep "out: execute: stdout: 1" $rlRun_LOG
-                   rlAssertGrep "out: execute: stderr: 1" $rlRun_LOG
-
-                   rlAssertGrep "out: finish: stdin: 0" $rlRun_LOG
-                   rlAssertGrep "out: finish: stdout: 0" $rlRun_LOG
-                   rlAssertGrep "out: finish: stderr: 0" $rlRun_LOG
-               rlPhaseEnd
-       fi
-
-        rlPhaseStartTest "With $method provision method, interactive tests"
-            rlRun -s "NO_COLOR=1 ../ptty-wrapper tmt run -avvvvddd provision -h $method execute -h tmt --interactive"
-
-            rlAssertGrep "out: prepare: stdin: False" $rlRun_LOG
-            rlAssertGrep "out: prepare: stdout: False" $rlRun_LOG
-            rlAssertGrep "out: prepare: stderr: False" $rlRun_LOG
-
-            rlAssertGrep "execute: stdin: True" $rlRun_LOG
-            rlAssertGrep "execute: stdout: True" $rlRun_LOG
-            rlAssertGrep "execute: stderr: True" $rlRun_LOG
-
-            rlAssertGrep "out: finish: stdin: False" $rlRun_LOG
-            rlAssertGrep "out: finish: stdout: False" $rlRun_LOG
-            rlAssertGrep "out: finish: stderr: False" $rlRun_LOG
-
-            rlAssertGrep "out: prepare: stdin: 0" $rlRun_LOG
-            rlAssertGrep "out: prepare: stdout: 0" $rlRun_LOG
-            rlAssertGrep "out: prepare: stderr: 0" $rlRun_LOG
-
-            rlAssertGrep "execute: stdin: 1" $rlRun_LOG
-            rlAssertGrep "execute: stdout: 1" $rlRun_LOG
-            rlAssertGrep "execute: stderr: 1" $rlRun_LOG
-
-            rlAssertGrep "out: finish: stdin: 0" $rlRun_LOG
-            rlAssertGrep "out: finish: stdout: 0" $rlRun_LOG
-            rlAssertGrep "out: finish: stderr: 0" $rlRun_LOG
-        rlPhaseEnd
-    done
+    rlPhaseStartTest "With $PROVISION_HOW provision method (tty:false)"
+        rlRun -s "tmt run -avvvvddd provision -h $PROVISION_HOW"
+
+        rlAssertGrep "out: prepare: stdin: False" $rlRun_LOG
+        rlAssertGrep "out: prepare: stdout: False" $rlRun_LOG
+        rlAssertGrep "out: prepare: stderr: False" $rlRun_LOG
+
+        rlAssertGrep "out: execute: stdin: False" $rlRun_LOG
+        rlAssertGrep "out: execute: stdout: False" $rlRun_LOG
+        rlAssertGrep "out: execute: stderr: False" $rlRun_LOG
+
+        rlAssertGrep "out: finish: stdin: False" $rlRun_LOG
+        rlAssertGrep "out: finish: stdout: False" $rlRun_LOG
+        rlAssertGrep "out: finish: stderr: False" $rlRun_LOG
+
+        rlAssertGrep "out: prepare: stdin: 0" $rlRun_LOG
+        rlAssertGrep "out: prepare: stdout: 0" $rlRun_LOG
+        rlAssertGrep "out: prepare: stderr: 0" $rlRun_LOG
+
+        rlAssertGrep "out: execute: stdin: 0" $rlRun_LOG
+        rlAssertGrep "out: execute: stdout: 0" $rlRun_LOG
+        rlAssertGrep "out: execute: stderr: 0" $rlRun_LOG
+
+        rlAssertGrep "out: finish: stdin: 0" $rlRun_LOG
+        rlAssertGrep "out: finish: stdout: 0" $rlRun_LOG
+        rlAssertGrep "out: finish: stderr: 0" $rlRun_LOG
+
+        # test for #2429, not related to tty
+        rlRun -s "tmt run --last report -vvv"
+        rlAssertNotGrep "Connection to.*closed" $rlRun_LOG
+        rlAssertNotGrep "Shared connection to.*closed" $rlRun_LOG
+    rlPhaseEnd
+
+    # NOTE: Our local provisioner cannot execute commands with a pty allocated
+    if [ "$PROVISION_HOW" != "local" ]; then
+            rlPhaseStartTest "With $PROVISION_HOW provision method (tty:true)"
+                rlRun -s "NO_COLOR=1 ../ptty-wrapper tmt -c tty=true run -avvvvddd provision -h $PROVISION_HOW"
+
+                rlAssertGrep "out: prepare: stdin: False" $rlRun_LOG
+                rlAssertGrep "out: prepare: stdout: False" $rlRun_LOG
+                rlAssertGrep "out: prepare: stderr: False" $rlRun_LOG
+
+                rlAssertGrep "out: execute: stdin: True" $rlRun_LOG
+                rlAssertGrep "out: execute: stdout: True" $rlRun_LOG
+                rlAssertGrep "out: execute: stderr: True" $rlRun_LOG
+
+                rlAssertGrep "out: finish: stdin: False" $rlRun_LOG
+                rlAssertGrep "out: finish: stdout: False" $rlRun_LOG
+                rlAssertGrep "out: finish: stderr: False" $rlRun_LOG
+
+                rlAssertGrep "out: prepare: stdin: 0" $rlRun_LOG
+                rlAssertGrep "out: prepare: stdout: 0" $rlRun_LOG
+                rlAssertGrep "out: prepare: stderr: 0" $rlRun_LOG
+
+                rlAssertGrep "out: execute: stdin: 1" $rlRun_LOG
+                rlAssertGrep "out: execute: stdout: 1" $rlRun_LOG
+                rlAssertGrep "out: execute: stderr: 1" $rlRun_LOG
+
+                rlAssertGrep "out: finish: stdin: 0" $rlRun_LOG
+                rlAssertGrep "out: finish: stdout: 0" $rlRun_LOG
+                rlAssertGrep "out: finish: stderr: 0" $rlRun_LOG
+            rlPhaseEnd
+    fi
+
+    rlPhaseStartTest "With $PROVISION_HOW provision method, interactive tests"
+        rlRun -s "NO_COLOR=1 ../ptty-wrapper tmt run -avvvvddd provision -h $PROVISION_HOW execute -h tmt --interactive"
+
+        rlAssertGrep "out: prepare: stdin: False" $rlRun_LOG
+        rlAssertGrep "out: prepare: stdout: False" $rlRun_LOG
+        rlAssertGrep "out: prepare: stderr: False" $rlRun_LOG
+
+        rlAssertGrep "execute: stdin: True" $rlRun_LOG
+        rlAssertGrep "execute: stdout: True" $rlRun_LOG
+        rlAssertGrep "execute: stderr: True" $rlRun_LOG
+
+        rlAssertGrep "out: finish: stdin: False" $rlRun_LOG
+        rlAssertGrep "out: finish: stdout: False" $rlRun_LOG
+        rlAssertGrep "out: finish: stderr: False" $rlRun_LOG
+
+        rlAssertGrep "out: prepare: stdin: 0" $rlRun_LOG
+        rlAssertGrep "out: prepare: stdout: 0" $rlRun_LOG
+        rlAssertGrep "out: prepare: stderr: 0" $rlRun_LOG
+
+        rlAssertGrep "execute: stdin: 1" $rlRun_LOG
+        rlAssertGrep "execute: stdout: 1" $rlRun_LOG
+        rlAssertGrep "execute: stderr: 1" $rlRun_LOG
+
+        rlAssertGrep "out: finish: stdin: 0" $rlRun_LOG
+        rlAssertGrep "out: finish: stdout: 0" $rlRun_LOG
+        rlAssertGrep "out: finish: stderr: 0" $rlRun_LOG
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "popd"
diff --git a/tests/finish/ansible/main.fmf b/tests/finish/ansible/main.fmf
index 9d091c7fe7..a620172968 100644
--- a/tests/finish/ansible/main.fmf
+++ b/tests/finish/ansible/main.fmf
@@ -5,13 +5,8 @@ description:
     environment variables are correctly handed over and logs are
     pulled back. In the full testing mode check virtual and local
     provision method as well.
-tag+: [provision-virtual]
-
-# By default we run under a container only
-environment:
-    PROVISION_METHODS: container
-adjust+:
-  - when: trigger == commit
-    environment:
-        PROVISION_METHODS: container local
-    because: the pipeline does not support nested virtualization
+tag+:
+  - provision-only
+  - provision-container
+  - provision-local
+  - provision-virtual
diff --git a/tests/finish/ansible/test.sh b/tests/finish/ansible/test.sh
index 252e63db94..6cab6215fc 100755
--- a/tests/finish/ansible/test.sh
+++ b/tests/finish/ansible/test.sh
@@ -3,32 +3,31 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-local}"
         rlRun "pushd data"
         rlRun "run=\$(mktemp -d)" 0 "Create run directory"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-container}; do
-        rlPhaseStartTest "Test ($method)"
-            # Prepare common options, run given method
-            tmt="tmt run -i $run --scratch"
-            rlRun "$tmt -av provision -h $method"
+    rlPhaseStartTest "Test ($PROVISION_HOW)"
+        # Prepare common options, run given method
+        tmt="tmt run -i $run --scratch"
+        rlRun "$tmt -av provision -h $PROVISION_HOW"
 
-            # Check that created file is synced back
-            rlRun "ls -l $run/plan/data"
-            rlAssertExists "$run/plan/data/my_file.txt"
+        # Check that created file is synced back
+        rlRun "ls -l $run/plan/data"
+        rlAssertExists "$run/plan/data/my_file.txt"
 
-            # For container provision try centos images as well
-            if [[ $method == container ]]; then
-                rlRun "$tmt -av finish provision -h $method -i centos:7"
-                rlRun "$tmt -av finish provision -h $method -i centos:stream8"
-            fi
+        # For container provision try centos images as well
+        if [[ $PROVISION_HOW == container ]]; then
+            rlRun "$tmt -av finish provision -h $PROVISION_HOW -i centos:7"
+            rlRun "$tmt -av finish provision -h $PROVISION_HOW -i centos:stream8"
+        fi
 
-            # After the local provision remove the test file
-            if [[ $method == local ]]; then
-                rlRun "sudo rm -f /tmp/finished"
-            fi
-        rlPhaseEnd
-    done
+        # After the local provision remove the test file
+        if [[ $PROVISION_HOW == local ]]; then
+            rlRun "sudo rm -f /tmp/finished"
+        fi
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "rm -r $run" 0 "Removing run directory"
diff --git a/tests/login/main.fmf b/tests/login/main.fmf
index dac78ef1a9..a8679797b8 100644
--- a/tests/login/main.fmf
+++ b/tests/login/main.fmf
@@ -22,6 +22,6 @@
     summary: Try to log into guest to verify property is_ready
     test: ./ready.sh
     duration: 15m
-    tag+: [provision-virtual]
-    environment:
-        PROVISION_METHODS: local container
+    tag+:
+      - provision-container
+      - provision-virtual
diff --git a/tests/login/ready.sh b/tests/login/ready.sh
index 5d9768283c..6c54e06092 100755
--- a/tests/login/ready.sh
+++ b/tests/login/ready.sh
@@ -3,33 +3,32 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-local}"
         rlRun "pushd data"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-virtual}; do
-        rlPhaseStartTest "Positive login test for ($method)"
-            rlRun -s "tmt run -a provision -h $method login -c exit" 0-255
-            rlAssertGrep "login: Starting interactive shell" "$rlRun_LOG"
-        rlPhaseEnd
+    rlPhaseStartTest "Positive login test for ($PROVISION_HOW)"
+        rlRun -s "tmt run -a provision -h $PROVISION_HOW login -c exit" 0-255
+        rlAssertGrep "login: Starting interactive shell" "$rlRun_LOG"
+    rlPhaseEnd
 
-        if [[ $method == "virtual" ]]; then
-            image_url="FOOOOO"
-            rlPhaseStartTest "Negative login test for $method (image url = $image_url)"
-                rlRun -s "tmt run -a provision -h $method -i $image_url login -c exit" 0-255 \
-                    "disallowed to login into guest which is virtual if image url is invalid"
-                rlAssertNotGrep "login: Starting interactive shell" "$rlRun_LOG"
-                rlAssertGrep "Could not get image url" "$rlRun_LOG"
-            rlPhaseEnd
+    if [[ $PROVISION_HOW == "virtual" ]]; then
+        image_url="FOOOOO"
+        rlPhaseStartTest "Negative login test for $PROVISION_HOW (image url = $image_url)"
+            rlRun -s "tmt run -a provision -h $PROVISION_HOW -i $image_url login -c exit" 0-255 \
+                "disallowed to login into guest which is virtual if image url is invalid"
+            rlAssertNotGrep "login: Starting interactive shell" "$rlRun_LOG"
+            rlAssertGrep "Could not get image url" "$rlRun_LOG"
+        rlPhaseEnd
 
-            image_url="file:///rubbish"
-            rlPhaseStartTest "Negative login test for $method (image url = $image_url)"
-                rlRun -s "tmt run -a provision -h $method -i $image_url login -c exit" 0-255 \
-                    "disallowed to login into guest which is virtual if image url is invalid"
-                rlAssertNotGrep "login: Starting interactive shell" "$rlRun_LOG"
-                rlAssertGrep "Image .*rubbish' not found" "$rlRun_LOG"
-            rlPhaseEnd
-        fi
-    done
+        image_url="file:///rubbish"
+        rlPhaseStartTest "Negative login test for $PROVISION_HOW (image url = $image_url)"
+            rlRun -s "tmt run -a provision -h $PROVISION_HOW -i $image_url login -c exit" 0-255 \
+                "disallowed to login into guest which is virtual if image url is invalid"
+            rlAssertNotGrep "login: Starting interactive shell" "$rlRun_LOG"
+            rlAssertGrep "Image .*rubbish' not found" "$rlRun_LOG"
+        rlPhaseEnd
+    fi
 
     rlPhaseStartCleanup
         rlRun "popd"
diff --git a/tests/prepare/ansible/main.fmf b/tests/prepare/ansible/main.fmf
index 2e0a37d70a..8677ec53b3 100644
--- a/tests/prepare/ansible/main.fmf
+++ b/tests/prepare/ansible/main.fmf
@@ -4,13 +4,8 @@ description:
     centos) and prepare it with an ansible playbook. Make sure the
     environment variables are correctly handed over. In the full
     testing mode check virtual and local provision method as well.
-tag+: [provision-virtual]
-
-# By default we run under a container only
-environment:
-    PROVISION_METHODS: container
-adjust+:
-  - when: trigger == commit
-    environment:
-        PROVISION_METHODS: container local
-    because: the pipeline does not support nested virtualization
+tag+:
+  - provision-only
+  - provision-container
+  - provision-local
+  - provision-virtual
diff --git a/tests/prepare/ansible/test.sh b/tests/prepare/ansible/test.sh
index 5221008df8..c4533ce10e 100755
--- a/tests/prepare/ansible/test.sh
+++ b/tests/prepare/ansible/test.sh
@@ -3,33 +3,32 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-container}"
         rlRun "pushd data"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-container}; do
-        for plan in local remote; do
-            rlPhaseStartTest "Test $plan playbook ($method)"
-                rlRun "tmt run -arv provision -h $method plan -n /$plan"
+    for plan in "local" "remote"; do
+        rlPhaseStartTest "Test $plan playbook ($PROVISION_HOW)"
+            rlRun "tmt run -arv provision -h $PROVISION_HOW plan -n /$plan"
 
-                # For container provision try centos images as well
-                if [[ $method == container ]]; then
-                    rlRun "tmt run -arv provision -h $method -i centos:7 plan -n /$plan"
-                    rlRun "tmt run -arv provision -h $method -i centos:stream8 plan -n /$plan"
-                fi
+            # For container provision try centos images as well
+            if [[ $PROVISION_HOW == container ]]; then
+                rlRun "tmt run -arv provision -h $PROVISION_HOW -i centos:7 plan -n /$plan"
+                rlRun "tmt run -arv provision -h $PROVISION_HOW -i centos:stream8 plan -n /$plan"
+            fi
 
-                # After the local provision remove the test file
-                if [[ $method == local ]]; then
-                    rlRun "sudo rm -f /tmp/prepared"
-                fi
-            rlPhaseEnd
+            # After the local provision remove the test file
+            if [[ $PROVISION_HOW == local ]]; then
+                rlRun "sudo rm -f /tmp/prepared"
+            fi
+        rlPhaseEnd
 
-            rlPhaseStartTest "Ansible ($method) - check extra-args attribute"
-                rlRun "tmt run -rddd discover provision -h $method prepare finish plan -n /$plan 2>&1 >/dev/null \
-                    | grep \"ansible-playbook\"\
-                    | tee output"
-                rlAssertGrep "-vvv" output
-            rlPhaseEnd
-        done
+        rlPhaseStartTest "Ansible ($PROVISION_HOW) - check extra-args attribute"
+            rlRun "tmt run -rddd discover provision -h $PROVISION_HOW prepare finish plan -n /$plan 2>&1 >/dev/null \
+                | grep \"ansible-playbook\"\
+                | tee output"
+            rlAssertGrep "-vvv" output
+        rlPhaseEnd
     done
 
     rlPhaseStartCleanup
diff --git a/tests/prepare/install/main.fmf b/tests/prepare/install/main.fmf
index b6504fb046..32f4a504ba 100644
--- a/tests/prepare/install/main.fmf
+++ b/tests/prepare/install/main.fmf
@@ -4,11 +4,8 @@ description:
     Make sure that special characters are correctly escaped.
     Verify that installation from copr works for epel7. Exercises
     all provision methods in full mode, container only by default.
-tag+: [provision-virtual]
-environment:
-    PROVISION_METHODS: container
-adjust+:
-  - when: trigger == commit
-    environment:
-        PROVISION_METHODS: container local
-    because: the pipeline does not support nested virtualization
+tag+:
+  - provision-only
+  - provision-container
+  - provision-local
+  - provision-virtual
diff --git a/tests/prepare/install/test.sh b/tests/prepare/install/test.sh
index d700464451..8fdbeee212 100755
--- a/tests/prepare/install/test.sh
+++ b/tests/prepare/install/test.sh
@@ -3,6 +3,7 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-container}"
         rlRun "run=\$(mktemp -d)" 0 "Create run directory"
         rlRun "pushd data"
 
@@ -13,64 +14,65 @@ rlJournalStart
     # Prepare the common tmt command
     tmt="tmt run --all --id $run --scratch -vvv"
 
-    # Run basic tests against all enabled provision methods
-    for method in ${PROVISION_METHODS:-container}; do
-        provision="provision --how $method"
+    # Run basic tests against the given provision method
+    provision="provision --how $PROVISION_HOW"
 
-        rlPhaseStartTest "Install an existing package ($method)"
+    rlPhaseStartTest "Install an existing package ($PROVISION_HOW)"
+        rlRun "$tmt $provision plan --name existing"
+    rlPhaseEnd
+
+    rlPhaseStartTest "Report a missing package ($PROVISION_HOW)"
+        rlRun "$tmt $provision plan --name missing" 2
+    rlPhaseEnd
+
+    # Add one extra CoreOS run for virtual provision
+    if [[ "$PROVISION_HOW" == "virtual" ]]; then
+        provision="provision --how $PROVISION_HOW --image fedora-coreos"
+
+        rlPhaseStartTest "Install an existing package ($PROVISION_HOW, CoreOS)"
             rlRun "$tmt $provision plan --name existing"
+            rlAssertGrep "rpm-ostree install.*tree" $run/log.txt
+            rlAssertNotGrep "rpm-ostree install.*/usr/bin/flock" $run/log.txt
         rlPhaseEnd
 
-        rlPhaseStartTest "Report a missing package ($method)"
+        rlPhaseStartTest "Report a missing package ($PROVISION_HOW, CoreOS)"
             rlRun "$tmt $provision plan --name missing" 2
         rlPhaseEnd
+    fi
+
+    # And a couple of additional tests with container provision
+    if [[ "$PROVISION_HOW" == "container" ]]; then
+        rlPhaseStartTest "Provide package on the command line"
+            rlRun "tmt run -vvvr plan --default \
+                provision --how container \
+                prepare --how install --package tree \
+                finish"
+        rlPhaseEnd
 
-        # Add one extra CoreOS run for virtual provision
-        if [[ "$method" == "virtual" ]]; then
-            provision="provision --how $method --image fedora-coreos"
-
-            rlPhaseStartTest "Install an existing package ($method, CoreOS)"
-                rlRun "$tmt $provision plan --name existing"
-                rlAssertGrep "rpm-ostree install.*tree" $run/log.txt
-                rlAssertNotGrep "rpm-ostree install.*/usr/bin/flock" $run/log.txt
-            rlPhaseEnd
-
-            rlPhaseStartTest "Report a missing package ($method, CoreOS)"
-                rlRun "$tmt $provision plan --name missing" 2
-            rlPhaseEnd
-        fi
-    done
-
-    rlPhaseStartTest "Provide package on the command line"
-        rlRun "tmt run -vvvr plan --default \
-            provision --how container \
-            prepare --how install --package tree \
-            finish"
-    rlPhaseEnd
-
-    rlPhaseStartTest "Just enable copr"
-        rlRun "$tmt plan --name copr"
-    rlPhaseEnd
+        rlPhaseStartTest "Just enable copr"
+            rlRun "$tmt plan --name copr"
+        rlPhaseEnd
 
-    rlPhaseStartTest "Escape package names"
-        rlRun "$tmt plan --name escape"
-    rlPhaseEnd
+        rlPhaseStartTest "Escape package names"
+            rlRun "$tmt plan --name escape"
+        rlPhaseEnd
 
-    rlPhaseStartTest "Exclude selected packages"
-        rlRun "$tmt plan --name exclude"
-    rlPhaseEnd
+        rlPhaseStartTest "Exclude selected packages"
+            rlRun "$tmt plan --name exclude"
+        rlPhaseEnd
 
-    rlPhaseStartTest "Install from epel7 copr"
-        rlRun "$tmt plan --name epel7"
-    rlPhaseEnd
+        rlPhaseStartTest "Install from epel7 copr"
+            rlRun "$tmt plan --name epel7"
+        rlPhaseEnd
 
-    rlPhaseStartTest "Install remote packages"
-        rlRun "$tmt plan --name epel8-remote"
-    rlPhaseEnd
+        rlPhaseStartTest "Install remote packages"
+            rlRun "$tmt plan --name epel8-remote"
+        rlPhaseEnd
 
-    rlPhaseStartTest "Install debuginfo packages"
-        rlRun "$tmt plan --name debuginfo"
-    rlPhaseEnd
+        rlPhaseStartTest "Install debuginfo packages"
+            rlRun "$tmt plan --name debuginfo"
+        rlPhaseEnd
+    fi
 
     rlPhaseStartCleanup
         rlRun "popd"
diff --git a/tests/prepare/multihost/main.fmf b/tests/prepare/multihost/main.fmf
index 147397d41b..c48077a0f4 100644
--- a/tests/prepare/multihost/main.fmf
+++ b/tests/prepare/multihost/main.fmf
@@ -1,11 +1,5 @@
 summary: Check that requirement installation is guest-aware in multihost scenario
-tag+: [provision-virtual]
-
-environment:
-    PROVISION_METHODS: container
-
-adjust+:
-  - when: trigger == commit
-    environment:
-        PROVISION_METHODS: container
-    because: the pipeline does not support nested virtualization
+tag+:
+  - provision-only
+  - provision-container
+  - provision-virtual
diff --git a/tests/prepare/multihost/test.sh b/tests/prepare/multihost/test.sh
index 6656d2ce1a..9a52f56a54 100755
--- a/tests/prepare/multihost/test.sh
+++ b/tests/prepare/multihost/test.sh
@@ -3,17 +3,16 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-container}"
         rlRun "pushd data"
 
         rlRun "export TMT_BOOT_TIMEOUT=300"
         rlRun "export TMT_CONNECT_TIMEOUT=300"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-container}; do
-        rlPhaseStartTest "Test with $method provisioning"
-            rlRun "tmt -vv run -a provision --update --how $method"
-        rlPhaseEnd
-    done
+    rlPhaseStartTest "Test with $PROVISION_HOW provisioning"
+        rlRun "tmt -vv run -a provision --update --how $PROVISION_HOW"
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "popd"
diff --git a/tests/prepare/recommend/main.fmf b/tests/prepare/recommend/main.fmf
index d223101224..69e1a9658e 100644
--- a/tests/prepare/recommend/main.fmf
+++ b/tests/prepare/recommend/main.fmf
@@ -3,11 +3,8 @@ description:
     Run a simple test which recommends two packages. Check that
     the existing one is installed and the other one is ignored. No
     error should be reported.
-tag+: [provision-virtual]
-environment:
-    PROVISION_METHODS: container
-adjust+:
-  - when: trigger == commit
-    environment:
-        PROVISION_METHODS: container local
-    because: the pipeline does not support nested virtualization
+tag+:
+  - provision-only
+  - provision-container
+  - provision-local
+  - provision-virtual
diff --git a/tests/prepare/recommend/test.sh b/tests/prepare/recommend/test.sh
index 2551cca49a..a43157ddd3 100755
--- a/tests/prepare/recommend/test.sh
+++ b/tests/prepare/recommend/test.sh
@@ -3,45 +3,44 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-container}"
         rlRun "pushd data"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-container}; do
-        tmt="tmt run --all --remove provision --how $method"
-        basic="plan --name 'mixed|weird'"
-        debuginfo="plan --name debuginfo"
+    tmt="tmt run --all --remove provision --how $PROVISION_HOW"
+    basic="plan --name 'mixed|weird'"
+    debuginfo="plan --name debuginfo"
 
-        # Verify against the default provision image
-        rlPhaseStartTest "Test the default image ($method)"
-            rlRun "$tmt $basic"
-        rlPhaseEnd
-
-        # Check CentOS images for container provision
-        if [[ "$method" == "container" ]]; then
-            for image in centos:7 centos:stream8; do
-                rlPhaseStartTest "Test $image ($method)"
-                    rlRun "$tmt --image $image $basic"
-                rlPhaseEnd
-            done
-        fi
+    # Verify against the default provision image
+    rlPhaseStartTest "Test the default image ($PROVISION_HOW)"
+        rlRun "$tmt $basic"
+    rlPhaseEnd
 
-        # Check debuginfo install (only for supported distros)
-        # https://bugzilla.redhat.com/show_bug.cgi?id=1964505
-        if [[ "$method" == "container" ]]; then
-            for image in fedora centos:7; do
-                rlPhaseStartTest "Test $image ($method) [debuginfo]"
-                    rlRun "$tmt --image $image $debuginfo"
-                rlPhaseEnd
-            done
-        fi
+    # Check CentOS images for container provision
+    if [[ "$PROVISION_HOW" == "container" ]]; then
+        for image in centos:7 centos:stream8; do
+            rlPhaseStartTest "Test $image ($PROVISION_HOW)"
+                rlRun "$tmt --image $image $basic"
+            rlPhaseEnd
+        done
+    fi
 
-        # Add one extra CoreOS run for virtual provision
-        if [[ "$method" == "virtual" ]]; then
-            rlPhaseStartTest "Test fedora-coreos ($method)"
-                rlRun "$tmt --image fedora-coreos $basic"
+    # Check debuginfo install (only for supported distros)
+    # https://bugzilla.redhat.com/show_bug.cgi?id=1964505
+    if [[ "$PROVISION_HOW" == "container" ]]; then
+        for image in fedora centos:7; do
+            rlPhaseStartTest "Test $image ($PROVISION_HOW) [debuginfo]"
+                rlRun "$tmt --image $image $debuginfo"
             rlPhaseEnd
-        fi
-    done
+        done
+    fi
+
+    # Add one extra CoreOS run for virtual provision
+    if [[ "$PROVISION_HOW" == "virtual" ]]; then
+        rlPhaseStartTest "Test fedora-coreos ($PROVISION_HOW)"
+            rlRun "$tmt --image fedora-coreos $basic"
+        rlPhaseEnd
+    fi
 
     rlPhaseStartCleanup
         rlRun "popd"
diff --git a/tests/provision/become/main.fmf b/tests/provision/become/main.fmf
index 4bd86c0eda..4874eedeb5 100644
--- a/tests/provision/become/main.fmf
+++ b/tests/provision/become/main.fmf
@@ -1,5 +1,9 @@
 summary: Check that become works on virtual and container provision
-description: Ensures that become works when used in virtual instances and on containers.
-tag+: [provision-virtual,provision-container]
+description:
+    Ensure that become works when used in virtual instances and on
+    containers.
+tag+:
+  - provision-only
+  - provision-container
+  - provision-virtual
 duration: 20m
-tier: null
diff --git a/tests/provision/become/test.sh b/tests/provision/become/test.sh
index 78dbdc69a7..cea56c24f3 100755
--- a/tests/provision/become/test.sh
+++ b/tests/provision/become/test.sh
@@ -1,13 +1,11 @@
 #!/bin/bash
 . /usr/share/beakerlib/beakerlib.sh || exit 1
 
-PROVISION_METHODS=${PROVISION_METHODS:-container virtual}
-
 rlJournalStart
-
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-container}"
         rlRun "pushd data"
-        if [[ "$PROVISION_METHODS" =~ "container" ]]; then
+        if [[ "$PROVISION_HOW" == "container" ]]; then
             # Try several times to build the container
             # https://github.com/teemtee/tmt/issues/2063
             build="podman build -t become-container-test:latest ."
@@ -15,37 +13,33 @@ rlJournalStart
         fi
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS}; do
-        if [ "$method" = "container" ] || [ "$method" = "virtual" ]; then
-            rlPhaseStartTest "$method, test with become=true"
-                rlRun "tmt --context provisiontest=$method run -rvvv plan --name /test/root"
-            rlPhaseEnd
+    rlPhaseStartTest "$PROVISION_HOW, test with become=true"
+        rlRun "tmt --context provisiontest=$PROVISION_HOW run -rvvv plan --name /test/root"
+    rlPhaseEnd
 
-            rlPhaseStartTest "$method, test with become=false"
-                rlRun "tmt --context provisiontest=$method run -rvvv plan --name /test/user"
-            rlPhaseEnd
+    rlPhaseStartTest "$PROVISION_HOW, test with become=false"
+        rlRun "tmt --context provisiontest=$PROVISION_HOW run -rvvv plan --name /test/user"
+    rlPhaseEnd
 
-            rlPhaseStartTest "$method, prepare/finish inline with become=true"
-                rlRun "tmt --context provisiontest=$method run -rvvv plan --name /prepare-finish/root/inline"
-            rlPhaseEnd
+    rlPhaseStartTest "$PROVISION_HOW, prepare/finish inline with become=true"
+        rlRun "tmt --context provisiontest=$PROVISION_HOW run -rvvv plan --name /prepare-finish/root/inline"
+    rlPhaseEnd
 
-            rlPhaseStartTest "$method, prepare/finish inline with become=false"
-                rlRun "tmt --context provisiontest=$method run -rvvv plan --name /prepare-finish/user/inline"
-            rlPhaseEnd
+    rlPhaseStartTest "$PROVISION_HOW, prepare/finish inline with become=false"
+        rlRun "tmt --context provisiontest=$PROVISION_HOW run -rvvv plan --name /prepare-finish/user/inline"
+    rlPhaseEnd
 
-            rlPhaseStartTest "$method, prepare/finish scripts with become=true"
-                rlRun "tmt --context provisiontest=$method run -rvvv plan --name /prepare-finish/root/scripts"
-            rlPhaseEnd
+    rlPhaseStartTest "$PROVISION_HOW, prepare/finish scripts with become=true"
+        rlRun "tmt --context provisiontest=$PROVISION_HOW run -rvvv plan --name /prepare-finish/root/scripts"
+    rlPhaseEnd
 
-            rlPhaseStartTest "$method, prepare/finish scripts with become=false"
-                rlRun "tmt --context provisiontest=$method run -rvvv plan --name /prepare-finish/user/scripts"
-            rlPhaseEnd
-        fi
-    done
+    rlPhaseStartTest "$PROVISION_HOW, prepare/finish scripts with become=false"
+        rlRun "tmt --context provisiontest=$PROVISION_HOW run -rvvv plan --name /prepare-finish/user/scripts"
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "popd"
-        if [[ "$PROVISION_METHODS" =~ "container" ]]; then
+        if [[ "$PROVISION_HOW" == "container" ]]; then
             rlRun "podman image rm -f localhost/become-container-test:latest" 0 "Remove custom image"
         fi
     rlPhaseEnd
diff --git a/tests/provision/facts/main.fmf b/tests/provision/facts/main.fmf
index f879699793..cd38dc5fc1 100644
--- a/tests/provision/facts/main.fmf
+++ b/tests/provision/facts/main.fmf
@@ -1,9 +1,8 @@
 /guest:
     summary: Check that guest facts are discovered and reported correctly
     test: ./test-guest.sh
-
-    environment:
-        PROVISION_METHODS: local container
+    tag+:
+      - provision-container
 
 /runner:
     summary: Check that host facts are discovered and reported correctly
diff --git a/tests/provision/facts/test-guest.sh b/tests/provision/facts/test-guest.sh
index 08aad0562a..9a043b6c5a 100755
--- a/tests/provision/facts/test-guest.sh
+++ b/tests/provision/facts/test-guest.sh
@@ -4,96 +4,95 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-local}"
         rlRun "run=\$(mktemp -d)" 0 "Create run directory"
         rlRun "set -o pipefail"
     rlPhaseEnd
 
-    for provision_method in ${PROVISION_METHODS:-local}; do
-        rlPhaseStartTest "Check $provision_method plugin"
-            if [ "$provision_method" = "local" ]; then
-                provision_options=""
-                bfu_provision_options=""
-
-                arch="$(arch)"
-
-                if [ -f /etc/os-release ]; then
-                    distro="$(grep PRETTY_NAME /etc/os-release | cut -d'=' -f2 | tr -d '"')"
-                else
-                    distro="$(cat /etc/redhat-release || cat /etc/fedora-release)"
-                fi
-
-                kernel="$(uname -r)"
-
-                package_manager="dnf\|yum"
-
-                grep "selinuxfs" /proc/filesystems &> /dev/null
-                if [ $? -eq 1 ]; then
-                    selinux="no"
-                else
-                    selinux="yes"
-                fi
-
-                if [ "$(whoami)" != "root" ]; then
-                    is_superuser="no"
-                else
-                    is_superuser="yes"
-                fi
-
-            elif [ "$provision_method" = "container" ]; then
-                provision_options="--image fedora:37"
-                bfu_provision_options="$provision_options --user=nobody"
-
-                arch="$(arch)"
-                distro="Fedora Linux 37 (Container Image)"
-                kernel="$(uname -r)"
-                package_manager="dnf"
-
-                grep "selinuxfs" /proc/filesystems &> /dev/null
-                if [ $? -eq 1 ]; then
-                    selinux="no"
-                else
-                    selinux="yes"
-                fi
+    rlPhaseStartTest "Check $PROVISION_HOW plugin"
+        if [ "$PROVISION_HOW" = "local" ]; then
+            provision_options=""
+            bfu_provision_options=""
 
+            arch="$(arch)"
+
+            if [ -f /etc/os-release ]; then
+                distro="$(grep PRETTY_NAME /etc/os-release | cut -d'=' -f2 | tr -d '"')"
+            else
+                distro="$(cat /etc/redhat-release || cat /etc/fedora-release)"
+            fi
+
+            kernel="$(uname -r)"
+
+            package_manager="dnf\|yum"
+
+            grep "selinuxfs" /proc/filesystems &> /dev/null
+            if [ $? -eq 1 ]; then
+                selinux="no"
+            else
+                selinux="yes"
+            fi
+
+            if [ "$(whoami)" != "root" ]; then
+                is_superuser="no"
+            else
                 is_superuser="yes"
-                bfu_is_superuser="no"
+            fi
 
+        elif [ "$PROVISION_HOW" = "container" ]; then
+            provision_options="--image fedora:39"
+            bfu_provision_options="$provision_options --user=nobody"
+
+            arch="$(arch)"
+            distro="Fedora Linux 39 (Container Image)"
+            kernel="$(uname -r)"
+            package_manager="dnf"
+
+            grep "selinuxfs" /proc/filesystems &> /dev/null
+            if [ $? -eq 1 ]; then
+                selinux="no"
             else
-                rlDie "Provision method ${provision_method} is not supported by the test."
+                selinux="yes"
             fi
 
-            rlRun -s "tmt run -i $run --scratch     provision -h "$provision_method" $provision_options plan -n /plans/features/core"
+            is_superuser="yes"
+            bfu_is_superuser="no"
 
-            rlAssertGrep "arch: $arch" $rlRun_LOG
-            rlAssertGrep "distro: $distro" $rlRun_LOG
-            rlAssertNotGrep "kernel: $kernel" $rlRun_LOG
-            rlAssertNotGrep "package manager: $package_manager" $rlRun_LOG
-            rlAssertNotGrep "selinux: $selinux" $rlRun_LOG
-            rlAssertNotGrep "is superuser: " $rlRun_LOG
+        else
+            rlDie "Provision method ${PROVISION_HOW} is not supported by the test."
+        fi
+
+        rlRun -s "tmt run -i $run --scratch     provision -h "$PROVISION_HOW" $provision_options plan -n /plans/features/core"
 
-            rlRun -s "tmt run -i $run --scratch -vv provision -h "$provision_method" $provision_options plan -n /plans/features/core"
+        rlAssertGrep "arch: $arch" $rlRun_LOG
+        rlAssertGrep "distro: $distro" $rlRun_LOG
+        rlAssertNotGrep "kernel: $kernel" $rlRun_LOG
+        rlAssertNotGrep "package manager: $package_manager" $rlRun_LOG
+        rlAssertNotGrep "selinux: $selinux" $rlRun_LOG
+        rlAssertNotGrep "is superuser: " $rlRun_LOG
+
+        rlRun -s "tmt run -i $run --scratch -vv provision -h "$PROVISION_HOW" $provision_options plan -n /plans/features/core"
+
+        rlAssertGrep "arch: $arch" $rlRun_LOG
+        rlAssertGrep "distro: $distro" $rlRun_LOG
+        rlAssertGrep "kernel: $kernel" $rlRun_LOG
+        rlAssertGrep "package manager: $package_manager" $rlRun_LOG
+        rlAssertGrep "selinux: $selinux" $rlRun_LOG
+        rlAssertGrep "is superuser: $is_superuser" $rlRun_LOG
+
+        # If provisioning method allows a less privileged user, check that one as well
+        if [ "$bfu_provision_options" != "" ]; then
+            rlRun -s "tmt run -i $run --scratch -vv provision -h "$PROVISION_HOW" $bfu_provision_options plan -n /plans/features/core"
 
             rlAssertGrep "arch: $arch" $rlRun_LOG
             rlAssertGrep "distro: $distro" $rlRun_LOG
             rlAssertGrep "kernel: $kernel" $rlRun_LOG
             rlAssertGrep "package manager: $package_manager" $rlRun_LOG
             rlAssertGrep "selinux: $selinux" $rlRun_LOG
-            rlAssertGrep "is superuser: $is_superuser" $rlRun_LOG
-
-            # If provisioning method allows a less privileged user, check that one as well
-            if [ "$bfu_provision_options" != "" ]; then
-                rlRun -s "tmt run -i $run --scratch -vv provision -h "$provision_method" $bfu_provision_options plan -n /plans/features/core"
-
-                rlAssertGrep "arch: $arch" $rlRun_LOG
-                rlAssertGrep "distro: $distro" $rlRun_LOG
-                rlAssertGrep "kernel: $kernel" $rlRun_LOG
-                rlAssertGrep "package manager: $package_manager" $rlRun_LOG
-                rlAssertGrep "selinux: $selinux" $rlRun_LOG
-                rlAssertGrep "is superuser: $bfu_is_superuser" $rlRun_LOG
-            fi
+            rlAssertGrep "is superuser: $bfu_is_superuser" $rlRun_LOG
+        fi
 
-        rlPhaseEnd
-    done
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "rm -r $run" 0 "Remove run directory"
diff --git a/tests/provision/reboot/main.fmf b/tests/provision/reboot/main.fmf
index fef9a20111..10088ecfcf 100644
--- a/tests/provision/reboot/main.fmf
+++ b/tests/provision/reboot/main.fmf
@@ -1,16 +1,7 @@
 summary: Check that the reboot command works
-tag+: [provision-virtual]
-
-environment:
-    PROVISION_METHODS: container
-
-adjust:
-  - when: how == full
-    environment:
-        PROVISION_METHODS: container connect
-    tag+: [additional_coverage]
-
-  - when: how == beaker
-    environment:
-        PROVISION_METHODS: beaker
-    tag+: [additional_coverage]
+tag+:
+  - provision-only
+  - provision-beaker
+  - provision-virtual
+  - provision-connect
+  - provision-container
diff --git a/tests/provision/reboot/test.sh b/tests/provision/reboot/test.sh
index a7488955eb..ea73b12f0c 100755
--- a/tests/provision/reboot/test.sh
+++ b/tests/provision/reboot/test.sh
@@ -2,10 +2,9 @@
 # vim: dict+=/usr/share/beakerlib/dictionary.vim cpt=.,w,b,u,t,i,k
 . /usr/share/beakerlib/beakerlib.sh || exit 1
 
-PROVISION_METHODS=${PROVISION_METHODS:-container}
-
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-container}"
         rlRun "tmp=\$(mktemp -d)" 0 "Create tmp directory"
         rlRun "run=\$(mktemp -d)" 0 "Create run directory"
         rlRun "run_connect=\$(mktemp -d)" 0 "Create run directory for connect plugin"
@@ -15,7 +14,7 @@ rlJournalStart
         rlRun "tmt plan create -t mini plan"
     rlPhaseEnd
 
-    if [[ "$PROVISION_METHODS" =~ container ]]; then
+    if [[ "$PROVISION_HOW" =~ container ]]; then
         rlPhaseStartTest "Container"
             rlRun "tmt run -i $run provision -h container"
 
@@ -27,7 +26,7 @@ rlJournalStart
         rlPhaseEnd
     fi
 
-    if [[ "$PROVISION_METHODS" =~ beaker ]]; then
+    if [[ "$PROVISION_HOW" =~ beaker ]]; then
         rlPhaseStartTest "Beaker"
             rlRun "tmt run --scratch -i $run provision -h beaker"
 
@@ -43,7 +42,7 @@ rlJournalStart
         rlPhaseEnd
     fi
 
-    if [[ "$PROVISION_METHODS" =~ virtual ]]; then
+    if [[ "$PROVISION_HOW" =~ virtual ]]; then
         rlPhaseStartTest "Virtual"
             rlRun "tmt run --scratch -i $run provision -h virtual"
 
@@ -59,7 +58,7 @@ rlJournalStart
         rlPhaseEnd
     fi
 
-    if [[ "$PROVISION_METHODS" =~ connect ]]; then
+    if [[ "$PROVISION_HOW" =~ connect ]]; then
         rlPhaseStartTest "Connect"
             rlRun "tmt run --scratch -i $run provision -h virtual"
 
diff --git a/tests/provision/ssh-options/main.fmf b/tests/provision/ssh-options/main.fmf
index 3eddaf35fb..78917ebc08 100644
--- a/tests/provision/ssh-options/main.fmf
+++ b/tests/provision/ssh-options/main.fmf
@@ -1,6 +1,5 @@
 summary: Check that custom SSH options are used
-enabled: false
-adjust:
-  - when: how == full
-    enabled: true
-    tag+: [additional_coverage]
+tag+:
+  - provision-only
+  - provision-connect
+  - provision-virtual
diff --git a/tests/provision/ssh-options/test.sh b/tests/provision/ssh-options/test.sh
index 92acda8879..b3ccd3641b 100755
--- a/tests/provision/ssh-options/test.sh
+++ b/tests/provision/ssh-options/test.sh
@@ -1,21 +1,17 @@
 #!/bin/bash
-# vim: dict+=/usr/share/beakerlib/dictionary.vim cpt=.,w,b,u,t,i,k
 . /usr/share/beakerlib/beakerlib.sh || exit 1
 
-PROVISION_METHODS=${PROVISION_METHODS:-virtual}
-
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-virtual}"
         rlRun "run=\$(mktemp -d)" 0 "Create run directory"
         rlRun "pushd data"
     rlPhaseEnd
 
-    for provision_method in $PROVISION_METHODS; do
-        rlPhaseStartTest "Test with provision $provision_method"
-            rlRun "tmt run --scratch -vvi $run -a provision -h $provision_method --ssh-option ServerAliveCountMax=123456789"
-            rlAssertGrep "Run command: ssh .*-oServerAliveCountMax=123456789" "$run/log.txt"
-        rlPhaseEnd
-    done
+    rlPhaseStartTest "Test with provision $PROVISION_HOW"
+        rlRun "tmt run --scratch -vvi $run -a provision -h $PROVISION_HOW --ssh-option ServerAliveCountMax=123456789"
+        rlAssertGrep "Run command: ssh .*-oServerAliveCountMax=123456789" "$run/log.txt"
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "popd"
diff --git a/tests/provision/user/data/.fmf/version b/tests/provision/user/data/.fmf/version
new file mode 100644
index 0000000000..d00491fd7e
--- /dev/null
+++ b/tests/provision/user/data/.fmf/version
@@ -0,0 +1,1 @@
+1
diff --git a/tests/provision/user/data/plan.fmf b/tests/provision/user/data/plan.fmf
new file mode 100644
index 0000000000..a8d703f6be
--- /dev/null
+++ b/tests/provision/user/data/plan.fmf
@@ -0,0 +1,4 @@
+provision:
+    how: container
+execute:
+    script: id
diff --git a/tests/provision/user/main.fmf b/tests/provision/user/main.fmf
index 651647b58c..8d1c7d23fe 100644
--- a/tests/provision/user/main.fmf
+++ b/tests/provision/user/main.fmf
@@ -1,2 +1,5 @@
 summary: Check that setting a user works
-description: As for now covers podman provision only.
+tag+:
+  - provision-only
+  - provision-container
+  - provision-virtual
diff --git a/tests/provision/user/test.sh b/tests/provision/user/test.sh
index 00188b5814..02dd04e332 100755
--- a/tests/provision/user/test.sh
+++ b/tests/provision/user/test.sh
@@ -1,35 +1,25 @@
 #!/bin/bash
 . /usr/share/beakerlib/beakerlib.sh || exit 1
 
-PROVISION_METHODS=${PROVISION_METHODS:-container}
-
 rlJournalStart
     rlPhaseStartSetup
-        rlRun "tmp=\$(mktemp -d)" 0 "Create tmp directory"
-        rlRun "chmod go+rx $tmp" 0 "Make tmp directory accessible by others"
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-container}"
         rlRun "run=\$(mktemp -d)" 0 "Create run directory"
-        rlRun "pushd $tmp"
-        rlRun "set -o pipefail"
-        rlRun "tmt init"
-        STEPS="--execute 'script: id'"
-        rlRun "tmt plan create test --template mini $STEPS"
+        rlRun "pushd data"
     rlPhaseEnd
 
-    if [[ "$PROVISION_METHODS" =~ container ]]; then
-        rlPhaseStartTest "Container, default user root"
-            rlRun -s "tmt run -i $run -a provision -h container report -vvv"
-            rlAssertGrep "uid=0(root) gid=0(root) groups=0(root)" $rlRun_LOG
-        rlPhaseEnd
+    rlPhaseStartTest "Container, default user root"
+        rlRun -s "tmt run -i $run -a provision --how $PROVISION_HOW report -vvv"
+        rlAssertGrep "uid=0(root) gid=0(root) groups=0(root)" $rlRun_LOG
+    rlPhaseEnd
 
-        rlPhaseStartTest "Container, set specific user"
-            rlRun -s "tmt run --scratch -i $run -a provision -h container -u nobody report -vvv"
-            rlAssertGrep "uid=65534(nobody) gid=65534(nobody) groups=65534(nobody)" $rlRun_LOG
-        rlPhaseEnd
-    fi
+    rlPhaseStartTest "Container, set specific user"
+        rlRun -s "tmt run --scratch -i $run -a provision --how $PROVISION_HOW --user nobody report -vvv"
+        rlAssertGrep "uid=65534(nobody) gid=65534(nobody) groups=65534(nobody)" $rlRun_LOG
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "popd"
-        rlRun "rm -r $tmp" 0 "Remove tmp directory"
-        rlRun "rm -r $run" 0 "Remove run directory"
+        rlRun "rm -rf $run" 0 "Remove run directory"
     rlPhaseEnd
 rlJournalEnd
diff --git a/tests/provision/virtual.testcloud/main.fmf b/tests/provision/virtual.testcloud/main.fmf
index 203c7289b6..ee84cced3b 100644
--- a/tests/provision/virtual.testcloud/main.fmf
+++ b/tests/provision/virtual.testcloud/main.fmf
@@ -1,8 +1,6 @@
 summary: Make sure that virtual.testcloud works
-adjust:
--   when: how is not defined or how != full
-    enabled: false
-    because: needs to be able to spawn VM
+tag+:
+  - provision-only
+  - provision-virtual
 require:
-- tmt+provision-virtual
-tag: [virtual, additional_coverage]
+  - tmt+provision-virtual
diff --git a/tests/provision/virtual.testcloud/test.sh b/tests/provision/virtual.testcloud/test.sh
index ea43709848..1c2ac6f6d7 100755
--- a/tests/provision/virtual.testcloud/test.sh
+++ b/tests/provision/virtual.testcloud/test.sh
@@ -1,8 +1,6 @@
 #!/bin/bash
 . /usr/share/beakerlib/beakerlib.sh || exit 1
 
-PROVISION_METHODS=${PROVISION_METHODS:-virtual.testcloud}
-
 SRC_PLAN="$(pwd)/data/plan.fmf"
 
 rlJournalStart
diff --git a/tests/provision/virtual/dependencies/main.fmf b/tests/provision/virtual/dependencies/main.fmf
index 9f0dfcfae2..f2e611c91f 100644
--- a/tests/provision/virtual/dependencies/main.fmf
+++ b/tests/provision/virtual/dependencies/main.fmf
@@ -5,7 +5,14 @@ description:
     `system` connection to work without additional steps except
     for setting group and starting the `libvirtd` service for the
     `system` case.
-tag: provision-virtual-only
-tier: null
+tag+:
+  - provision-only
+  - provision-virtual
 require: tmt+provision-virtual
 order: 10
+
+# In order to properly verify that all packages necessary for the
+# virtual provision are installed on the guest, this test would
+# have to be a single one in the plan. Probably not worth it.
+# Disabling for now to prevent wasting resources.
+enabled: false
diff --git a/tests/pull/results/main.fmf b/tests/pull/results/main.fmf
index 91d72e75ce..b117b5ddc0 100644
--- a/tests/pull/results/main.fmf
+++ b/tests/pull/results/main.fmf
@@ -3,7 +3,6 @@ description:
     Check that test logs are correctly fetched from the guest,
     test results are stored into `results.yaml` and plan data
     directory content is synced back.
-tag+: [provision-virtual]
-
-environment:
-    PROVISION_METHODS: container local
+tag+:
+  - provision-container
+  - provision-virtual
diff --git a/tests/pull/results/test.sh b/tests/pull/results/test.sh
index 51cd56643c..c8ade3c914 100755
--- a/tests/pull/results/test.sh
+++ b/tests/pull/results/test.sh
@@ -3,45 +3,44 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-local}"
         rlRun "run=\$(mktemp -d)" 0 "Create run directory"
         rlRun "pushd data"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-local}; do
-        rlPhaseStartTest "Test $method"
-            # Run the plan, check for expected results
-            rlRun -s "tmt run -av --scratch --id $run provision -h $method" 1
-            rlAssertGrep "2 tests passed and 1 test failed" $rlRun_LOG
+    rlPhaseStartTest "Test $PROVISION_HOW"
+        # Run the plan, check for expected results
+        rlRun -s "tmt run -av --scratch --id $run provision -h $PROVISION_HOW" 1
+        rlAssertGrep "2 tests passed and 1 test failed" $rlRun_LOG
 
-            # Check output and extra logs in the test data directory
-            data="$run/plan/execute/data"
-            rlAssertGrep "ok" "$data/guest/default-0/test/good-3/output.txt"
-            rlAssertGrep "ko" "$data/guest/default-0/test/bad-1/output.txt"
-            rlAssertGrep "extra good" "$data/guest/default-0/test/good-3/data/extra.log"
-            rlAssertGrep "extra bad" "$data/guest/default-0/test/bad-1/data/extra.log"
+        # Check output and extra logs in the test data directory
+        data="$run/plan/execute/data"
+        rlAssertGrep "ok" "$data/guest/default-0/test/good-3/output.txt"
+        rlAssertGrep "ko" "$data/guest/default-0/test/bad-1/output.txt"
+        rlAssertGrep "extra good" "$data/guest/default-0/test/good-3/data/extra.log"
+        rlAssertGrep "extra bad" "$data/guest/default-0/test/bad-1/data/extra.log"
 
-            # Check logs in the plan data directory
-            rlAssertGrep "common good" "$run/plan/data/log.txt"
-            rlAssertGrep "common bad" "$run/plan/data/log.txt"
+        # Check logs in the plan data directory
+        rlAssertGrep "common good" "$run/plan/data/log.txt"
+        rlAssertGrep "common bad" "$run/plan/data/log.txt"
 
-            # Check report of the last run for correct results
-            rlRun -s "tmt run --last report" 1
-            rlAssertGrep "2 tests passed and 1 test failed" $rlRun_LOG
+        # Check report of the last run for correct results
+        rlRun -s "tmt run --last report" 1
+        rlAssertGrep "2 tests passed and 1 test failed" $rlRun_LOG
 
-            # Check beakerlib's backup directory pull
-            if [[ "$method" =~ local|container ]]; then
-                # No pull happened so it shoud be present
-                rlAssertExists "$data/guest/default-0/test/beakerlib-2/backup"
-                rlAssertExists "$data/guest/default-0/test/beakerlib-2/backup-NS1"
-                rlAssertNotEquals "any backup dir is present" "$(eval 'echo $data/guest/default-0/test/beakerlib-2/backup*')" "$data/guest/default-0/test/beakerlib-2/backup*"
-            else
-                # Should be ignored
-                rlAssertNotExists "$data/guest/default-0/test/beakerlib-2/backup"
-                rlAssertNotExists "$data/guest/default-0/test/beakerlib-2/backup-NS1"
-                rlAssertEquals "no backup dir is present" "$(eval 'echo $data/guest/default-0/test/beakerlib-2/backup*')" "$data/guest/default-0/test/beakerlib-2/backup*"
-            fi
-        rlPhaseEnd
-    done
+        # Check beakerlib's backup directory pull
+        if [[ "$PROVISION_HOW" =~ local|container ]]; then
+            # No pull happened so it shoud be present
+            rlAssertExists "$data/guest/default-0/test/beakerlib-2/backup"
+            rlAssertExists "$data/guest/default-0/test/beakerlib-2/backup-NS1"
+            rlAssertNotEquals "any backup dir is present" "$(eval 'echo $data/guest/default-0/test/beakerlib-2/backup*')" "$data/guest/default-0/test/beakerlib-2/backup*"
+        else
+            # Should be ignored
+            rlAssertNotExists "$data/guest/default-0/test/beakerlib-2/backup"
+            rlAssertNotExists "$data/guest/default-0/test/beakerlib-2/backup-NS1"
+            rlAssertEquals "no backup dir is present" "$(eval 'echo $data/guest/default-0/test/beakerlib-2/backup*')" "$data/guest/default-0/test/beakerlib-2/backup*"
+        fi
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "popd"
diff --git a/tests/pull/simple/main.fmf b/tests/pull/simple/main.fmf
index ef16704b4f..4f52bca004 100644
--- a/tests/pull/simple/main.fmf
+++ b/tests/pull/simple/main.fmf
@@ -3,9 +3,8 @@ description:
     Make sure that provisioning a guest and clean it up works as
     expected even if no preparation, test execution or finish step
     scripts are performed.
-tag+: [provision-virtual]
+tag+:
+  - provision-container
+  - provision-virtual
 link:
   - verifies: https://github.com/teemtee/tmt/issues/1011
-
-environment:
-    PROVISION_METHODS: container local
diff --git a/tests/pull/simple/test.sh b/tests/pull/simple/test.sh
index 86472ac144..0445fd346c 100755
--- a/tests/pull/simple/test.sh
+++ b/tests/pull/simple/test.sh
@@ -3,21 +3,20 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-local}"
         rlRun "run=\$(mktemp -d)" 0 "Create run directory"
         rlRun "tmp=\$(mktemp -d)" 0 "Create tmt directory"
         rlRun "pushd $tmp"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-local}; do
-        rlPhaseStartTest "Test one step ($method)"
-            rlRun "tmt run -i $run --scratch provision -h $method finish"
-        rlPhaseEnd
+    rlPhaseStartTest "Test one step ($PROVISION_HOW)"
+        rlRun "tmt run -i $run --scratch provision -h $PROVISION_HOW finish"
+    rlPhaseEnd
 
-        rlPhaseStartTest "Test two steps ($method)"
-            rlRun "tmt run -i $run --scratch provision -h $method"
-            rlRun "tmt run -i $run finish"
-        rlPhaseEnd
-    done
+    rlPhaseStartTest "Test two steps ($PROVISION_HOW)"
+        rlRun "tmt run -i $run --scratch provision -h $PROVISION_HOW"
+        rlRun "tmt run -i $run finish"
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "popd"
diff --git a/tests/run/shell/main.fmf b/tests/run/shell/main.fmf
index 9f2d3578fa..e949868f3b 100644
--- a/tests/run/shell/main.fmf
+++ b/tests/run/shell/main.fmf
@@ -2,14 +2,9 @@ summary: Use bash regardless users' login shell or /bin/sh value
 test: ./test.sh
 framework: beakerlib
 require:
-- zsh
-- tmt
+  - zsh
+  - tmt
 tag+:
-- as_root
-- provision-virtual-only
-enabled: false
-adjust+:
-  - enabled: true
-    when: how == full
-    tag+: [additional_coverage]
-tier: null
+  - as_root
+  - provision-only
+  - provision-virtual
diff --git a/tests/run/shell/test.sh b/tests/run/shell/test.sh
index 10c4211097..c0f5f3dc38 100755
--- a/tests/run/shell/test.sh
+++ b/tests/run/shell/test.sh
@@ -25,7 +25,7 @@ rlJournalStart
         # BASH_VERSION is not set unless in running in BASH
         # Reproducer plan uses 'local' provisioner.
         # as of now support for 'user' in virtual is not always working
-        rlRun "su -l -c 'cd data && tmt run -v --id /home/$USER/run_id plan --name /reproducer' $USER"
+        rlRun "su -l -c 'cd data && TMT_TEST_PIDFILE_ROOT=/tmp tmt run -v --id /home/$USER/run_id plan --name /reproducer' $USER"
         rlBundleLogs "log_txt" "/home/$USER/run_id/log.txt"
     rlPhaseEnd
 
diff --git a/tests/run/worktree/main.fmf b/tests/run/worktree/main.fmf
index 6581a46200..d0d046ea68 100644
--- a/tests/run/worktree/main.fmf
+++ b/tests/run/worktree/main.fmf
@@ -9,10 +9,7 @@ description:
     against `local` and during `full` testing using `virtual` as
     well.
 require+: [tmt+provision-container]
-
-environment:
-    PROVISION_METHODS: 'container'
-adjust+:
-  - environment:
-        PROVISION_METHODS: 'container local'
-    when: trigger == commit
+tag+:
+  - provision-only
+  - provision-container
+  - provision-local
diff --git a/tests/run/worktree/test.sh b/tests/run/worktree/test.sh
index 00a0ad4b83..64b04c78b3 100755
--- a/tests/run/worktree/test.sh
+++ b/tests/run/worktree/test.sh
@@ -2,29 +2,31 @@
 . /usr/share/beakerlib/beakerlib.sh || exit 1
 
 rlJournalStart
-    for method in ${PROVISION_METHODS:-container}; do
-        rlPhaseStartTest "Simple ($method)"
-            rlRun "pushd data/simple"
-            rlRun "tmt run -ar provision -h $method report -vvv"
-            rlRun "popd"
-        rlPhaseEnd
+    rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-container}"
+    rlPhaseEnd
 
-        rlPhaseStartTest "Prepare ($method)"
-            rlRun "pushd data/prepare"
-            rlRun "tmt run -ar provision -h $method report -vvv"
-            rlRun "popd"
-        rlPhaseEnd
+    rlPhaseStartTest "Simple ($PROVISION_HOW)"
+        rlRun "pushd data/simple"
+        rlRun "tmt run -ar provision -h $PROVISION_HOW report -vvv"
+        rlRun "popd"
+    rlPhaseEnd
 
-        rlPhaseStartTest "Ansible ($method)"
-            rlRun "pushd data/ansible"
-            rlRun "tmt run -ar provision -h $method report -vvv"
-            rlRun "popd"
-        rlPhaseEnd
+    rlPhaseStartTest "Prepare ($PROVISION_HOW)"
+        rlRun "pushd data/prepare"
+        rlRun "tmt run -ar provision -h $PROVISION_HOW report -vvv"
+        rlRun "popd"
+    rlPhaseEnd
 
-        rlPhaseStartTest "Verify the TMT_TREE variable ($method)"
-            rlRun "pushd data/tree"
-            rlRun "tmt run -ar provision -h $method report -vvv"
-            rlRun "popd"
-        rlPhaseEnd
-    done
+    rlPhaseStartTest "Ansible ($PROVISION_HOW)"
+        rlRun "pushd data/ansible"
+        rlRun "tmt run -ar provision -h $PROVISION_HOW report -vvv"
+        rlRun "popd"
+    rlPhaseEnd
+
+    rlPhaseStartTest "Verify the TMT_TREE variable ($PROVISION_HOW)"
+        rlRun "pushd data/tree"
+        rlRun "tmt run -ar provision -h $PROVISION_HOW report -vvv"
+        rlRun "popd"
+    rlPhaseEnd
 rlJournalEnd
diff --git a/tests/security/ansible/main.fmf b/tests/security/ansible/main.fmf
index ef3e5e427a..8e5bfb1fc4 100644
--- a/tests/security/ansible/main.fmf
+++ b/tests/security/ansible/main.fmf
@@ -1,12 +1,6 @@
 summary: Check whether an injected shell code is executed
-tier: 4
-tag+: [provision-virtual]
-
-# By default, we run under a container only
-environment:
-    PROVISION_METHODS: container
-adjust:
-  - when: trigger == commit
-    environment:
-        PROVISION_METHODS: container local
-    because: the pipeline does not support nested virtualization
+tier: null
+tag+:
+  - provision-container
+  - provision-local
+  - provision-virtual
diff --git a/tests/security/ansible/test.sh b/tests/security/ansible/test.sh
index 4014c6392a..f9b23db201 100755
--- a/tests/security/ansible/test.sh
+++ b/tests/security/ansible/test.sh
@@ -3,18 +3,17 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-container}"
         rlRun "run=\$(mktemp -d)" 0 "Create a run directory"
         rlRun "secret=\$(mktemp /tmp/secret.XXX)" 0 "Create a secret file"
         rlRun "echo revealed > $secret" 0 "Add a secret content"
         rlRun "pushd data"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-container}; do
-        rlPhaseStartTest "Test ($method)"
-            rlRun -s "tmt run --id $run -avvvddd provision -h $method" 1-3
-            rlAssertNotGrep "revealed" $rlRun_LOG
-        rlPhaseEnd
-    done
+    rlPhaseStartTest "Test ($PROVISION_HOW)"
+        rlRun -s "tmt run --id $run -avvvddd provision -h $PROVISION_HOW" 1-3
+        rlAssertNotGrep "revealed" $rlRun_LOG
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "popd"
diff --git a/tests/test/check/main.fmf b/tests/test/check/main.fmf
index 58c952c787..013e7826aa 100644
--- a/tests/test/check/main.fmf
+++ b/tests/test/check/main.fmf
@@ -3,13 +3,11 @@ tier: 2
 tag+: [provision-virtual]
 
 /dmesg:
-  test: ./test-dmesg.sh
-
-  environment:
-      PROVISION_METHODS: local container
+    test: ./test-dmesg.sh
+    tag+:
+      - provision-only
+      - provision-container
+      - provision-local
 
 /avc:
-  test: ./test-avc.sh
-
-  environment:
-      PROVISION_METHODS: local
+    test: ./test-avc.sh
diff --git a/tests/test/check/test-avc.sh b/tests/test/check/test-avc.sh
index aec62f3ed1..f704b04e8a 100755
--- a/tests/test/check/test-avc.sh
+++ b/tests/test/check/test-avc.sh
@@ -9,6 +9,7 @@ function assert_check_result () {
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-local}"
         rlRun "run=\$(mktemp -d)" 0 "Create run directory"
 
         rlRun "results=$run/plan/execute/results.yaml"
@@ -16,37 +17,35 @@ rlJournalStart
         rlRun "pushd data"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-local}; do
-        rlPhaseStartTest "Run /avc tests with $method"
-            rlRun "tmt -c provision_method=$method run --id $run --scratch -a -vv provision -h $method test -n /avc"
-            rlRun "cat $results"
-        rlPhaseEnd
-
-        rlPhaseStartTest "Test harmless AVC check with $method"
-            rlRun "avc_log=$run/plan/execute/data/guest/default-0/avc/harmless-2/checks/avc.txt"
-            rlAssertExists "$avc_log"
-            rlRun "cat $avc_log"
-
-            assert_check_result "avc as an after-test should pass" "pass" "after-test" "/avc/harmless"
-
-            rlAssertGrep "# timestamp" "$avc_log"
-            rlAssertGrep "export AVC_SINCE=\"[[:digit:]]{2}/[[:digit:]]{2}/[[:digit:]]{4} [[:digit:]]{2}:[[:digit:]]{2}:[[:digit:]]{2}\"" "$avc_log" -E
-            rlAssertGrep "<no matches>" "$avc_log"
-        rlPhaseEnd
-
-        rlPhaseStartTest "Test nasty AVC check with $method"
-            rlRun "avc_log=$run/plan/execute/data/guest/default-0/avc/nasty-1/checks/avc.txt"
-            rlAssertExists "$avc_log"
-            rlRun "cat $avc_log"
-
-            assert_check_result "avc as an after-test should report AVC denials" "fail" "after-test" "/avc/nasty"
-
-            rlAssertGrep "# timestamp" "$avc_log"
-            rlAssertGrep "export AVC_SINCE=\"[[:digit:]]{2}/[[:digit:]]{2}/[[:digit:]]{4} [[:digit:]]{2}:[[:digit:]]{2}:[[:digit:]]{2}\"" "$avc_log" -E
-            rlAssertGrep "avc:  denied" "$avc_log"
-            rlAssertGrep "path=/root/passwd.log" "$avc_log"
-        rlPhaseEnd
-    done
+    rlPhaseStartTest "Run /avc tests with $PROVISION_HOW"
+        rlRun "tmt -c provision_method=$PROVISION_HOW run --id $run --scratch -a -vv provision -h $PROVISION_HOW test -n /avc"
+        rlRun "cat $results"
+    rlPhaseEnd
+
+    rlPhaseStartTest "Test harmless AVC check with $PROVISION_HOW"
+        rlRun "avc_log=$run/plan/execute/data/guest/default-0/avc/harmless-2/checks/avc.txt"
+        rlAssertExists "$avc_log"
+        rlRun "cat $avc_log"
+
+        assert_check_result "avc as an after-test should pass" "pass" "after-test" "/avc/harmless"
+
+        rlAssertGrep "# timestamp" "$avc_log"
+        rlAssertGrep "export AVC_SINCE=\"[[:digit:]]{2}/[[:digit:]]{2}/[[:digit:]]{4} [[:digit:]]{2}:[[:digit:]]{2}:[[:digit:]]{2}\"" "$avc_log" -E
+        rlAssertGrep "<no matches>" "$avc_log"
+    rlPhaseEnd
+
+    rlPhaseStartTest "Test nasty AVC check with $PROVISION_HOW"
+        rlRun "avc_log=$run/plan/execute/data/guest/default-0/avc/nasty-1/checks/avc.txt"
+        rlAssertExists "$avc_log"
+        rlRun "cat $avc_log"
+
+        assert_check_result "avc as an after-test should report AVC denials" "fail" "after-test" "/avc/nasty"
+
+        rlAssertGrep "# timestamp" "$avc_log"
+        rlAssertGrep "export AVC_SINCE=\"[[:digit:]]{2}/[[:digit:]]{2}/[[:digit:]]{4} [[:digit:]]{2}:[[:digit:]]{2}:[[:digit:]]{2}\"" "$avc_log" -E
+        rlAssertGrep "avc:  denied" "$avc_log"
+        rlAssertGrep "path=/root/passwd.log" "$avc_log"
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "popd"
diff --git a/tests/test/check/test-dmesg.sh b/tests/test/check/test-dmesg.sh
index 0ca5f2b323..b7a460d5cf 100755
--- a/tests/test/check/test-dmesg.sh
+++ b/tests/test/check/test-dmesg.sh
@@ -13,6 +13,7 @@ function assert_check_result () {
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-container}"
         rlRun "run=\$(mktemp -d)" 0 "Create run directory"
 
         rlRun "results=$run/plan/execute/results.yaml"
@@ -25,52 +26,50 @@ rlJournalStart
         rlRun "set -o pipefail"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-local}; do
-        rlPhaseStartTest "Test dmesg check with $method"
-            # Segfault test only reproducible with virtual (needs root)
-            if [ "$method" = "virtual" ]; then
-                test_name=/dmesg
-            else
-                test_name=/dmesg/harmless
-            fi
+    rlPhaseStartTest "Test dmesg check with $PROVISION_HOW"
+        # Segfault test only reproducible with virtual (needs root)
+        if [ "$PROVISION_HOW" = "virtual" ]; then
+            test_name=/dmesg
+        else
+            test_name=/dmesg/harmless
+        fi
 
-            rlRun "tmt run --id $run --scratch -a -vv provision -h $method test -n $test_name"
+        rlRun "tmt run --id $run --scratch -a -vv provision -h $PROVISION_HOW test -n $test_name"
 
-            rlRun "cat $results"
+        rlRun "cat $results"
 
-            if [ "$method" = "container" ]; then
-                assert_check_result "dmesg as a before-test should skip with containers" "skip" "before-test" "harmless"
+        if [ "$PROVISION_HOW" = "container" ]; then
+            assert_check_result "dmesg as a before-test should skip with containers" "skip" "before-test" "harmless"
 
-                rlAssertNotExists "$dump_before"
+            rlAssertNotExists "$dump_before"
 
-            else
-                assert_check_result "dmesg as a before-test should pass" "pass" "before-test" "harmless"
+        else
+            assert_check_result "dmesg as a before-test should pass" "pass" "before-test" "harmless"
 
-                rlAssertExists "$dump_before"
-                rlLogInfo "$(cat $dump_before)"
-            fi
+            rlAssertExists "$dump_before"
+            rlLogInfo "$(cat $dump_before)"
+        fi
 
-            if [ "$method" = "container" ]; then
-                assert_check_result "dmesg as an after-test should skip with containers" "skip" "after-test" "harmless"
+        if [ "$PROVISION_HOW" = "container" ]; then
+            assert_check_result "dmesg as an after-test should skip with containers" "skip" "after-test" "harmless"
 
-                rlAssertNotExists "$dump_after"
+            rlAssertNotExists "$dump_after"
 
-            elif [ "$method" = "virtual" ]; then
-                assert_check_result "dmesg as an after-test should fail" "fail" "after-test" "segfault"
+        elif [ "$PROVISION_HOW" = "virtual" ]; then
+            assert_check_result "dmesg as an after-test should fail" "fail" "after-test" "segfault"
 
-                rlAssertExists "$dump_after"
-                rlLogInfo "$(cat $dump_after)"
+            rlAssertExists "$dump_after"
+            rlLogInfo "$(cat $dump_after)"
 
-                rlAssertGrep "Some segfault happened" "$segfault/checks/dmesg-after-test.txt"
+            rlAssertGrep "Some segfault happened" "$segfault/checks/dmesg-after-test.txt"
 
-            else
-                assert_check_result "dmesg as an after-test should pass" "pass" "after-test" "harmless"
+        else
+            assert_check_result "dmesg as an after-test should pass" "pass" "after-test" "harmless"
 
-                rlAssertExists "$dump_after"
-                rlLogInfo "$(cat $dump_after)"
-            fi
-        rlPhaseEnd
-    done
+            rlAssertExists "$dump_after"
+            rlLogInfo "$(cat $dump_after)"
+        fi
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "popd"
diff --git a/tests/test/debug/main.fmf b/tests/test/debug/main.fmf
index bcfd98a2b6..5beb8f2b15 100644
--- a/tests/test/debug/main.fmf
+++ b/tests/test/debug/main.fmf
@@ -2,7 +2,6 @@ summary: Verify that test debugging works fine
 description:
     Prepare the environment for testing using provision & prepare,
     then debug test code using repeated discover & execute.
-tag+: [provision-virtual]
-
-environment:
-    PROVISION_METHODS: local container
+tag+:
+  - provision-container
+  - provision-virtual
diff --git a/tests/test/debug/test.sh b/tests/test/debug/test.sh
index c3259a3ed9..4cd4a80072 100755
--- a/tests/test/debug/test.sh
+++ b/tests/test/debug/test.sh
@@ -3,6 +3,7 @@
 
 rlJournalStart
     rlPhaseStartSetup
+        rlRun "PROVISION_HOW=${PROVISION_HOW:-local}"
         rlRun "tmp=\$(mktemp -d)" 0 "Create tmp directory"
         rlRun "run=\$(mktemp -d)" 0 "Create run directory"
         rlRun "pushd $tmp"
@@ -11,24 +12,22 @@ rlJournalStart
         rlRun "tmt test create --template shell /test"
     rlPhaseEnd
 
-    for method in ${PROVISION_METHODS:-local}; do
-        rlPhaseStartTest "Test $method"
-            # Run until execute
-            tmt="tmt run --id $run --verbose"
-            rlRun "$tmt --all --scratch --before execute provision -h $method"
+    rlPhaseStartTest "Test $PROVISION_HOW"
+        # Run until execute
+        tmt="tmt run --id $run --verbose"
+        rlRun "$tmt --all --scratch --before execute provision -h $PROVISION_HOW"
 
-            # Failing test
-            rlRun "echo -e '#!/bin/bash\n/bin/false' > test/test.sh"
-            rlRun "$tmt discover --force execute --force" 1 "Failing test"
+        # Failing test
+        rlRun "echo -e '#!/bin/bash\n/bin/false' > test/test.sh"
+        rlRun "$tmt discover --force execute --force" 1 "Failing test"
 
-            # Fixed test
-            rlRun "echo -e '#!/bin/bash\n/bin/true' > test/test.sh"
-            rlRun "$tmt discover --force execute --force" 0 "Fixed test"
+        # Fixed test
+        rlRun "echo -e '#!/bin/bash\n/bin/true' > test/test.sh"
+        rlRun "$tmt discover --force execute --force" 0 "Fixed test"
 
-            # Clenup until finish
-            rlRun "$tmt --until finish"
-        rlPhaseEnd
-    done
+        # Clenup until finish
+        rlRun "$tmt --until finish"
+    rlPhaseEnd
 
     rlPhaseStartCleanup
         rlRun "popd"