e2e

package
v0.0.0-...-0a6ecdb Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 8, 2026 License: Apache-2.0 Imports: 94 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	// CoreTestPriority is the test priority for the "DPF System tests - Core" test suite.
	CoreTestPriority = 101
	// SDNTestPriority is the test priority for the "DPF System tests - SDN" test suite.
	SDNTestPriority = 100
)

Test priorities are defined below. these are used for specific test specs to ensure they are run in the correct order. for tests which do not specify a priority, ginkgo will will assign a default priority of 0. test specs with a higher priority will run first. for more information, see: https://onsi.github.io/ginkgo/#prioritizing-specs in most cases, assigning a specific test priority for a test should not be needed.

View Source 
const (
	// NodeUnschedulableTaintKey is the well known taint key that indicates a node is unschedulable, typically used when
	// draining a node
	NodeUnschedulableTaintKey = "node.kubernetes.io/unschedulable"
)
View Source 
const (

	// The cleanup scope of the platform objects the tenant specs share. Registered by the spec file,
	// which is where the tracker lives.
	TenantPlatformScopeName = "tenant-platform"
)

A tenant owns a namespace, selects the DPUs its service runs on by labeling their DPUDevices, and either needs no bridge connectivity, attaches to the tenant bridge through a DPUServiceNAD, or attaches through a DPUServiceChain it owns. HBN, the tenant bridge patch and the chain to HBN stay in the DPF operator namespace.

The DPUFlavor creates the bridges on every DPU at provisioning time: 

br-sfc   The chaining bridge. sfc-controller programs the flows a DPUServiceChain asks for.
br-tenant1  The tenant segment. A plain learning bridge in the default fail mode, no flows.

Variables

View Source 
var CleanupScope = cleanup.CleanupLabels

CleanupScope is an alias for cleanup.CleanupLabels for ease of use

View Source 
var Domain = TestDomain{
	DPFSystem:               "DPFSystem",
	Scale:                   "SCALE",
	SDN:                     "SDN",
	SNAP:                    "SNAP",
	Provisioning:            "Provisioning",
	RequiresNodes:           "RequiresNodes",
	L2Connectivity:          "L2Connectivity",
	DPFUpgrade:              "DPFUpgrade",
	DPFUpgradeValidation:    "DPFUpgradeValidation",
	DPFBFBLTSUpgrade:        "DPFBFBLTSUpgrade",
	DPFBFBLTSUpgradeV264:    "DPFBFBLTSUpgradeV264",
	DPFBFBLTSUpgradeV268:    "DPFBFBLTSUpgradeV268",
	DPFBFBLTSUpgradeCurrent: "DPFBFBLTSUpgradeCurrent",
	ExternalTest:            "ExternalTest",
	TCP:                     "TCP",
	UDP:                     "UDP",
	OVNKPrimary:             "OVNKPrimary",
	OVNKHBN:                 "OVNKHBN",
	DPFVPCOVN:               "DPFVPCOVN",
	Weave:                   "Weave",
	WeavePhysical:           "WeavePhysical",
	MultiDPUCluster:         "MultiDPUCluster",
	ZeroTrust:               "ZeroTrust",
	Observability:           "Observability",
	ImagePullSecretsSync:    "ImagePullSecretsSync",
	Performance:             "Performance",
	OCP:                     "OCP",
}

Domain is the global instance of test label domains

Functions

func ApplyNodeRebootConfigMap 

func ApplyNodeRebootConfigMap(ctx context.Context, c client.Client, configMapPath string)

ApplyNodeRebootConfigMap creates the BMC credentials Secret (sourced from $E2E_ZT_BMC_USERNAME / $E2E_ZT_BMC_PASSWORD) and applies the reboot ConfigMap fixture as-is.

func BeforeProvisioning 

func BeforeProvisioning(ctx context.Context, input *systemTestInput)

func CleanupTenantPlatform 

func CleanupTenantPlatform(ctx context.Context, input *systemTestInput)

CleanupTenantPlatform removes HBN from the DPUDeployment and then the shared platform objects.

The order matters. The DPUDeployment holds the dependent finalizer on the HBN template and configuration for as long as it references them, so deleting them first leaves both with a deletionTimestamp and nothing to remove it, and the cleanup times out waiting.

func CopySecretToNamespace 

func CopySecretToNamespace(ctx context.Context, c client.Client, secretName string, sourceNamespace, targetNamespace string, targetNamespaceLabels map[string]string)

CopySecretToNamespace copies a secret from one namespace to another If the source secret doesn't exist, does nothing (nothing to copy) Always set's the label "dpu.nvidia.com/image-pull-secret" to "" in the target namespace to ensure reconciliation in the DPU cluster

func CreateDPUDiscovery 

func CreateDPUDiscovery(ctx context.Context, input DeployDPFSystemComponentsInput)

CreateDPUDiscovery verifies no worker nodes and no DPUDevices are in the host cluster. Creates DPUDiscovery and verifies DPUDevices were found and added.

func CreateProvisioningDPUCluster 

func CreateProvisioningDPUCluster(ctx context.Context, input *systemTestInput)

func CreateProvisioningDPUSet 

func CreateProvisioningDPUSet(ctx context.Context, input *systemTestInput)

func DeleteDPFOperatorConfig 

func DeleteDPFOperatorConfig(ctx context.Context, testClient client.Client)

func DeleteProvisioning 

func DeleteProvisioning(ctx context.Context, input *systemTestInput)

func DeployDPFSystemComponents 

func DeployDPFSystemComponents(ctx context.Context, input DeployDPFSystemComponentsInput)

DeployDPFSystemComponents creates the operatorConfig and some dependencies and checks that the system components are deployed from the operator. 1) Ensures the DPF Operator is running and ready 2) Creates a PersistentVolumeClaim for the Provisioning controller 3) Creates ImagePullSecrets which are tested as part of the e2e flow (note these are fake and could possibly be replaced by real ones) 4) Creates the operatorConfig for the test 5) Ensures the DPF System components - including DPUServices - have been deployed.

func DeployOVNKHBNScenario 

func DeployOVNKHBNScenario(ctx context.Context, input *systemTestInput)

DeployOVNKHBNScenario creates the application-layer objects required for the HBN-OVN scenario: physical DPUServiceInterfaces (p0, p1, ovn), IPAM pools, HBN DPUServiceTemplate, DPUServiceConfiguration, OVN-K DPUServiceTemplate, DPUServiceConfiguration, and the ovn-hbn DPUDeployment. It must be called after applyConfig/applySDNConfig have run (to populate input fields).

func EventuallyCheckReadyStatusCondition 

func EventuallyCheckReadyStatusCondition(ctx context.Context, c client.Client, obj client.Object, timeout time.Duration)

EventuallyCheckReadyStatusCondition waits until obj has a Ready condition with Status True and ObservedGeneration equal to the object's current Generation.

func GetDPUNodeToBMCIPs 

func GetDPUNodeToBMCIPs(ctx context.Context, c client.Client, expectedDPUNodes int,
	setupInfo *ciSetupInfo) map[string]string

GetDPUNodeToBMCIPs ensures the expected DPUNodes exist and maps each DPUNode name to its host BMC IP from the pre-loaded setupInfo map. In Zero-Trust mode, this validates each DPUNode against the setup info, failing clearly if not found.

func GetNodeInternalIP 

func GetNodeInternalIP(ctx context.Context, c client.Client, nodeName string) net.IP

GetNodeInternalIP returns the internal IP of the node with the given name.

func GetServiceIDForDPUDeploymentService 

func GetServiceIDForDPUDeploymentService(ctx context.Context, c client.Client, dpuDeployment *dpuservicev1.DPUDeployment, serviceName string) string

GetServiceIDForDPUDeploymentService retrieves the ServiceID for the named service within a DPUDeployment.

func InstallOVNKResourceInjector 

func InstallOVNKResourceInjector(ctx context.Context, c client.Client)

InstallOVNKResourceInjector installs the OVN-K resource injection webhook on the host cluster as a separate Helm release. The webhook mutates pods scheduled to DPU-enabled worker nodes, injecting VF resource requests so OVN-K can obtain the device ID for DPU offload. Reads OVN_KUBERNETES_REPO_URL and OVN_KUBERNETES_CHART_TAG env vars for the chart source.

func PatchDPUDeviceValuesForFlavorTemplate 

func PatchDPUDeviceValuesForFlavorTemplate(ctx context.Context, input *systemTestInput)

PatchDPUDeviceValuesForFlavorTemplate patches each DPUDevice.spec.values with a per-device labelSuffix so the DPUFlavorTemplate body renders with real data. Rendering runs with missingkey=error, so unset keys would fail the render and starve the DPUSet controller.

func PatchDPUDevicesForZeroTrust 

func PatchDPUDevicesForZeroTrust(ctx context.Context, c client.Client, expectedDPUs int,
	expectedNicDeviceCount int, setupInfo *ciSetupInfo)

PatchDPUDevicesForZeroTrust waits for expectedDPUs DPUDevices, then optionally patches NICDeviceCount and per-serial Spec.Values from setupInfo.

func PatchDPUNodesForScriptReboot 

func PatchDPUNodesForScriptReboot(ctx context.Context, c client.Client,
	expectedDPUNodes int, configMapName string, bmcIPs map[string]string)

PatchDPUNodesForScriptReboot updates each DPUNode to use the specified script-based reboot method, assigning the correct BMC IP label from the externally provided bmcIPs map. This pattern is necessary because we use dpudiscovery (and do not create the DPUNode objects ourselves), so we must associate host identity (BMC IPs) externally. This is especially important in Zero-Trust setups, where host identity cannot be reliably derived from cluster state.

func PatchNFDWorkerForVIP 

func PatchNFDWorkerForVIP(ctx context.Context, c client.Client, namespace, vip string, port int)

PatchNFDWorkerForVIP patches the node-feature-discovery-worker DaemonSet with the KUBERNETES_SERVICE_HOST and KUBERNETES_SERVICE_PORT env vars so that NFD workers can reach the kube-apiserver via VIP on nodes where the ClusterIP is not yet reachable (e.g. before OVN-K is running on physical performance setups).

func PrepareWeavePhysicalProvisioning 

func PrepareWeavePhysicalProvisioning(ctx context.Context, input *systemTestInput)

PrepareWeavePhysicalProvisioning creates the flavor template, services, and DPUDeployment that own provisioning for this suite.

func ProcessDPUNodeMaintenanceHold 

func ProcessDPUNodeMaintenanceHold(ctx context.Context, input ProvisionDPUClustersInput)

ProcessDPUNodeMaintenanceHold waits for DPUNodeMaintenance CRs to have the hold annotation set to "true" and then patches them to "false" to allow DPU provisioning to continue. This simulates an external system completing the node effect in a non-K8s environment.

func ProvisionBFB 

func ProvisionBFB(ctx context.Context, input ProvisionDPUClustersInput)

ProvisionBFB creates the BFB resource, waits for it to reach Ready phase, and verifies the BFB file is reachable via the bfb-registry service (ZeroTrust only).

func ProvisionBFBOrBlueFieldSoftwareAndDPUFlavor 

func ProvisionBFBOrBlueFieldSoftwareAndDPUFlavor(ctx context.Context, input ProvisionDPUClustersInput)

ProvisionBFBOrBlueFieldSoftwareAndDPUFlavor creates the BFB or BlueFieldSoftware and optionally the DPUFlavor resources.

func ProvisionBlueFieldSoftware 

func ProvisionBlueFieldSoftware(ctx context.Context, input ProvisionDPUClustersInput)

ProvisionBlueFieldSoftware creates the BlueFieldSoftware resource and waits for it to reach Ready phase.

func ProvisionDPUClusters 

func ProvisionDPUClusters(ctx context.Context, input ProvisionDPUClustersInput)

ProvisionDPUClusters provisions DPUClusters.

func ProvisionDPUDeploymentWithEachDPUJoiningADifferentDPUCluster 

func ProvisionDPUDeploymentWithEachDPUJoiningADifferentDPUCluster(ctx context.Context, input *systemTestInput)

ProvisionDPUDeploymentWithEachDPUJoiningADifferentDPUCluster creates a DPUDeployment where each DPU joins a different cluster

func ProvisionDPUFlavor 

func ProvisionDPUFlavor(ctx context.Context, input ProvisionDPUClustersInput)

ProvisionDPUFlavor creates the DPUFlavor resource.

func ProvisionDPUSet 

func ProvisionDPUSet(ctx context.Context, input ProvisionDPUClustersInput)

ProvisionDPUSet DPUSet that will provision DPUs in the background if the environment has such DPUs. It doesn't check whether the DPUs become ready intentionally to allow for subsequent tests to be executed in the meantime.

func SetMaintenanceOperatorMaxParallelOperations 

func SetMaintenanceOperatorMaxParallelOperations(ctx context.Context, c client.Client, value int32) func()

SetMaintenanceOperatorMaxParallelOperations patches the MaintenanceOperatorConfig to allow up to value concurrent node drain operations. The default DPF value is 60% which limits parallelism to ~60% of cluster nodes. Returns a restore function that reverts to the original value.

func SetupTenantPlatform 

func SetupTenantPlatform(ctx context.Context, input *systemTestInput, scope *cleanup.Scope)

SetupTenantPlatform brings up everything the tenant specs share. Meant for a BeforeAll: building it per spec would add HBN to the DPUDeployment and remove it again for each of them, which is two rollouts of HBN more than the specs need. The scope is the one registered for TenantPlatformScopeName.

func ValidateBMCFactoryResetSkippedOnBootstrap 

func ValidateBMCFactoryResetSkippedOnBootstrap(ctx context.Context, input *systemTestInput)

ValidateBMCFactoryResetSkippedOnBootstrap asserts the ZT bootstrap contract for BMC factory reset: the suite explicitly sets discoveredDPUDeviceBMCFactoryResetPolicy=Never (there is no CRD default for that OperatorConfig field), so every discovered DPUDevice reports FactoryResetSkipped while password hardening still runs and leaves no managed account on the factory default.

func ValidateBMCServerCertificateRotation 

func ValidateBMCServerCertificateRotation(ctx context.Context, input *systemTestInput)

ValidateBMCServerCertificateRotation exercises the BMC mTLS server-certificate rotation feature end-to-end against real hardware: it waits for each DPUDevice to report a ready server certificate, requests a manual rotation via the annotation, and verifies the controller drives a fresh cert through the BMC (Redfish GenerateCSR -> cert-manager -> ReplaceServerCert) and reports it Ready.

This requires the Redfish install interface with reachable BMCs, so it only runs in Zero-Trust runs with provisioned nodes.

func ValidateDMAScalableFunction 

func ValidateDMAScalableFunction(ctx context.Context, input *systemTestInput)

ValidateDMAScalableFunction validates the SNAP DMA SF created by the dpu-agent's sfconfig operation when the DPUFlavor has a scalableFunctions dma entry. It only wires the suite state into the validation, which lives next to the operation it covers in test/utils/dpuagent.

func ValidateDPFMetricsScrapedByPrometheus 

func ValidateDPFMetricsScrapedByPrometheus(ctx context.Context)

ValidateDPFMetricsScrapedByPrometheus confirms that DPF kube-state-metrics are not only produced but actually scraped into Prometheus, where the dashboards read them. ValidateGeneralDPFMetrics checks the KSM endpoint directly, which isolates producer correctness but does not exercise the Prometheus scrape config; this closes that gap. dpfoperatorconfig is a singleton, so dpf_dpfoperatorconfig_info is always present once the scrape has run.

func ValidateDPFOperatorBaseConfiguration 

func ValidateDPFOperatorBaseConfiguration(ctx context.Context, input *systemTestInput)

ValidateDPFOperatorBaseConfiguration verifies that DPFOperatorConfiguration ContainerComponentConfiguration options work. It changes the images for all system components to arbitrary values, checks that the changes have propagated and then changes them back to their default versions.

func ValidateDPFOperatorConfigCleanupPrerequisites 

func ValidateDPFOperatorConfigCleanupPrerequisites(ctx context.Context, input *systemTestInput)

ValidateDPFOperatorConfigCleanupPrerequisites this function ensures that the prerequisite objects exist before removing the DPFOperatorConfig to ensure that we cover edge cases.

func ValidateDPFOperatorFlannelPodCIDRChange 

func ValidateDPFOperatorFlannelPodCIDRChange(ctx context.Context, input *systemTestInput)

func ValidateDPFOperatorKubernetesAPIServerVIPAndPort 

func ValidateDPFOperatorKubernetesAPIServerVIPAndPort(ctx context.Context, input *systemTestInput)

ValidateDPFOperatorKubernetesAPIServerVIPAndPort validates that the Kubernetes API Server related variables are propagated correctly to the DMS pods.

func ValidateDPFOperatorMTUConfigurationChange 

func ValidateDPFOperatorMTUConfigurationChange(ctx context.Context, input *systemTestInput)

func ValidateDPFOperatorMTUCurrentConfiguration 

func ValidateDPFOperatorMTUCurrentConfiguration(ctx context.Context, input *systemTestInput)

func ValidateDPFOperatorMaxDPUParallelInstallations 

func ValidateDPFOperatorMaxDPUParallelInstallations(ctx context.Context, input *systemTestInput)

func ValidateDPFOperatorOOBBridgeNameChange 

func ValidateDPFOperatorOOBBridgeNameChange(ctx context.Context, input *systemTestInput)

func ValidateDPFOperatorOOBBridgePostProvisioning 

func ValidateDPFOperatorOOBBridgePostProvisioning(ctx context.Context, input *systemTestInput)

func ValidateDPFOperatorPathConfiguration 

func ValidateDPFOperatorPathConfiguration(ctx context.Context, input *systemTestInput)

func ValidateDPUAgentStatus 

func ValidateDPUAgentStatus(ctx context.Context, input *systemTestInput, expected provisioningv1.AgentStatus)

ValidateDPUAgentStatus verifies that the DPU agent has reported its status correctly on every ready DPU. Each DPU is validated against the supplied expected AgentStatus.

func ValidateDPUClusterDNSResolution 

func ValidateDPUClusterDNSResolution(ctx context.Context, input *systemTestInput)

ValidateDPUClusterDNSResolution resolves a Service name from inside a DPU cluster Pod. This is the end to end check, and it applies whichever CoreDNS answers: it only passes if kubelet hands Pods the DNS Service ClusterIP and something is actually serving that address.

func ValidateDPUClusterDeletion 

func ValidateDPUClusterDeletion(ctx context.Context, input *systemTestInput)

ValidateDPUClusterDeletion validates the system when first DPUCluster is deleted. It uses the existing DPUDeployment (with each DPU joining a different cluster) and verifies that after cluster 1 is deleted the system remains healthy: DPFOperatorConfig, all DPUServices, DPUServiceChains, DPUServiceInterfaces, DPUServiceIPAMs, and the DPUDeployment are ready.

func ValidateDPUClusterEtcdEncryptionAtRest 

func ValidateDPUClusterEtcdEncryptionAtRest(ctx context.Context, input *systemTestInput)

ValidateDPUClusterEtcdEncryptionAtRest validates every managed Kamaji DPUCluster configured with encryption at rest. For static keys, it waits for rotation to finish and verifies that status references the latest source Secret revision. It then verifies that all Secrets and ConfigMaps remain readable through the tenant API and use the configured encryption provider in the shared Kamaji etcd. Static-key clusters must use one active key for every stored value.

func ValidateDPUClusterLogFlow 

func ValidateDPUClusterLogFlow(ctx context.Context, input *systemTestInput)

ValidateDPUClusterLogFlow verifies logs flow from DPU cluster to Loki

func ValidateDPUClusterMetricsFlow 

func ValidateDPUClusterMetricsFlow(ctx context.Context, input *systemTestInput)

ValidateDPUClusterMetricsFlow verifies that container, pod, and node metrics scraped by the DPU cluster collector's kubeletstats receiver are streamed to the host cluster and land in the host Prometheus. The DPU collector stamps every series with cluster=<DPUCluster name>, which uniquely identifies DPU-origin metrics and distinguishes them from host cadvisor metrics. The test queries Prometheus for kubelet-origin workload series carrying that label.

func ValidateDPUClusterOpenTelemetryConfiguration 

func ValidateDPUClusterOpenTelemetryConfiguration(ctx context.Context, input *systemTestInput)

ValidateDPUClusterOpenTelemetryConfiguration verifies DPU cluster collector configuration

func ValidateDPUDeploymentCreation 

func ValidateDPUDeploymentCreation(ctx context.Context, input *systemTestInput)

func ValidateDPUDeploymentDPUServiceChainDisruptiveUpgradeBadConfigurationAndBack 

func ValidateDPUDeploymentDPUServiceChainDisruptiveUpgradeBadConfigurationAndBack(ctx context.Context, input *systemTestInput)

ValidateDPUDeploymentDPUServiceChainDisruptiveUpgradeBadConfigurationAndBack validates that the DPUDeployment disruptive upgrade flow for DPUServiceChain behaves correctly when a bad configuration is deployed (causing the ServiceChain to be stuck not-ready). It validates that only one host node is drained, the DPU is stuck in Node Effect Removal for 1 minute, and that reverting to the original configuration recovers the DPU. The other DPU should not be drained at any point.

func ValidateDPUDeploymentDPUServiceChainDisruptiveUpgradeDrain 

func ValidateDPUDeploymentDPUServiceChainDisruptiveUpgradeDrain(ctx context.Context, input *systemTestInput)

ValidateDPUDeploymentDPUServiceChainDisruptiveUpgradeDrain validates that DPUDeployment disruptive upgrade flow for DPUServiceChain works as expected with drain node effect which is the recommendation for Host Trusted

func ValidateDPUDeploymentDPUServiceChainDisruptiveUpgradeHold 

func ValidateDPUDeploymentDPUServiceChainDisruptiveUpgradeHold(ctx context.Context, input *systemTestInput)

ValidateDPUDeploymentDPUServiceChainDisruptiveUpgradeHold validates that DPUDeployment disruptive upgrade flow for DPUServiceChain works as expected with hold node effect which is the default recommendation for Zero Trust

func ValidateDPUDeploymentDPUServiceDisruptiveUpgradeBadConfigurationAndBack 

func ValidateDPUDeploymentDPUServiceDisruptiveUpgradeBadConfigurationAndBack(ctx context.Context, input *systemTestInput)

ValidateDPUDeploymentDPUServiceDisruptiveUpgradeBadConfigurationAndBack validates that DPUDeployment disruptive upgrade flow for standard DPUService behaves correctly when a bad configuration is deployed (causing the pod to be stuck in CrashLoopBackOff). It validates that only one host node is drained, the DPU is stuck in Node Effect Removal for 1 minute, and that reverting to the original configuration recovers the DPU. The other DPU should not be drained at any point.

func ValidateDPUDeploymentDPUServiceDisruptiveUpgradeDrain 

func ValidateDPUDeploymentDPUServiceDisruptiveUpgradeDrain(ctx context.Context, input *systemTestInput)

ValidateDPUDeploymentDPUServiceDisruptiveUpgradeDrain validates that DPUDeployment disruptive upgrade flow for standard DPUService works as expected with node effect drain which is the recommendation for Host Trusted

func ValidateDPUDeploymentDPUServiceDisruptiveUpgradeHold 

func ValidateDPUDeploymentDPUServiceDisruptiveUpgradeHold(ctx context.Context, input *systemTestInput)

ValidateDPUDeploymentDPUServiceDisruptiveUpgradeHold validates that DPUDeployment disruptive upgrade flow for standard DPUService works as expected with hold node effect which is the recommendation for Zero Trust

func ValidateDPUDeploymentDeletionWhileDisruptiveUpgradeInProgress 

func ValidateDPUDeploymentDeletionWhileDisruptiveUpgradeInProgress(ctx context.Context, input *systemTestInput)

func ValidateDPUDeploymentFullCreation 

func ValidateDPUDeploymentFullCreation(ctx context.Context, input *systemTestInput)

func ValidateDPUDeploymentInClusterDPUServiceDisruptiveUpgrade 

func ValidateDPUDeploymentInClusterDPUServiceDisruptiveUpgrade(ctx context.Context, input *systemTestInput)

ValidateDPUDeploymentInClusterDPUServiceDisruptiveUpgrade validates that DPUDeployment disruptive upgrade flow for in-cluster DPUServices works as expected

func ValidateDPUDeploymentMetrics 

func ValidateDPUDeploymentMetrics(ctx context.Context, input *systemTestInput)

func ValidateDPUDeviceClusterNodeLabelsPropagation 

func ValidateDPUDeviceClusterNodeLabelsPropagation(ctx context.Context, input *systemTestInput)

ValidateDPUDeviceClusterNodeLabelsPropagation validates that changing DPUDevice.spec.cluster.nodeLabels/nodeAnnotations (add/update/remove) is reflected on the tenant cluster Node for a Ready DPU.

func ValidateDPUFlavorNodeLabelScripts 

func ValidateDPUFlavorNodeLabelScripts(ctx context.Context, input *systemTestInput)

ValidateDPUFlavorNodeLabelScripts validates that node label scripts delivered by DPUFlavor.spec.configFiles are executed by dpuagent and reflected as labels on tenant cluster Nodes.

func ValidateDPUFlavorTemplatePerDeviceNodeLabels 

func ValidateDPUFlavorTemplatePerDeviceNodeLabels(ctx context.Context, input *systemTestInput)

ValidateDPUFlavorTemplatePerDeviceNodeLabels verifies that each tenant Node carries a node label whose value equals the labelSuffix injected into its DPUDevice.spec.values. This proves the DPUFlavorTemplate was rendered per-DPU with data pulled from DPUDevice.spec.values and applied on the DPU by dpuagent.

func ValidateDPUServiceChainCreation 

func ValidateDPUServiceChainCreation(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceChainDeletion 

func ValidateDPUServiceChainDeletion(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceChainMetrics 

func ValidateDPUServiceChainMetrics(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceConfigPorts 

func ValidateDPUServiceConfigPorts(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceCreationAndMirroring 

func ValidateDPUServiceCreationAndMirroring(ctx context.Context, input *systemTestInput)

ValidateDPUServiceCreationAndMirroring creates the DPUService in DPU cluster and host cluster. It verifies all triggered objects are created and ready. Can be used as a test precondition (ex: DPUServiceDeletion test) and as a separate test.

func ValidateDPUServiceCredentialRequestCreation 

func ValidateDPUServiceCredentialRequestCreation(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceCredentialRequestDeletion 

func ValidateDPUServiceCredentialRequestDeletion(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceCredentialRequestMetrics 

func ValidateDPUServiceCredentialRequestMetrics(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceDeletion 

func ValidateDPUServiceDeletion(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceIPAMCreationInvalid 

func ValidateDPUServiceIPAMCreationInvalid(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceIPAMCreationNetworkForIPv4AndIPv6 

func ValidateDPUServiceIPAMCreationNetworkForIPv4AndIPv6(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceIPAMCreationSubnetForIPv4AndIPv6 

func ValidateDPUServiceIPAMCreationSubnetForIPv4AndIPv6(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceIPAMDeletionCidrSplit 

func ValidateDPUServiceIPAMDeletionCidrSplit(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceIPAMInL2ModePerDPUCluster 

func ValidateDPUServiceIPAMInL2ModePerDPUCluster(ctx context.Context, input *systemTestInput)

ValidateDPUServiceIPAMInL2ModePerDPUCluster validates per-DPUCluster DPUServiceIPAM configuration in L2 mode. This covers the advanced use case where each DPUCluster requires its own DPUServiceIPAM object (via DPUClusterSelector), where the user splits the CIDR on their own per DPUCluster.

func ValidateDPUServiceIPAMInL2ModeSharedAcrossDPUClusters 

func ValidateDPUServiceIPAMInL2ModeSharedAcrossDPUClusters(ctx context.Context, input *systemTestInput)

ValidateDPUServiceIPAMInL2ModeSharedAcrossDPUClusters validates a single DPUServiceIPAM object in L2 mode that spans all DPUClusters without a DPUClusterSelector. This is the standard multi-DPUCluster use case where the controller distributes IP allocations from a shared pool across all clusters automatically.

func ValidateDPUServiceIPAMInL2ModeSharedAcrossDPUClustersWithSingleIPPerNode 

func ValidateDPUServiceIPAMInL2ModeSharedAcrossDPUClustersWithSingleIPPerNode(ctx context.Context, input *systemTestInput)

ValidateDPUServiceIPAMInL2ModeSharedAcrossDPUClustersWithSingleIPPerNode validates a single DPUServiceIPAM in L2 mode spanning all DPUClusters where each node receives exactly one IP (PerNodeIPCount: 1).

func ValidateDPUServiceIPAMInL3ModePerDPUCluster 

func ValidateDPUServiceIPAMInL3ModePerDPUCluster(ctx context.Context, input *systemTestInput)

ValidateDPUServiceIPAMInL3ModePerDPUCluster validates per-DPUCluster DPUServiceIPAM configuration in L3 mode. This covers the advanced use case where each DPUCluster requires its own DPUServiceIPAM object (via DPUClusterSelector), where the user splits the CIDR on their own per DPUCluster.

func ValidateDPUServiceIPAMInL3ModeSharedAcrossDPUClusters 

func ValidateDPUServiceIPAMInL3ModeSharedAcrossDPUClusters(ctx context.Context, input *systemTestInput)

ValidateDPUServiceIPAMInL3ModeSharedAcrossDPUClusters validates a single DPUServiceIPAM object in L3 mode that spans all DPUClusters without a DPUClusterSelector. This is the standard multi-DPUCluster use case where the controller distributes IP prefix allocations from a shared network across all clusters automatically.

func ValidateDPUServiceIPAMInL3ModeSharedAcrossDPUClustersWithSingleIPPerNode 

func ValidateDPUServiceIPAMInL3ModeSharedAcrossDPUClustersWithSingleIPPerNode(ctx context.Context, input *systemTestInput)

ValidateDPUServiceIPAMInL3ModeSharedAcrossDPUClustersWithSingleIPPerNode validates a single DPUServiceIPAM in L3 mode spanning all DPUClusters where each node receives a /32 prefix (one IP address).

func ValidateDPUServiceIPAMInL3ModeSharedAcrossDPUClustersWithStaticAllocations 

func ValidateDPUServiceIPAMInL3ModeSharedAcrossDPUClustersWithStaticAllocations(ctx context.Context, input *systemTestInput)

ValidateDPUServiceIPAMInL3ModeSharedAcrossDPUClustersWithStaticAllocations validates a single DPUServiceIPAM in L3 mode that uses static allocations to explicitly pin each node across all DPUClusters to a specific IP prefix. This is the standard multi-DPUCluster use case for static allocations where one DPUServiceIPAM covers all clusters.

func ValidateDPUServiceIPAMMetrics 

func ValidateDPUServiceIPAMMetrics(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceIPAMMetricsDeletion 

func ValidateDPUServiceIPAMMetricsDeletion(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceIPAMWorkload 

func ValidateDPUServiceIPAMWorkload(ctx context.Context, input *systemTestInput, name, interfaceName string, pools []dpuServiceIPAMWorkloadPool)

func ValidateDPUServiceInterfaceCreation 

func ValidateDPUServiceInterfaceCreation(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceKataRuntimeClass 

func ValidateDPUServiceKataRuntimeClass(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceMetrics 

func ValidateDPUServiceMetrics(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceNADConsumedByPod 

func ValidateDPUServiceNADConsumedByPod(ctx context.Context, input *systemTestInput)

func ValidateDPUServiceNADFromOtherNamespaceConsumedByPod 

func ValidateDPUServiceNADFromOtherNamespaceConsumedByPod(ctx context.Context, input *systemTestInput)

ValidateDPUServiceNADFromOtherNamespaceConsumedByPod publishes the DPUServiceNAD in one namespace and consumes it from another, which ServiceDef.Network supports through its "namespace/name" form. It covers the resource injection in particular: fetchResourceNameFromNAD resolves the DPUServiceNAD in the namespace the reference names, and skips silently when it cannot, so an unresolved reference leaves the DPUService reporting Success and fails the Pod later with "deviceID is not set".

func ValidateDPUServiceNADMetrics 

func ValidateDPUServiceNADMetrics(ctx context.Context)

func ValidateDPUServiceTemplateCreationNoAnnotations 

func ValidateDPUServiceTemplateCreationNoAnnotations(ctx context.Context, input *systemTestInput)

func ValidateDPUSetClusterNodeLabelsPropagation 

func ValidateDPUSetClusterNodeLabelsPropagation(ctx context.Context, input *systemTestInput)

ValidateDPUSetClusterNodeLabelsPropagation validates that changing DPUSet.spec.dpuTemplate.spec.cluster.nodeLabels/nodeAnnotations is reflected on the tenant cluster Node for a Ready DPU.

func ValidateDPUSetNotReadyOnClusterMetadataConflict 

func ValidateDPUSetNotReadyOnClusterMetadataConflict(ctx context.Context, input *systemTestInput)

ValidateDPUSetNotReadyOnClusterMetadataConflict patches DPUSet template and a referenced DPUDevice to create a key/value conflict and verifies the DPUSet transitions to NotReady with the expected reason.

func ValidateExternalSecretsOpenBaoIntegration 

func ValidateExternalSecretsOpenBaoIntegration(ctx context.Context, input *systemTestInput)

ValidateExternalSecretsOpenBaoIntegration verifies initial replication and refresh from OpenBao.

func ValidateGeneralDPFMetrics 

func ValidateGeneralDPFMetrics(ctx context.Context, input *systemTestInput)

func ValidateImagePullSecretsSync 

func ValidateImagePullSecretsSync(ctx context.Context, input *systemTestInput)

func ValidateKamajiAuditLogFlow 

func ValidateKamajiAuditLogFlow(ctx context.Context, input *systemTestInput)

ValidateKamajiAuditLogFlow verifies that kube-apiserver audit logs from Kamaji DPU clusters are collected by the management cluster otel-agent and forwarded to Loki. It creates a namespace in the DPU cluster (which generates audit events) then checks that matching audit log entries appear in Loki tagged with the DPU cluster name.

func ValidateLeaderElectionFailover 

func ValidateLeaderElectionFailover(ctx context.Context, c client.Client, target leaderElectionTarget)

ValidateLeaderElectionFailover runs the full failover scenario for one controller: capture the current leader -> delete that pod (simulates leader failure) -> assert a different pod takes over the Lease and renews it at least once -> wait for the Deployment to recover.

func ValidateLegacyDPUServiceIPAMCreationCidrSplit 

func ValidateLegacyDPUServiceIPAMCreationCidrSplit(ctx context.Context, input *systemTestInput)

func ValidateLegacyDPUServiceIPAMCreationSubnetSplit 

func ValidateLegacyDPUServiceIPAMCreationSubnetSplit(ctx context.Context, input *systemTestInput)

func ValidateManagementClusterLogFlow 

func ValidateManagementClusterLogFlow(ctx context.Context, input *systemTestInput)

ValidateManagementClusterLogFlow verifies logs flow from management cluster to Loki

func ValidateNodeSRIOVDevicePluginConfigValidCreate 

func ValidateNodeSRIOVDevicePluginConfigValidCreate(ctx context.Context, input *systemTestInput)

ValidateNodeSRIOVDevicePluginConfigValidCreate creates a valid NodeSRIOVDevicePluginConfig and verifies it is accepted.

func ValidateNodeSRIOVDevicePluginManagement 

func ValidateNodeSRIOVDevicePluginManagement(ctx context.Context, input *systemTestInput)

func ValidateNodeSRIOVDevicePluginWebhookRejectsInvalid 

func ValidateNodeSRIOVDevicePluginWebhookRejectsInvalid(ctx context.Context, input *systemTestInput)

func ValidatePrivilegedPodEnforcementToggle 

func ValidatePrivilegedPodEnforcementToggle(ctx context.Context, input *systemTestInput)

ValidatePrivilegedPodEnforcementToggle verifies the breakglass toggle for PrivilegedPodEnforcement in DPFOperatorConfig. Disabling the field must keep the ValidatingAdmissionPolicy, its binding, and the allowlist ConfigMap in the DPU cluster, switching the binding's validationActions to Audit (so admission is logged, not denied) while keeping the allowlist ConfigMap maintained (not cleared) so the audit log only flags pods that enforcement would have denied. The objects are never deleted, to avoid the Kubernetes VAP paramRef informer bug on re-enable (https://github.com/kubernetes/kubernetes/issues/133827). Re-enabling must switch the binding back to Deny.

func ValidatePrometheusTargetsHealthy 

func ValidatePrometheusTargetsHealthy(ctx context.Context, input *systemTestInput)

ValidatePrometheusTargetsHealthy asserts that every scrape target known to Prometheus is currently up. It first checks that each DPU cluster has all the expected control-plane jobs (apiserver, kube-controller-manager, kube-scheduler, plus coredns for clusters served by the host cluster) represented among its up{cluster=<name>} series. It checks distinct job names rather than a sample count, because Kamaji runs multiple replicas of each control-plane component, so the number of samples per job varies with the replica count. This positive existence check catches the case where a missing credential Secret causes prometheus-operator to silently drop the entire ServiceMonitor — in that scenario no up{cluster=<name>} series exists at all, so the subsequent up==0 check would pass vacuously. It then queries `up == 0` (targets whose last scrape failed) and fails with a table of the offending job/instance pairs so that failures are immediately actionable without manual Prometheus inspection.

func ValidateVAPDeprecationWarnings 

func ValidateVAPDeprecationWarnings(ctx context.Context, input *systemTestInput)

ValidateVAPDeprecationWarnings verifies that the generated VAP deprecation warnings fire when a deprecated field is set on a DPF resource. It uses spec.bmcIP on a DPU as one arbitrary example of a deprecated field to trigger and assert on the warning.

func VerifyClusterPods 

func VerifyClusterPods(ctx context.Context, client client.Client, podSubstrToVerify []string)

VerifyClusterPods waits until, for each name substring in podSubstrToVerify, at least one pod in the cluster whose name contains that substring exists and its containers are ready.

func VerifyDPFOperatorConfigReady 

func VerifyDPFOperatorConfigReady(ctx context.Context, kclient client.Client, timeout time.Duration)

VerifyDPFOperatorConfigReady waits and verifies if the DPFOperatorConfig is ready.

func VerifyDPUClusterDNSEndpoint 

func VerifyDPUClusterDNSEndpoint(ctx context.Context, input *systemTestInput)

VerifyDPUClusterDNSEndpoint verifies the DNS Service in each DPU cluster is backed by the host cluster CoreDNS serving that same DPUCluster. The EndpointSlice matters as much as the Service: ArgoCD excludes EndpointSlice from the resources it manages, which is why the cluster manager writes both objects directly rather than shipping them in a chart.

func VerifyDPUClusterServesOwnDNS 

func VerifyDPUClusterServesOwnDNS(ctx context.Context, input *systemTestInput)

VerifyDPUClusterServesOwnDNS verifies that a DPUCluster the host cluster does not serve keeps the CoreDNS Kamaji deployed for it. Without a keepalived VIP there is no NodePort path back to the host cluster, so taking that CoreDNS away would leave the DPU cluster with no DNS at all.

func VerifyDPUClusterWithNodes 

func VerifyDPUClusterWithNodes(ctx context.Context, input ProvisionDPUClustersInput)

VerifyDPUClusterWithNodes waits and verifies if the DPUCluster has nodes meaning that there were DPUs provisioned. In addition verifies that the DPUs become ready. Note: Each DPU joins the DPU cluster as a separate K8s node, so the number of nodes in the DPU cluster equals totalDPUs.

func VerifyDPUDeploymentIsReady 

func VerifyDPUDeploymentIsReady(ctx context.Context, input *systemTestInput)

func VerifyDPUKSMMetricsCollection 

func VerifyDPUKSMMetricsCollection(ctx context.Context, input *systemTestInput)

func VerifyDPUPodToPodRDMATraffic 

func VerifyDPUPodToPodRDMATraffic(ctx context.Context, input *systemTestInput)

VerifyDPUPodToPodRDMATraffic verifies that 2 Pods in the DPUCluster can run RDMA traffic between each other.

func VerifyDPUServiceTemplateCreationWithAnnotations 

func VerifyDPUServiceTemplateCreationWithAnnotations(ctx context.Context, input *systemTestInput)

func VerifyDPUServiceTemplateMetrics 

func VerifyDPUServiceTemplateMetrics(ctx context.Context, input *systemTestInput)

func VerifyDPUServicesDeployed 

func VerifyDPUServicesDeployed(ctx context.Context, clusterClient client.Client, namespace string)

VerifyDPUServicesDeployed verifies that the expected DPUServices are deployed in the DPU cluster. This function can be reused across different test files (provisioning, system_setup, etc.)

func VerifyDeploymentUnderlyingObjectsCreated 

func VerifyDeploymentUnderlyingObjectsCreated(ctx context.Context, g Gomega, testClient client.Client, dpuDeployment *dpuservicev1.DPUDeployment) bool

func VerifyHBNOnlyBadFlowRecovery 

func VerifyHBNOnlyBadFlowRecovery(ctx context.Context, input *systemTestInput)

func VerifyHBNOnlyServiceFunctionChain 

func VerifyHBNOnlyServiceFunctionChain(ctx context.Context, input *systemTestInput)

func VerifyHostClusterCoreDNS 

func VerifyHostClusterCoreDNS(ctx context.Context, input *systemTestInput)

VerifyHostClusterCoreDNS verifies that every DPUCluster gets its own CoreDNS running on the host cluster, exposed by a Service the DPU nodes reach through the keepalived VIP.

func VerifyHostKSMMetricsCollection 

func VerifyHostKSMMetricsCollection(ctx context.Context)

func VerifyKamajiCoreDNSAddonDisabled 

func VerifyKamajiCoreDNSAddonDisabled(ctx context.Context, input *systemTestInput)

VerifyKamajiCoreDNSAddonDisabled verifies the Kamaji CoreDNS addon is off for every DPUCluster. If it were on, a second CoreDNS would run on the DPUs answering for the same zone, which is exactly what moving DNS to the host cluster is meant to avoid.

func VerifyNodeProblemDetectorConditions 

func VerifyNodeProblemDetectorConditions(ctx context.Context, input *systemTestInput)

func VerifyPerformancePodToPodDifferentNode 

func VerifyPerformancePodToPodDifferentNode(ctx context.Context, input *systemTestInput, namespacePrefix string)

VerifyPerformancePodToPodDifferentNode verifies performance between pods on different nodes

func VerifyPerformancePodToPodSameNode 

func VerifyPerformancePodToPodSameNode(ctx context.Context, input *systemTestInput, namespacePrefix string)

VerifyPerformancePodToPodSameNode verifies performance between pods on the same node

func VerifyPlainServiceFunctionChain 

func VerifyPlainServiceFunctionChain(ctx context.Context, input *systemTestInput)

func VerifyProvisioning 

func VerifyProvisioning(ctx context.Context, input *systemTestInput)

func VerifyProvisioningControllerPodsArg 

func VerifyProvisioningControllerPodsArg(ctx context.Context, kclient client.Client, arg string, timeout time.Duration)

VerifyProvisioningControllerPodsArg waits and verifies that all provisioning controller pods have the given argument in their manager container args.

func VerifyServiceMTUOnDPUPods 

func VerifyServiceMTUOnDPUPods(ctx context.Context, input *systemTestInput)

func VerifyTenantNamespaceViaChain 

func VerifyTenantNamespaceViaChain(ctx context.Context, input *systemTestInput)

VerifyTenantNamespaceViaChain attaches a DPUService to the tenant bridge through a service DPUServiceInterface, a patch DPUServiceInterface and a DPUServiceChain, all owned by the tenant and all carrying the service node selector. The NAD names br-sfc here, so the Pod's SF lands on the chaining bridge and the tenant's own chain and patch carry it to the tenant bridge: 

Pod ──SF──► br-sfc ══flows══► tenant-app-patch ──► br-tenant1 ──► tenant1-patch ──► br-sfc ══flows══► HBN tenant1_if
└────────────── tenant namespace ──────────────┘                 └──────────── dpf-operator-system ────────────────┘
    DPUServiceNAD, two DPUServiceInterfaces,                         DPUServiceInterface, DPUServiceChain,
    DPUServiceChain, DPUService                                      DPUServiceIPAM, HBN through the DPUDeployment

The handover is br-tenant1: the tenant's patch ends there, the platform's starts there, and the bridge learns between them. The two patches carry distinct labels, so they are separate ports on one bridge.

func VerifyTenantNamespaceViaNAD 

func VerifyTenantNamespaceViaNAD(ctx context.Context, input *systemTestInput)

VerifyTenantNamespaceViaNAD attaches a DPUService to the tenant bridge through a DPUServiceNAD, with no tenant DPUServiceInterface or DPUServiceChain. The NAD names br-tenant1, so the Pod's SF lands on the tenant bridge itself and the bridge learns between it and the patch the platform put there: 

Pod ──SF──► br-tenant1 ──► tenant1-patch ──► br-sfc ══flows══► HBN tenant1_if
└── tenant namespace ──┘   └────────────── dpf-operator-system ───────────────┘
    DPUServiceNAD              DPUServiceInterface, DPUServiceChain, DPUServiceIPAM,
    DPUService                 HBN through the DPUDeployment

The tenant owns two objects, and neither of them names HBN, the patch or the chain.

func WaitForDPUReboot 

func WaitForDPUReboot(ctx context.Context, input ProvisionDPUClustersInput)

WaitForDPUReboot waits for all DPUs to reach the DPURebooting phase, then polls each DPU's `Status.RebootStatus.Phase` until it reports `Succeeded`. The actual reboot is driven in-cluster by the DPUNode controller, which spawns a Job from the ConfigMap named in ProvisionDPUClustersInput.NodeRebootConfigMap (e.g. `dpunode-reboot-redfish`) and updates `RebootStatus` as the Job progresses; the test does not look at the Job directly because the controller may garbage-collect it after success. Fails fast if any DPU's `RebootStatus.Phase` becomes `Failed`. Applies to ZeroTrust only.

func WaitForExistingDPUClustersReady 

func WaitForExistingDPUClustersReady(ctx context.Context, input ProvisionDPUClustersInput)

WaitForExistingDPUClustersReady waits for each DPUCluster referenced by the e2e config to already exist and report Ready, without creating or mutating them. Used by OCP reuse mode where the DPUClusters are provisioned out of band and must not be recreated.

func WaitForOVNKHBNDeploymentReady 

func WaitForOVNKHBNDeploymentReady(ctx context.Context, input *systemTestInput)

func WeaveBeforeSuite 

func WeaveBeforeSuite(c config)

WeaveBeforeSuite is called from the e2e BeforeSuite to load Weave test artifacts from config.

func WeavePhysicalBeforeSuite 

func WeavePhysicalBeforeSuite(c config)

WeavePhysicalBeforeSuite loads WeavePhysical objects during e2e BeforeSuite.

Types

type ByTracker 

type ByTracker struct {
	// contains filtered or unexported fields
}

ByTracker tracks Ginkgo By() statements to ensure they are only printed once

func NewByTracker 

func NewByTracker() *ByTracker

NewByTracker creates a new ByTracker instance

func (*ByTracker) By 

func (b *ByTracker) By(key string, format string, args ...interface{})

By ensures a By() statement is only printed once for a given key

type DPUDeploymentNodesInfo 

type DPUDeploymentNodesInfo struct {
	// contains filtered or unexported fields
}

DPUDeploymentNodesInfo holds information about target nodes and DPUNodes

type DeployDPFSystemComponentsInput 

type DeployDPFSystemComponentsInput struct {
	ProvisioningControllerPVC *corev1.PersistentVolumeClaim
	ImagePullSecrets          []string
	// contains filtered or unexported fields
}

type ProvisionDPUClustersInput 

type ProvisionDPUClustersInput struct {
	NodeRebootConfigMap string
	DPUNodeBMCs         map[string]string
	// contains filtered or unexported fields
}

type ProvisioningExpected 

type ProvisioningExpected struct {
	DPUNodes      int
	DPUsPerNode   int
	TotalDPUs     int
	DPUClusters   int
	DPUSets       int
	DPUFlavors    int
	BFBs          int
	Prerequisites int
	DPUServices   int
}

ProvisioningExpected holds all expected counts for provisioning tests

type TestDomain 

type TestDomain struct {
	DPFSystem               string // DPFSystem test suite (e2e, provisioning-e2e)
	Scale                   string // Scale test suite
	SDN                     string // SDN test suite
	SNAP                    string // SNAP test suite
	Provisioning            string // Provisioning test suite
	RequiresNodes           string // Tests that require at least 1 DPU to be provisioned
	L2Connectivity          string // Tests that require L2 connectivity between nodes
	DPFUpgrade              string // Upgrade test suite
	DPFUpgradeValidation    string // Upgrade validation test suite
	DPFBFBLTSUpgrade        string // BFB LTS upgrade test suite - phase 1: install v25.10 with BFB LTS
	DPFBFBLTSUpgradeV264    string // BFB LTS upgrade test suite - phase 2: validate v26.4 + DPU rollout
	DPFBFBLTSUpgradeV268    string // BFB LTS upgrade test suite - phase 3: validate v26.8
	DPFBFBLTSUpgradeCurrent string // BFB LTS upgrade test suite - phase 4: validate HEAD with BFB LTS DPUs
	ExternalTest            string // External test scripts (DPF precondition setup)
	TCP                     string // TCP external performance tests
	UDP                     string // UDP external performance tests
	OVNKPrimary             string // Tests that need OVNK as primary CNI
	OVNKHBN                 string // Tests that need OVNK as primary CNI with HBN deployed alongside
	DPFVPCOVN               string // VPC OVN test suite
	Weave                   string // Weave test suite
	WeavePhysical           string // Physical BF4 Weave test suite (ZT)
	MultiDPUCluster         string // Multi DPUCluster setup tests
	ZeroTrust               string // Zero Trust mode in DPFOperatorConfig on the BeforeSuite stage
	Observability           string // Observability test suite
	ImagePullSecretsSync    string // ImagePullSecrets sync/cleanup validation (opt out in CI via !ImagePullSecretsSync)
	Performance             string // Performance test suite - applies MTU 9000 and extended DMS timeout
	OCP                     string // OpenShift reuse tests: run non-destructively against an already-provisioned cluster (no DPU (re)provisioning)
}

TestDomain defines test label domains for categorizing e2e tests

type TestVPCConfig 

type TestVPCConfig struct {
	Name               string
	Namespace          string
	Tenant             string
	VirtualNetworkName string
	Subnet             string
	Labels             map[string]string
}

TestVPCConfig holds VPC test configuration

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.