foreman_nutanix 0.1.5 → 0.1.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e4f699c1534db4e1dc7d31dab1ed7af4ea04f69ec364f1ade64b243c8b3ab19d
-  data.tar.gz: 5c82e86ec3fdd45fc9a282cdf7d5c688b16931fa656b7dda6407175bf48d551d
+  metadata.gz: 20eff365f58c477410d10f5b140961e4825738e49601442bec1740613aaf5704
+  data.tar.gz: bcefb95f0276c18905b569b187436a59a5e33276320b84238d4d6204e4ea3e6a
 SHA512:
-  metadata.gz: c5b08a2a38277497d102b4b383daf31c5a5b407acfd33df940499e86bfe39016dea843faa21b98596a703e94f5280f55b655c0c72df2821f6e00684e485ea6b5
-  data.tar.gz: 32e6620c3dff62d75fe1dc17a101648d076f11928c21e1f571642c26286b53fa254e4e643ae165fa2ac1637c3e20c2d25d3786120ba01fff073bd6238601c8aa
+  metadata.gz: 461cc7ed6c08843073891195b480c8356c148fadf2d2825aacfb0c8284167967abe1e30e37ac37a93c8cb102d86dc75cbab37ab93bca3789b4707cf87f63365e
+  data.tar.gz: bfea4f00a1a9148d6568014c9904b1afaef15172fb70033f386132fe83fd438b89896c3ecc8e6139104874f961908f9f5154cf0f7263caa0a112b9e5fea9acd6

data/app/models/foreman_nutanix/nutanix.rb

@@ -135,6 +135,48 @@ module ForemanNutanix
       []
     end
 
+    # Physical GPU profiles on this cluster, as options for the VM form's single
+    # GPU select.
+    #
+    # One select can only post one value, so the option id is a composite of the
+    # three things the shim's provision call needs:
+    # "<device_id>:<vendor_name>:<gpu_type>", e.g. "7864:NVIDIA:PASSTHROUGH_GRAPHICS".
+    # NutanixCompute#save splits it back apart.
+    #
+    # A profile ext_id is deliberately NOT the value: it pins the VM to one
+    # physical card, which fails the moment that card is busy. A device_id names
+    # a GPU model, so Nutanix schedules any free matching card.
+    def available_gpus
+      Rails.logger.info '=== NUTANIX: Fetching available GPU profiles from shim server ==='
+      cluster_ext_id = cluster
+      return [] unless cluster_ext_id
+
+      data = shim.get("/api/v1/clustermgmt/clusters/#{cluster_ext_id}/gpu-profiles").json
+
+      # Passthrough only, and only profiles whose composite round-trips. See
+      # ForemanNutanix::GpuProfile.usable? - an unusable profile offered here
+      # would provision a VM with no GPU and still report success.
+      filtered_data = data.select { |profile| GpuProfile.usable?(profile) }
+      Rails.logger.info "=== NUTANIX: GPU profiles - total: #{data.count}, usable: #{filtered_data.count} ==="
+
+      filtered_data.map do |profile|
+        OpenStruct.new({
+          id: GpuProfile.build(profile),
+          ext_id: profile['ext_id'],
+          name: GpuProfile.label(profile),
+          device_id: profile['device_id'],
+          device_name: profile['device_name'],
+          vendor_name: profile['vendor_name'],
+          gpu_type: profile['gpu_type'],
+          assignable: profile['assignable'],
+          is_in_use: profile['is_in_use'],
+        })
+      end
+    rescue StandardError => e
+      Rails.logger.error "=== NUTANIX: Error fetching GPU profiles: #{e.message} ==="
+      []
+    end
+
     # Cluster resource statistics (CPU, memory, storage usage)
     def cluster_resource_stats
       Rails.logger.info '=== NUTANIX: Fetching cluster resource stats from shim server ==='
@@ -412,6 +454,9 @@ module ForemanNutanix
 
     private
 
+    # "NVIDIA Tesla T4 (2 assignable)". Every part is optional in the shim's
+    # payload, so degrade instead of rendering a blank option.
+
     def shim
       @shim ||= ShimClient.new(shim_server_url)
     end

data/app/models/foreman_nutanix/nutanix_compute.rb

@@ -7,7 +7,7 @@ module ForemanNutanix
       :storage_container_ext_id, :num_sockets, :num_cores_per_socket,
       :disk_size_bytes, :description, :network_id, :storage_container,
       :disk_size_gb, :mac_address, :vm_ip_addresses, :create_time,
-      :boot_method, :secure_boot, :gpus
+      :boot_method, :secure_boot, :gpus, :gpu, :gpu_count
 
     def initialize(cluster = nil, args = {})
       Rails.logger.info "=== NUTANIX: NutanixCompute::initialize cluster=#{cluster} args=#{args} ==="
@@ -50,6 +50,13 @@ module ForemanNutanix
       # 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] || []
+
+      # GPU passthrough selection. `gpu` is the composite the form's single
+      # select carries: "<device_id>:<vendor_name>:<gpu_type>". Both stay nil
+      # when nothing was selected, which is what keeps #save's payload
+      # byte-identical to a GPU-less provision.
+      @gpu = args[:gpu]
+      @gpu_count = args[:gpu_count]
     end
 
     # Required by Foreman - indicates if VM exists
@@ -98,6 +105,10 @@ module ForemanNutanix
         boot_method: @boot_method,
       }
 
+      # Adds nothing at all unless a GPU was actually selected, so a GPU-less
+      # provision posts exactly the request it always did.
+      provision_request.merge!(gpu_provision_fields)
+
       Rails.logger.info "=== NUTANIX: Provisioning VM with request: #{provision_request} ==="
 
       # Call the shim server to provision the VM
@@ -379,6 +390,42 @@ module ForemanNutanix
 
     private
 
+    # The form's GPU select carries a single composite value,
+    # "<device_id>:<vendor_name>:<gpu_type>" (e.g. "7864:NVIDIA:PASSTHROUGH_GRAPHICS"),
+    # because one select cannot post three fields. Split it back apart here.
+    #
+    # Returns {} unless all three parts are present: a half-parsed composite
+    # must contribute nothing rather than provision a VM against a partially
+    # specified GPU. {} is also the no-GPU-selected case, which is what keeps
+    # the provision request byte-identical to a pre-GPU one.
+    def gpu_provision_fields
+      # Nothing selected is the common case and means exactly that.
+      return {} if GpuProfile.blank?(@gpu)
+
+      # Selected but unparseable is different: the user asked for a GPU. Dropping
+      # it here would build a GPU-less VM and report the build as successful, so
+      # fail the way a missing network or storage container does.
+      parts = GpuProfile.parse(@gpu)
+      if parts.nil?
+        raise StandardError, "Malformed GPU selection #{@gpu.inspect}; expected " \
+                             "'<device_id>:<vendor>:<gpu_type>'"
+      end
+
+      device_id, vendor, mode = parts
+
+      # The count field is hidden until a GPU is picked, so it routinely arrives
+      # nil or empty; one GPU is what selecting a GPU means.
+      count = @gpu_count.to_i
+      count = 1 if count < 1
+
+      {
+        gpu_device_id: device_id.to_i,
+        gpu_vendor: vendor,
+        gpu_mode: mode,
+        gpu_count: count,
+      }
+    end
+
     # NutanixCompute holds no reference to the ComputeResource, so it builds its
     # own client off the shim server address in the environment.
     def shim

data/app/views/compute_resources_vms/form/nutanix/_base.html.erb

@@ -66,6 +66,32 @@ compute_resource.available_storage_containers,
   max: 10_000,
 } %>
 
+<%# One select for three shim fields: the option value is the composite
+#    "<device_id>:<vendor_name>:<gpu_type>". NutanixCompute#save splits it.
+#    Passthrough only - available_gpus filters vGPU profiles out. %>
+<%= select_f f,
+:gpu,
+compute_resource.available_gpus,
+:id,
+:name,
+{ include_blank: _("No GPU"), selected: f.object.try(:gpu) },
+{
+  label: _("GPU"),
+  help_inline: _("Passthrough GPU to attach when the VM is created"),
+  id: "gpu-select",
+} %>
+
+<div id="gpu-options" class="hidden">
+  <%= counter_f f,
+  :gpu_count,
+  {
+    label: _("GPU Count"),
+    help_inline: _("How many of the selected GPU to attach"),
+    min: 1,
+    max: 8,
+  } %>
+</div>
+
 <%# `checked:` must reflect the saved value, else the box always renders
 #    checked and the compute profile's "off" never survives a page render.
 #    f.object is compute_resource.new_vm(vm_attrs); NutanixCompute has no :start
@@ -106,11 +132,20 @@ compute_resource.available_boot_methods,
 
 <script>
   var $bootMethod = $('#boot-method-select');
+  var $gpu = $('#gpu-select');
 
   function toggleUefiOptions() {
     $('#uefi-options').toggleClass('hidden', $bootMethod.val() !== 'uefi');
   }
 
+  // Same pattern as above: the count only means anything once a GPU is picked,
+  // and the blank "No GPU" option posts an empty value.
+  function toggleGpuOptions() {
+    $('#gpu-options').toggleClass('hidden', !$gpu.val());
+  }
+
   toggleUefiOptions();
+  toggleGpuOptions();
   $bootMethod.on('change', toggleUefiOptions);
+  $gpu.on('change', toggleGpuOptions);
 </script>

data/lib/foreman_nutanix/gpu_profile.rb

@@ -0,0 +1,54 @@
+module ForemanNutanix
+  # The compute profile form is a single select, so a GPU choice is stored as one
+  # composite string: "<device_id>:<vendor_name>:<gpu_type>". This module owns that
+  # format at both ends - Nutanix#available_gpus builds it, NutanixCompute#save
+  # parses it - so the two can never disagree about it.
+  #
+  # Plain Ruby, no Rails: loaded directly by the standalone tests. See test/README.md.
+  module GpuProfile
+    SEPARATOR = ':'.freeze
+    PARTS = %w[device_id vendor_name gpu_type].freeze
+
+    module_function
+
+    def blank?(value)
+      value.nil? || value.to_s.strip.empty?
+    end
+
+    # Only offer a profile that can survive the round trip: passthrough (the shim
+    # rejects VIRTUAL), and every composite part present. A profile missing one
+    # part builds a composite that #parse rejects, which would provision a VM with
+    # no GPU while reporting success.
+    def usable?(profile)
+      return false unless profile[PARTS.last].to_s.start_with?('PASSTHROUGH')
+
+      PARTS.none? { |part| blank?(profile[part]) }
+    end
+
+    def build(profile)
+      PARTS.map { |part| profile[part] }.join(SEPARATOR)
+    end
+
+    # [device_id, vendor, mode], or nil if this is not a usable composite.
+    # Caller distinguishes "nothing selected" from "malformed" by checking blank?
+    # first - the two mean very different things at provision time.
+    def parse(composite)
+      return nil if blank?(composite)
+
+      parts = composite.to_s.split(SEPARATOR, PARTS.length)
+      return nil unless parts.length == PARTS.length
+      return nil if parts.any? { |part| blank?(part) }
+
+      parts
+    end
+
+    def label(profile)
+      name = [profile['vendor_name'], profile['device_name']]
+             .reject { |part| blank?(part) }
+             .join(' ')
+      name = "GPU #{profile['device_id']}" if name.empty?
+      assignable = profile['assignable']
+      assignable.nil? ? name : "#{name} (#{assignable} assignable)"
+    end
+  end
+end

data/lib/foreman_nutanix/version.rb

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

data/lib/foreman_nutanix.rb

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

data/test/README.md

@@ -9,8 +9,9 @@ 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.
+deliberately plain Ruby (net/http, json, uri), plus a five-line `Rails.logger`
+stub. That is the whole reason the suite boots in milliseconds with nothing
+installed but minitest and rake.
 
 ## What this covers
 

data/test/gpu_profile_test.rb

@@ -0,0 +1,98 @@
+require 'test_helper'
+require 'foreman_nutanix/gpu_profile'
+
+# A profile as it arrives from the shim's /gpu-profiles endpoint.
+def profile(overrides = {})
+  {
+    'ext_id' => '0005a1b2-1111-2222-3333-444455556666',
+    'device_id' => 7864,
+    'device_name' => 'Tesla T4',
+    'vendor_name' => 'NVIDIA',
+    'gpu_type' => 'PASSTHROUGH_GRAPHICS',
+    'assignable' => 3,
+    'is_in_use' => false,
+  }.merge(overrides)
+end
+
+class GpuProfileUsableTest < Minitest::Test
+  def test_a_complete_passthrough_profile_is_usable
+    assert ForemanNutanix::GpuProfile.usable?(profile)
+    assert ForemanNutanix::GpuProfile.usable?(profile('gpu_type' => 'PASSTHROUGH_COMPUTE'))
+  end
+
+  def test_virtual_profiles_are_not_usable
+    # vGPU is rejected by the shim, so offering one would only let a user pick a
+    # provision that cannot succeed.
+    refute ForemanNutanix::GpuProfile.usable?(profile('gpu_type' => 'VIRTUAL'))
+  end
+
+  # Regression: a profile with a nil part still passed the PASSTHROUGH filter and
+  # was offered in the dropdown. Selecting it posted a composite that parse
+  # rejects, so the VM was created with NO GPU and the build reported success.
+  def test_a_profile_missing_any_composite_part_is_not_usable
+    refute ForemanNutanix::GpuProfile.usable?(profile('vendor_name' => nil))
+    refute ForemanNutanix::GpuProfile.usable?(profile('device_id' => nil))
+    refute ForemanNutanix::GpuProfile.usable?(profile('vendor_name' => '  '))
+    refute ForemanNutanix::GpuProfile.usable?(profile('gpu_type' => nil))
+  end
+
+  def test_an_entirely_empty_profile_is_not_usable
+    refute ForemanNutanix::GpuProfile.usable?({})
+  end
+
+  def test_every_usable_profile_round_trips_through_parse
+    built = ForemanNutanix::GpuProfile.build(profile)
+    assert_equal %w[7864 NVIDIA PASSTHROUGH_GRAPHICS], ForemanNutanix::GpuProfile.parse(built)
+  end
+end
+
+class GpuProfileParseTest < Minitest::Test
+  def parse(value)
+    ForemanNutanix::GpuProfile.parse(value)
+  end
+
+  def test_a_well_formed_composite_yields_three_parts
+    assert_equal %w[7864 NVIDIA PASSTHROUGH_GRAPHICS], parse('7864:NVIDIA:PASSTHROUGH_GRAPHICS')
+  end
+
+  def test_too_few_parts_are_rejected
+    assert_nil parse('7864')
+    assert_nil parse('7864:NVIDIA')
+  end
+
+  def test_blank_parts_are_rejected
+    assert_nil parse('::')
+    assert_nil parse('7864::PASSTHROUGH_GRAPHICS')
+    assert_nil parse(':NVIDIA:PASSTHROUGH_GRAPHICS')
+    assert_nil parse('7864:NVIDIA:')
+  end
+
+  def test_unselected_values_are_rejected
+    assert_nil parse(nil)
+    assert_nil parse('')
+    assert_nil parse('   ')
+  end
+
+  def test_split_caps_at_three_so_gpu_type_is_never_truncated
+    assert_equal %w[7864 NVIDIA A:B], parse('7864:NVIDIA:A:B')
+  end
+end
+
+class GpuProfileLabelTest < Minitest::Test
+  def label(overrides = {})
+    ForemanNutanix::GpuProfile.label(profile(overrides))
+  end
+
+  def test_vendor_name_and_assignable_count
+    assert_equal 'NVIDIA Tesla T4 (3 assignable)', label
+  end
+
+  def test_missing_assignable_drops_the_suffix
+    assert_equal 'NVIDIA Tesla T4', label('assignable' => nil)
+  end
+
+  def test_missing_device_name_falls_back_to_the_device_id
+    assert_equal 'NVIDIA (3 assignable)', label('device_name' => nil)
+    assert_equal 'GPU 7864 (3 assignable)', label('device_name' => nil, 'vendor_name' => nil)
+  end
+end

data/test/nutanix_compute_gpu_test.rb

@@ -0,0 +1,207 @@
+require 'test_helper'
+
+require 'ostruct'
+require_relative '../app/models/foreman_nutanix/nutanix_compute'
+
+class NutanixComputeGpuAccessorsTest < Minitest::Test
+  def build(attrs = {})
+    ForemanNutanix::NutanixCompute.new('cluster-1', { name: 'vm1' }.merge(attrs))
+  end
+
+  def test_gpu_composite_comes_from_args
+    assert_equal '7864:NVIDIA:PASSTHROUGH_GRAPHICS',
+      build(gpu: '7864:NVIDIA:PASSTHROUGH_GRAPHICS').gpu
+  end
+
+  def test_gpu_defaults_to_nil
+    assert_nil build.gpu
+  end
+
+  def test_gpu_count_comes_from_args
+    assert_equal 4, build(gpu_count: 4).gpu_count
+  end
+
+  def test_gpu_count_defaults_to_nil
+    assert_nil build.gpu_count
+  end
+
+  def test_gpu_and_gpu_count_are_writable
+    vm = build
+    vm.gpu = '7864:NVIDIA:PASSTHROUGH_COMPUTE'
+    vm.gpu_count = 2
+    assert_equal '7864:NVIDIA:PASSTHROUGH_COMPUTE', vm.gpu
+    assert_equal 2, vm.gpu_count
+  end
+end
+
+# #save posts the provision request through the private #shim memo. Seed that
+# memo with a recorder instead of reaching for the network; ShimClient itself is
+# covered separately in shim_client_test.rb.
+class FakeShimResponse
+  def success?
+    true
+  end
+
+  def json
+    { 'ext_id' => 'vm-ext-1' }
+  end
+
+  def code
+    '200'
+  end
+
+  def body
+    '{}'
+  end
+end
+
+class RecordingShim
+  attr_reader :path, :payload
+
+  def post(path, payload = nil)
+    @path = path
+    @payload = payload
+    FakeShimResponse.new
+  end
+end
+
+module GpuProvisionHelper
+  # A provision that supplies everything #save demands and nothing more.
+  BASE_ATTRS = {
+    name: 'vm1',
+    subnet_ext_id: 'subnet-1',
+    storage_container_ext_id: 'sc-1',
+    memory: 4,
+    disk_size_gb: 50,
+  }.freeze
+
+  # Exactly what the plugin posted before GPU support existed. Any drift here is
+  # a regression: a GPU-less provision must stay byte-identical.
+  PRE_GPU_PAYLOAD = {
+    name: 'vm1',
+    cluster_ext_id: 'cluster-1',
+    subnet_ext_id: 'subnet-1',
+    storage_container_ext_id: 'sc-1',
+    num_sockets: 1,
+    num_cores_per_socket: 2,
+    memory_size_bytes: 4_294_967_296,
+    disk_size_bytes: 53_687_091_200,
+    description: '',
+    secure_boot: nil,
+    boot_method: nil,
+  }.freeze
+
+  GPU_KEYS = %i[gpu_device_id gpu_vendor gpu_mode gpu_count].freeze
+
+  def provision(attrs = {})
+    vm = ForemanNutanix::NutanixCompute.new('cluster-1', BASE_ATTRS.merge(attrs))
+    shim = RecordingShim.new
+    vm.instance_variable_set(:@shim, shim)
+    vm.save
+    shim.payload
+  end
+
+end
+
+class NutanixComputeGpuPayloadTest < Minitest::Test
+  include GpuProvisionHelper
+
+  def test_no_gpu_selected_leaves_the_payload_exactly_as_it_was
+    assert_equal PRE_GPU_PAYLOAD, provision
+    assert_equal PRE_GPU_PAYLOAD.keys, provision.keys
+  end
+
+  def test_no_gpu_selected_adds_no_gpu_keys
+    payload = provision
+    GPU_KEYS.each { |key| refute_includes payload.keys, key }
+  end
+
+  def test_well_formed_composite_is_split_into_three_fields
+    payload = provision(gpu: '7864:NVIDIA:PASSTHROUGH_GRAPHICS')
+    assert_equal 7864, payload[:gpu_device_id]
+    assert_equal 'NVIDIA', payload[:gpu_vendor]
+    assert_equal 'PASSTHROUGH_GRAPHICS', payload[:gpu_mode]
+  end
+
+  def test_selecting_a_gpu_leaves_every_other_key_untouched
+    payload = provision(gpu: '7864:NVIDIA:PASSTHROUGH_GRAPHICS')
+    assert_equal PRE_GPU_PAYLOAD, payload.reject { |key, _| GPU_KEYS.include?(key) }
+  end
+end
+
+class NutanixComputeGpuCountTest < Minitest::Test
+  include GpuProvisionHelper
+
+  GPU = '7864:NVIDIA:PASSTHROUGH_GRAPHICS'.freeze
+
+  def test_count_defaults_to_one_when_a_gpu_is_selected_without_one
+    assert_equal 1, provision(gpu: GPU)[:gpu_count]
+  end
+
+  def test_count_defaults_to_one_when_the_hidden_field_posts_empty
+    assert_equal 1, provision(gpu: GPU, gpu_count: '')[:gpu_count]
+    assert_equal 1, provision(gpu: GPU, gpu_count: nil)[:gpu_count]
+  end
+
+  def test_an_explicit_count_is_carried_through
+    assert_equal 3, provision(gpu: GPU, gpu_count: 3)[:gpu_count]
+  end
+
+  def test_a_string_count_from_the_form_is_coerced
+    assert_equal 3, provision(gpu: GPU, gpu_count: '3')[:gpu_count]
+  end
+
+  def test_a_nonsensical_count_still_provisions_the_selected_gpu
+    assert_equal 1, provision(gpu: GPU, gpu_count: 0)[:gpu_count]
+    assert_equal 1, provision(gpu: GPU, gpu_count: -2)[:gpu_count]
+  end
+end
+
+class NutanixComputeMalformedGpuCompositeTest < Minitest::Test
+  include GpuProvisionHelper
+
+  # A composite that did not survive the round trip must omit the GPU entirely.
+  # Provisioning against half a GPU spec is worse than provisioning without one.
+  def assert_no_gpu_fields(gpu)
+    payload = provision(gpu: gpu)
+    GPU_KEYS.each do |key|
+      refute_includes payload.keys, key, "expected #{gpu.inspect} to contribute no #{key}"
+    end
+    assert_equal PRE_GPU_PAYLOAD, payload
+  end
+
+  # Unselected: no GPU fields, no error. This is what an untouched dropdown posts.
+  def test_unselected_values_contribute_no_gpu_fields
+    assert_no_gpu_fields ''
+    assert_no_gpu_fields '   '
+    assert_no_gpu_fields nil
+  end
+
+  # Selected but malformed: raise. Silently building a GPU-less VM and reporting
+  # success is the worst available outcome, and matches how a missing network or
+  # storage container already behaves in #save.
+  def assert_raises_on(gpu)
+    error = assert_raises(StandardError) { provision(gpu: gpu) }
+    assert_match(/Malformed GPU selection/, error.message)
+  end
+
+  def test_too_few_parts_raise
+    assert_raises_on '7864'
+    assert_raises_on '7864:NVIDIA'
+  end
+
+  def test_blank_parts_raise
+    assert_raises_on '::'
+    assert_raises_on '7864::PASSTHROUGH_GRAPHICS'
+    assert_raises_on ':NVIDIA:PASSTHROUGH_GRAPHICS'
+    assert_raises_on '7864:NVIDIA:'
+  end
+
+  # split(':', 3) caps at three, so a gpu_type is never truncated by a stray
+  # colon further right.
+  def test_extra_colons_stay_with_the_gpu_type
+    payload = provision(gpu: '7864:NVIDIA:PASSTHROUGH_GRAPHICS:EXTRA')
+    assert_equal 'PASSTHROUGH_GRAPHICS:EXTRA', payload[:gpu_mode]
+    assert_equal 'NVIDIA', payload[:gpu_vendor]
+  end
+end

data/test/nutanix_compute_test.rb

@@ -1,14 +1,5 @@
 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'
 

data/test/test_helper.rb

@@ -1,5 +1,15 @@
 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.
+# Standalone: no Rails, no Foreman, no database. See test/README.md for what
+# that rules out.
 require 'foreman_nutanix/shim_client'
+
+# NutanixCompute is a plain object, but it logs in nearly every method. This is
+# the whole of the Rails surface the suite needs; it lives here rather than in
+# one test file so a second file defining it cannot redefine the first's.
+require 'logger'
+module Rails
+  def self.logger
+    @logger ||= Logger.new(IO::NULL)
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: foreman_nutanix
 version: !ruby/object:Gem::Version
-  version: 0.1.5
+  version: 0.1.6
 platform: ruby
 authors:
 - Miles Granger
@@ -54,12 +54,15 @@ files:
 - config/routes.rb
 - lib/foreman_nutanix.rb
 - lib/foreman_nutanix/engine.rb
+- lib/foreman_nutanix/gpu_profile.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/gpu_profile_test.rb
+- test/nutanix_compute_gpu_test.rb
 - test/nutanix_compute_test.rb
 - test/shim_client_test.rb
 - test/test_helper.rb
@@ -101,6 +104,8 @@ specification_version: 4
 summary: Nutanix plugin for Foreman
 test_files:
 - test/README.md
+- test/gpu_profile_test.rb
+- test/nutanix_compute_gpu_test.rb
 - test/nutanix_compute_test.rb
 - test/shim_client_test.rb
 - test/test_helper.rb