cc userver: use gmock matchers instead of string find + npos

commit_hash:ea65472b0a3a439cfb1bb0821e41964ebf851a13

Author: Anton3

chaotic/integration_tests/tests/render/all_of.cpp

@@ -1,6 +1,8 @@
 #include <userver/formats/json/inline.hpp>
 #include <userver/utest/assert_macros.hpp>
 
+#include <gmock/gmock.h>
+
 #include <userver/chaotic/exception.hpp>
 #include <userver/formats/json/serialize.hpp>
 #include <userver/formats/json/value_builder.hpp>
@@ -161,7 +163,7 @@ TEST(Simple, AllOfOneOf) {
     std::get<1>(oneof).type = "broken";
     EXPECT_EQ(std::get<1>(oneof).type, "broken");
     EXPECT_EQ(TestToJsonString(obj), json);
-    EXPECT_NE(ToJsonString(obj).find("\"type\""), std::string::npos) << "No 'type'";
+    EXPECT_THAT(ToJsonString(obj), testing::HasSubstr("\"type\"")) << "No 'type'";
     EXPECT_EQ(ToJsonString(obj).find("\"type\""), ToJsonString(obj).rfind("\"type\"")) << "Multiple 'type's";
 }*/
 

chaotic/integration_tests/tests/render/one_of.cpp

@@ -1,6 +1,8 @@
 #include <userver/formats/json/inline.hpp>
 #include <userver/utest/assert_macros.hpp>
 
+#include <gmock/gmock.h>
+
 #include <userver/chaotic/exception.hpp>
 #include <userver/formats/json/serialize.hpp>
 #include <userver/formats/json/value_builder.hpp>
@@ -95,7 +97,7 @@ TEST(Simple, OneOfWithDiscriminator) {
     EXPECT_EQ(std::get<0>(obj.oneof.value()).foo, 42);
     EXPECT_EQ(TestToJsonString(obj), json);
     EXPECT_EQ(TestWriteToStream(obj), json);
-    EXPECT_NE(ToJsonString(obj).find("\"type\""), std::string::npos) << "No 'type'";
+    EXPECT_THAT(ToJsonString(obj), testing::HasSubstr("\"type\"")) << "No 'type'";
     EXPECT_EQ(ToJsonString(obj).find("\"type\""), ToJsonString(obj).rfind("\"type\"")) << "Multiple 'type's";
 
     EXPECT_EQ(TestDomSerializer(obj), json);
@@ -104,7 +106,7 @@ TEST(Simple, OneOfWithDiscriminator) {
     EXPECT_EQ(std::get<0>(obj.oneof.value()).type, "incorrect");
     EXPECT_EQ(TestDomSerializer(obj), json);
     EXPECT_EQ(TestToJsonString(obj), json);
-    EXPECT_NE(ToJsonString(obj).find("\"type\""), std::string::npos) << "No 'type'";
+    EXPECT_THAT(ToJsonString(obj), testing::HasSubstr("\"type\"")) << "No 'type'";
     EXPECT_EQ(ToJsonString(obj).find("\"type\""), ToJsonString(obj).rfind("\"type\"")) << "Multiple 'type's";
 }
 
@@ -114,7 +116,7 @@ TEST(Simple, OneOfWithDiscriminatorSax) {
     EXPECT_EQ(std::get<0>(obj.oneof.value()).type, "ObjectFoo");
     EXPECT_EQ(std::get<0>(obj.oneof.value()).foo, 42);
     EXPECT_EQ(TestToJsonString(obj), json);
-    EXPECT_NE(ToJsonString(obj).find("\"type\""), std::string::npos) << "No 'type'";
+    EXPECT_THAT(ToJsonString(obj), testing::HasSubstr("\"type\"")) << "No 'type'";
     EXPECT_EQ(ToJsonString(obj).find("\"type\""), ToJsonString(obj).rfind("\"type\"")) << "Multiple 'type's";
 
     EXPECT_EQ(TestDomSerializer(obj), json);

chaotic/integration_tests/tests/render/oneofdiscriminator.cpp

@@ -1,6 +1,8 @@
 #include <userver/formats/json/inline.hpp>
 #include <userver/utest/assert_macros.hpp>
 
+#include <gmock/gmock.h>
+
 #include <userver/chaotic/exception.hpp>
 #include <userver/formats/json/serialize.hpp>
 #include <userver/formats/json/value_builder.hpp>
@@ -48,7 +50,7 @@ TEST(Simple, OneOfWithDiscriminator2) {
     EXPECT_EQ(std::get<0>(obj.foo.value()).extra["additional"].As<int>(), 14);
     EXPECT_EQ(TestToJsonString(obj), json);
     EXPECT_EQ(TestWriteToStream(obj), json);
-    EXPECT_NE(ToJsonString(obj).find("\"type\""), std::string::npos) << "No 'type'";
+    EXPECT_THAT(ToJsonString(obj), testing::HasSubstr("\"type\"")) << "No 'type'";
     EXPECT_EQ(ToJsonString(obj).find("\"type\""), ToJsonString(obj).rfind("\"type\"")) << "Multiple 'type's";
 
     EXPECT_EQ(TestDomSerializer(obj), json);
@@ -57,7 +59,7 @@ TEST(Simple, OneOfWithDiscriminator2) {
     EXPECT_EQ(std::get<0>(obj.foo.value()).type, "incorrect");
     EXPECT_EQ(TestDomSerializer(obj), json);
     EXPECT_EQ(TestToJsonString(obj), json);
-    EXPECT_NE(ToJsonString(obj).find("\"type\""), std::string::npos) << "No 'type'";
+    EXPECT_THAT(ToJsonString(obj), testing::HasSubstr("\"type\"")) << "No 'type'";
     EXPECT_EQ(ToJsonString(obj).find("\"type\""), ToJsonString(obj).rfind("\"type\"")) << "Multiple 'type's";
 }
 
@@ -69,7 +71,7 @@ TEST(Simple, OneOfWithDiscriminator3) {
     EXPECT_EQ(std::get<1>(obj.foo.value()).b_prop, 42);
     EXPECT_EQ(std::get<1>(obj.foo.value()).extra["additional"].As<int>(), 14);
     EXPECT_EQ(TestToJsonString(obj), json);
-    EXPECT_NE(ToJsonString(obj).find("\"type\""), std::string::npos) << "No 'type'";
+    EXPECT_THAT(ToJsonString(obj), testing::HasSubstr("\"type\"")) << "No 'type'";
     EXPECT_EQ(ToJsonString(obj).find("\"type\""), ToJsonString(obj).rfind("\"type\"")) << "Multiple 'type's";
 
     EXPECT_EQ(TestDomSerializer(obj), json);
@@ -78,7 +80,7 @@ TEST(Simple, OneOfWithDiscriminator3) {
     EXPECT_EQ(std::get<1>(obj.foo.value()).type, "incorrect");
     EXPECT_EQ(TestDomSerializer(obj), json);
     EXPECT_EQ(TestToJsonString(obj), json);
-    EXPECT_NE(ToJsonString(obj).find("\"type\""), std::string::npos) << "No 'type'";
+    EXPECT_THAT(ToJsonString(obj), testing::HasSubstr("\"type\"")) << "No 'type'";
     EXPECT_EQ(ToJsonString(obj).find("\"type\""), ToJsonString(obj).rfind("\"type\"")) << "Multiple 'type's";
 }
 
@@ -87,7 +89,7 @@ TEST(Simple, OneOfWithDiscriminator4) {
     auto obj = json.As<ns::IntegerOneOfDiscriminator>();
     EXPECT_EQ(std::get<0>(obj.foo.value()).version, 42);
     EXPECT_EQ(TestToJsonString(obj), json);
-    EXPECT_NE(ToJsonString(obj).find("\"version\""), std::string::npos) << "No 'version'";
+    EXPECT_THAT(ToJsonString(obj), testing::HasSubstr("\"version\"")) << "No 'version'";
     EXPECT_EQ(ToJsonString(obj).find("\"version\""), ToJsonString(obj).rfind("\"version\"")) << "Multiple 'version's";
 
     EXPECT_EQ(TestDomSerializer(obj), json);
@@ -96,7 +98,7 @@ TEST(Simple, OneOfWithDiscriminator4) {
     EXPECT_EQ(std::get<0>(obj.foo.value()).version, 777);
     EXPECT_EQ(TestDomSerializer(obj), json);
     EXPECT_EQ(TestToJsonString(obj), json);
-    EXPECT_NE(ToJsonString(obj).find("\"version\""), std::string::npos) << "No 'version'";
+    EXPECT_THAT(ToJsonString(obj), testing::HasSubstr("\"version\"")) << "No 'version'";
     EXPECT_EQ(ToJsonString(obj).find("\"version\""), ToJsonString(obj).rfind("\"version\"")) << "Multiple 'version's";
 }
 
@@ -105,7 +107,7 @@ TEST(Simple, OneOfWithDiscriminator5) {
     auto obj = json.As<ns::IntegerOneOfDiscriminator>();
     EXPECT_EQ(std::get<1>(obj.foo.value()).version, 52);
     EXPECT_EQ(TestToJsonString(obj), json);
-    EXPECT_NE(ToJsonString(obj).find("\"version\""), std::string::npos) << "No 'version'";
+    EXPECT_THAT(ToJsonString(obj), testing::HasSubstr("\"version\"")) << "No 'version'";
     EXPECT_EQ(ToJsonString(obj).find("\"version\""), ToJsonString(obj).rfind("\"version\"")) << "Multiple 'version's";
 
     EXPECT_EQ(TestDomSerializer(obj), json);
@@ -114,7 +116,7 @@ TEST(Simple, OneOfWithDiscriminator5) {
     EXPECT_EQ(std::get<1>(obj.foo.value()).version, 777);
     EXPECT_EQ(TestDomSerializer(obj), json);
     EXPECT_EQ(TestToJsonString(obj), json);
-    EXPECT_NE(ToJsonString(obj).find("\"version\""), std::string::npos) << "No 'version'";
+    EXPECT_THAT(ToJsonString(obj), testing::HasSubstr("\"version\"")) << "No 'version'";
     EXPECT_EQ(ToJsonString(obj).find("\"version\""), ToJsonString(obj).rfind("\"version\"")) << "Multiple 'version's";
 }
 

core/src/clients/http/client_test.cpp

@@ -274,7 +274,7 @@ struct ComplexStatusValidateCallback {
 HttpResponse PutValidateCallback(const HttpRequest& request) {
     LOG_INFO() << "HTTP Server receive: " << request;
 
-    EXPECT_NE(request.find("PUT"), std::string::npos) << "PUT request has no PUT in headers: " << request;
+    EXPECT_THAT(request, testing::HasSubstr("PUT")) << "PUT request has no PUT in headers: " << request;
 
     return {
         "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Length: "
@@ -322,8 +322,7 @@ std::string TryGetHeader(const HttpRequest& request, std::string_view header) {
     if (first_pos == std::string::npos) {
         return {};
     }
-    const auto second_pos = request.find(header, first_pos + header.length());
-    EXPECT_EQ(second_pos, std::string::npos)
+    EXPECT_EQ(request.find(header, first_pos + header.length()), std::string::npos)
         << "Header `" << header << "` exists more than once in request: " << request;
 
     auto values_begin_pos = request.find(':', first_pos + header.length()) + 1;
@@ -335,8 +334,8 @@ std::string TryGetHeader(const HttpRequest& request, std::string_view header) {
 }
 
 std::string AssertHeader(const HttpRequest& request, std::string_view header) {
-    const auto first_pos = request.find(header);
-    EXPECT_NE(first_pos, std::string::npos) << "Failed to find header `" << header << "` in request: " << request;
+    EXPECT_THAT(request, testing::HasSubstr(header))
+        << "Failed to find header `" << header << "` in request: " << request;
 
     return TryGetHeader(request, header);
 }
@@ -403,16 +402,30 @@ struct CheckCookie {
     const std::set<std::string> expected_cookies;
 
     HttpResponse operator()(const HttpRequest& request) {
+        static const HttpResponse kOkResponse{
+            "HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Length: 0\r\n\r\n",
+            HttpResponse::kWriteAndClose
+        };
+
         const auto header_pos = request.find("Cookie:");
-        EXPECT_NE(header_pos, std::string::npos) << "Failed to find 'Cookie' header in request: " << request;
+        if (header_pos == std::string::npos) {
+            ADD_FAILURE() << "Failed to find 'Cookie' header in request: " << request;
+            return kOkResponse;
+        }
 
         EXPECT_EQ(request.find("Cookie:", header_pos + 1), std::string::npos)
             << "Duplicate 'Cookie' header in request: " << request;
 
         const auto value_start = request.find_first_not_of(' ', header_pos + 7);
-        EXPECT_NE(value_start, std::string::npos) << "Malformed request: " << request;
+        if (value_start == std::string::npos) {
+            ADD_FAILURE() << "Malformed request: " << request;
+            return kOkResponse;
+        }
         const auto value_end = request.find("\r\n", value_start);
-        EXPECT_NE(value_end, std::string::npos) << "Malformed request: " << request;
+        if (value_end == std::string::npos) {
+            ADD_FAILURE() << "Malformed request: " << request;
+            return kOkResponse;
+        }
 
         auto value = request.substr(value_start, value_end - value_start);
         std::vector<std::string> received_cookies;
@@ -425,7 +438,7 @@ struct CheckCookie {
         }
         EXPECT_TRUE(unseen_cookies.empty()) << "Not all cookies received";
 
-        return {"HTTP/1.1 200 OK\r\nConnection: close\r\nContent-Length: 0\r\n\r\n", HttpResponse::kWriteAndClose};
+        return kOkResponse;
     }
 };
 
@@ -1203,7 +1216,7 @@ UTEST(HttpClient, GetWithBody) {
     auto http_client_ptr = utest::CreateHttpClient();
 
     const utest::SimpleServer http_server_final{[](const HttpRequest& request) -> HttpResponse {
-        EXPECT_NE(request.find("get_body_data"), std::string::npos);
+        EXPECT_THAT(request, testing::HasSubstr("get_body_data"));
         return {
             fmt::format(clients::http::kResponse200WithHeaderPattern, "xxx: good"),
             HttpResponse::kWriteAndClose,

core/src/clients/http/form_test.cpp

@@ -1,5 +1,7 @@
 #include <userver/clients/http/form.hpp>
 
+#include <gmock/gmock.h>
+
 #include <userver/clients/http/client.hpp>
 #include <userver/http/http_version.hpp>
 #include <userver/utest/http_client.hpp>
@@ -57,20 +59,20 @@ void ValidateFilesend(
     key = "name=\"" + key + "\"";
     filename = "filename=\"" + filename + "\"";
 
-    const auto key_pos = request.find(key);
-    EXPECT_NE(key_pos, std::string::npos) << "Found no '" << key << "' in: " << request;
+    EXPECT_THAT(request, testing::HasSubstr(key)) << "Found no '" << key << "' in: " << request;
 
     const auto test_data_pos = request.find(test_data);
-    EXPECT_NE(test_data_pos, std::string::npos) << "failed to find '" << test_data << "' in:" << request;
+    EXPECT_THAT(request, testing::HasSubstr(test_data)) << "failed to find '" << test_data << "' in:" << request;
 
     const auto multipart_pos = request.find("multipart/form-data");
-    EXPECT_NE(multipart_pos, std::string::npos) << "failed to find 'multipart/form-data' in:" << request;
+    EXPECT_THAT(request, testing::HasSubstr("multipart/form-data"))
+        << "failed to find 'multipart/form-data' in:" << request;
 
     const auto filename_pos = request.find(filename);
-    EXPECT_NE(filename_pos, std::string::npos) << "failed to find '" << filename << "' in:" << request;
+    EXPECT_THAT(request, testing::HasSubstr(filename)) << "failed to find '" << filename << "' in:" << request;
 
     const auto content_type_pos = request.find(content_type);
-    EXPECT_NE(content_type_pos, std::string::npos) << "failed to find 'image/jpeg' in:" << request;
+    EXPECT_THAT(request, testing::HasSubstr(content_type)) << "failed to find 'image/jpeg' in:" << request;
 
     EXPECT_LT(multipart_pos, filename_pos) << "Filename appears before 'multipart/form-data': " << request;
 

core/src/engine/io/socket_test.cpp

@@ -1,6 +1,7 @@
 #include <userver/utest/utest.hpp>
 
 #include <arpa/inet.h>
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 #include <sys/socket.h>
 #include <unistd.h>
@@ -346,7 +347,7 @@ UTEST(Socket, ErrorPeername) {
             error_value == std::errc::wrong_protocol_type || error_value == std::errc::broken_pipe ||
             error_value == std::errc::connection_reset || error_value == std::errc::connection_aborted
         );
-        EXPECT_NE(std::string_view{ex.what()}.find(fmt::to_string(listener.addr)), std::string_view::npos);
+        EXPECT_THAT(std::string_view{ex.what()}, testing::HasSubstr(fmt::to_string(listener.addr)));
     }
 }
 
@@ -523,7 +524,7 @@ UTEST(Socket, UdpIpMreqIPv4) {
 
         EXPECT_FALSE(result);  // not expecting any input
     } catch (const std::exception& e) {
-        EXPECT_NE(std::string_view{e.what()}.find("No such device"), std::string_view::npos)
+        EXPECT_THAT(std::string_view{e.what()}, testing::HasSubstr("No such device"))
             << "Error not related to host support of IPv4: " << e.what();
     }
 }

core/src/logging/log_message_test.cpp

@@ -35,7 +35,7 @@ std::string ToStringViaStreams(const T& value) {
 
 void CheckModulePath(std::string_view message, std::string_view expected) {
     auto module_pos = message.find("module=");
-    ASSERT_NE(std::string::npos, module_pos) << "no module logged";
+    ASSERT_THAT(message, testing::HasSubstr("module=")) << "no module logged";
     auto path_pos = message.find(std::string{expected} + ':', module_pos);
     auto delim_pos = message.find('\t', module_pos);
     ASSERT_LT(path_pos, delim_pos)
@@ -372,10 +372,10 @@ TEST_F(LoggingTest, LogExtraTAXICOMMON1362) {
     EXPECT_EQ(result.back(), '\n');
     result.pop_back();
 
-    EXPECT_TRUE(result.find(tskv_test::ascii_part) != std::string::npos) << "Result: " << result;
+    EXPECT_THAT(result, testing::HasSubstr(tskv_test::ascii_part)) << "Result: " << result;
 
     const auto png_pos = result.find("PNG");
-    EXPECT_TRUE(png_pos != std::string::npos) << "Result: " << result;
+    ASSERT_THAT(result, testing::HasSubstr("PNG")) << "Result: " << result;
 
     EXPECT_EQ(0, std::count(result.begin() + png_pos, result.end(), '\n')) << "Result: " << result;
     EXPECT_EQ(0, std::count(result.begin() + png_pos, result.end(), '\t')) << "Result: " << result;
@@ -391,10 +391,10 @@ TEST_F(LoggingTest, TAXICOMMON1362) {
     const std::string result = GetStreamString();
 
     const auto ascii_pos = result.find(tskv_test::ascii_part);
-    EXPECT_TRUE(ascii_pos != std::string::npos) << "Result: " << result;
+    ASSERT_THAT(result, testing::HasSubstr(tskv_test::ascii_part)) << "Result: " << result;
 
     const auto body_pos = result.find("body=");
-    EXPECT_TRUE(body_pos != std::string::npos) << "Result: " << result;
+    ASSERT_THAT(result, testing::HasSubstr("body=")) << "Result: " << result;
 
     EXPECT_EQ(result.substr(body_pos, ascii_pos - body_pos).find_first_of({'\n', '\t', '\0'}), std::string::npos)
         << "Result: " << result;

core/src/logging/log_test.cpp

@@ -1,3 +1,4 @@
+#include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
 #include <optional>
@@ -46,9 +47,9 @@ TEST_F(LoggingTest, LogExtraExtendType) {
 
     logging::LogFlush();
     const auto log_contents = GetStreamString();
-    EXPECT_NE(log_contents.find("key1=value1"), std::string::npos);
-    EXPECT_NE(log_contents.find("key1=value2"), std::string::npos);
-    EXPECT_EQ(log_contents.find("key1=value3"), std::string::npos);
+    EXPECT_THAT(log_contents, testing::HasSubstr("key1=value1"));
+    EXPECT_THAT(log_contents, testing::HasSubstr("key1=value2"));
+    EXPECT_THAT(log_contents, testing::Not(testing::HasSubstr("key1=value3")));
 }
 
 TEST_F(LoggingTest, MultipleFlushes) {
@@ -62,8 +63,8 @@ TEST_F(LoggingTest, MultipleFlushes) {
     LOG_TRACE() << "some message2";
 
     const auto log_contents = GetStreamString();
-    EXPECT_NE(log_contents.find("text=some message1"), std::string::npos);
-    EXPECT_NE(log_contents.find("text=some message2"), std::string::npos);
+    EXPECT_THAT(log_contents, testing::HasSubstr("text=some message1"));
+    EXPECT_THAT(log_contents, testing::HasSubstr("text=some message2"));
 }
 
 TEST_F(LoggingTest, ChronoDuration) {

core/src/server/http/http_response_cookie_test.cpp

@@ -1,3 +1,5 @@
+#include <gmock/gmock.h>
+
 #include <userver/utest/utest.hpp>
 
 #include <sys/param.h>
@@ -150,7 +152,7 @@ TEST(HttpCookie, AttributeValidation) {
     UEXPECT_NO_THROW(cookie.SetPath("/some/path"));
     UEXPECT_NO_THROW(cookie.SetDomain("sub.domain.test"));
     UEXPECT_NO_THROW(cookie.SetSameSite("None"));
-    EXPECT_EQ(cookie.ToString().find("\r\n"), std::string::npos);
+    EXPECT_THAT(cookie.ToString(), testing::Not(testing::HasSubstr("\r\n")));
 }
 
 TEST(HttpCookie, FromString) {

core/src/server/http/http_response_test.cpp

@@ -38,7 +38,7 @@ UTEST(HttpResponse, Smoke) {
     constexpr std::string_view expected_header = "HTTP/1.1 200 OK\r\n";
     ASSERT_EQ(reply.substr(0, expected_header.size()), expected_header);
     const auto expected_content_length = fmt::format("\r\n{}: {}\r\n", http::headers::kContentLength, kBody.size());
-    EXPECT_TRUE(reply.find(expected_content_length) != std::string_view::npos);
+    EXPECT_THAT(reply, testing::HasSubstr(expected_content_length));
 
     EXPECT_EQ(reply.substr(reply.size() - 4 - kBody.size()), fmt::format("\r\n\r\n{}", kBody));
 }
@@ -104,7 +104,7 @@ UTEST_P(HttpResponseBody, ForbiddenBody) {
     const std::string_view reply{buffer.data(), reply_size};
     const std::string expected_header = "HTTP/1.1 " + std::to_string(GetParam()) + " ";
     ASSERT_EQ(reply.substr(0, expected_header.size()), expected_header);
-    EXPECT_TRUE(reply.find(http::headers::kContentLength) == std::string_view::npos);
+    EXPECT_THAT(reply, testing::Not(testing::HasSubstr(http::headers::kContentLength)));
     EXPECT_EQ(reply.substr(reply.size() - 4), "\r\n\r\n");
 }