From 1c0bfa6263aa42212c8fcaa60c27c19fe37f6328 Mon Sep 17 00:00:00 2001
From: eeff <33566201+eeff@users.noreply.github.com>
Date: Wed, 6 Sep 2023 11:57:30 +0800
Subject: [PATCH 1/4] feat: add json parser for updating template group

---
 src/parser/neu_json_template.c | 73 ++++++++++++++++++++++++++++++++++
 src/parser/neu_json_template.h | 13 ++++++
 2 files changed, 86 insertions(+)

diff --git a/src/parser/neu_json_template.c b/src/parser/neu_json_template.c
index 232f0bae..f7c9fc16 100644
--- a/src/parser/neu_json_template.c
+++ b/src/parser/neu_json_template.c
@@ -464,6 +464,79 @@ void neu_json_decode_template_mod_group_req_free(
     }
 }
 
+int neu_json_decode_template_update_group_req(
+    char *buf, neu_json_template_update_group_req_t **result)
+{
+    int ret = 0;
+
+    neu_json_template_update_group_req_t *req = calloc(1, sizeof(*req));
+    if (req == NULL) {
+        return -1;
+    }
+
+    void *json_obj = neu_json_decode_new(buf);
+    if (NULL == json_obj) {
+        free(req);
+        return -1;
+    }
+
+    neu_json_elem_t req_elems[] = {
+        {
+            .name = "template",
+            .t    = NEU_JSON_STR,
+        },
+        {
+            .name = "group",
+            .t    = NEU_JSON_STR,
+        },
+        {
+            .name      = "new_name",
+            .t         = NEU_JSON_STR,
+            .attribute = NEU_JSON_ATTRIBUTE_OPTIONAL,
+        },
+    };
+    ret       = neu_json_decode_by_json(json_obj, NEU_JSON_ELEM_SIZE(req_elems),
+                                  req_elems);
+    req->tmpl = req_elems[0].v.val_str;
+    req->group    = req_elems[1].v.val_str;
+    req->new_name = req_elems[2].v.val_str;
+    if (0 != ret) {
+        goto error;
+    }
+
+    json_t *json_interval = json_object_get(json_obj, "interval");
+    if (NULL != json_interval) {
+        if (!json_is_integer(json_interval)) {
+            nlog_error("decode interval is not integer");
+            goto error;
+        }
+        req->set_interval = true;
+        req->interval     = json_integer_value(json_interval);
+    } else if (NULL == req->new_name) {
+        // at least one of `new_name` or `interval` should be provided
+        goto error;
+    }
+
+    *result = req;
+    neu_json_decode_free(json_obj);
+    return 0;
+
+error:
+    neu_json_decode_template_update_group_req_free(req);
+    neu_json_decode_free(json_obj);
+    return -1;
+}
+
+void neu_json_decode_template_update_group_req_free(
+    neu_json_template_update_group_req_t *req)
+{
+    free(req->tmpl);
+    free(req->group);
+    free(req->new_name);
+
+    free(req);
+}
+
 int neu_json_encode_template_del_group_req(void *json_object, void *param)
 {
     int                                ret = 0;
diff --git a/src/parser/neu_json_template.h b/src/parser/neu_json_template.h
index 8864021a..9a710a66 100644
--- a/src/parser/neu_json_template.h
+++ b/src/parser/neu_json_template.h
@@ -89,6 +89,19 @@ int neu_json_decode_template_mod_group_req(
 void neu_json_decode_template_mod_group_req_free(
     neu_json_template_mod_group_req_t *req);
 
+typedef struct {
+    char *  tmpl;
+    char *  group;
+    char *  new_name;
+    bool    set_interval;
+    int64_t interval;
+} neu_json_template_update_group_req_t;
+
+int neu_json_decode_template_update_group_req(
+    char *buf, neu_json_template_update_group_req_t **result);
+void neu_json_decode_template_update_group_req_free(
+    neu_json_template_update_group_req_t *req);
+
 typedef struct {
     char *tmpl;
     char *group;

From 148cf4d21203f2a327822d40a6b32e76e6a0b992 Mon Sep 17 00:00:00 2001
From: eeff <33566201+eeff@users.noreply.github.com>
Date: Wed, 6 Sep 2023 13:58:41 +0800
Subject: [PATCH 2/4] feat(core): support update template group name

---
 include/neuron/adapter.h         |  9 ++++++++-
 include/neuron/persist/persist.h |  2 ++
 src/adapter/storage.c            |  4 ++--
 src/base/template.c              | 29 +++++++++++++++++++++++++++--
 src/base/template.h              |  6 ++++--
 src/core/manager.c               |  8 ++------
 src/core/manager_internal.c      | 16 +++++++++++++++-
 src/core/storage.c               | 12 +++++++-----
 src/core/storage.h               |  3 ++-
 src/persist/persist.c            | 28 ++++++++++++++++++++++++----
 10 files changed, 93 insertions(+), 24 deletions(-)

diff --git a/include/neuron/adapter.h b/include/neuron/adapter.h
index 1b479adc..b0605556 100644
--- a/include/neuron/adapter.h
+++ b/include/neuron/adapter.h
@@ -612,7 +612,14 @@ typedef struct {
     char     tmpl[NEU_TEMPLATE_NAME_LEN];
     char     group[NEU_GROUP_NAME_LEN];
     uint32_t interval;
-} neu_req_add_template_group_t, neu_req_update_template_group_t;
+} neu_req_add_template_group_t;
+
+typedef struct {
+    char     tmpl[NEU_TEMPLATE_NAME_LEN];
+    char     group[NEU_GROUP_NAME_LEN];
+    char     new_name[NEU_GROUP_NAME_LEN];
+    uint32_t interval;
+} neu_req_update_template_group_t;
 
 typedef struct {
     char tmpl[NEU_TEMPLATE_NAME_LEN];
diff --git a/include/neuron/persist/persist.h b/include/neuron/persist/persist.h
index 5cfe01f5..0a427626 100644
--- a/include/neuron/persist/persist.h
+++ b/include/neuron/persist/persist.h
@@ -383,10 +383,12 @@ int neu_persister_store_template_group(const char *              tmpl_name,
 /**
  * Update template group.
  * @param tmpl_name                 template name.
+ * @param group_name                group name.
  * @param group_info                group info to persist.
  * @return 0 on success, non-zero otherwise
  */
 int neu_persister_update_template_group(const char *              tmpl_name,
+                                        const char *              group_name,
                                         neu_persist_group_info_t *group_info);
 
 /**
diff --git a/src/adapter/storage.c b/src/adapter/storage.c
index ed69c2b0..d4b00812 100644
--- a/src/adapter/storage.c
+++ b/src/adapter/storage.c
@@ -54,8 +54,8 @@ void adapter_storage_update_group(const char *node, const char *group,
 
     int rv = neu_persister_update_group(node, group, &info);
     if (0 != rv) {
-        nlog_error("fail update adapter:%s group:%s, interval: %u", node, group,
-                   interval);
+        nlog_error("fail update adapter:%s group:%s, new_name:%s interval: %u",
+                   node, group, new_name, interval);
     }
 }
 
diff --git a/src/base/template.c b/src/base/template.c
index 4adc3a17..f76c19bf 100644
--- a/src/base/template.c
+++ b/src/base/template.c
@@ -145,8 +145,8 @@ int neu_template_del_group(neu_template_t *tmpl, const char *group)
     return 0;
 }
 
-int neu_template_update_group(neu_template_t *tmpl, const char *group,
-                              uint32_t interval)
+int neu_template_update_group_interval(neu_template_t *tmpl, const char *group,
+                                       uint32_t interval)
 {
     group_entry_t *ent = NULL;
     HASH_FIND(hh, tmpl->groups, group, strlen(group), ent);
@@ -157,6 +157,31 @@ int neu_template_update_group(neu_template_t *tmpl, const char *group,
     return neu_group_update(ent->group, interval);
 }
 
+int neu_template_update_group_name(neu_template_t *tmpl, const char *group,
+                                   const char *new_name)
+{
+    if (0 == strcmp(group, new_name)) {
+        return 0;
+    }
+
+    if (NULL != neu_template_get_group(tmpl, new_name)) {
+        return NEU_ERR_GROUP_EXIST;
+    }
+
+    group_entry_t *ent = NULL;
+    HASH_FIND(hh, tmpl->groups, group, strlen(group), ent);
+    if (NULL == ent) {
+        return NEU_ERR_GROUP_NOT_EXIST;
+    }
+
+    HASH_DEL(tmpl->groups, ent);
+    int rv   = neu_group_set_name(ent->group, new_name);
+    new_name = neu_group_get_name(ent->group);
+    HASH_ADD_KEYPTR(hh, tmpl->groups, new_name, strlen(new_name), ent);
+
+    return rv;
+}
+
 size_t neu_template_group_num(const neu_template_t *tmpl)
 {
     return HASH_COUNT(tmpl->groups);
diff --git a/src/base/template.h b/src/base/template.h
index 339d33c8..f8b38dcd 100644
--- a/src/base/template.h
+++ b/src/base/template.h
@@ -51,8 +51,10 @@ neu_group_t *neu_template_get_group(const neu_template_t *tmpl,
 int neu_template_add_group(neu_template_t *tmpl, const char *group,
                            uint32_t interval);
 int neu_template_del_group(neu_template_t *tmpl, const char *group);
-int neu_template_update_group(neu_template_t *tmpl, const char *group,
-                              uint32_t interval);
+int neu_template_update_group_interval(neu_template_t *tmpl, const char *group,
+                                       uint32_t interval);
+int neu_template_update_group_name(neu_template_t *tmpl, const char *group,
+                                   const char *new_name);
 
 // Iterate through groups in the template and apply `cb` each.
 // NOTE: `cb` must not alter the group name or delete the group.
diff --git a/src/core/manager.c b/src/core/manager.c
index fc84e047..2627fd51 100644
--- a/src/core/manager.c
+++ b/src/core/manager.c
@@ -441,15 +441,11 @@ static int manager_loop(enum neu_event_io_type type, int fd, void *usr_data)
             (neu_req_update_template_group_t *) &header[1];
         neu_resp_error_t e = { 0 };
 
-        if (cmd->interval < NEU_GROUP_INTERVAL_LIMIT) {
-            e.error = NEU_ERR_GROUP_PARAMETER_INVALID;
-        } else {
-            e.error = neu_manager_update_template_group(manager, cmd);
-        }
+        e.error = neu_manager_update_template_group(manager, cmd);
 
         if (e.error == NEU_ERR_SUCCESS) {
             manager_storage_update_template_group(cmd->tmpl, cmd->group,
-                                                  cmd->interval);
+                                                  cmd->new_name, cmd->interval);
         }
 
         neu_msg_exchange(header);
diff --git a/src/core/manager_internal.c b/src/core/manager_internal.c
index 8b843f93..71938ec6 100644
--- a/src/core/manager_internal.c
+++ b/src/core/manager_internal.c
@@ -332,7 +332,21 @@ int neu_manager_update_template_group(neu_manager_t *                  manager,
         return NEU_ERR_TEMPLATE_NOT_FOUND;
     }
 
-    return neu_template_update_group(tmpl, req->group, req->interval);
+    int rv = 0;
+
+    if (strlen(req->new_name) > 0 && 0 != strcmp(req->group, req->new_name)) {
+        rv = neu_template_update_group_name(tmpl, req->group, req->new_name);
+        if (0 != rv) {
+            return rv;
+        }
+    }
+
+    if (req->interval >= NEU_GROUP_INTERVAL_LIMIT) {
+        rv = neu_template_update_group_interval(tmpl, req->new_name,
+                                                req->interval);
+    }
+
+    return rv;
 }
 
 int neu_manager_del_template_group(neu_manager_t *               manager,
diff --git a/src/core/storage.c b/src/core/storage.c
index 46a1311c..9caea1a0 100644
--- a/src/core/storage.c
+++ b/src/core/storage.c
@@ -234,17 +234,19 @@ void manager_storage_add_template_group(const char *tmpl, const char *group,
 }
 
 void manager_storage_update_template_group(const char *tmpl, const char *group,
-                                           uint32_t interval)
+                                           const char *new_name,
+                                           uint32_t    interval)
 {
     neu_persist_group_info_t info = {
-        .name     = (char *) group,
+        .name     = (char *) new_name,
         .interval = interval,
     };
 
-    int rv = neu_persister_update_template_group(tmpl, &info);
+    int rv = neu_persister_update_template_group(tmpl, group, &info);
     if (0 != rv) {
-        nlog_error("update template:%s grp:%s, interval:%" PRIu32 " fail", tmpl,
-                   group, interval);
+        nlog_error("update template:%s group:%s, new_name:%s interval:%" PRIu32
+                   " fail",
+                   tmpl, group, new_name, interval);
     }
 }
 
diff --git a/src/core/storage.h b/src/core/storage.h
index 0ce6e798..ed46b08c 100644
--- a/src/core/storage.h
+++ b/src/core/storage.h
@@ -55,7 +55,8 @@ void manager_storage_clear_templates(neu_manager_t *manager);
 void manager_storage_add_template_group(const char *tmpl, const char *group,
                                         uint32_t interval);
 void manager_storage_update_template_group(const char *tmpl, const char *group,
-                                           uint32_t interval);
+                                           const char *new_name,
+                                           uint32_t    interval);
 void manager_storage_del_template_group(const char *tmpl, const char *group);
 void manager_storage_add_template_tag(const char *tmpl, const char *group,
                                       const neu_datatag_t *tag);
diff --git a/src/persist/persist.c b/src/persist/persist.c
index f1313bc7..0540a4b8 100644
--- a/src/persist/persist.c
+++ b/src/persist/persist.c
@@ -1487,12 +1487,32 @@ int neu_persister_store_template_group(const char *              tmpl_name,
 }
 
 int neu_persister_update_template_group(const char *              tmpl_name,
+                                        const char *              group_name,
                                         neu_persist_group_info_t *group_info)
 {
-    return execute_sql(
-        global_db,
-        "UPDATE template_groups SET interval=%i WHERE tmpl_name=%Q AND name=%Q",
-        group_info->interval, tmpl_name, group_info->name);
+    int  ret             = -1;
+    bool update_name     = (0 != strcmp(group_name, group_info->name));
+    bool update_interval = (NEU_GROUP_INTERVAL_LIMIT <= group_info->interval);
+
+    if (update_name && update_interval) {
+        ret = execute_sql(global_db,
+                          "UPDATE template_groups SET name=%Q, interval=%i "
+                          "WHERE tmpl_name=%Q AND name=%Q",
+                          group_info->name, group_info->interval, tmpl_name,
+                          group_name);
+    } else if (update_name) {
+        ret = execute_sql(global_db,
+                          "UPDATE template_groups SET name=%Q "
+                          "WHERE tmpl_name=%Q AND name=%Q",
+                          group_info->name, tmpl_name, group_name);
+    } else if (update_interval) {
+        ret = execute_sql(global_db,
+                          "UPDATE template_groups SET interval=%i "
+                          "WHERE tmpl_name=%Q AND name=%Q",
+                          group_info->interval, tmpl_name, group_name);
+    }
+
+    return ret;
 }
 
 int neu_persister_load_template_groups(const char *tmpl_name,

From 8edbee9f6356c67319b399b139f5ec4b95a47ed3 Mon Sep 17 00:00:00 2001
From: eeff <33566201+eeff@users.noreply.github.com>
Date: Wed, 6 Sep 2023 14:03:23 +0800
Subject: [PATCH 3/4] feat(restful): support update template group name

---
 plugins/restful/template_handle.c | 78 ++++++++++++++++++++++++++-----
 src/parser/neu_json_template.c    | 16 +++----
 src/parser/neu_json_template.h    | 12 ++---
 3 files changed, 81 insertions(+), 25 deletions(-)

diff --git a/plugins/restful/template_handle.c b/plugins/restful/template_handle.c
index d99430f3..69673f08 100644
--- a/plugins/restful/template_handle.c
+++ b/plugins/restful/template_handle.c
@@ -338,8 +338,8 @@ void handle_get_templates_resp(nng_aio *aio, neu_resp_get_templates_t *resp)
 }
 
 static inline int
-send_template_mod_group_req(nng_aio *aio, neu_reqresp_type_e type,
-                            neu_json_template_mod_group_req_t *req)
+send_template_add_group_req(nng_aio *                          aio,
+                            neu_json_template_add_group_req_t *req)
 {
     neu_plugin_t *plugin = neu_rest_get_plugin();
 
@@ -358,7 +358,7 @@ send_template_mod_group_req(nng_aio *aio, neu_reqresp_type_e type,
 
     neu_reqresp_head_t header = {
         .ctx  = aio,
-        .type = type,
+        .type = NEU_REQ_ADD_TEMPLATE_GROUP,
     };
 
     if (0 != neu_plugin_op(plugin, header, &cmd)) {
@@ -368,13 +368,12 @@ send_template_mod_group_req(nng_aio *aio, neu_reqresp_type_e type,
     return 0;
 }
 
-static inline void process_mod_template_group(nng_aio *          aio,
-                                              neu_reqresp_type_e type)
+void handle_add_template_group(nng_aio *aio)
 {
     NEU_PROCESS_HTTP_REQUEST_VALIDATE_JWT(
-        aio, neu_json_template_mod_group_req_t,
-        neu_json_decode_template_mod_group_req, {
-            int ret = send_template_mod_group_req(aio, type, req);
+        aio, neu_json_template_add_group_req_t,
+        neu_json_decode_template_add_group_req, {
+            int ret = send_template_add_group_req(aio, req);
             if (ret != 0) {
                 NEU_JSON_RESPONSE_ERROR(
                     ret, { neu_http_response(aio, ret, result_error); });
@@ -382,14 +381,71 @@ static inline void process_mod_template_group(nng_aio *          aio,
         })
 }
 
-void handle_add_template_group(nng_aio *aio)
+static inline int
+send_template_update_group_req(nng_aio *                             aio,
+                               neu_json_template_update_group_req_t *req)
 {
-    process_mod_template_group(aio, NEU_REQ_ADD_TEMPLATE_GROUP);
+    neu_plugin_t *plugin = neu_rest_get_plugin();
+
+    if (strlen(req->tmpl) >= NEU_TEMPLATE_NAME_LEN) {
+        return NEU_ERR_TEMPLATE_NAME_TOO_LONG;
+    } else if (strlen(req->group) >= NEU_GROUP_NAME_LEN) {
+        return NEU_ERR_GROUP_NAME_TOO_LONG;
+    } else if (req->set_interval &&
+               (req->interval < NEU_GROUP_INTERVAL_LIMIT ||
+                req->interval > UINT32_MAX)) {
+        return NEU_ERR_GROUP_PARAMETER_INVALID;
+    }
+
+    // for backward compatibility,
+    // `new_name` or `interval` (inclusive) should be provided
+    if (!req->new_name && !req->set_interval) {
+        return NEU_ERR_BODY_IS_WRONG;
+    }
+
+    neu_req_update_template_group_t cmd = { 0 };
+
+    if (req->new_name) {
+        // if `new_name` is provided, then it should be valid
+        int len = strlen(req->new_name);
+        if (0 == len) {
+            return NEU_ERR_BODY_IS_WRONG;
+        } else if (len >= NEU_GROUP_NAME_LEN) {
+            return NEU_ERR_GROUP_NAME_TOO_LONG;
+        }
+        strcpy(cmd.new_name, req->new_name);
+    } else {
+        // if `new_name` is omitted, then keep the group name
+        strcpy(cmd.new_name, req->group);
+    }
+
+    strcpy(cmd.tmpl, req->tmpl);
+    strcpy(cmd.group, req->group);
+    cmd.interval = req->interval;
+
+    neu_reqresp_head_t header = {
+        .ctx  = aio,
+        .type = NEU_REQ_UPDATE_TEMPLATE_GROUP,
+    };
+
+    if (0 != neu_plugin_op(plugin, header, &cmd)) {
+        return NEU_ERR_IS_BUSY;
+    }
+
+    return 0;
 }
 
 void handle_update_template_group(nng_aio *aio)
 {
-    process_mod_template_group(aio, NEU_REQ_UPDATE_TEMPLATE_GROUP);
+    NEU_PROCESS_HTTP_REQUEST_VALIDATE_JWT(
+        aio, neu_json_template_update_group_req_t,
+        neu_json_decode_template_update_group_req, {
+            int ret = send_template_update_group_req(aio, req);
+            if (ret != 0) {
+                NEU_JSON_RESPONSE_ERROR(
+                    ret, { neu_http_response(aio, ret, result_error); });
+            }
+        })
 }
 
 static inline int
diff --git a/src/parser/neu_json_template.c b/src/parser/neu_json_template.c
index f7c9fc16..2cd6f868 100644
--- a/src/parser/neu_json_template.c
+++ b/src/parser/neu_json_template.c
@@ -378,10 +378,10 @@ int neu_json_encode_get_templates_resp(void *json_obj, void *param)
                                  NEU_JSON_ELEM_SIZE(req_elems));
 }
 
-int neu_json_encode_template_mod_group_req(void *json_obj, void *param)
+int neu_json_encode_template_add_group_req(void *json_obj, void *param)
 {
     int                                ret = 0;
-    neu_json_template_mod_group_req_t *req = param;
+    neu_json_template_add_group_req_t *req = param;
 
     neu_json_elem_t req_elems[] = { {
                                         .name      = "template",
@@ -404,12 +404,12 @@ int neu_json_encode_template_mod_group_req(void *json_obj, void *param)
     return ret;
 }
 
-int neu_json_decode_template_mod_group_req(
-    char *buf, neu_json_template_mod_group_req_t **result)
+int neu_json_decode_template_add_group_req(
+    char *buf, neu_json_template_add_group_req_t **result)
 {
     int                                ret      = 0;
     void *                             json_obj = NULL;
-    neu_json_template_mod_group_req_t *req      = NULL;
+    neu_json_template_add_group_req_t *req      = NULL;
 
     json_obj = neu_json_decode_new(buf);
     if (NULL == json_obj) {
@@ -449,13 +449,13 @@ int neu_json_decode_template_mod_group_req(
     return 0;
 
 decode_fail:
-    neu_json_decode_template_mod_group_req_free(req);
+    neu_json_decode_template_add_group_req_free(req);
     neu_json_decode_free(json_obj);
     return -1;
 }
 
-void neu_json_decode_template_mod_group_req_free(
-    neu_json_template_mod_group_req_t *req)
+void neu_json_decode_template_add_group_req_free(
+    neu_json_template_add_group_req_t *req)
 {
     if (req) {
         free(req->tmpl);
diff --git a/src/parser/neu_json_template.h b/src/parser/neu_json_template.h
index 9a710a66..cb58e6dc 100644
--- a/src/parser/neu_json_template.h
+++ b/src/parser/neu_json_template.h
@@ -81,13 +81,13 @@ typedef struct {
     char *  tmpl;
     char *  group;
     int64_t interval;
-} neu_json_template_mod_group_req_t;
+} neu_json_template_add_group_req_t;
 
-int neu_json_encode_template_mod_group_req(void *json_obj, void *param);
-int neu_json_decode_template_mod_group_req(
-    char *buf, neu_json_template_mod_group_req_t **result);
-void neu_json_decode_template_mod_group_req_free(
-    neu_json_template_mod_group_req_t *req);
+int neu_json_encode_template_add_group_req(void *json_obj, void *param);
+int neu_json_decode_template_add_group_req(
+    char *buf, neu_json_template_add_group_req_t **result);
+void neu_json_decode_template_add_group_req_free(
+    neu_json_template_add_group_req_t *req);
 
 typedef struct {
     char *  tmpl;

From aaaf68ddc313a4377e610c85e7890e4ebe15df5a Mon Sep 17 00:00:00 2001
From: eeff <33566201+eeff@users.noreply.github.com>
Date: Wed, 6 Sep 2023 15:57:00 +0800
Subject: [PATCH 4/4] test: add ft for template group name update

---
 ft/resource/api.resource |   5 +-
 ft/template.robot        | 105 +++++++++++++++++++++++++++++++++++----
 2 files changed, 99 insertions(+), 11 deletions(-)

diff --git a/ft/resource/api.resource b/ft/resource/api.resource
index 1379dd38..446d0f55 100644
--- a/ft/resource/api.resource
+++ b/ft/resource/api.resource
@@ -258,8 +258,9 @@ Add Template Group
   [RETURN]            ${res}[0]
 
 Put Template Group
-  [Arguments]         ${tmpl}                 ${group}            ${interval}
-  PUT                 /api/v2/template/group  {"template": "${tmpl}", "group": "${group}", "interval": ${interval}}
+  [Arguments]         ${tmpl}                 ${group}            &{updates}
+  ${data} =           Evaluate                json.dumps({"template": "${tmpl}", "group": "${group}", **$updates})     json
+  PUT                 /api/v2/template/group  ${data}
   ${res} =            Object  response body
   [RETURN]            ${res}[0]
 
diff --git a/ft/template.robot b/ft/template.robot
index 5bc02fda..814642b4 100644
--- a/ft/template.robot
+++ b/ft/template.robot
@@ -496,7 +496,7 @@ Get groups from existent template having one group, it should success.
 
 
 Update group interval when template does not exist, it should fail.
-    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     ${1000}
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     interval=${1000}
     Check Response Status         ${res}                404
     Check Error Code              ${res}                ${NEU_ERR_TEMPLATE_NOT_FOUND}
 
@@ -508,7 +508,7 @@ Update group using too long template name in request, it should fail.
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
-    ${res} =                      Put Template Group    ${g_long_str}                 ${g_group1}[name]     ${2000}
+    ${res} =                      Put Template Group    ${g_long_str}                 ${g_group1}[name]     interval=${2000}
     Check Response Status         ${res}                400
     Check Error Code              ${res}                ${NEU_ERR_TEMPLATE_NAME_TOO_LONG}
 
@@ -520,7 +520,7 @@ Update group using too long group name in request, it should fail.
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
-    ${res} =                      Put Template Group    ${g_template}                 ${g_long_str}         ${2000}
+    ${res} =                      Put Template Group    ${g_template}                 ${g_long_str}         interval=${2000}
     Check Response Status         ${res}                400
     Check Error Code              ${res}                ${NEU_ERR_GROUP_NAME_TOO_LONG}
 
@@ -532,7 +532,7 @@ Update group interval when group does not exist, it should fail.
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
-    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     ${1000}
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     interval=${1000}
     Check Response Status         ${res}                404
     Check Error Code              ${res}                ${NEU_ERR_GROUP_NOT_EXIST}
 
@@ -544,7 +544,7 @@ Update group interval to invalid value, it should fail.
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
-    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     ${10}
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     interval=${10}
     Check Response Status         ${res}                400
     Check Error Code              ${res}                ${NEU_ERR_GROUP_PARAMETER_INVALID}
 
@@ -556,7 +556,7 @@ Update group interval, it should success.
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
-    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     ${1000}
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     interval=${1000}
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
@@ -568,6 +568,93 @@ Update group interval, it should success.
     [Teardown]                    Del Template          ${g_template}
 
 
+Update group with empty new name, it should fail.
+    ${res} =                      Add Template          ${g_template}                 ${g_plugin}           ${g_groups}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     new_name=${EMPTY}
+    Check Response Status         ${res}                400
+    Check Error Code              ${res}                ${NEU_ERR_BODY_IS_WRONG}
+
+    [Teardown]                    Del Template          ${g_template}
+
+
+Update group with too long new name, it should fail.
+    ${res} =                      Add Template          ${g_template}                 ${g_plugin}           ${g_groups}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     new_name=${g_long_str}
+    Check Response Status         ${res}                400
+    Check Error Code              ${res}                ${NEU_ERR_GROUP_NAME_TOO_LONG}
+
+    [Teardown]                    Del Template          ${g_template}
+
+
+Update group name to conflicting group name, it should fail.
+    ${res} =                      Add Template          ${g_template}                 ${g_plugin}           ${g_groups}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Add Template Group    ${g_template}                 grp                   ${1000}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     new_name=grp
+    Check Response Status         ${res}                409
+    Check Error Code              ${res}                ${NEU_ERR_GROUP_EXIST}
+
+    [Teardown]                    Del Template          ${g_template}
+
+
+Update group name, it should success.
+    ${res} =                      Add Template          ${g_template}                 ${g_plugin}           ${g_groups}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     new_name=grp
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Get Template Groups   ${g_template}
+    Check Response Status         ${res}                200
+    Should Have Only One Group    ${res}[groups]        grp                           ${g_group1}[interval]
+    Group Tag Count Should Be     ${res}[groups][0]     2
+
+    [Teardown]                    Del Template          ${g_template}
+
+
+Update group with at least name or interval, otherwise it should fail.
+    ${res} =                      Add Template          ${g_template}                 ${g_plugin}           ${g_groups}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]
+    Check Response Status         ${res}                400
+    Check Error Code              ${res}                ${NEU_ERR_BODY_IS_WRONG}
+
+    [Teardown]                    Del Template          ${g_template}
+
+
+Update group name and interval, it should success.
+    ${res} =                      Add Template          ${g_template}                 ${g_plugin}           ${g_groups}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     new_name=grp      interval=${1000}
+    Check Response Status         ${res}                200
+    Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
+
+    ${res} =                      Get Template Groups   ${g_template}
+    Check Response Status         ${res}                200
+    Should Have Only One Group    ${res}[groups]        grp                           ${1000}
+    Group Tag Count Should Be     ${res}[groups][0]     2
+
+    [Teardown]                    Del Template          ${g_template}
+
+
 Delete group from nonexistent template, it should fail.
     ${res} =                      Del Template Group    ${g_template}                 ${g_group1}[name]
     Check Response Status         ${res}                404
@@ -642,7 +729,7 @@ Template groups should be persisted.
     Should Have Only One Group    ${res}[groups]        ${g_group1}[name]             ${g_group1}[interval]
     Group Tag Count Should Be     ${res}[groups][0]     0
 
-    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     ${1000}
+    ${res} =                      Put Template Group    ${g_template}                 ${g_group1}[name]     new_name=grp      interval=${1000}
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}
 
@@ -650,10 +737,10 @@ Template groups should be persisted.
 
     ${res} =                      Get Template Groups   ${g_template}
     Check Response Status         ${res}                200
-    Should Have Only One Group    ${res}[groups]        ${g_group1}[name]             ${1000}
+    Should Have Only One Group    ${res}[groups]        grp                           ${1000}
     Group Tag Count Should Be     ${res}[groups][0]     0
 
-    ${res} =                      Del Template Group    ${g_template}                 ${g_group1}[name]
+    ${res} =                      Del Template Group    ${g_template}                 grp
     Check Response Status         ${res}                200
     Check Error Code              ${res}                ${NEU_ERR_SUCCESS}