foreman_nutanix 0.1.4 → 0.1.6

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.6'.freeze
 end

data/lib/foreman_nutanix.rb

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

data/test/README.md

@@ -0,0 +1,46 @@
+# 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), 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
+
+`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/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

@@ -0,0 +1,62 @@
+require 'test_helper'
+
+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