test: add test for canonical pcie

Signed-off-by: Abhinandan Purkait <[email protected]>

Author: Abhinandan-Purkait

Cargo.lock

@@ -7,7 +7,6 @@ use grpc::{
     },
 };
 use itertools::Itertools;
-use regex::Regex;
 use std::{collections::HashMap, convert::TryFrom, thread::sleep, time::Duration};
 use stor_port::types::v0::store::pool::{Encryption, EncryptionSecret};
 use stor_port::types::v0::transport::{GetBlockDevices, NodeStatus};
@@ -1364,34 +1363,3 @@ async fn reject_devlink_reuse() {
         }
     }
 }
-
-#[tokio::test]
-async fn persistent_devlink_regex() {
-    fn is_persistent_devlink(pattern: &str) -> bool {
-        let re = Regex::new(utils::DEVLINK_REGEX).expect("DEVLINK_REGEX should be valid");
-        re.is_match(pattern)
-    }
-
-    let test_suite = [
-        ("/dev/some/path", false),
-        ("/dev/mapper/some/path", false),
-        ("/dev/disk/some/path", false),
-        ("/dev/disk/by-something/path", false),
-        ("/devil/disk/by-something/path", false),
-        ("/dev/diskxyz/by-something/path", false),
-        ("/dev/disk/something-by/path", false),
-        ("/dev/disk/by-/path", false),
-        ("something", false),
-        ("/dev/somevg/lv0", false), // LVM Paths are to be used via the /dev/mapper or by /dev/disk/by-id
-        ("/dev/disk/by-id/somepath", true),
-        ("/dev/disk/by-path/somepath", true),
-        ("/dev/disk/by-label/somepath", true),
-        ("/dev/disk/by-partuuid/somepath", true),
-        ("/dev/disk/by-partlabel/somepath", true),
-        ("/dev/mapper/dm0", true),
-    ];
-
-    for test in test_suite {
-        assert_eq!(is_persistent_devlink(test.0), test.1);
-    }
-}

control-plane/agents/src/bin/core/tests/pool/mod.rs

@@ -358,24 +358,3 @@ pub(crate) async fn migrate_and_clean_msps(k8s: &Client, namespace: &str) -> Res
     }
     Ok(())
 }
-
-#[cfg(test)]
-mod test {
-
-    #[test]
-    fn normalize_disk() {
-        let disks = [
-            "aio:///dev/null",
-            "uring:///dev/null",
-            "uring://dev/null", // this URL is invalid
-            "pcie:///0000:01:00.0",
-            "pcie:///00:01:00.0",
-        ];
-
-        assert_eq!(utils::disk::normalize_disk(disks[0]), "/dev/null");
-        assert_eq!(utils::disk::normalize_disk(disks[1]), "/dev/null");
-        assert_eq!(utils::disk::normalize_disk(disks[2]), "uring://dev/null");
-        assert_eq!(utils::disk::normalize_disk(disks[3]), "/0000:01:00.0");
-        assert_eq!(utils::disk::normalize_disk(disks[4]), "/0000:01:00.0");
-    }
-}

k8s/operators/src/pool/main.rs

@@ -10,6 +10,7 @@
 )
 import pytest
 import subprocess
+from retrying import retry
 
 from common.deployer import Deployer
 from common.apiclient import ApiClient
@@ -179,6 +180,7 @@ def publish_to_node_2(background):
 
 
 @pytest.fixture
+@retry(wait_fixed=10, stop_max_attempt_number=200)
 def connect_to_node_2(publish_to_node_2):
     device = nvme_connect(publish_to_node_2)
     desc = nvme_list_subsystems(device)

tests/bdd/features/ana/validate/test_validate_nexus_swap.py

@@ -23,6 +23,7 @@ url = "2.5.4"
 strum = "0.26.3"
 strum_macros = "0.26.4"
 heck = "0.5.0"
+regex = "1.11.1"
 
 version-info = { path = "../dependencies/version-info", default-features = false }
 git-version-macro = { path = "../dependencies/git-version-macro" }

utils/utils-lib/Cargo.toml

@@ -1,7 +1,7 @@
 use url::Url;
 
-/// Normalize the disks if they have a schema, we dont want to change anything
-/// or do any error checking -- the loop will converge to the error state eventually
+/// Normalize the disks if they have a schema, we don't want to change anything
+/// or do any error checking.
 pub fn normalize_disk(disk: &str) -> String {
     let disk = if disk.starts_with("pcie://") {
         canonical_pcie_address(disk).unwrap_or_else(|| disk.to_string())
@@ -19,7 +19,7 @@ pub fn normalize_disk(disk: &str) -> String {
 }
 
 fn canonical_pcie_address(addr: &str) -> Option<String> {
-    let stripped = addr.strip_prefix("pcie://")?;
+    let stripped = addr.strip_prefix("pcie:///")?;
 
     let parts: Vec<&str> = stripped.split([':', '.']).collect();
     if parts.len() != 4 {
@@ -33,3 +33,80 @@ fn canonical_pcie_address(addr: &str) -> Option<String> {
 
     Some(format!("pcie:///{domain}:{bus}:{device}.{function}"))
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::disk::{canonical_pcie_address, normalize_disk};
+    use regex::Regex;
+
+    #[test]
+    fn persistent_devlink_regex() {
+        fn is_persistent_devlink(pattern: &str) -> bool {
+            let re = Regex::new(crate::DEVLINK_REGEX).expect("DEVLINK_REGEX should be valid");
+            re.is_match(pattern)
+        }
+
+        let test_suite = [
+            ("/dev/some/path", false),
+            ("/dev/mapper/some/path", false),
+            ("/dev/disk/some/path", false),
+            ("/dev/disk/by-something/path", false),
+            ("/devil/disk/by-something/path", false),
+            ("/dev/diskxyz/by-something/path", false),
+            ("/dev/disk/something-by/path", false),
+            ("/dev/disk/by-/path", false),
+            ("something", false),
+            ("/dev/somevg/lv0", false),
+            ("/dev/disk/by-id/somepath", true),
+            ("/dev/disk/by-path/somepath", true),
+            ("/dev/disk/by-label/somepath", true),
+            ("/dev/disk/by-partuuid/somepath", true),
+            ("/dev/disk/by-partlabel/somepath", true),
+            ("/dev/mapper/dm0", true),
+        ];
+
+        for test in test_suite {
+            assert_eq!(is_persistent_devlink(test.0), test.1);
+        }
+    }
+
+    #[test]
+    fn normalize_disk_test() {
+        let test_suite = [
+            ("aio:///dev/null", "/dev/null"),
+            ("uring:///dev/null", "/dev/null"),
+            ("uring://dev/null", "uring://dev/null"),
+            ("pcie:///0000:01:00.0", "/0000:01:00.0"),
+            ("pcie:///00:01:00.0", "/0000:01:00.0"),
+            ("pcie:///12454:01:00.0", "/12454:01:00.0"),
+        ];
+        for test in test_suite {
+            assert_eq!(normalize_disk(test.0), test.1);
+        }
+    }
+
+    #[test]
+    fn canonical_pcie_address_test() {
+        let test_suite = [
+            (
+                "pcie:///0000:01:00.0",
+                Some("pcie:///0000:01:00.0".to_string()),
+            ),
+            (
+                "pcie:///00:01:00.0",
+                Some("pcie:///0000:01:00.0".to_string()),
+            ),
+            (
+                "pcie:///12454:01:00.0", // Invalid address
+                None,
+            ),
+            (
+                "pcie:///0011:0111:00.0", // Invalid address
+                None,
+            ),
+        ];
+        for test in test_suite {
+            assert_eq!(canonical_pcie_address(test.0), test.1);
+        }
+    }
+}