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