feat userver: handle non-101 HTTP responses in WebSocket handshake

#### Summary

Fixed WebSocket client to properly handle HTTP error responses (401, 403, etc.) during handshake instead of treating them as connection errors.

#### Problem

curl expects 101 status for WebSocket upgrade. When server returns other HTTP status (e.g., 401 Unauthorized), curl reports `kHttpReturnedError`, preventing client code from accessing the actual HTTP response.

#### Solution

Ignore curl error in `request_state.cpp` for WebSocket handshake when a valid HTTP status code is received. This allows client to inspect response status, headers, and body.
commit_hash:fe9f0782a43dfefc66295357d5a38c54f026d1b5

Author: abakumov-mik

core/functional_tests/websocket_client/service.cpp

@@ -37,6 +37,21 @@ class WebSocketEcho final : public server::handlers::WebsocketHandlerBase {
     }
 };
 
+class WebSocketUnauth final : public server::handlers::WebsocketHandlerBase {
+public:
+    static constexpr std::string_view kName = "websocket-unauth-handler";
+
+    using WebsocketHandlerBase::WebsocketHandlerBase;
+
+    bool
+    HandleHandshake(const server::http::HttpRequest&, server::http::HttpResponse& response, server::request::RequestContext&) const override {
+        response.SetStatus(server::http::HttpStatus::kUnauthorized);
+        return false;
+    }
+
+    void Handle(websocket::WebSocketConnection&, server::request::RequestContext&) const override {}
+};
+
 // HTTP handler for testing C++ WebSocket client
 class TestClientHandler final : public server::handlers::HttpHandlerBase {
 public:
@@ -66,6 +81,10 @@ class TestClientHandler final : public server::handlers::HttpHandlerBase {
                 return TestNonblockingRead(request);
             } else if (test_name == "nonblocking_write") {
                 return TestNonblockingWrite(request);
+            } else if (test_name == "unauth") {
+                return TestUnauth(request);
+            } else if (test_name == "connection_already_extracted") {
+                return TestConnectionAlreadyExtracted(request);
             }
             return "Unknown test";
         } catch (const std::exception& e) {
@@ -74,20 +93,15 @@ class TestClientHandler final : public server::handlers::HttpHandlerBase {
     }
 
 private:
-    std::shared_ptr<websocket::WebSocketConnection> MakeWebSocketConnection(
-        const server::http::HttpRequest& request,
-        const std::string& uri = "/echo"
-    ) const {
+    clients::http::WebSocketResponse PerformWebSocket(const server::http::HttpRequest& request, const std::string& uri)
+        const {
         const auto port = std::stoi(request.GetArg("port"));
 
-        auto ws_response =
-            client_.CreateRequest().url(fmt::format("ws://localhost:{}{}", port, uri)).PerformWebSocketHandshake();
-
-        return ws_response.MakeWebSocketConnection();
+        return client_.CreateRequest().url(fmt::format("ws://localhost:{}{}", port, uri)).PerformWebSocketHandshake();
     }
 
     std::string TestEcho(const server::http::HttpRequest& request) const {
-        auto conn = MakeWebSocketConnection(request);
+        auto conn = PerformWebSocket(request, "/echo").MakeWebSocketConnection();
 
         conn->SendText("Hello WebSocket");
         websocket::Message msg;
@@ -97,7 +111,7 @@ class TestClientHandler final : public server::handlers::HttpHandlerBase {
     }
 
     std::string TestLarge(const server::http::HttpRequest& request) const {
-        auto conn = MakeWebSocketConnection(request);
+        auto conn = PerformWebSocket(request, "/echo").MakeWebSocketConnection();
 
         std::string large_msg(50000, 'X');
         conn->SendText(large_msg);
@@ -108,7 +122,7 @@ class TestClientHandler final : public server::handlers::HttpHandlerBase {
     }
 
     std::string TestMultiple(const server::http::HttpRequest& request) const {
-        auto conn = MakeWebSocketConnection(request);
+        auto conn = PerformWebSocket(request, "/echo").MakeWebSocketConnection();
 
         for (int i = 0; i < 50; ++i) {
             const auto text = fmt::format("msg{}", i);
@@ -124,7 +138,7 @@ class TestClientHandler final : public server::handlers::HttpHandlerBase {
     }
 
     std::string TestBinary(const server::http::HttpRequest& request) const {
-        auto conn = MakeWebSocketConnection(request);
+        auto conn = PerformWebSocket(request, "/echo").MakeWebSocketConnection();
 
         std::vector<std::byte> data{std::byte{0x01}, std::byte{0xFF}};
         conn->SendBinary(data);
@@ -143,8 +157,8 @@ class TestClientHandler final : public server::handlers::HttpHandlerBase {
             return resp.data == msg;
         };
 
-        auto conn1 = MakeWebSocketConnection(request);
-        auto conn2 = MakeWebSocketConnection(request);
+        auto conn1 = PerformWebSocket(request, "/echo").MakeWebSocketConnection();
+        auto conn2 = PerformWebSocket(request, "/echo").MakeWebSocketConnection();
 
         auto task1 = utils::Async("task1", func, std::ref(*conn1), std::string("msg1"));
         auto task2 = utils::Async("task2", func, std::ref(*conn2), std::string("msg2"));
@@ -153,8 +167,8 @@ class TestClientHandler final : public server::handlers::HttpHandlerBase {
     }
 
     std::string TestNonblockingRead(const server::http::HttpRequest& request) const {
-        auto conn0 = MakeWebSocketConnection(request);
-        auto conn1 = MakeWebSocketConnection(request);
+        auto conn0 = PerformWebSocket(request, "/echo").MakeWebSocketConnection();
+        auto conn1 = PerformWebSocket(request, "/echo").MakeWebSocketConnection();
 
         conn0->SendText("msg0");
         conn1->SendText("msg1");
@@ -183,8 +197,8 @@ class TestClientHandler final : public server::handlers::HttpHandlerBase {
     }
 
     std::string TestNonblockingWrite(const server::http::HttpRequest& request) const {
-        auto conn0 = MakeWebSocketConnection(request);
-        auto conn1 = MakeWebSocketConnection(request);
+        auto conn0 = PerformWebSocket(request, "/echo").MakeWebSocketConnection();
+        auto conn1 = PerformWebSocket(request, "/echo").MakeWebSocketConnection();
 
         std::vector<std::string> messages{};
         for (int i = 0; i < 10; ++i) {
@@ -201,6 +215,39 @@ class TestClientHandler final : public server::handlers::HttpHandlerBase {
         return "OK";
     }
 
+    std::string TestUnauth(const server::http::HttpRequest& request) const {
+        auto ws_response = PerformWebSocket(request, "/unauth");
+
+        if (ws_response.IsProtocolUpgraded()) {
+            return "FAIL: Protocol upgraded";
+        }
+
+        const auto status_code = ws_response.GetHandshakeResponse()->status_code();
+        if (status_code != http::StatusCode::kUnauthorized) {
+            return "FAIL: Status code is " + ToString(status_code);
+        }
+
+        try {
+            ws_response.MakeWebSocketConnection();
+            return "FAIL: connection should not be created";
+        } catch (const std::exception&) {  // NOLINT(bugprone-empty-catch)
+        }
+
+        return "OK";
+    }
+
+    std::string TestConnectionAlreadyExtracted(const server::http::HttpRequest& request) const {
+        auto ws_response = PerformWebSocket(request, "/echo");
+        ws_response.MakeWebSocketConnection();
+
+        try {
+            ws_response.MakeWebSocketConnection();
+            return "FAIL: connection should not be created twice";
+        } catch (const std::exception&) {  // NOLINT(bugprone-empty-catch)
+        }
+        return "OK";
+    }
+
     clients::http::Client& client_;
 };
 
@@ -210,6 +257,7 @@ int main(int argc, char* argv[]) {
             .AppendComponentList(clients::http::ComponentList())
             .Append<clients::dns::Component>()
             .Append<WebSocketEcho>()
+            .Append<WebSocketUnauth>()
             .Append<TestClientHandler>()
             .Append<components::TestsuiteSupport>();
     return utils::DaemonMain(argc, argv, component_list);

core/functional_tests/websocket_client/static_config.yaml

@@ -29,6 +29,13 @@ components_manager:
             max-remote-payload: 100000
             fragment-size: 65536
 
+        websocket-unauth-handler:
+            path: /unauth
+            method: GET
+            task_processor: main-task-processor
+            max-remote-payload: 100000
+            fragment-size: 65536
+
         # HTTP handler for C++ client tests
         test-client:
             path: /test-client

core/functional_tests/websocket_client/tests/test_websocket_client.py

@@ -2,7 +2,18 @@
 
 
 @pytest.mark.parametrize(
-    'test_name', ['echo', 'large', 'multiple', 'binary', 'concurrent', 'nonblocking_read', 'nonblocking_write']
+    'test_name',
+    [
+        'echo',
+        'large',
+        'multiple',
+        'binary',
+        'concurrent',
+        'nonblocking_read',
+        'nonblocking_write',
+        'unauth',
+        'connection_already_extracted',
+    ],
 )
 async def test_client(service_client, service_port, test_name):
     response = await service_client.get(

core/src/clients/http/request_state.cpp

@@ -513,6 +513,14 @@ void RequestState::OnCompleted(std::shared_ptr<RequestState> holder, std::error_
 
     holder->CheckResponseDeadline(err, status_code);
 
+    if (err && std::get_if<WebSocketHandshakeData>(&holder->data_) &&
+        err == std::error_code(curl::errc::EasyErrorCode::kHttpReturnedError) && status_code != Status::kInvalid)
+    {
+        // curl expects 101 for WebSocket, treats other statuses as error.
+        // Ignore error if got complete HTTP response (e.g. 401, 403).
+        err = {};
+    }
+
     if (holder->testsuite_config_ && !err) {
         const auto& headers = holder->response()->headers();
         err = TestsuiteResponseHook(status_code, headers, span);

core/src/clients/http/websocket_response.cpp

@@ -19,8 +19,12 @@ bool WebSocketResponse::IsProtocolUpgraded() const {
 }
 
 std::shared_ptr<websocket::WebSocketConnection> WebSocketResponse::MakeWebSocketConnection() {
+    if (!IsProtocolUpgraded()) {
+        throw std::runtime_error("Protocol is not upgraded to WebSocket");
+    }
+
     if (!socket_.IsOpen()) {
-        return nullptr;
+        throw std::runtime_error("WebSocketConnection has already been extracted");
     }
 
     auto socket = std::make_unique<engine::io::Socket>(socket_.GetNative());