feat: e2e tests for APIs

engine/commands/model_get_cmd.cc

@@ -3,7 +3,6 @@
 #include <iomanip>
 #include <iostream>
 #include <vector>
-#include "cmd_info.h"
 #include "config/yaml_config.h"
 #include "database/models.h"
 #include "utils/file_manager_utils.h"

engine/commands/model_list_cmd.cc

@@ -31,7 +31,7 @@ void ModelListCmd::Exec() {
       count += 1;
       yaml_handler.ModelConfigFromFile(model_entry.path_to_model_yaml);
       auto model_config = yaml_handler.GetModelConfig();
-      table.add_row({std::to_string(count), model_entry.model_id,
+      table.add_row({std::to_string(count), model_entry.model,
                      model_entry.model_alias, model_config.engine,
                      model_config.version});
       yaml_handler.Reset();

engine/controllers/command_line_parser.cc

@@ -1,7 +1,6 @@
 #include "command_line_parser.h"
 #include "commands/chat_cmd.h"
 #include "commands/chat_completion_cmd.h"
-#include "commands/cmd_info.h"
 #include "commands/cortex_upd_cmd.h"
 #include "commands/engine_get_cmd.h"
 #include "commands/engine_install_cmd.h"

engine/controllers/engines.h

@@ -12,7 +12,7 @@ class Engines : public drogon::HttpController<Engines> {
   Engines() : engine_service_{EngineService()} {};
 
   METHOD_LIST_BEGIN
-  METHOD_ADD(Engines::InstallEngine, "/{1}/install", Post);
+  METHOD_ADD(Engines::InstallEngine, "/install/{1}", Post);
   METHOD_ADD(Engines::UninstallEngine, "/{1}", Delete);
   METHOD_ADD(Engines::ListEngine, "", Get);
   METHOD_ADD(Engines::GetEngine, "/{1}", Get);

engine/controllers/models.cc

@@ -12,11 +12,11 @@
 
 void Models::PullModel(const HttpRequestPtr& req,
                        std::function<void(const HttpResponsePtr&)>&& callback) {
-  if (!http_util::HasFieldInReq(req, callback, "modelId")) {
+  if (!http_util::HasFieldInReq(req, callback, "model")) {
     return;
   }
 
-  auto model_handle = (*(req->getJsonObject())).get("modelId", "").asString();
+  auto model_handle = (*(req->getJsonObject())).get("model", "").asString();
   if (model_handle.empty()) {
     Json::Value ret;
     ret["result"] = "Bad Request";
@@ -103,22 +103,18 @@ void Models::ListModel(
   }
 }
 
-void Models::GetModel(
-    const HttpRequestPtr& req,
-    std::function<void(const HttpResponsePtr&)>&& callback) const {
-  if (!http_util::HasFieldInReq(req, callback, "modelId")) {
-    return;
-  }
-  auto model_handle = (*(req->getJsonObject())).get("modelId", "").asString();
-  LOG_DEBUG << "GetModel, Model handle: " << model_handle;
+void Models::GetModel(const HttpRequestPtr& req,
+                      std::function<void(const HttpResponsePtr&)>&& callback,
+                      const std::string& model_id) const {
+  LOG_DEBUG << "GetModel, Model handle: " << model_id;
   Json::Value ret;
   ret["object"] = "list";
   Json::Value data(Json::arrayValue);
 
   try {
     cortex::db::Models modellist_handler;
     config::YamlHandler yaml_handler;
-    auto model_entry = modellist_handler.GetModelInfo(model_handle);
+    auto model_entry = modellist_handler.GetModelInfo(model_id);
     if (model_entry.has_error()) {
       // CLI_LOG("Error: " + model_entry.error());
       ret["data"] = data;
@@ -142,7 +138,7 @@ void Models::GetModel(
     callback(resp);
   } catch (const std::exception& e) {
     std::string message = "Fail to get model information with ID '" +
-                          model_handle + "': " + e.what();
+                          model_id + "': " + e.what();
     LOG_ERROR << message;
     ret["data"] = data;
     ret["result"] = "Fail to get model information";
@@ -172,13 +168,9 @@ void Models::DeleteModel(const HttpRequestPtr& req,
   }
 }
 
-void Models::UpdateModel(
-    const HttpRequestPtr& req,
-    std::function<void(const HttpResponsePtr&)>&& callback) const {
-  if (!http_util::HasFieldInReq(req, callback, "modelId")) {
-    return;
-  }
-  auto model_id = (*(req->getJsonObject())).get("modelId", "").asString();
+void Models::UpdateModel(const HttpRequestPtr& req,
+                         std::function<void(const HttpResponsePtr&)>&& callback,
+                         const std::string& model_id) const {
   auto json_body = *(req->getJsonObject());
   try {
     cortex::db::Models model_list_utils;
@@ -198,7 +190,7 @@ void Models::UpdateModel(
     ret["message"] = message;
 
     auto resp = cortex_utils::CreateCortexHttpJsonResponse(ret);
-    resp->setStatusCode(k400BadRequest);
+    resp->setStatusCode(k200OK);
     callback(resp);
 
   } catch (const std::exception& e) {
@@ -218,11 +210,11 @@ void Models::UpdateModel(
 void Models::ImportModel(
     const HttpRequestPtr& req,
     std::function<void(const HttpResponsePtr&)>&& callback) const {
-  if (!http_util::HasFieldInReq(req, callback, "modelId") ||
+  if (!http_util::HasFieldInReq(req, callback, "model") ||
       !http_util::HasFieldInReq(req, callback, "modelPath")) {
     return;
   }
-  auto modelHandle = (*(req->getJsonObject())).get("modelId", "").asString();
+  auto modelHandle = (*(req->getJsonObject())).get("model", "").asString();
   auto modelPath = (*(req->getJsonObject())).get("modelPath", "").asString();
   config::GGUFHandler gguf_handler;
   config::YamlHandler yaml_handler;
@@ -288,11 +280,11 @@ void Models::ImportModel(
 void Models::SetModelAlias(
     const HttpRequestPtr& req,
     std::function<void(const HttpResponsePtr&)>&& callback) const {
-  if (!http_util::HasFieldInReq(req, callback, "modelId") ||
+  if (!http_util::HasFieldInReq(req, callback, "model") ||
       !http_util::HasFieldInReq(req, callback, "modelAlias")) {
     return;
   }
-  auto model_handle = (*(req->getJsonObject())).get("modelId", "").asString();
+  auto model_handle = (*(req->getJsonObject())).get("model", "").asString();
   auto model_alias = (*(req->getJsonObject())).get("modelAlias", "").asString();
   LOG_DEBUG << "GetModel, Model handle: " << model_handle
             << ", Model alias: " << model_alias;
@@ -390,7 +382,7 @@ void Models::StopModel(const HttpRequestPtr& req,
     callback(resp);
   } else {
     Json::Value ret;
-    ret["message"] = "Started successfully!";
+    ret["message"] = "Stopped successfully!";
     auto resp = cortex_utils::CreateCortexHttpJsonResponse(ret);
     resp->setStatusCode(k200OK);
     callback(resp);

engine/controllers/models.h

@@ -13,8 +13,8 @@ class Models : public drogon::HttpController<Models> {
   METHOD_LIST_BEGIN
   METHOD_ADD(Models::PullModel, "/pull", Post);
   METHOD_ADD(Models::ListModel, "", Get);
-  METHOD_ADD(Models::GetModel, "/get", Post);
-  METHOD_ADD(Models::UpdateModel, "/update", Post);
+  METHOD_ADD(Models::GetModel, "/{1}", Get);
+  METHOD_ADD(Models::UpdateModel, "/{1}", Post);
   METHOD_ADD(Models::ImportModel, "/import", Post);
   METHOD_ADD(Models::DeleteModel, "/{1}", Delete);
   METHOD_ADD(Models::SetModelAlias, "/alias", Post);
@@ -27,10 +27,11 @@ class Models : public drogon::HttpController<Models> {
   void ListModel(const HttpRequestPtr& req,
                  std::function<void(const HttpResponsePtr&)>&& callback) const;
   void GetModel(const HttpRequestPtr& req,
-                std::function<void(const HttpResponsePtr&)>&& callback) const;
-  void UpdateModel(
-      const HttpRequestPtr& req,
-      std::function<void(const HttpResponsePtr&)>&& callback) const;
+                std::function<void(const HttpResponsePtr&)>&& callback,
+                const std::string& model_id) const;
+  void UpdateModel(const HttpRequestPtr& req,
+                   std::function<void(const HttpResponsePtr&)>&& callback,
+                   const std::string& model_id) const;
   void ImportModel(
       const HttpRequestPtr& req,
       std::function<void(const HttpResponsePtr&)>&& callback) const;