From 2589c3bcb9f6fb1206f88c5b65bef3c308ffc3cc Mon Sep 17 00:00:00 2001
From: Shengliang Guan <slguan@taosdata.com>
Date: Mon, 13 Dec 2021 18:19:09 +0800
Subject: [PATCH] TD-10431 create user test

---
 source/dnode/mgmt/impl/test/dnode/dnode.cpp |  11 +-
 source/dnode/mgmt/impl/test/user/user.cpp   | 489 +++++++-------------
 source/dnode/mnode/impl/src/mndUser.c       |   9 +-
 source/dnode/mnode/sdb/src/sdb.c            |   4 +-
 4 files changed, 183 insertions(+), 330 deletions(-)

diff --git a/source/dnode/mgmt/impl/test/dnode/dnode.cpp b/source/dnode/mgmt/impl/test/dnode/dnode.cpp
index c156852905..fba3794f6a 100644
--- a/source/dnode/mgmt/impl/test/dnode/dnode.cpp
+++ b/source/dnode/mgmt/impl/test/dnode/dnode.cpp
@@ -271,7 +271,6 @@ TEST_F(DndTestDnode, DropDnode_01) {
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, 0);
 
-  taosMsleep(1300);
   SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
   SendThenCheckShowRetrieveMsg(1);
   CheckInt16(1);
@@ -363,7 +362,7 @@ TEST_F(DndTestDnode, CreateDnode_02) {
 }
 
 TEST_F(DndTestDnode, RestartDnode_01) {
-  uInfo("===> stop all server");
+  uInfo("stop all server");
   stopServer(pServer1);
   stopServer(pServer2);
   stopServer(pServer3);
@@ -375,14 +374,16 @@ TEST_F(DndTestDnode, RestartDnode_01) {
   pServer4 = NULL;
   pServer5 = NULL;
 
-  taosMsleep(3000);  // wait tcp port cleanedup
-  uInfo("===> start all server");
+  uInfo("start all server");
 
   const char* fqdn = "localhost";
   const char* firstEp = "localhost:9521";
   pServer1 = startServer("/tmp/dndTestDnode1", fqdn, 9521, firstEp);
+  // pServer1 = startServer("/tmp/dndTestDnode3", fqdn, 9523, firstEp);
+  // pServer1 = startServer("/tmp/dndTestDnode4", fqdn, 9524, firstEp);
+  // pServer1 = startServer("/tmp/dndTestDnode5", fqdn, 9525, firstEp);
 
-  uInfo("===> all server is running");
+  uInfo("all server is running");
 
   // taosMsleep(1300);
   // SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_DNODE, "show dnodes", 7);
diff --git a/source/dnode/mgmt/impl/test/user/user.cpp b/source/dnode/mgmt/impl/test/user/user.cpp
index c3c1d1d406..137e271b32 100644
--- a/source/dnode/mgmt/impl/test/user/user.cpp
+++ b/source/dnode/mgmt/impl/test/user/user.cpp
@@ -17,202 +17,174 @@
 
 class DndTestUser : public ::testing::Test {
  protected:
-  void SetUp() override {}
-  void TearDown() override {}
+  static SServer* CreateServer(const char* path, const char* fqdn, uint16_t port, const char* firstEp) {
+    SServer* pServer = createServer(path, fqdn, port, firstEp);
+    ASSERT(pServer);
+    return pServer;
+  }
 
   static void SetUpTestSuite() {
-    const char* user = "root";
-    const char* pass = "taosdata";
-    const char* path = "/tmp/dndTestUser";
-    const char* fqdn = "localhost";
-    uint16_t    port = 9524;
-    const char* firstEp = "localhost:9524";
+    initLog("/tmp/dndTestUser");
 
-    pServer = createServer(path, fqdn, port, firstEp);
-    ASSERT(pServer);
-    pClient = createClient(user, pass, fqdn, port);
+    const char* fqdn = "localhost";
+    const char* firstEp = "localhost:9530";
+    pServer = CreateServer("/tmp/dndTestUser", fqdn, 9530, firstEp);
+    pClient = createClient("root", "taosdata", fqdn, 9530);
+    taosMsleep(300);
   }
 
   static void TearDownTestSuite() {
     stopServer(pServer);
     dropClient(pClient);
+    pServer = NULL;
+    pClient = NULL;
   }
 
   static SServer* pServer;
   static SClient* pClient;
   static int32_t  connId;
+
+ public:
+  void SetUp() override {}
+  void TearDown() override {}
+
+  void SendTheCheckShowMetaMsg(int8_t showType, const char* showName, int32_t columns) {
+    SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
+    pShow->type = showType;
+    strcpy(pShow->db, "");
+
+    SRpcMsg showRpcMsg = {0};
+    showRpcMsg.pCont = pShow;
+    showRpcMsg.contLen = sizeof(SShowMsg);
+    showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
+
+    sendMsg(pClient, &showRpcMsg);
+    ASSERT_NE(pClient->pRsp, nullptr);
+    ASSERT_EQ(pClient->pRsp->code, 0);
+    ASSERT_NE(pClient->pRsp->pCont, nullptr);
+
+    SShowRsp* pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
+    ASSERT_NE(pShowRsp, nullptr);
+    pShowRsp->showId = htonl(pShowRsp->showId);
+    pMeta = &pShowRsp->tableMeta;
+    pMeta->numOfTags = htons(pMeta->numOfTags);
+    pMeta->numOfColumns = htons(pMeta->numOfColumns);
+    pMeta->sversion = htons(pMeta->sversion);
+    pMeta->tversion = htons(pMeta->tversion);
+    pMeta->tuid = htobe64(pMeta->tuid);
+    pMeta->suid = htobe64(pMeta->suid);
+
+    showId = pShowRsp->showId;
+
+    EXPECT_NE(pShowRsp->showId, 0);
+    EXPECT_STREQ(pMeta->tbFname, showName);
+    EXPECT_EQ(pMeta->numOfTags, 0);
+    EXPECT_EQ(pMeta->numOfColumns, columns);
+    EXPECT_EQ(pMeta->precision, 0);
+    EXPECT_EQ(pMeta->tableType, 0);
+    EXPECT_EQ(pMeta->update, 0);
+    EXPECT_EQ(pMeta->sversion, 0);
+    EXPECT_EQ(pMeta->tversion, 0);
+    EXPECT_EQ(pMeta->tuid, 0);
+    EXPECT_EQ(pMeta->suid, 0);
+  }
+
+  void CheckSchema(int32_t index, int8_t type, int32_t bytes, const char* name) {
+    SSchema* pSchema = &pMeta->pSchema[index];
+    pSchema->bytes = htons(pSchema->bytes);
+    EXPECT_EQ(pSchema->colId, 0);
+    EXPECT_EQ(pSchema->type, type);
+    EXPECT_EQ(pSchema->bytes, bytes);
+    EXPECT_STREQ(pSchema->name, name);
+  }
+
+  void SendThenCheckShowRetrieveMsg(int32_t rows) {
+    SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
+    pRetrieve->showId = htonl(showId);
+    pRetrieve->free = 0;
+
+    SRpcMsg retrieveRpcMsg = {0};
+    retrieveRpcMsg.pCont = pRetrieve;
+    retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
+    retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
+
+    sendMsg(pClient, &retrieveRpcMsg);
+
+    ASSERT_NE(pClient->pRsp, nullptr);
+    ASSERT_EQ(pClient->pRsp->code, 0);
+    ASSERT_NE(pClient->pRsp->pCont, nullptr);
+
+    pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
+    ASSERT_NE(pRetrieveRsp, nullptr);
+    pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
+    pRetrieveRsp->offset = htobe64(pRetrieveRsp->offset);
+    pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
+    pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
+
+    EXPECT_EQ(pRetrieveRsp->numOfRows, rows);
+    EXPECT_EQ(pRetrieveRsp->offset, 0);
+    EXPECT_EQ(pRetrieveRsp->useconds, 0);
+    // EXPECT_EQ(pRetrieveRsp->completed, completed);
+    EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
+    EXPECT_EQ(pRetrieveRsp->compressed, 0);
+    EXPECT_EQ(pRetrieveRsp->reserved, 0);
+    EXPECT_EQ(pRetrieveRsp->compLen, 0);
+
+    pData = pRetrieveRsp->data;
+    pos = 0;
+  }
+
+  void CheckInt16(int16_t val) {
+    int16_t data = *((int16_t*)(pData + pos));
+    pos += sizeof(int16_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckInt64(int64_t val) {
+    int64_t data = *((int64_t*)(pData + pos));
+    pos += sizeof(int64_t);
+    EXPECT_EQ(data, val);
+  }
+
+  void CheckTimestamp() {
+    int64_t data = *((int64_t*)(pData + pos));
+    pos += sizeof(int64_t);
+    EXPECT_GT(data, 0);
+  }
+
+  void CheckBinary(const char* val, int32_t len) {
+    pos += sizeof(VarDataLenT);
+    char* data = (char*)(pData + pos);
+    pos += len;
+    EXPECT_STREQ(data, val);
+  }
+
+  int32_t            showId;
+  STableMetaMsg*     pMeta;
+  SRetrieveTableRsp* pRetrieveRsp;
+  char*              pData;
+  int32_t            pos;
 };
 
 SServer* DndTestUser::pServer;
 SClient* DndTestUser::pClient;
 int32_t  DndTestUser::connId;
 
-#if 0
 TEST_F(DndTestUser, ShowUser) {
-  int32_t showId = 0;
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_USER, "show users", 4);
+  CheckSchema(0, TSDB_DATA_TYPE_BINARY, TSDB_USER_LEN + VARSTR_HEADER_SIZE, "name");
+  CheckSchema(1, TSDB_DATA_TYPE_BINARY, 10 + VARSTR_HEADER_SIZE, "privilege");
+  CheckSchema(2, TSDB_DATA_TYPE_TIMESTAMP, 8, "create time");
+  CheckSchema(3, TSDB_DATA_TYPE_BINARY, TSDB_USER_LEN + VARSTR_HEADER_SIZE, "account");
 
-  //--- meta ---
-  SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-  pShow->type = TSDB_MGMT_TABLE_USER;
-  strcpy(pShow->db, "");
-
-  SRpcMsg showRpcMsg = {0};
-  showRpcMsg.pCont = pShow;
-  showRpcMsg.contLen = sizeof(SShowMsg);
-  showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-  sendMsg(pClient, &showRpcMsg);
-  ASSERT_NE(pClient->pRsp, nullptr);
-
-  SShowRsp* pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
-  ASSERT_NE(pShowRsp, nullptr);
-  pShowRsp->showId = htonl(pShowRsp->showId);
-  STableMetaMsg* pMeta = &pShowRsp->tableMeta;
-  pMeta->contLen = htonl(pMeta->contLen);
-  pMeta->numOfColumns = htons(pMeta->numOfColumns);
-  pMeta->sversion = htons(pMeta->sversion);
-  pMeta->tversion = htons(pMeta->tversion);
-  pMeta->tid = htonl(pMeta->tid);
-  pMeta->uid = htobe64(pMeta->uid);
-  pMeta->suid = htobe64(pMeta->suid);
-
-  showId = pShowRsp->showId;
-
-  EXPECT_NE(pShowRsp->showId, 0);
-  EXPECT_EQ(pMeta->contLen, 0);
-  EXPECT_STREQ(pMeta->tbFname, "show users");
-  EXPECT_EQ(pMeta->numOfTags, 0);
-  EXPECT_EQ(pMeta->precision, 0);
-  EXPECT_EQ(pMeta->tableType, 0);
-  EXPECT_EQ(pMeta->numOfColumns, 4);
-  EXPECT_EQ(pMeta->sversion, 0);
-  EXPECT_EQ(pMeta->tversion, 0);
-  EXPECT_EQ(pMeta->tid, 0);
-  EXPECT_EQ(pMeta->uid, 0);
-  EXPECT_STREQ(pMeta->sTableName, "");
-  EXPECT_EQ(pMeta->suid, 0);
-
-  SSchema* pSchema = NULL;
-
-  pSchema = &pMeta->pSchema[0];
-  pSchema->bytes = htons(pSchema->bytes);
-  EXPECT_EQ(pSchema->colId, 0);
-  EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-  EXPECT_EQ(pSchema->bytes, TSDB_USER_LEN + VARSTR_HEADER_SIZE);
-  EXPECT_STREQ(pSchema->name, "name");
-
-  pSchema = &pMeta->pSchema[1];
-  pSchema->bytes = htons(pSchema->bytes);
-  EXPECT_EQ(pSchema->colId, 0);
-  EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-  EXPECT_EQ(pSchema->bytes, 10 + VARSTR_HEADER_SIZE);
-  EXPECT_STREQ(pSchema->name, "privilege");
-
-  pSchema = &pMeta->pSchema[2];
-  pSchema->bytes = htons(pSchema->bytes);
-  EXPECT_EQ(pSchema->colId, 0);
-  EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_TIMESTAMP);
-  EXPECT_EQ(pSchema->bytes, 8);
-  EXPECT_STREQ(pSchema->name, "create_time");
-
-  pSchema = &pMeta->pSchema[3];
-  pSchema->bytes = htons(pSchema->bytes);
-  EXPECT_EQ(pSchema->colId, 0);
-  EXPECT_EQ(pSchema->type, TSDB_DATA_TYPE_BINARY);
-  EXPECT_EQ(pSchema->bytes, TSDB_USER_LEN + VARSTR_HEADER_SIZE);
-  EXPECT_STREQ(pSchema->name, "account");
-
-  //--- retrieve ---
-  SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-  pRetrieve->showId = htonl(showId);
-  pRetrieve->free = 0;
-
-  SRpcMsg retrieveRpcMsg = {0};
-  retrieveRpcMsg.pCont = pRetrieve;
-  retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
-  retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-  sendMsg(pClient, &retrieveRpcMsg);
-  ASSERT_NE(pClient->pRsp, nullptr);
-  ASSERT_EQ(pClient->pRsp->code, 0);
-
-  SRetrieveTableRsp* pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
-  ASSERT_NE(pRetrieveRsp, nullptr);
-  pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
-  pRetrieveRsp->offset = htobe64(pRetrieveRsp->offset);
-  pRetrieveRsp->useconds = htobe64(pRetrieveRsp->useconds);
-  pRetrieveRsp->compLen = htonl(pRetrieveRsp->compLen);
-
-  EXPECT_EQ(pRetrieveRsp->numOfRows, 2);
-  EXPECT_EQ(pRetrieveRsp->offset, 0);
-  EXPECT_EQ(pRetrieveRsp->useconds, 0);
-  EXPECT_EQ(pRetrieveRsp->completed, 1);
-  EXPECT_EQ(pRetrieveRsp->precision, TSDB_TIME_PRECISION_MILLI);
-  EXPECT_EQ(pRetrieveRsp->compressed, 0);
-  EXPECT_EQ(pRetrieveRsp->reserved, 0);
-  EXPECT_EQ(pRetrieveRsp->compLen, 0);
-
-  char*   pData = pRetrieveRsp->data;
-  int32_t pos = 0;
-  char*   strVal = NULL;
-  int64_t int64Val = 0;
-
-  //--- name ---
-  {
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += TSDB_USER_LEN;
-    EXPECT_STREQ(strVal, "root");
-
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += TSDB_USER_LEN;
-    EXPECT_STREQ(strVal, "_root");
-  }
-
-  //--- privilege ---
-  {
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += 10;
-    EXPECT_STREQ(strVal, "super");
-
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += 10;
-    EXPECT_STREQ(strVal, "writable");
-  }
-
-  //--- create_time ---
-  {
-    int64Val = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
-    EXPECT_GT(int64Val, 0);
-
-    int64Val = *((int64_t*)(pData + pos));
-    pos += sizeof(int64_t);
-    EXPECT_GT(int64Val, 0);
-  }
-
-  //--- account ---
-  {
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += TSDB_USER_LEN;
-    EXPECT_STREQ(strVal, "root");
-
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += TSDB_USER_LEN;
-    EXPECT_STREQ(strVal, "root");
-  }
+  SendThenCheckShowRetrieveMsg(1);
+  CheckBinary("root", TSDB_USER_LEN);
+  CheckBinary("super", 10);
+  CheckTimestamp();
+  CheckBinary("root", TSDB_USER_LEN);
 }
-#endif
 
 TEST_F(DndTestUser, CreateUser_01) {
-  ASSERT_NE(pClient, nullptr);
-
-  //--- create user ---
   SCreateUserMsg* pReq = (SCreateUserMsg*)rpcMallocCont(sizeof(SCreateUserMsg));
   strcpy(pReq->user, "u1");
   strcpy(pReq->pass, "p1");
@@ -227,60 +199,19 @@ TEST_F(DndTestUser, CreateUser_01) {
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, 0);
 
-  //--- meta ---
-  SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-  pShow->type = TSDB_MGMT_TABLE_USER;
-  SRpcMsg showRpcMsg = {0};
-  showRpcMsg.pCont = pShow;
-  showRpcMsg.contLen = sizeof(SShowMsg);
-  showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-  sendMsg(pClient, &showRpcMsg);
-  SShowRsp*      pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
-  STableMetaMsg* pMeta = &pShowRsp->tableMeta;
-  pMeta->numOfColumns = htons(pMeta->numOfColumns);
-  EXPECT_EQ(pMeta->numOfColumns, 4);
-
-  //--- retrieve ---
-  SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-  pRetrieve->showId = pShowRsp->showId;
-  SRpcMsg retrieveRpcMsg = {0};
-  retrieveRpcMsg.pCont = pRetrieve;
-  retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
-  retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-  sendMsg(pClient, &retrieveRpcMsg);
-  SRetrieveTableRsp* pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
-  pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
-  EXPECT_EQ(pRetrieveRsp->numOfRows, 3);
-
-  char*   pData = pRetrieveRsp->data;
-  int32_t pos = 0;
-  char*   strVal = NULL;
-
-  //--- name ---
-  {
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += TSDB_USER_LEN;
-    EXPECT_STREQ(strVal, "u1");
-
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += TSDB_USER_LEN;
-    EXPECT_STREQ(strVal, "root");
-
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += TSDB_USER_LEN;
-    EXPECT_STREQ(strVal, "_root");
-  }
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_USER, "show users", 4);
+  SendThenCheckShowRetrieveMsg(2);
+  CheckBinary("u1", TSDB_USER_LEN);
+  CheckBinary("root", TSDB_USER_LEN);
+  CheckBinary("normal", 10);
+  CheckBinary("super", 10);
+  CheckTimestamp();
+  CheckTimestamp();
+  CheckBinary("root", TSDB_USER_LEN);
+  CheckBinary("root", TSDB_USER_LEN);
 }
 
 TEST_F(DndTestUser, AlterUser_01) {
-  ASSERT_NE(pClient, nullptr);
-
-  //--- drop user ---
   SAlterUserMsg* pReq = (SAlterUserMsg*)rpcMallocCont(sizeof(SAlterUserMsg));
   strcpy(pReq->user, "u1");
   strcpy(pReq->pass, "p2");
@@ -295,60 +226,19 @@ TEST_F(DndTestUser, AlterUser_01) {
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, 0);
 
-  //--- meta ---
-  SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-  pShow->type = TSDB_MGMT_TABLE_USER;
-  SRpcMsg showRpcMsg = {0};
-  showRpcMsg.pCont = pShow;
-  showRpcMsg.contLen = sizeof(SShowMsg);
-  showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-  sendMsg(pClient, &showRpcMsg);
-  SShowRsp*      pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
-  STableMetaMsg* pMeta = &pShowRsp->tableMeta;
-  pMeta->numOfColumns = htons(pMeta->numOfColumns);
-  EXPECT_EQ(pMeta->numOfColumns, 4);
-
-  //--- retrieve ---
-  SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-  pRetrieve->showId = pShowRsp->showId;
-  SRpcMsg retrieveRpcMsg = {0};
-  retrieveRpcMsg.pCont = pRetrieve;
-  retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
-  retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-  sendMsg(pClient, &retrieveRpcMsg);
-  SRetrieveTableRsp* pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
-  pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
-  EXPECT_EQ(pRetrieveRsp->numOfRows, 3);
-
-  char*   pData = pRetrieveRsp->data;
-  int32_t pos = 0;
-  char*   strVal = NULL;
-
-  //--- name ---
-  {
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += TSDB_USER_LEN;
-    EXPECT_STREQ(strVal, "u1");
-
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += TSDB_USER_LEN;
-    EXPECT_STREQ(strVal, "root");
-
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += TSDB_USER_LEN;
-    EXPECT_STREQ(strVal, "_root");
-  }
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_USER, "show users", 4);
+  SendThenCheckShowRetrieveMsg(2);
+  CheckBinary("u1", TSDB_USER_LEN);
+  CheckBinary("root", TSDB_USER_LEN);
+  CheckBinary("normal", 10);
+  CheckBinary("super", 10);
+  CheckTimestamp();
+  CheckTimestamp();
+  CheckBinary("root", TSDB_USER_LEN);
+  CheckBinary("root", TSDB_USER_LEN);
 }
 
 TEST_F(DndTestUser, DropUser_01) {
-  ASSERT_NE(pClient, nullptr);
-
-  //--- drop user ---
   SDropUserMsg* pReq = (SDropUserMsg*)rpcMallocCont(sizeof(SDropUserMsg));
   strcpy(pReq->user, "u1");
 
@@ -362,47 +252,10 @@ TEST_F(DndTestUser, DropUser_01) {
   ASSERT_NE(pMsg, nullptr);
   ASSERT_EQ(pMsg->code, 0);
 
-  //--- meta ---
-  SShowMsg* pShow = (SShowMsg*)rpcMallocCont(sizeof(SShowMsg));
-  pShow->type = TSDB_MGMT_TABLE_USER;
-  SRpcMsg showRpcMsg = {0};
-  showRpcMsg.pCont = pShow;
-  showRpcMsg.contLen = sizeof(SShowMsg);
-  showRpcMsg.msgType = TSDB_MSG_TYPE_SHOW;
-
-  sendMsg(pClient, &showRpcMsg);
-  SShowRsp*      pShowRsp = (SShowRsp*)pClient->pRsp->pCont;
-  STableMetaMsg* pMeta = &pShowRsp->tableMeta;
-  pMeta->numOfColumns = htons(pMeta->numOfColumns);
-  EXPECT_EQ(pMeta->numOfColumns, 4);
-
-  //--- retrieve ---
-  SRetrieveTableMsg* pRetrieve = (SRetrieveTableMsg*)rpcMallocCont(sizeof(SRetrieveTableMsg));
-  pRetrieve->showId = pShowRsp->showId;
-  SRpcMsg retrieveRpcMsg = {0};
-  retrieveRpcMsg.pCont = pRetrieve;
-  retrieveRpcMsg.contLen = sizeof(SRetrieveTableMsg);
-  retrieveRpcMsg.msgType = TSDB_MSG_TYPE_SHOW_RETRIEVE;
-
-  sendMsg(pClient, &retrieveRpcMsg);
-  SRetrieveTableRsp* pRetrieveRsp = (SRetrieveTableRsp*)pClient->pRsp->pCont;
-  pRetrieveRsp->numOfRows = htonl(pRetrieveRsp->numOfRows);
-  EXPECT_EQ(pRetrieveRsp->numOfRows, 2);
-
-  char*   pData = pRetrieveRsp->data;
-  int32_t pos = 0;
-  char*   strVal = NULL;
-
-  //--- name ---
-  {
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += TSDB_USER_LEN;
-    EXPECT_STREQ(strVal, "root");
-
-    pos += sizeof(VarDataLenT);
-    strVal = (char*)(pData + pos);
-    pos += TSDB_USER_LEN;
-    EXPECT_STREQ(strVal, "_root");
-  }
-}
\ No newline at end of file
+  SendTheCheckShowMetaMsg(TSDB_MGMT_TABLE_USER, "show users", 4);
+  SendThenCheckShowRetrieveMsg(1);
+  CheckBinary("root", TSDB_USER_LEN);
+  CheckBinary("super", 10);
+  CheckTimestamp();
+  CheckBinary("root", TSDB_USER_LEN);
+}
diff --git a/source/dnode/mnode/impl/src/mndUser.c b/source/dnode/mnode/impl/src/mndUser.c
index 2e4719cceb..2f582a810d 100644
--- a/source/dnode/mnode/impl/src/mndUser.c
+++ b/source/dnode/mnode/impl/src/mndUser.c
@@ -85,9 +85,11 @@ static int32_t mndCreateDefaultUsers(SMnode *pMnode) {
     return -1;
   }
 
+#if 0
   if (mndCreateDefaultUser(pMnode, TSDB_DEFAULT_USER, "_" TSDB_DEFAULT_USER, TSDB_DEFAULT_PASS) != 0) {
     return -1;
   }
+#endif  
 
   return 0;
 }
@@ -469,7 +471,7 @@ static int32_t mndGetUserMeta(SMnodeMsg *pMsg, SShowObj *pShow, STableMetaMsg *p
 
   pShow->bytes[cols] = 8;
   pSchema[cols].type = TSDB_DATA_TYPE_TIMESTAMP;
-  strcpy(pSchema[cols].name, "create_time");
+  strcpy(pSchema[cols].name, "create time");
   pSchema[cols].bytes = htons(pShow->bytes[cols]);
   cols++;
 
@@ -516,11 +518,8 @@ static int32_t mndRetrieveUsers(SMnodeMsg *pMsg, SShowObj *pShow, char *data, in
     if (pUser->superAuth) {
       const char *src = "super";
       STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
-    } else if (pUser->writeAuth) {
-      const char *src = "writable";
-      STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
     } else {
-      const char *src = "readable";
+      const char *src = "normal";
       STR_WITH_SIZE_TO_VARSTR(pWrite, src, strlen(src));
     }
     cols++;
diff --git a/source/dnode/mnode/sdb/src/sdb.c b/source/dnode/mnode/sdb/src/sdb.c
index 1d4888c2eb..ccff5b6c82 100644
--- a/source/dnode/mnode/sdb/src/sdb.c
+++ b/source/dnode/mnode/sdb/src/sdb.c
@@ -52,10 +52,10 @@ SSdb *sdbInit(SSdbOpt *pOption) {
 void sdbCleanup(SSdb *pSdb) {
   mDebug("start to cleanup sdb");
 
-  if (pSdb->curVer != pSdb->lastCommitVer) {
+  // if (pSdb->curVer != pSdb->lastCommitVer) {
     mDebug("write sdb file for curVer:% " PRId64 " and lastVer:%" PRId64, pSdb->curVer, pSdb->lastCommitVer);
     sdbWriteFile(pSdb);
-  }
+  // }
 
   if (pSdb->currDir != NULL) {
     tfree(pSdb->currDir);