libvirt-python 12.6.0__tar.gz → 12.7.0__tar.gz

{libvirt_python-12.6.0 → libvirt_python-12.7.0}/AUTHORS

@@ -43,6 +43,7 @@ The individual contributors are
    Guido Günther <agx@sigxcpu.org>
    Han Han <hhan@redhat.com>
    Hu Tao <hutao@cn.fujitsu.com>
+   Jaehoon Kim <jhkim@linux.ibm.com>
    Jason Andryuk <andryuk@aero.org>
    Jelle van der Waa <jvanderwaa@redhat.com>
    Jim Fehlig <jfehlig@suse.com>

{libvirt_python-12.6.0 → libvirt_python-12.7.0}/ChangeLog

@@ -1,3 +1,116 @@
+ 2026- 8- 25 Jaehoon Kim <jhkim@linux.ibm.com>
+    
+    Add VIR_DOMAIN_IOTHREAD_POLL_WEIGHT macro
+    The VIR_DOMAIN_IOTHREAD_POLL_WEIGHT typed param is being introduced
+    in libvirt v12.7.0. Add the correct VIR_TYPED_PARAM_UINT entry to
+    virPyDomainSetIOThreadParams[] so that the parameter is parsed with
+    the correct type.
+    
+    
+    
+ 2026- 8- 20 Radoslaw Smigielski <rsmigiel@redhat.com>
+    
+    tests: add migration API tests for migrate, migrate2, and migrate3
+    Add a new test file test_domain_migration.py to cover the VM migration API,
+    using mocked C-level calls and test driver.
+    
+    
+    
+ 2026- 8- 6 Radoslaw Smigielski <rsmigiel@redhat.com>
+    
+    tests: expand connection tests in test_conn.py
+    Add functional tests for read-write and read-only connections using
+    the test:///default driver.
+    
+    
+    
+ 2026- 8- 6 Daniel P. Berrangé <berrange@redhat.com>
+    
+    rpm: convert to new pyproject macros
+    The currently used macros are deprecated:
+    
+    https://fedoraproject.org/wiki/Changes/DeprecateSetuppyMacros
+    
+    and print a warning that they will be removed in Fedora 45 so we
+    are overdue to port to the new macros.
+    
+    The new macros appear to be compatible with CentOS Stream 9, so
+    we don't need conditional use of the old macros.
+    
+    
+    
+ 2026- 8- 6 Daniel P. Berrangé <berrange@redhat.com>
+    
+    ci: add pyproject-rpm-macros
+    This is needed for the forthcoming change to the RPM packaging
+    
+    
+    
+ 2026- 8- 6 Daniel P. Berrangé <berrange@redhat.com>
+    
+    rpm: update to RHEL-9 / Fedora 43 as min versions
+    This lets us assume newer Python packaging macros
+    
+    
+    
+ 2026- 8- 5 Radoslaw Smigielski <rsmigiel@redhat.com>
+    
+    docs: simplyfy steps to build docs with Sphinx
+    Encapsulate all requirements in Python virtual environment,
+    do not depend on installing them at the system level.
+    
+    
+    
+ 2026- 8- 5 Radoslaw Smigielski <rsmigiel@redhat.com>
+    
+    docs: document Sphinx building steps
+    Added a "Building API Documentation" section to HACKING file
+    with the step of building docs with sphinx.
+    
+    
+    
+ 2026- 8- 5 Radoslaw Smigielski <rsmigiel@redhat.com>
+    
+    docs: publish libvirt-python API docs via GitLab pages
+    Add jobs:
+    - website_job
+    - pages
+    to build libvirt-python API docs using Sphinx.
+    
+    Created base on libvirt-php/libvirt-java/libvirt-ruby examples.
+    
+    
+    
+ 2026- 8- 5 Radoslaw Smigielski <rsmigiel@redhat.com>
+    
+    docs: add Sphinx configuration to generate Python API documentation
+    The libvirt-python bindings lack official API documentation despite
+    all the infrastructure for it already existing: the libvirt C project
+    ships XML API descriptions (libvirt-api.xml) with detailed function
+    documentation, and generator.py already extracts these descriptions
+    into Python docstrings in the generated code. However, there was no
+    tooling to render these docstrings into browsable documentation.
+    
+    Add a basic Sphinx setup with autodoc to generate HTML API reference
+    from the existing docstrings for all four modules: libvirt (main API),
+    libvirt_qemu, libvirt_lxc, and libvirtaio.
+    
+    
+    
+ 2026- 8- 3 Daniel P. Berrangé <berrange@redhat.com>
+    
+    Declare python 3.9 as min required
+    This is a side effect of the mypy type annotations changed in
+    
+    https://gitlab.com/libvirt/libvirt-python/-/merge_requests/208
+    
+    
+    
+ 2026- 8- 3 Jiri Denemark <jdenemar@redhat.com>
+    
+    Post-release version bump to 12.7.0
+    
+    
  2026- 7- 28 Daniel P. Berrangé <berrange@redhat.com>
     
     Use lowercase types for collection types

{libvirt_python-12.6.0 → libvirt_python-12.7.0}/HACKING

@@ -36,3 +36,23 @@ hand written source files
    the virStoragePool class
  - libvirt-override-virStream.py - high level overrides in
    the virStream class
+
+
+
+    Building API Documentation
+    ==========================
+
+The Python API reference is built with Sphinx using the autodoc
+extension. Since the Python modules are generated at build time
+from XML API descriptions, the package must be compiled before
+Sphinx can import anything.
+
+  $ python -m venv docs-venv --system-site-packages --symlinks
+  $ source docs-venv/bin/activate
+  $ python -m pip install setuptools build
+  $ python -m pip install -r requirements-docs.txt
+  $ python -m build -n -x
+  $ python -m pip install dist/libvirt_python*.whl
+  $ python -m sphinx -b html docs/ py_api_docs
+
+The rendered HTML will be in the py_api_docs/ directory.

{libvirt_python-12.6.0 → libvirt_python-12.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: libvirt-python
-Version: 12.6.0
+Version: 12.7.0
 Summary: The libvirt virtualization API python binding
 Home-page: http://www.libvirt.org
 Maintainer: Libvirt Maintainers
@@ -9,7 +9,7 @@ License: LGPL-v2.0-or-later
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3 :: Only
-Requires-Python: >=3.6
+Requires-Python: >=3.9
 Description-Content-Type: text/x-rst
 License-File: COPYING
 Dynamic: license-file

libvirt_python-12.7.0/VERSION

@@ -0,0 +1 @@
+12.7.0

{libvirt_python-12.6.0 → libvirt_python-12.7.0}/build/libvirt_python.egg-info/SOURCES.txt

@@ -57,6 +57,7 @@ tests/test_domain.py
 tests/test_domain_checkpoint.py
 tests/test_domain_config.py
 tests/test_domain_lifecycle.py
+tests/test_domain_migration.py
 tests/test_domain_snapshot.py
 tests/test_interface.py
 tests/test_network.py

{libvirt_python-12.6.0 → libvirt_python-12.7.0}/libvirt-override.c

@@ -1696,6 +1696,9 @@ static virPyTypedParamsHint virPyDomainSetIOThreadParams[] = {
     { VIR_DOMAIN_IOTHREAD_THREAD_POOL_MIN, VIR_TYPED_PARAM_INT },
     { VIR_DOMAIN_IOTHREAD_THREAD_POOL_MAX, VIR_TYPED_PARAM_INT },
 # endif /*  LIBVIR_CHECK_VERSION(8, 5, 0) */
+# if LIBVIR_CHECK_VERSION(12, 7, 0)
+    { VIR_DOMAIN_IOTHREAD_POLL_WEIGHT, VIR_TYPED_PARAM_UINT },
+# endif /*  LIBVIR_CHECK_VERSION(12, 7, 0) */
 };
 
 static PyObject *

{libvirt_python-12.6.0 → libvirt_python-12.7.0}/libvirt-python.spec

@@ -3,8 +3,8 @@
 # This spec file assumes you are building on a Fedora or RHEL version
 # that's still supported by the vendor. It may work on other distros
 # or versions, but no effort will be made to ensure that going forward
-%define min_rhel 8
-%define min_fedora 33
+%define min_rhel 9
+%define min_fedora 43
 
 %if (0%{?fedora} && 0%{?fedora} >= %{min_fedora}) || (0%{?rhel} && 0%{?rhel} >= %{min_rhel})
     %define supported_platform 1
@@ -16,7 +16,7 @@
 
 Summary: The libvirt virtualization API python3 binding
 Name: libvirt-python
-Version: 12.6.0
+Version: 12.7.0
 Release: 1%{?dist}
 Source0: https://libvirt.org/sources/python/%{dist_name}-%{version}.tar.gz
 Url: https://libvirt.org
@@ -25,7 +25,6 @@ BuildRequires: libvirt-devel == %{version}
 BuildRequires: python3-devel
 BuildRequires: python3-pytest
 BuildRequires: python3-lxml
-BuildRequires: python3-setuptools
 BuildRequires: gcc
 
 # Don't want provides for python shared objects
@@ -59,31 +58,26 @@ of recent versions of Linux (and other OSes).
 # for the -python3 package
 find examples -type f -exec chmod 0644 \{\} \;
 
+%generate_buildrequires
+%pyproject_buildrequires
+
 %build
 %if ! %{supported_platform}
 echo "This RPM requires either Fedora >= %{min_fedora} or RHEL >= %{min_rhel}"
 exit 1
 %endif
 
-%py3_build
+%pyproject_wheel
 
 %install
-%py3_install
+%pyproject_install
+%pyproject_save_files libvirt libvirt_lxc libvirt_qemu libvirtaio 'libvirtmod*'
 
 %check
+%pyproject_check_import
 %pytest
 
-%files -n python3-libvirt
+%files -n python3-libvirt -f %{pyproject_files}
 %doc ChangeLog AUTHORS README COPYING examples/
-%{python3_sitearch}/libvirt.py*
-%{python3_sitearch}/libvirtaio.py*
-%{python3_sitearch}/libvirt_qemu.py*
-%{python3_sitearch}/libvirt_lxc.py*
-%{python3_sitearch}/__pycache__/libvirt.cpython-*.py*
-%{python3_sitearch}/__pycache__/libvirt_qemu.cpython-*.py*
-%{python3_sitearch}/__pycache__/libvirt_lxc.cpython-*.py*
-%{python3_sitearch}/__pycache__/libvirtaio.cpython-*.py*
-%{python3_sitearch}/libvirtmod*
-%{python3_sitearch}/*egg-info
 
 %changelog

{libvirt_python-12.6.0 → libvirt_python-12.7.0}/setup.cfg

@@ -15,7 +15,7 @@ classifiers =
 	Programming Language :: Python :: 3 :: Only
 
 [options]
-python_requires = >=3.6
+python_requires = >=3.9
 package_dir = 
 	=build
 

libvirt_python-12.7.0/tests/test_conn.py

@@ -0,0 +1,268 @@
+import unittest
+import libvirt
+import tempfile
+import contextlib
+import os
+
+
+class TestLibvirtConn(unittest.TestCase):
+    def setUp(self):
+        self.conn = libvirt.open("test:///default")
+
+    def tearDown(self):
+        self.conn = None
+
+    def testConnDomainList(self):
+        doms = self.conn.listAllDomains()
+        self.assertEqual(len(doms), 1)
+        self.assertEqual(type(doms[0]), libvirt.virDomain)
+        self.assertEqual(doms[0].name(), "test")
+
+
+class TestLibvirtConnMetadata(unittest.TestCase):
+    """Connection metadata and lifecycle tests"""
+
+    def setUp(self):
+        self.conn = libvirt.open("test:///default")
+
+    def tearDown(self):
+        self.conn = None
+
+    def testConnGetURI(self):
+        uri = self.conn.getURI()
+
+        self.assertIsInstance(uri, str)
+        self.assertEqual(uri, "test:///default")
+
+    def testConnGetHostname(self):
+        hostname = self.conn.getHostname()
+
+        self.assertIsInstance(hostname, str)
+        self.assertGreater(len(hostname), 0)
+
+    def testConnGetLibVersion(self):
+        version = self.conn.getLibVersion()
+
+        self.assertIsInstance(version, int)
+        self.assertGreater(version, 0)
+
+    def testConnGetVersion(self):
+        """test driver reports hypervisor version 2"""
+        version = self.conn.getVersion()
+
+        self.assertIsInstance(version, int)
+        self.assertEqual(version, 2)
+
+    def testConnGetType(self):
+        """test driver reports type TEST"""
+        hv_type = self.conn.getType()
+
+        self.assertIsInstance(hv_type, str)
+        self.assertEqual(hv_type, "TEST")
+
+    def testConnIsAlive(self):
+        self.assertTrue(self.conn.isAlive())
+
+    def testConnIsEncrypted(self):
+        result = self.conn.isEncrypted()
+
+        self.assertIsInstance(result, (bool, int))
+        self.assertFalse(result)
+
+    def testConnIsSecure(self):
+        result = self.conn.isSecure()
+
+        self.assertIsInstance(result, (bool, int))
+        self.assertTrue(result)
+
+    def testConnClose(self):
+        self.assertTrue(self.conn.isAlive())
+
+        ret = self.conn.close()
+        self.assertEqual(ret, 0)
+
+        with self.assertRaises(libvirt.libvirtError):
+            self.conn.isAlive()
+
+    def testConnContextManager(self):
+        with libvirt.open("test:///default") as conn:
+            self.assertEqual(conn.getURI(), "test:///default")
+            self.assertTrue(conn.isAlive())
+
+        with self.assertRaises(libvirt.libvirtError):
+            conn.isAlive()
+
+
+class TestLibvirtConnOpenNegative(unittest.TestCase):
+    """Connection open failure for an invalid URI"""
+
+    def testOpenFails(self):
+        with self.assertRaises(libvirt.libvirtError) as ctx:
+            libvirt.open("not-a-valid-libvirt-uri")
+
+        self.assertIsNotNone(ctx.exception.get_error_message())
+
+
+class TestLibvirtConnReadOnly(unittest.TestCase):
+    """Read-only libvirt.openReadOnly() connection tests"""
+
+    DEFINE_XML = """
+        <domain type='test'>
+          <name>test-define-temp</name>
+          <uuid>12345678-1234-1234-1234-123456789abc</uuid>
+          <memory unit='KiB'>524288</memory>
+          <vcpu>1</vcpu>
+          <os>
+            <type>hvm</type>
+          </os>
+        </domain>
+        """
+
+    def setUp(self):
+        self.conn = libvirt.openReadOnly("test:///default")
+
+    def tearDown(self):
+        self.conn = None
+
+    def testOpenReadOnlySucceeds(self):
+        self.assertIsNotNone(self.conn)
+        self.assertTrue(self.conn.isAlive())
+
+    def testReadOnlyGetURI(self):
+        self.assertEqual(self.conn.getURI(), "test:///default")
+
+    def testReadOnlyGetType(self):
+        self.assertEqual(self.conn.getType(), "TEST")
+
+    def testReadOnlyListDomains(self):
+        domains = self.conn.listAllDomains()
+
+        self.assertIsInstance(domains, list)
+        self.assertGreater(len(domains), 0)
+        self.assertIsInstance(domains[0], libvirt.virDomain)
+
+    def testReadOnlyLookupAndInfo(self):
+        dom = self.conn.lookupByName("test")
+
+        self.assertEqual(dom.name(), "test")
+
+        info = dom.info()
+        self.assertIsInstance(info, (tuple, list))
+        self.assertEqual(len(info), 5)
+
+        state, _ = dom.state()
+        self.assertIsInstance(state, int)
+
+    def testReadOnlyXMLDesc(self):
+        dom = self.conn.lookupByName("test")
+        xml = dom.XMLDesc(0)
+
+        self.assertIsInstance(xml, str)
+        self.assertIn("<domain", xml)
+
+    def testReadOnlyDefineXMLDenied(self):
+        with self.assertRaises(libvirt.libvirtError) as ctx:
+            self.conn.defineXML(self.DEFINE_XML)
+
+        self.assertEqual(ctx.exception.get_error_code(),
+                         libvirt.VIR_ERR_OPERATION_DENIED)
+
+    def testReadOnlyDestroyDenied(self):
+        dom = self.conn.lookupByName("test")
+
+        with self.assertRaises(libvirt.libvirtError) as ctx:
+            dom.destroy()
+
+        self.assertEqual(ctx.exception.get_error_code(),
+                         libvirt.VIR_ERR_OPERATION_DENIED)
+
+    def testReadOnlyXMLDescSecureDenied(self):
+        dom = self.conn.lookupByName("test")
+
+        with self.assertRaises(libvirt.libvirtError) as ctx:
+            dom.XMLDesc(libvirt.VIR_DOMAIN_XML_SECURE)
+
+        self.assertEqual(ctx.exception.get_error_code(),
+                         libvirt.VIR_ERR_OPERATION_DENIED)
+
+    def testReadOnlyContextManager(self):
+        with libvirt.openReadOnly("test:///default") as conn:
+            self.assertEqual(conn.getURI(), "test:///default")
+            self.assertTrue(conn.isAlive())
+
+        with self.assertRaises(libvirt.libvirtError):
+            conn.isAlive()
+
+
+class TestLibvirtConnAuth(unittest.TestCase):
+    connXML = """
+<node>
+  <auth>
+    <user password="2147483647">marin</user>
+    <user password="87539319">srinivasa</user>
+  </auth>
+</node>"""
+    def setUp(self):
+        def noop(msg, opaque):
+            pass
+        libvirt.registerErrorHandler(noop, None)
+
+    @contextlib.contextmanager
+    def tempxmlfile(content):
+        try:
+            fp = tempfile.NamedTemporaryFile(delete=False,
+                                             prefix="libvirt-python-test",
+                                             suffix=".xml")
+            fname = fp.name
+            fp.write(content.encode("utf8"))
+            fp.close()
+            yield fname
+        finally:
+            os.unlink(fname)
+
+    def authHelper(self, username, password):
+        with TestLibvirtConnAuth.tempxmlfile(self.connXML) as fname:
+            magic = 142857
+            def authCB(creds, opaque):
+                if opaque != magic:
+                    return -1
+
+                for cred in creds:
+                    if (cred[0] == libvirt.VIR_CRED_AUTHNAME and
+                        username is not None):
+                        cred[4] = username
+                        return 0
+                    elif (cred[0] == libvirt.VIR_CRED_PASSPHRASE and
+                          password is not None):
+                        cred[4] = password
+                        return 0
+                    return -1
+                return 0
+
+            auth = [[libvirt.VIR_CRED_AUTHNAME,
+                     libvirt.VIR_CRED_ECHOPROMPT,
+                     libvirt.VIR_CRED_REALM,
+                     libvirt.VIR_CRED_PASSPHRASE,
+                     libvirt.VIR_CRED_NOECHOPROMPT,
+                     libvirt.VIR_CRED_EXTERNAL],
+                    authCB, magic]
+
+            return libvirt.openAuth("test://" + fname,
+                                    auth, 0)
+
+    def testOpenAuthGood(self):
+        conn = self.authHelper("srinivasa", "87539319")
+
+    def testOpenAuthBad(self):
+        try:
+            conn = self.authHelper("srinivasa", "2147483647")
+            raise Exception("Unexpected open success")
+        except libvirt.libvirtError as ex:
+            pass
+
+    def testOpenAuthNone(self):
+        try:
+            conn = self.authHelper(None, None)
+            raise Exception("Unexpected open success")
+        except libvirt.libvirtError as ex:
+            pass

libvirt_python-12.7.0/tests/test_domain_migration.py

@@ -0,0 +1,391 @@
+import libvirt
+import unittest
+
+from unittest.mock import patch, MagicMock
+
+
+class TestLibvirtDomainMigrationMocked(unittest.TestCase):
+    def setUp(self):
+        self.conn = libvirt.open("test:///default")
+        self.dom = self.conn.lookupByName("test")
+
+    def tearDown(self):
+        self.dom = None
+        self.conn = None
+
+    @patch("libvirtmod.virDomainMigrate3")
+    def testMigrate3LiveMigrationSuccess(self, mock_migrate3):
+        dst_conn = libvirt.open("test:///default")
+        dst_dom = dst_conn.lookupByName("test")
+
+        # A small hack to make virDomainFree work with mocked objects,
+        # the same applies to all tests in this set that return a domain pointer.
+        # Transfer ownership of the raw C pointer to the mock return value by
+        # setting _o to None so dst_dom.__del__ won't also call virDomainFree on it.
+        mock_migrate3.return_value = dst_dom._o
+        dst_dom._o = None
+
+        params = {
+            libvirt.VIR_MIGRATE_PARAM_URI: "qemu+ssh://desthost/system",
+            libvirt.VIR_MIGRATE_PARAM_BANDWIDTH: 1024,
+        }
+        flags = libvirt.VIR_MIGRATE_LIVE | libvirt.VIR_MIGRATE_PERSIST_DEST
+
+        result = self.dom.migrate3(dst_conn, params, flags)
+
+        self.assertIsInstance(result, libvirt.virDomain)
+
+        mock_migrate3.assert_called_once()
+        call_args = mock_migrate3.call_args
+        self.assertEqual(call_args[0][0], self.dom._o)
+        self.assertEqual(call_args[0][1], dst_conn._o)
+        self.assertEqual(call_args[0][3], flags)
+
+        dst_conn.close()
+
+    @patch("libvirtmod.virDomainMigrateToURI3")
+    def testMigrateToURI3PeerToPeerSuccess(self, mock_migrateToURI3):
+        mock_migrateToURI3.return_value = 0
+
+        dest_uri = "qemu+ssh://desthost/system"
+        params = {
+            libvirt.VIR_MIGRATE_PARAM_BANDWIDTH: 2048,
+            libvirt.VIR_MIGRATE_PARAM_DEST_NAME: "migrated-vm",
+        }
+        flags = libvirt.VIR_MIGRATE_LIVE | libvirt.VIR_MIGRATE_PEER2PEER
+
+        result = self.dom.migrateToURI3(dest_uri, params, flags)
+
+        self.assertEqual(result, 0)
+
+        mock_migrateToURI3.assert_called_once()
+        call_args = mock_migrateToURI3.call_args
+        self.assertEqual(call_args[0][0], self.dom._o)
+        self.assertEqual(call_args[0][1], dest_uri)
+        self.assertEqual(call_args[0][3], flags)
+
+    @patch("libvirtmod.virDomainMigrate3")
+    def testMigrate3OfflineMigration(self, mock_migrate3):
+        dst_conn = libvirt.open("test:///default")
+        dst_dom = dst_conn.lookupByName("test")
+
+        # domain must be inactive
+        if self.dom.isActive():
+            self.dom.destroy()
+
+        mock_migrate3.return_value = dst_dom._o
+        dst_dom._o = None
+
+        params = {}
+        flags = libvirt.VIR_MIGRATE_OFFLINE | libvirt.VIR_MIGRATE_PERSIST_DEST
+
+        result = self.dom.migrate3(dst_conn, params, flags)
+
+        self.assertIsInstance(result, libvirt.virDomain)
+        call_args = mock_migrate3.call_args
+        self.assertTrue(call_args[0][3] & libvirt.VIR_MIGRATE_OFFLINE)
+
+        dst_conn.close()
+
+    @patch("libvirtmod.virDomainMigrate3")
+    def testMigrate3WithCompressionParameters(self, mock_migrate3):
+        dst_conn = libvirt.open("test:///default")
+        dst_dom = dst_conn.lookupByName("test")
+
+        mock_migrate3.return_value = dst_dom._o
+        dst_dom._o = None
+
+        params = {
+            libvirt.VIR_MIGRATE_PARAM_BANDWIDTH: 1024,
+            libvirt.VIR_MIGRATE_PARAM_COMPRESSION: "mt",
+            libvirt.VIR_MIGRATE_PARAM_COMPRESSION_MT_LEVEL: 9,
+            libvirt.VIR_MIGRATE_PARAM_COMPRESSION_MT_THREADS: 4,
+            libvirt.VIR_MIGRATE_PARAM_COMPRESSION_MT_DTHREADS: 2,
+        }
+        flags = libvirt.VIR_MIGRATE_LIVE | libvirt.VIR_MIGRATE_COMPRESSED
+
+        result = self.dom.migrate3(dst_conn, params, flags)
+
+        self.assertIsInstance(result, libvirt.virDomain)
+        mock_migrate3.assert_called_once()
+        call_args = mock_migrate3.call_args
+        self.assertTrue(call_args[0][3] & libvirt.VIR_MIGRATE_COMPRESSED)
+
+        dst_conn.close()
+
+    @patch("libvirtmod.virDomainMigrateToURI3")
+    def testMigrateToURI3WithAutoConverge(self, mock_migrateToURI3):
+        mock_migrateToURI3.return_value = 0
+
+        params = {
+            libvirt.VIR_MIGRATE_PARAM_AUTO_CONVERGE_INITIAL: 20,
+            libvirt.VIR_MIGRATE_PARAM_AUTO_CONVERGE_INCREMENT: 10,
+        }
+        flags = (
+            libvirt.VIR_MIGRATE_LIVE
+            | libvirt.VIR_MIGRATE_PEER2PEER
+            | libvirt.VIR_MIGRATE_AUTO_CONVERGE
+        )
+
+        result = self.dom.migrateToURI3("qemu+ssh://dest/system", params, flags)
+
+        self.assertEqual(result, 0)
+        mock_migrateToURI3.assert_called_once()
+        call_args = mock_migrateToURI3.call_args
+        self.assertTrue(call_args[0][3] & libvirt.VIR_MIGRATE_AUTO_CONVERGE)
+
+    @patch("libvirtmod.virDomainMigrate3")
+    def testMigrate3WithTLSParameters(self, mock_migrate3):
+        dst_conn = libvirt.open("test:///default")
+        dst_dom = dst_conn.lookupByName("test")
+
+        mock_migrate3.return_value = dst_dom._o
+        dst_dom._o = None
+
+        params = {
+            libvirt.VIR_MIGRATE_PARAM_URI: "qemu+ssh://desthost/system",
+            libvirt.VIR_MIGRATE_PARAM_TLS_DESTINATION: "desthost.example.com",
+        }
+        flags = libvirt.VIR_MIGRATE_LIVE | libvirt.VIR_MIGRATE_TLS
+
+        result = self.dom.migrate3(dst_conn, params, flags)
+
+        self.assertIsInstance(result, libvirt.virDomain)
+        call_args = mock_migrate3.call_args
+        self.assertTrue(call_args[0][3] & libvirt.VIR_MIGRATE_TLS)
+
+        dst_conn.close()
+
+    @patch("libvirtmod.virDomainMigrateToURI3")
+    def testMigrateToURI3WithParallelConnections(self, mock_migrateToURI3):
+        mock_migrateToURI3.return_value = 0
+
+        params = {
+            libvirt.VIR_MIGRATE_PARAM_PARALLEL_CONNECTIONS: 4,
+            libvirt.VIR_MIGRATE_PARAM_BANDWIDTH: 4096,
+        }
+        flags = (
+            libvirt.VIR_MIGRATE_LIVE
+            | libvirt.VIR_MIGRATE_PEER2PEER
+            | libvirt.VIR_MIGRATE_PARALLEL
+        )
+
+        result = self.dom.migrateToURI3("qemu+ssh://dest/system", params, flags)
+
+        self.assertEqual(result, 0)
+
+        call_args = mock_migrateToURI3.call_args
+        self.assertTrue(call_args[0][3] & libvirt.VIR_MIGRATE_PARALLEL)
+
+    @patch("libvirtmod.virDomainMigrate3")
+    def testMigrate3EmptyParameterDict(self, mock_migrate3):
+        dst_conn = libvirt.open("test:///default")
+        dst_dom = dst_conn.lookupByName("test")
+
+        mock_migrate3.return_value = dst_dom._o
+        dst_dom._o = None
+
+        # Empty params dict
+        params = {}
+        flags = libvirt.VIR_MIGRATE_LIVE
+
+        result = self.dom.migrate3(dst_conn, params, flags)
+
+        self.assertIsInstance(result, libvirt.virDomain)
+        mock_migrate3.assert_called_once()
+
+        dst_conn.close()
+
+    @patch("libvirtmod.virDomainMigrate3")
+    def testMigrate3MultipleFlags(self, mock_migrate3):
+        dst_conn = libvirt.open("test:///default")
+        dst_dom = dst_conn.lookupByName("test")
+
+        mock_migrate3.return_value = dst_dom._o
+        dst_dom._o = None
+
+        params = {
+            libvirt.VIR_MIGRATE_PARAM_BANDWIDTH: 1024,
+        }
+
+        flags = (
+            libvirt.VIR_MIGRATE_LIVE
+            | libvirt.VIR_MIGRATE_PERSIST_DEST
+            | libvirt.VIR_MIGRATE_UNDEFINE_SOURCE
+            | libvirt.VIR_MIGRATE_COMPRESSED
+            | libvirt.VIR_MIGRATE_AUTO_CONVERGE
+        )
+
+        result = self.dom.migrate3(dst_conn, params, flags)
+
+        self.assertIsInstance(result, libvirt.virDomain)
+
+        call_args = mock_migrate3.call_args
+        passed_flags = call_args[0][3]
+        self.assertTrue(passed_flags & libvirt.VIR_MIGRATE_LIVE)
+        self.assertTrue(passed_flags & libvirt.VIR_MIGRATE_PERSIST_DEST)
+        self.assertTrue(passed_flags & libvirt.VIR_MIGRATE_UNDEFINE_SOURCE)
+        self.assertTrue(passed_flags & libvirt.VIR_MIGRATE_COMPRESSED)
+        self.assertTrue(passed_flags & libvirt.VIR_MIGRATE_AUTO_CONVERGE)
+
+        dst_conn.close()
+
+    @patch("libvirtmod.virDomainMigrate3")
+    def testMigrate3Failure(self, mock_migrate3):
+        dst_conn = libvirt.open("test:///default")
+
+        mock_migrate3.return_value = None
+
+        params = {}
+        flags = libvirt.VIR_MIGRATE_LIVE
+
+        # raise exception when C layer returns None
+        with self.assertRaises(libvirt.libvirtError) as ctx:
+            self.dom.migrate3(dst_conn, params, flags)
+
+        self.assertIn("virDomainMigrate3() failed", str(ctx.exception))
+
+        dst_conn.close()
+
+    @patch("libvirtmod.virDomainMigrateToURI3")
+    def testMigrateToURI3Failure(self, mock_migrateToURI3):
+        mock_migrateToURI3.return_value = -1
+
+        params = {}
+        flags = libvirt.VIR_MIGRATE_LIVE | libvirt.VIR_MIGRATE_PEER2PEER
+
+        # raise exception on failure
+        with self.assertRaises(libvirt.libvirtError):
+            self.dom.migrateToURI3("qemu+ssh://dest/system", params, flags)
+
+
+class TestLibvirtDomainMigrateLegacyMocked(unittest.TestCase):
+    """Tests for the legacy virDomainMigrate and virDomainMigrate2 APIs.
+
+    Both virDomainMigrate and virDomainMigrate2 call independent C functionas
+    (libvirtmod.virDomainMigrate and libvirtmod.virDomainMigrate2) and have
+    their own wrapping logic, so they are tested separately from migrate3.
+    """
+
+    def setUp(self):
+        self.conn = libvirt.open("test:///default")
+        self.dom = self.conn.lookupByName("test")
+
+    def tearDown(self):
+        self.dom = None
+        self.conn = None
+
+    @patch("libvirtmod.virDomainMigrate")
+    def testMigrateSuccess(self, mock_migrate):
+        dst_conn = libvirt.open("test:///default")
+        dst_dom = dst_conn.lookupByName("test")
+
+        mock_migrate.return_value = dst_dom._o
+        dst_dom._o = None
+
+        flags = libvirt.VIR_MIGRATE_LIVE | libvirt.VIR_MIGRATE_PERSIST_DEST
+        result = self.dom.migrate(dst_conn, flags, dname="migrated-vm",
+                                  uri="qemu+ssh://desthost/system", bandwidth=1024)
+
+        self.assertIsInstance(result, libvirt.virDomain)
+        mock_migrate.assert_called_once()
+        call_args = mock_migrate.call_args
+        self.assertEqual(call_args[0][0], self.dom._o)
+        self.assertEqual(call_args[0][1], dst_conn._o)
+        self.assertEqual(call_args[0][2], flags)
+
+        dst_conn.close()
+
+    @patch("libvirtmod.virDomainMigrate")
+    def testMigrateWithFlags(self, mock_migrate):
+        dst_conn = libvirt.open("test:///default")
+        dst_dom = dst_conn.lookupByName("test")
+
+        mock_migrate.return_value = dst_dom._o
+        dst_dom._o = None
+
+        flags = (
+            libvirt.VIR_MIGRATE_LIVE
+            | libvirt.VIR_MIGRATE_PERSIST_DEST
+            | libvirt.VIR_MIGRATE_UNDEFINE_SOURCE
+        )
+        result = self.dom.migrate(dst_conn, flags)
+
+        self.assertIsInstance(result, libvirt.virDomain)
+        call_args = mock_migrate.call_args
+        passed_flags = call_args[0][2]
+        self.assertTrue(passed_flags & libvirt.VIR_MIGRATE_LIVE)
+        self.assertTrue(passed_flags & libvirt.VIR_MIGRATE_PERSIST_DEST)
+        self.assertTrue(passed_flags & libvirt.VIR_MIGRATE_UNDEFINE_SOURCE)
+
+        dst_conn.close()
+
+    @patch("libvirtmod.virDomainMigrate")
+    def testMigrateFailure(self, mock_migrate):
+        dst_conn = libvirt.open("test:///default")
+
+        mock_migrate.return_value = None
+
+        with self.assertRaises(libvirt.libvirtError) as ctx:
+            self.dom.migrate(dst_conn, libvirt.VIR_MIGRATE_LIVE)
+
+        self.assertIn("virDomainMigrate() failed", str(ctx.exception))
+
+        dst_conn.close()
+
+    @patch("libvirtmod.virDomainMigrate2")
+    def testMigrate2Success(self, mock_migrate2):
+        dst_conn = libvirt.open("test:///default")
+        dst_dom = dst_conn.lookupByName("test")
+
+        mock_migrate2.return_value = dst_dom._o
+        dst_dom._o = None
+
+        dxml = "<domain type='test'><name>migrated-vm</name></domain>"
+        flags = libvirt.VIR_MIGRATE_LIVE | libvirt.VIR_MIGRATE_PERSIST_DEST
+        result = self.dom.migrate2(dst_conn, dxml=dxml, flags=flags,
+                                   dname="migrated-vm")
+
+        self.assertIsInstance(result, libvirt.virDomain)
+        mock_migrate2.assert_called_once()
+        call_args = mock_migrate2.call_args
+        self.assertEqual(call_args[0][0], self.dom._o)
+        self.assertEqual(call_args[0][1], dst_conn._o)
+        self.assertEqual(call_args[0][2], dxml)
+        self.assertEqual(call_args[0][3], flags)
+
+        dst_conn.close()
+
+    @patch("libvirtmod.virDomainMigrate2")
+    def testMigrate2WithoutXML(self, mock_migrate2):
+        dst_conn = libvirt.open("test:///default")
+        dst_dom = dst_conn.lookupByName("test")
+
+        mock_migrate2.return_value = dst_dom._o
+        dst_dom._o = None
+
+        flags = libvirt.VIR_MIGRATE_LIVE
+        result = self.dom.migrate2(dst_conn, flags=flags)
+
+        self.assertIsInstance(result, libvirt.virDomain)
+        call_args = mock_migrate2.call_args
+        self.assertIsNone(call_args[0][2])
+
+        dst_conn.close()
+
+    @patch("libvirtmod.virDomainMigrate2")
+    def testMigrate2Failure(self, mock_migrate2):
+        dst_conn = libvirt.open("test:///default")
+
+        mock_migrate2.return_value = None
+
+        with self.assertRaises(libvirt.libvirtError) as ctx:
+            self.dom.migrate2(dst_conn, flags=libvirt.VIR_MIGRATE_LIVE)
+
+        self.assertIn("virDomainMigrate2() failed", str(ctx.exception))
+
+        dst_conn.close()
+
+
+if __name__ == "__main__":
+    unittest.main()

libvirt_python-12.6.0/VERSION

@@ -1 +0,0 @@
-12.6.0

libvirt_python-12.6.0/tests/test_conn.py

@@ -1,92 +0,0 @@
-import unittest
-import libvirt
-import tempfile
-import contextlib
-import os
-
-
-class TestLibvirtConn(unittest.TestCase):
-    def setUp(self):
-        self.conn = libvirt.open("test:///default")
-
-    def tearDown(self):
-        self.conn = None
-
-    def testConnDomainList(self):
-        doms = self.conn.listAllDomains()
-        self.assertEqual(len(doms), 1)
-        self.assertEqual(type(doms[0]), libvirt.virDomain)
-        self.assertEqual(doms[0].name(), "test")
-
-class TestLibvirtConnAuth(unittest.TestCase):
-    connXML = """
-<node>
-  <auth>
-    <user password="2147483647">marin</user>
-    <user password="87539319">srinivasa</user>
-  </auth>
-</node>"""
-    def setUp(self):
-        def noop(msg, opaque):
-            pass
-        libvirt.registerErrorHandler(noop, None)
-
-    @contextlib.contextmanager
-    def tempxmlfile(content):
-        try:
-            fp = tempfile.NamedTemporaryFile(delete=False,
-                                             prefix="libvirt-python-test",
-                                             suffix=".xml")
-            fname = fp.name
-            fp.write(content.encode("utf8"))
-            fp.close()
-            yield fname
-        finally:
-            os.unlink(fname)
-
-    def authHelper(self, username, password):
-        with TestLibvirtConnAuth.tempxmlfile(self.connXML) as fname:
-            magic = 142857
-            def authCB(creds, opaque):
-                if opaque != magic:
-                    return -1
-
-                for cred in creds:
-                    if (cred[0] == libvirt.VIR_CRED_AUTHNAME and
-                        username is not None):
-                        cred[4] = username
-                        return 0
-                    elif (cred[0] == libvirt.VIR_CRED_PASSPHRASE and
-                          password is not None):
-                        cred[4] = password
-                        return 0
-                    return -1
-                return 0
-
-            auth = [[libvirt.VIR_CRED_AUTHNAME,
-                     libvirt.VIR_CRED_ECHOPROMPT,
-                     libvirt.VIR_CRED_REALM,
-                     libvirt.VIR_CRED_PASSPHRASE,
-                     libvirt.VIR_CRED_NOECHOPROMPT,
-                     libvirt.VIR_CRED_EXTERNAL],
-                    authCB, magic]
-
-            return libvirt.openAuth("test://" + fname,
-                                    auth, 0)
-
-    def testOpenAuthGood(self):
-        conn = self.authHelper("srinivasa", "87539319")
-
-    def testOpenAuthBad(self):
-        try:
-            conn = self.authHelper("srinivasa", "2147483647")
-            raise Exception("Unexpected open success")
-        except libvirt.libvirtError as ex:
-            pass
-
-    def testOpenAuthNone(self):
-        try:
-            conn = self.authHelper(None, None)
-            raise Exception("Unexpected open success")
-        except libvirt.libvirtError as ex:
-            pass