morpheus-cli 9.0.1 → 9.1.0

data/test/cli/clusters_uuid_test.rb

@@ -0,0 +1,131 @@
+require 'test/unit'
+require 'stringio'
+require 'morpheus'
+
+# Unit tests for MORPH-15042: cluster uuid support in the clusters command.
+#   - clusters get UUID resolves a single cluster via the path endpoint
+#     (/api/clusters/{uuid}), not the name query filter.
+#   - clusters list --uuid UUID [--uuid UUID ...] filters by one or more uuids.
+#
+# These follow the established pure-unit pattern (a fake ClustersInterface
+# recording calls; Test::Unit::TestCase, no appliance/auth required). See
+# test/cli/affinity_groups_cluster_scope_test.rb for the pattern this mirrors.
+class ClustersUuidTest < Test::Unit::TestCase
+  # Records every call so tests can assert exactly what the command requested.
+  class FakeClustersInterface
+    attr_reader :get_calls, :list_calls
+
+    def initialize(clusters: [], get_result: nil)
+      @clusters = clusters
+      @get_result = get_result
+      @get_calls = []
+      @list_calls = []
+      @dry = false
+    end
+
+    def setopts(_options)
+      self
+    end
+
+    def dry
+      @dry = true
+      self
+    end
+
+    def get(arg)
+      @get_calls << arg
+      @get_result || {'cluster' => {'id' => 42, 'name' => 'k8s-1'}}
+    end
+
+    def list(params = {})
+      @list_calls << params
+      return {method: :get, url: '/api/clusters', params: params} if @dry
+      {'clusters' => @clusters.select {|c| c['name'] == params[:name] }}
+    end
+  end
+
+  def setup
+    @uuid = 'a1b2c3d4-e5f6-4711-8899-0011223344ff'
+  end
+
+  ## find_cluster_by_name_or_id dispatch
+
+  def test_uuid_resolves_via_path_get_not_name_list
+    command, clusters = build_command
+    cluster = command.send(:find_cluster_by_name_or_id, @uuid)
+    assert_equal 42, cluster['id']
+    # The uuid is handed to get as a String path segment, never a name list.
+    assert_equal [@uuid], clusters.get_calls
+    assert_empty clusters.list_calls
+  end
+
+  def test_numeric_id_still_resolves_via_path_get
+    command, clusters = build_command
+    command.send(:find_cluster_by_name_or_id, '7')
+    assert_equal [7], clusters.get_calls
+    assert_empty clusters.list_calls
+  end
+
+  def test_name_still_resolves_via_list_by_name
+    managed = {'id' => 9, 'name' => 'prod'}
+    command, clusters = build_command([managed])
+    cluster = command.send(:find_cluster_by_name_or_id, 'prod')
+    assert_equal 9, cluster['id']
+    assert_equal [{name: 'prod'}], clusters.list_calls
+    assert_empty clusters.get_calls
+  end
+
+  def test_cluster_uuid_predicate
+    command, = build_command
+    assert command.send(:cluster_uuid?, @uuid)
+    assert command.send(:cluster_uuid?, @uuid.upcase)
+    assert !command.send(:cluster_uuid?, '7')
+    assert !command.send(:cluster_uuid?, 'prod')
+    assert !command.send(:cluster_uuid?, 'a1b2c3d4-e5f6-4711-8899-0011223344')
+  end
+
+  ## clusters list --uuid
+
+  def test_list_with_single_uuid_carries_uuid_param
+    command, = build_command
+    output = capture_stdout { command.list(['--uuid', @uuid, '--dry-run']) }
+    assert_match(/#{Regexp.escape(@uuid)}/, output)
+  end
+
+  def test_list_with_multiple_uuids_carries_all_uuids
+    command, = build_command
+    other = 'ffeeddcc-bbaa-4998-8776-655443322110'
+    output = capture_stdout { command.list(['--uuid', @uuid, '--uuid', other, '--dry-run']) }
+    assert_match(/#{Regexp.escape(@uuid)}/, output)
+    assert_match(/#{Regexp.escape(other)}/, output)
+  end
+
+  def test_list_without_uuid_has_no_uuid_param
+    command, = build_command
+    output = capture_stdout { command.list(['--dry-run']) }
+    assert_no_match(/uuid/i, output)
+  end
+
+  private
+
+  def build_command(managed_clusters = [], get_result: nil)
+    clusters = FakeClustersInterface.new(clusters: managed_clusters, get_result: get_result)
+    command = Morpheus::Cli::Clusters.new
+    command.instance_variable_set(:@clusters_interface, clusters)
+    command.define_singleton_method(:connect) do |_options|
+      @clusters_interface = clusters
+    end
+    [command, 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
+end

data/test/cli/distributed_workers_test.rb

@@ -0,0 +1,68 @@
+require 'morpheus_test'
+
+# Tests for Morpheus::Cli::DistributedWorkers
+class MorpheusTest::DistributedWorkersTest < MorpheusTest::TestCase
+
+  def test_distributed_workers_list
+    assert_execute %(distributed-workers list)
+  end
+
+  def test_distributed_workers_crud
+    worker_name = "cli-test-dw-#{rand(1000000)}"
+    created_id = nil
+    begin
+      # add and capture output to assert the apiKey is surfaced once
+      add_output = capture_stdout do
+        assert_execute %(distributed-workers add "#{worker_name}" --description "cli test worker" --enabled -N)
+      end
+      created_id = client.distributed_workers.list({name: worker_name})['distributedWorkers'].first['id']
+      assert_not_nil created_id, "Expected distributed worker to be created"
+
+      api_key = client.distributed_workers.list({name: worker_name})['distributedWorkers'].first['apiKey']
+      assert_nil api_key, "Expected apiKey to be omitted from list responses"
+      assert_match(/API Key/i, add_output, "Expected add output to surface the API Key")
+
+      # appears in list
+      assert_match(/#{Regexp.escape(worker_name)}/, capture_stdout { assert_execute %(distributed-workers list --json) })
+
+      # get by id and by name, apiKey must not be shown
+      get_output = capture_stdout do
+        assert_execute %(distributed-workers get "#{created_id}")
+        assert_execute %(distributed-workers get "#{escape_arg worker_name}")
+      end
+      refute_match(/API Key/i, get_output, "Expected get output to omit the API Key")
+
+      # update the description
+      assert_execute %(distributed-workers update "#{created_id}" --description "updated description")
+      updated = client.distributed_workers.get(created_id)['distributedWorker']
+      assert_equal "updated description", updated['description']
+
+      # remove and confirm it is gone
+      assert_execute %(distributed-workers remove "#{created_id}" -y)
+      assert_empty client.distributed_workers.list({name: worker_name})['distributedWorkers'],
+        "Expected distributed worker to be removed"
+      created_id = nil
+    ensure
+      if created_id
+        begin
+          client.distributed_workers.destroy(created_id)
+        rescue => e
+          puts "Failed to clean up distributed worker #{created_id}: #{e.message}"
+        end
+      end
+    end
+  end
+
+  protected
+
+  def capture_stdout
+    original = terminal.stdout
+    buffer = StringIO.new
+    terminal.set_stdout(buffer)
+    yield
+    buffer.string
+  ensure
+    terminal.set_stdout(original)
+  end
+
+end

data/test/cli/host_vm_groups_cluster_scope_test.rb

@@ -0,0 +1,187 @@
+require 'test/unit'
+require 'stringio'
+require 'morpheus'
+
+# Command-level offline exercise of the MORPH-17279 --cluster scope for
+# HostVmGroupsCommand#list. Parallels affinity_groups_cluster_scope_test.rb:
+# a bare --cluster name must resolve either to a managed cluster (POST/GET under
+# /api/clusters/{id}/...) or, failing that, fall back to a cloud-owned vSphere
+# cluster (ComputeZonePool type=Cluster) and scope the zone request with poolId.
+# A name that matches neither must fail loudly, not exit 1 silently.
+class HostVmGroupsClusterScopeTest < Test::Unit::TestCase
+  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_host_vm_groups(id, params = {})
+      @calls << [:list_host_vm_groups, id, params]
+      return {'hostVmGroups' => []} unless @dry
+
+      {method: :get, url: "/api/zones/#{id}/host-vm-groups", params: params}
+    end
+  end
+
+  class FakeResourcePoolsInterface
+    attr_reader :calls
+
+    def initialize(pools)
+      @pools = pools
+      @calls = []
+    end
+
+    def get(cloud_id, id, params = {})
+      @calls << [:get, cloud_id, id, params]
+      {'resourcePool' => @pools.find {|p| p['id'].to_i == id.to_i }}
+    end
+
+    def list(cloud_id, params = {})
+      @calls << [:list, cloud_id, params]
+      {'resourcePools' => @pools}
+    end
+
+    def list_without_cloud(params = {})
+      @calls << [:list_without_cloud, params]
+      {'resourcePools' => @pools}
+    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 list(params = {})
+      @calls << [:list, params]
+      {'clusters' => @clusters.select {|cluster| cluster['name'] == params[:name]}}
+    end
+
+    def list_host_vm_groups(id, params = {})
+      @calls << [:list_host_vm_groups, id, params]
+      return {'hostVmGroups' => []} unless @dry
+
+      {method: :get, url: "/api/clusters/#{id}/host-vm-groups", params: params}
+    end
+  end
+
+  def setup
+    @cloud = {'id' => 59, 'name' => 'vCenter Cloud'}
+    @pool = {
+      'id' => 501,
+      'name' => 'QA',
+      'type' => 'Cluster',
+      'zone' => @cloud
+    }
+  end
+
+  def test_cluster_name_falls_back_to_unique_vsphere_cluster
+    command, pools, clusters = build_command
+
+    output = capture_stdout { command.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'}]], clusters.calls
+    assert_equal [
+      [:list_without_cloud, {name: 'QA', type: 'Cluster', max: 1000}]
+    ], pools.calls
+  end
+
+  def test_managed_cluster_takes_precedence
+    managed_cluster = {'id' => 8, 'name' => 'QA'}
+    command, pools, clusters = build_command([managed_cluster])
+
+    output = capture_stdout { command.list(['--cluster', 'QA', '--dry-run']) }
+
+    assert_match(%r{/api/clusters/8/host-vm-groups}, output)
+    assert_equal [
+      [:list, {name: 'QA'}],
+      [:list_host_vm_groups, 8, {}]
+    ], clusters.calls
+    assert_empty pools.calls
+  end
+
+  def test_unknown_cluster_name_fails_loudly
+    command, _pools, _clusters = build_command([], [])
+
+    result = nil
+    err = capture_stderr do
+      capture_stdout { result = command.list(['--cluster', 'nope', '--dry-run']) }
+    end
+
+    assert_equal 1, (result.is_a?(Array) ? result[0] : result)
+    assert_match(/No managed or vSphere cluster found by name 'nope'/i, err)
+  end
+
+  private
+
+  def build_command(managed_clusters = [], pools = nil)
+    pools = [@pool] if pools.nil?
+    clouds = FakeCloudsInterface.new(@cloud)
+    pools_interface = FakeResourcePoolsInterface.new(pools)
+    clusters = FakeClustersInterface.new(managed_clusters)
+    command = Morpheus::Cli::HostVmGroupsCommand.new
+    command.define_singleton_method(:connect) do |_options|
+      @clouds_interface = clouds
+      @clusters_interface = clusters
+      @cloud_resource_pools_interface = pools_interface
+    end
+    [command, pools_interface, 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
+
+  def capture_stderr
+    original = $stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.string
+  ensure
+    $stderr = original
+  end
+end

data/test/cli/host_vm_groups_test.rb

@@ -0,0 +1,63 @@
+require 'morpheus_test'
+
+# Tests for Morpheus::Cli::HostVmGroupsCommand and the cloud-scoped
+# host-vm-group subcommands added to Morpheus::Cli::Clouds for MORPH-16326.
+#
+# Scope note: these cover only client-side behaviour -- help output and argument
+# validation -- both of which resolve before any API call is made.
+#
+# Tests that would exercise list/get/add/update/remove against the appliance are
+# deliberately omitted until the /api/host-vm-groups request and response
+# contract is confirmed against the MORPH-14136 / MORPH-16074 server work.
+class MorpheusTest::HostVmGroupsTest < MorpheusTest::TestCase
+
+  def test_host_vm_groups_help
+    assert_execute %(host-vm-groups --help)
+    assert_execute %(host-vm-groups list --help)
+    assert_execute %(host-vm-groups get --help)
+    assert_execute %(host-vm-groups add --help)
+    assert_execute %(host-vm-groups update --help)
+    assert_execute %(host-vm-groups remove --help)
+  end
+
+  # The cloud-scoped subcommands must be registered on the clouds command.
+  def test_clouds_host_vm_group_subcommands_help
+    assert_execute %(clouds list-host-vm-groups --help)
+    assert_execute %(clouds get-host-vm-group --help)
+    assert_execute %(clouds add-host-vm-group --help)
+    assert_execute %(clouds update-host-vm-group --help)
+    assert_execute %(clouds remove-host-vm-group --help)
+  end
+
+  ## Argument validation (fails during option parsing, before any request)
+
+  def test_host_vm_groups_unknown_subcommand
+    assert_error %(host-vm-groups nonsense-subcommand)
+  end
+
+  def test_host_vm_groups_get_requires_an_id
+    assert_error %(host-vm-groups get)
+  end
+
+  def test_host_vm_groups_remove_requires_an_id
+    assert_error %(host-vm-groups remove -y)
+  end
+
+  def test_clouds_list_host_vm_groups_requires_a_cloud
+    assert_error %(clouds list-host-vm-groups)
+  end
+
+  def test_clouds_get_host_vm_group_requires_both_args
+    assert_error %(clouds get-host-vm-group 1)
+  end
+
+  # No unscoped list/create route at /api/host-vm-groups.
+  def test_host_vm_groups_list_requires_a_scope
+    assert_error %(host-vm-groups list)
+  end
+
+  def test_host_vm_groups_add_requires_a_scope
+    assert_error %(host-vm-groups add --name cli-test --dry-run)
+  end
+
+end

data/test/cli/infrastructure_helper_cluster_resolver_test.rb

@@ -0,0 +1,250 @@
+require 'test/unit'
+require 'stringio'
+require 'json'
+require 'morpheus'
+
+# Unit tests for the MORPH-17279 cloud-owned vSphere cluster resolver added to
+# Morpheus::Cli::InfrastructureHelper:
+#   find_resource_pool_cluster_by_name_or_id / _by_id / _by_name
+#
+# These are pure unit tests against a fake CloudResourcePoolsInterface. They
+# deliberately do NOT extend MorpheusTest::TestCase because they require no
+# appliance, no remote and no authentication - they must always be runnable.
+# See test/cli/affinity_helper_test.rb for the established pattern this
+# follows.
+#
+# Bug context: --cloud CLOUD --cluster CLUSTER must resolve CLUSTER as a
+# ComputeZonePool(type='Cluster') owned by CLOUD, distinct from the managed
+# cluster (ComputeServerGroup) namespace resolved via ClustersInterface. A
+# name lookup that traverses ambiguous, wrong-cloud or wrong-type pools must
+# fail loudly instead of returning nil silently or the wrong pool.
+class InfrastructureHelperClusterResolverTest < Test::Unit::TestCase
+
+  # Fake standing in for Morpheus::CloudResourcePoolsInterface. Records every
+  # call so tests can assert exactly what was requested, mirroring the
+  # dry-run request assertions used elsewhere in this suite.
+  class FakeResourcePoolsInterface
+    attr_reader :get_calls, :list_calls
+
+    def initialize(get_result: nil, get_error: nil, list_result: nil)
+      @get_result = get_result
+      @get_error = get_error
+      @list_result = list_result
+      @get_calls = []
+      @list_calls = []
+    end
+
+    def get(cloud_id, id, params = {})
+      @get_calls << [cloud_id, id, params]
+      raise @get_error if @get_error
+      @get_result
+    end
+
+    def list(cloud_id, params = {})
+      @list_calls << [cloud_id, params]
+      @list_result
+    end
+  end
+
+  class FakeClustersInterface
+    def initialize(get_result: nil, get_error: nil, list_result: nil)
+      @get_result = get_result
+      @get_error = get_error
+      @list_result = list_result || {'clusters' => []}
+    end
+
+    def get(id)
+      raise @get_error if @get_error
+      @get_result
+    end
+
+    def list(params = {})
+      @list_result
+    end
+  end
+
+  # Bare host for the mixin under test.
+  class HelperHost
+    include Morpheus::Cli::InfrastructureHelper
+
+    def initialize(fake_interface, clusters_interface=nil)
+      @cloud_resource_pools_interface = fake_interface
+      @clusters_interface = clusters_interface if clusters_interface
+    end
+  end
+
+  def fake_not_found_error
+    response = Object.new
+    def response.code; 404; end
+    RestClient::Exception.new(response)
+  end
+
+  def fake_server_error
+    response = Object.new
+    def response.code; 500; end
+    RestClient::Exception.new(response)
+  end
+
+  def cloud
+    {'id' => 59, 'name' => 'vCenter Cloud'}
+  end
+
+  # print_red_alert writes straight to $stderr (print_helper.rb) - capture it.
+  def capture_stderr
+    original = $stderr
+    $stderr = StringIO.new
+    yield
+    $stderr.string
+  ensure
+    $stderr = original
+  end
+
+  ## find_resource_pool_cluster_by_id
+
+  def test_find_by_id_returns_the_pool_when_it_is_a_cluster_in_the_cloud
+    fake = FakeResourcePoolsInterface.new(get_result: {
+      'resourcePool' => {'id' => 501, 'name' => 'QA', 'type' => 'Cluster', 'zone' => {'id' => 59, 'name' => 'vCenter Cloud'}}
+    })
+    helper = HelperHost.new(fake)
+    pool = helper.find_resource_pool_cluster_by_id(cloud, 501)
+    assert_not_nil pool
+    assert_equal 501, pool['id']
+    assert_equal 'QA', pool['name']
+    # Scoped to the cloud -- the server itself enforces ownership.
+    assert_equal [[59, 501, {}]], fake.get_calls
+  end
+
+  # ZoneResourcePoolsController#show 404s when the pool's zone does not match
+  # the requested cloud -- this is the server-side cloud-ownership check.
+  def test_find_by_id_reports_not_found_on_404_without_raising
+    fake = FakeResourcePoolsInterface.new(get_error: fake_not_found_error)
+    helper = HelperHost.new(fake)
+    pool = nil
+    output = capture_stderr { pool = helper.find_resource_pool_cluster_by_id(cloud, 999) }
+    assert_nil pool
+    assert_match(/not found by id 999/i, output)
+    assert_match(/vCenter Cloud/, output)
+  end
+
+  # A non-404 failure (auth, server error, etc.) must not be swallowed as a
+  # not-found -- that would hide a real problem behind a wrong error message.
+  def test_find_by_id_reraises_non_404_errors
+    fake = FakeResourcePoolsInterface.new(get_error: fake_server_error)
+    helper = HelperHost.new(fake)
+    assert_raise(RestClient::Exception) { helper.find_resource_pool_cluster_by_id(cloud, 501) }
+  end
+
+  def test_find_by_id_rejects_a_non_cluster_resource_pool
+    fake = FakeResourcePoolsInterface.new(get_result: {
+      'resourcePool' => {'id' => 501, 'name' => 'Folder A', 'type' => 'ResourcePool', 'zone' => {'id' => 59, 'name' => 'vCenter Cloud'}}
+    })
+    helper = HelperHost.new(fake)
+    pool = nil
+    output = capture_stderr { pool = helper.find_resource_pool_cluster_by_id(cloud, 501) }
+    assert_nil pool
+    assert_match(/not a Cluster/i, output)
+    assert_match(/ResourcePool/, output)
+  end
+
+  ## find_resource_pool_cluster_by_name
+
+  def test_find_by_name_returns_the_single_match
+    fake = FakeResourcePoolsInterface.new(list_result: {
+      'resourcePools' => [
+        {'id' => 501, 'name' => 'QA', 'type' => 'Cluster'},
+      ]
+    })
+    helper = HelperHost.new(fake)
+    pool = helper.find_resource_pool_cluster_by_name(cloud, 'QA')
+    assert_not_nil pool
+    assert_equal 501, pool['id']
+    assert_equal [[59, {name: 'QA', type: 'Cluster'}]], fake.list_calls
+  end
+
+  def test_find_by_name_matches_on_display_name
+    fake = FakeResourcePoolsInterface.new(list_result: {
+      'resourcePools' => [
+        {'id' => 501, 'name' => 'internal-qa-01', 'displayName' => 'QA', 'type' => 'Cluster'},
+      ]
+    })
+    helper = HelperHost.new(fake)
+    pool = helper.find_resource_pool_cluster_by_name(cloud, 'QA')
+    assert_not_nil pool
+    assert_equal 501, pool['id']
+  end
+
+  def test_find_by_name_reports_not_found_with_a_managed_cluster_hint
+    fake = FakeResourcePoolsInterface.new(list_result: {'resourcePools' => []})
+    helper = HelperHost.new(fake)
+    pool = nil
+    output = capture_stderr { pool = helper.find_resource_pool_cluster_by_name(cloud, 'QA') }
+    assert_nil pool
+    assert_match(/not found by name 'QA'/i, output)
+    assert_match(/vCenter Cloud/, output)
+    assert_match(/--cluster 'QA' without --cloud/, output)
+  end
+
+  # The cloud-scoped resource-pools endpoint returns a pool *tree*: when the
+  # matched pool has a parent folder, ancestor entries are backfilled into the
+  # result so the hierarchy renders, even though they do not match the
+  # name/type filter. The resolver must not misreport this as ambiguity.
+  def test_find_by_name_ignores_ancestor_tree_padding
+    fake = FakeResourcePoolsInterface.new(list_result: {
+      'resourcePools' => [
+        {'id' => 10, 'name' => 'Datacenter Folder', 'type' => 'Folder', 'depth' => 0},
+        {'id' => 501, 'name' => 'QA', 'type' => 'Cluster', 'depth' => 1},
+      ]
+    })
+    helper = HelperHost.new(fake)
+    pool = helper.find_resource_pool_cluster_by_name(cloud, 'QA')
+    assert_not_nil pool, "the ancestor folder must not be counted as a second match"
+    assert_equal 501, pool['id']
+  end
+
+  def test_find_by_name_reports_ambiguity_with_candidates_and_requires_numeric_id
+    fake = FakeResourcePoolsInterface.new(list_result: {
+      'resourcePools' => [
+        {'id' => 501, 'name' => 'QA', 'type' => 'Cluster'},
+        {'id' => 502, 'name' => 'QA', 'type' => 'Cluster'},
+      ]
+    })
+    helper = HelperHost.new(fake)
+    pool = nil
+    output = capture_stderr { pool = helper.find_resource_pool_cluster_by_name(cloud, 'QA') }
+    assert_nil pool
+    assert_match(/2 clusters found by name 'QA'/i, output)
+    assert_match(/numeric cluster id/i, output)
+  end
+
+  ## find_resource_pool_cluster_by_name_or_id dispatch
+
+  def test_find_by_name_or_id_dispatches_numeric_strings_to_by_id
+    fake = FakeResourcePoolsInterface.new(get_result: {
+      'resourcePool' => {'id' => 501, 'name' => 'QA', 'type' => 'Cluster', 'zone' => {'id' => 59}}
+    })
+    helper = HelperHost.new(fake)
+    pool = helper.find_resource_pool_cluster_by_name_or_id(cloud, '501')
+    assert_not_nil pool
+    assert_equal 1, fake.get_calls.size
+    assert_equal 0, fake.list_calls.size
+  end
+
+  def test_find_by_name_or_id_dispatches_non_numeric_strings_to_by_name
+    fake = FakeResourcePoolsInterface.new(list_result: {
+      'resourcePools' => [{'id' => 501, 'name' => 'QA', 'type' => 'Cluster'}]
+    })
+    helper = HelperHost.new(fake)
+    pool = helper.find_resource_pool_cluster_by_name_or_id(cloud, 'QA')
+    assert_not_nil pool
+    assert_equal 0, fake.get_calls.size
+    assert_equal 1, fake.list_calls.size
+  end
+
+  def test_managed_cluster_lookup_reraises_non_404_errors
+    pools = FakeResourcePoolsInterface.new
+    clusters = FakeClustersInterface.new(get_error: fake_server_error)
+    helper = HelperHost.new(pools, clusters)
+    assert_raise(RestClient::Exception) { helper.find_managed_cluster_by_name_or_id('8') }
+  end
+
+end