1 #define BOOST_TEST_MODULE pichi vo_credential test
2
3 #include "utils.hpp"
4 #include "vo.hpp"
5 #include <boost/test/unit_test.hpp>
6 #include <pichi/vo/credential.hpp>
7 #include <pichi/vo/keys.hpp>
8 #include <pichi/vo/parse.hpp>
9 #include <pichi/vo/to_json.hpp>
10 #include <unordered_map>
11
12 using namespace std;
13 using namespace rapidjson;
14
15 namespace pichi::unit_test {
16
17 BOOST_AUTO_TEST_SUITE(VO_CREDENTIAL)
18
19 using namespace pichi::vo;
20
BOOST_AUTO_TEST_CASE_TEMPLATE(parse_Credential_Normal_Case,Credential,AllCredentials)21 BOOST_AUTO_TEST_CASE_TEMPLATE(parse_Credential_Normal_Case, Credential, AllCredentials)
22 {
23 BOOST_CHECK(parse<Credential>(defaultCredentialJson<Credential>()) ==
24 defaultCredential<Credential>());
25 }
26
BOOST_AUTO_TEST_CASE_TEMPLATE(toJson_Credential_Normal_Case,Credential,AllCredentials)27 BOOST_AUTO_TEST_CASE_TEMPLATE(toJson_Credential_Normal_Case, Credential, AllCredentials)
28 {
29 BOOST_CHECK(toJson(defaultCredential<Credential>(), alloc) ==
30 defaultCredentialJson<Credential>());
31 }
32
BOOST_AUTO_TEST_CASE_TEMPLATE(parse_IngressCredential_Invalid_Type,Credential,IngressCredentials)33 BOOST_AUTO_TEST_CASE_TEMPLATE(parse_IngressCredential_Invalid_Type, Credential, IngressCredentials)
34 {
35 for (auto t : {kNumberType, kNullType, kStringType, kTrueType, kFalseType, kObjectType}) {
36 BOOST_CHECK_EXCEPTION(parse<Credential>(Value{t}), Exception,
37 verifyException<PichiError::BAD_JSON>);
38 }
39 }
40
BOOST_AUTO_TEST_CASE_TEMPLATE(parse_IngressCredential_Empty_Credential,Credential,IngressCredentials)41 BOOST_AUTO_TEST_CASE_TEMPLATE(parse_IngressCredential_Empty_Credential, Credential,
42 IngressCredentials)
43 {
44 BOOST_CHECK_EXCEPTION(parse<Credential>(Value{kArrayType}), Exception,
45 verifyException<PichiError::BAD_JSON>);
46 }
47
BOOST_AUTO_TEST_CASE_TEMPLATE(parse_IngressCredential_Invalid_Type_Of_Items,Credential,IngressCredentials)48 BOOST_AUTO_TEST_CASE_TEMPLATE(parse_IngressCredential_Invalid_Type_Of_Items, Credential,
49 IngressCredentials)
50 {
51 for (auto t : {kNumberType, kNullType, kStringType, kTrueType, kFalseType, kArrayType}) {
52 auto v = Value{kArrayType};
53 v.PushBack(Value{t}, alloc);
54 BOOST_CHECK_EXCEPTION(parse<Credential>(v), Exception, verifyException<PichiError::BAD_JSON>);
55 }
56 }
57
BOOST_AUTO_TEST_CASE_TEMPLATE(parse_IngressCredential_Mandatory_Fields,Credential,IngressCredentials)58 BOOST_AUTO_TEST_CASE_TEMPLATE(parse_IngressCredential_Mandatory_Fields, Credential,
59 IngressCredentials)
60 {
61 auto keys = vector<string>{};
62 if constexpr (is_same_v<Credential, UpIngressCredential>) {
63 keys.push_back(credential::USERNAME);
64 keys.push_back(credential::PASSWORD);
65 }
66 else if constexpr (is_same_v<Credential, TrojanIngressCredential>) {
67 keys.push_back(credential::PASSWORD);
68 }
69 else if constexpr (is_same_v<Credential, VMessIngressCredential>) {
70 keys.push_back(credential::UUID);
71 }
72 for (auto&& key : keys) {
73 auto json = defaultCredentialJson<Credential>();
74 json[0].RemoveMember(key.c_str());
75 BOOST_CHECK_EXCEPTION(parse<Credential>(json), Exception,
76 verifyException<PichiError::BAD_JSON>);
77 }
78 }
79
BOOST_AUTO_TEST_CASE_TEMPLATE(parse_IngressCredential_Duplicated_Key,Credential,IngressCredentials)80 BOOST_AUTO_TEST_CASE_TEMPLATE(parse_IngressCredential_Duplicated_Key, Credential,
81 IngressCredentials)
82 {
83 auto modify = function<void(Value&)>{};
84 if constexpr (is_same_v<Credential, UpIngressCredential>) {
85 modify = [](auto&& item) {
86 item.AddMember(credential::USERNAME, ph, alloc).AddMember(credential::PASSWORD, ph, alloc);
87 };
88 }
89 else if constexpr (is_same_v<Credential, TrojanIngressCredential>) {
90 modify = [](auto&& item) { item.AddMember(credential::PASSWORD, ph, alloc); };
91 }
92 else if constexpr (is_same_v<Credential, VMessIngressCredential>) {
93 modify = [](auto&& item) { item.AddMember(credential::UUID, ph, alloc); };
94 }
95 auto json = defaultCredentialJson<Credential>();
96 json.PushBack(createJsonObject(modify), alloc);
97 BOOST_CHECK_EXCEPTION(parse<Credential>(json), Exception,
98 verifyException<PichiError::SEMANTIC_ERROR>);
99 }
100
BOOST_AUTO_TEST_CASE_TEMPLATE(parse_IngressCredential_Empty_Key,Credential,IngressCredentials)101 BOOST_AUTO_TEST_CASE_TEMPLATE(parse_IngressCredential_Empty_Key, Credential, IngressCredentials)
102 {
103 auto key = ""s;
104 if constexpr (is_same_v<Credential, UpIngressCredential>) {
105 key = credential::USERNAME;
106 }
107 else if constexpr (is_same_v<Credential, TrojanIngressCredential>) {
108 key = credential::PASSWORD;
109 }
110 else if constexpr (is_same_v<Credential, VMessIngressCredential>) {
111 key = credential::UUID;
112 }
113 auto empty = defaultCredentialJson<Credential>();
114 empty[0][key.c_str()] = "";
115 BOOST_CHECK_EXCEPTION(parse<Credential>(empty), Exception, verifyException<PichiError::BAD_JSON>);
116 }
117
BOOST_AUTO_TEST_CASE_TEMPLATE(toJson_IngressCredential_Empty_Credential,Credential,IngressCredentials)118 BOOST_AUTO_TEST_CASE_TEMPLATE(toJson_IngressCredential_Empty_Credential, Credential,
119 IngressCredentials)
120 {
121 BOOST_CHECK_EXCEPTION(toJson(Credential{}, alloc), Exception, verifyException<PichiError::MISC>);
122 }
123
BOOST_AUTO_TEST_CASE_TEMPLATE(parse_EgressCredential_Invalid_Type,Credential,EgressCredentials)124 BOOST_AUTO_TEST_CASE_TEMPLATE(parse_EgressCredential_Invalid_Type, Credential, EgressCredentials)
125 {
126 for (auto t : {kNumberType, kNullType, kStringType, kTrueType, kFalseType, kArrayType}) {
127 BOOST_CHECK_EXCEPTION(parse<Credential>(Value{t}), Exception,
128 verifyException<PichiError::BAD_JSON>);
129 }
130 }
131
BOOST_AUTO_TEST_CASE_TEMPLATE(parse_EgressCredential_Mandatory_Fields,Credential,EgressCredentials)132 BOOST_AUTO_TEST_CASE_TEMPLATE(parse_EgressCredential_Mandatory_Fields, Credential,
133 EgressCredentials)
134 {
135 auto keys = vector<string>{};
136 if constexpr (is_same_v<Credential, UpEgressCredential>) {
137 keys.push_back(credential::USERNAME);
138 keys.push_back(credential::PASSWORD);
139 }
140 else if constexpr (is_same_v<Credential, TrojanEgressCredential>) {
141 keys.push_back(credential::PASSWORD);
142 }
143 else if constexpr (is_same_v<Credential, VMessEgressCredential>) {
144 keys.push_back(credential::UUID);
145 }
146 for (auto&& key : keys) {
147 auto json = defaultCredentialJson<Credential>();
148 json.RemoveMember(key.c_str());
149 BOOST_CHECK_EXCEPTION(parse<Credential>(json), Exception,
150 verifyException<PichiError::BAD_JSON>);
151 }
152 }
153
BOOST_AUTO_TEST_CASE(parse_vmess_EgressCredential_Default_Fields)154 BOOST_AUTO_TEST_CASE(parse_vmess_EgressCredential_Default_Fields)
155 {
156 using Credential = VMessEgressCredential;
157
158 auto alterId = defaultCredentialJson<Credential>();
159 alterId.RemoveMember(credential::ALTER_ID);
160 BOOST_CHECK(parse<Credential>(alterId) == defaultCredential<Credential>());
161
162 auto security = defaultCredentialJson<Credential>();
163 security.RemoveMember(credential::SECURITY);
164 BOOST_CHECK(parse<Credential>(security) == defaultCredential<Credential>());
165 }
166
167 BOOST_AUTO_TEST_SUITE_END()
168
169 } // namespace pichi::unit_test
170