From f3d97c9d9a316062f7b67272cddc3aed6ebd84de Mon Sep 17 00:00:00 2001
From: Jon Cope <jcope@redhat.com>
Date: Wed, 24 Jul 2024 15:43:44 -0500
Subject: [PATCH] implementation of Optional CSI Config:
 openshift/enhancements#1635

expand microshift config with new storage root field. allows users to disable LVMS and/or CSI components

Signed-off-by: Jon Cope <jcope@redhat.com>
---
 .../config/config-openapi-spec.json           |  31 ++-
 docs/user/howto_config.md                     |   8 +
 .../openshift/microshift/pkg/config/config.go |  11 +-
 .../microshift/pkg/config/storage.go          | 116 ++++++++
 packaging/greenboot/functions.sh              |  92 +++++++
 .../greenboot/microshift-running-check.sh     |  31 ++-
 packaging/microshift/config.yaml              |  19 ++
 packaging/rpm/microshift.spec                 |   1 +
 pkg/components/csi-snapshot-controller.go     |  89 +++++--
 pkg/components/storage.go                     |   4 +
 pkg/config/config.go                          |  11 +-
 pkg/config/config_test.go                     |  18 +-
 pkg/config/storage.go                         | 116 ++++++++
 pkg/config/storage_test.go                    | 250 ++++++++++++++++++
 test/resources/oc.resource                    |   9 +
 test/suites/standard1/configuration.robot     | 111 ++++++--
 test/suites/tuned/microshift-tuned.robot      |   3 +-
 17 files changed, 854 insertions(+), 66 deletions(-)
 create mode 100644 etcd/vendor/github.com/openshift/microshift/pkg/config/storage.go
 create mode 100644 pkg/config/storage.go
 create mode 100644 pkg/config/storage_test.go

diff --git a/cmd/generate-config/config/config-openapi-spec.json b/cmd/generate-config/config/config-openapi-spec.json
index a8f87e040a..e8d8c21621 100755
--- a/cmd/generate-config/config/config-openapi-spec.json
+++ b/cmd/generate-config/config/config-openapi-spec.json
@@ -9,7 +9,8 @@
     "kubelet",
     "manifests",
     "network",
-    "node"
+    "node",
+    "storage"
   ],
   "properties": {
     "apiServer": {
@@ -267,6 +268,34 @@
           "type": "string"
         }
       }
+    },
+    "storage": {
+      "description": "Storage represents a subfield of the MicroShift config data structure. Its purpose to provide a user\nfacing interface to control whether MicroShift should deploy LVMS on startup.",
+      "type": "object",
+      "properties": {
+        "driver": {
+          "description": "Driver is a user defined string value matching one of the above CSIStorageDriver values. MicroShift uses this\nvalue to decide whether to deploy the LVMS operator. An unset field defaults to \"\" during yaml parsing, and thus\ncould mean that the cluster has been upgraded. In order to support the existing out-of-box behavior, MicroShift\nassumes an empty string to mean the storage driver should be deployed.\nAllowed values are: unset or one of [\"\", \"lvms\", \"none\"]",
+          "type": "string",
+          "enum": [
+            "",
+            "none",
+            "lvms"
+          ]
+        },
+        "optionalCsiComponents": {
+          "description": "OptionalCSIComponents is a user defined slice of CSIComponent values. These value tell MicroShift which\nadditional, non-driver, CSI controllers to deploy on start. MicroShift will deploy snapshot controller\nand webhook when no components are specified. This preserves the current deployment behavior of existing\nclusters. Users must set `.storage.optionalCsiComponents: []` to explicitly tell MicroShift not to deploy any CSI\ncomponents. The CSI Driver is excluded as it is typically deployed via the same manifest as the accompanying\nstorage driver. Like CSIStorageDriver, uninstallation is not supported as this can lead to orphaned storage\nobjects.\nAllowed values are: unset, [], or one or more of [\"snapshot-controller\", \"snapshot-webhook\"]",
+          "type": "array",
+          "items": {
+            "description": "OptionalCsiComponent values determine which CSI components MicroShift should deploy. Currently only csi snapshot components\nare supported.",
+            "type": "string",
+            "enum": [
+              "none",
+              "snapshot-controller",
+              "snapshot-webhook"
+            ]
+          }
+        }
+      }
     }
   }
 }
\ No newline at end of file
diff --git a/docs/user/howto_config.md b/docs/user/howto_config.md
index 6e4daa1b8a..fdbf570ba9 100644
--- a/docs/user/howto_config.md
+++ b/docs/user/howto_config.md
@@ -50,6 +50,10 @@ node:
     hostnameOverride: ""
     nodeIP: ""
     nodeIPv6: ""
+storage:
+    driver: ""
+    optionalCsiComponents:
+        - ""
 
 ```
 <!---
@@ -110,6 +114,10 @@ node:
     hostnameOverride: ""
     nodeIP: ""
     nodeIPv6: ""
+storage:
+    driver: ""
+    optionalCsiComponents:
+        - ""
 
 ```
 <!---
diff --git a/etcd/vendor/github.com/openshift/microshift/pkg/config/config.go b/etcd/vendor/github.com/openshift/microshift/pkg/config/config.go
index 2ca0fbece2..4a6f7a0ace 100644
--- a/etcd/vendor/github.com/openshift/microshift/pkg/config/config.go
+++ b/etcd/vendor/github.com/openshift/microshift/pkg/config/config.go
@@ -50,6 +50,7 @@ type Config struct {
 	Debugging Debugging     `json:"debugging"`
 	Manifests Manifests     `json:"manifests"`
 	Ingress   IngressConfig `json:"ingress"`
+	Storage   Storage       `json:"storage"`
 
 	// Settings specified in this section are transferred as-is into the Kubelet config.
 	// +kubebuilder:validation:Schemaless
@@ -146,7 +147,6 @@ func (c *Config) fillDefaults() error {
 			Https: ptr.To[int](443),
 		},
 	}
-
 	c.MultiNode.Enabled = false
 	c.Kubelet = nil
 
@@ -257,6 +257,12 @@ func (c *Config) incorporateUserSettings(u *Config) {
 		c.ApiServer.NamedCertificates = u.ApiServer.NamedCertificates
 	}
 
+	if u.Storage.Driver != "" {
+		c.Storage.Driver = u.Storage.Driver
+	}
+	if len(u.Storage.OptionalCSIComponents) > 0 {
+		c.Storage.OptionalCSIComponents = u.Storage.OptionalCSIComponents
+	}
 	if u.Kubelet != nil {
 		c.Kubelet = u.Kubelet
 	}
@@ -457,6 +463,9 @@ func (c *Config) validate() error {
 		return fmt.Errorf("error validating node.nodeIPv6: %w", err)
 	}
 
+	if errs := c.Storage.IsValid(); c.Storage.IsEnabled() && len(errs) > 0 {
+		return fmt.Errorf("error validating storage: %w", errors.Join(errs...))
+	}
 	return nil
 }
 
diff --git a/etcd/vendor/github.com/openshift/microshift/pkg/config/storage.go b/etcd/vendor/github.com/openshift/microshift/pkg/config/storage.go
new file mode 100644
index 0000000000..db29432809
--- /dev/null
+++ b/etcd/vendor/github.com/openshift/microshift/pkg/config/storage.go
@@ -0,0 +1,116 @@
+package config
+
+import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/util/sets"
+)
+
+// CSIStorageDriver is an enum value that determines whether MicroShift deploys LVMS.
+// +kubebuilder:validation:Enum:="";none;lvms
+type CSIStorageDriver string
+
+const (
+	// CsiDriverUnset exists to support backwards compatibility with existing MicroShift clusters. When .storage.driver is
+	// "", MicroShift will default to deploying LVMS. This preserves the current deployment behavior of existing
+	// clusters.
+	CsiDriverUnset CSIStorageDriver = ""
+	//  CsiDriverNone signals MicroShift to not deploy the LVMS components. Setting the value for a cluster that has already
+	//  deployed LVMS will not cause LVMS to be deleted. Otherwise, volumes already deployed on the cluster would be
+	//  orphaned once their workloads stop or restart.
+	CsiDriverNone CSIStorageDriver = "none"
+	// CsiDriverLVMS is equivalent to CsiDriverUnset, and explicitly tells MicroShift to deploy LVMS. This option exists to
+	// provide a differentiation between LVMS and potential future driver options.
+	CsiDriverLVMS CSIStorageDriver = "lvms"
+)
+
+// OptionalCsiComponent values determine which CSI components MicroShift should deploy. Currently only csi snapshot components
+// are supported.
+// +kubebuilder:validation:Enum:=none;snapshot-controller;snapshot-webhook
+type OptionalCsiComponent string
+
+const (
+	// CsiComponentNone exists to support backwards compatibility with existing MicroShift clusters. By default,
+	// MicroShift will deploy snapshot controller and webhook when no components are specified. This preserves the
+	// current deployment behavior of existing clusters. Users must set .storage.with-csi-components: [ "none" ] to
+	// explicitly tell MicroShift not to deploy any CSI components. The CSI Driver is excluded as it is typically
+	// deployed via the same manifest as the accompanying storage driver. Like DriverOpt, uninstallation is not
+	// supported as this can lead to orphaned storage volumes. Mutually exclusive with all other ComponentOpt values.
+	CsiComponentNone OptionalCsiComponent = "none"
+	// CsiComponentSnapshot causes MicroShift to deploy the CSI Snapshot controller.
+	CsiComponentSnapshot OptionalCsiComponent = "snapshot-controller"
+	// CsiComponentSnapshotWebhook causes MicroShift to deploy the CSI Snapshot Validation Webhook.
+	CsiComponentSnapshotWebhook OptionalCsiComponent = "snapshot-webhook"
+)
+
+// Storage represents a subfield of the MicroShift config data structure. Its purpose to provide a user
+// facing interface to control whether MicroShift should deploy LVMS on startup.
+type Storage struct {
+	// Driver is a user defined string value matching one of the above CSIStorageDriver values. MicroShift uses this
+	// value to decide whether to deploy the LVMS operator. An unset field defaults to "" during yaml parsing, and thus
+	// could mean that the cluster has been upgraded. In order to support the existing out-of-box behavior, MicroShift
+	// assumes an empty string to mean the storage driver should be deployed.
+	// Allowed values are: unset or one of ["", "lvms", "none"]
+	// +kubebuilder:validation:Optional
+	Driver CSIStorageDriver `json:"driver,omitempty"`
+	// OptionalCSIComponents is a user defined slice of CSIComponent values. These value tell MicroShift which
+	// additional, non-driver, CSI controllers to deploy on start. MicroShift will deploy snapshot controller
+	// and webhook when no components are specified. This preserves the current deployment behavior of existing
+	// clusters. Users must set `.storage.optionalCsiComponents: []` to explicitly tell MicroShift not to deploy any CSI
+	// components. The CSI Driver is excluded as it is typically deployed via the same manifest as the accompanying
+	// storage driver. Like CSIStorageDriver, uninstallation is not supported as this can lead to orphaned storage
+	// objects.
+	// Allowed values are: unset, [], or one or more of ["snapshot-controller", "snapshot-webhook"]
+	// +kubebuilder:validation:Optional
+	OptionalCSIComponents []OptionalCsiComponent `json:"optionalCsiComponents,omitempty"`
+}
+
+func (s Storage) driverIsValid() (isSupported bool) {
+	return sets.New[CSIStorageDriver](CsiDriverNone, CsiDriverLVMS, CsiDriverUnset).Has(s.Driver)
+}
+
+func (s Storage) csiComponentsAreValid() []string {
+	supported := sets.New[OptionalCsiComponent](CsiComponentSnapshot, CsiComponentSnapshotWebhook, CsiComponentNone)
+	unsupported := sets.New[string]()
+
+	for _, cfgComp := range s.OptionalCSIComponents {
+		if !supported.Has(cfgComp) {
+			unsupported.Insert(string(cfgComp))
+		}
+	}
+	return unsupported.UnsortedList()
+}
+
+func (s Storage) noneIsMutuallyExclusive() ([]string, bool) {
+	components := sets.New[OptionalCsiComponent](s.OptionalCSIComponents...)
+	if components.Has(CsiComponentNone) && components.Len() > 1 {
+		components.Delete(CsiComponentNone)
+		ret := sets.New[string]()
+		for v := range components {
+			ret.Insert(string(v))
+		}
+		return ret.UnsortedList(), false
+	}
+	return nil, true
+}
+
+// IsValid checks all sub-fields of a Storage object. The data is considered valid when
+// both .driver and .csi-components are either empty strings or legitimate values. For
+// .csi-components, the string "none" is mutually exclusive with all other values, valid or not.
+func (s Storage) IsValid() []error {
+	errs := sets.New[error]()
+	if !s.driverIsValid() {
+		errs.Insert(fmt.Errorf("invalid driver %q", s.Driver))
+	}
+	if comps := s.csiComponentsAreValid(); len(comps) > 0 {
+		errs.Insert(fmt.Errorf("invalid CSI components: %v", comps))
+	}
+	return errs.UnsortedList()
+}
+
+// IsEnabled returns false only when .storage.driver: "none". An empty value is considered "enabled"
+// for backwards compatibility. Otherwise, the meaning of the config would silently change after an
+// upgrade from enabled-by-default to disabled-by-default.
+func (s Storage) IsEnabled() bool {
+	return s.Driver != CsiDriverNone
+}
diff --git a/packaging/greenboot/functions.sh b/packaging/greenboot/functions.sh
index 456e40c945..f4ba96813d 100644
--- a/packaging/greenboot/functions.sh
+++ b/packaging/greenboot/functions.sh
@@ -294,3 +294,95 @@ function log_script_exit() {
         echo "FINISHED"
     fi
 }
+
+# lvmsDriverShouldExist shallowly wraps some python yaml parsing to determine if the LVMS-Operator is expected to be
+# deployed.
+# args:
+#   none
+# return:
+#   0:  "true", expect the driver to be running
+#   1:  "false", do not expect the driver to be running
+function lvmsDriverShouldExist() {
+    # The python script checks the config's .storage.driver value. Parsing errors are ignored, these will be caught
+    # by MicroShift during startup, before this greenboot script is run. The script favors verbosity over simplified
+    # code.
+    # args:
+    #   None
+    # return:
+    #   None
+    # exit code:
+    #   0: The lvms components should be checked for. This case occurs for any one of:
+    #       - .storage.driver == one of ["", "lvms"]
+    #       - .storage.driver is unset (indicates default config)
+    #       - .storage is unset (indicates default config)
+    #       - the file cannot be opened (indicates default config)
+    #   1: The lvms components should not be checked for. This case occurs for:
+    #       - .storage.driver == "none"
+    if python -c \
+'import yaml, sys
+try:
+    with open("/etc/microshift/config.yaml") as stream:
+        try:
+            config = yaml.safe_load(stream)
+            if config["storage"]["driver"] == "none":
+                sys.exit(1)
+            elif config["storage"]["driver"] == "lvms":
+                sys.exit(0)
+            elif config["storage"]["driver"] == "":
+                sys.exit(0)
+            else:
+                sys.exit(1)
+        except KeyError as e:
+            sys.exit(0)
+        finally:
+            stream.close()
+except Exception as e:
+    print(f"error opening config: {e}", file=sys.Stderr)
+    '; then
+         return 0
+    fi
+    return 1
+}
+
+# csiComponentsShouldBeDeployed checks for a given csi component string identifier in the config's
+# .storage.optionalCsiComponents array.
+# args:
+#   $1    "some-csi-component"
+# return:
+#   0:    the component should be checked for. This case occurs for any one of:
+#           - .storage is unset
+#           - .storage.optionalCsiComponents is unset
+#           - "some-csi-component" matches an element in .storage.optionalCsiComponents
+#   1:    the component should not be checked for. This case occurs for:
+#           - .storage.optionalCsiComponents is set and does not contain "some-csi-component"
+#           - .storage.optionalCsiComponents is set and len(.storage.optionalCsiComponents) == 0
+function csiComponentShouldBeDeployed() {
+    local -r component="${1?csiComponentsShouldBeDeployed expects a single string argument, got none}"
+
+    if python -c \
+'import sys
+import yaml
+try:
+    with open("/etc/microshift/config.yaml") as stream:
+        try:
+            config = yaml.safe_load(stream)
+            if len(config["storage"]["optionalCsiComponents"]) == 0:
+                sys.exit(0)
+            elif "none" in config["storage"]["optionalCsiComponents"]:
+                sys.exit(1)
+            elif sys.argv[1] in config["storage"]["optionalCsiComponents"]:
+                sys.exit(0)
+            else:
+                sys.exit(1)
+        except KeyError as e:
+            sys.exit(0)
+        finally:
+            stream.close()
+except Exception as e:
+    print(f"error opening config: {e}", file=sys.Stderr)
+' "${component}";
+    then
+        return 0
+    fi
+    return 1
+}
\ No newline at end of file
diff --git a/packaging/greenboot/microshift-running-check.sh b/packaging/greenboot/microshift-running-check.sh
index 4687d97a73..1de5d6041e 100755
--- a/packaging/greenboot/microshift-running-check.sh
+++ b/packaging/greenboot/microshift-running-check.sh
@@ -3,8 +3,8 @@ set -e
 
 SCRIPT_NAME=$(basename "$0")
 SCRIPT_PID=$$
-PODS_NS_LIST=(openshift-ovn-kubernetes openshift-service-ca openshift-ingress openshift-dns kube-system)
-PODS_CT_LIST=(2                        1                    1                 2             2)
+PODS_NS_LIST=(openshift-ovn-kubernetes openshift-service-ca openshift-ingress openshift-dns)
+PODS_CT_LIST=(2 1 1 2)
 LOG_POD_EVENTS=false
 
 # Source the MicroShift health check functions library
@@ -25,19 +25,21 @@ function forced_termination() {
     exit 1
 }
 
-# Check preconditions for existence of topolvm deployment.
+# Check preconditions for existence of lvms deployment.
 # Adapted from MicroShift code.
 #
 # args: None
-# return: 0 if topolvm readiness should be checked, 1 otherwise
-function topolvmShouldBeDeployed() {
+# return: 0 if lvms readiness should be checked, 1 otherwise
+function lvmsShouldBeDeployed() {
     if ! hash vgs 2>/dev/null; then
         return 1
     fi
-
     if [ -f /etc/microshift/lvmd.yaml ]; then
         return 0
     fi
+    if ! lvmsDriverShouldExist; then
+        return 1
+    fi
 
     local -r volume_groups=$(vgs --readonly --options=name --noheadings)
     local -r volume_groups_count=$(echo "${volume_groups}" | wc -w)
@@ -139,10 +141,21 @@ if ! wait_for "${WAIT_TIMEOUT_SECS}" microshift_health_endpoints_ok ; then
     exit 1
 fi
 
-if topolvmShouldBeDeployed; then
+if lvmsShouldBeDeployed; then
     PODS_NS_LIST+=(openshift-storage)
     PODS_CT_LIST+=(2)
 fi
+declare -a csi_components=('csi-snapshot-controller' 'csi-snapshot-webhook')
+csi_pods_ct=0
+for csi_c in "${csi_components[@]}"; do
+    if csiComponentShouldBeDeployed "${csi_c}"; then
+        (( csi_pods_ct += 1 ))
+    fi
+done
+if [ ${csi_pods_ct} -gt 0 ]; then
+    PODS_NS_LIST+=(kube-system)
+    PODS_CT_LIST+=("${csi_pods_ct}")
+fi
 
 # Starting pod-specific checks
 # Log list of pods and their events on failure
@@ -160,7 +173,7 @@ for i in "${!PODS_NS_LIST[@]}"; do
     CHECK_PODS_NS=${PODS_NS_LIST[${i}]}
 
     echo "Waiting ${WAIT_TIMEOUT_SECS}s for pod image(s) from the '${CHECK_PODS_NS}' namespace to be downloaded"
-    if ! wait_for "${WAIT_TIMEOUT_SECS}" namespace_images_downloaded ; then
+    if ! wait_for "${WAIT_TIMEOUT_SECS}" namespace_images_downloaded; then
         echo "Error: Timed out waiting for pod image(s) from the '${CHECK_PODS_NS}' namespace to be downloaded"
         exit 1
     fi
@@ -172,7 +185,7 @@ for i in "${!PODS_NS_LIST[@]}"; do
     CHECK_PODS_CT=${PODS_CT_LIST[${i}]}
 
     echo "Waiting ${WAIT_TIMEOUT_SECS}s for ${CHECK_PODS_CT} pod(s) from the '${CHECK_PODS_NS}' namespace to be in 'Ready' state"
-    if ! wait_for "${WAIT_TIMEOUT_SECS}" namespace_pods_ready ; then
+    if ! wait_for "${WAIT_TIMEOUT_SECS}" namespace_pods_ready; then
         echo "Error: Timed out waiting for ${CHECK_PODS_CT} pod(s) in the '${CHECK_PODS_NS}' namespace to be in 'Ready' state"
         exit 1
     fi
diff --git a/packaging/microshift/config.yaml b/packaging/microshift/config.yaml
index 6a449bfa42..6298c3fb9a 100644
--- a/packaging/microshift/config.yaml
+++ b/packaging/microshift/config.yaml
@@ -114,4 +114,23 @@ node:
     # IPv6 address of the node, passed to the kubelet. This parameter
     # is only allowed when dual stack deployment is configured.
     nodeIPv6: ""
+# Storage represents a subfield of the MicroShift config data structure. Its purpose to provide a user
+# facing interface to control whether MicroShift should deploy LVMS on startup.
+storage:
+    # Driver is a user defined string value matching one of the above CSIStorageDriver values. MicroShift uses this
+    # value to decide whether to deploy the LVMS operator. An unset field defaults to "" during yaml parsing, and thus
+    # could mean that the cluster has been upgraded. In order to support the existing out-of-box behavior, MicroShift
+    # assumes an empty string to mean the storage driver should be deployed.
+    # Allowed values are: unset or one of ["", "lvms", "none"]
+    driver: ""
+    # OptionalCSIComponents is a user defined slice of CSIComponent values. These value tell MicroShift which
+    # additional, non-driver, CSI controllers to deploy on start. MicroShift will deploy snapshot controller
+    # and webhook when no components are specified. This preserves the current deployment behavior of existing
+    # clusters. Users must set `.storage.optionalCsiComponents: []` to explicitly tell MicroShift not to deploy any CSI
+    # components. The CSI Driver is excluded as it is typically deployed via the same manifest as the accompanying
+    # storage driver. Like CSIStorageDriver, uninstallation is not supported as this can lead to orphaned storage
+    # objects.
+    # Allowed values are: unset, [], or one or more of ["snapshot-controller", "snapshot-webhook"]
+    optionalCsiComponents:
+        - ""
 
diff --git a/packaging/rpm/microshift.spec b/packaging/rpm/microshift.spec
index 24ea043145..9915012446 100644
--- a/packaging/rpm/microshift.spec
+++ b/packaging/rpm/microshift.spec
@@ -122,6 +122,7 @@ Summary: Greenboot components for MicroShift
 BuildArch: noarch
 Requires: microshift = %{version}
 Requires: greenboot
+Requires: python3-pyyaml
 
 %description greenboot
 The microshift-greenboot package provides the Greenboot scripts used for verifying that MicroShift is up and running.
diff --git a/pkg/components/csi-snapshot-controller.go b/pkg/components/csi-snapshot-controller.go
index da41960513..810e1c1831 100644
--- a/pkg/components/csi-snapshot-controller.go
+++ b/pkg/components/csi-snapshot-controller.go
@@ -4,44 +4,75 @@ import (
 	"context"
 	"fmt"
 
+	"k8s.io/apimachinery/pkg/util/sets"
+	"k8s.io/klog/v2"
+
 	"github.com/openshift/microshift/pkg/assets"
 	"github.com/openshift/microshift/pkg/config"
 )
 
 func startCSISnapshotController(ctx context.Context, cfg *config.Config, kubeconfigPath string) error {
+	csiComps := sets.New[config.OptionalCsiComponent](cfg.Storage.OptionalCSIComponents...)
+	if len(cfg.Storage.OptionalCSIComponents) == 0 {
+		// Upgraded clusters will not have set .storage.*, so we need to support the prior default behavior and deploy
+		// CSI snapshots when .storage.optionalCsiComponents is nil.
+		csiComps.Insert(config.CsiComponentSnapshot, config.CsiComponentSnapshotWebhook)
+	} else if csiComps.Has(config.CsiComponentNone) {
+		// User set a zero-len slice, indicating that the cluster supports optional CSI components, and that they should
+		// be disabled.
+		klog.Warningf("additional (non-driver) csi components have been disabled by user")
+		return nil
+	}
+
 	var (
-		cr  = []string{"components/csi-snapshot-controller/clusterrole.yaml"}
-		crb = []string{"components/csi-snapshot-controller/clusterrolebinding.yaml"}
-		sa  = []string{
-			"components/csi-snapshot-controller/serviceaccount.yaml",
-			"components/csi-snapshot-controller/webhook_serviceaccount.yaml",
-		}
-		svc        = []string{"components/csi-snapshot-controller/webhook_service.yaml"}
-		webhookCfg = []string{"components/csi-snapshot-controller/webhook_config.yaml"}
-		deploy     = []string{
-			"components/csi-snapshot-controller/csi_controller_deployment.yaml",
-			"components/csi-snapshot-controller/webhook_deployment.yaml",
-		}
+		whSA     = []string{"components/csi-snapshot-controller/webhook_serviceaccount.yaml"}
+		whCfg    = []string{"components/csi-snapshot-controller/webhook_config.yaml"}
+		whDeploy = []string{"components/csi-snapshot-controller/webhook_deployment.yaml"}
+		whSvc    = []string{"components/csi-snapshot-controller/webhook_service.yaml"}
+		cr       = []string{"components/csi-snapshot-controller/clusterrole.yaml"}
+		crb      = []string{"components/csi-snapshot-controller/clusterrolebinding.yaml"}
+		sa       = []string{"components/csi-snapshot-controller/serviceaccount.yaml"}
+		deploy   = []string{"components/csi-snapshot-controller/csi_controller_deployment.yaml"}
 	)
 
-	if err := assets.ApplyClusterRoles(ctx, cr, kubeconfigPath); err != nil {
-		return fmt.Errorf("apply clusterRole: %w", err)
-	}
-	if err := assets.ApplyClusterRoleBindings(ctx, crb, kubeconfigPath); err != nil {
-		return fmt.Errorf("apply clusterRoleBinding: %w", err)
-	}
-	if err := assets.ApplyServiceAccounts(ctx, sa, kubeconfigPath); err != nil {
-		return fmt.Errorf("apply service account: %w", err)
-	}
-	if err := assets.ApplyServices(ctx, svc, nil, map[string]interface{}{}, kubeconfigPath); err != nil {
-		return fmt.Errorf("apply service: %w", err)
-	}
-	if err := assets.ApplyValidatingWebhookConfiguration(ctx, webhookCfg, kubeconfigPath); err != nil {
-		return fmt.Errorf("apply validationWebhookConfiguration: %w", err)
-	}
-	if err := assets.ApplyDeployments(ctx, deploy, renderTemplate, renderParamsFromConfig(cfg, nil), kubeconfigPath); err != nil {
-		return fmt.Errorf("apply deployments: %w", err)
+	// Deploy Webhook
+	//nolint:nestif
+	if csiComps.Has(config.CsiComponentSnapshotWebhook) {
+		klog.Infof("deploying CSI snapshot webhook")
+		if err := assets.ApplyServiceAccounts(ctx, whSA, kubeconfigPath); err != nil {
+			return fmt.Errorf("apply service account: %w", err)
+		}
+		if err := assets.ApplyDeployments(ctx, whDeploy, renderTemplate, renderParamsFromConfig(cfg, nil), kubeconfigPath); err != nil {
+			return fmt.Errorf("apply deployment: %w", err)
+		}
+		if err := assets.ApplyValidatingWebhookConfiguration(ctx, whCfg, kubeconfigPath); err != nil {
+			return fmt.Errorf("apply validationWebhookConfiguration: %w", err)
+		}
+		if err := assets.ApplyDeployments(ctx, deploy, renderTemplate, renderParamsFromConfig(cfg, nil), kubeconfigPath); err != nil {
+			return fmt.Errorf("apply deployments: %w", err)
+		}
+	} else {
+		klog.Warningf("CSI snapshot webhook is disabled")
 	}
 
+	// Deploy CSI Controller Deployment
+	//nolint:nestif
+	if csiComps.Has(config.CsiComponentSnapshot) || csiComps.Len() == 0 {
+		klog.Infof("deploying CSI snapshot controller")
+		if err := assets.ApplyClusterRoles(ctx, cr, kubeconfigPath); err != nil {
+			return fmt.Errorf("apply clusterRole: %w", err)
+		}
+		if err := assets.ApplyClusterRoleBindings(ctx, crb, kubeconfigPath); err != nil {
+			return fmt.Errorf("apply clusterRoleBinding: %w", err)
+		}
+		if err := assets.ApplyServiceAccounts(ctx, sa, kubeconfigPath); err != nil {
+			return fmt.Errorf("apply service account: %w", err)
+		}
+		if err := assets.ApplyServices(ctx, whSvc, nil, map[string]interface{}{}, kubeconfigPath); err != nil {
+			return fmt.Errorf("apply service: %w", err)
+		}
+	} else {
+		klog.Warningf("CSI snapshot controller is disabled")
+	}
 	return nil
 }
diff --git a/pkg/components/storage.go b/pkg/components/storage.go
index 1aa2b0ae34..83a250e6d2 100644
--- a/pkg/components/storage.go
+++ b/pkg/components/storage.go
@@ -22,6 +22,10 @@ import (
 )
 
 func startCSIPlugin(ctx context.Context, cfg *config.Config, kubeconfigPath string) error {
+	if !cfg.Storage.IsEnabled() {
+		klog.Warningf("CSI driver deployment disabled, persistent storage will not be available")
+		return nil
+	}
 	if err := lvmd.LvmPresentOnMachine(); err != nil {
 		klog.Warningf("skipping CSI deployment: %v", err)
 		return nil
diff --git a/pkg/config/config.go b/pkg/config/config.go
index 2ca0fbece2..4a6f7a0ace 100644
--- a/pkg/config/config.go
+++ b/pkg/config/config.go
@@ -50,6 +50,7 @@ type Config struct {
 	Debugging Debugging     `json:"debugging"`
 	Manifests Manifests     `json:"manifests"`
 	Ingress   IngressConfig `json:"ingress"`
+	Storage   Storage       `json:"storage"`
 
 	// Settings specified in this section are transferred as-is into the Kubelet config.
 	// +kubebuilder:validation:Schemaless
@@ -146,7 +147,6 @@ func (c *Config) fillDefaults() error {
 			Https: ptr.To[int](443),
 		},
 	}
-
 	c.MultiNode.Enabled = false
 	c.Kubelet = nil
 
@@ -257,6 +257,12 @@ func (c *Config) incorporateUserSettings(u *Config) {
 		c.ApiServer.NamedCertificates = u.ApiServer.NamedCertificates
 	}
 
+	if u.Storage.Driver != "" {
+		c.Storage.Driver = u.Storage.Driver
+	}
+	if len(u.Storage.OptionalCSIComponents) > 0 {
+		c.Storage.OptionalCSIComponents = u.Storage.OptionalCSIComponents
+	}
 	if u.Kubelet != nil {
 		c.Kubelet = u.Kubelet
 	}
@@ -457,6 +463,9 @@ func (c *Config) validate() error {
 		return fmt.Errorf("error validating node.nodeIPv6: %w", err)
 	}
 
+	if errs := c.Storage.IsValid(); c.Storage.IsEnabled() && len(errs) > 0 {
+		return fmt.Errorf("error validating storage: %w", errors.Join(errs...))
+	}
 	return nil
 }
 
diff --git a/pkg/config/config_test.go b/pkg/config/config_test.go
index cec2e92fe1..3520500302 100644
--- a/pkg/config/config_test.go
+++ b/pkg/config/config_test.go
@@ -159,7 +159,6 @@ func TestGetActiveConfigFromYAML(t *testing.T) {
 				return c
 			}(),
 		},
-
 		{
 			name: "api-server-advertise-address",
 			config: dedent(`
@@ -371,6 +370,23 @@ func TestGetActiveConfigFromYAML(t *testing.T) {
 				}
 				return c
 			}(),
+		}, {
+			name: "storage",
+			config: dedent(`
+			storage:
+			  driver: "none"
+			  optionalCsiComponents:
+			  - "snapshot-controller" 
+			  - "snapshot-webhook"
+			`),
+			expected: func() *Config {
+				c := mkDefaultConfig()
+				c.Storage = Storage{
+					Driver:                CsiDriverNone,
+					OptionalCSIComponents: []OptionalCsiComponent{CsiComponentSnapshot, CsiComponentSnapshotWebhook},
+				}
+				return c
+			}(),
 		},
 	}
 
diff --git a/pkg/config/storage.go b/pkg/config/storage.go
new file mode 100644
index 0000000000..db29432809
--- /dev/null
+++ b/pkg/config/storage.go
@@ -0,0 +1,116 @@
+package config
+
+import (
+	"fmt"
+
+	"k8s.io/apimachinery/pkg/util/sets"
+)
+
+// CSIStorageDriver is an enum value that determines whether MicroShift deploys LVMS.
+// +kubebuilder:validation:Enum:="";none;lvms
+type CSIStorageDriver string
+
+const (
+	// CsiDriverUnset exists to support backwards compatibility with existing MicroShift clusters. When .storage.driver is
+	// "", MicroShift will default to deploying LVMS. This preserves the current deployment behavior of existing
+	// clusters.
+	CsiDriverUnset CSIStorageDriver = ""
+	//  CsiDriverNone signals MicroShift to not deploy the LVMS components. Setting the value for a cluster that has already
+	//  deployed LVMS will not cause LVMS to be deleted. Otherwise, volumes already deployed on the cluster would be
+	//  orphaned once their workloads stop or restart.
+	CsiDriverNone CSIStorageDriver = "none"
+	// CsiDriverLVMS is equivalent to CsiDriverUnset, and explicitly tells MicroShift to deploy LVMS. This option exists to
+	// provide a differentiation between LVMS and potential future driver options.
+	CsiDriverLVMS CSIStorageDriver = "lvms"
+)
+
+// OptionalCsiComponent values determine which CSI components MicroShift should deploy. Currently only csi snapshot components
+// are supported.
+// +kubebuilder:validation:Enum:=none;snapshot-controller;snapshot-webhook
+type OptionalCsiComponent string
+
+const (
+	// CsiComponentNone exists to support backwards compatibility with existing MicroShift clusters. By default,
+	// MicroShift will deploy snapshot controller and webhook when no components are specified. This preserves the
+	// current deployment behavior of existing clusters. Users must set .storage.with-csi-components: [ "none" ] to
+	// explicitly tell MicroShift not to deploy any CSI components. The CSI Driver is excluded as it is typically
+	// deployed via the same manifest as the accompanying storage driver. Like DriverOpt, uninstallation is not
+	// supported as this can lead to orphaned storage volumes. Mutually exclusive with all other ComponentOpt values.
+	CsiComponentNone OptionalCsiComponent = "none"
+	// CsiComponentSnapshot causes MicroShift to deploy the CSI Snapshot controller.
+	CsiComponentSnapshot OptionalCsiComponent = "snapshot-controller"
+	// CsiComponentSnapshotWebhook causes MicroShift to deploy the CSI Snapshot Validation Webhook.
+	CsiComponentSnapshotWebhook OptionalCsiComponent = "snapshot-webhook"
+)
+
+// Storage represents a subfield of the MicroShift config data structure. Its purpose to provide a user
+// facing interface to control whether MicroShift should deploy LVMS on startup.
+type Storage struct {
+	// Driver is a user defined string value matching one of the above CSIStorageDriver values. MicroShift uses this
+	// value to decide whether to deploy the LVMS operator. An unset field defaults to "" during yaml parsing, and thus
+	// could mean that the cluster has been upgraded. In order to support the existing out-of-box behavior, MicroShift
+	// assumes an empty string to mean the storage driver should be deployed.
+	// Allowed values are: unset or one of ["", "lvms", "none"]
+	// +kubebuilder:validation:Optional
+	Driver CSIStorageDriver `json:"driver,omitempty"`
+	// OptionalCSIComponents is a user defined slice of CSIComponent values. These value tell MicroShift which
+	// additional, non-driver, CSI controllers to deploy on start. MicroShift will deploy snapshot controller
+	// and webhook when no components are specified. This preserves the current deployment behavior of existing
+	// clusters. Users must set `.storage.optionalCsiComponents: []` to explicitly tell MicroShift not to deploy any CSI
+	// components. The CSI Driver is excluded as it is typically deployed via the same manifest as the accompanying
+	// storage driver. Like CSIStorageDriver, uninstallation is not supported as this can lead to orphaned storage
+	// objects.
+	// Allowed values are: unset, [], or one or more of ["snapshot-controller", "snapshot-webhook"]
+	// +kubebuilder:validation:Optional
+	OptionalCSIComponents []OptionalCsiComponent `json:"optionalCsiComponents,omitempty"`
+}
+
+func (s Storage) driverIsValid() (isSupported bool) {
+	return sets.New[CSIStorageDriver](CsiDriverNone, CsiDriverLVMS, CsiDriverUnset).Has(s.Driver)
+}
+
+func (s Storage) csiComponentsAreValid() []string {
+	supported := sets.New[OptionalCsiComponent](CsiComponentSnapshot, CsiComponentSnapshotWebhook, CsiComponentNone)
+	unsupported := sets.New[string]()
+
+	for _, cfgComp := range s.OptionalCSIComponents {
+		if !supported.Has(cfgComp) {
+			unsupported.Insert(string(cfgComp))
+		}
+	}
+	return unsupported.UnsortedList()
+}
+
+func (s Storage) noneIsMutuallyExclusive() ([]string, bool) {
+	components := sets.New[OptionalCsiComponent](s.OptionalCSIComponents...)
+	if components.Has(CsiComponentNone) && components.Len() > 1 {
+		components.Delete(CsiComponentNone)
+		ret := sets.New[string]()
+		for v := range components {
+			ret.Insert(string(v))
+		}
+		return ret.UnsortedList(), false
+	}
+	return nil, true
+}
+
+// IsValid checks all sub-fields of a Storage object. The data is considered valid when
+// both .driver and .csi-components are either empty strings or legitimate values. For
+// .csi-components, the string "none" is mutually exclusive with all other values, valid or not.
+func (s Storage) IsValid() []error {
+	errs := sets.New[error]()
+	if !s.driverIsValid() {
+		errs.Insert(fmt.Errorf("invalid driver %q", s.Driver))
+	}
+	if comps := s.csiComponentsAreValid(); len(comps) > 0 {
+		errs.Insert(fmt.Errorf("invalid CSI components: %v", comps))
+	}
+	return errs.UnsortedList()
+}
+
+// IsEnabled returns false only when .storage.driver: "none". An empty value is considered "enabled"
+// for backwards compatibility. Otherwise, the meaning of the config would silently change after an
+// upgrade from enabled-by-default to disabled-by-default.
+func (s Storage) IsEnabled() bool {
+	return s.Driver != CsiDriverNone
+}
diff --git a/pkg/config/storage_test.go b/pkg/config/storage_test.go
new file mode 100644
index 0000000000..4a4434ba3f
--- /dev/null
+++ b/pkg/config/storage_test.go
@@ -0,0 +1,250 @@
+package config
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestStorage_IsEnabled(t *testing.T) {
+	type fields struct {
+		Driver        CSIStorageDriver
+		CSIComponents []OptionalCsiComponent
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   bool
+	}{
+		{
+			name: "is disabled when driver is none",
+			fields: fields{
+				Driver: CsiDriverNone,
+			},
+			want: false,
+		},
+		{
+			name: "is enabled when driver is lvms",
+			fields: fields{
+				Driver: CsiDriverLVMS,
+			},
+			want: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := Storage{
+				Driver:                tt.fields.Driver,
+				OptionalCSIComponents: tt.fields.CSIComponents,
+			}
+			assert.Equalf(t, tt.want, s.IsEnabled(), "IsEnabled()")
+		})
+	}
+}
+
+func TestStorage_IsValid(t *testing.T) {
+	type fields struct {
+		Driver        CSIStorageDriver
+		CSIComponents []OptionalCsiComponent
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   []error
+	}{
+		{
+			name: "is valid when a driver is set and csi-components are valid",
+			fields: fields{
+				Driver:        CsiDriverLVMS,
+				CSIComponents: []OptionalCsiComponent{CsiComponentSnapshot, CsiComponentSnapshotWebhook},
+			},
+			want: []error{},
+		},
+		{
+			name: "is valid when a driver unset and csi-components are valid",
+			fields: fields{
+				Driver:        CsiDriverUnset,
+				CSIComponents: []OptionalCsiComponent{CsiComponentSnapshot},
+			},
+			want: []error{},
+		},
+		{
+			name: "is valid when the driver is unset and csi-components are valid",
+			fields: fields{
+				Driver:        CsiDriverUnset,
+				CSIComponents: []OptionalCsiComponent{CsiComponentSnapshot, CsiComponentSnapshotWebhook},
+			},
+			want: []error{},
+		},
+		{
+			name: "is invalid when driver is valid, but csi-components are invalid",
+			fields: fields{
+				Driver:        CsiDriverLVMS,
+				CSIComponents: []OptionalCsiComponent{"foobar", CsiComponentSnapshot, CsiComponentSnapshotWebhook},
+			},
+			want: []error{
+				fmt.Errorf("invalid CSI components: [foobar]"),
+			},
+		},
+		{
+			name: "is invalid when driver is invalid, but CSI components are valid",
+			fields: fields{
+				Driver:        "foobar",
+				CSIComponents: []OptionalCsiComponent{CsiComponentSnapshot, CsiComponentSnapshotWebhook},
+			},
+			want: []error{
+				fmt.Errorf("invalid driver \"foobar\""),
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := Storage{
+				Driver:                tt.fields.Driver,
+				OptionalCSIComponents: tt.fields.CSIComponents,
+			}
+			got := s.IsValid()
+			assert.Equalf(t, tt.want, got, "IsValid()")
+		})
+	}
+}
+
+func TestStorage_csiComponentIsValid(t *testing.T) {
+	type fields struct {
+		Driver        CSIStorageDriver
+		CSIComponents []OptionalCsiComponent
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   []string
+	}{
+		{
+			name: "passes for all csi-component values",
+			fields: fields{
+				CSIComponents: []OptionalCsiComponent{
+					CsiComponentSnapshot,
+					CsiComponentSnapshotWebhook,
+				},
+			},
+			want: []string{},
+		},
+		{
+			name: "passes when unsupported values are caught and returned",
+			fields: fields{
+				CSIComponents: []OptionalCsiComponent{"FOOBAR", CsiComponentSnapshot},
+			},
+			want: []string{"FOOBAR"},
+		},
+		{
+			name: "passes for empty array",
+			fields: fields{
+				CSIComponents: []OptionalCsiComponent{},
+			},
+			want: []string{},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := Storage{
+				Driver:                tt.fields.Driver,
+				OptionalCSIComponents: tt.fields.CSIComponents,
+			}
+			got := s.csiComponentsAreValid()
+			assert.Equalf(t, tt.want, got, "csiComponentsAreValid()")
+		})
+	}
+}
+
+func TestStorage_driverIsValid(t *testing.T) {
+	type fields struct {
+		Driver        CSIStorageDriver
+		CSIComponents []OptionalCsiComponent
+	}
+	tests := []struct {
+		name            string
+		fields          fields
+		wantIsSupported bool
+	}{
+		{
+			name: "is valid when value matches one of predefined drivers",
+			fields: fields{
+				Driver: CsiDriverLVMS,
+			},
+			wantIsSupported: true,
+		},
+		{
+			name: "is valid when value is an empty string",
+			fields: fields{
+				Driver: "",
+			},
+			wantIsSupported: true,
+		},
+		{
+			name: "is invalid when value does not match one of predefined drivers",
+			fields: fields{
+				Driver: "foobar",
+			},
+			wantIsSupported: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := Storage{
+				Driver:                tt.fields.Driver,
+				OptionalCSIComponents: tt.fields.CSIComponents,
+			}
+			assert.Equalf(t, tt.wantIsSupported, s.driverIsValid(), "driverIsValid()")
+		})
+	}
+}
+
+func TestStorage_noneIsMutuallyExclusive(t *testing.T) {
+	type fields struct {
+		Driver        CSIStorageDriver
+		CSIComponents []OptionalCsiComponent
+	}
+	tests := []struct {
+		name   string
+		fields fields
+		want   []string
+		want1  bool
+	}{
+		{
+			name: "passes when none is the sole value",
+			fields: fields{
+				CSIComponents: []OptionalCsiComponent{CsiComponentNone},
+			},
+			want:  nil,
+			want1: true,
+		},
+		{
+			name: "fails when none is not the sole value",
+			fields: fields{
+				CSIComponents: []OptionalCsiComponent{CsiComponentNone, CsiComponentSnapshot},
+			},
+			want:  []string{string(CsiComponentSnapshot)},
+			want1: false,
+		},
+		{
+			name: "passes when none is not in a list of values",
+			fields: fields{
+				CSIComponents: []OptionalCsiComponent{CsiComponentSnapshot, CsiComponentSnapshotWebhook},
+			},
+			want:  nil,
+			want1: true,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			s := Storage{
+				Driver:                tt.fields.Driver,
+				OptionalCSIComponents: tt.fields.CSIComponents,
+			}
+			got, got1 := s.noneIsMutuallyExclusive()
+			assert.Equalf(t, tt.want, got, "noneIsMutuallyExclusive()")
+			assert.Equalf(t, tt.want1, got1, "noneIsMutuallyExclusive()")
+		})
+	}
+}
diff --git a/test/resources/oc.resource b/test/resources/oc.resource
index 680d995d27..b911281b4f 100644
--- a/test/resources/oc.resource
+++ b/test/resources/oc.resource
@@ -100,6 +100,15 @@ Named Deployment Should Be Available
     [Arguments]    ${name}    ${ns}=${NAMESPACE}    ${timeout}=${DEFAULT_WAIT_TIMEOUT}
     Run With Kubeconfig    oc wait -n ${ns} deploy ${name} --for=condition=Available --timeout=${timeout}
 
+Named Daemonset Should Be Available
+    [Documentation]    Wait for a given daemonset's Available condition to be true
+    ...    ${name}    Name of daemonset to wait for
+    ...    ${ns}    Namespace of named daemonset. Defaults to NAMESPACE suite variable
+    ...    ${timeout}    Period of time to wait for daemonset to reach ready status. Default 60s.
+    [Arguments]    ${name}    ${ns}=${NAMESPACE}    ${timeout}=${DEFAULT_WAIT_TIMEOUT}
+    Run With Kubeconfig
+    ...    oc wait -n ${ns} daemonset ${name} --for=jsonpath='{.status.numberAvailable}'=1 --timeout=${timeout}
+
 Named PVC Should Be Resized
     [Documentation]    Wait for pvc with ${name} to resize to ${to_size}
     ...    ${name}    Name of pvc to wait for
diff --git a/test/suites/standard1/configuration.robot b/test/suites/standard1/configuration.robot
index f0bf8977e1..162490eaeb 100644
--- a/test/suites/standard1/configuration.robot
+++ b/test/suites/standard1/configuration.robot
@@ -13,29 +13,41 @@ Test Tags           restart    slow
 
 
 *** Variables ***
-${CURSOR}               ${EMPTY}    # The journal cursor before restarting MicroShift
-${BAD_LOG_LEVEL}        SEPARATOR=\n
-...                     ---
-...                     debugging:
-...                     \ \ logLevel: unknown-value
-${DEBUG_LOG_LEVEL}      SEPARATOR=\n
-...                     ---
-...                     debugging:
-...                     \ \ logLevel: debug
-${BAD_AUDIT_PROFILE}    SEPARATOR=\n
-...                     apiServer:
-...                     \ \ auditLog:
-...                     \ \ \ \ profile: BAD_PROFILE
-${AUDIT_PROFILE}        SEPARATOR=\n
-...                     apiServer:
-...                     \ \ auditLog:
-...                     \ \ \ \ profile: WriteRequestBodies
-${AUDIT_FLAGS}          SEPARATOR=\n
-...                     apiServer:
-...                     \ \ auditLog:
-...                     \ \ \ \ maxFileSize: 1000
-...                     \ \ \ \ maxFiles: 1000
-...                     \ \ \ \ maxFileAge: 1000
+${CURSOR}                           ${EMPTY}    # The journal cursor before restarting MicroShift
+${BAD_LOG_LEVEL}                    SEPARATOR=\n
+...                                 ---
+...                                 debugging:
+...                                 \ \ logLevel: unknown-value
+${DEBUG_LOG_LEVEL}                  SEPARATOR=\n
+...                                 ---
+...                                 debugging:
+...                                 \ \ logLevel: debug
+${BAD_AUDIT_PROFILE}                SEPARATOR=\n
+...                                 apiServer:
+...                                 \ \ auditLog:
+...                                 \ \ \ \ profile: BAD_PROFILE
+${AUDIT_PROFILE}                    SEPARATOR=\n
+...                                 apiServer:
+...                                 \ \ auditLog:
+...                                 \ \ \ \ profile: WriteRequestBodies
+${AUDIT_FLAGS}                      SEPARATOR=\n
+...                                 apiServer:
+...                                 \ \ auditLog:
+...                                 \ \ \ \ maxFileSize: 1000
+...                                 \ \ \ \ maxFiles: 1000
+...                                 \ \ \ \ maxFileAge: 1000
+${LVMS_DEFAULT}                     SEPARATOR=\n
+...                                 storage: {}
+${LVMS_DISABLED}                    SEPARATOR=\n
+...                                 storage:
+...                                 \ \ driver: "none"
+${CSI_SNAPSHOT_DISABLED}            SEPARATOR=\n
+...                                 storage:
+...                                 \ \ optionalCsiComponents: [ none ]
+${LVMS_CSI_SNAPSHOT_DISABLED}       SEPARATOR=\n
+...                                 storage:
+...                                 \ \ driver: "none"
+...                                 \ \ optionalCsiComponents: [ none ]
 
 
 *** Test Cases ***
@@ -63,6 +75,39 @@ Config Flags Are Logged in Audit Flags
     Pattern Should Appear In Log Output    ${CURSOR}    FLAG: --audit-log-maxbackup=\"1000\"
     Pattern Should Appear In Log Output    ${CURSOR}    FLAG: --audit-log-maxage=\"1000\"
 
+Deploy MicroShift With LVMS By Default
+    [Documentation]    Verify that LVMS and CSI snapshotting are deployed when config fields are null.
+    [Setup]    Deploy Storage Config    ${LVMS_DEFAULT}
+    LVMS Is Deployed
+    CSI Snapshot Controller And Webhook Are Deployed
+    [Teardown]    Run Keywords
+    ...    Restore Default MicroShift Config
+    ...    Restart MicroShift
+
+Deploy MicroShift Without LVMS
+    [Documentation]    Verify that LVMS is not deployed when storage.driver == none, and that CSI snapshotting
+    ...    components are still deployed.
+    [Setup]    Deploy Storage Config    ${LVMS_DISABLED}
+
+    CSI Snapshot Controller And Webhook Are Deployed
+    Run Keyword And Expect Error    1 != 0
+    ...    LVMS Is Deployed
+    [Teardown]    Run Keywords
+    ...    Restore Default MicroShift Config
+    ...    Restart MicroShift
+
+Deploy MicroShift Without CSI Snapshotter
+    [Documentation]    Verify that only LVMS is deployed when .storage.optionalCsiComponents is an empty array.
+    [Setup]    Deploy Storage Config    ${CSI_SNAPSHOT_DISABLED}
+
+    LVMS Is Deployed
+    Run Keyword And Expect Error    1 != 0
+    ...    CSI Snapshot Controller And Webhook Are Deployed
+
+    [Teardown]    Run Keywords
+    ...    Restore Default MicroShift Config
+    ...    Restart MicroShift
+
 
 *** Keywords ***
 Setup
@@ -110,3 +155,23 @@ Setup Audit Flags
     ${merged}=    Extend MicroShift Config    ${AUDIT_FLAGS}
     Upload MicroShift Config    ${merged}
     Restart MicroShift
+
+Deploy Storage Config
+    [Documentation]    Applies a storage ${config} to the exist MicroShift config, pushes it to the MicroShift host,
+    ...    and restarts microshift.service
+    [Arguments]    ${config}
+    Cleanup MicroShift    opt='--keep-images'
+    ${merged}=    Extend MicroShift Config    ${config}
+    Upload MicroShift Config    ${merged}
+    Start MicroShift
+
+LVMS Is Deployed
+    [Documentation]    Wait for LVMS components to deploy
+    Named Deployment Should Be Available    lvms-operator    openshift-storage    120s
+    # the daemonset trails the lvms-operator by roughly 1min, so give it extra time to spin up
+    Named Daemonset Should Be Available    vg-manager    openshift-storage    120s
+
+CSI Snapshot Controller And Webhook Are Deployed
+    [Documentation]    Wait for CSI snapshot controller and webhook to be deployed
+    Named Deployment Should Be Available    csi-snapshot-controller    kube-system    120s
+    Named Deployment Should Be Available    csi-snapshot-webhook    kube-system    120s
diff --git a/test/suites/tuned/microshift-tuned.robot b/test/suites/tuned/microshift-tuned.robot
index f9e343b8ba..dd975fb8c5 100644
--- a/test/suites/tuned/microshift-tuned.robot
+++ b/test/suites/tuned/microshift-tuned.robot
@@ -41,7 +41,8 @@ Variables Are Changed
     Should Not Be Equal    ${old_hash}    ${new_hash}
 
 No Reboot If Not Allowed
-    [Documentation]    If reboot_after_apply is False, then microshift-tuned should not reboot the host even if the profile changed.
+    [Documentation]    If reboot_after_apply is False, then microshift-tuned should not reboot the host even if the
+    ...    profile changed.
 
     Command Should Work
     ...    sed -i 's/^offline_cpu_set=.*$/offline_cpu_set=3/' /etc/tuned/microshift-baseline-variables.conf