morpheus-cli 9.0.1 → 9.1.0

data/lib/morpheus/cli/mixins/infrastructure_helper.rb

@@ -21,6 +21,11 @@ module Morpheus::Cli::InfrastructureHelper
     @clouds_interface
   end
 
+  def clusters_interface
+    raise "#{self.class} has not defined @clusters_interface" if @clusters_interface.nil?
+    @clusters_interface
+  end
+
   def networks_interface
     # @api_client.networks
     raise "#{self.class} has not defined @networks_interface" if @networks_interface.nil?
@@ -166,11 +171,11 @@ module Morpheus::Cli::InfrastructureHelper
 
   # Networks
 
-  def find_network_by_name_or_id(val)
+  def find_network_by_name_or_id(val, include_tenants=false)
     if val.to_s =~ /\A\d{1,}\Z/
       return find_network_by_id(val)
     else
-      return find_network_by_name(val)
+      return find_network_by_name(val, include_tenants)
     end
   end
 
@@ -188,8 +193,10 @@ module Morpheus::Cli::InfrastructureHelper
     end
   end
 
-  def find_network_by_name(name)
-    json_response = networks_interface.list({name: name.to_s})
+  def find_network_by_name(name, include_tenants=false)
+    params = {name: name.to_s}
+    params['includeTenants'] = true if include_tenants
+    json_response = networks_interface.list(params)
     networks = json_response['networks']
     if networks.empty?
       print_red_alert "Network not found by name #{name}"
@@ -412,6 +419,138 @@ module Morpheus::Cli::InfrastructureHelper
     end
   end
 
+  # Resolve a cloud-owned vSphere cluster: a ComputeZonePool with type='Cluster'
+  # that belongs to the given cloud. This is distinct from a Morpheus managed
+  # cluster (ComputeServerGroup, resolved via ClustersInterface / /api/clusters).
+  #
+  # MORPH-17279: --cloud CLOUD --cluster CLUSTER must resolve CLUSTER within
+  # CLOUD's own resource pools, not the top-level managed-cluster namespace.
+  # `cloud` is the already-resolved cloud Hash (from find_cloud_by_name_or_id).
+  def find_resource_pool_cluster_by_name_or_id(cloud, val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_resource_pool_cluster_by_id(cloud, val)
+    else
+      return find_resource_pool_cluster_by_name(cloud, val)
+    end
+  end
+
+  def find_resource_pool_cluster_by_id(cloud, id)
+    begin
+      # Scoped to the cloud so the server itself verifies pool ownership --
+      # ZoneResourcePoolsController#show 404s when the pool's zone does not
+      # match the requested cloud.
+      json_response = resource_pools_interface.get(cloud['id'], id.to_i)
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Cluster not found by id #{id} in cloud '#{cloud['name']}'"
+        return nil
+      else
+        raise e
+      end
+    end
+    resource_pool = json_response['resourcePool']
+    if resource_pool.nil?
+      print_red_alert "Cluster not found by id #{id} in cloud '#{cloud['name']}'"
+      return nil
+    end
+    if resource_pool['type'].to_s != 'Cluster'
+      print_red_alert "Resource pool #{id} in cloud '#{cloud['name']}' is a '#{resource_pool['type'] || 'unknown'}' resource pool, not a Cluster"
+      return nil
+    end
+    return resource_pool
+  end
+
+  def find_resource_pool_cluster_by_name(cloud, name)
+    json_response = resource_pools_interface.list(cloud['id'], {name: name.to_s, type: 'Cluster'})
+    # The cloud-scoped resource-pools endpoint returns a pool *tree*, backfilling
+    # ancestor folder pools so the hierarchy renders correctly. Ancestors do not
+    # satisfy our name/type filter, so re-filter here rather than trusting the
+    # raw result size for ambiguity detection.
+    resource_pools = (json_response['resourcePools'] || []).select do |it|
+      it['type'].to_s == 'Cluster' && (it['name'].to_s == name.to_s || it['displayName'].to_s == name.to_s)
+    end
+    if resource_pools.empty?
+      print_red_alert "Cluster not found by name '#{name}' in cloud '#{cloud['name']}'.\n" \
+        "To look up a Morpheus managed cluster instead, use --cluster '#{name}' without --cloud."
+      return nil
+    elsif resource_pools.size > 1
+      print_red_alert "#{resource_pools.size} clusters found by name '#{name}' in cloud '#{cloud['name']}'. Use a numeric cluster id instead."
+      rows = resource_pools.collect do |it|
+        {id: it['id'], name: it['name']}
+      end
+      puts as_pretty_table(rows, [:id, :name], {color:red})
+      return nil
+    else
+      return resource_pools[0]
+    end
+  end
+
+  def find_managed_cluster_by_name_or_id(val, report_not_found=true)
+    cluster = nil
+    if val.to_s =~ /\A\d{1,}\Z/
+      begin
+        cluster = clusters_interface.get(val.to_i)['cluster']
+      rescue RestClient::Exception => e
+        raise e unless e.response && e.response.code == 404
+      end
+    else
+      clusters = clusters_interface.list({name: val})['clusters'] || []
+      if clusters.size > 1
+        print_red_alert "#{clusters.size} managed clusters found by name '#{val}'. Use a numeric cluster id instead."
+        rows = clusters.collect {|it| {id: it['id'], name: it['name']} }
+        puts as_pretty_table(rows, [:id, :name], {color:red})
+        return nil
+      end
+      cluster = clusters[0]
+    end
+    if cluster.nil? && report_not_found
+      print_red_alert "Managed cluster not found by name or id '#{val}'.\n" \
+        "If '#{val}' is a vSphere cluster owned by a cloud, use --cloud CLOUD --cluster #{val} instead."
+    end
+    cluster
+  end
+
+  def find_cluster_list_scope_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      cluster = find_managed_cluster_by_name_or_id(val)
+      return cluster ? {type: :managed_cluster, cluster: cluster} : nil
+    end
+
+    managed_clusters = clusters_interface.list({name: val})['clusters'] || []
+    if managed_clusters.size > 1
+      print_red_alert "#{managed_clusters.size} managed clusters found by name '#{val}'. Use a numeric cluster id instead."
+      rows = managed_clusters.collect {|it| {id: it['id'], name: it['name']} }
+      puts as_pretty_table(rows, [:id, :name], {color:red})
+      return nil
+    elsif managed_clusters.size == 1
+      return {type: :managed_cluster, cluster: managed_clusters[0]}
+    end
+
+    json_response = resource_pools_interface.list_without_cloud({name: val.to_s, type: 'Cluster', max: 1000})
+    resource_pools = (json_response['resourcePools'] || []).select do |it|
+      it['type'].to_s == 'Cluster' && (it['name'].to_s == val.to_s || it['displayName'].to_s == val.to_s)
+    end
+    if resource_pools.empty?
+      print_red_alert "No managed or vSphere cluster found by name '#{val}'."
+      return nil
+    elsif resource_pools.size > 1
+      print_red_alert "#{resource_pools.size} vSphere clusters found by name '#{val}'. Use --cloud CLOUD --cluster #{val} to disambiguate."
+      rows = resource_pools.collect do |it|
+        {id: it['id'], name: it['name'], cloud: it['zone'] && it['zone']['name']}
+      end
+      puts as_pretty_table(rows, [:id, :name, :cloud], {color:red})
+      return nil
+    end
+
+    resource_pool = resource_pools[0]
+    cloud = resource_pool['zone']
+    if cloud.nil? || cloud['id'].nil?
+      print_red_alert "vSphere cluster '#{val}' does not include its owning cloud."
+      return nil
+    end
+    {type: :cloud_pool, cloud: cloud, pool: resource_pool}
+  end
+
   def find_resource_pool_group_by_name_or_id(val)
     if val.to_s =~ /\A\d{1,}\Z/
       return find_resource_pool_group_by_id(val)

data/lib/morpheus/cli/option_types.rb

@@ -1501,13 +1501,48 @@ module Morpheus
       end
 
       def self.sort_option_types(option_types)
-        if option_types.find {|it| it['fieldGroup'] || it['displayOrder'] }
+        sorted = if option_types.find {|it| it['fieldGroup'] || it['displayOrder'] }
           option_types.select {|it| (it['fieldGroup'] || 'default').casecmp?('default')}.sort {|a,b| a['displayOrder'].to_i <=> b['displayOrder'].to_i} +
           option_types.reject {|it| ['default', 'advanced'].include?((it['fieldGroup'] || 'default').downcase)}.sort{|a,b| a['displayOrder'] <=> b['displayOrder']}.group_by{|it| it['fieldGroup']}.values.collect { |it| it.sort{|a,b| a['displayOrder'].to_i <=> b['displayOrder'].to_i}}.flatten +
           option_types.select {|it| 'advanced'.casecmp?(it['fieldGroup'])}.sort {|a,b| a['displayOrder'].to_i <=> b['displayOrder'].to_i}
         else
           option_types
         end
+        reorder_option_type_dependencies(sorted)
+      end
+
+      # displayOrder alone can put a field ahead of another field it depends on
+      # via dependsOnCode/visibleOnCode (eg. a hidden, optionSource-populated field
+      # with a high displayOrder that a lower displayOrder field is gated on). Move
+      # any depended-upon option type ahead of the option type(s) that depend on it,
+      # preserving displayOrder order otherwise.
+      def self.reorder_option_type_dependencies(option_types)
+        field_key_for = lambda {|it| it['fieldContext'].to_s.empty? ? it['fieldName'].to_s : "#{it['fieldContext']}.#{it['fieldName']}" }
+        depends_on_codes_for = lambda {|option_type|
+          depends_value = option_type['visibleOnCode'].to_s.empty? ? option_type['dependsOnCode'] : option_type['visibleOnCode']
+          next [] if depends_value.to_s.empty? || depends_value == 'networkInterfaces'
+          depends_value = depends_value[(depends_value.index('::') + 2)..-1] if depends_value.include?('::')
+          depends_value.to_s.sub(',', ' ').split(' ').collect {|value| value.split(':')[0] }
+        }
+        result = option_types.dup
+        passes = 0
+        changed = true
+        while changed && passes < result.size
+          changed = false
+          passes += 1
+          result.each_with_index do |option_type, i|
+            depends_on_codes_for.call(option_type).each do |depends_on_code|
+              dep_index = result.index {|it| it['code'] == depends_on_code || field_key_for.call(it) == depends_on_code }
+              if dep_index && dep_index > i
+                result.insert(i, result.delete_at(dep_index))
+                changed = true
+                break
+              end
+            end
+            break if changed
+          end
+        end
+        result
       end
 
       def self.display_select_options(opt, select_options = [], paging = nil)

data/lib/morpheus/cli/version.rb

@@ -1,6 +1,6 @@
 
 module Morpheus
   module Cli
-    VERSION = "9.0.1"
+    VERSION = "9.1.0"
   end
 end

data/test/api/affinity_groups_interface_test.rb

@@ -0,0 +1,43 @@
+require 'test/unit'
+$LOAD_PATH.unshift(File.expand_path('../../lib', __dir__))
+require 'morpheus/api/affinity_groups_interface'
+
+class AffinityGroupsInterfaceTest < Test::Unit::TestCase
+
+  def setup
+    @affinity_groups_interface = Morpheus::AffinityGroupsInterface.new(access_token: 'token', url: 'https://example.test', verify_ssl: false)
+  end
+
+  def test_get_builds_bearer_authorization_header
+    request = @affinity_groups_interface.dry.get(123, details: true)
+    assert_equal :get, request[:method]
+    assert_equal 'https://example.test/api/affinity-groups/123', request[:url]
+    assert_equal({details: true}, request[:headers][:params])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+  def test_update_builds_bearer_authorization_header
+    request = @affinity_groups_interface.dry.update(123, {name: 'rule-a'})
+    assert_equal :put, request[:method]
+    assert_equal 'https://example.test/api/affinity-groups/123', request[:url]
+    assert_equal({name: 'rule-a'}.to_json, request[:payload])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+  def test_destroy_builds_bearer_authorization_header
+    request = @affinity_groups_interface.dry.destroy(123, force: true)
+    assert_equal :delete, request[:method]
+    assert_equal 'https://example.test/api/affinity-groups/123', request[:url]
+    assert_equal({force: true}, request[:headers][:params])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+  def test_violations_builds_bearer_authorization_header
+    request = @affinity_groups_interface.dry.violations(scope: 'cloud')
+    assert_equal :get, request[:method]
+    assert_equal 'https://example.test/api/affinity-groups/violations', request[:url]
+    assert_equal({scope: 'cloud'}, request[:headers][:params])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+end

data/test/api/clouds_interface_test.rb

@@ -0,0 +1,67 @@
+require 'test/unit'
+$LOAD_PATH.unshift(File.expand_path('../../lib', __dir__))
+require 'morpheus/api/clouds_interface'
+
+class CloudsInterfaceTest < Test::Unit::TestCase
+
+  def setup
+    @clouds_interface = Morpheus::CloudsInterface.new(access_token: 'token', url: 'https://example.test', verify_ssl: false)
+  end
+
+  def test_affinity_group_form_options_builds_bearer_authorization_header
+    request = @clouds_interface.dry.affinity_group_form_options(59, phase: 'create')
+    assert_equal :get, request[:method]
+    assert_equal 'https://example.test/api/zones/59/affinity-groups/form-options', request[:url]
+    assert_equal({phase: 'create'}, request[:headers][:params])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+  def test_list_host_vm_groups_builds_bearer_authorization_header
+    request = @clouds_interface.dry.list_host_vm_groups(59, phrase: 'group')
+    assert_equal :get, request[:method]
+    assert_equal 'https://example.test/api/zones/59/host-vm-groups', request[:url]
+    assert_equal({phrase: 'group'}, request[:headers][:params])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+  def test_get_host_vm_group_builds_bearer_authorization_header
+    request = @clouds_interface.dry.get_host_vm_group(59, 415, details: true)
+    assert_equal :get, request[:method]
+    assert_equal 'https://example.test/api/zones/59/host-vm-groups/415', request[:url]
+    assert_equal({details: true}, request[:headers][:params])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+  def test_create_host_vm_group_builds_bearer_authorization_header
+    request = @clouds_interface.dry.create_host_vm_group(59, {name: 'group-a'})
+    assert_equal :post, request[:method]
+    assert_equal 'https://example.test/api/zones/59/host-vm-groups', request[:url]
+    assert_equal({name: 'group-a'}.to_json, request[:payload])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+  def test_update_host_vm_group_builds_bearer_authorization_header
+    request = @clouds_interface.dry.update_host_vm_group(59, 415, {name: 'group-b'})
+    assert_equal :put, request[:method]
+    assert_equal 'https://example.test/api/zones/59/host-vm-groups/415', request[:url]
+    assert_equal({name: 'group-b'}.to_json, request[:payload])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+  def test_destroy_host_vm_group_builds_bearer_authorization_header
+    request = @clouds_interface.dry.destroy_host_vm_group(59, 415, force: true)
+    assert_equal :delete, request[:method]
+    assert_equal 'https://example.test/api/zones/59/host-vm-groups/415', request[:url]
+    assert_equal({force: true}, request[:headers][:params])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+  def test_host_vm_group_form_options_builds_bearer_authorization_header
+    request = @clouds_interface.dry.host_vm_group_form_options(59, scope: 'qa')
+    assert_equal :get, request[:method]
+    assert_equal 'https://example.test/api/zones/59/host-vm-groups/form-options', request[:url]
+    assert_equal({scope: 'qa'}, request[:headers][:params])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+end

data/test/api/host_vm_groups_interface_test.rb

@@ -0,0 +1,35 @@
+require 'test/unit'
+$LOAD_PATH.unshift(File.expand_path('../../lib', __dir__))
+require 'morpheus/api/host_vm_groups_interface'
+
+class HostVmGroupsInterfaceTest < Test::Unit::TestCase
+
+  def setup
+    @host_vm_groups_interface = Morpheus::HostVmGroupsInterface.new(access_token: 'token', url: 'https://example.test', verify_ssl: false)
+  end
+
+  def test_get_builds_bearer_authorization_header
+    request = @host_vm_groups_interface.dry.get(415, details: true)
+    assert_equal :get, request[:method]
+    assert_equal 'https://example.test/api/host-vm-groups/415', request[:url]
+    assert_equal({details: true}, request[:headers][:params])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+  def test_update_builds_bearer_authorization_header
+    request = @host_vm_groups_interface.dry.update(415, {name: 'group-a'})
+    assert_equal :put, request[:method]
+    assert_equal 'https://example.test/api/host-vm-groups/415', request[:url]
+    assert_equal({name: 'group-a'}.to_json, request[:payload])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+  def test_destroy_builds_bearer_authorization_header
+    request = @host_vm_groups_interface.dry.destroy(415, force: true)
+    assert_equal :delete, request[:method]
+    assert_equal 'https://example.test/api/host-vm-groups/415', request[:url]
+    assert_equal({force: true}, request[:headers][:params])
+    assert_equal 'Bearer token', request[:headers][:authorization]
+  end
+
+end

data/test/cli/affinity_groups_cloud_cluster_scope_test.rb

@@ -0,0 +1,270 @@
+require 'test/unit'
+require 'stringio'
+require 'json'
+require 'morpheus'
+
+# Command-level offline exercise of the MORPH-17279 --cloud + --cluster
+# (vSphere cluster) scope for AffinityGroupsCommand and HostVmGroupsCommand
+# list/add. Runs the real command methods end-to-end (option parsing, scope
+# resolution, --dry-run request construction) against fake interfaces, so no
+# live appliance or credentials are required.
+#
+# This complements infrastructure_helper_cluster_resolver_test.rb (which
+# unit-tests the resolver in isolation) by proving the resolved pool actually
+# flows into list (poolId query param) and add (pool.id in the create
+# payload), exactly as it would against a real appliance.
+class AffinityGroupsCloudClusterScopeTest < Test::Unit::TestCase
+
+  # Fake for Morpheus::CloudsInterface -- records every call, answers cloud
+  # name/id lookups, and answers .dry.* calls with a print_dry_run-compatible
+  # request hash (mirrors how Morpheus::APIClient#dry / #execute behave).
+  class FakeCloudsInterface
+    attr_reader :calls
+
+    def initialize(cloud:)
+      @cloud = cloud
+      @calls = []
+      @dry = false
+    end
+
+    def setopts(options); self; end
+    def dry; @dry = true; self; end
+
+    def get(id, params = {})
+      @calls << [:get, id, params]
+      {'zone' => @cloud}
+    end
+
+    def list(params = {})
+      @calls << [:list, params]
+      {'zones' => [@cloud]}
+    end
+
+    def list_affinity_groups(id, params = {})
+      @calls << [:list_affinity_groups, id, params]
+      respond({'affinityGroups' => []}) { {method: :get, url: "/api/zones/#{id}/affinity-groups", params: params} }
+    end
+
+    def create_affinity_group(id, payload)
+      @calls << [:create_affinity_group, id, payload]
+      respond({'affinityGroup' => {'id' => 1}}) { {method: :post, url: "/api/zones/#{id}/affinity-groups", payload: payload.to_json} }
+    end
+
+    def affinity_group_form_options(id, params = {})
+      @calls << [:affinity_group_form_options, id, params]
+      {'supportsCombinedRules' => true, 'availableVmGroups' => [], 'availableHostGroups' => []}
+    end
+
+    def list_host_vm_groups(id, params = {})
+      @calls << [:list_host_vm_groups, id, params]
+      respond({'hostVmGroups' => []}) { {method: :get, url: "/api/zones/#{id}/host-vm-groups", params: params} }
+    end
+
+    def create_host_vm_group(id, payload)
+      @calls << [:create_host_vm_group, id, payload]
+      respond({'hostVmGroup' => {'id' => 1}}) { {method: :post, url: "/api/zones/#{id}/host-vm-groups", payload: payload.to_json} }
+    end
+
+    def host_vm_group_form_options(id, params = {})
+      @calls << [:host_vm_group_form_options, id, params]
+      {'availableServers' => []}
+    end
+
+    private
+
+    def respond(real_result)
+      @dry ? yield : real_result
+    end
+  end
+
+  # Fake for Morpheus::CloudResourcePoolsInterface -- used by
+  # find_resource_pool_cluster_by_name_or_id.
+  class FakeResourcePoolsInterface
+    attr_reader :calls
+
+    def initialize(pool:)
+      @pool = pool
+      @calls = []
+    end
+
+    def get(cloud_id, id, params = {})
+      @calls << [:get, cloud_id, id, params]
+      {'resourcePool' => @pool}
+    end
+
+    def list(cloud_id, params = {})
+      @calls << [:list, cloud_id, params]
+      {'resourcePools' => [@pool]}
+    end
+
+    def list_without_cloud(params = {})
+      @calls << [:list_without_cloud, params]
+      {'resourcePools' => [@pool]}
+    end
+  end
+
+  class FakeClustersInterface
+    attr_reader :calls
+
+    def initialize(clusters: [])
+      @clusters = clusters
+      @calls = []
+      @dry = false
+    end
+
+    def setopts(options); self; end
+    def dry; @dry = true; self; end
+
+    def get(id, params = {})
+      @calls << [:get, id, params]
+      {'cluster' => @clusters.find {|cluster| cluster['id'].to_i == id.to_i}}
+    end
+
+    def list(params = {})
+      @calls << [:list, params]
+      {'clusters' => @clusters.select {|cluster| cluster['name'] == params[:name]}}
+    end
+
+    def list_affinity_groups(id, params = {})
+      @calls << [:list_affinity_groups, id, params]
+      respond({'affinityGroups' => []}) { {method: :get, url: "/api/clusters/#{id}/affinity-groups", params: params} }
+    end
+
+    def list_host_vm_groups(id, params = {})
+      @calls << [:list_host_vm_groups, id, params]
+      respond({'hostVmGroups' => []}) { {method: :get, url: "/api/clusters/#{id}/host-vm-groups", params: params} }
+    end
+
+    private
+
+    def respond(real_result)
+      @dry ? yield : real_result
+    end
+  end
+
+  def cloud
+    {'id' => 59, 'name' => 'vCenter Cloud'}
+  end
+
+  def pool
+    {'id' => 501, 'name' => 'QA', 'type' => 'Cluster', 'zone' => {'id' => 59, 'name' => 'vCenter Cloud'}}
+  end
+
+  def build_affinity_command(managed_clusters: [])
+    cmd = Morpheus::Cli::AffinityGroupsCommand.new
+    fake_clouds = FakeCloudsInterface.new(cloud: cloud)
+    fake_pools = FakeResourcePoolsInterface.new(pool: pool)
+    fake_clusters = FakeClustersInterface.new(clusters: managed_clusters)
+    cmd.define_singleton_method(:connect) do |opts|
+      instance_variable_set(:@affinity_groups_interface, nil)
+      instance_variable_set(:@clouds_interface, fake_clouds)
+      instance_variable_set(:@clusters_interface, fake_clusters)
+      instance_variable_set(:@cloud_resource_pools_interface, fake_pools)
+    end
+    [cmd, fake_clouds, fake_pools, fake_clusters]
+  end
+
+  def build_host_vm_command(managed_clusters: [])
+    cmd = Morpheus::Cli::HostVmGroupsCommand.new
+    fake_clouds = FakeCloudsInterface.new(cloud: cloud)
+    fake_pools = FakeResourcePoolsInterface.new(pool: pool)
+    fake_clusters = FakeClustersInterface.new(clusters: managed_clusters)
+    cmd.define_singleton_method(:connect) do |opts|
+      instance_variable_set(:@host_vm_groups_interface, nil)
+      instance_variable_set(:@clouds_interface, fake_clouds)
+      instance_variable_set(:@clusters_interface, fake_clusters)
+      instance_variable_set(:@cloud_resource_pools_interface, fake_pools)
+    end
+    [cmd, fake_clouds, fake_pools, fake_clusters]
+  end
+
+  def capture_stdout
+    terminal = Morpheus::Terminal.instance
+    original = terminal.stdout
+    buffer = StringIO.new
+    terminal.set_stdout(buffer)
+    yield
+    buffer.string
+  ensure
+    terminal.set_stdout(original)
+  end
+
+  ## AffinityGroupsCommand
+
+  def test_affinity_groups_list_cloud_cluster_combo_sends_pool_id
+    cmd, _fake_clouds, fake_pools, _fake_clusters = build_affinity_command
+    output = capture_stdout { cmd.list(['--cloud', 'vCenter Cloud', '--cluster', 'QA', '--dry-run']) }
+    assert_match(/poolId=501/, output, "dry-run request must carry the resolved poolId, got: #{output}")
+    assert_match(%r{/api/zones/59/affinity-groups}, output)
+    # Name resolution stayed scoped to the cloud and to type=Cluster.
+    assert_equal [[:list, 59, {name: 'QA', type: 'Cluster'}]], fake_pools.calls
+  end
+
+  def test_affinity_groups_add_cloud_cluster_combo_sets_pool_id_payload
+    cmd, fake_clouds, _fake_pools, _fake_clusters = build_affinity_command
+    payload_json = '{"affinityGroup":{"name":"cli-test","affinityType":"KEEP_TOGETHER","servers":[{"id":1}]}}'
+    output = capture_stdout do
+      cmd.add(['--cloud', 'vCenter Cloud', '--cluster', 'QA', '--payload-json', payload_json, '--dry-run'])
+    end
+    assert_match(%r{/api/zones/59/affinity-groups}, output, "must POST to the zone endpoint, not a cluster endpoint")
+    create_call = fake_clouds.calls.find {|c| c[0] == :create_affinity_group }
+    assert_not_nil create_call, "create_affinity_group must be called on the clouds interface"
+    payload = create_call[2].is_a?(String) ? JSON.parse(create_call[2]) : create_call[2]
+    assert_equal({'id' => 501}, payload['affinityGroup']['pool'])
+    assert_nil payload['affinityGroup']['cloudId']
+    assert_nil payload['affinityGroup']['clusterId']
+  end
+
+  def test_affinity_groups_list_cluster_name_falls_back_to_unique_vsphere_cluster
+    cmd, _fake_clouds, fake_pools, fake_clusters = build_affinity_command
+    output = capture_stdout { cmd.list(['--cluster', 'QA', '--dry-run']) }
+    assert_match(%r{/api/zones/59/affinity-groups}, output)
+    assert_match(/poolId=501/, output)
+    assert_equal [[:list, {name: 'QA'}]], fake_clusters.calls
+    assert_equal [[:list_without_cloud, {name: 'QA', type: 'Cluster', max: 1000}]], fake_pools.calls
+  end
+
+  def test_affinity_groups_list_cluster_name_preserves_managed_cluster_precedence
+    managed_cluster = {'id' => 8, 'name' => 'QA'}
+    cmd, _fake_clouds, fake_pools, fake_clusters = build_affinity_command(managed_clusters: [managed_cluster])
+    output = capture_stdout { cmd.list(['--cluster', 'QA', '--dry-run']) }
+    assert_match(%r{/api/clusters/8/affinity-groups}, output)
+    assert_equal [[:list, {name: 'QA'}], [:list_affinity_groups, 8, {}]], fake_clusters.calls
+    assert_empty fake_pools.calls
+  end
+
+  ## HostVmGroupsCommand
+
+  def test_host_vm_groups_list_cloud_cluster_combo_sends_pool_id
+    cmd, _fake_clouds, fake_pools, _fake_clusters = build_host_vm_command
+    output = capture_stdout { cmd.list(['--cloud', 'vCenter Cloud', '--cluster', 'QA', '--dry-run']) }
+    assert_match(/poolId=501/, output, "dry-run request must carry the resolved poolId, got: #{output}")
+    assert_match(%r{/api/zones/59/host-vm-groups}, output)
+    assert_equal [[:list, 59, {name: 'QA', type: 'Cluster'}]], fake_pools.calls
+  end
+
+  def test_host_vm_groups_add_cloud_cluster_combo_sets_pool_id_payload
+    cmd, fake_clouds, _fake_pools, _fake_clusters = build_host_vm_command
+    payload_json = '{"hostVmGroup":{"name":"cli-test","type":"HOST_GROUP","servers":[{"id":1}]}}'
+    output = capture_stdout do
+      cmd.add(['--cloud', 'vCenter Cloud', '--cluster', 'QA', '--payload-json', payload_json, '--dry-run'])
+    end
+    assert_match(%r{/api/zones/59/host-vm-groups}, output, "must POST to the zone endpoint, not a cluster endpoint")
+    create_call = fake_clouds.calls.find {|c| c[0] == :create_host_vm_group }
+    assert_not_nil create_call, "create_host_vm_group must be called on the clouds interface"
+    payload = create_call[2].is_a?(String) ? JSON.parse(create_call[2]) : create_call[2]
+    assert_equal({'id' => 501}, payload['hostVmGroup']['pool'])
+    assert_nil payload['hostVmGroup']['cloudId']
+    assert_nil payload['hostVmGroup']['clusterId']
+  end
+
+  def test_host_vm_groups_list_cluster_name_falls_back_to_unique_vsphere_cluster
+    cmd, _fake_clouds, fake_pools, fake_clusters = build_host_vm_command
+    output = capture_stdout { cmd.list(['--cluster', 'QA', '--dry-run']) }
+    assert_match(%r{/api/zones/59/host-vm-groups}, output)
+    assert_match(/poolId=501/, output)
+    assert_equal [[:list, {name: 'QA'}]], fake_clusters.calls
+    assert_equal [[:list_without_cloud, {name: 'QA', type: 'Cluster', max: 1000}]], fake_pools.calls
+  end
+
+end