clean up test linking (#4)

- Improvement: Add zenhttp-test and zenutil-test
- Improvement: Moved cachepolicy test to cachepolicy.cpp
- Improvement: Renamed cachestore tests from z$ to cachestore
- Improvement: Moved test linking so test for a lib is linked by <lib>-test
- Improvement: Removed HttpRequestParseRelativeUri in httpstructuredcache.cpp and use the one in cacherequests.h instead

1 files changed, 2 insertions, 278 deletions

diff --git a/src/zenserver/cache/httpstructuredcache.cpp b/src/zenserver/cache/httpstructuredcache.cpp
index 4cf7c9a01..f64b9c5a5 100644
--- a/src/zenserver/cache/httpstructuredcache.cpp
+++ b/src/zenserver/cache/httpstructuredcache.cpp
@@ -39,11 +39,6 @@
 #include <cpr/cpr.h>
 #include <gsl/gsl-lite.hpp>
 
-#if ZEN_WITH_TESTS
-#	include <zencore/testing.h>
-#	include <zencore/testutils.h>
-#endif
-
 namespace zen {
 
 using namespace std::literals;
@@ -64,64 +59,6 @@ namespace {
 	static constinit std::string_view HttpZCacheUtilReplayRecording = "exec$/replay-recording"sv;
 	static constinit std::string_view HttpZCacheDetailsPrefix		= "details$"sv;
 
-	constinit AsciiSet ValidNamespaceNameCharactersSet{"abcdefghijklmnopqrstuvwxyz0123456789-_.ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
-	constinit AsciiSet ValidBucketNameCharactersSet{"abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
-
-	std::optional<std::string> GetValidNamespaceName(std::string_view Name)
-	{
-		if (Name.empty())
-		{
-			ZEN_WARN("Namespace is invalid, empty namespace is not allowed");
-			return {};
-		}
-
-		if (Name.length() > 64)
-		{
-			ZEN_WARN("Namespace '{}' is invalid, length exceeds 64 characters", Name);
-			return {};
-		}
-
-		if (!AsciiSet::HasOnly(Name, ValidNamespaceNameCharactersSet))
-		{
-			ZEN_WARN("Namespace '{}' is invalid, invalid characters detected", Name);
-			return {};
-		}
-
-		return ToLower(Name);
-	}
-
-	std::optional<std::string> GetValidBucketName(std::string_view Name)
-	{
-		if (Name.empty())
-		{
-			ZEN_WARN("Bucket name is invalid, empty bucket name is not allowed");
-			return {};
-		}
-
-		if (!AsciiSet::HasOnly(Name, ValidBucketNameCharactersSet))
-		{
-			ZEN_WARN("Bucket name '{}' is invalid, invalid characters detected", Name);
-			return {};
-		}
-
-		return ToLower(Name);
-	}
-
-	std::optional<IoHash> GetValidIoHash(std::string_view Hash)
-	{
-		if (Hash.length() != IoHash::StringLength)
-		{
-			return {};
-		}
-
-		IoHash KeyHash;
-		if (!ParseHexBytes(Hash.data(), Hash.size(), KeyHash.Hash))
-		{
-			return {};
-		}
-		return KeyHash;
-	}
-
 	struct HttpRequestData
 	{
 		std::optional<std::string> Namespace;
@@ -130,117 +67,6 @@ namespace {
 		std::optional<IoHash>	   ValueContentId;
 	};
 
-	bool HttpRequestParseRelativeUri(std::string_view Key, HttpRequestData& Data)
-	{
-		std::vector<std::string_view> Tokens;
-		uint32_t					  TokenCount = ForEachStrTok(Key, '/', [&](const std::string_view& Token) {
-			 Tokens.push_back(Token);
-			 return true;
-		 });
-
-		switch (TokenCount)
-		{
-			case 0:
-				return true;
-			case 1:
-				Data.Namespace = GetValidNamespaceName(Tokens[0]);
-				return Data.Namespace.has_value();
-			case 2:
-				{
-					std::optional<IoHash> PossibleHashKey = GetValidIoHash(Tokens[1]);
-					if (PossibleHashKey.has_value())
-					{
-						// Legacy bucket/key request
-						Data.Bucket = GetValidBucketName(Tokens[0]);
-						if (!Data.Bucket.has_value())
-						{
-							return false;
-						}
-						Data.HashKey   = PossibleHashKey;
-						Data.Namespace = ZenCacheStore::DefaultNamespace;
-						return true;
-					}
-					Data.Namespace = GetValidNamespaceName(Tokens[0]);
-					if (!Data.Namespace.has_value())
-					{
-						return false;
-					}
-					Data.Bucket = GetValidBucketName(Tokens[1]);
-					if (!Data.Bucket.has_value())
-					{
-						return false;
-					}
-					return true;
-				}
-			case 3:
-				{
-					std::optional<IoHash> PossibleHashKey = GetValidIoHash(Tokens[1]);
-					if (PossibleHashKey.has_value())
-					{
-						// Legacy bucket/key/valueid request
-						Data.Bucket = GetValidBucketName(Tokens[0]);
-						if (!Data.Bucket.has_value())
-						{
-							return false;
-						}
-						Data.HashKey		= PossibleHashKey;
-						Data.ValueContentId = GetValidIoHash(Tokens[2]);
-						if (!Data.ValueContentId.has_value())
-						{
-							return false;
-						}
-						Data.Namespace = ZenCacheStore::DefaultNamespace;
-						return true;
-					}
-					Data.Namespace = GetValidNamespaceName(Tokens[0]);
-					if (!Data.Namespace.has_value())
-					{
-						return false;
-					}
-					Data.Bucket = GetValidBucketName(Tokens[1]);
-					if (!Data.Bucket.has_value())
-					{
-						return false;
-					}
-					Data.HashKey = GetValidIoHash(Tokens[2]);
-					if (!Data.HashKey)
-					{
-						return false;
-					}
-					return true;
-				}
-			case 4:
-				{
-					Data.Namespace = GetValidNamespaceName(Tokens[0]);
-					if (!Data.Namespace.has_value())
-					{
-						return false;
-					}
-
-					Data.Bucket = GetValidBucketName(Tokens[1]);
-					if (!Data.Bucket.has_value())
-					{
-						return false;
-					}
-
-					Data.HashKey = GetValidIoHash(Tokens[2]);
-					if (!Data.HashKey.has_value())
-					{
-						return false;
-					}
-
-					Data.ValueContentId = GetValidIoHash(Tokens[3]);
-					if (!Data.ValueContentId.has_value())
-					{
-						return false;
-					}
-					return true;
-				}
-			default:
-				return false;
-		}
-	}
-
 }  // namespace
 
 //////////////////////////////////////////////////////////////////////////
@@ -614,8 +440,8 @@ HttpStructuredCacheService::HandleRequest(HttpServerRequest& Request)
 		return;
 	}
 
-	HttpRequestData RequestData;
-	if (!HttpRequestParseRelativeUri(Key, RequestData))
+	cacherequests::HttpRequestData RequestData;
+	if (!cacherequests::HttpRequestParseRelativeUri(Key, ZenCacheStore::DefaultNamespace, RequestData))
 	{
 		m_CacheStats.BadRequestCount++;
 		return Request.WriteResponse(HttpResponseCode::BadRequest);	 // invalid URL
@@ -1968,106 +1794,4 @@ HttpStructuredCacheService::AreDiskWritesAllowed() const
 	return (m_DiskWriteBlocker == nullptr || m_DiskWriteBlocker->AreDiskWritesAllowed());
 }
 
-#if ZEN_WITH_TESTS
-
-TEST_CASE("z$service.parse.relative.Uri")
-{
-	HttpRequestData RootRequest;
-	CHECK(HttpRequestParseRelativeUri("", RootRequest));
-	CHECK(!RootRequest.Namespace.has_value());
-	CHECK(!RootRequest.Bucket.has_value());
-	CHECK(!RootRequest.HashKey.has_value());
-	CHECK(!RootRequest.ValueContentId.has_value());
-
-	RootRequest = {};
-	CHECK(HttpRequestParseRelativeUri("/", RootRequest));
-	CHECK(!RootRequest.Namespace.has_value());
-	CHECK(!RootRequest.Bucket.has_value());
-	CHECK(!RootRequest.HashKey.has_value());
-	CHECK(!RootRequest.ValueContentId.has_value());
-
-	HttpRequestData LegacyBucketRequestBecomesNamespaceRequest;
-	CHECK(HttpRequestParseRelativeUri("test", LegacyBucketRequestBecomesNamespaceRequest));
-	CHECK(LegacyBucketRequestBecomesNamespaceRequest.Namespace == "test"sv);
-	CHECK(!LegacyBucketRequestBecomesNamespaceRequest.Bucket.has_value());
-	CHECK(!LegacyBucketRequestBecomesNamespaceRequest.HashKey.has_value());
-	CHECK(!LegacyBucketRequestBecomesNamespaceRequest.ValueContentId.has_value());
-
-	HttpRequestData LegacyHashKeyRequest;
-	CHECK(HttpRequestParseRelativeUri("test/0123456789abcdef12340123456789abcdef1234", LegacyHashKeyRequest));
-	CHECK(LegacyHashKeyRequest.Namespace == ZenCacheStore::DefaultNamespace);
-	CHECK(LegacyHashKeyRequest.Bucket == "test"sv);
-	CHECK(LegacyHashKeyRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"sv));
-	CHECK(!LegacyHashKeyRequest.ValueContentId.has_value());
-
-	HttpRequestData LegacyValueContentIdRequest;
-	CHECK(HttpRequestParseRelativeUri("test/0123456789abcdef12340123456789abcdef1234/56789abcdef12345678956789abcdef123456789",
-									  LegacyValueContentIdRequest));
-	CHECK(LegacyValueContentIdRequest.Namespace == ZenCacheStore::DefaultNamespace);
-	CHECK(LegacyValueContentIdRequest.Bucket == "test"sv);
-	CHECK(LegacyValueContentIdRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"sv));
-	CHECK(LegacyValueContentIdRequest.ValueContentId == IoHash::FromHexString("56789abcdef12345678956789abcdef123456789"sv));
-
-	HttpRequestData V2DefaultNamespaceRequest;
-	CHECK(HttpRequestParseRelativeUri("ue4.ddc", V2DefaultNamespaceRequest));
-	CHECK(V2DefaultNamespaceRequest.Namespace == "ue4.ddc");
-	CHECK(!V2DefaultNamespaceRequest.Bucket.has_value());
-	CHECK(!V2DefaultNamespaceRequest.HashKey.has_value());
-	CHECK(!V2DefaultNamespaceRequest.ValueContentId.has_value());
-
-	HttpRequestData V2NamespaceRequest;
-	CHECK(HttpRequestParseRelativeUri("nicenamespace", V2NamespaceRequest));
-	CHECK(V2NamespaceRequest.Namespace == "nicenamespace"sv);
-	CHECK(!V2NamespaceRequest.Bucket.has_value());
-	CHECK(!V2NamespaceRequest.HashKey.has_value());
-	CHECK(!V2NamespaceRequest.ValueContentId.has_value());
-
-	HttpRequestData V2BucketRequestWithDefaultNamespace;
-	CHECK(HttpRequestParseRelativeUri("ue4.ddc/test", V2BucketRequestWithDefaultNamespace));
-	CHECK(V2BucketRequestWithDefaultNamespace.Namespace == "ue4.ddc");
-	CHECK(V2BucketRequestWithDefaultNamespace.Bucket == "test"sv);
-	CHECK(!V2BucketRequestWithDefaultNamespace.HashKey.has_value());
-	CHECK(!V2BucketRequestWithDefaultNamespace.ValueContentId.has_value());
-
-	HttpRequestData V2BucketRequestWithNamespace;
-	CHECK(HttpRequestParseRelativeUri("nicenamespace/test", V2BucketRequestWithNamespace));
-	CHECK(V2BucketRequestWithNamespace.Namespace == "nicenamespace"sv);
-	CHECK(V2BucketRequestWithNamespace.Bucket == "test"sv);
-	CHECK(!V2BucketRequestWithNamespace.HashKey.has_value());
-	CHECK(!V2BucketRequestWithNamespace.ValueContentId.has_value());
-
-	HttpRequestData V2HashKeyRequest;
-	CHECK(HttpRequestParseRelativeUri("test/0123456789abcdef12340123456789abcdef1234", V2HashKeyRequest));
-	CHECK(V2HashKeyRequest.Namespace == ZenCacheStore::DefaultNamespace);
-	CHECK(V2HashKeyRequest.Bucket == "test");
-	CHECK(V2HashKeyRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"sv));
-	CHECK(!V2HashKeyRequest.ValueContentId.has_value());
-
-	HttpRequestData V2ValueContentIdRequest;
-	CHECK(
-		HttpRequestParseRelativeUri("nicenamespace/test/0123456789abcdef12340123456789abcdef1234/56789abcdef12345678956789abcdef123456789",
-									V2ValueContentIdRequest));
-	CHECK(V2ValueContentIdRequest.Namespace == "nicenamespace"sv);
-	CHECK(V2ValueContentIdRequest.Bucket == "test"sv);
-	CHECK(V2ValueContentIdRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"sv));
-	CHECK(V2ValueContentIdRequest.ValueContentId == IoHash::FromHexString("56789abcdef12345678956789abcdef123456789"sv));
-
-	HttpRequestData Invalid;
-	CHECK(!HttpRequestParseRelativeUri("bad\2_namespace", Invalid));
-	CHECK(!HttpRequestParseRelativeUri("nice/\2\1bucket", Invalid));
-	CHECK(!HttpRequestParseRelativeUri("namespace/bucket/0123456789a", Invalid));
-	CHECK(!HttpRequestParseRelativeUri("namespace/bucket/0123456789abcdef12340123456789abcdef1234/56789abcdef1234", Invalid));
-	CHECK(!HttpRequestParseRelativeUri("namespace/bucket/pppppppp89abcdef12340123456789abcdef1234", Invalid));
-	CHECK(!HttpRequestParseRelativeUri("namespace/bucket/0123456789abcdef12340123456789abcdef1234/56789abcd", Invalid));
-	CHECK(!HttpRequestParseRelativeUri("namespace/bucket/0123456789abcdef12340123456789abcdef1234/ppppppppdef12345678956789abcdef123456789",
-									   Invalid));
-}
-
-#endif
-
-void
-z$service_forcelink()
-{
-}
-
 }  // namespace zen