morpheus-cli 5.5.2.2 → 5.5.3.1

data/test/cli/shell_test.rb

@@ -0,0 +1,81 @@
+require 'morpheus_test'
+
+class MorpheusTest::ShellTest < MorpheusTest::TestCase
+
+  def requires_remote
+    false
+  end
+
+  def requires_authentication
+    false
+  end
+
+  # class << self
+  #   def startup
+  #     # one time use remote and login at beginning of testsuite, not each method
+  #     use_remote()
+  #     login()
+  #   end
+  # end
+
+  # def test_remote_use
+  #   # use remote needed for all except test_shell_clean() , todo: exclude paradigm that yet..
+  #   use_remote()
+  # end
+
+  def test_shell
+    with_input "exit"  do
+      assert_execute "shell"
+    end
+  end
+
+  def test_shell_verbose
+    login_if_needed()
+    with_input "whoami", "exit" do
+      assert_execute "shell -V"
+    end
+  end
+
+  def test_shell_history
+    with_input "history", "exit" do
+      assert_execute "shell"
+    end
+  end
+
+  def test_shell_sleep
+    with_input "echo \"It is time for a rest.\"", "sleep 0.5", "echo \"OK, let's keep testing\"", "exit" do
+      assert_execute "shell -V"
+    end
+  end
+
+  def test_shell_temporary
+    with_input "remote list", "remote current", "echo this is a temporary shell with no history", "history", "exit" do
+      assert_execute "shell -Z -V"
+    end
+  end
+
+  def test_shell_confirmation
+    with_input "access-token refresh", "I'm not sure...", "no", "exit" do
+      assert_execute "shell -Z -V"
+    end
+  end
+
+# todo: fix bug where appliances are not restored after clean shell.. so remote use #{@config.remote_name}" starts failing here..
+=begin
+  def test_shell_clean
+    with_input "echo this is a clean shell with no remotes or history", "remote list", "remote current", "history", "exit" do
+      assert_execute "shell -z"
+    end
+    with_input "echo this is another clean shell", "exit" do
+      assert_execute "shell --clean"
+    end
+  end
+
+  def test_shell_history_again
+    with_input "echo back in test shell again with our remote and history", "remote get #{@config.remote_name}", "history", "exit" do
+      assert_execute "shell"
+    end
+  end
+=end
+
+end

data/test/cli/version_test.rb

@@ -0,0 +1,23 @@
+require 'morpheus_test'
+
+# Tests for Morpheus::Cli::VersionCommand
+class MorpheusTest::VersionTest < MorpheusTest::TestCase
+  
+  def requires_authentication
+    false
+  end
+
+  def test_version
+  	assert_execute %(version)
+  end
+
+  def test_version_short
+    assert_execute %(version -v)
+    assert_execute %(version --short)
+  end
+
+  # def test_version_help
+  #   assert_execute %(version --help)
+  # end
+
+end

data/test/cli/view_test.rb

@@ -0,0 +1,55 @@
+require 'morpheus_test'
+
+# Tests for Morpheus::Cli::View class, corresponds to the `view` CLI command
+class MorpheusTest::ViewTest < MorpheusTest::TestCase
+  
+  def teardown
+    # todo: close browser after each test
+  end
+
+# these all pass but it's kind of obnoxious to open so many tabs
+
+=begin
+  def test_view
+    assert_execute %(view)
+  end
+
+  def test_view_login
+    assert_execute %(view --login)
+    #puts "pausing a moment while logging in with browser"
+    #sleep(3)
+    
+  end
+
+  def test_view_login_short
+    assert_execute %(view -l)
+    #puts "pausing a moment while logging in with browser"
+    #sleep(3)
+  end
+
+  def test_view_clouds
+    assert_execute %(view clouds)
+  end
+
+  def test_view_cloud_by_id
+    cloud = client.clouds.list({})['zones'][0]
+    if cloud
+      assert_execute %(view cloud "#{escape_arg cloud['id']}")
+    else
+      puts "No cloud found, unable to execute test `#{__method__}`"
+    end
+  end
+
+  def test_view_instance_by_name
+    assert_execute %(view -l)
+    instance = client.instances.list({})['instances'][0]
+    if instance
+      assert_execute %(view instance "#{escape_arg instance['name']}")
+    else
+      puts "No instance found, unable to execute test `#{__method__}`"
+    end
+  end
+=end
+  protected
+
+end

data/test/cli/whoami_test.rb

@@ -0,0 +1,17 @@
+require 'morpheus_test'
+
+class MorpheusTest::WhoamiTest < MorpheusTest::TestCase
+  
+  def test_whoami
+    assert_execute("whoami")
+    assert_execute("whoami --name")
+    assert_execute("whoami --permissions")
+  end
+
+  def test_whoami_unauthorized
+    without_authentication do
+      assert_error("whoami", "Expected error while unauthorized")
+    end
+  end
+
+end

data/test/morpheus_test.rb

@@ -0,0 +1,16 @@
+require 'test/unit'
+require 'test_case'
+require 'test_data_helper'
+
+# setup at_start hook that runs once at the beginning of all tests
+Test::Unit.at_start {
+  
+}
+
+# setup at_exit hook that runs once at the end of all tests
+Test::Unit.at_exit {
+  # always logout when all done
+  # logout_if_needed()
+  # terminal.execute("logout") if is_logged_in()
+  Morpheus::Terminal.instance.execute("logout")
+}

data/test/test_case.rb

@@ -0,0 +1,338 @@
+require 'test/unit'
+# use a different default home directory when running tests
+ENV['MORPHEUS_CLI_HOME'] = ENV['TEST_CLI_HOME'] || File.join(Dir.home, ".morpheus_test")
+require 'morpheus'
+require 'test_config'
+#require 'securerandom'
+
+module MorpheusTest
+
+  # TestCase is the base class for all unit tests to provide standard behavior
+  # for testing CLI commands and API interfaces.
+  #
+  # +assert_execute+ is available to execute a CLI command or expression and assert the result is a success (exit:0) by default.
+  #
+  # +terminal+ is available to execute any commands eg. +terminal.execute("source foo")+
+  #
+  # +client+ is available for executing API requests
+  #
+  class TestCase < Test::Unit::TestCase
+    include Morpheus::Cli::PrintHelper # printhelper for print_red_alert and what not.. should probably not be included in MorpheusTest
+
+    # execute test cases in the order they are defined.
+    self.test_order = :defined
+
+    # indicates the test requires the user to have a current remote
+    # override this to return false if your tests do not require `remote use` as part of its setup
+    def requires_remote
+      true
+    end
+
+    # indicates the test requires the user to be logged in and authenticated
+    # override this to return false if your tests do not require `login` as part of its setup
+    def requires_authentication
+      true
+    end
+
+    # hook at the beginning of each test
+    def setup()
+      #puts "TestCase #{self} setup()"
+      # @config is provided for accessing test environment settings in our tests
+      @config = get_config()
+      # use the remote and login if needed
+      use_remote() if requires_remote
+      login_if_needed() if requires_authentication
+    end
+
+    # hook at the end of each test
+    def teardown()
+      #puts "TestCase #{self} teardown()"
+      #logout_if_needed() if requires_authentication
+    end
+
+    # def initialize(*args)
+    #   obj = super(*args)
+    #   @client = establish_test_terminal()
+    # end
+
+    protected
+
+     # @return [Morpheus::APIClient] client for executing api requests in our tests and examining the results
+    def client
+      # todo: return terminal.get_api_client()
+      #@api_client ||= Morpheus::APIClient.new(url: @config.url, username: @config.username, password: @config.password_decrypted, verify_ssl: false, client_id: 'morph-api')
+      #@api_client.login() unless @api_client.logged_in?
+      # this only works while logged in, fine for now...
+      @client ||= Morpheus::APIClient.new(url: @config.url, username: @config.username, password: @config.password, access_token: get_access_token(), verify_ssl: false, client_id: 'morph-cli')
+    end
+
+   
+
+    # Execute the command in the CLI terminal and assert the result
+    # By default, the result should be a success with exit code: 0 and error: nil
+    # @param [String] cmd the command or expression to be executed by the CLI terminal
+    # @param [Hash,String] opts. See +assert_command_result+ If passed as a String, then treated as failure message.
+    # @param [String] failure_message Optional message to use on failure used instead of the default "Expected command..."
+    #
+    # @example Assert a command succeeds with a 0 exit status
+    #   assert_execute("whoami")
+    #
+    # @example Assert that a command fails with any non zero exit status
+    #   assert_execute("foobar", success:false, "Expected unknown command to fail")
+    #
+    # @example Assert a specific exit status code
+    #   assert_execute("foobar", exit:1, "Expected unknown command to fail")
+    #
+    def assert_execute(cmd, opts = {}, failure_message = nil)
+      opts = opts.is_a?(String) ? {failure_message:opts} : (opts || {})
+      result = terminal.execute(cmd)
+      assert_command_result(result, opts, failure_message)
+    end
+
+    # +assert_success()+ is an alias for +assert_execute()+
+    alias :assert_success :assert_execute
+
+    # Execute the command  in the CLI terminal and assert that the result is in an error (exit non-0)
+    # @param [String] cmd the command or expression to be executed by the CLI terminal
+    # @param [Hash,String] opts. See +assert_command_result+ If passed as a String, then treated as failure message.
+    # @param [String] failure_message Optional message to use on failure used instead of the default "Expected command to succeed|fail..."
+    #
+    # @example Assert a command fails with an error
+    #   assert_error("apps list --unknown-option", "Expected unknown option error")
+    #
+    def assert_error(cmd, opts = {}, failure_message = nil)
+      opts = opts.is_a?(String) ? {failure_message:opts} : (opts || {})
+      assert_execute(cmd, opts.merge(success:false), failure_message)
+    end
+
+
+    # Assert that a command is has the expected exit status and message
+    # The default behavior is to assert the result is successful, exit: 0, error: nil
+    # use {success:false} to assert non-zero
+    # or use {exit:1, error: "something bad happened"} to assert a specific error exit and/or message
+    # @param [Array] Result containing: [exit_code, error].
+    # @param [Hash,String] opts. Hash of options for assertion. If passed as a String, then treated as failure message.
+    # @option opts [true,false] :success Expect success (true) or failure (false). Default is +true+, set to +false+ to assert that an error occurs instead.
+    # @option opts [Integer] :exit Expect a specific exit status code. The default is 0 on success or anything but 0 for failure.
+    # @option opts [String] :failure Optional message to use on failure used instead of the default "Expected command to succe..."
+    # @param [String] failure_message Optional message to use on failure used instead of the default "Expected command to succeed|fail..."
+    def assert_command_result(result, opts = {}, failure_message = nil)
+      # determine what to assert
+      success = opts.key?(:success) ? opts[:success] : true
+      expected_code = opts[:exit] ? opts[:exit] : (success ? 0 : nil)
+      if expected_code && expected_code != 0
+        success = false
+      end
+      expected_message = opts[:error]
+      failure_message = failure_message || opts[:failure_message] || opts[:failure]
+      # parse command result
+      exit_code, err = Morpheus::Cli::CliRegistry.parse_command_result(result)
+      # result assertions
+      if success
+        assert_equal([0, nil], [exit_code, err], failure_message || "Expected command to succeed with exit code: 0 and instead got exit code: #{exit_code.inspect}, error: #{err.inspect}")
+      else
+        if expected_code
+          assert_equal(expected_code, exit_code, failure_message || "Expected command to fail with exit code: #{expected_code.inspect} and instead got exit code: #{exit_code.inspect}, error: #{err.inspect}")
+        else
+          assert_not_equal(0, exit_code, failure_message || "Expected command to fail with exit code: (non-zero) and instead got exit code: #{exit_code.inspect}, error: #{err.inspect}")
+        end
+        if expected_message
+          assert_equal(expected_message, err, "Expected command to fail with error message: #{expected_message.inspect} and instead got error message: #{err.inspect}")
+        end
+      end
+    end
+
+    # Get the shared CLI terminal
+    # @return [Morpheus::Terminal]
+    def terminal
+      # return Morpheus::Terminal.instance
+      establish_test_terminal()
+      Thread.current[:terminal]
+    end
+
+    # Get the shared test configuration settings
+    # parses environment variables and config file to establish CLI environment
+    # @return [Map] containing :url, :username, etc., including :password!
+    def get_config(refresh=false)
+      Thread.current[:config] ||= TestConfig.new
+    end
+
+    # todo: make this work IOError unitialized stream right now
+    QUIET = ENV['QUIET'] ? true : false unless defined?(QUIET)
+
+    # Creates a remote for executing unit tests
+    # This requires the user to set environment variables: TEST_URL, TEST_USERNAME and TEST_PASSWORD or TEST_CONFIG
+    # By default, test_config.yaml in the current directory can be used.
+    # The home directory can be specified with TEST_HOME, and the default TEST_CONFIG filename is ~/.morpheus_test
+    # returns the Morpheus::Terminal instance for executing CLI commands
+    def establish_test_terminal()
+      if Thread.current[:terminal].nil?
+        config = get_config()
+
+        # create the terminal scoped to our test environment
+        terminal_opts = {homedir: config.homedir}
+        Thread.current[:terminal] = Morpheus::Terminal.new(terminal_opts)
+
+        # debug is not a terminal option right now, set it this way instead...
+        if config.debug # || Morpheus::Logging.debug?
+          # Morpheus::Logging.set_log_level(Morpheus::Logging::Logger::DEBUG)
+          terminal.execute("debug")
+        else
+          if QUIET
+            #blackhole = Morpheus::Terminal::Blackhole.new('blackhole')
+            blackhole = File.open(Morpheus::Cli.windows? ? 'NUL:' : '/dev/null', 'w')
+            terminal.set_stdout(blackhole)
+            terminal.set_stderr(blackhole)
+          end
+        end
+        
+        #terminal.execute("remote get \"#{config.remote_name}\" -q || remote add \"#{config.remote_name}\" \"#{config.url}\" --insecure --use -N")
+        appliance = Morpheus::Cli::Remote.load_remote(config.remote_name)
+        if appliance
+          # appliance already exists, update it if needed
+          if appliance[:url] != config.url
+            terminal.execute("remote update \"#{config.remote_name}\" --url \"#{escape_arg config.url}\" --insecure")
+          end
+        else
+          # create appliance
+          terminal.execute("remote add \"#{config.remote_name}\" \"#{escape_arg config.url}\" --insecure --use -N")
+        end
+        sleep 1
+        # use the remote
+        terminal.execute("remote use \"#{config.remote_name}\"")
+
+        # could skip this and just let the tests fail that require authentication...
+        # login right away to make sure credentials work before attempting to run test suite
+        # abort if bad credentials
+        #login_status_code, login_error = login()
+        login_results = terminal.execute(%(login "#{escape_arg config.username}" "#{escape_arg config.password_decrypted}"))
+        if login_results[0] == 0
+          #print_green_success "Established terminal to #{config.username}@#{config.url}\nStarting the test run now"
+        else
+          print_red_alert "Failed to login as #{config.username}@#{config.url}"
+          abort("Test run aborted")
+          exit 1
+        end
+      end
+      return Thread.current[:terminal]
+    end
+
+    # use the test remote quietly
+    def use_remote()
+      config = get_config()
+      terminal.execute %(remote use #{config.remote_name} --quiet)
+    end
+
+    alias :remote_use :use_remote
+
+    # @return [true|false]
+    def is_logged_in()
+      return get_access_token() != nil
+    end
+
+    # Fetch the access token for the current remote.
+    # @return [String,nil] 
+    def get_access_token()
+      config = get_config()
+      appliance = Morpheus::Cli::Remote.load_remote(config.remote_name)
+      if appliance.nil?
+        #abort("test appliance not found #{config.remote_name}")
+        return nil
+      end
+      wallet = ::Morpheus::Cli::Credentials.new(appliance[:name], nil).load_saved_credentials()
+      if wallet.nil?
+        return nil
+      end
+      return wallet['access_token']
+    end
+
+    def login_if_needed()
+      if !is_logged_in()
+        login()
+      end
+    end
+
+    def logout_if_needed()
+      if is_logged_in()
+        logout()
+      end
+    end
+
+    # def login()
+    #   config = get_config()
+    #   result = terminal.execute(%(login "#{escape_arg config.username}" "#{escape_arg config.password_decrypted}" --quiet))
+    #   exit_code, err = Morpheus::Cli::CliRegistry.parse_command_result(result)
+    #   if exit_code != 0
+    #     abort("Failed to login as #{config.username}@#{config.url}")
+    #   else
+    #     # hooray
+    #   end
+    # end
+
+    def login()
+      config = get_config()
+      terminal.execute(%(login "#{escape_arg config.username}" "#{escape_arg config.password_decrypted}" --quiet))
+    end
+
+    def logout()
+      terminal.execute("logout --quiet")
+    end
+
+    # login to execute block and return to previous logged in/out state
+    def with_authentication(&block)
+      was_logged_out = !is_logged_in()
+      login_if_needed()
+      result = block.call()
+      logout_if_needed() if was_logged_out
+      return result
+    end
+
+    # logout to execute block and return to previous logged in/out state
+    def without_authentication(&block)
+      was_logged_in = is_logged_in()
+      logout_if_needed()
+      result = block.call()
+      login_if_needed() if was_logged_in
+      return result
+    end
+
+    # send input to CLI terminal stdin to handle interactive prompting
+    def with_input(*messages, &block)
+      with_tmpfile_input(*messages, &block)
+    end
+
+    # send input to CLI shell stdin to handle interactive prompting
+    # def with_shell_input(*messages, &block)
+    #   with_tmpfile_input(*messages, &block)
+    # end
+
+    # Set stdin to a File (Readline requires a File object for input=)
+    # this way works for all testing purposes
+    def with_tmpfile_input(*messages, &block)
+      messages = messages.flatten #.compact
+      original_stdin = $stdin
+      #todo: use temp directory...
+      tmpfilename = ".cli_unit_test_shell_input_#{SecureRandom.hex(10)}.morpheus"
+      file = nil
+      begin
+        File.open(tmpfilename, 'w+') {|f| f.write(messages.join("\n") + "\n") }
+        file = File.new(tmpfilename, 'r')
+        Readline.input = file
+        $stdin = file
+        yield
+      ensure
+        Readline.input = original_stdin
+        $stdin = original_stdin
+        file.close if file && !file.closed?
+        File.delete(tmpfilename) if File.exist?(tmpfilename)
+      end
+    end
+
+    # escape double quotes for interpolating values between double quotes in your terminal command arguments
+    def escape_arg(value)
+      # escape double quotes
+      value.to_s.gsub("\"", "\\\"")
+    end
+
+  end
+end

data/test/test_config.rb

@@ -0,0 +1,137 @@
+# use a different default home directory when running tests
+ENV['MORPHEUS_CLI_HOME'] = ENV['TEST_CLI_HOME'] || File.join(Dir.home, ".morpheus_test") unless ENV['MORPHEUS_CLI_HOME']
+require 'morpheus'
+
+module MorpheusTest
+  
+  # TestConfig handles parsing of the Morpheus test config settings
+  # This parses environment variables or a config file, the latter takes priority
+  # The default config file named +test_config.yaml+
+  class TestConfig
+    include Morpheus::Cli::PrintHelper # for parse_json_or_yaml() todo: remove this include and use a class method
+
+    # The default filename for the test config
+    DEFAULT_FILENAME = 'test_config.yaml'
+
+    # The environment variables that are parsed and the corresponding config property name
+    ENVIRONMENT_VARIABLES = {
+      # "TEST_CLI_HOME" => :homedir, 
+      "TEST_REMOTE_NAME" => :remote_name, 
+      "TEST_REMOTE_URL" => :url, 
+      "TEST_URL" => :url,
+      "TEST_USERNAME" => :username,
+      "TEST_PASSWORD" => :password,
+      "TEST_DEBUG" => :debug, 
+      "DEBUG" => :debug,
+    }.freeze
+
+    # The default name of the remote to create and do our unit testing in
+    DEFAULT_REMOTE_NAME = 'unit_test'
+
+    # use a different default home directory when running tests
+    # load settings from environment variables and config file
+    # unless ENV['MORPHEUS_CLI_HOME']
+    #   ENV['MORPHEUS_CLI_HOME'] = File.join(Dir.home, ".morpheus_test")
+    # end
+    # The default name of the remote to create and use for unit testing
+    DEFAULT_HOMEDIR = Morpheus::Cli.home_directory
+
+    # raised if the config cannot be parsed or is missing required settings
+    class BadConfigError < StandardError
+    end
+
+    attr_accessor :homedir, :remote_name, :url, :username
+    attr_writer :password
+    attr_reader :debug
+  
+    def initialize
+      # set defaults
+      @remote_name = DEFAULT_REMOTE_NAME # 'unit_test'
+      @homedir = DEFAULT_HOMEDIR # Morpheus::Cli.home_directory
+      
+      # load settings from environment variable and set instance variables
+      #ENVIRONMENT_VARIABLES.each { |name, value| instance_variable_set("@#{name}", ENV[name]) if ENV[name] }
+      ENVIRONMENT_VARIABLES.each { |name, value| send("#{value}=", ENV[name]) if ENV[name] }
+
+      # load settings from config file
+      config_filename = nil
+      if ENV['TEST_CONFIG']
+        config_filename = ENV['TEST_CONFIG']
+      elsif File.exist?(DEFAULT_FILENAME)
+        config_filename = DEFAULT_FILENAME
+      elsif File.exist?(File.join(homedir, DEFAULT_FILENAME))
+        config_filename = File.join(@homedir, DEFAULT_FILENAME)
+      end
+      if config_filename
+        full_filename = File.expand_path(config_filename)
+        file_content = nil
+        if File.exist?(full_filename)
+          file_content = File.read(full_filename)
+        else
+          raise "Test config file not found: #{full_filename}"
+        end
+        parse_result = parse_json_or_yaml(file_content)
+        config_map = parse_result[:data]
+        if config_map.nil?
+          bad_config "Failed to parse test config file '#{config_filename}' as YAML or JSON. Error: #{parse_result[:error]}"
+        end
+        @homedir = config_map['homedir'] if config_map['homedir']
+        @remote_name = config_map['remote_name'] if config_map['remote_name']
+        @url = (config_map['url'] || config_map['remote_url']) if (config_map['url'] || config_map['remote_url'])
+        @username = config_map['username'] if config_map['username']
+        @password = config_map['password'] if config_map['password']
+        @debug = config_map['debug'].to_s.strip.downcase == "true" if config_map.key?('debug')
+      end
+      
+      # print_h1 "Test Config"
+      # print cyan
+      # puts "homedir: #{homedir}"
+      # puts "remote_name: #{remote_name}"
+      # puts "url: #{url}"
+      # puts "username: #{username}"
+      # puts "password: #{password}"
+      # print reset
+
+      # validate now
+      # For now force user to create a test_config.yaml or use environment variables
+      if remote_name.to_s.empty?
+        bad_config "Unable to execute unit tests without specifying a remote name.\nYou must specify the environment variable TEST_REMOTE_NAME=unit_test\nor in a config file named #{config_filename || 'test_config.yaml'} like this:\n\nremote_name: unit_test\n"
+      end
+      if url.to_s.empty?
+        bad_config "Unable to execute unit tests without specifying a url.\nThis can be specified with the environment variable TEST_URL=https://test-appliance\nor in a config file named #{config_filename || 'test_config.yaml'} like this:\n\nurl: https://test-appliance\n"
+      end
+      if username.to_s.empty?
+        bad_config "Unable to execute unit tests without specifying a username.\nThis can be specified with the environment variable TEST_USERNAME=testrunner\nor in a config file named #{config_filename || 'test_config.yaml'} like this:\n\nusername: testrunner\n"
+      end
+      if password.to_s.empty?
+        bad_config "Unable to execute unit tests without specifying a password.\nThis can be specified with the environment variable TEST_PASSWORD='SecretPassword123$'\nor in a config file named #{config_filename || 'test_config.yaml'} like this:\n\npassword: 'SecretPassword123$'\n"
+      end
+      # debug is not a terminal method right now, set it this way to enable morpheus debugging right away
+      if debug
+        Morpheus::Logging.set_log_level(Morpheus::Logging::Logger::DEBUG)
+      end
+      
+      # todo: test authentication now...
+      # config looks good
+    end
+
+    def password
+      @password ? ('*' * 12) : nil
+    end
+
+    def password_decrypted
+      @password
+    end
+
+    def debug=(v)
+      @debug = v.to_s.strip.downcase == "true"
+    end
+
+    def bad_config(msg)
+      #todo: make this work with raise but also don't run every test so just abort for now
+      #raise BadConfigError.new(msg)
+      print_red_alert msg
+      abort("Aborting tests...")
+    end
+  end
+end