Continue to write core test code.

9 files changed, 202 insertions, 175 deletions

diff --git a/src/gpg/CMakeLists.txt b/src/gpg/CMakeLists.txt
index 9c32761a..e74ba86f 100644
--- a/src/gpg/CMakeLists.txt
+++ b/src/gpg/CMakeLists.txt
@@ -9,27 +9,29 @@ set(UTILS_DIR ${CMAKE_SOURCE_DIR}/utils)
 
 set(GPGME_LIB_DIR ${UTILS_DIR}/gpgme/lib)
 
-if(ESAY_LOGGING_CPP)
-   message(STATUS "Link ESAY_LOGGING_CPP")
-   set(THIRD_PARTY_LIBS easy_logging_cpp)
+if(ESAY_LOGGING_PP)
+   message(STATUS "Link ESAY_LOGGING_PP")
+   set(THIRD_PARTY_LIBS easy_logging_pp config++)
 endif()
 
+set(BOOST_LIBS Boost::date_time Boost::filesystem)
+
 message(STATUS "Third Party Libraries " ${THIRD_PARTY_LIBS})
 
 if (MINGW)
     message(STATUS "Link GPG Static Library For MINGW")
     target_link_libraries(gpg_core ${THIRD_PARTY_LIBS}
-            Boost::date_time
+            ${BOOST_LIBS}
             gpgme gpg-error assuan wsock32)
 elseif(APPLE)
     message(STATUS "Link GPG Static Library For macOS")
     target_link_libraries(gpg_core ${THIRD_PARTY_LIBS}
-            Boost::date_time
-            libgpgme.a libgpg-error.a libassuan.a)
+            ${BOOST_LIBS}
+            libgpgme.a libgpg-error.a libassuan.a dl)
 else()
     message(STATUS "Link GPG Static Library For Unix")
     target_link_libraries(gpg_core ${THIRD_PARTY_LIBS}
             libgpgme.a libgpg-error.a libassuan.a
-            Boost::date_time
-            pthread)
+            ${BOOST_LIBS}
+            pthread dl)
 endif()
diff --git a/src/gpg/GpgConstants.cpp b/src/gpg/GpgConstants.cpp
index 2ba04ed2..8090a261 100644
--- a/src/gpg/GpgConstants.cpp
+++ b/src/gpg/GpgConstants.cpp
@@ -23,21 +23,24 @@
  */
 
 #include "gpg/GpgConstants.h"
+
 #include <gpg-error.h>
+#include <boost/algorithm/string/predicate.hpp>
+#include <filesystem>
 
-const char *GpgFrontend::GpgConstants::PGP_CRYPT_BEGIN =
+const char* GpgFrontend::GpgConstants::PGP_CRYPT_BEGIN =
     "-----BEGIN PGP MESSAGE-----";
-const char *GpgFrontend::GpgConstants::PGP_CRYPT_END =
+const char* GpgFrontend::GpgConstants::PGP_CRYPT_END =
     "-----END PGP MESSAGE-----";
-const char *GpgFrontend::GpgConstants::PGP_SIGNED_BEGIN =
+const char* GpgFrontend::GpgConstants::PGP_SIGNED_BEGIN =
     "-----BEGIN PGP SIGNED MESSAGE-----";
-const char *GpgFrontend::GpgConstants::PGP_SIGNED_END =
+const char* GpgFrontend::GpgConstants::PGP_SIGNED_END =
     "-----END PGP SIGNATURE-----";
-const char *GpgFrontend::GpgConstants::PGP_SIGNATURE_BEGIN =
+const char* GpgFrontend::GpgConstants::PGP_SIGNATURE_BEGIN =
     "-----BEGIN PGP SIGNATURE-----";
-const char *GpgFrontend::GpgConstants::PGP_SIGNATURE_END =
+const char* GpgFrontend::GpgConstants::PGP_SIGNATURE_END =
     "-----END PGP SIGNATURE-----";
-const char *GpgFrontend::GpgConstants::GPG_FRONTEND_SHORT_CRYPTO_HEAD =
+const char* GpgFrontend::GpgConstants::GPG_FRONTEND_SHORT_CRYPTO_HEAD =
     "GpgF_Scpt://";
 
 gpgme_error_t GpgFrontend::check_gpg_error(gpgme_error_t err) {
@@ -49,9 +52,10 @@ gpgme_error_t GpgFrontend::check_gpg_error(gpgme_error_t err) {
   return err;
 }
 
-gpg_err_code_t GpgFrontend::check_gpg_error_2_err_code(gpgme_error_t err) {
+gpg_err_code_t GpgFrontend::check_gpg_error_2_err_code(gpgme_error_t err,
+                                                       gpgme_error_t predict) {
   auto err_code = gpg_err_code(err);
-  if (err_code != GPG_ERR_NO_ERROR) {
+  if (err_code != predict) {
     LOG(ERROR) << "[Error " << gpg_err_code(err)
                << "] Source: " << gpgme_strsource(err)
                << " Description: " << gpgme_strerror(err);
@@ -61,18 +65,17 @@ gpg_err_code_t GpgFrontend::check_gpg_error_2_err_code(gpgme_error_t err) {
 
 // error-handling
 gpgme_error_t GpgFrontend::check_gpg_error(gpgme_error_t err,
-                                           const std::string &comment) {
+                                           const std::string& comment) {
   if (gpg_err_code(err) != GPG_ERR_NO_ERROR) {
     LOG(ERROR) << "[Error " << gpg_err_code(err)
                << "] Source: " << gpgme_strsource(err)
-               << " Description: " << gpgme_strerror(err) << " "
-               << comment.c_str();
+               << " Description: " << gpgme_strerror(err) << " " << comment;
   }
   return err;
 }
 
-std::string
-GpgFrontend::beautify_fingerprint(GpgFrontend::BypeArrayRef fingerprint) {
+std::string GpgFrontend::beautify_fingerprint(
+    GpgFrontend::BypeArrayRef fingerprint) {
   uint len = fingerprint.size();
   if ((len > 0) && (len % 4 == 0))
     for (uint n = 0; 4 * (n + 1) < len; ++n)
@@ -81,14 +84,14 @@ GpgFrontend::beautify_fingerprint(GpgFrontend::BypeArrayRef fingerprint) {
 }
 
 // trim from start (in place)
-static inline void ltrim(std::string &s) {
+static inline void ltrim(std::string& s) {
   s.erase(s.begin(), std::find_if(s.begin(), s.end(), [](unsigned char ch) {
             return !std::isspace(ch);
           }));
 }
 
 // trim from end (in place)
-static inline void rtrim(std::string &s) {
+static inline void rtrim(std::string& s) {
   s.erase(std::find_if(s.rbegin(), s.rend(),
                        [](unsigned char ch) { return !std::isspace(ch); })
               .base(),
@@ -96,12 +99,64 @@ static inline void rtrim(std::string &s) {
 }
 
 // trim from both ends (in place)
-static inline std::string trim(std::string &s) {
+static inline std::string trim(std::string& s) {
   ltrim(s);
   rtrim(s);
   return s;
 }
 
+std::string GpgFrontend::read_all_data_in_file(const std::string& path) {
+  using namespace std::filesystem;
+  class path file_info(path.c_str());
+
+  if (!exists(file_info) || !is_regular_file(path))
+    throw std::runtime_error("no permission");
+
+  std::ifstream in_file;
+  in_file.open(path, std::ios::in);
+  if (!in_file.good())
+    throw std::runtime_error("cannot open file");
+  std::istreambuf_iterator<char> begin(in_file);
+  std::istreambuf_iterator<char> end;
+  std::string in_buffer(begin, end);
+  in_file.close();
+  return in_buffer;
+}
+
+void GpgFrontend::write_buffer_to_file(const std::string& path,
+                                       const std::string& out_buffer) {
+  std::ofstream out_file(path);
+  out_file.open(path.c_str(), std::ios::out);
+  if (!out_file.good())
+    throw std::runtime_error("cannot open file");
+  out_file.write(out_buffer.c_str(), out_buffer.size());
+  out_file.close();
+}
+
+std::string GpgFrontend::get_file_extension(const std::string& path) {
+  // Create a Path object from given string
+  std::filesystem::path path_obj(path);
+  // Check if file name in the path object has extension
+  if (path_obj.has_extension()) {
+    // Fetch the extension from path object and return
+    return path_obj.extension().string();
+  }
+  // In case of no extension return empty string
+  return std::string();
+}
+
+std::string get_file_name_with_path(const std::string& path) {
+  // Create a Path object from given string
+  std::filesystem::path path_obj(path);
+  // Check if file name in the path object has extension
+  if (path_obj.has_filename()) {
+    // Fetch the extension from path object and return
+    return path_obj.parent_path() / path_obj.filename();
+  }
+  // In case of no extension return empty string
+  throw std::runtime_error("invalid file path");
+}
+
 /*
  * isSigned returns:
  * - 0, if text isn't signed at all
@@ -109,13 +164,16 @@ static inline std::string trim(std::string &s) {
  * - 2, if text is completly signed
  */
 int GpgFrontend::text_is_signed(GpgFrontend::BypeArrayRef text) {
-  if (trim(text).starts_with(GpgConstants::PGP_SIGNED_BEGIN) &&
-      trim(text).ends_with(GpgConstants::PGP_SIGNED_END))
+  using boost::algorithm::ends_with;
+  using boost::algorithm::starts_with;
+
+  auto trim_text = trim(text);
+  if (starts_with(trim_text, GpgConstants::PGP_SIGNED_BEGIN) &&
+      ends_with(trim_text, GpgConstants::PGP_SIGNED_END))
     return 2;
   else if (text.find(GpgConstants::PGP_SIGNED_BEGIN) != std::string::npos &&
            text.find(GpgConstants::PGP_SIGNED_END) != std::string::npos)
     return 1;
-
   else
     return 0;
 }
diff --git a/src/gpg/GpgConstants.h b/src/gpg/GpgConstants.h
index e82810b0..f891151f 100644
--- a/src/gpg/GpgConstants.h
+++ b/src/gpg/GpgConstants.h
@@ -30,11 +30,13 @@
 #include <functional>
 
 #include <assert.h>
+#include <gpg-error.h>
 #include <gpgme.h>
 #include <memory>
 #include <string>
 
 #include <easyloggingpp/easylogging++.h>
+#include <libconfig.h++>
 
 const int RESTART_CODE = 1000;
 
@@ -42,50 +44,61 @@ namespace GpgFrontend {
 
 using BypeArrayPtr = std::unique_ptr<std::string>;
 using StdBypeArrayPtr = std::unique_ptr<std::string>;
-using BypeArrayRef = std::string &;
+using BypeArrayRef = std::string&;
 using StringArgsPtr = std::unique_ptr<std::vector<std::string>>;
-using StringArgsRef = std::vector<std::string> &;
+using StringArgsRef = std::vector<std::string>&;
 
 using GpgError = gpgme_error_t;
 
 // Result
-struct __result_ref_deletor {
-  void operator()(void *_result) {
+struct _result_ref_deletor {
+  void operator()(void* _result) {
     if (_result != nullptr)
       gpgme_result_unref(_result);
   }
 };
 
 using GpgEncrResult =
-    std::unique_ptr<struct _gpgme_op_encrypt_result, __result_ref_deletor>;
+    std::unique_ptr<struct _gpgme_op_encrypt_result, _result_ref_deletor>;
 using GpgDecrResult =
-    std::unique_ptr<struct _gpgme_op_decrypt_result, __result_ref_deletor>;
+    std::unique_ptr<struct _gpgme_op_decrypt_result, _result_ref_deletor>;
 using GpgSignResult =
-    std::unique_ptr<struct _gpgme_op_sign_result, __result_ref_deletor>;
+    std::unique_ptr<struct _gpgme_op_sign_result, _result_ref_deletor>;
 using GpgVerifyResult =
-    std::unique_ptr<struct _gpgme_op_verify_result, __result_ref_deletor>;
+    std::unique_ptr<struct _gpgme_op_verify_result, _result_ref_deletor>;
 
 // Error Info Printer
 GpgError check_gpg_error(GpgError err);
-GpgError check_gpg_error(GpgError gpgmeError, const std::string &comment);
-gpg_err_code_t check_gpg_error_2_err_code(gpgme_error_t err);
+GpgError check_gpg_error(GpgError gpgmeError, const std::string& comment);
+gpg_err_code_t check_gpg_error_2_err_code(
+    gpgme_error_t err,
+    gpgme_error_t predict = GPG_ERR_NO_ERROR);
 
 // Fingerprint
 std::string beautify_fingerprint(BypeArrayRef fingerprint);
 
+// File Operation
+std::string read_all_data_in_file(const std::string& path);
+void write_buffer_to_file(const std::string& path,
+                          const std::string& out_buffer);
+
+std::string get_file_extension(const std::string& path);
+std::string get_file_extension(const std::string& path);
+std::string get_file_name_with_path(const std::string& path);
+
 // Check
 int text_is_signed(BypeArrayRef text);
 
 class GpgConstants {
-public:
-  static const char *PGP_CRYPT_BEGIN;
-  static const char *PGP_CRYPT_END;
-  static const char *PGP_SIGNED_BEGIN;
-  static const char *PGP_SIGNED_END;
-  static const char *PGP_SIGNATURE_BEGIN;
-  static const char *PGP_SIGNATURE_END;
-  static const char *GPG_FRONTEND_SHORT_CRYPTO_HEAD;
+ public:
+  static const char* PGP_CRYPT_BEGIN;
+  static const char* PGP_CRYPT_END;
+  static const char* PGP_SIGNED_BEGIN;
+  static const char* PGP_SIGNED_END;
+  static const char* PGP_SIGNATURE_BEGIN;
+  static const char* PGP_SIGNATURE_END;
+  static const char* GPG_FRONTEND_SHORT_CRYPTO_HEAD;
 };
-} // namespace GpgFrontend
+}  // namespace GpgFrontend
 
-#endif // GPG_CONSTANTS_H
+#endif  // GPG_CONSTANTS_H
diff --git a/src/gpg/GpgContext.cpp b/src/gpg/GpgContext.cpp
index db670938..a8c9a6de 100644
--- a/src/gpg/GpgContext.cpp
+++ b/src/gpg/GpgContext.cpp
@@ -31,7 +31,7 @@
 #include <windows.h>
 #endif
 
-#define INT2VOIDP(i) (void *)(uintptr_t)(i)
+#define INT2VOIDP(i) (void*)(uintptr_t)(i)
 
 namespace GpgFrontend {
 
@@ -40,7 +40,6 @@ namespace GpgFrontend {
  *  Set up gpgme-context, set paths to app-run path
  */
 GpgContext::GpgContext() {
-
   static bool _first = true;
 
   if (_first) {
@@ -76,7 +75,7 @@ GpgContext::GpgContext() {
       find_gpgconf = true;
     if (engineInfo->protocol == GPGME_PROTOCOL_OpenPGP &&
         strcmp(engineInfo->version, "1.0.0") != 0)
-      find_openpgp = true, info.appPath = engineInfo->file_name;
+      find_openpgp = true, info.AppPath = engineInfo->file_name;
     if (engineInfo->protocol == GPGME_PROTOCOL_CMS &&
         strcmp(engineInfo->version, "1.0.0") != 0)
       find_cms = true;
@@ -107,7 +106,9 @@ GpgContext::GpgContext() {
   }
 }
 
-bool GpgContext::good() const { return good_; }
+bool GpgContext::good() const {
+  return good_;
+}
 
 void GpgContext::SetPassphraseCb(decltype(test_passphrase_cb) cb) const {
   gpgme_set_passphrase_cb(*this, cb, nullptr);
@@ -117,4 +118,4 @@ std::string GpgContext::getGpgmeVersion() {
   return {gpgme_check_version(nullptr)};
 }
 
-} // namespace GpgFrontend
\ No newline at end of file
+}  // namespace GpgFrontend
\ No newline at end of file
diff --git a/src/gpg/GpgInfo.h b/src/gpg/GpgInfo.h
index 4c82897f..dbcf3b40 100644
--- a/src/gpg/GpgInfo.h
+++ b/src/gpg/GpgInfo.h
@@ -31,11 +31,13 @@
  * Use to record some info about gnupg
  */
 class GpgInfo {
-public:
+ public:
   /**
    * executable binary path of gnupg
    */
-  std::string appPath;
+  std::string AppPath;
+
+  std::string DatabasePath;
 };
 
-#endif // GPGFRONTEND_ZH_CN_TS_GPGINFO_H
+#endif  // GPGFRONTEND_ZH_CN_TS_GPGINFO_H
diff --git a/src/gpg/function/GpgCommandExecutor.cpp b/src/gpg/function/GpgCommandExecutor.cpp
index b5e6ccae..efe1446f 100644
--- a/src/gpg/function/GpgCommandExecutor.cpp
+++ b/src/gpg/function/GpgCommandExecutor.cpp
@@ -29,8 +29,7 @@ using boost::process::async_pipe;
 
 void GpgFrontend::GpgCommandExecutor::Execute(
     StringArgsRef arguments,
-    const std::function<void(async_pipe &in, async_pipe &out)> &interact_func) {
-
+    const std::function<void(async_pipe& in, async_pipe& out)>& interact_func) {
   using namespace boost::process;
 
   boost::asio::io_service ios;
@@ -40,12 +39,12 @@ void GpgFrontend::GpgCommandExecutor::Execute(
   async_pipe in_pipe_stream(ios);
   async_pipe out_pipe_stream(ios);
 
-  child child_process(ctx.GetInfo().appPath.c_str(), arguments,
+  child child_process(ctx.GetInfo().AppPath.c_str(), arguments,
                       std_out > in_pipe_stream, std_in < out_pipe_stream);
 
   boost::asio::async_read(
       in_pipe_stream, boost::asio::buffer(buf),
-      [&](const boost::system::error_code &ec, std::size_t size) {
+      [&](const boost::system::error_code& ec, std::size_t size) {
         interact_func(in_pipe_stream, out_pipe_stream);
       });
 
diff --git a/src/gpg/function/GpgFileOpera.cpp b/src/gpg/function/GpgFileOpera.cpp
index 71e60f76..79214d2d 100644
--- a/src/gpg/function/GpgFileOpera.cpp
+++ b/src/gpg/function/GpgFileOpera.cpp
@@ -26,42 +26,15 @@
 #include "gpg/function/BasicOperator.h"
 
 #include <boost/process/detail/config.hpp>
-#include <filesystem>
+
 #include <iterator>
 #include <memory>
 #include <string>
 
-std::string read_all_data_in_file(const std::string &path) {
-  using namespace std::filesystem;
-  class path file_info(path.c_str());
-
-  if (!exists(file_info) || !is_regular_file(path))
-    throw std::runtime_error("no permission");
-
-  std::ifstream in_file;
-  in_file.open(path, std::ios::in);
-  if (!in_file.good())
-    throw std::runtime_error("cannot open file");
-  std::istreambuf_iterator<char> begin(in_file);
-  std::istreambuf_iterator<char> end;
-  std::string in_buffer(begin, end);
-  in_file.close();
-  return in_buffer;
-}
-
-void write_buufer_to_file(const std::string &path,
-                          const std::string &out_buffer) {
-  std::ofstream out_file(path);
-  out_file.open(path.c_str(), std::ios::out);
-  if (!out_file.good())
-    throw std::runtime_error("cannot open file");
-  out_file.write(out_buffer.c_str(), out_buffer.size());
-  out_file.close();
-}
-
 GpgFrontend::GpgError GpgFrontend::GpgFileOpera::EncryptFile(
-    KeyArgsList &keys, const std::string &path, GpgEncrResult &result) {
-
+    KeyArgsList& keys,
+    const std::string& path,
+    GpgEncrResult& result) {
   std::string in_buffer = read_all_data_in_file(path);
   std::unique_ptr<std::string> out_buffer;
 
@@ -70,38 +43,13 @@ GpgFrontend::GpgError GpgFrontend::GpgFileOpera::EncryptFile(
 
   assert(check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR);
 
-  write_buufer_to_file(path + ".asc", *out_buffer);
+  write_buffer_to_file(path + ".asc", *out_buffer);
   return err;
 }
 
-std::string get_file_extension(const std::string &path) {
-  // Create a Path object from given string
-  std::filesystem::path path_obj(path);
-  // Check if file name in the path object has extension
-  if (path_obj.has_extension()) {
-    // Fetch the extension from path object and return
-    return path_obj.extension().string();
-  }
-  // In case of no extension return empty string
-  return std::string();
-}
-
-std::string get_file_name_with_path(const std::string &path) {
-  // Create a Path object from given string
-  std::filesystem::path path_obj(path);
-  // Check if file name in the path object has extension
-  if (path_obj.has_filename()) {
-    // Fetch the extension from path object and return
-    return path_obj.parent_path() / path_obj.filename();
-  }
-  // In case of no extension return empty string
-  throw std::runtime_error("invalid file path");
-}
-
-GpgFrontend::GpgError
-GpgFrontend::GpgFileOpera::DecryptFile(const std::string &path,
-                                       GpgDecrResult &result) {
-
+GpgFrontend::GpgError GpgFrontend::GpgFileOpera::DecryptFile(
+    const std::string& path,
+    GpgDecrResult& result) {
   std::string in_buffer = read_all_data_in_file(path);
   std::unique_ptr<std::string> out_buffer;
 
@@ -116,15 +64,14 @@ GpgFrontend::GpgFileOpera::DecryptFile(const std::string &path,
   if (!(file_extension == ".asc" || file_extension == ".gpg"))
     out_file_name += ".out";
 
-  write_buufer_to_file(out_file_name, *out_buffer);
+  write_buffer_to_file(out_file_name, *out_buffer);
 
   return err;
 }
 
-gpgme_error_t GpgFrontend::GpgFileOpera::SignFile(KeyArgsList &keys,
-                                                  const std::string &path,
-                                                  GpgSignResult &result) {
-
+gpgme_error_t GpgFrontend::GpgFileOpera::SignFile(KeyArgsList& keys,
+                                                  const std::string& path,
+                                                  GpgSignResult& result) {
   auto in_buffer = read_all_data_in_file(path);
   std::unique_ptr<std::string> out_buffer;
 
@@ -133,14 +80,13 @@ gpgme_error_t GpgFrontend::GpgFileOpera::SignFile(KeyArgsList &keys,
 
   assert(check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR);
 
-  write_buufer_to_file(path + ".sig", *out_buffer);
+  write_buffer_to_file(path + ".sig", *out_buffer);
 
   return err;
 }
 
-gpgme_error_t GpgFrontend::GpgFileOpera::VerifyFile(const std::string &path,
-                                                    GpgVerifyResult &result) {
-
+gpgme_error_t GpgFrontend::GpgFileOpera::VerifyFile(const std::string& path,
+                                                    GpgVerifyResult& result) {
   auto in_buffer = read_all_data_in_file(path);
   std::unique_ptr<std::string> sign_buffer = nullptr;
 
@@ -162,9 +108,10 @@ gpgme_error_t GpgFrontend::GpgFileOpera::VerifyFile(const std::string &path,
 // TODO
 
 gpg_error_t GpgFrontend::GpgFileOpera::EncryptSignFile(
-    KeyArgsList &keys, const std::string &path, GpgEncrResult &encr_res,
-    GpgSignResult &sign_res) {
-
+    KeyArgsList& keys,
+    const std::string& path,
+    GpgEncrResult& encr_res,
+    GpgSignResult& sign_res) {
   auto in_buffer = read_all_data_in_file(path);
   std::unique_ptr<std::string> out_buffer = nullptr;
 
@@ -177,16 +124,15 @@ gpg_error_t GpgFrontend::GpgFileOpera::EncryptSignFile(
 
   assert(check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR);
 
-  write_buufer_to_file(path + ".gpg", *out_buffer);
+  write_buffer_to_file(path + ".gpg", *out_buffer);
 
   return err;
 }
 
-gpg_error_t
-GpgFrontend::GpgFileOpera::DecryptVerifyFile(const std::string &path,
-                                             GpgDecrResult &decr_res,
-                                             GpgVerifyResult &verify_res) {
-
+gpg_error_t GpgFrontend::GpgFileOpera::DecryptVerifyFile(
+    const std::string& path,
+    GpgDecrResult& decr_res,
+    GpgVerifyResult& verify_res) {
   auto in_buffer = read_all_data_in_file(path);
   std::unique_ptr<std::string> out_buffer = nullptr;
 
@@ -200,7 +146,7 @@ GpgFrontend::GpgFileOpera::DecryptVerifyFile(const std::string &path,
   if (!(file_extension == ".asc" || file_extension == ".gpg"))
     out_file_name = path + ".out";
 
-  write_buufer_to_file(out_file_name, *out_buffer);
+  write_buffer_to_file(out_file_name, *out_buffer);
 
   return err;
 }
diff --git a/src/gpg/function/GpgKeyGetter.cpp b/src/gpg/function/GpgKeyGetter.cpp
index 88f80fbf..6d80088a 100644
--- a/src/gpg/function/GpgKeyGetter.cpp
+++ b/src/gpg/function/GpgKeyGetter.cpp
@@ -23,49 +23,50 @@
  */
 
 #include "gpg/function/GpgKeyGetter.h"
+#include <gpg-error.h>
+#include "GpgConstants.h"
 
-GpgFrontend::GpgKey GpgFrontend::GpgKeyGetter::GetKey(const std::string &fpr) {
-  LOG(INFO) << "GpgKeyGetter GetKey Fpr " << fpr;
+GpgFrontend::GpgKey GpgFrontend::GpgKeyGetter::GetKey(const std::string& fpr) {
+  DLOG(INFO) << "GpgKeyGetter GetKey Fpr " << fpr;
   gpgme_key_t _p_key;
   gpgme_get_key(ctx, fpr.c_str(), &_p_key, 1);
   if (_p_key == nullptr)
-    LOG(WARNING) << "GpgKeyGetter GetKey _p_key Null";
+    DLOG(WARNING) << "GpgKeyGetter GetKey _p_key Null";
   return GpgKey(std::move(_p_key));
 }
 
-GpgFrontend::GpgKey
-GpgFrontend::GpgKeyGetter::GetPubkey(const std::string &fpr) {
+GpgFrontend::GpgKey GpgFrontend::GpgKeyGetter::GetPubkey(
+    const std::string& fpr) {
   gpgme_key_t _p_key;
   gpgme_get_key(ctx, fpr.c_str(), &_p_key, 0);
   return GpgKey(std::move(_p_key));
 }
 
 GpgFrontend::KeyListPtr GpgFrontend::GpgKeyGetter::FetchKey() {
-
   gpgme_error_t err;
 
-  LOG(INFO) << "Clear List and Map";
+  DLOG(INFO) << "Clear List and Map";
 
   KeyListPtr keys_list = std::make_unique<std::vector<GpgKey>>();
 
-  LOG(INFO) << "Operate KeyList Start";
+  DLOG(INFO) << "Operate KeyList Start";
 
   err = gpgme_op_keylist_start(ctx, nullptr, 0);
-  assert(gpg_err_code(err) != GPG_ERR_NO_ERROR);
+  assert(check_gpg_error_2_err_code(err) == GPG_ERR_NO_ERROR);
 
-  LOG(INFO) << "Start Loop";
+  DLOG(INFO) << "Start Loop";
 
   gpgme_key_t key;
   while ((err = gpgme_op_keylist_next(ctx, &key)) == GPG_ERR_NO_ERROR) {
     keys_list->push_back(GpgKey(std::move(key)));
-    LOG(INFO) << "Append Key" << keys_list->back().id().c_str();
+    DLOG(INFO) << "Append Key" << keys_list->back().id().c_str();
   }
 
-  assert(gpg_err_code(err) != GPG_ERR_NO_ERROR);
+  assert(check_gpg_error_2_err_code(err, GPG_ERR_EOF) == GPG_ERR_EOF);
 
   err = gpgme_op_keylist_end(ctx);
 
-  LOG(INFO) << "Operate KeyList End";
+  DLOG(INFO) << "Operate KeyList End";
 
   return keys_list;
 }
diff --git a/src/gpg/model/GpgKey.h b/src/gpg/model/GpgKey.h
index c0671b35..52e089ff 100644
--- a/src/gpg/model/GpgKey.h
+++ b/src/gpg/model/GpgKey.h
@@ -34,7 +34,7 @@
 namespace GpgFrontend {
 
 class GpgKey {
-public:
+ public:
   [[nodiscard]] bool good() const { return _key_ref != nullptr; }
 
   [[nodiscard]] std::string id() const { return _key_ref->subkeys->keyid; }
@@ -53,19 +53,20 @@ public:
 
   [[nodiscard]] std::string owner_trust() const {
     switch (_key_ref->owner_trust) {
-    case GPGME_VALIDITY_UNKNOWN:
-      return "Unknown";
-    case GPGME_VALIDITY_UNDEFINED:
-      return "Undefined";
-    case GPGME_VALIDITY_NEVER:
-      return "Never";
-    case GPGME_VALIDITY_MARGINAL:
-      return "Marginal";
-    case GPGME_VALIDITY_FULL:
-      return "FULL";
-    case GPGME_VALIDITY_ULTIMATE:
-      return "Ultimate";
+      case GPGME_VALIDITY_UNKNOWN:
+        return "Unknown";
+      case GPGME_VALIDITY_UNDEFINED:
+        return "Undefined";
+      case GPGME_VALIDITY_NEVER:
+        return "Never";
+      case GPGME_VALIDITY_MARGINAL:
+        return "Marginal";
+      case GPGME_VALIDITY_FULL:
+        return "FULL";
+      case GPGME_VALIDITY_ULTIMATE:
+        return "Ultimate";
     }
+    return "Invalid";
   }
 
   [[nodiscard]] std::string pubkey_algo() const {
@@ -124,33 +125,37 @@ public:
 
   GpgKey() = default;
 
-  explicit GpgKey(gpgme_key_t &&key);
+  explicit GpgKey(gpgme_key_t&& key);
 
   ~GpgKey() = default;
 
-  GpgKey(const gpgme_key_t &key) = delete;
+  GpgKey(const gpgme_key_t& key) = delete;
 
-  GpgKey(GpgKey &&k) noexcept;
+  GpgKey(GpgKey&& k) noexcept;
 
-  GpgKey &operator=(GpgKey &&k) noexcept;
+  GpgKey& operator=(GpgKey&& k) noexcept;
 
-  GpgKey &operator=(const gpgme_key_t &key) = delete;
+  GpgKey& operator=(const gpgme_key_t& key) = delete;
+
+  bool operator==(const GpgKey& o) { return o.id() == this->id(); }
+
+  bool operator<=(const GpgKey& o) { return this->id() < o.id(); }
 
   explicit operator gpgme_key_t() const { return _key_ref.get(); }
 
-private:
-  struct __key_ref_deletor {
+ private:
+  struct _key_ref_deletor {
     void operator()(gpgme_key_t _key) {
       if (_key != nullptr)
         gpgme_key_unref(_key);
     }
   };
 
-  using KeyRefHandler = std::unique_ptr<struct _gpgme_key, __key_ref_deletor>;
+  using KeyRefHandler = std::unique_ptr<struct _gpgme_key, _key_ref_deletor>;
 
   KeyRefHandler _key_ref = nullptr;
 };
 
-} // namespace GpgFrontend
+}  // namespace GpgFrontend
 
-#endif // GPGFRONTEND_GPGKEY_H
+#endif  // GPGFRONTEND_GPGKEY_H