idrac 0.1.92 → 0.3.2

data/bin/idrac

@@ -23,6 +23,8 @@ module IDRAC
     class_option :no_ssl, type: :boolean, default: false, desc: "Disable SSL"
     class_option :verify_ssl, type: :boolean, default: false, desc: "Enable SSL verification (not recommended for iDRAC's self-signed certificates)"
     class_option :auto_delete_sessions, type: :boolean, default: true, desc: "Automatically delete sessions when maximum sessions are reached"
+    class_option :retries, type: :numeric, default: 3, desc: "Number of retries for API calls"
+    class_option :retry_delay, type: :numeric, default: 1, desc: "Initial delay in seconds between retries (increases exponentially)"
     class_option :verbose, type: :boolean, default: false, aliases: '-v', desc: "Enable verbose output"
     class_option :very_verbose, type: :boolean, default: false, aliases: '-vv', desc: "Enable very verbose output with detailed headers and requests"
     class_option :debug, type: :boolean, default: false, aliases: '-vvv', desc: "Enable debug output with detailed stack traces and SSL info"
@@ -454,6 +456,921 @@ module IDRAC
       end
     end
 
+    desc "test:all", "Run tests for all major functionality areas"
+    map "test" => :test_all
+    option :quiet, type: :boolean, default: false, desc: "Minimize output, just show pass/fail"
+    option :skip_destructive, type: :boolean, default: true, desc: "Skip tests that could modify the system"
+    def test_all
+      quiet = options[:quiet]
+      skip_destructive = options[:skip_destructive]
+      
+      passed = []
+      failed = []
+      skipped = []
+      
+      tests = [
+        # Basic information
+        { name: "System Summary", method: -> (c) { c.summary } },
+        { name: "Redfish Version", method: -> (c) { c.redfish_version } },
+        
+        # Power methods
+        { name: "Power State", method: -> (c) { c.get_power_state } },
+        { name: "Power Usage", method: -> (c) { c.get_power_usage_watts } },
+        
+        # Jobs and lifecycle
+        { name: "Jobs List", method: -> (c) { c.jobs } },
+        { name: "Lifecycle Status", method: -> (c) { c.lifecycle_status } },
+        
+        # Storage
+        { name: "Storage Controller", method: -> (c) { c.controller } },
+        { name: "Physical Drives", method: -> (c) { controller = c.controller; c.drives(controller) } },
+        { name: "Virtual Disks", method: -> (c) { controller = c.controller; c.volumes(controller) } },
+        
+        # System components
+        { name: "Memory Info", method: -> (c) { c.memory } },
+        { name: "PSU Info", method: -> (c) { c.psus } },
+        { name: "Fan Info", method: -> (c) { c.fans } },
+        { name: "NIC Info", method: -> (c) { c.nics } },
+        { name: "PCI Devices", method: -> (c) { c.pci_devices } },
+        { name: "iDRAC Network", method: -> (c) { c.idrac_network } },
+        { name: "System Events", method: -> (c) { c.system_event_logs } },
+        
+        # Virtual media
+        { name: "Virtual Media Status", method: -> (c) { c.virtual_media } },
+        { name: "Boot Source", method: -> (c) { c.get_boot_source_override } },
+        
+        # Boot/BIOS
+        { name: "Boot Options", method: -> (c) { c.get_bios_boot_options } }
+      ]
+      
+      # Destructive tests - only run if explicitly enabled
+      destructive_tests = [
+        # Virtual media operations
+        { name: "Eject Virtual Media", method: -> (c) { c.eject_virtual_media } },
+        
+        # BIOS settings check (read-only but could affect future operations)
+        { name: "BIOS OS Power Control", method: -> (c) { c.set_bios_os_power_control } },
+      ]
+      
+      puts "======= iDRAC Functionality Test =======" unless quiet
+      puts "Testing #{tests.length} non-destructive operations" unless quiet
+      
+      with_idrac_client do |client|
+        begin
+          # Get firmware version first to help with diagnostics
+          firmware = client.get_firmware_version
+          puts "iDRAC Firmware: #{firmware}" unless quiet
+          
+          # Run all the standard tests
+          tests.each do |test|
+            test_name = test[:name]
+            
+            begin
+              puts "\nTesting: #{test_name}..." unless quiet
+              result = test[:method].call(client)
+              
+              if result || result.nil? # nil is fine for commands that just print
+                passed << test_name
+                puts "✅ #{test_name} - PASSED" unless quiet
+              else
+                failed << test_name
+                puts "❌ #{test_name} - FAILED" unless quiet
+              end
+            rescue => e
+              failed << test_name
+              puts "❌ #{test_name} - ERROR: #{e.message}" unless quiet
+              puts e.backtrace.join("\n") if options[:verbose]
+            end
+          end
+          
+          # Run destructive tests if enabled
+          unless skip_destructive
+            puts "\nTesting #{destructive_tests.length} potentially destructive operations" unless quiet
+            
+            destructive_tests.each do |test|
+              test_name = test[:name]
+              
+              begin
+                puts "\nTesting: #{test_name}..." unless quiet
+                result = test[:method].call(client)
+                
+                if result || result.nil?
+                  passed << test_name
+                  puts "✅ #{test_name} - PASSED" unless quiet
+                else
+                  failed << test_name
+                  puts "❌ #{test_name} - FAILED" unless quiet
+                end
+              rescue => e
+                failed << test_name
+                puts "❌ #{test_name} - ERROR: #{e.message}" unless quiet
+                puts e.backtrace.join("\n") if options[:verbose]
+              end
+            end
+          else
+            skipped = destructive_tests.map { |t| t[:name] }
+            puts "\nSkipped #{skipped.length} destructive tests" unless quiet
+          end
+        rescue => e
+          puts "Failed to initialize client: #{e.message}".red
+          puts e.backtrace.join("\n") if options[:verbose]
+          exit 1
+        end
+      end
+      
+      # Print summary
+      puts "\n======= Test Summary =======" 
+      puts "✅ PASSED: #{passed.length} tests"
+      
+      if failed.any?
+        puts "❌ FAILED: #{failed.length} tests"
+        puts failed.map { |name| "  - #{name}" }.join("\n")
+      end
+      
+      if skipped.any?
+        puts "⏭ SKIPPED: #{skipped.length} tests"
+        puts skipped.map { |name| "  - #{name}" }.join("\n") unless quiet
+      end
+      
+      exit(failed.empty? ? 0 : 1)
+    end
+
+    # Storage commands
+    desc "storage_controller", "Get storage controller information"
+    map "storage:controller" => :storage_controller
+    def storage_controller
+      with_idrac_client do |client|
+        controller = client.controller
+        puts "\nStorage Controller Summary:".green.bold
+        puts "Name: #{controller['Name']}".cyan
+        puts "Model: #{controller['Model']}".cyan
+        puts "Health: #{controller['Status']['Health']}".cyan
+        puts "Manufacturer: #{controller['Manufacturer']}".cyan
+        
+        if client.controller_encryption_capable?(controller)
+          puts "Encryption Capable: Yes".green
+          puts "Encryption Enabled: #{client.controller_encryption_enabled?(controller) ? 'Yes'.green : 'No'.yellow}"
+        else
+          puts "Encryption Capable: No".yellow
+        end
+      end
+    end
+
+    desc "storage_controllers", "Get all storage controllers information"
+    map "storage:controllers" => :storage_controllers
+    def storage_controllers
+      with_idrac_client do |client|
+        controllers = client.controllers
+        
+        puts "\nStorage Controllers Summary:".green.bold
+        puts "-" * 80
+        
+        controllers.each do |controller|
+          puts "Controller: #{controller[:name]}".cyan.bold
+          puts "  Model:           #{controller[:model]}"
+          puts "  Status:          #{controller[:status]}"
+          puts "  Drives:          #{controller[:drives_count]}"
+          puts "  Firmware:        #{controller[:firmware_version]}"
+          puts "  Type:            #{controller[:controller_type]}"
+          puts "  PCI Slot:        #{controller[:pci_slot]}"
+          
+          if controller[:encryption_capability]
+            puts "  Encryption:      #{controller[:encryption_capability]}"
+            puts "  Encryption Mode: #{controller[:encryption_mode] || 'Disabled'}"
+          end
+          
+          puts
+        end
+        
+        puts "Total controllers: #{controllers.size}".green
+      end
+    end
+
+    desc "storage_drives", "Get physical drive information"
+    map "storage:drives" => :storage_drives
+    def storage_drives
+      with_idrac_client do |client|
+        controller = client.controller
+        drives = client.drives(controller)
+        
+        puts "\nPhysical Drives (#{drives.size}):".green.bold
+        drives.each do |drive|
+          capacity_gb = drive[:capacity_bytes].to_f / (1024**3)
+          health_color = drive[:health] == "OK" ? :green : :red
+          
+          puts "#{drive[:name]}:".bold
+          puts "  Model: #{drive[:model]}".cyan
+          puts "  Health: #{drive[:health].send(health_color)}"
+          puts "  Capacity: #{capacity_gb.round(2)} GB".cyan
+          puts "  Media Type: #{drive[:media_type]}".cyan
+          puts "  Serial: #{drive[:serial]}".cyan
+          if drive[:encryption_ability]
+            puts "  Encryption: #{drive[:encryption_ability]}".cyan
+          end
+          puts ""
+        end
+      end
+    end
+
+    desc "storage_volumes", "Get virtual disk information"
+    map "storage:volumes" => :storage_volumes
+    def storage_volumes
+      with_idrac_client do |client|
+        controller = client.controller
+        volumes = client.volumes(controller)
+        
+        puts "\nVirtual Disks (#{volumes.size}):".green.bold
+        volumes.each do |volume|
+          capacity_gb = volume[:capacity_bytes].to_f / (1024**3)
+          health_color = volume[:health] == "OK" ? :green : :yellow
+          
+          puts "#{volume[:name]}:".bold
+          puts "  RAID Type: #{volume[:raid_level] || volume[:volume_type]}".cyan
+          puts "  Health: #{volume[:health].send(health_color)}"
+          puts "  Capacity: #{capacity_gb.round(2)} GB".cyan
+          puts "  Stripe Size: #{volume[:stripe_size]}".cyan
+          puts "  Read Cache: #{volume[:read_cache_policy]}".cyan
+          puts "  Write Cache: #{volume[:write_cache_policy]}".cyan
+          puts "  FastPath: #{volume[:fastpath] == 'enabled' ? 'Enabled'.green : 'Disabled'.yellow}"
+          puts "  Encrypted: #{volume[:encrypted] ? 'Yes'.green : 'No'.yellow}" if volume[:encrypted] != nil
+          
+          if volume[:progress]
+            puts "  Progress: #{volume[:progress]}%".cyan
+            puts "  Operation: #{volume[:message]}".cyan
+          end
+          puts ""
+        end
+      end
+    end
+
+    desc "storage_create_volume", "Create a new virtual disk"
+    map "storage:create_volume" => :storage_create_volume
+    method_option :name, type: :string, default: "vssd0", desc: "Volume name"
+    method_option :raid, type: :string, default: "RAID5", desc: "RAID type (RAID0, RAID1, RAID5, RAID6, RAID10)"
+    def storage_create_volume
+      with_idrac_client do |client|
+        controller = client.controller
+        drives = client.drives(controller)
+        
+        # Confirm with the user before proceeding
+        puts "This will create a new #{options[:raid]} volume named '#{options[:name]}' using #{drives.size} drives.".yellow
+        puts "All data on these drives will be lost!".red.bold
+        
+        print "Do you want to continue? (y/n): "
+        confirmation = $stdin.gets.chomp.downcase
+        
+        if confirmation == 'y'
+          client.create_virtual_disk(controller['Id'], drives, name: options[:name], raid_type: options[:raid])
+          puts "Volume created successfully".green
+        else
+          puts "Operation cancelled".yellow
+        end
+      end
+    end
+
+    desc "storage_delete_volume", "Delete a virtual disk"
+    map "storage:delete_volume" => :storage_delete_volume
+    def storage_delete_volume
+      with_idrac_client do |client|
+        controller = client.controller
+        volumes = client.volumes(controller)
+        
+        if volumes.empty?
+          puts "No volumes found to delete".yellow
+          return
+        end
+        
+        puts "Available volumes:".green
+        volumes.each_with_index do |vol, idx|
+          puts "#{idx+1}. #{vol[:name]} (#{vol[:raid_level] || vol[:volume_type]}, #{(vol[:capacity_bytes].to_f / (1024**3)).round(2)} GB)"
+        end
+        
+        print "Enter the number of the volume to delete (or 'q' to quit): "
+        input = $stdin.gets.chomp
+        
+        if input.downcase == 'q'
+          puts "Operation cancelled".yellow
+          return
+        end
+        
+        index = input.to_i - 1
+        if index >= 0 && index < volumes.size
+          volume = volumes[index]
+          
+          puts "You are about to delete '#{volume[:name]}'. All data will be lost!".red.bold
+          print "Type the volume name to confirm deletion: "
+          confirm = $stdin.gets.chomp
+          
+          if confirm == volume[:name]
+            client.delete_volume(volume[:"@odata.id"])
+            puts "Volume deleted successfully".green
+          else
+            puts "Volume name did not match. Operation cancelled".yellow
+          end
+        else
+          puts "Invalid selection".red
+        end
+      end
+    end
+
+    desc "storage_encryption_enable", "Enable Self-Encrypting Drive (SED) support"
+    map "storage:encryption_enable" => :storage_encryption_enable
+    method_option :passphrase, type: :string, desc: "Encryption passphrase"
+    method_option :keyid, type: :string, desc: "Key identifier"
+    def storage_encryption_enable
+      with_idrac_client do |client|
+        controller = client.controller
+        drives = client.drives(controller)
+        
+        if !client.controller_encryption_capable?(controller)
+          puts "This controller does not support encryption".red
+          return
+        end
+        
+        if client.controller_encryption_enabled?(controller)
+          puts "Encryption is already enabled on this controller".yellow
+          return
+        end
+        
+        if !client.all_seds?(drives)
+          puts "Not all drives are Self-Encrypting Drives (SEDs)".red
+          return
+        end
+        
+        # Get passphrase if not provided
+        passphrase = options[:passphrase]
+        if passphrase.nil?
+          print "Enter encryption passphrase (min 8 characters): "
+          passphrase = $stdin.noecho(&:gets).chomp
+          puts
+        end
+        
+        # Get keyid if not provided
+        keyid = options[:keyid] || "RAID-Key-#{Time.now.strftime('%Y%m%d')}"
+        
+        client.enable_local_key_management(controller['Id'], passphrase: passphrase, keyid: keyid)
+        puts "Encryption enabled successfully".green
+      end
+    end
+
+    desc "storage_encryption_disable", "Disable Self-Encrypting Drive (SED) support"
+    map "storage:encryption_disable" => :storage_encryption_disable
+    def storage_encryption_disable
+      with_idrac_client do |client|
+        controller = client.controller
+        
+        if !client.controller_encryption_enabled?(controller)
+          puts "Encryption is not enabled on this controller".yellow
+          return
+        end
+        
+        puts "WARNING: Disabling encryption may prevent access to encrypted data!".red.bold
+        print "Type 'DISABLE' to confirm: "
+        confirmation = $stdin.gets.chomp
+        
+        if confirmation == 'DISABLE'
+          client.disable_local_key_management(controller['Id'])
+          puts "Encryption disabled successfully".green
+        else
+          puts "Operation cancelled".yellow
+        end
+      end
+    end
+    
+    # System component commands
+    desc "system_memory", "Get memory/DIMM information"
+    map "system:memory" => :system_memory
+    def system_memory
+      with_idrac_client do |client|
+        memory = client.memory
+        
+        puts "\nMemory Modules (#{memory.size}):".green.bold
+        memory.each do |dimm|
+          capacity_gb = dimm["capacity_bytes"].to_f / (1024**3)
+          health_color = dimm["health"] == "OK" ? :green : :red
+          
+          puts "#{dimm['name']}:".bold
+          puts "  Model: #{dimm['model']}".cyan
+          puts "  Health: #{dimm['health'].send(health_color)}"
+          puts "  Capacity: #{capacity_gb.round(2)} GB".cyan
+          puts "  Speed: #{dimm['speed_mhz']} MHz".cyan
+          puts "  Serial: #{dimm['serial']}".cyan
+          puts ""
+        end
+        
+        # Show total memory
+        puts "Total Memory: #{client.total_memory_human(memory)}".green.bold
+      end
+    end
+
+    desc "system_psus", "Get power supply information"
+    map "system:psus" => :system_psus
+    def system_psus
+      with_idrac_client do |client|
+        psus = client.psus
+        
+        puts "\nPower Supplies (#{psus.size}):".green.bold
+        psus.each do |psu|
+          health_color = psu["status"] == "OK" ? :green : :red
+          
+          puts "#{psu['name']}:".bold
+          puts "  Model: #{psu['model']}".cyan
+          puts "  Health: #{psu['status'].send(health_color)}"
+          puts "  Input: #{psu['voltage']} V (#{psu['voltage_human']})".cyan
+          puts "  Output: #{psu['watts']} W".cyan
+          puts "  Serial: #{psu['serial']}".cyan
+          puts ""
+        end
+      end
+    end
+
+    desc "system_fans", "Get fan information"
+    map "system:fans" => :system_fans
+    def system_fans
+      with_idrac_client do |client|
+        fans = client.fans
+        
+        if fans.empty?
+          puts "No fan information available (system might be powered off)".yellow
+          return
+        end
+        
+        puts "\nFans (#{fans.size}):".green.bold
+        fans.each do |fan|
+          health_color = fan["status"] == "OK" ? :green : :red
+          
+          puts "#{fan['name']}:".bold
+          puts "  Health: #{fan['status'].send(health_color)}"
+          puts "  Speed: #{fan['rpm']} RPM".cyan
+          puts ""
+        end
+      end
+    end
+
+    desc "system_nics", "Get network adapter information"
+    map "system:nics" => :system_nics
+    def system_nics
+      with_idrac_client do |client|
+        nics = client.nics
+        pci = client.pci_devices
+        nics_with_pci = client.nics_to_pci(nics, pci)
+        
+        puts "\nNetwork Adapters (#{nics_with_pci.size}):".green.bold
+        nics_with_pci.each do |nic|
+          puts "#{nic['name']}:".bold
+          puts "  Manufacturer: #{nic['manufacturer']}".cyan
+          puts "  Model: #{nic['model']}".cyan
+          
+          if nic['ports'] && nic['ports'].any?
+            puts "  Ports:".cyan
+            nic['ports'].each do |port|
+              status_color = port["status"] == "Up" ? :green : :yellow
+              
+              puts "    #{port['name']}:".bold
+              puts "      Status: #{port['status'].send(status_color)}"
+              puts "      MAC: #{port['mac']}".cyan
+              puts "      Speed: #{port['speed_mbps']} Mbps".cyan
+              if port['pci']
+                puts "      PCI Bus: #{port['pci']}".cyan
+                puts "      Linux Device: #{port['linux_device']}".cyan
+              end
+              puts ""
+            end
+          end
+          puts ""
+        end
+      end
+    end
+
+    desc "system_idrac_network", "Get iDRAC network configuration"
+    map "system:idrac_network" => :system_idrac_network
+    def system_idrac_network
+      with_idrac_client do |client|
+        idrac = client.idrac_network
+        
+        puts "\niDRAC Network Configuration:".green.bold
+        puts "Status: #{idrac['status']}".cyan
+        puts "IPv4: #{idrac['ipv4']}".cyan
+        puts "Subnet Mask: #{idrac['mask']}".cyan
+        puts "MAC Address: #{idrac['mac']}".cyan
+        puts "Origin: #{idrac['origin']}".cyan
+        puts "Speed: #{idrac['speed_mbps']} Mbps".cyan
+      end
+    end
+
+    desc "system_events", "Get system event logs"
+    map "system:events" => :system_events
+    def system_events
+      with_idrac_client do |client|
+        events = client.system_event_logs
+        
+        puts "\nSystem Events (#{events.size}):".green.bold
+        events.each do |event|
+          severity_color = case event[:severity]
+                          when "Critical" then :red
+                          when "Warning" then :yellow
+                          else :cyan
+                          end
+          
+          puts "#{event[:id]} - #{event[:created]} - #{event[:severity].send(severity_color)} - #{event[:message]}"
+        end
+      end
+    end
+    
+    # Virtual media commands
+    desc "vmedia_status", "Get virtual media status"
+    map "vmedia:status" => :vmedia_status
+    def vmedia_status
+      with_idrac_client do |client|
+        media = client.virtual_media
+        
+        puts "\nVirtual Media Status:".green.bold
+        
+        if media.empty?
+          puts "No virtual media devices found".yellow
+          return
+        end
+        
+        media.each do |m|
+          status = m[:inserted] ? "Inserted: #{m[:image]}".green : "Not Inserted".yellow
+          puts "#{m[:device]}: #{status}"
+        end
+      end
+    end
+
+    desc "vmedia_insert URL", "Insert virtual media from URL"
+    map "vmedia:insert" => :vmedia_insert
+    method_option :device, type: :string, default: "CD", desc: "Device type (CD or RemovableDisk)"
+    def vmedia_insert(url)
+      with_idrac_client do |client|
+        puts "Inserting media from #{url} into #{options[:device]}..."
+        client.insert_virtual_media(url, device: options[:device])
+      end
+    end
+
+    desc "vmedia_eject", "Eject virtual media"
+    map "vmedia:eject" => :vmedia_eject
+    method_option :device, type: :string, default: "CD", desc: "Device to eject (CD or RemovableDisk)"
+    def vmedia_eject
+      with_idrac_client do |client|
+        client.eject_virtual_media(device: options[:device])
+      end
+    end
+
+    desc "vmedia_boot_once", "Set system to boot from virtual media once"
+    map "vmedia:boot_once" => :vmedia_boot_once
+    def vmedia_boot_once
+      with_idrac_client do |client|
+        client.set_one_time_virtual_media_boot
+        puts "System configured to boot from virtual media on next restart"
+      end
+    end
+    
+    # Boot management commands
+    desc "boot_options", "Get current boot options"
+    map "boot:options" => :boot_options
+    def boot_options
+      with_idrac_client do |client|
+        options = client.get_bios_boot_options
+        
+        if options == false
+          puts "Failed to get boot options. System may not be in UEFI mode.".red
+          return
+        end
+        
+        puts "\nBoot Options:".green.bold
+        
+        # Display enabled boot options (current boot order)
+        puts "Current Boot Order:".cyan
+        options[:boot_order].each_with_index do |opt, idx|
+          puts "  #{idx+1}. #{opt}"
+        end
+        
+        # Display all available boot options
+        puts "\nAvailable Boot Options:".cyan
+        options[:boot_options].each do |opt|
+          enabled = options[:boot_order].include?(opt)
+          status = enabled ? "Enabled".green : "Disabled".yellow
+          puts "  #{opt}: #{status}"
+        end
+      end
+    end
+
+    desc "boot_enable_uefi", "Enable UEFI boot mode"
+    map "boot:enable_uefi" => :boot_enable_uefi
+    def boot_enable_uefi
+      with_idrac_client do |client|
+        client.ensure_uefi_boot
+      end
+    end
+
+    desc "boot_set_hd_first", "Set boot order with hard drive first"
+    map "boot:set_hd_first" => :boot_set_hd_first
+    def boot_set_hd_first
+      with_idrac_client do |client|
+        client.set_boot_order_hd_first
+      end
+    end
+
+    desc "boot_ignore_errors", "Configure BIOS to ignore boot errors"
+    map "boot:ignore_errors" => :boot_ignore_errors
+    method_option :enable, type: :boolean, default: true, desc: "Enable or disable ignoring boot errors"
+    def boot_ignore_errors
+      with_idrac_client do |client|
+        client.set_bios_ignore_errors(options[:enable])
+        if options[:enable]
+          puts "BIOS configured to ignore boot errors".green
+        else
+          puts "BIOS configured to halt on boot errors".green
+        end
+      end
+    end
+
+    desc "boot_power_optimization", "Configure BIOS for OS-controlled power management"
+    map "boot:power_optimization" => :boot_power_optimization
+    def boot_power_optimization
+      with_idrac_client do |client|
+        client.set_bios_os_power_control
+        puts "BIOS configured for OS power management optimization".green
+      end
+    end
+
+    desc "boot_source_override", "Get current boot source override settings"
+    map "boot:source_override" => :boot_source_override
+    def boot_source_override
+      with_idrac_client do |client|
+        client.get_boot_source_override
+      end
+    end
+
+    # Test commands
+    desc "test_live", "Test all major functionality of the gem on a real system"
+    map "test:live" => :test_live
+    method_option :timeout, type: :numeric, default: 10, desc: "Connection timeout in seconds"
+    def test_live
+      test_results = {}
+      
+      puts "Running comprehensive live test of idrac gem functionality...".green.bold
+      puts "=" * 80
+      puts "This will test all read-only operations of the gem. No changes will be made to your system.".yellow
+      puts "Using connection timeout of #{options[:timeout]} seconds (use --timeout=X to change)".yellow
+      puts "=" * 80
+      
+      with_idrac_client do |client|
+        # Set higher verbosity temporarily for comprehensive logging
+        original_verbosity = client.verbosity
+        
+        # Configure verbosity level based on user options
+        if options[:very_verbose] || options[:debug]
+          client.verbosity = options[:debug] ? 3 : 2
+          puts "HTTP request/response details will be shown (verbosity level: #{client.verbosity})".cyan
+        else
+          client.verbosity = options[:verbose] ? 1 : 0
+          puts "HTTP request/response details hidden (use -vv or -vvv for details)".cyan 
+          
+          # Silence Faraday logging for lower verbosity levels
+          if defined?(Faraday.default_connection) && Faraday.default_connection
+            begin
+              Faraday.default_connection.builder.handlers.each do |handler|
+                if defined?(Faraday::Response::Logger) && handler.klass == Faraday::Response::Logger && 
+                   handler.instance_variable_defined?(:@logger) && handler.instance_variable_get(:@logger)
+                  handler.instance_variable_get(:@logger).level = Logger::WARN
+                end
+              end
+            rescue => e
+              puts "Warning: Unable to configure logging: #{e.message}".yellow if options[:verbose]
+            end
+          end
+          
+          # Also try to silence the built-in logger in the client
+          if client.respond_to?(:connection) && client.connection.respond_to?(:builder)
+            begin
+              client.connection.builder.handlers.each do |handler|
+                if defined?(Faraday::Response::Logger) && handler.klass == Faraday::Response::Logger &&
+                   handler.instance_variable_defined?(:@logger) && handler.instance_variable_get(:@logger)
+                  handler.instance_variable_get(:@logger).level = Logger::WARN
+                end
+              end
+            rescue => e
+              puts "Warning: Unable to configure client logging: #{e.message}".yellow if options[:verbose]
+            end
+          end
+        end
+        
+        # Set timeout for connection - modify the connection object if it's available
+        begin
+          if client.respond_to?(:connection) && client.connection.respond_to?(:options)
+            client.connection.options.timeout = options[:timeout]
+            client.connection.options.open_timeout = options[:timeout]
+          end
+        rescue => e
+          puts "Warning: Unable to set timeout options: #{e.message}".yellow
+        end
+        
+        begin
+          # Establish a session that will be used for all tests
+          # Force the creation of a new session and test it works
+          if client.session.respond_to?(:delete) 
+            client.session.delete rescue nil
+          end
+          
+          session_created = client.session.create
+          if !session_created && !client.direct_mode
+            puts "Failed to establish a session, falling back to direct mode".yellow
+            client.direct_mode = true
+          end
+          
+          # Basic connection test
+          puts "\n[TEST] Basic connection".cyan.bold
+          begin
+            version = client.redfish_version
+            puts "✓ Connection successful, Redfish version: #{version}".green
+            test_results["connection"] = { status: "PASS", message: "Connected to iDRAC successfully" }
+          rescue Faraday::TimeoutError => e
+            puts "✗ Connection timed out after #{options[:timeout]} seconds. Check host and network.".red
+            test_results["connection"] = { status: "FAIL", message: "Connection timeout: #{e.message}" }
+            puts "No further tests will be run until connection is established.".red
+            break
+          rescue => e
+            puts "✗ Connection failed: #{e.message}".red
+            test_results["connection"] = { status: "FAIL", message: e.message }
+            puts "No further tests will be run until connection is established.".red
+            break
+          end
+          
+          # System info test
+          puts "\n[TEST] System information".cyan.bold
+          begin
+            response = client.authenticated_request(:get, "/redfish/v1/Systems/System.Embedded.1")
+            system_info = JSON.parse(response.body)
+            puts "✓ System info: #{system_info['Model']} (#{system_info['SKU']})".green
+            test_results["system_info"] = { status: "PASS", message: "Retrieved system information successfully" }
+          rescue => e
+            puts "✗ System info failed: #{e.message}".red
+            test_results["system_info"] = { status: "FAIL", message: e.message }
+            # If we can't get basic system info, stop testing
+            break
+          end
+          
+          # Power tests
+          puts "\n[TEST] Power management".cyan.bold
+          begin
+            power_state = client.get_power_state
+            puts "✓ Power state: #{power_state}".green
+            
+            watts = client.get_power_usage_watts
+            puts "✓ Power usage: #{watts} watts".green
+            test_results["power"] = { status: "PASS", message: "Retrieved power information successfully" }
+          rescue => e
+            puts "✗ Power tests failed: #{e.message}".red
+            test_results["power"] = { status: "FAIL", message: e.message }
+          end
+          
+          # Storage tests
+          puts "\n[TEST] Storage management".cyan.bold
+          begin
+            controller = client.controller
+            puts "✓ Storage controller: #{controller['Name']} (#{controller['Model']})".green
+            
+            drives = client.drives(controller)
+            puts "✓ Found #{drives.size} physical drives".green
+            
+            volumes = client.volumes(controller)
+            puts "✓ Found #{volumes.size} virtual disks".green
+            test_results["storage"] = { status: "PASS", message: "Retrieved storage information successfully" }
+          rescue => e
+            puts "✗ Storage tests failed: #{e.message}".red
+            test_results["storage"] = { status: "FAIL", message: e.message }
+          end
+          
+          # System component tests
+          puts "\n[TEST] System components".cyan.bold
+          begin
+            begin
+              memory = client.memory
+              puts "✓ Memory: #{client.total_memory_human(memory)}".green
+              memory_test_status = "PASS"
+              memory_test_message = "Retrieved memory information successfully"
+            rescue => e
+              puts "✗ Memory test failed: #{e.message}".red
+              memory_test_status = "FAIL"
+              memory_test_message = e.message
+            end
+            
+            begin
+              psus = client.psus
+              puts "✓ Found #{psus.size} power supplies".green
+              psu_test_status = "PASS"
+              psu_test_message = "Retrieved PSU information successfully"
+            rescue => e
+              puts "✗ PSU test failed: #{e.message}".red
+              psu_test_status = "FAIL"
+              psu_test_message = e.message
+            end
+            
+            begin
+              fans = client.fans
+              puts "✓ Found #{fans.size} fans".green
+              fan_test_status = "PASS"
+              fan_test_message = "Retrieved fan information successfully"
+            rescue => e
+              puts "✗ Fan test failed: #{e.message}".red
+              fan_test_status = "FAIL" 
+              fan_test_message = e.message
+            end
+            
+            begin
+              nics = client.nics
+              puts "✓ Found #{nics.size} network interfaces".green
+              nic_test_status = "PASS"
+              nic_test_message = "Retrieved NIC information successfully"
+            rescue => e
+              puts "✗ NIC test failed: #{e.message}".red
+              nic_test_status = "FAIL"
+              nic_test_message = e.message
+            end
+            
+            test_results["memory"] = { status: memory_test_status, message: memory_test_message }
+            test_results["psus"] = { status: psu_test_status, message: psu_test_message }
+            test_results["fans"] = { status: fan_test_status, message: fan_test_message }
+            test_results["nics"] = { status: nic_test_status, message: nic_test_message }
+          rescue => e
+            puts "✗ System component tests failed: #{e.message}".red
+            test_results["system_components"] = { status: "FAIL", message: e.message }
+          end
+          
+          # Virtual media tests
+          puts "\n[TEST] Virtual media".cyan.bold
+          begin
+            media = client.virtual_media
+            puts "✓ Found #{media.size} virtual media devices".green
+            test_results["virtual_media"] = { status: "PASS", message: "Retrieved virtual media information successfully" }
+          rescue => e
+            puts "✗ Virtual media test failed: #{e.message}".red
+            test_results["virtual_media"] = { status: "FAIL", message: e.message }
+          end
+          
+          # Boot management tests
+          puts "\n[TEST] Boot management".cyan.bold
+          begin
+            boot_options = client.get_bios_boot_options
+            puts "✓ Retrieved BIOS boot options".green
+            
+            boot_override = client.get_boot_source_override
+            puts "✓ Boot source override: #{boot_override}".green
+            test_results["boot"] = { status: "PASS", message: "Retrieved boot information successfully" }
+          rescue => e
+            puts "✗ Boot management test failed: #{e.message}".red
+            test_results["boot"] = { status: "FAIL", message: e.message }
+          end
+          
+          # Jobs and tasks
+          puts "\n[TEST] Jobs and tasks".cyan.bold
+          begin
+            jobs = client.jobs
+            puts "✓ Retrieved job queue information".green
+            test_results["jobs"] = { status: "PASS", message: "Retrieved job information successfully" }
+          rescue => e
+            puts "✗ Jobs test failed: #{e.message}".red
+            test_results["jobs"] = { status: "FAIL", message: e.message }
+          end
+          
+        rescue => e
+          puts "\n✗ Unexpected error during testing: #{e.message}".red.bold
+          puts e.backtrace.join("\n").red if client.verbosity >= 2
+        ensure
+          # Clean up - make sure we delete the session to avoid leaving orphaned sessions
+          begin
+            if client.session.respond_to?(:delete) && client.session.x_auth_token
+              client.session.delete 
+            end
+          rescue
+            # Ignore errors during cleanup
+          end
+          
+          # Restore original verbosity
+          client.verbosity = original_verbosity
+        end
+        
+        # Print summary
+        puts "\n" + "=" * 80
+        puts "TEST SUMMARY:".green.bold
+        puts "=" * 80
+        
+        pass_count = test_results.count { |_, v| v[:status] == "PASS" }
+        fail_count = test_results.count { |_, v| v[:status] == "FAIL" }
+        
+        test_results.each do |test_name, result|
+          status_color = result[:status] == "PASS" ? :green : :red
+          puts "#{test_name.ljust(20)}: #{result[:status].send(status_color)} - #{result[:message]}"
+        end
+        
+        puts "=" * 80
+        puts "OVERALL: #{pass_count} passed, #{fail_count} failed".send(fail_count == 0 ? :green : :yellow).bold
+        puts "=" * 80
+      end
+    end
+    
     private
 
     def with_idrac_client
@@ -509,7 +1426,9 @@ module IDRAC
         port: options[:port],
         use_ssl: !options[:no_ssl],
         verify_ssl: options[:verify_ssl],
-        auto_delete_sessions: options[:auto_delete_sessions]
+        auto_delete_sessions: options[:auto_delete_sessions],
+        retry_count: options[:retries],
+        retry_delay: options[:retry_delay]
       )
     end
   end