1 /* 2 * Copyright (c) 2023-2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 16 #include "netstack_log.h" 17 #include "gtest/gtest.h" 18 #include <cstring> 19 #include <iostream> 20 21 #include "close_context.h" 22 #include "connect_context.h" 23 #include "send_context.h" 24 #include "websocket_async_work.h" 25 #include "websocket_exec.h" 26 #include "websocket_module.h" 27 #ifdef NETSTACK_WEBSOCKETSERVER 28 #include "server_start_context.h" 29 #include "server_close_context.h" 30 #include "server_send_context.h" 31 #include "server_stop_context.h" 32 #include "list_all_connections_context.h" 33 #include "websocket_server_exec.h" 34 #endif // NETSTACK_WEBSOCKETSERVER 35 36 class WebSocketTest : public testing::Test { 37 public: SetUpTestCase()38 static void SetUpTestCase() {} 39 TearDownTestCase()40 static void TearDownTestCase() {} 41 SetUp()42 virtual void SetUp() {} 43 TearDown()44 virtual void TearDown() {} 45 }; 46 47 namespace { 48 using namespace testing::ext; 49 using namespace OHOS::NetStack::Websocket; 50 51 HWTEST_F(WebSocketTest, WebSocketTest001, TestSize.Level1) 52 { 53 napi_env env = nullptr; 54 auto eventManager = std::make_shared<EventManager>(); 55 ConnectContext context(env, eventManager); 56 bool ret = WebSocketExec::ExecConnect(&context); 57 EXPECT_EQ(ret, false); 58 } 59 60 HWTEST_F(WebSocketTest, WebSocketTest002, TestSize.Level1) 61 { 62 napi_env env = nullptr; 63 auto eventManager = std::make_shared<EventManager>(); 64 SendContext context(env, eventManager); 65 bool ret = WebSocketExec::ExecSend(&context); 66 EXPECT_EQ(ret, false); 67 } 68 69 HWTEST_F(WebSocketTest, WebSocketTest003, TestSize.Level1) 70 { 71 napi_env env = nullptr; 72 auto eventManager = std::make_shared<EventManager>(); 73 CloseContext context(env, eventManager); 74 bool ret = WebSocketExec::ExecClose(&context); 75 EXPECT_EQ(ret, false); 76 } 77 78 HWTEST_F(WebSocketTest, WebSocketTest004, TestSize.Level1) 79 { 80 bool ret = WebSocketExec::ExecConnect(nullptr); 81 EXPECT_EQ(ret, false); 82 } 83 84 HWTEST_F(WebSocketTest, WebSocketTest005, TestSize.Level1) 85 { 86 napi_env env = nullptr; 87 auto eventManager = std::make_shared<EventManager>(); 88 ConnectContext context(env, eventManager); 89 context.caPath_ = "/etc/ssl/certs/test_ca.crt"; 90 bool ret = WebSocketExec::ExecConnect(&context); 91 EXPECT_EQ(ret, false); 92 } 93 94 HWTEST_F(WebSocketTest, WebSocketTest006, TestSize.Level1) 95 { 96 napi_env env = nullptr; 97 auto eventManager = std::make_shared<EventManager>(); 98 ConnectContext context(env, eventManager); 99 context.caPath_ = ""; 100 bool ret = WebSocketExec::ExecConnect(&context); 101 EXPECT_EQ(ret, false); 102 } 103 104 HWTEST_F(WebSocketTest, WebSocketTest007, TestSize.Level1) 105 { 106 napi_env env = nullptr; 107 auto eventManager = std::make_shared<EventManager>(); 108 ConnectContext context(env, eventManager); 109 110 context.url = "ws://123.123.123.123:9000"; 111 std::string myProtocol = "my-protocol"; 112 context.SetProtocol(myProtocol); 113 std::string getMyProtocol = context.GetProtocol(); 114 bool ret = WebSocketExec::ExecConnect(&context); 115 EXPECT_EQ(getMyProtocol, "my-protocol"); 116 EXPECT_EQ(ret, false); 117 } 118 119 HWTEST_F(WebSocketTest, WebSocketTest008, TestSize.Level1) 120 { 121 napi_env env = nullptr; 122 auto eventManager = std::make_shared<EventManager>(); 123 ConnectContext context(env, eventManager); 124 125 context.url = "ws://123.123.123.123:9000"; 126 context.SetWebsocketProxyType(WebsocketProxyType::USE_SPECIFIED); 127 std::string host = "192.168.147.60"; 128 int32_t port = 8888; 129 std::string exclusions = "www.httpbin.org"; 130 context.SetSpecifiedWebsocketProxy(host, port, exclusions); 131 std::string getHost; 132 uint32_t getPort; 133 std::string getExclusions; 134 context.GetSpecifiedWebsocketProxy(getHost, getPort, getExclusions); 135 bool ret = WebSocketExec::ExecConnect(&context); 136 EXPECT_EQ(getHost, "192.168.147.60"); 137 EXPECT_EQ(getPort, 8888); 138 EXPECT_EQ(getExclusions, "www.httpbin.org"); 139 EXPECT_EQ(ret, false); 140 } 141 142 #ifdef NETSTACK_WEBSOCKETSERVER 143 HWTEST_F(WebSocketTest, WebSocketTest009, TestSize.Level1) 144 { 145 napi_env env = nullptr; 146 auto eventManager = std::make_shared<EventManager>(); 147 ServerStartContext context(env, eventManager); 148 bool ret = WebSocketServerExec::ExecServerStart(&context); 149 EXPECT_EQ(ret, false); 150 } 151 152 HWTEST_F(WebSocketTest, WebSocketTest010, TestSize.Level1) 153 { 154 bool ret = WebSocketServerExec::ExecServerStart(nullptr); 155 EXPECT_EQ(ret, false); 156 } 157 158 HWTEST_F(WebSocketTest, WebSocketTest011, TestSize.Level1) 159 { 160 napi_env env = nullptr; 161 auto eventManager = std::make_shared<EventManager>(); 162 ServerStartContext context(env, eventManager); 163 context.SetPermissionDenied(true); 164 bool ret = WebSocketServerExec::ExecServerStart(&context); 165 EXPECT_EQ(ret, false); 166 } 167 168 HWTEST_F(WebSocketTest, WebSocketTest012, TestSize.Level1) 169 { 170 napi_env env = nullptr; 171 auto eventManager = std::make_shared<EventManager>(); 172 ServerSendContext context(env, eventManager); 173 bool ret = WebSocketServerExec::ExecServerSend(&context); 174 EXPECT_EQ(ret, false); 175 } 176 177 HWTEST_F(WebSocketTest, WebSocketTest013, TestSize.Level1) 178 { 179 bool ret = WebSocketServerExec::ExecServerSend(nullptr); 180 EXPECT_EQ(ret, false); 181 } 182 183 HWTEST_F(WebSocketTest, WebSocketTest014, TestSize.Level1) 184 { 185 napi_env env = nullptr; 186 auto eventManager = std::make_shared<EventManager>(); 187 ServerSendContext context(env, eventManager); 188 context.SetPermissionDenied(true); 189 bool ret = WebSocketServerExec::ExecServerSend(&context); 190 EXPECT_EQ(ret, false); 191 } 192 193 HWTEST_F(WebSocketTest, WebSocketTest015, TestSize.Level1) 194 { 195 napi_env env = nullptr; 196 auto eventManager = std::make_shared<EventManager>(); 197 ServerCloseContext context(env, eventManager); 198 bool ret = WebSocketServerExec::ExecServerClose(&context); 199 EXPECT_EQ(ret, false); 200 } 201 202 HWTEST_F(WebSocketTest, WebSocketTest016, TestSize.Level1) 203 { 204 bool ret = WebSocketServerExec::ExecServerClose(nullptr); 205 EXPECT_EQ(ret, false); 206 } 207 208 HWTEST_F(WebSocketTest, WebSocketTest017, TestSize.Level1) 209 { 210 napi_env env = nullptr; 211 auto eventManager = std::make_shared<EventManager>(); 212 ServerCloseContext context(env, eventManager); 213 context.SetPermissionDenied(true); 214 bool ret = WebSocketServerExec::ExecServerClose(&context); 215 EXPECT_EQ(ret, false); 216 } 217 218 HWTEST_F(WebSocketTest, WebSocketTest018, TestSize.Level1) 219 { 220 napi_env env = nullptr; 221 auto eventManager = std::make_shared<EventManager>(); 222 ServerStopContext context(env, eventManager); 223 bool ret = WebSocketServerExec::ExecServerStop(&context); 224 EXPECT_EQ(ret, false); 225 } 226 227 HWTEST_F(WebSocketTest, WebSocketTest019, TestSize.Level1) 228 { 229 bool ret = WebSocketServerExec::ExecServerStop(nullptr); 230 EXPECT_EQ(ret, false); 231 } 232 233 HWTEST_F(WebSocketTest, WebSocketTest020, TestSize.Level1) 234 { 235 napi_env env = nullptr; 236 auto eventManager = std::make_shared<EventManager>(); 237 ServerStopContext context(env, eventManager); 238 context.SetPermissionDenied(true); 239 bool ret = WebSocketServerExec::ExecServerStop(&context); 240 EXPECT_EQ(ret, false); 241 } 242 243 HWTEST_F(WebSocketTest, WebSocketTest021, TestSize.Level1) 244 { 245 napi_env env = nullptr; 246 auto eventManager = std::make_shared<EventManager>(); 247 ListAllConnectionsContext context(env, eventManager); 248 bool ret = WebSocketServerExec::ExecListAllConnections(&context); 249 EXPECT_EQ(ret, false); 250 } 251 252 HWTEST_F(WebSocketTest, WebSocketTest022, TestSize.Level1) 253 { 254 bool ret = WebSocketServerExec::ExecListAllConnections(nullptr); 255 EXPECT_EQ(ret, false); 256 } 257 258 HWTEST_F(WebSocketTest, WebSocketTest023, TestSize.Level1) 259 { 260 napi_env env = nullptr; 261 auto eventManager = std::make_shared<EventManager>(); 262 ListAllConnectionsContext context(env, eventManager); 263 context.SetPermissionDenied(true); 264 bool ret = WebSocketServerExec::ExecListAllConnections(&context); 265 EXPECT_EQ(ret, false); 266 } 267 268 HWTEST_F(WebSocketTest, WebSocketTest024, TestSize.Level1) 269 { 270 napi_env env = nullptr; 271 auto eventManager = std::make_shared<EventManager>(); 272 ConnectContext context(env, eventManager); 273 context.SetPermissionDenied(true); 274 bool ret = WebSocketExec::ExecConnect(&context); 275 EXPECT_EQ(ret, false); 276 } 277 278 HWTEST_F(WebSocketTest, WebSocketTest025, TestSize.Level1) 279 { 280 napi_env env = nullptr; 281 auto eventManager = std::make_shared<EventManager>(); 282 SendContext context(env, eventManager); 283 context.SetPermissionDenied(true); 284 bool ret = WebSocketExec::ExecSend(&context); 285 EXPECT_EQ(ret, false); 286 } 287 288 HWTEST_F(WebSocketTest, WebSocketTest026, TestSize.Level1) 289 { 290 napi_env env = nullptr; 291 auto eventManager = std::make_shared<EventManager>(); 292 CloseContext context(env, eventManager); 293 context.SetPermissionDenied(true); 294 bool ret = WebSocketExec::ExecClose(&context); 295 EXPECT_EQ(ret, false); 296 } 297 298 HWTEST_F(WebSocketTest, WebSocketTest027, TestSize.Level1) 299 { 300 napi_env env = nullptr; 301 auto eventManager = std::make_shared<EventManager>(); 302 ServerStartContext context(env, eventManager); 303 context.SetPermissionDenied(false); 304 bool ret = WebSocketServerExec::ExecServerStart(&context); 305 EXPECT_EQ(ret, false); 306 } 307 308 HWTEST_F(WebSocketTest, WebSocketTest028, TestSize.Level1) 309 { 310 napi_env env = nullptr; 311 auto eventManager = std::make_shared<EventManager>(); 312 ServerSendContext context(env, eventManager); 313 context.SetPermissionDenied(false); 314 bool ret = WebSocketServerExec::ExecServerSend(&context); 315 EXPECT_EQ(ret, false); 316 } 317 318 HWTEST_F(WebSocketTest, WebSocketTest029, TestSize.Level1) 319 { 320 napi_env env = nullptr; 321 auto eventManager = std::make_shared<EventManager>(); 322 ServerCloseContext context(env, eventManager); 323 context.SetPermissionDenied(false); 324 bool ret = WebSocketServerExec::ExecServerClose(&context); 325 EXPECT_EQ(ret, false); 326 } 327 328 HWTEST_F(WebSocketTest, WebSocketTest030, TestSize.Level1) 329 { 330 napi_env env = nullptr; 331 auto eventManager = std::make_shared<EventManager>(); 332 ServerStopContext context(env, eventManager); 333 context.SetPermissionDenied(false); 334 bool ret = WebSocketServerExec::ExecServerStop(&context); 335 EXPECT_EQ(ret, false); 336 } 337 338 HWTEST_F(WebSocketTest, WebSocketTest031, TestSize.Level1) 339 { 340 napi_env env = nullptr; 341 auto eventManager = std::make_shared<EventManager>(); 342 ListAllConnectionsContext context(env, eventManager); 343 context.SetPermissionDenied(false); 344 bool ret = WebSocketServerExec::ExecListAllConnections(&context); 345 EXPECT_EQ(ret, false); 346 } 347 348 HWTEST_F(WebSocketTest, WebSocketTest032, TestSize.Level1) 349 { 350 napi_env env = nullptr; 351 auto eventManager = std::make_shared<EventManager>(); 352 ConnectContext context(env, eventManager); 353 context.SetPermissionDenied(false); 354 bool ret = WebSocketExec::ExecConnect(&context); 355 EXPECT_EQ(ret, false); 356 } 357 358 HWTEST_F(WebSocketTest, WebSocketTest033, TestSize.Level1) 359 { 360 napi_env env = nullptr; 361 auto eventManager = std::make_shared<EventManager>(); 362 SendContext context(env, eventManager); 363 context.SetPermissionDenied(false); 364 bool ret = WebSocketExec::ExecSend(&context); 365 EXPECT_EQ(ret, false); 366 } 367 368 HWTEST_F(WebSocketTest, WebSocketTest034, TestSize.Level1) 369 { 370 napi_env env = nullptr; 371 auto eventManager = std::make_shared<EventManager>(); 372 CloseContext context(env, eventManager); 373 context.SetPermissionDenied(false); 374 bool ret = WebSocketExec::ExecClose(&context); 375 EXPECT_EQ(ret, false); 376 } 377 #endif 378 } // namespace