clonebox 1.1.9__tar.gz → 1.1.11__tar.gz

{clonebox-1.1.9/src/clonebox.egg-info → clonebox-1.1.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 1.1.9
+Version: 1.1.11
 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.9 → clonebox-1.1.11}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "clonebox"
-version = "1.1.9"
+version = "1.1.11"
 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.9 → clonebox-1.1.11}/src/clonebox/cli.py

@@ -2724,20 +2724,69 @@ def cmd_monitor(args) -> None:
 def cmd_exec(args) -> None:
     """Execute command in VM via QEMU Guest Agent."""
     vm_name, config_file = _resolve_vm_name_and_config_file(args.name)
-    conn_uri = "qemu:///session" if getattr(args, "user", False) else "qemu:///system"
-    command = args.command
-    if isinstance(command, list):
-        command = " ".join(command).strip()
+    user_session = getattr(args, "user", False)
+    timeout = getattr(args, "timeout", 30)
+
+    # When using argparse.REMAINDER for `command`, any flags placed after the VM name
+    # may end up inside args.command. Recover common exec flags from the remainder.
+    command_tokens = args.command
+    if not isinstance(command_tokens, list):
+        command_tokens = [str(command_tokens)] if command_tokens is not None else []
+
+    if "--" in command_tokens:
+        sep_idx = command_tokens.index("--")
+        pre_tokens = command_tokens[:sep_idx]
+        post_tokens = command_tokens[sep_idx + 1 :]
+    else:
+        pre_tokens = command_tokens
+        post_tokens = []
+
+    i = 0
+    while i < len(pre_tokens):
+        tok = pre_tokens[i]
+        if tok in ("-u", "--user"):
+            user_session = True
+            i += 1
+            continue
+        if tok in ("-t", "--timeout"):
+            if i + 1 < len(pre_tokens):
+                try:
+                    timeout = int(pre_tokens[i + 1])
+                except ValueError:
+                    pass
+                i += 2
+                continue
+        break
+
+    remaining_pre = pre_tokens[i:]
+    if post_tokens:
+        command_tokens = remaining_pre + post_tokens
+    else:
+        command_tokens = remaining_pre
+
+    command = " ".join(command_tokens).strip()
     if not command:
         console.print("[red]❌ No command specified[/]")
         return
-    timeout = getattr(args, "timeout", 30)
+
+    conn_uri = "qemu:///session" if user_session else "qemu:///system"
+    other_conn_uri = "qemu:///system" if conn_uri == "qemu:///session" else "qemu:///session"
 
     qga_ready = _qga_ping(vm_name, conn_uri)
+    if not qga_ready:
+        alt_ready = _qga_ping(vm_name, other_conn_uri)
+        if alt_ready:
+            conn_uri = other_conn_uri
+            qga_ready = True
     if not qga_ready:
         for _ in range(12):  # ~60s
             time.sleep(5)
             qga_ready = _qga_ping(vm_name, conn_uri)
+            if not qga_ready:
+                alt_ready = _qga_ping(vm_name, other_conn_uri)
+                if alt_ready:
+                    conn_uri = other_conn_uri
+                    qga_ready = True
             if qga_ready:
                 break
 

{clonebox-1.1.9 → clonebox-1.1.11}/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 [])
@@ -1267,29 +1288,71 @@ fi
         pre_chown_dirs: set[str] = set()
         for idx, (host_path, guest_path) in enumerate(all_paths.items()):
             if Path(host_path).exists():
-                if str(guest_path).startswith("/home/ubuntu/snap/"):
-                    guest_parts = Path(guest_path).parts
-                    if len(guest_parts) > 4:
-                        snap_name = guest_parts[4]
-                        for d in (
-                            "/home/ubuntu",
-                            "/home/ubuntu/snap",
-                            f"/home/ubuntu/snap/{snap_name}",
-                        ):
-                            if d not in pre_chown_dirs:
-                                pre_chown_dirs.add(d)
-                                mount_commands.append(f"  - mkdir -p {d}")
-                                mount_commands.append(f"  - chown 1000:1000 {d}")
+                # Ensure all parent directories in /home/ubuntu are owned by user
+                # This prevents "Permission denied" when creating config dirs (e.g. .config) as root
+                if str(guest_path).startswith("/home/ubuntu/"):
+                    try:
+                        rel_path = Path(guest_path).relative_to("/home/ubuntu")
+                        current = Path("/home/ubuntu")
+                        # Create and chown each component in the path
+                        for part in rel_path.parts:
+                            current = current / part
+                            d_str = str(current)
+                            if d_str not in pre_chown_dirs:
+                                pre_chown_dirs.add(d_str)
+                                mount_commands.append(f"  - mkdir -p {d_str}")
+                                mount_commands.append(f"  - chown 1000:1000 {d_str}")
+                    except ValueError:
+                        pass
+
                 tag = f"mount{idx}"
                 # Use uid=1000,gid=1000 to give ubuntu user access to mounts
                 # mmap allows proper file mapping
                 mount_opts = "trans=virtio,version=9p2000.L,mmap,uid=1000,gid=1000,users"
-                mount_commands.append(f"  - mkdir -p {guest_path}")
-                mount_commands.append(f"  - chown 1000:1000 {guest_path}")
+                
+                # Ensure target exists and is owned by user (if not already handled)
+                if str(guest_path) not in pre_chown_dirs:
+                    mount_commands.append(f"  - mkdir -p {guest_path}")
+                    mount_commands.append(f"  - chown 1000:1000 {guest_path}")
+
                 mount_commands.append(f"  - mount -t 9p -o {mount_opts} {tag} {guest_path} || true")
                 # 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"]
@@ -1330,16 +1393,37 @@ fi
         for cmd in mount_commands:
             runcmd_lines.append(cmd)
 
+        # Create user directories with correct permissions EARLY to avoid race conditions with GDM
+        if config.gui:
+            # Create directories that GNOME services need
+            runcmd_lines.extend(
+                [
+                    "  - mkdir -p /home/ubuntu/.config/pulse /home/ubuntu/.cache/ibus /home/ubuntu/.local/share",
+                    "  - mkdir -p /home/ubuntu/.config/dconf /home/ubuntu/.cache/tracker3",
+                    "  - mkdir -p /home/ubuntu/.config/autostart",
+                    "  - chown -R 1000:1000 /home/ubuntu/.config /home/ubuntu/.cache /home/ubuntu/.local",
+                    "  - chmod 700 /home/ubuntu/.config /home/ubuntu/.cache",
+                    "  - systemctl set-default graphical.target",
+                    "  - systemctl enable gdm3 || systemctl enable gdm || true",
+                ]
+            )
+
         runcmd_lines.append("  - chown -R 1000:1000 /home/ubuntu || true")
         runcmd_lines.append("  - chown -R 1000:1000 /home/ubuntu/snap || true")
 
-        # Install snap packages
+        # Install snap packages (with retry logic)
         if config.snap_packages:
             runcmd_lines.append("  - echo 'Installing snap packages...'")
             for snap_pkg in config.snap_packages:
-                runcmd_lines.append(
-                    f"  - snap install {snap_pkg} --classic || snap install {snap_pkg} || true"
+                # Try classic first, then strict, with retries
+                cmd = (
+                    f"for i in 1 2 3; do "
+                    f"snap install {snap_pkg} --classic && break || "
+                    f"snap install {snap_pkg} && break || "
+                    f"sleep 10; "
+                    f"done"
                 )
+                runcmd_lines.append(f"  - {cmd}")
 
             # Connect snap interfaces for GUI apps (not auto-connected via cloud-init)
             runcmd_lines.append("  - echo 'Connecting snap interfaces...'")
@@ -1352,22 +1436,8 @@ fi
 
             runcmd_lines.append("  - systemctl restart snapd || true")
 
-        # Add GUI setup if enabled - runs AFTER package installation completes
+        # Add remaining GUI setup if enabled
         if config.gui:
-            # Create directories that GNOME services need BEFORE GUI starts
-            # These may conflict with mounted host directories, so ensure they exist with correct perms
-            runcmd_lines.extend(
-                [
-                    "  - mkdir -p /home/ubuntu/.config/pulse /home/ubuntu/.cache/ibus /home/ubuntu/.local/share",
-                    "  - mkdir -p /home/ubuntu/.config/dconf /home/ubuntu/.cache/tracker3",
-                    "  - mkdir -p /home/ubuntu/.config/autostart",
-                    "  - chown -R 1000:1000 /home/ubuntu/.config /home/ubuntu/.cache /home/ubuntu/.local",
-                    "  - chmod 700 /home/ubuntu/.config /home/ubuntu/.cache",
-                    "  - systemctl set-default graphical.target",
-                    "  - systemctl enable gdm3 || systemctl enable gdm || true",
-                ]
-            )
-
             # Create autostart entries for GUI apps
             autostart_apps = {
                 "pycharm-community": (
@@ -1861,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(
                         {
@@ -2315,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.9 → clonebox-1.1.11}/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.9 → clonebox-1.1.11}/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.9 → clonebox-1.1.11}/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"]
@@ -897,6 +928,23 @@ class VMValidator:
             self.results["overall"] = "qga_not_ready"
             return self.results
 
+        ci_status = self._exec_in_vm("cloud-init status --long 2>/dev/null || cloud-init status 2>/dev/null || true", timeout=20)
+        if ci_status:
+            ci_lower = ci_status.lower()
+            if "running" in ci_lower:
+                self.console.print("[yellow]⏳ Cloud-init still running - skipping deep validation for now[/]")
+                self.results["overall"] = "cloud_init_running"
+                return self.results
+
+        ready_msg = self._exec_in_vm(
+            "cat /var/log/clonebox-ready 2>/dev/null || true",
+            timeout=10,
+        )
+        if not (ready_msg and "clonebox vm ready" in ready_msg.lower()):
+            self.console.print(
+                "[yellow]⚠️  CloneBox ready marker not found - provisioning may not have completed[/]"
+            )
+
         # Run all validations
         self.validate_mounts()
         self.validate_packages()

{clonebox-1.1.9 → clonebox-1.1.11/src/clonebox.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: clonebox
-Version: 1.1.9
+Version: 1.1.11
 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.9 → clonebox-1.1.11}/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"})
@@ -266,6 +282,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.9 → clonebox-1.1.11}/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.9 → clonebox-1.1.11}/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")