245 lines
8.9 KiB
C++
245 lines
8.9 KiB
C++
/**
|
|
* Copyright (c) 2021 OceanBase
|
|
* OceanBase CE is licensed under Mulan PubL v2.
|
|
* You can use this software according to the terms and conditions of the Mulan PubL v2.
|
|
* You may obtain a copy of Mulan PubL v2 at:
|
|
* http://license.coscl.org.cn/MulanPubL-2.0
|
|
* THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
|
|
* EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
|
|
* MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
|
|
* See the Mulan PubL v2 for more details.
|
|
*/
|
|
|
|
#include <gtest/gtest.h>
|
|
#include "lib/allocator/ob_tc_malloc.h"
|
|
#include "lib/utility/utility.h"
|
|
#include "share/schema/ob_schema_struct.h"
|
|
#include "ob_schema_test_utils.cpp"
|
|
using namespace oceanbase::common;
|
|
using namespace oceanbase::share::schema;
|
|
|
|
TEST(ObPrivStructTest, ob_tenant_user_id)
|
|
{
|
|
ObTenantUserId tenant_user_id(2, 1);
|
|
ObTenantUserId tenant_user_id_eq(2, 1);
|
|
ObTenantUserId tenant_user_id_big(2, 2);
|
|
|
|
ASSERT_TRUE(tenant_user_id == tenant_user_id_eq);
|
|
ASSERT_TRUE(tenant_user_id.hash() == tenant_user_id_eq.hash());
|
|
ASSERT_FALSE(tenant_user_id == tenant_user_id_big);
|
|
ASSERT_TRUE(tenant_user_id < tenant_user_id_big);
|
|
|
|
const int64_t buf_len = 256;
|
|
char buffer[buf_len];
|
|
int64_t pos = 0;
|
|
tenant_user_id.serialize(buffer, buf_len, pos);
|
|
ObTenantUserId tenant_user_id_des;
|
|
pos = 0;
|
|
tenant_user_id_des.deserialize(buffer, buf_len, pos);
|
|
ASSERT_TRUE(tenant_user_id == tenant_user_id_des);
|
|
}
|
|
|
|
TEST(ObPrivStructTest, ob_priv)
|
|
{
|
|
ObPrivSet priv_set = OB_PRIV_CREATE | OB_PRIV_SELECT;
|
|
ObPrivSet priv_set_other = OB_PRIV_CREATE | OB_PRIV_ALTER;
|
|
|
|
const int64_t schema_version = INT64_MAX;
|
|
ObPriv ob_priv(2, 1, schema_version, priv_set);
|
|
ObPriv ob_priv_eq(2, 1, schema_version, priv_set);
|
|
ObPriv ob_priv_big(2, 2, schema_version, priv_set_other);
|
|
|
|
ASSERT_EQ(priv_set, ob_priv.get_priv_set());
|
|
ASSERT_EQ(priv_set_other, ob_priv_big.get_priv_set());
|
|
//cmp_tenant_user_id lhs->get_tenant_user_id < tenant_user_id
|
|
ASSERT_TRUE(ObPriv::cmp_tenant_user_id(&ob_priv, ob_priv_big.get_tenant_user_id()));
|
|
ASSERT_FALSE(ObPriv::cmp_tenant_user_id(&ob_priv, ob_priv_eq.get_tenant_user_id()));
|
|
ASSERT_FALSE(ObPriv::cmp_tenant_user_id(&ob_priv_big, ObTenantUserId(2, 2)));
|
|
ASSERT_TRUE(ObPriv::equal_tenant_user_id(&ob_priv, ob_priv_eq.get_tenant_user_id()));
|
|
|
|
ob_priv.set_tenant_id(3);
|
|
ASSERT_EQ(3UL, ob_priv.get_tenant_id());
|
|
ASSERT_TRUE(ObPriv::cmp_tenant_id(&ob_priv_eq, ob_priv.get_tenant_id()));
|
|
ob_priv.set_user_id(4);
|
|
ASSERT_EQ(4UL, ob_priv.get_user_id());
|
|
|
|
ob_priv.set_priv_set(priv_set_other);
|
|
ASSERT_EQ(priv_set_other, ob_priv.get_priv_set());
|
|
|
|
const int64_t buf_len = 256;
|
|
char buffer[buf_len];
|
|
int64_t pos = 0;
|
|
ob_priv.serialize(buffer, buf_len, pos);
|
|
pos = 0;
|
|
ObPriv ob_priv_des;
|
|
ob_priv_des.deserialize(buffer, buf_len, pos);
|
|
ASSERT_EQ(ob_priv.get_tenant_id(), ob_priv_des.get_tenant_id());
|
|
ASSERT_EQ(ob_priv.get_user_id(), ob_priv_des.get_user_id());
|
|
ASSERT_EQ(ob_priv.get_priv_set(), ob_priv_des.get_priv_set());
|
|
}
|
|
|
|
TEST(ObPrivStructTest, ob_user_info_hash_wrapper)
|
|
{
|
|
ObUserInfoHashWrapper user_info_hash(2, ObString::make_string("user"));
|
|
ObUserInfoHashWrapper user_info_hash_eq(2, ObString::make_string("user"));
|
|
ObUserInfoHashWrapper user_info_hash_diff(2, ObString::make_string("other"));
|
|
|
|
ASSERT_EQ(2UL, user_info_hash.get_tenant_id());
|
|
ASSERT_TRUE(ObString::make_string("user") == user_info_hash.get_user_name());
|
|
ASSERT_TRUE(user_info_hash == user_info_hash_eq);
|
|
ASSERT_TRUE(user_info_hash.hash() == user_info_hash_eq.hash());
|
|
ASSERT_FALSE(user_info_hash == user_info_hash_diff);
|
|
ASSERT_FALSE(user_info_hash.hash() == user_info_hash_diff.hash());
|
|
}
|
|
|
|
TEST(ObPrivStructTest, ob_user_info)
|
|
{
|
|
ObUserInfo user_info;
|
|
ObUserInfo user_info_eq;
|
|
ObUserInfo user_info_other;
|
|
ObPrivSet priv_set = OB_PRIV_CREATE | OB_PRIV_SELECT;
|
|
FILL_USER_INFO(user_info, 2, 2, "user", "123", "", false, priv_set);
|
|
FILL_USER_INFO(user_info_eq, 2, 2, "user", "123", "", false, priv_set);
|
|
FILL_USER_INFO(user_info_other, 2, 3, "LiLei", "123", "", false, priv_set);
|
|
|
|
ASSERT_TRUE(ObUserInfo::cmp(&user_info, &user_info_other));
|
|
ASSERT_FALSE(ObUserInfo::cmp(&user_info, &user_info_eq));
|
|
ASSERT_TRUE(ObUserInfo::equal(&user_info, &user_info_eq));
|
|
ASSERT_FALSE(ObUserInfo::equal(&user_info, &user_info_other));
|
|
|
|
const int64_t buf_len = 256;
|
|
char buffer[buf_len];
|
|
int64_t pos = 0;
|
|
user_info.serialize(buffer, buf_len, pos);
|
|
pos = 0;
|
|
ObUserInfo user_info_des;
|
|
user_info_des.deserialize(buffer, buf_len, pos);
|
|
ASSERT_TRUE(ObUserInfo::equal(&user_info, &user_info_des));
|
|
ASSERT_TRUE(ObString::make_string("user") == user_info_des.get_user_name_str());
|
|
}
|
|
|
|
TEST(ObPrivStructTest, ob_db_priv_sort_key)
|
|
{
|
|
ObDBPrivSortKey db_priv_key(2, 2, 3);
|
|
ObDBPrivSortKey db_priv_key_eq(2, 2, 3);
|
|
ObDBPrivSortKey db_priv_key_big(2, 3, 3);
|
|
ObDBPrivSortKey db_priv_key_little(2, 2, 100);
|
|
|
|
ASSERT_TRUE(db_priv_key == db_priv_key_eq);
|
|
ASSERT_FALSE(db_priv_key == db_priv_key_little);
|
|
ASSERT_TRUE(db_priv_key != db_priv_key_little);
|
|
ASSERT_FALSE(db_priv_key != db_priv_key_eq);
|
|
|
|
//sort value from big to small
|
|
ASSERT_TRUE(db_priv_key_little < db_priv_key);
|
|
ASSERT_TRUE(db_priv_key < db_priv_key_big);
|
|
}
|
|
|
|
TEST(ObPrivStructTest, ob_org_db_key)
|
|
{
|
|
ObOriginalDBKey org_key(2, 2, ObString::make_string("test"));
|
|
ObOriginalDBKey org_key_eq(2, 2, ObString::make_string("test"));
|
|
ObOriginalDBKey org_key_diff1(2, 3, ObString::make_string("test"));
|
|
ObOriginalDBKey org_key_diff2(2, 2, ObString::make_string("db"));
|
|
|
|
ASSERT_EQ(org_key.hash(), org_key_eq.hash());
|
|
ASSERT_NE(org_key.hash(), org_key_diff1.hash());
|
|
ASSERT_NE(org_key.hash(), org_key_diff2.hash());
|
|
//operator== cmp tenant_id, user_id, db_name
|
|
ASSERT_TRUE(org_key == org_key_eq);
|
|
ASSERT_FALSE(org_key == org_key_diff1);
|
|
ASSERT_FALSE(org_key == org_key_diff2);
|
|
|
|
//operator< cmp tenant_id, user_id
|
|
ASSERT_TRUE(org_key < org_key_diff1);
|
|
}
|
|
|
|
TEST(ObPrivStructTest, ob_db_priv)
|
|
{
|
|
ObDBPriv db_priv;
|
|
ObDBPriv db_priv_eq;
|
|
ObDBPriv db_priv_diff1;
|
|
ObDBPriv db_priv_diff2;
|
|
ObPrivSet priv_set = OB_PRIV_CREATE | OB_PRIV_SELECT;
|
|
FILL_DB_PRIV(db_priv, 2, 2, ObString::make_string("test"), priv_set);
|
|
FILL_DB_PRIV(db_priv_eq, 2, 2, ObString::make_string("db"), priv_set);
|
|
FILL_DB_PRIV(db_priv_diff1, 2, 2, ObString::make_string("db%"), priv_set);
|
|
FILL_DB_PRIV(db_priv_diff2, 2, 3, ObString::make_string("db"), priv_set);
|
|
|
|
//db% is less specific;
|
|
ASSERT_TRUE(ObDBPriv::cmp(&db_priv, &db_priv_diff1));
|
|
ASSERT_TRUE(ObDBPriv::cmp(&db_priv, &db_priv_diff2));
|
|
ASSERT_TRUE(ObDBPriv::equal(&db_priv, &db_priv_eq));
|
|
|
|
const int64_t buf_len = 256;
|
|
char buffer[buf_len];
|
|
int64_t pos = 0;
|
|
db_priv.serialize(buffer, buf_len, pos);
|
|
pos = 0;
|
|
ObDBPriv db_priv_des;
|
|
db_priv_des.deserialize(buffer, buf_len, pos);
|
|
|
|
ASSERT_EQ(db_priv.get_tenant_id(), db_priv_des.get_tenant_id());
|
|
ASSERT_EQ(db_priv.get_user_id(), db_priv_des.get_user_id());
|
|
ASSERT_TRUE(db_priv.get_database_name_str() == db_priv_des.get_database_name_str());
|
|
ASSERT_EQ(db_priv.get_priv_set(), db_priv_des.get_priv_set());
|
|
}
|
|
|
|
TEST(ObPrivStructTest, ob_table_priv_db_key)
|
|
{
|
|
ObTablePrivDBKey table_db_key(2, 2, ObString::make_string("test"));
|
|
ObTablePrivDBKey table_db_key_eq(2, 2, ObString::make_string("test"));
|
|
ObTablePrivDBKey table_db_key_diff(2, 2, ObString::make_string("db"));
|
|
|
|
ASSERT_TRUE(table_db_key == table_db_key_eq);
|
|
ASSERT_TRUE(table_db_key_diff < table_db_key);
|
|
|
|
}
|
|
|
|
TEST(ObPrivStructTest, ob_table_priv_sort_key)
|
|
{
|
|
ObTablePrivSortKey table_priv_key(2, 2, "test", "table");
|
|
ObTablePrivSortKey table_priv_key_eq(2, 2, "test", "table");
|
|
ObTablePrivSortKey table_priv_key_diff1(2, 2, "test", "index");
|
|
ObTablePrivSortKey table_priv_key_diff2(2, 3, "test", "table");
|
|
|
|
ASSERT_TRUE(table_priv_key == table_priv_key_eq);
|
|
ASSERT_TRUE(table_priv_key_diff1 < table_priv_key);
|
|
ASSERT_TRUE(table_priv_key < table_priv_key_diff2);
|
|
|
|
ASSERT_EQ(table_priv_key.hash(), table_priv_key_eq.hash());
|
|
ASSERT_NE(table_priv_key.hash(), table_priv_key_diff1.hash());
|
|
}
|
|
|
|
TEST(ObPrivStructTest, ob_table_priv)
|
|
{
|
|
ObTablePriv table_priv;
|
|
ObTablePriv table_priv_eq;
|
|
ObTablePriv table_priv_diff1;
|
|
ObTablePriv table_priv_diff2;
|
|
ObPrivSet priv_set = OB_PRIV_INSERT | OB_PRIV_SELECT;
|
|
FILL_TABLE_PRIV(table_priv, 2, 2, "test", "table", priv_set);
|
|
FILL_TABLE_PRIV(table_priv_eq, 2, 2, "test", "table", priv_set);
|
|
FILL_TABLE_PRIV(table_priv_diff1, 2, 2, "test", "index", priv_set);
|
|
FILL_TABLE_PRIV(table_priv_diff2, 2, 3, "test", "table", priv_set);
|
|
|
|
ASSERT_TRUE(ObTablePriv::equal(&table_priv, &table_priv_eq));
|
|
ASSERT_TRUE(ObTablePriv::cmp(&table_priv_diff1, &table_priv));
|
|
ASSERT_TRUE(ObTablePriv::cmp(&table_priv, &table_priv_diff2));
|
|
|
|
const int64_t buf_len = 256;
|
|
char buffer[buf_len];
|
|
int64_t pos = 0;
|
|
table_priv.serialize(buffer, buf_len, pos);
|
|
pos = 0;
|
|
ObTablePriv table_priv_des;
|
|
table_priv_des.deserialize(buffer, buf_len, pos);
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
OB_LOGGER.set_log_level("ERROR");
|
|
::testing::InitGoogleTest(&argc,argv);
|
|
return RUN_ALL_TESTS();
|
|
}
|