Merge pull request #1134 from rackerlabs/split-nvme-driver-library

feat(cinder-understack): split up library from driver interface and add test framework

Author: nidzrai

.github/workflows/code-test.yaml

@@ -53,7 +53,13 @@ jobs:
           python-version-file: python/${{ matrix.project }}/pyproject.toml
       - run: uv sync
       - run: uv build --wheel
-      - run: "uv run pytest --cov --cov-report xml:coverage.xml"
+      - run: |
+          set -e
+          if [ -e .stestr.conf ]; then
+            uv run stestr run
+          else
+            uv run pytest --cov --cov-report xml:coverage.xml
+          fi
       - uses: actions/upload-artifact@ea165f8d65b6e75b540449e92b4886f43607fa02 # v4
         with:
           name: coverage-${{ matrix.project }}

python/cinder-understack/.gitignore

@@ -0,0 +1 @@
+.stestr/

python/cinder-understack/.stestr.conf

@@ -0,0 +1,3 @@
+[DEFAULT]
+test_path=${OS_TEST_PATH:-./cinder_understack/tests}
+top_dir=./

python/cinder-understack/cinder_understack/dynamic_netapp_driver.py

@@ -2,6 +2,7 @@
 
 from cinder import context
 from cinder import exception
+from cinder import interface
 from cinder.objects import volume_type as vol_type_obj
 from cinder.volume import driver as volume_driver
 from cinder.volume.drivers.netapp import options
@@ -31,8 +32,8 @@
 ]
 
 
-class NetappCinderDynamicDriver(NetAppNVMeStorageLibrary):
-    """NetApp NVMe driver with dynamic SVM selection from volume types.
+class NetappDynamicLibrary(NetAppNVMeStorageLibrary):
+    """NetApp NVMe storage library with dynamic SVM selection from volume types.
 
     Key difference from standard NetApp drivers:
     - Standard: One SVM per backend, all config in cinder.conf
@@ -964,6 +965,87 @@ def create_volume(self, volume):
             ) from e
 
 
+@interface.volumedriver
+class NetappCinderDynamicDriver(volume_driver.BaseVD):
+    """NetApp NVMe driver with dynamic multi-SVM support.
+
+    This driver follows the standard Cinder pattern by inheriting from BaseVD
+    and delegating storage operations to the NetappDynamicLibrary.
+    """
+
+    VERSION = "1.0.0"
+    DRIVER_NAME = "NetApp_Dynamic_NVMe"
+
+    def __init__(self, *args, **kwargs):
+        """Initialize the driver and create library instance."""
+        super().__init__(*args, **kwargs)
+        self.library = NetappDynamicLibrary(self.DRIVER_NAME, "NVMe", **kwargs)
+
+    def do_setup(self, context):
+        """Setup the driver."""
+        self.library.do_setup(context)
+
+    def check_for_setup_error(self):
+        """Check for setup errors."""
+        self.library.check_for_setup_error()
+
+    def create_volume(self, volume):
+        """Create a volume."""
+        return self.library.create_volume(volume)
+
+    def delete_volume(self, volume):
+        """Delete a volume."""
+        return self.library.delete_volume(volume)
+
+    def create_snapshot(self, snapshot):
+        """Create a snapshot."""
+        return self.library.create_snapshot(snapshot)
+
+    def delete_snapshot(self, snapshot):
+        """Delete a snapshot."""
+        return self.library.delete_snapshot(snapshot)
+
+    def create_volume_from_snapshot(self, volume, snapshot):
+        """Create a volume from a snapshot."""
+        return self.library.create_volume_from_snapshot(volume, snapshot)
+
+    def create_cloned_volume(self, volume, src_vref):
+        """Create a cloned volume."""
+        return self.library.create_cloned_volume(volume, src_vref)
+
+    def extend_volume(self, volume, new_size):
+        """Extend a volume."""
+        return self.library.extend_volume(volume, new_size)
+
+    def initialize_connection(self, volume, connector):
+        """Initialize connection to volume."""
+        return self.library.initialize_connection(volume, connector)
+
+    def terminate_connection(self, volume, connector, **kwargs):
+        """Terminate connection to volume."""
+        return self.library.terminate_connection(volume, connector, **kwargs)
+
+    def get_volume_stats(self, refresh=False):
+        """Get volume stats."""
+        return self.library.get_volume_stats(refresh)
+
+    def update_provider_info(self, volumes, snapshots):
+        """Update provider info."""
+        return self.library.update_provider_info(volumes, snapshots)
+
+    def create_export(self, context, volume, connector):
+        """Create export for volume."""
+        return self.library.create_export(context, volume, connector)
+
+    def ensure_export(self, context, volume):
+        """Ensure export for volume."""
+        return self.library.ensure_export(context, volume)
+
+    def remove_export(self, context, volume):
+        """Remove export for volume."""
+        return self.library.remove_export(context, volume)
+
+
 # NOTES
 # Namespace: Manually created because we skip standard do_setup()
 # Pool: Custom svm#flexvol format to support multi-SVM

python/cinder-understack/cinder_understack/tests/test_dynamic_netapp_driver.py

@@ -0,0 +1,64 @@
+"""Test NetApp dynamic driver implementation."""
+
+from unittest import mock
+
+from cinder.tests.unit import test
+from cinder.tests.unit.volume.drivers.netapp import fakes as na_fakes
+
+from cinder_understack import dynamic_netapp_driver
+
+
+class NetappDynamicDriverTestCase(test.TestCase):
+    """Test case for NetappCinderDynamicDriver."""
+
+    def setUp(self):
+        """Set up test case."""
+        super().setUp()
+
+        kwargs = {
+            "configuration": self.get_config_base(),
+            "host": "openstack@netapp_dynamic",
+        }
+        self.driver = dynamic_netapp_driver.NetappCinderDynamicDriver(**kwargs)
+        self.library = self.driver.library
+
+    def get_config_base(self):
+        """Get base configuration for testing."""
+        return na_fakes.create_configuration()
+
+    def test_driver_has_correct_attributes(self):
+        """Test that driver has expected attributes."""
+        self.assertEqual("1.0.0", self.driver.VERSION)
+        self.assertEqual("NetApp_Dynamic_NVMe", self.driver.DRIVER_NAME)
+
+    def test_driver_has_library_instance(self):
+        """Test that driver has library instance."""
+        self.assertIsInstance(self.library, dynamic_netapp_driver.NetappDynamicLibrary)
+
+    def test_library_inherits_from_netapp_library(self):
+        """Test that library inherits from NetApp NVMe library."""
+        from cinder.volume.drivers.netapp.dataontap.nvme_library import (
+            NetAppNVMeStorageLibrary,
+        )
+
+        self.assertIsInstance(self.library, NetAppNVMeStorageLibrary)
+
+    @mock.patch.object(dynamic_netapp_driver.NetappDynamicLibrary, "do_setup")
+    def test_do_setup_calls_library(self, mock_do_setup):
+        """Test that do_setup delegates to library."""
+        context = mock.Mock()
+        self.driver.do_setup(context)
+        mock_do_setup.assert_called_once_with(context)
+
+    @mock.patch.object(dynamic_netapp_driver.NetappDynamicLibrary, "create_volume")
+    def test_create_volume_calls_library(self, mock_create_volume):
+        """Test that create_volume delegates to library."""
+        volume = mock.Mock()
+        self.driver.create_volume(volume)
+        mock_create_volume.assert_called_once_with(volume)
+
+    @mock.patch.object(dynamic_netapp_driver.NetappDynamicLibrary, "get_volume_stats")
+    def test_get_volume_stats_calls_library(self, mock_get_volume_stats):
+        """Test that get_volume_stats delegates to library."""
+        self.driver.get_volume_stats(refresh=True)
+        mock_get_volume_stats.assert_called_once_with(True)

python/cinder-understack/cinder_understack/tests/test_noop.py

@@ -24,17 +24,19 @@ classifiers = [
     "Programming Language :: Python :: 3.10",
 ]
 dependencies = [
+  "cinder>=25.0.0,<26",
+  "oslo.utils>=6.0.0,<8"
 ]
 
 [project.urls]
 Source = "https://github.com/rackerlabs/understack"
 
 [dependency-groups]
 test = [
-    "pytest>=8.3.2,<9",
-    "pytest-cov>=6.2.1,<7",
-    "pytest-mock>=3.14.0,<4",
-]
+    "ddt>=1.4.4",
+    "fixtures>=3.0.0",
+    "stestr>=3.2.1",
+ ]
 
 [tool.uv]
 default-groups = ["test"]