feat: add missing http error codes (#1097)

* feature: added missing http error codes

* fix: sq

* fix: address pr review comments

Author: ccrugoPhilips

services/network/Http.cpp

@@ -205,12 +205,9 @@ namespace services
             infra::Tokenizer tokenizer(statusLine, ' ');
 
             auto versionValid = HttpVersionValid(tokenizer.Token(0));
-            auto optionalStatusCode = HttpStatusCodeFromString(tokenizer.Token(1));
-            if (versionValid && optionalStatusCode)
-            {
-                statusCode = *optionalStatusCode;
+            auto statusCode = HttpStatusCodeFromString(tokenizer.Token(1));
+            if (versionValid)
                 observer.StatusAvailable(statusCode, statusLine);
-            }
             else
             {
                 error = true;
@@ -408,100 +405,14 @@ namespace services
         return std::nullopt;
     }
 
-    std::optional<HttpStatusCode> HttpStatusCodeFromString(infra::BoundedConstString statusCode)
+    HttpStatusCode HttpStatusCodeFromString(infra::BoundedConstString statusCode)
     {
         std::underlying_type<services::HttpStatusCode>::type value = 0;
 
         for (std::size_t index = 0; index < statusCode.size(); ++index)
             value = value * 10 + statusCode[index] - '0';
 
-        switch (value)
-        {
-            case 100:
-                return std::make_optional(HttpStatusCode::Continue);
-            case 101:
-                return std::make_optional(HttpStatusCode::SwitchingProtocols);
-            case 200:
-                return std::make_optional(HttpStatusCode::OK);
-            case 201:
-                return std::make_optional(HttpStatusCode::Created);
-            case 202:
-                return std::make_optional(HttpStatusCode::Accepted);
-            case 203:
-                return std::make_optional(HttpStatusCode::NonAuthorativeInformation);
-            case 204:
-                return std::make_optional(HttpStatusCode::NoContent);
-            case 205:
-                return std::make_optional(HttpStatusCode::ResetContent);
-            case 206:
-                return std::make_optional(HttpStatusCode::PartialContent);
-            case 300:
-                return std::make_optional(HttpStatusCode::MultipleChoices);
-            case 301:
-                return std::make_optional(HttpStatusCode::MovedPermanently);
-            case 302:
-                return std::make_optional(HttpStatusCode::Found);
-            case 303:
-                return std::make_optional(HttpStatusCode::SeeOther);
-            case 304:
-                return std::make_optional(HttpStatusCode::NotModified);
-            case 305:
-                return std::make_optional(HttpStatusCode::UseProxy);
-            case 307:
-                return std::make_optional(HttpStatusCode::TemporaryRedirect);
-            case 308:
-                return std::make_optional(HttpStatusCode::PermanentRedirect);
-            case 400:
-                return std::make_optional(HttpStatusCode::BadRequest);
-            case 401:
-                return std::make_optional(HttpStatusCode::Unauthorized);
-            case 402:
-                return std::make_optional(HttpStatusCode::PaymentRequired);
-            case 403:
-                return std::make_optional(HttpStatusCode::Forbidden);
-            case 404:
-                return std::make_optional(HttpStatusCode::NotFound);
-            case 405:
-                return std::make_optional(HttpStatusCode::MethodNotAllowed);
-            case 406:
-                return std::make_optional(HttpStatusCode::NotAcceptable);
-            case 407:
-                return std::make_optional(HttpStatusCode::ProxyAuthenticationRequired);
-            case 408:
-                return std::make_optional(HttpStatusCode::RequestTimeOut);
-            case 409:
-                return std::make_optional(HttpStatusCode::Conflict);
-            case 410:
-                return std::make_optional(HttpStatusCode::Gone);
-            case 411:
-                return std::make_optional(HttpStatusCode::LengthRequired);
-            case 412:
-                return std::make_optional(HttpStatusCode::PreconditionFailed);
-            case 413:
-                return std::make_optional(HttpStatusCode::RequestEntityTooLarge);
-            case 414:
-                return std::make_optional(HttpStatusCode::RequestUriTooLarge);
-            case 415:
-                return std::make_optional(HttpStatusCode::UnsupportedMediaType);
-            case 416:
-                return std::make_optional(HttpStatusCode::RequestRangeNotSatisfiable);
-            case 417:
-                return std::make_optional(HttpStatusCode::ExpectationFailed);
-            case 500:
-                return std::make_optional(HttpStatusCode::InternalServerError);
-            case 501:
-                return std::make_optional(HttpStatusCode::NotImplemented);
-            case 502:
-                return std::make_optional(HttpStatusCode::BadGateway);
-            case 503:
-                return std::make_optional(HttpStatusCode::ServiceUnavailable);
-            case 504:
-                return std::make_optional(HttpStatusCode::GatewayTimeOut);
-            case 505:
-                return std::make_optional(HttpStatusCode::HttpVersionNotSupported);
-        }
-
-        return std::nullopt;
+        return static_cast<services::HttpStatusCode>(value);
     }
 
     infra::BoundedConstString HttpStatusCodeToString(services::HttpStatusCode statusCode)
@@ -578,6 +489,26 @@ namespace services
                 return "RequestRangeNotSatisfiable";
             case services::HttpStatusCode::ExpectationFailed:
                 return "ExpectationFailed";
+            case services::HttpStatusCode::MisdirectedRequest:
+                return "MisdirectedRequest";
+            case services::HttpStatusCode::UnprocessableContent:
+                return "UnprocessableContent";
+            case services::HttpStatusCode::Locked:
+                return "Locked";
+            case services::HttpStatusCode::FailedDependency:
+                return "FailedDependency";
+            case services::HttpStatusCode::TooEarly:
+                return "TooEarly";
+            case services::HttpStatusCode::UpgradeRequired:
+                return "UpgradeRequired";
+            case services::HttpStatusCode::PreconditionRequired:
+                return "PreconditionRequired";
+            case services::HttpStatusCode::TooManyRequests:
+                return "TooManyRequests";
+            case services::HttpStatusCode::RequestHeaderFieldsTooLarge:
+                return "RequestHeaderFieldsTooLarge";
+            case services::HttpStatusCode::UnavailableForLegalReasons:
+                return "UnavailableForLegalReasons";
             case services::HttpStatusCode::InternalServerError:
                 return "InternalServerError";
             case services::HttpStatusCode::NotImplemented:
@@ -590,9 +521,19 @@ namespace services
                 return "GatewayTimeOut";
             case services::HttpStatusCode::HttpVersionNotSupported:
                 return "HttpVersionNotSupported";
+            case services::HttpStatusCode::VariantAlsoNegotiates:
+                return "VariantAlsoNegotiates";
+            case services::HttpStatusCode::InsufficientStorage:
+                return "InsufficientStorage";
+            case services::HttpStatusCode::LoopDetected:
+                return "LoopDetected";
+            case services::HttpStatusCode::NotExtended:
+                return "NotExtended";
+            case services::HttpStatusCode::NetworkAuthenticationRequired:
+                return "NetworkAuthenticationRequired";
         }
 
-        std::abort();
+        return "Unknown HTTP status";
     }
 }
 
@@ -614,7 +555,10 @@ namespace infra
 
     TextOutputStream& operator<<(TextOutputStream& stream, services::HttpStatusCode statusCode)
     {
-        stream << services::HttpStatusCodeToString(statusCode);
+        auto status = services::HttpStatusCodeToString(statusCode);
+        stream << status;
+        if (status == "Unknown HTTP status")
+            stream << ": " << static_cast<int>(statusCode);
 
         return stream;
     }

services/network/Http.hpp

@@ -58,12 +58,27 @@ namespace services
         UnsupportedMediaType = 415,
         RequestRangeNotSatisfiable = 416,
         ExpectationFailed = 417,
+        MisdirectedRequest = 421,
+        UnprocessableContent = 422,
+        Locked = 423,
+        FailedDependency = 424,
+        TooEarly = 425,
+        UpgradeRequired = 426,
+        PreconditionRequired = 428,
+        TooManyRequests = 429,
+        RequestHeaderFieldsTooLarge = 431,
+        UnavailableForLegalReasons = 451,
         InternalServerError = 500,
         NotImplemented = 501,
         BadGateway = 502,
         ServiceUnavailable = 503,
         GatewayTimeOut = 504,
-        HttpVersionNotSupported = 505
+        HttpVersionNotSupported = 505,
+        VariantAlsoNegotiates = 506,
+        InsufficientStorage = 507,
+        LoopDetected = 508,
+        NotExtended = 510,
+        NetworkAuthenticationRequired = 511
     };
 
     namespace http_responses
@@ -178,7 +193,7 @@ namespace services
     infra::BoundedConstString HttpVerbToString(HttpVerb verb);
     std::optional<HttpVerb> HttpVerbFromString(infra::BoundedConstString verb);
 
-    std::optional<HttpStatusCode> HttpStatusCodeFromString(infra::BoundedConstString statusCode);
+    HttpStatusCode HttpStatusCodeFromString(infra::BoundedConstString statusCode);
     infra::BoundedConstString HttpStatusCodeToString(services::HttpStatusCode statusCode);
 }
 

services/network/test/TestHttpClient.cpp

@@ -86,12 +86,28 @@ INSTANTIATE_TEST_SUITE_P(HttpStatusMessageTest, HttpStatusMessageFormattingTest,
         HttpStatusCodeWithString{ services::HttpStatusCode::UnsupportedMediaType, "UnsupportedMediaType" },
         HttpStatusCodeWithString{ services::HttpStatusCode::RequestRangeNotSatisfiable, "RequestRangeNotSatisfiable" },
         HttpStatusCodeWithString{ services::HttpStatusCode::ExpectationFailed, "ExpectationFailed" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::MisdirectedRequest, "MisdirectedRequest" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::UnprocessableContent, "UnprocessableContent" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::Locked, "Locked" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::FailedDependency, "FailedDependency" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::TooEarly, "TooEarly" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::UpgradeRequired, "UpgradeRequired" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::PreconditionRequired, "PreconditionRequired" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::TooManyRequests, "TooManyRequests" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::RequestHeaderFieldsTooLarge, "RequestHeaderFieldsTooLarge" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::UnavailableForLegalReasons, "UnavailableForLegalReasons" },
         HttpStatusCodeWithString{ services::HttpStatusCode::InternalServerError, "InternalServerError" },
         HttpStatusCodeWithString{ services::HttpStatusCode::NotImplemented, "NotImplemented" },
         HttpStatusCodeWithString{ services::HttpStatusCode::BadGateway, "BadGateway" },
         HttpStatusCodeWithString{ services::HttpStatusCode::ServiceUnavailable, "ServiceUnavailable" },
         HttpStatusCodeWithString{ services::HttpStatusCode::GatewayTimeOut, "GatewayTimeOut" },
-        HttpStatusCodeWithString{ services::HttpStatusCode::HttpVersionNotSupported, "HttpVersionNotSupported" }));
+        HttpStatusCodeWithString{ services::HttpStatusCode::HttpVersionNotSupported, "HttpVersionNotSupported" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::VariantAlsoNegotiates, "VariantAlsoNegotiates" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::InsufficientStorage, "InsufficientStorage" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::LoopDetected, "LoopDetected" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::NotExtended, "NotExtended" },
+        HttpStatusCodeWithString{ services::HttpStatusCode::NetworkAuthenticationRequired, "NetworkAuthenticationRequired" },
+        HttpStatusCodeWithString{ static_cast<services::HttpStatusCode>(900), "Unknown HTTP status: 900" }));
 
 struct HttpStatusCodeAndString
 {
@@ -149,12 +165,27 @@ INSTANTIATE_TEST_SUITE_P(HttpStatusMessageTest, HttpStatusMessageParsingTest,
         HttpStatusCodeAndString{ "415", services::HttpStatusCode::UnsupportedMediaType },
         HttpStatusCodeAndString{ "416", services::HttpStatusCode::RequestRangeNotSatisfiable },
         HttpStatusCodeAndString{ "417", services::HttpStatusCode::ExpectationFailed },
+        HttpStatusCodeAndString{ "421", services::HttpStatusCode::MisdirectedRequest },
+        HttpStatusCodeAndString{ "422", services::HttpStatusCode::UnprocessableContent },
+        HttpStatusCodeAndString{ "423", services::HttpStatusCode::Locked },
+        HttpStatusCodeAndString{ "424", services::HttpStatusCode::FailedDependency },
+        HttpStatusCodeAndString{ "425", services::HttpStatusCode::TooEarly },
+        HttpStatusCodeAndString{ "426", services::HttpStatusCode::UpgradeRequired },
+        HttpStatusCodeAndString{ "428", services::HttpStatusCode::PreconditionRequired },
+        HttpStatusCodeAndString{ "429", services::HttpStatusCode::TooManyRequests },
+        HttpStatusCodeAndString{ "431", services::HttpStatusCode::RequestHeaderFieldsTooLarge },
+        HttpStatusCodeAndString{ "451", services::HttpStatusCode::UnavailableForLegalReasons },
         HttpStatusCodeAndString{ "500", services::HttpStatusCode::InternalServerError },
         HttpStatusCodeAndString{ "501", services::HttpStatusCode::NotImplemented },
         HttpStatusCodeAndString{ "502", services::HttpStatusCode::BadGateway },
         HttpStatusCodeAndString{ "503", services::HttpStatusCode::ServiceUnavailable },
         HttpStatusCodeAndString{ "504", services::HttpStatusCode::GatewayTimeOut },
-        HttpStatusCodeAndString{ "505", services::HttpStatusCode::HttpVersionNotSupported }));
+        HttpStatusCodeAndString{ "505", services::HttpStatusCode::HttpVersionNotSupported },
+        HttpStatusCodeAndString{ "506", services::HttpStatusCode::VariantAlsoNegotiates },
+        HttpStatusCodeAndString{ "507", services::HttpStatusCode::InsufficientStorage },
+        HttpStatusCodeAndString{ "508", services::HttpStatusCode::LoopDetected },
+        HttpStatusCodeAndString{ "510", services::HttpStatusCode::NotExtended },
+        HttpStatusCodeAndString{ "511", services::HttpStatusCode::NetworkAuthenticationRequired }));
 
 class HttpClientTest
     : public testing::Test
@@ -410,15 +441,13 @@ TEST_F(HttpClientTest, incorrect_response_version_should_not_call_StatusAvailabl
     connection.SimulateDataReceived(infra::StringAsByteRange(infra::BoundedConstString("HTTP/X.Y 200 Success\r\n")));
 }
 
-TEST_F(HttpClientTest, incorrect_response_code_should_not_call_StatusAvailable)
+TEST_F(HttpClientTest, unexpected_response_code_should_call_StatusAvailable)
 {
     Connect();
 
-    EXPECT_CALL(client, StatusAvailable(testing::_)).Times(0);
+    EXPECT_CALL(client, StatusAvailable(static_cast<services::HttpStatusCode>(900)));
 
     EXPECT_CALL(connection, AckReceivedMock());
-    EXPECT_CALL(connection, AbortAndDestroyMock());
-    EXPECT_CALL(client, Detaching());
     client.Subject().Get("/");
     ExecuteAllActions();
     connection.SimulateDataReceived(infra::StringAsByteRange(infra::BoundedConstString("HTTP/1.1 900 Invalid\r\n")));