Upgrade Checker Enhancements

- Adding suggested to use targetVersion option if it was not used.
- Selecting the latest version of the series in case the
  targetVersion option was specified but with an incomplete version.

Change-Id: Ic6bc2412340d357d0bfdda47331d86d6889d66ab

Author: rennox

CMakeLists.txt

@@ -1262,7 +1262,7 @@ if(HAVE_V8)
   endif()
 endif()
 
-add_definitions(-DMYSH_VERSION="${MYSH_VERSION}" -DMYSH_BUILD_ID="${MYSH_BUILD_ID}" -DEXTRA_NAME_SUFFIX="${EXTRA_NAME_SUFFIX}")
+add_definitions(-DMYSH_VERSION="${MYSH_VERSION}" -DLATEST_MYSH_80_VERSION="${LATEST_MYSH_80_VERSION}" -DMYSH_BUILD_ID="${MYSH_BUILD_ID}" -DEXTRA_NAME_SUFFIX="${EXTRA_NAME_SUFFIX}")
 if(WIN32)
   add_definitions(-DMYSH_VERSION_WIN="${MYSH_VERSION_WIN}")
 endif()

modules/util/upgrade_check.cc

@@ -53,7 +53,16 @@ namespace {
 
 const Version ALL_VERSIONS("777.777.777");
 
-}
+// This map should be updated with the latest version of each series to enable
+// gatting the latest version available in case a partial version is provided
+// as the taget value, so for example, not needed when patch version is 0 in
+// the last version of a series
+static std::unordered_map<std::string, Version> latest_versions = {
+    {"8", Version(MYSH_VERSION)},  // If 8 is given, latest version
+                                   // is the current shell version
+    {"8.0", Version(LATEST_MYSH_80_VERSION)}};
+
+}  // namespace
 
 std::string upgrade_issue_to_string(const Upgrade_issue &problem) {
   std::stringstream ss;
@@ -96,9 +105,17 @@ const shcore::Option_pack_def<Upgrade_check_options>
   return opts;
 }
 
+mysqlshdk::utils::Version Upgrade_check_options::get_target_version() const {
+  return target_version.value_or(mysqlshdk::utils::Version(MYSH_VERSION));
+}
+
 void Upgrade_check_options::set_target_version(const std::string &value) {
-  if (!value.empty() && value != "8.0") {
-    target_version = Version(value);
+  if (!value.empty()) {
+    if (latest_versions.contains(value)) {
+      target_version = latest_versions.at(value);
+    } else {
+      target_version = Version(value);
+    }
   }
 }
 
@@ -2160,7 +2177,8 @@ bool UNUSED_VARIABLE(register_get_deprecated_default_auth_check) =
 
 Upgrade_check_config::Upgrade_check_config(const Upgrade_check_options &options)
     : m_output_format(options.output_format) {
-  m_upgrade_info.target_version = options.target_version;
+  m_upgrade_info.target_version = options.get_target_version();
+  m_upgrade_info.explicit_target_version = options.target_version.has_value();
   m_upgrade_info.config_path = options.config_path;
 
   if (m_output_format.empty()) {
@@ -2231,7 +2249,8 @@ bool check_for_upgrade(const Upgrade_check_config &config) {
 
   print->check_info(config.session()->get_connection_options().uri_endpoint(),
                     config.upgrade_info().server_version_long,
-                    config.upgrade_info().target_version.get_base());
+                    config.upgrade_info().target_version.get_base(),
+                    config.upgrade_info().explicit_target_version);
 
   const auto checklist =
       Upgrade_check::create_checklist(config.upgrade_info(), config.targets());

modules/util/upgrade_check.h

@@ -69,13 +69,17 @@ struct Upgrade_issue {
 struct Upgrade_check_options {
   static const shcore::Option_pack_def<Upgrade_check_options> &options();
 
-  mysqlshdk::utils::Version target_version =
-      mysqlshdk::utils::Version(MYSH_VERSION);
+  std::optional<mysqlshdk::utils::Version> target_version;
   std::string config_path;
   std::string output_format;
   std::optional<std::string> password;
 
+  mysqlshdk::utils::Version get_target_version() const;
+
  private:
+#ifdef FRIEND_TEST
+  FRIEND_TEST(Upgrade_check_options, set_target_version);
+#endif
   void set_target_version(const std::string &value);
 };
 
@@ -89,6 +93,7 @@ class Upgrade_check {
     mysqlshdk::utils::Version target_version;
     std::string server_os;
     std::string config_path;
+    bool explicit_target_version;
   };
 
   enum class Target {

modules/util/upgrade_check_formatter.cc

@@ -69,13 +69,18 @@ class Text_upgrade_checker_output : public Upgrade_check_output_formatter {
 
   void check_info(const std::string &server_addres,
                   const std::string &server_version,
-                  const std::string &target_version) override {
+                  const std::string &target_version,
+                  bool explicit_target_version) override {
     print_paragraph(
         shcore::str_format(
             "The MySQL server at %s, version %s, will now be checked for "
-            "compatibility issues for upgrade to MySQL %s...",
+            "compatibility issues for upgrade to MySQL %s%s...",
             server_addres.c_str(), server_version.c_str(),
-            target_version.c_str()),
+            target_version.c_str(),
+            explicit_target_version
+                ? ""
+                : ". To check for a different target server version, use the "
+                  "targetVersion option"),
         0, 0);
   }
 
@@ -170,7 +175,8 @@ class JSON_upgrade_checker_output : public Upgrade_check_output_formatter {
 
   void check_info(const std::string &server_addres,
                   const std::string &server_version,
-                  const std::string &target_version) override {
+                  const std::string &target_version,
+                  [[maybe_unused]] bool explicit_target_version) override {
     rapidjson::Value addr;
     addr.SetString(server_addres.c_str(), server_addres.length(), m_allocator);
     m_json_document.AddMember("serverAddress", addr, m_allocator);

modules/util/upgrade_check_formatter.h

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2022, Oracle and/or its affiliates.
+ * Copyright (c) 2022, 2023, Oracle and/or its affiliates.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License, version 2.0,
@@ -41,7 +41,8 @@ class Upgrade_check_output_formatter {
 
   virtual void check_info(const std::string &server_addres,
                           const std::string &server_version,
-                          const std::string &target_version) = 0;
+                          const std::string &target_version,
+                          bool explicit_target_version) = 0;
   virtual void check_results(const Upgrade_check &check,
                              const std::vector<Upgrade_issue> &results) = 0;
   virtual void check_error(const Upgrade_check &check, const char *description,

unittest/modules/upgrade_check_t.cc

@@ -20,6 +20,7 @@
  * along with this program; if not, write to the Free Software Foundation, Inc.,
  * 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  */
+#include "unittest/gprod_clean.h"
 
 #include "modules/util/mod_util.h"
 #include "modules/util/upgrade_check.h"
@@ -179,6 +180,27 @@ class MySQL_upgrade_check_test : public Shell_core_test_wrapper {
   std::vector<mysqlsh::Upgrade_issue> issues;
 };
 
+TEST(Upgrade_check_options, set_target_version) {
+  Upgrade_check_options options;
+  options.set_target_version("8");
+  EXPECT_EQ(Version(MYSH_VERSION), options.target_version);
+
+  options.set_target_version("8.0");
+  EXPECT_EQ(Version(LATEST_MYSH_80_VERSION), options.target_version);
+
+  options.set_target_version("8.1");
+  EXPECT_EQ(Version(8, 1, 0), options.target_version);
+
+  options.set_target_version("8.2");
+  EXPECT_EQ(Version(8, 2, 0), options.target_version);
+
+  options.set_target_version("8.3");
+  EXPECT_EQ(Version(8, 3, 0), options.target_version);
+
+  options.set_target_version("8.0.34");
+  EXPECT_EQ(Version(8, 0, 34), options.target_version);
+}
+
 TEST_F(MySQL_upgrade_check_test, checklist_generation) {
   Version current(MYSH_VERSION);
   Version prev(current.get_major(), current.get_minor(),

unittest/shell_cli_operation_t.cc

@@ -850,6 +850,16 @@ TEST_F(Shell_cli_operation_test, integration_test) {
                     {"--", "util", "check-for-server-upgrade", uri.c_str()}, "",
                     env));
   MY_EXPECT_STDOUT_CONTAINS("will now be checked for compatibility issues");
+  MY_EXPECT_STDOUT_CONTAINS("To check for a different target server version");
+  output_handler.wipe_all();
+
+  EXPECT_NE(10,
+            testutil->call_mysqlsh_c({"--", "util", "check-for-server-upgrade",
+                                      uri.c_str(), "--target-version=8.3.0"},
+                                     "", env));
+  MY_EXPECT_STDOUT_CONTAINS("will now be checked for compatibility issues");
+  MY_EXPECT_STDOUT_NOT_CONTAINS(
+      "To check for a different target server version");
   output_handler.wipe_all();
 
   MY_EXPECT_EQ_OR_DUMP(

version.cmake

@@ -109,9 +109,25 @@ MACRO(GET_MYSQL_VERSION)
 
 ENDMACRO()
 
+MACRO(GET_LATEST_VERSIONS)
+  # This macro ensures the following variable is kept up to date release after release
+  SET(LATEST_MYSH_80_VERSION "8.0.36")
+
+  IF (NOT "${MYSH_NO_DASH_VERSION}" STREQUAL "${LATEST_MYSH_80_VERSION}")
+    SET(VERSION_MAPPING "8.4.0/8.0.37" "8.3.0/8.0.36" "8.2.0/8.0.35")
+
+    LIST(FIND VERSION_MAPPING "${MYSH_NO_DASH_VERSION}/${LATEST_MYSH_80_VERSION}" POSITION)
+    IF (${POSITION} EQUAL -1)
+      MESSAGE(FATAL_ERROR "Unable to find latest 80 version (${MYSH_NO_DASH_VERSION}/${LATEST_MYSH_80_VERSION}), please ${VERSION_MAPPING} update the definitions of VERSION_MAPPING and LATEST_MYSH_80_VERSION.")
+    ENDIF()
+  ENDIF()
+ENDMACRO()
+
+
 # Get mysql version and other interesting variables
 GET_MYSH_VERSION()
 GET_MYSQL_VERSION()
+GET_LATEST_VERSIONS()
 
 SET(MYSH_BUILD_ID     "$ENV{PARENT_ID}")
 SET(MYSH_COMMIT_ID    "$ENV{PUSH_REVISION}")