foreman_nutanix 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e0782547a714f12943e80c4f2e4eef7eeabec0dd586ffa5c1744156014b20d3f
-  data.tar.gz: 66704a2b48bcc57bacb8a44f5a996b737ab671b0eb9923079793b92e164d2864
+  metadata.gz: e4f699c1534db4e1dc7d31dab1ed7af4ea04f69ec364f1ade64b243c8b3ab19d
+  data.tar.gz: 5c82e86ec3fdd45fc9a282cdf7d5c688b16931fa656b7dda6407175bf48d551d
 SHA512:
-  metadata.gz: 8f3f940f6dd0918586e800e10d40b0ca8afad77216fffc577671e69f96518c729bafdf1e694ebf2f13d62f7a2433deb0428ec5f788f5e843c729bc71fabe4325
-  data.tar.gz: 4f42b6419740c82a050f71121f28e893dcd1e2322560db45dc435b9b157e2eeb9fad6e44377d76bb971f3f31e47f2b4b18a7ffa9e39e5c759316f91374983afc
+  metadata.gz: c5b08a2a38277497d102b4b383daf31c5a5b407acfd33df940499e86bfe39016dea843faa21b98596a703e94f5280f55b655c0c72df2821f6e00684e485ea6b5
+  data.tar.gz: 32e6620c3dff62d75fe1dc17a101648d076f11928c21e1f571642c26286b53fa254e4e643ae165fa2ac1637c3e20c2d25d3786120ba01fff073bd6238601c8aa

data/Rakefile

@@ -20,8 +20,6 @@ RDoc::Task.new(:rdoc) do |rdoc|
   rdoc.rdoc_files.include('lib/**/*.rb')
 end
 
-APP_RAKEFILE = File.expand_path('test/dummy/Rakefile', __dir__)
-
 Bundler::GemHelper.install_tasks
 
 require 'rake/testtask'
@@ -43,7 +41,3 @@ rescue StandardError => _e
 rescue LoadError
   puts 'Rubocop not loaded.'
 end
-
-task :default do
-  Rake::Task['rubocop'].execute
-end

data/app/lib/foreman_nutanix/nutanix_adapter.rb

@@ -33,15 +33,13 @@ module ForemanNutanix
         Rails.logger.info "=== NUTANIX: ServersCollection::get called with uuid: #{uuid} ==="
 
         # Extract the actual UUID if it has a prefix
-        actual_uuid = uuid.to_s.include?(':') ? uuid.to_s.split(':').last : uuid.to_s
+        actual_uuid = ShimClient.normalize_uuid(uuid)
 
         # Fetch full VM details from shim server
-        base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-        uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}")
-        response = Net::HTTP.get_response(uri)
+        response = shim.get("/api/v1/vmm/vms/#{actual_uuid}")
 
-        if response.is_a?(Net::HTTPSuccess)
-          data = JSON.parse(response.body)
+        if response.success?
+          data = response.json
 
           total_cpus = (data['num_sockets'] || 1) * (data['num_cores_per_socket'] || 1)
           memory_gb = data['memory_size_bytes'] ? (data['memory_size_bytes'].to_f / 1024**3).round : 4
@@ -82,10 +80,7 @@ module ForemanNutanix
         Rails.logger.info "=== NUTANIX: ServersCollection::all called with opts: #{opts} ==="
 
         # Fetch VMs from shim server (now includes MAC and IP)
-        base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-        uri = URI("#{base.chomp('/')}/api/v1/vmm/list-vms")
-        response = Net::HTTP.get_response(uri)
-        data = JSON.parse(response.body)
+        data = shim.get('/api/v1/vmm/list-vms').json
 
         # Filter VMs by cluster
         filtered_data = data.select { |vm| vm['cluster_ext_id'] == @cluster }
@@ -106,6 +101,7 @@ module ForemanNutanix
             ip_addresses: vm_data['ip_addresses'] || [],
             create_time: vm_data['create_time'],
             disk_size_gb: vm_data['disk_size_bytes'].to_i / (1024**3),
+            gpus: vm_data['gpus'],
           })
           vm.instance_variable_set(:@persisted, true)
           vm
@@ -114,6 +110,14 @@ module ForemanNutanix
         Rails.logger.error "=== NUTANIX: Error fetching VMs: #{e.message} ==="
         []
       end
+
+      private
+
+      # ServersCollection holds no reference to the ComputeResource, so it builds
+      # its own client off the shim server address in the environment.
+      def shim
+        @shim ||= ShimClient.new
+      end
     end
   end
 end

data/app/models/foreman_nutanix/nutanix.rb

@@ -40,8 +40,9 @@ module ForemanNutanix
       "#{name} (#{provider_friendly_name})"
     end
 
+    # Kept public: app/views/compute_resources/show/_nutanix.html.erb renders it.
     def shim_server_url
-      ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
+      ShimClient.default_base_url
     end
 
     def provided_attributes
@@ -56,10 +57,7 @@ module ForemanNutanix
 
     # Available clusters for selection
     def available_clusters
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/clustermgmt/list-clusters")
-      response = Net::HTTP.get_response(uri)
-      data = JSON.parse(response.body)
+      data = shim.get('/api/v1/clustermgmt/list-clusters').json
 
       data.map do |cluster|
         cluster[:name] = "#{cluster['name']} (#{cluster['arch']})"
@@ -80,10 +78,7 @@ module ForemanNutanix
     # Available networks for VMs
     def available_networks
       Rails.logger.info '=== NUTANIX: Fetching available networks from shim server ==='
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/networking/list-networks")
-      response = Net::HTTP.get_response(uri)
-      data = JSON.parse(response.body)
+      data = shim.get('/api/v1/networking/list-networks').json
 
       # Filter networks by the cluster associated with this compute resource
       cluster_ext_id = cluster
@@ -114,10 +109,7 @@ module ForemanNutanix
     # Available storage containers for VMs
     def available_storage_containers
       Rails.logger.info '=== NUTANIX: Fetching available storage containers from shim server ==='
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/clustermgmt/list-storage-containers")
-      response = Net::HTTP.get_response(uri)
-      data = JSON.parse(response.body)
+      data = shim.get('/api/v1/clustermgmt/list-storage-containers').json
 
       # Filter storage containers by the cluster associated with this compute resource
       cluster_ext_id = cluster
@@ -146,13 +138,10 @@ module ForemanNutanix
     # Cluster resource statistics (CPU, memory, storage usage)
     def cluster_resource_stats
       Rails.logger.info '=== NUTANIX: Fetching cluster resource stats from shim server ==='
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
       cluster_id = cluster
       return nil unless cluster_id
 
-      uri = URI("#{base.chomp('/')}/api/v1/clustermgmt/clusters/#{cluster_id}/stats")
-      response = Net::HTTP.get_response(uri)
-      data = JSON.parse(response.body)
+      data = shim.get("/api/v1/clustermgmt/clusters/#{cluster_id}/stats").json
 
       OpenStruct.new(data)
     rescue StandardError => e
@@ -163,10 +152,7 @@ module ForemanNutanix
     # Available images
     def available_images(_opts = {})
       Rails.logger.info '=== NUTANIX: Fetching available images from shim server ==='
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/list-images")
-      response = Net::HTTP.get_response(uri)
-      data = JSON.parse(response.body)
+      data = shim.get('/api/v1/vmm/list-images').json
 
       # Filter images by cluster if cluster_location_ext_ids is available
       cluster_ext_id = cluster
@@ -286,20 +272,10 @@ module ForemanNutanix
     # Start VM - called by Foreman for power on
     def start_vm(uuid)
       Rails.logger.info "=== NUTANIX: START_VM CALLED with uuid: #{uuid} ==="
-      actual_uuid = uuid.to_s.include?(':') ? uuid.to_s.split(':').last : uuid.to_s
+      actual_uuid = ShimClient.normalize_uuid(uuid)
 
-      base = shim_server_url
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}/power-state")
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == 'https'
-
-      request = Net::HTTP::Post.new(uri.path)
-      request['Content-Type'] = 'application/json'
-      request.body = { action: 'POWER_ON' }.to_json
-
-      response = http.request(request)
-      response.is_a?(Net::HTTPSuccess)
+      response = shim.post("/api/v1/vmm/vms/#{actual_uuid}/power-state", { action: 'POWER_ON' })
+      response.success?
     rescue StandardError => e
       Rails.logger.error "=== NUTANIX: START_VM ERROR: #{e.message} ==="
       raise e
@@ -308,20 +284,10 @@ module ForemanNutanix
     # Stop VM - called by Foreman for power off
     def stop_vm(uuid)
       Rails.logger.info "=== NUTANIX: STOP_VM CALLED with uuid: #{uuid} ==="
-      actual_uuid = uuid.to_s.include?(':') ? uuid.to_s.split(':').last : uuid.to_s
-
-      base = shim_server_url
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}/power-state")
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == 'https'
+      actual_uuid = ShimClient.normalize_uuid(uuid)
 
-      request = Net::HTTP::Post.new(uri.path)
-      request['Content-Type'] = 'application/json'
-      request.body = { action: 'POWER_OFF' }.to_json
-
-      response = http.request(request)
-      response.is_a?(Net::HTTPSuccess)
+      response = shim.post("/api/v1/vmm/vms/#{actual_uuid}/power-state", { action: 'POWER_OFF' })
+      response.success?
     rescue StandardError => e
       Rails.logger.error "=== NUTANIX: STOP_VM ERROR: #{e.message} ==="
       raise e
@@ -331,14 +297,12 @@ module ForemanNutanix
     def vm_power_state(vm)
       Rails.logger.info "=== NUTANIX: VM_POWER_STATE CALLED for vm: #{vm} ==="
       uuid = vm.respond_to?(:identity) ? vm.identity : vm.to_s
-      actual_uuid = uuid.to_s.include?(':') ? uuid.to_s.split(':').last : uuid.to_s
+      actual_uuid = ShimClient.normalize_uuid(uuid)
 
-      base = shim_server_url
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}/power-state")
-      response = Net::HTTP.get_response(uri)
+      response = shim.get("/api/v1/vmm/vms/#{actual_uuid}/power-state")
 
-      if response.is_a?(Net::HTTPSuccess)
-        data = JSON.parse(response.body)
+      if response.success?
+        data = response.json
         state = data['power_state']
         Rails.logger.info "=== NUTANIX: VM_POWER_STATE returning: #{state} ==="
         # Return hash that Foreman expects
@@ -375,19 +339,12 @@ module ForemanNutanix
       return true if uuid.nil? || uuid.to_s.strip.empty?
 
       # Extract the actual UUID if it has a prefix
-      actual_uuid = uuid.to_s.include?(':') ? uuid.to_s.split(':').last : uuid.to_s
+      actual_uuid = ShimClient.normalize_uuid(uuid)
 
       # Call the shim server to delete the VM
-      base = shim_server_url
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}")
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == 'https'
-
-      request = Net::HTTP::Delete.new(uri.path)
-      response = http.request(request)
+      response = shim.delete("/api/v1/vmm/vms/#{actual_uuid}")
 
-      if response.is_a?(Net::HTTPNoContent) || response.is_a?(Net::HTTPSuccess)
+      if response.no_content? || response.success?
         Rails.logger.info "=== NUTANIX: VM #{actual_uuid} deleted successfully ==="
         true
       else
@@ -455,6 +412,10 @@ module ForemanNutanix
 
     private
 
+    def shim
+      @shim ||= ShimClient.new(shim_server_url)
+    end
+
     def client
       Rails.logger.info "=== NUTANIX: Creating client for cluster #{cluster} ==="
       @client ||= NutanixAdapter.new(cluster)

data/app/models/foreman_nutanix/nutanix_compute.rb

@@ -46,8 +46,10 @@ module ForemanNutanix
       @boot_method = args[:boot_method]
       @secure_boot = args[:secure_boot]
 
-      # GPUs
-      @gpus = args[:gpus]
+      # GPUs. Defaults to [] rather than nil: the shim's /list-vms response
+      # carries no gpus field, so VMs built by ServersCollection#all never
+      # receive one, and the index view calls #gpus.empty? on every row.
+      @gpus = args[:gpus] || []
     end
 
     # Required by Foreman - indicates if VM exists
@@ -99,20 +101,10 @@ module ForemanNutanix
       Rails.logger.info "=== NUTANIX: Provisioning VM with request: #{provision_request} ==="
 
       # Call the shim server to provision the VM
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/provision-vm")
+      response = shim.post('/api/v1/vmm/provision-vm', provision_request)
 
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == 'https'
-
-      request = Net::HTTP::Post.new(uri.path)
-      request['Content-Type'] = 'application/json'
-      request.body = provision_request.to_json
-
-      response = http.request(request)
-
-      if response.is_a?(Net::HTTPSuccess)
-        result = JSON.parse(response.body)
+      if response.success?
+        result = response.json
         Rails.logger.info "=== NUTANIX: VM provisioned successfully: #{result} ==="
 
         # Update identity with the real ext_id from Nutanix
@@ -176,22 +168,12 @@ module ForemanNutanix
       return false unless persisted?
 
       # Extract actual UUID (handle ZXJnb24=:uuid format)
-      actual_uuid = @identity.to_s.include?(':') ? @identity.to_s.split(':').last : @identity.to_s
+      actual_uuid = ShimClient.normalize_uuid(@identity)
 
       # Call the shim server to power on the VM
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}/power-state")
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == 'https'
-
-      request = Net::HTTP::Post.new(uri.path)
-      request['Content-Type'] = 'application/json'
-      request.body = { action: 'POWER_ON' }.to_json
+      response = shim.post("/api/v1/vmm/vms/#{actual_uuid}/power-state", { action: 'POWER_ON' })
 
-      response = http.request(request)
-
-      if response.is_a?(Net::HTTPSuccess)
+      if response.success?
         Rails.logger.info "=== NUTANIX: VM #{actual_uuid} powered on successfully ==="
         @power_state = 'ON'
         true
@@ -211,22 +193,12 @@ module ForemanNutanix
       return false unless persisted?
 
       # Extract actual UUID (handle ZXJnb24=:uuid format)
-      actual_uuid = @identity.to_s.include?(':') ? @identity.to_s.split(':').last : @identity.to_s
+      actual_uuid = ShimClient.normalize_uuid(@identity)
 
       # Call the shim server to power off the VM
-      base = ENV['NUTANIX_SHIM_SERVER_ADDR'] || 'http://localhost:8000'
-      uri = URI("#{base.chomp('/')}/api/v1/vmm/vms/#{actual_uuid}/power-state")
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.use_ssl = uri.scheme == 'https'
-
-      request = Net::HTTP::Post.new(uri.path)
-      request['Content-Type'] = 'application/json'
-      request.body = { action: 'POWER_OFF' }.to_json
-
-      response = http.request(request)
+      response = shim.post("/api/v1/vmm/vms/#{actual_uuid}/power-state", { action: 'POWER_OFF' })
 
-      if response.is_a?(Net::HTTPSuccess)
+      if response.success?
         Rails.logger.info "=== NUTANIX: VM #{actual_uuid} powered off successfully ==="
         @power_state = 'OFF'
         true
@@ -240,6 +212,20 @@ module ForemanNutanix
       raise e
     end
 
+    # Human-readable GPU labels for the views, e.g. "NVIDIA Tesla T4".
+    # The shim returns each GPU as a hash; a shim older than 0.1.5 omits the
+    # field on /list-vms entirely, which #initialize turns into [].
+    def gpu_labels
+      @gpus.map do |gpu|
+        next gpu.to_s unless gpu.is_a?(Hash)
+
+        name = gpu['name']
+        name = gpu['device_id'] if blank_gpu_field?(name)
+        label = [gpu['vendor'], name].reject { |part| blank_gpu_field?(part) }.join(' ')
+        label.empty? ? 'GPU' : label
+      end
+    end
+
     # Required by Foreman - CPU count
     def cpu
       Rails.logger.info '=== NUTANIX: NutanixCompute::cpu called ==='
@@ -377,11 +363,26 @@ module ForemanNutanix
       yield if block_given?
     end
 
+    # Deliberately not ActiveSupport's #blank?: this class is loaded without
+    # Rails in test/nutanix_compute_test.rb.
+    def blank_gpu_field?(value)
+      value.nil? || value.to_s.strip.empty?
+    end
+    private :blank_gpu_field?
+
     # Required by Foreman - destroy VM
     def destroy
       Rails.logger.info '=== NUTANIX: NutanixCompute::destroy called ==='
       @persisted = false
       true
     end
+
+    private
+
+    # NutanixCompute holds no reference to the ComputeResource, so it builds its
+    # own client off the shim server address in the environment.
+    def shim
+      @shim ||= ShimClient.new
+    end
   end
 end

data/app/views/compute_resources_vms/show/_nutanix.html.erb

@@ -53,7 +53,8 @@
     </tr>
     <tr>
       <td><%= _("GPUs") %></td>
-      <td><%= @vm.gpus %></td>
+      <% gpu_labels = @vm.gpu_labels %>
+      <td><%= gpu_labels.any? ? gpu_labels.join(", ") : _("None") %></td>
     </tr>
   </tbody>
 </table>

data/lib/foreman_nutanix/shim_client.rb

@@ -0,0 +1,93 @@
+require 'json'
+require 'net/http'
+require 'uri'
+
+module ForemanNutanix
+  # Single HTTP seam for every call the plugin makes to the nutanix-shim-server.
+  #
+  # Deliberately plain Ruby: no Rails, no ActiveSupport, no Rails.logger. It must
+  # stay require-able from a bare minitest process with no Rails booted.
+  #
+  # Callers get back a Response value object rather than parsed data so that each
+  # one keeps its own (and today wildly inconsistent) success/failure branching.
+  class ShimClient
+    DEFAULT_BASE_URL = 'http://localhost:8000'.freeze
+
+    # Thin value object over a Net::HTTPResponse.
+    class Response
+      def initialize(raw)
+        @raw = raw
+      end
+
+      def success?
+        @raw.is_a?(Net::HTTPSuccess)
+      end
+
+      # Net::HTTPNoContent is the 204 response class. Exposed separately because
+      # destroy_vm historically tested for it explicitly alongside success?.
+      def no_content?
+        @raw.is_a?(Net::HTTPNoContent)
+      end
+
+      def code
+        @raw.code
+      end
+
+      def body
+        @raw.body
+      end
+
+      # Intentionally does NOT rescue: a non-JSON body (an HTML 500 page, say)
+      # must keep raising JSON::ParserError out to the caller, exactly as the
+      # inline JSON.parse(response.body) calls did before.
+      def json
+        JSON.parse(body)
+      end
+    end
+
+    def self.default_base_url
+      ENV['NUTANIX_SHIM_SERVER_ADDR'] || DEFAULT_BASE_URL
+    end
+
+    # Strips the "prefix:" from identities of the form "ZXJnb24=:<uuid>".
+    def self.normalize_uuid(uuid)
+      uuid.to_s.include?(':') ? uuid.to_s.split(':').last : uuid.to_s
+    end
+
+    attr_reader :base_url
+
+    # http: is an internal seam for tests only; production code never passes it.
+    def initialize(base_url = nil, http: Net::HTTP)
+      @base_url = (base_url || self.class.default_base_url).to_s.chomp('/')
+      @http = http
+    end
+
+    def get(path)
+      execute(Net::HTTP::Get, path)
+    end
+
+    def post(path, body = nil)
+      execute(Net::HTTP::Post, path, body)
+    end
+
+    def delete(path)
+      execute(Net::HTTP::Delete, path)
+    end
+
+    private
+
+    def execute(verb_class, path, body = nil)
+      uri = URI("#{@base_url}#{path}")
+      connection = @http.new(uri.host, uri.port)
+      connection.use_ssl = uri.scheme == 'https'
+
+      request = verb_class.new(uri.request_uri)
+      unless body.nil?
+        request['Content-Type'] = 'application/json'
+        request.body = body.to_json
+      end
+
+      Response.new(connection.request(request))
+    end
+  end
+end

data/lib/foreman_nutanix/version.rb

@@ -1,3 +1,3 @@
 module ForemanNutanix
-  VERSION = '0.1.4'.freeze
+  VERSION = '0.1.5'.freeze
 end

data/lib/foreman_nutanix.rb

@@ -1,3 +1,4 @@
+require 'foreman_nutanix/shim_client'
 require 'foreman_nutanix/engine'
 
 module ForemanNutanix

data/test/README.md

@@ -0,0 +1,45 @@
+# Tests
+
+Standalone minitest. No Rails, no Foreman, no database, no `test/dummy`.
+
+Run with:
+
+```
+bundle exec rake test
+```
+
+`test_helper.rb` requires only `lib/foreman_nutanix/shim_client.rb`, which is
+deliberately plain Ruby (net/http, json, uri). That is the whole reason the
+suite boots in milliseconds with nothing installed but minitest and rake.
+
+## What this covers
+
+`ForemanNutanix::ShimClient` — base URL resolution, trailing-slash chomping,
+verb and path construction, JSON body encoding, `success?` / `no_content?` /
+`code` / `body` / `json` on the response value object, and `normalize_uuid`.
+HTTP is faked through the `http:` keyword seam; no network, no webmock.
+
+## What cannot be tested here
+
+Everything that needs a booted Foreman:
+
+- `ForemanNutanix::Nutanix` — it is a `ComputeResource` subclass, and `cluster`
+  is stored in the inherited `url` column, so instantiating it at all needs
+  ActiveRecord, the Foreman schema, and the compute-resource STI machinery.
+- `ForemanNutanix::HostManagedExtensions` — a concern mixed into `Host::Managed`.
+- The `.erb` views under `app/views/`.
+- The API controller extensions under `app/controllers/`.
+- Anything touching the database, `Rails.logger`, or `Foreman::Plugin`.
+
+`NutanixCompute` and `NutanixAdapter` are plain objects but still call
+`Rails.logger` on nearly every method, so they are not reachable from here
+either without stubbing Rails.
+
+## What a full harness would need
+
+1. A `test/dummy` Rails app generated against a Foreman core checkout.
+2. That Foreman core pinned to a known version (the plugin requires >= 3.14.0),
+   since plugin tests load Foreman's own `test_helper`.
+3. A database created and migrated in CI before the suite runs.
+
+Not built. The standalone suite above is the part that pays for itself today.

data/test/nutanix_compute_test.rb

@@ -0,0 +1,71 @@
+require 'test_helper'
+
+# NutanixCompute is a plain class, but it logs in #initialize. Stub just enough
+# Rails to load it standalone; see test/README.md.
+require 'logger'
+module Rails
+  def self.logger
+    @logger ||= Logger.new(IO::NULL)
+  end
+end
+
+require 'ostruct'
+require_relative '../app/models/foreman_nutanix/nutanix_compute'
+
+class NutanixComputeTest < Minitest::Test
+  # Regression: ServersCollection#all builds VMs without a :gpus key, because
+  # the shim's /list-vms payload has no gpus field. The VM index template calls
+  # vm.gpus.empty? on every row, so a nil default raised NoMethodError there.
+  def test_gpus_defaults_to_an_empty_array_when_absent
+    vm = ForemanNutanix::NutanixCompute.new('cluster-1', name: 'vm1')
+    assert_equal [], vm.gpus
+    assert_empty vm.gpus
+  end
+
+  def test_gpus_passes_through_when_supplied
+    vm = ForemanNutanix::NutanixCompute.new('cluster-1', name: 'vm1', gpus: %w[gpu-a gpu-b])
+    assert_equal %w[gpu-a gpu-b], vm.gpus
+    refute_empty vm.gpus
+  end
+
+  def test_gpus_explicit_nil_still_yields_an_empty_array
+    vm = ForemanNutanix::NutanixCompute.new('cluster-1', name: 'vm1', gpus: nil)
+    assert_equal [], vm.gpus
+  end
+end
+
+class NutanixComputeGpuLabelsTest < Minitest::Test
+  def build(gpus)
+    ForemanNutanix::NutanixCompute.new('cluster-1', name: 'vm1', gpus: gpus)
+  end
+
+  def test_no_gpus_gives_no_labels
+    assert_equal [], build(nil).gpu_labels
+    assert_equal [], build([]).gpu_labels
+  end
+
+  def test_vendor_and_name_are_joined
+    labels = build([{ 'vendor' => 'NVIDIA', 'name' => 'Tesla T4', 'device_id' => 7864 }]).gpu_labels
+    assert_equal ['NVIDIA Tesla T4'], labels
+  end
+
+  def test_falls_back_to_device_id_when_name_is_missing_or_blank
+    assert_equal ['NVIDIA 7864'], build([{ 'vendor' => 'NVIDIA', 'device_id' => 7864 }]).gpu_labels
+    assert_equal ['NVIDIA 7864'], build([{ 'vendor' => 'NVIDIA', 'name' => '  ', 'device_id' => 7864 }]).gpu_labels
+  end
+
+  def test_name_alone_is_enough
+    assert_equal ['Tesla T4'], build([{ 'name' => 'Tesla T4' }]).gpu_labels
+  end
+
+  def test_entirely_empty_gpu_still_gets_a_label
+    assert_equal ['GPU'], build([{}]).gpu_labels
+    assert_equal ['GPU'], build([{ 'vendor' => nil, 'name' => nil, 'device_id' => nil }]).gpu_labels
+  end
+
+  def test_label_count_always_matches_gpu_count
+    labels = build([{ 'name' => 'A' }, {}, { 'vendor' => 'AMD' }]).gpu_labels
+    assert_equal 3, labels.size
+    refute_includes labels, ''
+  end
+end

data/test/shim_client_test.rb

@@ -0,0 +1,257 @@
+require 'test_helper'
+
+class ShimClientTest < Minitest::Test
+  # --- Fakes injected through the http: keyword -----------------------------
+
+  # Stands in for a Net::HTTP connection object.
+  class FakeConnection
+    attr_reader :host, :port, :requests
+    attr_accessor :use_ssl
+
+    def initialize(host, port, response)
+      @host = host
+      @port = port
+      @response = response
+      @requests = []
+      @use_ssl = nil
+    end
+
+    def request(req)
+      @requests << req
+      @response
+    end
+  end
+
+  # Stands in for the Net::HTTP class itself.
+  class FakeHttp
+    attr_reader :connections
+
+    def initialize(response)
+      @response = response
+      @connections = []
+    end
+
+    def new(host, port)
+      conn = FakeConnection.new(host, port, @response)
+      @connections << conn
+      conn
+    end
+
+    def last_connection
+      @connections.last
+    end
+
+    def last_request
+      last_connection.requests.last
+    end
+  end
+
+  def stub_response(klass = Net::HTTPOK, code: '200', body: '{}')
+    response = klass.new('1.1', code, 'Stub')
+    response.instance_variable_set(:@body, body)
+    response.instance_variable_set(:@read, true)
+    response
+  end
+
+  def client(base_url = 'http://shim.example:8000', response: stub_response)
+    http = FakeHttp.new(response)
+    [ForemanNutanix::ShimClient.new(base_url, http: http), http]
+  end
+
+  def with_env(value)
+    previous = ENV['NUTANIX_SHIM_SERVER_ADDR']
+    had_key = ENV.key?('NUTANIX_SHIM_SERVER_ADDR')
+    if value.nil?
+      ENV.delete('NUTANIX_SHIM_SERVER_ADDR')
+    else
+      ENV['NUTANIX_SHIM_SERVER_ADDR'] = value
+    end
+    yield
+  ensure
+    if had_key
+      ENV['NUTANIX_SHIM_SERVER_ADDR'] = previous
+    else
+      ENV.delete('NUTANIX_SHIM_SERVER_ADDR')
+    end
+  end
+
+  # --- Base URL -------------------------------------------------------------
+
+  def test_base_url_defaults_to_localhost_when_env_is_unset
+    with_env(nil) do
+      assert_equal 'http://localhost:8000', ForemanNutanix::ShimClient.new.base_url
+      assert_equal 'http://localhost:8000', ForemanNutanix::ShimClient.default_base_url
+    end
+  end
+
+  def test_base_url_comes_from_env_when_set
+    with_env('http://shim.internal:9000') do
+      assert_equal 'http://shim.internal:9000', ForemanNutanix::ShimClient.new.base_url
+      assert_equal 'http://shim.internal:9000', ForemanNutanix::ShimClient.default_base_url
+    end
+  end
+
+  def test_explicit_base_url_wins_over_env
+    with_env('http://shim.internal:9000') do
+      assert_equal 'http://explicit:1234', ForemanNutanix::ShimClient.new('http://explicit:1234').base_url
+    end
+  end
+
+  def test_trailing_slash_is_chomped
+    shim = ForemanNutanix::ShimClient.new('http://shim.example:8000/')
+    assert_equal 'http://shim.example:8000', shim.base_url
+  end
+
+  def test_trailing_slash_from_env_is_chomped
+    with_env('http://shim.internal:9000/') do
+      assert_equal 'http://shim.internal:9000', ForemanNutanix::ShimClient.new.base_url
+    end
+  end
+
+  # --- Verbs and path construction -----------------------------------------
+
+  def test_get_builds_a_get_request_at_the_joined_path
+    shim, http = client
+    shim.get('/api/v1/vmm/list-images')
+
+    request = http.last_request
+    assert_instance_of Net::HTTP::Get, request
+    assert_equal '/api/v1/vmm/list-images', request.path
+    assert_equal 'shim.example', http.last_connection.host
+    assert_equal 8000, http.last_connection.port
+  end
+
+  def test_post_builds_a_post_request_at_the_joined_path
+    shim, http = client
+    shim.post('/api/v1/vmm/vms/abc/power-state', { action: 'POWER_ON' })
+
+    assert_instance_of Net::HTTP::Post, http.last_request
+    assert_equal '/api/v1/vmm/vms/abc/power-state', http.last_request.path
+  end
+
+  def test_delete_builds_a_delete_request_at_the_joined_path
+    shim, http = client
+    shim.delete('/api/v1/vmm/vms/abc')
+
+    assert_instance_of Net::HTTP::Delete, http.last_request
+    assert_equal '/api/v1/vmm/vms/abc', http.last_request.path
+  end
+
+  def test_path_is_joined_to_a_base_url_that_had_a_trailing_slash
+    http = FakeHttp.new(stub_response)
+    ForemanNutanix::ShimClient.new('http://shim.example:8000/', http: http).get('/api/v1/vmm/list-vms')
+
+    assert_equal '/api/v1/vmm/list-vms', http.last_request.path
+  end
+
+  # --- Body encoding --------------------------------------------------------
+
+  def test_post_json_encodes_the_body_and_sets_content_type
+    shim, http = client
+    shim.post('/api/v1/vmm/provision-vm', { name: 'vm-1', num_sockets: 2 })
+
+    assert_equal 'application/json', http.last_request['Content-Type']
+    assert_equal({ 'name' => 'vm-1', 'num_sockets' => 2 }, JSON.parse(http.last_request.body))
+  end
+
+  def test_post_without_a_body_sends_no_body_and_no_content_type
+    shim, http = client
+    shim.post('/api/v1/vmm/noop')
+
+    assert_nil http.last_request.body
+    assert_nil http.last_request['Content-Type']
+  end
+
+  def test_get_sends_no_body_and_no_content_type
+    shim, http = client
+    shim.get('/api/v1/vmm/list-vms')
+
+    assert_nil http.last_request.body
+    assert_nil http.last_request['Content-Type']
+  end
+
+  # --- Scheme ---------------------------------------------------------------
+
+  def test_https_is_inferred_from_the_scheme
+    http = FakeHttp.new(stub_response)
+    ForemanNutanix::ShimClient.new('https://shim.example', http: http).get('/api/v1/vmm/list-vms')
+
+    assert_equal true, http.last_connection.use_ssl
+    assert_equal 443, http.last_connection.port
+  end
+
+  def test_http_scheme_does_not_enable_ssl
+    shim, http = client
+    shim.get('/api/v1/vmm/list-vms')
+
+    assert_equal false, http.last_connection.use_ssl
+  end
+
+  # --- Response -------------------------------------------------------------
+
+  def test_success_is_true_for_200
+    shim, = client(response: stub_response(Net::HTTPOK, code: '200'))
+    response = shim.get('/whatever')
+
+    assert_equal true, response.success?
+    assert_equal '200', response.code
+  end
+
+  def test_success_is_false_for_404
+    shim, = client(response: stub_response(Net::HTTPNotFound, code: '404', body: 'not found'))
+    response = shim.get('/whatever')
+
+    assert_equal false, response.success?
+    assert_equal '404', response.code
+    assert_equal 'not found', response.body
+  end
+
+  def test_success_is_false_for_500
+    error = stub_response(Net::HTTPInternalServerError, code: '500', body: '<html>boom</html>')
+    shim, = client(response: error)
+    response = shim.get('/whatever')
+
+    assert_equal false, response.success?
+    assert_equal '500', response.code
+  end
+
+  def test_no_content_is_true_only_for_204
+    shim, = client(response: stub_response(Net::HTTPNoContent, code: '204', body: nil))
+    assert_equal true, shim.get('/whatever').no_content?
+
+    shim_ok, = client(response: stub_response(Net::HTTPOK, code: '200'))
+    assert_equal false, shim_ok.get('/whatever').no_content?
+  end
+
+  def test_json_parses_the_body
+    shim, = client(response: stub_response(Net::HTTPOK, body: '[{"ext_id":"abc"}]'))
+
+    assert_equal [{ 'ext_id' => 'abc' }], shim.get('/whatever').json
+  end
+
+  def test_json_propagates_parser_error_on_non_json_bodies
+    error = stub_response(Net::HTTPInternalServerError, code: '500', body: '<html>boom</html>')
+    shim, = client(response: error)
+
+    assert_raises(JSON::ParserError) { shim.get('/whatever').json }
+  end
+
+  # --- normalize_uuid -------------------------------------------------------
+
+  def test_normalize_uuid_strips_a_prefix
+    assert_equal 'the-uuid', ForemanNutanix::ShimClient.normalize_uuid('ZXJnb24=:the-uuid')
+  end
+
+  def test_normalize_uuid_leaves_a_bare_uuid_alone
+    assert_equal 'the-uuid', ForemanNutanix::ShimClient.normalize_uuid('the-uuid')
+  end
+
+  def test_normalize_uuid_coerces_non_strings
+    assert_equal '', ForemanNutanix::ShimClient.normalize_uuid(nil)
+    assert_equal '42', ForemanNutanix::ShimClient.normalize_uuid(42)
+  end
+
+  def test_normalize_uuid_keeps_only_the_last_segment
+    assert_equal 'c', ForemanNutanix::ShimClient.normalize_uuid('a:b:c')
+  end
+end

data/test/test_helper.rb

@@ -0,0 +1,5 @@
+require 'minitest/autorun'
+
+# Standalone: no Rails, no Foreman, no database. Only the plain-Ruby seam is
+# loaded here. See test/README.md for what that rules out.
+require 'foreman_nutanix/shim_client'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: foreman_nutanix
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Miles Granger
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-09-14 00:00:00.000000000 Z
+date: 2026-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rdoc
@@ -54,10 +54,15 @@ files:
 - config/routes.rb
 - lib/foreman_nutanix.rb
 - lib/foreman_nutanix/engine.rb
+- lib/foreman_nutanix/shim_client.rb
 - lib/foreman_nutanix/version.rb
 - lib/tasks/foreman_nutanix_tasks.rake
 - locale/foreman_nutanix.pot
 - package.json
+- test/README.md
+- test/nutanix_compute_test.rb
+- test/shim_client_test.rb
+- test/test_helper.rb
 - webpack/global_index.js
 - webpack/global_test_setup.js
 - webpack/index.js
@@ -94,4 +99,8 @@ rubygems_version: 3.4.19
 signing_key:
 specification_version: 4
 summary: Nutanix plugin for Foreman
-test_files: []
+test_files:
+- test/README.md
+- test/nutanix_compute_test.rb
+- test/shim_client_test.rb
+- test/test_helper.rb