morpheus-cli 9.0.2 → 9.1.0

data/test/cli/backups_test.rb

@@ -0,0 +1,212 @@
+require 'test/unit'
+$LOAD_PATH.unshift(File.expand_path('../../lib', __dir__))
+require 'morpheus'
+require 'morpheus/cli/commands/backups_command'
+
+# Tests for Morpheus::Cli::BackupsCommand
+#
+# These tests focus on the human-readable backup detail rendering, which is
+# pure formatting logic and does not require a live appliance. The detail view
+# should prefer the nested API object names (backupType.name, backupProvider.name,
+# storageProvider.name) and only fall back to legacy tag labels when absent.
+class BackupsCommandTest < Test::Unit::TestCase
+  class RecordingBackupsInterface
+    attr_reader :created_payload
+
+    def initialize(backup_type_code)
+      @backup_type_code = backup_type_code
+    end
+
+    def setopts(_options)
+    end
+
+    def create_options(_payload)
+      {
+        'containers' => [{'id' => 101, 'name' => 'web'}],
+        'backupTypes' => [{'code' => @backup_type_code, 'name' => 'Test Backup Type'}],
+        'backup' => {},
+        'backupSettings' => {},
+      }
+    end
+
+    def create(payload)
+      @created_payload = Marshal.load(Marshal.dump(payload))
+      {'success' => true, 'backup' => {'id' => 99, 'name' => payload.dig('backup', 'name')}}
+    end
+  end
+
+  class RecordingOptionsInterface
+    attr_reader :requests
+
+    def initialize(plugin_option_types)
+      @plugin_option_types = plugin_option_types
+      @requests = []
+    end
+
+    def options_for_source(source, params)
+      @requests << [source, params]
+      option_types = source == 'backupOptionTypes' ? @plugin_option_types : []
+      {'success' => true, 'data' => {'optionTypes' => option_types}}
+    end
+  end
+
+  class OfflineInstancesInterface
+    def list(_params)
+      {'instances' => [{'id' => 7, 'name' => 'test-instance'}]}
+    end
+  end
+
+  class OfflineBackupsCommand < Morpheus::Cli::BackupsCommand
+    attr_reader :backups_interface, :options_interface
+
+    def initialize(backup_type_code, plugin_option_types)
+      @backup_type_code = backup_type_code
+      @plugin_option_types = plugin_option_types
+    end
+
+    def connect(_options)
+      @api_client = Object.new
+      @backups_interface = RecordingBackupsInterface.new(@backup_type_code)
+      @options_interface = RecordingOptionsInterface.new(@plugin_option_types)
+      @instances_interface = OfflineInstancesInterface.new
+      @servers_interface = Object.new
+      @backup_jobs_interface = Object.new
+    end
+  end
+
+  def command
+    @command ||= Morpheus::Cli::BackupsCommand.new
+  end
+
+  # snapshot backup with nested backupType/backupProvider/storageProvider names
+  def sample_backup
+    {
+      'id' => 132614,
+      'name' => 'vmware-snapshot-backup',
+      'backupType' => {'id' => 13, 'code' => 'vmwareSnapshot', 'name' => 'VMware VM Snapshot'},
+      'backupProvider' => {'id' => 543, 'code' => 'morpheus', 'name' => 'Internal Backup'},
+      'storageProvider' => {'id' => 194, 'name' => 'Local Backups'},
+    }
+  end
+
+  def test_backup_detail_prefers_nested_names
+    columns = command.send(:backup_column_definitions)
+    backup = sample_backup
+    assert_equal 'VMware VM Snapshot', columns['Backup Type'].call(backup)
+    assert_equal 'Internal Backup', columns['Backup Provider'].call(backup)
+    assert_equal 'Local Backups', columns['Storage Provider'].call(backup)
+  end
+
+  # when backupType.name is absent, fall back to the legacy POLICY/MANUAL tag
+  def test_backup_type_falls_back_to_legacy_tag
+    columns = command.send(:backup_column_definitions)
+    manual_backup = {'id' => 1, 'name' => 'manual'}
+    assert_match(/MANUAL/, columns['Backup Type'].call(manual_backup))
+
+    policy_backup = {'id' => 2, 'name' => 'policy', 'job' => {'id' => 5}}
+    assert_match(/POLICY/, columns['Backup Type'].call(policy_backup))
+  end
+
+  # location tag should render the provider name instead of empty parens
+  def test_backup_location_tag_uses_provider_name
+    tag = command.send(:format_backup_location_tag, sample_backup)
+    assert_match(/REMOTE/, tag)
+    assert_match(/Local Backups/, tag)
+    refute_match(/\(\)/, tag)
+  end
+
+  def test_add_continues_when_backup_type_has_no_plugin_options
+    add_command = OfflineBackupsCommand.new('vmwareSnapshot', [])
+
+    with_backup_add_prompts('vmwareSnapshot') do
+      assert_equal [0, nil], add_command.add(['--quiet'])
+    end
+
+    backup_payload = add_command.backups_interface.created_payload['backup']
+    assert_equal 'vmwareSnapshot', backup_payload['backupType']
+    assert_equal 'addTo', backup_payload['jobAction']
+    assert_equal 44, backup_payload['jobId']
+    assert_equal ['backupOptionTypes', {'backupTypeCode' => 'vmwareSnapshot'}], add_command.options_interface.requests.first
+  end
+
+  def test_add_flattens_plugin_domain_options_into_backup_payload
+    plugin_option_types = [
+      {
+        'fieldName' => 'pluginTarget',
+        'fieldLabel' => 'Plugin Target',
+        'fieldContext' => 'domain',
+        'type' => 'text',
+        'required' => true,
+      },
+    ]
+    add_command = OfflineBackupsCommand.new('pluginBackup', plugin_option_types)
+
+    with_backup_add_prompts('pluginBackup', {'backup' => {'pluginTarget' => 'archive'}}) do
+      assert_equal [0, nil], add_command.add(['--quiet'])
+    end
+
+    backup_payload = add_command.backups_interface.created_payload['backup']
+    assert_equal 'archive', backup_payload['pluginTarget']
+    assert_false backup_payload.key?('backup')
+  end
+
+  def test_add_continues_when_all_plugin_options_are_skipped
+    plugin_option_types = [
+      {
+        'fieldName' => 'pluginTarget',
+        'fieldLabel' => 'Plugin Target',
+        'fieldContext' => 'domain',
+        'type' => 'text',
+        'required' => false,
+        'dependsOnCode' => 'missingToggle:on',
+      },
+    ]
+    add_command = OfflineBackupsCommand.new('conditionalPluginBackup', plugin_option_types)
+
+    with_backup_add_prompts('conditionalPluginBackup') do
+      assert_equal [0, nil], add_command.add(['--quiet'])
+    end
+
+    backup_payload = add_command.backups_interface.created_payload['backup']
+    assert_equal 'conditionalPluginBackup', backup_payload['backupType']
+    assert_equal 44, backup_payload['jobId']
+    assert_false backup_payload.key?('pluginTarget')
+  end
+
+  private
+
+  def with_backup_add_prompts(backup_type_code, plugin_values = {})
+    original_prompt = Morpheus::Cli::OptionTypes.method(:prompt)
+    Morpheus::Cli::OptionTypes.define_singleton_method(:prompt) do |option_types, options = {}, api_client = nil, *args|
+      if option_types.any? {|option_type| option_type['fieldContext'] == 'domain'}
+        prompt_options = options.deep_merge(plugin_values).merge(:no_prompt => true)
+        original_prompt.call(option_types, prompt_options, api_client, *args)
+      else
+        field_name = option_types.first && option_types.first['fieldName']
+        case field_name
+        when 'source'
+          {'source' => 'instance'}
+        when 'instanceId'
+          {'instanceId' => 7}
+        when 'name'
+          {'name' => 'offline-backup'}
+        when 'containerId'
+          {'containerId' => 101}
+        when 'backupType'
+          {'backupType' => backup_type_code}
+        when 'jobAction'
+          {'jobAction' => 'addTo'}
+        when 'jobId'
+          {'jobId' => 44}
+        when nil
+          {}
+        else
+          raise "Unexpected option prompt for #{field_name}"
+        end
+      end
+    end
+    yield
+  ensure
+    Morpheus::Cli::OptionTypes.define_singleton_method(:prompt, original_prompt)
+  end
+end

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