mtncloud-cli 1.0.0

data/test/cli/cli_test.rb

@@ -0,0 +1,48 @@
+require 'mtncloud_test'
+
+# Tests for top level CLI functionality
+class MtnCloudTest::CliTest < MtnCloudTest::TestCase
+  
+  def requires_remote
+    false
+  end
+
+  def requires_authentication
+    false
+  end
+
+  def test_cli_no_arguments
+  	assert_error("")
+  end
+
+  def test_cli_unknown_command
+    assert_error("unknown_command")
+  end
+
+  def test_cli_unknown_subcommand
+    assert_error("instances unknown_subcommand")
+  end
+
+  def test_cli_version_option
+    assert_execute("-v")
+    assert_execute("--version")
+  end
+
+  def test_cli_nocolor
+    assert_execute("version -C")
+    assert_execute("echo -C \"disable coloring with the -C option\"")
+    # todo: fix bug here that makes this persist for all subsequent terminal commands
+    # this re-enavbles it for remainder of tests
+    # assert_execute("coloring on?")
+    assert_execute("coloring off?")
+    assert_execute("coloring")
+  end
+
+  # HelpTest handles this now..
+  # def test_help
+  #   assert_execute("help")
+  # 	assert_execute("-h")
+  # 	assert_execute("--help")
+  # end
+
+end

data/test/cli/clients_test.rb

@@ -0,0 +1,45 @@
+require 'mtncloud_test'
+
+class MtnCloudTest::ClientsTest < MtnCloudTest::TestCase
+  
+  def test_clients_list
+    assert_execute %(clients list)
+    assert_execute %(clients list "System Admin")
+  end
+
+  # def test_clients_get_system_admin
+  #   assert_execute %(clients get "System Admin")
+  #   assert_execute %(clients get "System Admin" --permissions)
+  # end
+
+  def test_clients_get
+    record = client.clients.list({})['clients'][0]
+    if record
+      assert_execute %(clients get "#{record['id']}")
+      name_arg = record['clientId']
+      assert_execute %(clients get "#{escape_arg name_arg}")
+    else
+      puts "No client found, unable to execute test `#{__method__}`"
+    end
+  end
+
+  def test_clients_get_morph_cli
+    assert_execute %(clients get morph-cli)
+  end
+
+  # todo: test all the other commands
+
+  # def test_clients_add
+  #   assert_execute %(clients add "test_client_#{random_id}" -N)
+  # end
+
+  # def test_clients_update
+  #   #skip "Test needs to be added"
+  #   assert_execute %(clients update "test_client_#{random_id}" --description "neat")
+  # end
+
+  # def test_clients_remove
+  #   assert_execute %(clients remove "test_client_#{random_id}" -y")
+  # end
+
+end

data/test/cli/clusters_uuid_test.rb

@@ -0,0 +1,146 @@
+require 'test/unit'
+require 'stringio'
+require 'mtncloud'
+
+# 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
+
+  def test_get_help_documents_multiple_cluster_identifiers
+    command, clusters = build_command
+    output = capture_stdout do
+      error = assert_raise(SystemExit) { command.get(['--help']) }
+      assert_equal 0, error.status
+    end
+    assert_match(/Usage: mtncloud clusters get \[cluster\.\.\.\]/, output)
+    assert_include output, 'Get details about one or more clusters.'
+    assert_include output, 'At least one [cluster] is required.'
+    assert_include output, 'Each identifier can be an id, name, or uuid.'
+    assert_include output, 'Supports 1-N [cluster] arguments.'
+    assert_empty clusters.get_calls
+    assert_empty clusters.list_calls
+  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 = MtnCloud::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 = MtnCloud::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/containers_test.rb

@@ -0,0 +1,92 @@
+require 'mtncloud_test'
+require 'test_data_helper'
+
+# Tests for MtnCloud::Cli::Containers
+class MtnCloudTest::ContainersTest < MtnCloudTest::TestCase
+  
+  include MtnCloudTest::TestDataHelper  
+
+  def setup()
+    super
+    #load_container_test_data()
+  end
+
+  def test_containers_get
+    id = find_first_container_id()
+    assert_execute %(containers get #{id})
+  end
+
+  # todo: need to wait and refresh status for this to work well
+  
+=begin
+  def test_containers_get_many
+    ids = find_many_container_ids().take(5)
+    assert_execute %(containers get #{ids.join(' ')})
+  end
+
+  def test_containers_stop
+    with_input ["n", "y"] do
+      assert_execute %(containers stop #{@id}), exit_code: 9
+      assert_execute %(containers stop #{@id})
+    end
+  end
+
+  def test_containers_start
+    with_input ["n", "y"] do
+      assert_execute %(containers start #{@id}), exit_code: 9
+      assert_execute %(containers start #{@id})
+    end
+  end
+
+  def test_containers_restart
+    with_input ["n", "y"] do
+      assert_execute %(containers restart #{@id}), exit_code: 9
+      assert_execute %(containers restart #{@id})
+    end
+  end
+
+  def test_containers_suspend
+    with_input ["n", "y"] do
+      assert_execute %(containers suspend #{@id}), exit_code: 9
+      assert_execute %(containers suspend #{@id})
+    end
+  end
+
+  def test_containers_eject
+    with_input ["n", "y"] do
+      assert_execute %(containers eject #{@id}), exit_code: 9
+      assert_execute %(containers eject #{@id})
+    end
+  end
+=end
+
+  def test_containers_actions
+    @id = find_first_container_id()
+    assert_execute %(containers actions #{@id})
+  end
+
+=begin
+  # do not run random actions for now
+  # def test_containers_action
+  #   #action_code = "docker-remove-node"
+  #   action = client.containers.available_actions(@id)['actions'].first
+  #   assert action.is_a?(Hash),  "Expected to find an action to run"
+  #   action_code = action['code']
+  #   assert_execute %(containers action #{@id} -a #{action_code} -y)
+  # end
+
+  def test_containers_import
+    with_input ["n", "y"] do
+      assert_execute %(containers import #{@id} -N), exit_code: 9
+      assert_execute %(containers import #{@id} -N)
+    end
+  end
+
+  def test_containers_clone_image
+    with_input ["n", "y"] do
+      assert_execute %(containers clone-image #{@id} -N), exit_code: 9
+      assert_execute %(containers clone-image #{@id} -N)
+    end
+  end
+=end
+end

data/test/cli/distributed_workers_test.rb

@@ -0,0 +1,68 @@
+require 'mtncloud_test'
+
+# Tests for MtnCloud::Cli::DistributedWorkers
+class MtnCloudTest::DistributedWorkersTest < MtnCloudTest::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/help_test.rb

@@ -0,0 +1,25 @@
+require 'mtncloud_test'
+
+# Tests for help command and global --help option
+class MtnCloudTest::HelpTest < MtnCloudTest::TestCase
+  
+  def requires_authentication
+    false
+  end
+
+  def test_help
+  	assert_execute %(help)
+  	assert_execute %(-h)
+  	assert_execute %(--help)
+  end
+
+  def test_subcommand_help
+  	assert_execute %(remote --help)
+  	assert_execute %(remote -h)
+  	assert_execute %(remote use --help)
+    assert_execute %(instances list --help)
+  	assert_execute %(whoami --help)
+  	assert_execute %(whoami -h)
+  end
+
+end

data/test/cli/host_vm_groups_cluster_scope_test.rb

@@ -0,0 +1,187 @@
+require 'test/unit'
+require 'stringio'
+require 'mtncloud'
+
+# 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 = MtnCloud::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 = MtnCloud::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 'mtncloud_test'
+
+# Tests for MtnCloud::Cli::HostVmGroupsCommand and the cloud-scoped
+# host-vm-group subcommands added to MtnCloud::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 MtnCloudTest::HostVmGroupsTest < MtnCloudTest::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