clonebox 1.1.10__tar.gz → 1.1.12__tar.gz

{clonebox-1.1.10/src/clonebox.egg-info → clonebox-1.1.12}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 1.1.10
+Version: 1.1.12
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0

{clonebox-1.1.10 → clonebox-1.1.12}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "clonebox"
-version = "1.1.10"
+version = "1.1.12"
 description = "Clone your workstation environment to an isolated VM with selective apps, paths and services"
 readme = "README.md"
 license = {text = "Apache-2.0"}

{clonebox-1.1.10 → clonebox-1.1.12}/src/clonebox/cli.py

@@ -1825,23 +1825,37 @@ def cmd_test(args):
     # Test 4: Check mounts (if running)
     if not quick and state == "running":
         console.print("[bold]4. Mount Points Check[/]")
-        all_paths = config.get("paths", {}).copy()
-        all_paths.update(config.get("app_data_paths", {}))
+        paths = config.get("paths", {})
+        app_data_paths = config.get("app_data_paths", {})
 
-        if all_paths:
+        if paths or app_data_paths:
             if not _qga_ping(vm_name, conn_uri):
                 console.print("[yellow]⚠️  QEMU guest agent not connected - cannot verify mounts[/]")
             else:
-                for idx, (host_path, guest_path) in enumerate(all_paths.items()):
+                # Check bind mounts
+                for idx, (host_path, guest_path) in enumerate(paths.items()):
                     try:
                         # Use the same QGA helper as diagnose/status
                         is_accessible = _qga_exec(
                             vm_name, conn_uri, f"test -d {guest_path} && echo yes || echo no", timeout=5
                         )
                         if is_accessible == "yes":
-                            console.print(f"[green]✅ {guest_path}[/]")
+                            console.print(f"[green]✅ {guest_path} (mount)[/]")
+                        else:
+                            console.print(f"[red]❌ {guest_path} (mount inaccessible)[/]")
+                    except Exception:
+                        console.print(f"[yellow]⚠️  {guest_path} (could not check)[/]")
+                
+                # Check copied paths
+                for idx, (host_path, guest_path) in enumerate(app_data_paths.items()):
+                    try:
+                        is_accessible = _qga_exec(
+                            vm_name, conn_uri, f"test -d {guest_path} && echo yes || echo no", timeout=5
+                        )
+                        if is_accessible == "yes":
+                            console.print(f"[green]✅ {guest_path} (copied)[/]")
                         else:
-                            console.print(f"[red]❌ {guest_path} (not accessible)[/]")
+                            console.print(f"[red]❌ {guest_path} (copy missing)[/]")
                     except Exception:
                         console.print(f"[yellow]⚠️  {guest_path} (could not check)[/]")
         else:
@@ -2521,14 +2535,22 @@ def cmd_clone(args):
             console.print("  [cyan]clonebox-health[/]  # Re-run health check")
 
             # Show mount instructions
-            all_paths = config.get("paths", {}).copy()
-            all_paths.update(config.get("app_data_paths", {}))
-            if all_paths:
-                console.print("\n[bold]📁 Mounted paths (automatic):[/]")
-                for idx, (host, guest) in enumerate(list(all_paths.items())[:5]):
+            paths = config.get("paths", {})
+            app_data_paths = config.get("app_data_paths", {})
+
+            if paths:
+                console.print("\n[bold]📁 Mounted paths (shared live):[/]")
+                for idx, (host, guest) in enumerate(list(paths.items())[:5]):
+                    console.print(f"  [dim]{host}[/] → [cyan]{guest}[/]")
+                if len(paths) > 5:
+                    console.print(f"  [dim]... and {len(paths) - 5} more paths[/]")
+
+            if app_data_paths:
+                console.print("\n[bold]📥 Copied paths (one-time import):[/]")
+                for idx, (host, guest) in enumerate(list(app_data_paths.items())[:5]):
                     console.print(f"  [dim]{host}[/] → [cyan]{guest}[/]")
-                if len(all_paths) > 5:
-                    console.print(f"  [dim]... and {len(all_paths) - 5} more paths[/]")
+                if len(app_data_paths) > 5:
+                    console.print(f"  [dim]... and {len(app_data_paths) - 5} more paths[/]")
         except PermissionError as e:
             console.print(f"[red]❌ Permission Error:[/]\n{e}")
             console.print("\n[yellow]💡 Try running with --user flag:[/]")

{clonebox-1.1.10 → clonebox-1.1.12}/src/clonebox/cloner.py

@@ -92,6 +92,7 @@ class VMConfig:
     snap_packages: list = field(default_factory=list)  # Snap packages to install
     services: list = field(default_factory=list)
     post_commands: list = field(default_factory=list)  # Commands to run after setup
+    copy_paths: dict = field(default_factory=dict)  # Paths to copy (import) instead of bind-mount
     user_session: bool = field(
         default_factory=lambda: os.getenv("VM_USER_SESSION", "false").lower() == "true"
     )  # Use qemu:///session instead of qemu:///system
@@ -183,7 +184,13 @@ class SelectiveVMCloner:
             )
 
         try:
-            self.conn = libvirt.open(self.conn_uri)
+            # Use openAuth to avoid blocking on graphical auth dialogs (polkit)
+            # This is more robust for CLI usage
+            def auth_cb(creds, opaque):
+                return 0
+
+            auth = [[libvirt.VIR_CRED_AUTHNAME, libvirt.VIR_CRED_NOECHOPROMPT], auth_cb, None]
+            self.conn = libvirt.openAuth(self.conn_uri, auth, 0)
         except libvirt.libvirtError as e:
             raise ConnectionError(
                 f"Cannot connect to {self.conn_uri}\n"
@@ -523,7 +530,8 @@ class SelectiveVMCloner:
             pass
 
         # CPU tuning element
-        if limits.cpu.shares or limits.cpu.quota or limits.cpu.pin:
+        # Only available in system session (requires cgroups)
+        if not self.user_session and (limits.cpu.shares or limits.cpu.quota or limits.cpu.pin):
             cputune = ET.SubElement(root, "cputune")
             ET.SubElement(cputune, "shares").text = str(limits.cpu.shares)
             if limits.cpu.quota:
@@ -534,7 +542,8 @@ class SelectiveVMCloner:
                     ET.SubElement(cputune, "vcpupin", vcpu=str(idx), cpuset=str(cpu))
 
         # Memory tuning element
-        if limits.memory.soft_limit or limits.memory.swap:
+        # Only available in system session (requires cgroups)
+        if not self.user_session and (limits.memory.soft_limit or limits.memory.swap):
             memtune = ET.SubElement(root, "memtune")
             ET.SubElement(memtune, "hard_limit", unit="KiB").text = str(limit_kib)
             if limits.memory.soft_limit_bytes:
@@ -558,7 +567,8 @@ class SelectiveVMCloner:
         ET.SubElement(disk, "target", dev="vda", bus="virtio")
         
         # Disk I/O tuning
-        if limits.disk.read_bps or limits.disk.write_bps or limits.disk.read_iops or limits.disk.write_iops:
+        # Only available in system session (requires cgroups)
+        if not self.user_session and (limits.disk.read_bps or limits.disk.write_bps or limits.disk.read_iops or limits.disk.write_iops):
             iotune = ET.SubElement(disk, "iotune")
             if limits.disk.read_bps_bytes:
                 ET.SubElement(iotune, "read_bytes_sec").text = str(limits.disk.read_bps_bytes)
@@ -588,6 +598,16 @@ class SelectiveVMCloner:
                 tag = f"mount{idx}"
                 ET.SubElement(fs, "target", dir=tag)
 
+        # 9p filesystem mounts for COPY paths (mounted to temp location for import)
+        for idx, (host_path, guest_path) in enumerate(config.copy_paths.items()):
+            if Path(host_path).exists():
+                fs = ET.SubElement(devices, "filesystem", type="mount", accessmode="mapped")
+                ET.SubElement(fs, "driver", type="path", wrpolicy="immediate")
+                ET.SubElement(fs, "source", dir=host_path)
+                # Use import tag names for copy mounts
+                tag = f"import{idx}"
+                ET.SubElement(fs, "target", dir=tag)
+
         # Network interface
         network_mode = self.resolve_network_mode(config)
         if network_mode == "user":
@@ -655,7 +675,8 @@ class SelectiveVMCloner:
         import base64
 
         wants_google_chrome = any(
-            p == "/home/ubuntu/.config/google-chrome" for p in (config.paths or {}).values()
+            p == "/home/ubuntu/.config/google-chrome"
+            for p in list((config.paths or {}).values()) + list((config.copy_paths or {}).values())
         )
 
         apt_pkg_list = list(config.packages or [])
@@ -1298,6 +1319,40 @@ fi
                 # Add fstab entry for persistence after reboot
                 fstab_entries.append(f"{tag} {guest_path} 9p {mount_opts},nofail 0 0")
 
+        # Handle copy_paths (import then copy)
+        all_copy_paths = dict(config.copy_paths) if config.copy_paths else {}
+        for idx, (host_path, guest_path) in enumerate(all_copy_paths.items()):
+            if Path(host_path).exists():
+                tag = f"import{idx}"
+                temp_mount_point = f"/mnt/import{idx}"
+                # Use regular mount options
+                mount_opts = "trans=virtio,version=9p2000.L,mmap,uid=1000,gid=1000"
+
+                # 1. Create temp mount point
+                mount_commands.append(f"  - mkdir -p {temp_mount_point}")
+                
+                # 2. Mount the 9p share
+                mount_commands.append(f"  - mount -t 9p -o {mount_opts} {tag} {temp_mount_point} || true")
+                
+                # 3. Ensure target directory exists and permissions are prepared
+                if str(guest_path).startswith("/home/ubuntu/"):
+                    mount_commands.append(f"  - mkdir -p {guest_path}")
+                    mount_commands.append(f"  - chown 1000:1000 {guest_path}")
+                else:
+                    mount_commands.append(f"  - mkdir -p {guest_path}")
+
+                # 4. Copy contents (cp -rT to copy contents of source to target)
+                # We use || true to ensure boot continues even if copy fails
+                mount_commands.append(f"  - echo 'Importing {host_path} to {guest_path}...'")
+                mount_commands.append(f"  - cp -rT {temp_mount_point} {guest_path} || true")
+                
+                # 5. Fix ownership recursively
+                mount_commands.append(f"  - chown -R 1000:1000 {guest_path}")
+
+                # 6. Unmount and cleanup
+                mount_commands.append(f"  - umount {temp_mount_point} || true")
+                mount_commands.append(f"  - rmdir {temp_mount_point} || true")
+
         # User-data
         # Add desktop environment if GUI is enabled
         base_packages = ["qemu-guest-agent", "cloud-guest-utils"]
@@ -1876,8 +1931,14 @@ esac
                             }
                         )
 
-            # Check for google-chrome from app_data_paths
-            for host_path, guest_path in (config.paths or {}).items():
+            # Check for google-chrome from app_data_paths (now in copy_paths or paths)
+            all_paths_to_check = {}
+            if config.paths:
+                all_paths_to_check.update(config.paths)
+            if config.copy_paths:
+                all_paths_to_check.update(config.copy_paths)
+
+            for host_path, guest_path in all_paths_to_check.items():
                 if guest_path == "/home/ubuntu/.config/google-chrome":
                     autostart_apps.append(
                         {
@@ -2330,7 +2391,31 @@ final_message: "CloneBox VM is ready after $UPTIME seconds"
             vm.destroy()
         else:
             log(f"[cyan]🛑 Shutting down VM '{vm_name}'...[/]")
-            vm.shutdown()
+            try:
+                vm.shutdown()
+            except libvirt.libvirtError as e:
+                log(f"[red]❌ Failed to request shutdown: {e}[/]")
+                return False
+
+            # Wait for shutdown
+            import time
+            waiting = True
+            for i in range(30):
+                try:
+                    if not vm.isActive():
+                        waiting = False
+                        break
+                except libvirt.libvirtError:
+                    # Domain might be gone
+                    waiting = False
+                    break
+                time.sleep(1)
+            
+            if waiting:
+                log(f"[red]❌ Shutdown timed out. VM is still running.[/]")
+                log(f"[dim]The guest OS is not responding to ACPI shutdown signal.[/]")
+                log(f"[dim]Try using: clonebox stop {vm_name} --force[/]")
+                return False
 
         log("[green]✅ VM stopped![/]")
         return True

{clonebox-1.1.10 → clonebox-1.1.12}/src/clonebox/di.py

@@ -34,7 +34,7 @@ class DependencyContainer:
 
     def __init__(self):
         self._registrations: Dict[Type, ServiceRegistration] = {}
-        self._lock = threading.Lock()
+        self._lock = threading.RLock()
 
     def register(
         self,

{clonebox-1.1.10 → clonebox-1.1.12}/src/clonebox/models.py

@@ -116,10 +116,6 @@ class CloneBoxConfig(BaseModel):
         """Convert to legacy VMConfig dataclass for compatibility."""
         from clonebox.cloner import VMConfig as VMConfigDataclass
 
-        # Merge paths and app_data_paths
-        all_paths = dict(self.paths)
-        all_paths.update(self.app_data_paths)
-
         return VMConfigDataclass(
             name=self.vm.name,
             ram_mb=self.vm.ram_mb,
@@ -127,7 +123,8 @@ class CloneBoxConfig(BaseModel):
             disk_size_gb=self.vm.disk_size_gb,
             gui=self.vm.gui,
             base_image=self.vm.base_image,
-            paths=all_paths,
+            paths=self.paths,
+            copy_paths=self.app_data_paths,  # Map app_data_paths to copy_paths
             packages=self.packages,
             snap_packages=self.snap_packages,
             services=self.services,

{clonebox-1.1.10 → clonebox-1.1.12}/src/clonebox/validator.py

@@ -106,14 +106,14 @@ class VMValidator:
             return None
 
     def validate_mounts(self) -> Dict:
-        """Validate all mount points are accessible and contain data."""
-        self.console.print("\n[bold]💾 Validating Mount Points...[/]")
+        """Validate all mount points and copied data paths."""
+        self.console.print("\n[bold]💾 Validating Mounts & Data...[/]")
 
-        all_paths = self.config.get("paths", {}).copy()
-        all_paths.update(self.config.get("app_data_paths", {}))
+        paths = self.config.get("paths", {})
+        app_data_paths = self.config.get("app_data_paths", {})
 
-        if not all_paths:
-            self.console.print("[dim]No mount points configured[/]")
+        if not paths and not app_data_paths:
+            self.console.print("[dim]No mounts or data paths configured[/]")
             return self.results["mounts"]
 
         # Get mounted filesystems
@@ -122,64 +122,95 @@ class VMValidator:
         if mount_output:
             mounted_paths = [line.split()[2] for line in mount_output.split("\n") if line.strip()]
 
-        mount_table = Table(title="Mount Validation", border_style="cyan")
+        mount_table = Table(title="Data Validation", border_style="cyan")
         mount_table.add_column("Guest Path", style="bold")
-        mount_table.add_column("Mounted", justify="center")
-        mount_table.add_column("Accessible", justify="center")
+        mount_table.add_column("Type", justify="center")
+        mount_table.add_column("Status", justify="center")
         mount_table.add_column("Files", justify="right")
 
-        for host_path, guest_path in all_paths.items():
+        # Validate bind mounts (paths)
+        for host_path, guest_path in paths.items():
             self.results["mounts"]["total"] += 1
-
+            
             # Check if mounted
             is_mounted = any(guest_path in mp for mp in mounted_paths)
-
+            
             # Check if accessible
             accessible = False
             file_count = "?"
-
+            
             if is_mounted:
                 test_result = self._exec_in_vm(f"test -d {guest_path} && echo 'yes' || echo 'no'")
                 accessible = test_result == "yes"
-
+                
                 if accessible:
-                    # Get file count
                     count_str = self._exec_in_vm(f"ls -A {guest_path} 2>/dev/null | wc -l")
                     if count_str and count_str.isdigit():
                         file_count = count_str
 
-            # Determine status
             if is_mounted and accessible:
-                mount_status = "[green]✅[/]"
-                access_status = "[green]✅[/]"
+                status_icon = "[green]✅ Mounted[/]"
                 self.results["mounts"]["passed"] += 1
                 status = "pass"
             elif is_mounted:
-                mount_status = "[green]✅[/]"
-                access_status = "[red]❌[/]"
+                status_icon = "[red]❌ Inaccessible[/]"
                 self.results["mounts"]["failed"] += 1
                 status = "mounted_but_inaccessible"
             else:
-                mount_status = "[red]❌[/]"
-                access_status = "[dim]N/A[/]"
+                status_icon = "[red]❌ Not Mounted[/]"
                 self.results["mounts"]["failed"] += 1
                 status = "not_mounted"
 
-            mount_table.add_row(guest_path, mount_status, access_status, str(file_count))
-
-            self.results["mounts"]["details"].append(
-                {
-                    "path": guest_path,
-                    "mounted": is_mounted,
-                    "accessible": accessible,
-                    "files": file_count,
-                    "status": status,
-                }
-            )
+            mount_table.add_row(guest_path, "Bind Mount", status_icon, str(file_count))
+            self.results["mounts"]["details"].append({
+                "path": guest_path,
+                "type": "mount",
+                "mounted": is_mounted,
+                "accessible": accessible,
+                "files": file_count,
+                "status": status
+            })
+
+        # Validate copied paths (app_data_paths)
+        for host_path, guest_path in app_data_paths.items():
+            self.results["mounts"]["total"] += 1
+            
+            # Check if exists and has content
+            exists = False
+            file_count = "?"
+            
+            test_result = self._exec_in_vm(f"test -d {guest_path} && echo 'yes' || echo 'no'")
+            exists = test_result == "yes"
+            
+            if exists:
+                count_str = self._exec_in_vm(f"ls -A {guest_path} 2>/dev/null | wc -l")
+                if count_str and count_str.isdigit():
+                    file_count = count_str
+
+            # For copied paths, we just check existence and content
+            if exists:
+                # Warning if empty? Maybe, but strictly it passed existence check
+                status_icon = "[green]✅ Copied[/]"
+                self.results["mounts"]["passed"] += 1
+                status = "pass"
+            else:
+                status_icon = "[red]❌ Missing[/]"
+                self.results["mounts"]["failed"] += 1
+                status = "missing"
+
+            mount_table.add_row(guest_path, "Imported", status_icon, str(file_count))
+            self.results["mounts"]["details"].append({
+                "path": guest_path,
+                "type": "copy",
+                "mounted": False, # Expected false for copies
+                "accessible": exists,
+                "files": file_count,
+                "status": status
+            })
 
         self.console.print(mount_table)
         self.console.print(
-            f"[dim]{self.results['mounts']['passed']}/{self.results['mounts']['total']} mounts working[/]"
+            f"[dim]{self.results['mounts']['passed']}/{self.results['mounts']['total']} paths valid[/]"
         )
 
         return self.results["mounts"]

{clonebox-1.1.10 → clonebox-1.1.12/src/clonebox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 1.1.10
+Version: 1.1.12
 Summary: Clone your workstation environment to an isolated VM with selective apps, paths and services
 Author: CloneBox Team
 License: Apache-2.0

{clonebox-1.1.10 → clonebox-1.1.12}/tests/test_cloner.py

@@ -72,12 +72,14 @@ class TestSelectiveVMClonerInit:
     @patch("clonebox.cloner.libvirt")
     def test_system_images_dir(self, mock_libvirt):
         mock_libvirt.open.return_value = MagicMock()
+        mock_libvirt.openAuth.return_value = MagicMock()
         cloner = SelectiveVMCloner()
         assert cloner.SYSTEM_IMAGES_DIR == Path("/var/lib/libvirt/images")
 
     @patch("clonebox.cloner.libvirt")
     def test_user_images_dir(self, mock_libvirt):
         mock_libvirt.open.return_value = MagicMock()
+        mock_libvirt.openAuth.return_value = MagicMock()
         cloner = SelectiveVMCloner()
         expected = Path.home() / ".local/share/libvirt/images"
         assert cloner.USER_IMAGES_DIR == expected
@@ -93,17 +95,22 @@ class TestSelectiveVMClonerInit:
     def test_init_session_type(self, mock_libvirt, user_session, expected_uri):
         mock_conn = MagicMock()
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner(user_session=user_session)
 
         assert cloner.conn_uri == expected_uri
         assert cloner.user_session is user_session
-        mock_libvirt.open.assert_called_with(expected_uri)
+        
+        # Verify openAuth was called with expected URI
+        args, _ = mock_libvirt.openAuth.call_args
+        assert args[0] == expected_uri
 
     @patch("clonebox.cloner.libvirt")
     def test_init_custom_uri(self, mock_libvirt):
         mock_conn = MagicMock()
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner(conn_uri="qemu+ssh://host/system")
 
@@ -122,6 +129,7 @@ class TestSelectiveVMClonerInit:
 
             mock_libvirt.libvirtError = real_libvirt.libvirtError
             mock_libvirt.open.side_effect = real_libvirt.libvirtError("Connection refused")
+            mock_libvirt.openAuth.side_effect = real_libvirt.libvirtError("Connection refused")
         except ImportError:
             # If libvirt is not installed, create a mock exception
             class MockLibvirtError(Exception):
@@ -129,6 +137,7 @@ class TestSelectiveVMClonerInit:
 
             mock_libvirt.libvirtError = MockLibvirtError
             mock_libvirt.open.side_effect = MockLibvirtError("Connection refused")
+            mock_libvirt.openAuth.side_effect = MockLibvirtError("Connection refused")
 
         with pytest.raises(ConnectionError) as exc_info:
             SelectiveVMCloner()
@@ -149,6 +158,7 @@ class TestSelectiveVMClonerMethods:
     @patch("clonebox.cloner.libvirt")
     def test_get_images_dir(self, mock_libvirt, user_session, expected_path):
         mock_libvirt.open.return_value = MagicMock()
+        mock_libvirt.openAuth.return_value = MagicMock()
 
         cloner = SelectiveVMCloner(user_session=user_session)
         assert cloner.get_images_dir() == expected_path
@@ -159,6 +169,7 @@ class TestSelectiveVMClonerMethods:
         mock_conn.isAlive.return_value = True
         mock_conn.networkLookupByName.return_value.isActive.return_value = 1
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner(user_session=True)  # Use user session to avoid permission issues
         checks = cloner.check_prerequisites()
@@ -182,6 +193,7 @@ class TestSelectiveVMClonerMethods:
         mock_conn = MagicMock()
         mock_conn.isAlive.return_value = True
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner(user_session=user_session)
         assert cloner.check_prerequisites()["session_type"] == expected_type
@@ -203,6 +215,7 @@ class TestSelectiveVMClonerMethods:
         mock_conn.lookupByID.return_value = running_vm
         mock_conn.lookupByName.return_value = stopped_vm
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner()
         vms = cloner.list_vms()
@@ -217,6 +230,7 @@ class TestSelectiveVMClonerMethods:
     def test_close(self, mock_libvirt):
         mock_conn = MagicMock()
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner()
         cloner.close()
@@ -230,6 +244,7 @@ class TestVMXMLGeneration:
     @patch("clonebox.cloner.libvirt")
     def test_generate_vm_xml_basic(self, mock_libvirt):
         mock_libvirt.open.return_value = MagicMock()
+        mock_libvirt.openAuth.return_value = MagicMock()
 
         cloner = SelectiveVMCloner()
         config = VMConfig(name="test-vm", ram_mb=2048, vcpus=2)
@@ -245,6 +260,7 @@ class TestVMXMLGeneration:
     @patch("clonebox.cloner.libvirt")
     def test_generate_vm_xml_with_paths(self, mock_libvirt):
         mock_libvirt.open.return_value = MagicMock()
+        mock_libvirt.openAuth.return_value = MagicMock()
 
         cloner = SelectiveVMCloner()
         config = VMConfig(name="test-vm", paths={"/home/user/project": "/mnt/project"})
@@ -256,6 +272,40 @@ class TestVMXMLGeneration:
         assert "filesystem" in xml
         assert "mount" in xml
 
+    @patch("clonebox.cloner.libvirt")
+    def test_generate_vm_xml_tuning_exclusion(self, mock_libvirt):
+        """Test that resource tuning elements are excluded in user session mode."""
+        mock_libvirt.open.return_value = MagicMock()
+        mock_libvirt.openAuth.return_value = MagicMock()
+
+        # 1. Test User Session (Should exclude tuning)
+        cloner_user = SelectiveVMCloner(user_session=True)
+        config = VMConfig(
+            name="test-vm",
+            ram_mb=2048,
+            vcpus=2,
+            resources={
+                "cpu": {"shares": 1024, "quota": 10000},
+                "memory": {"soft_limit": "1G"},
+                "disk": {"read_bps": "10M"},
+            }
+        )
+        
+        xml_user = cloner_user._generate_vm_xml(config, Path("/tmp/root.qcow2"), None)
+        
+        assert "cputune" not in xml_user
+        assert "memtune" not in xml_user
+        assert "iotune" not in xml_user
+
+        # 2. Test System Session (Should include tuning)
+        cloner_system = SelectiveVMCloner(user_session=False)
+        
+        xml_system = cloner_system._generate_vm_xml(config, Path("/tmp/root.qcow2"), None)
+        
+        assert "cputune" in xml_system
+        assert "memtune" in xml_system
+        assert "iotune" in xml_system
+
 
 class TestVMCreation:
     """Test VM creation (with mocked libvirt)."""
@@ -266,6 +316,7 @@ class TestVMCreation:
         mock_conn = MagicMock()
         mock_conn.lookupByName.side_effect = Exception("not found")
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner()
         config = VMConfig(name="test-vm")

{clonebox-1.1.10 → clonebox-1.1.12}/tests/test_coverage_boost_final.py

@@ -137,6 +137,7 @@ def test_cloner_additional_branches():
     with patch("clonebox.cloner.libvirt") as mock_libvirt:
         mock_conn = Mock()
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
         cloner = SelectiveVMCloner()
 
         # Cover _get_downloads_dir
@@ -164,6 +165,7 @@ def test_cloner_create_vm_branches():
     with patch("clonebox.cloner.libvirt") as mock_libvirt:
         mock_conn = Mock()
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
         cloner = SelectiveVMCloner()
 
         config = VMConfig(name="test-vm", packages=["vim"])
@@ -299,6 +301,7 @@ def test_cloner_cloudinit_generation():
     with patch("clonebox.cloner.libvirt") as mock_libvirt:
         mock_conn = Mock()
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
         cloner = SelectiveVMCloner()
 
         config = VMConfig(
@@ -332,6 +335,7 @@ def test_cloner_delete_vm_branches():
     with patch("clonebox.cloner.libvirt") as mock_libvirt:
         mock_conn = Mock()
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
         cloner = SelectiveVMCloner()
 
         mock_vm = Mock()

{clonebox-1.1.10 → clonebox-1.1.12}/tests/test_network.py

@@ -40,6 +40,7 @@ class TestNetworkMode:
         """Test auto mode with system session uses default network."""
         mock_conn = MagicMock()
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner(user_session=False)
         config = VMConfig(network_mode="auto")
@@ -51,6 +52,8 @@ class TestNetworkMode:
     def test_resolve_network_mode_auto_user_with_default(self, mock_libvirt):
         """Test auto mode with user session and default network available."""
         mock_conn = MagicMock()
+        mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
         mock_net = MagicMock()
         mock_net.isActive.return_value = 1
         mock_conn.networkLookupByName.return_value = mock_net
@@ -78,6 +81,7 @@ class TestNetworkMode:
         mock_conn = MagicMock()
         mock_conn.networkLookupByName.side_effect = libvirt_error("No network")
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner(user_session=True)
         config = VMConfig(network_mode="auto")
@@ -90,6 +94,7 @@ class TestNetworkMode:
         """Test explicit default mode."""
         mock_conn = MagicMock()
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner(user_session=True)
         config = VMConfig(network_mode="default")
@@ -102,6 +107,7 @@ class TestNetworkMode:
         """Test explicit user mode."""
         mock_conn = MagicMock()
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner(user_session=False)
         config = VMConfig(network_mode="user")
@@ -114,6 +120,7 @@ class TestNetworkMode:
         """Test invalid network mode falls back to default."""
         mock_conn = MagicMock()
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner()
         config = VMConfig(network_mode="invalid")
@@ -125,6 +132,8 @@ class TestNetworkMode:
     def test_default_network_active_true(self, mock_libvirt):
         """Test _default_network_active returns True when network is active."""
         mock_conn = MagicMock()
+        mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
         mock_net = MagicMock()
         mock_net.isActive.return_value = 1
         mock_conn.networkLookupByName.return_value = mock_net
@@ -138,6 +147,8 @@ class TestNetworkMode:
         """Test _default_network_active returns False when network is inactive."""
 
         mock_conn = MagicMock()
+        mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
         mock_net = MagicMock()
         mock_net.isActive.return_value = 0
         mock_conn.networkLookupByName.return_value = mock_net
@@ -162,6 +173,7 @@ class TestNetworkMode:
         mock_conn = MagicMock()
         mock_conn.networkLookupByName.side_effect = libvirt_error("Not found")
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner()
         assert cloner._default_network_active() is False
@@ -171,6 +183,7 @@ class TestNetworkMode:
         """Test VM XML generation with user network."""
         mock_conn = MagicMock()
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner()
         config = VMConfig(name="test-vm", network_mode="user")
@@ -185,6 +198,7 @@ class TestNetworkMode:
         """Test VM XML generation with default network."""
         mock_conn = MagicMock()
         mock_libvirt.open.return_value = mock_conn
+        mock_libvirt.openAuth.return_value = mock_conn
 
         cloner = SelectiveVMCloner()
         config = VMConfig(name="test-vm", network_mode="default")