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, 106 insertions, 83 deletions

diff --git a/src/zenutil/cache/cacherequests.cpp b/src/zenutil/cache/cacherequests.cpp
index 51fb61c27..f4de6bacd 100644
--- a/src/zenutil/cache/cacherequests.cpp
+++ b/src/zenutil/cache/cacherequests.cpp
@@ -24,67 +24,67 @@ namespace cacherequests {
 	namespace {
 		constinit AsciiSet ValidNamespaceNameCharactersSet{"abcdefghijklmnopqrstuvwxyz0123456789-_.ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
 		constinit AsciiSet ValidBucketNameCharactersSet{"abcdefghijklmnopqrstuvwxyz0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ"};
+	}  // namespace
 
-		std::optional<std::string> GetValidNamespaceName(std::string_view Name)
+	std::optional<std::string> GetValidNamespaceName(std::string_view Name)
+	{
+		if (Name.empty())
 		{
-			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 {};
-			}
+			ZEN_WARN("Namespace is invalid, empty namespace is not allowed");
+			return {};
+		}
 
-			return ToLower(Name);
+		if (Name.length() > 64)
+		{
+			ZEN_WARN("Namespace '{}' is invalid, length exceeds 64 characters", Name);
+			return {};
 		}
 
-		std::optional<std::string> GetValidBucketName(std::string_view Name)
+		if (!AsciiSet::HasOnly(Name, ValidNamespaceNameCharactersSet))
 		{
-			if (Name.empty())
-			{
-				ZEN_WARN("Bucket name is invalid, empty bucket name is not allowed");
-				return {};
-			}
+			ZEN_WARN("Namespace '{}' is invalid, invalid characters detected", Name);
+			return {};
+		}
 
-			if (!AsciiSet::HasOnly(Name, ValidBucketNameCharactersSet))
-			{
-				ZEN_WARN("Bucket name '{}' is invalid, invalid characters detected", Name);
-				return {};
-			}
+		return ToLower(Name);
+	}
 
-			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 {};
 		}
 
-		std::optional<IoHash> GetValidIoHash(std::string_view Hash)
+		if (!AsciiSet::HasOnly(Name, ValidBucketNameCharactersSet))
 		{
-			if (Hash.length() != IoHash::StringLength)
-			{
-				return {};
-			}
+			ZEN_WARN("Bucket name '{}' is invalid, invalid characters detected", Name);
+			return {};
+		}
 
-			IoHash KeyHash;
-			if (!ParseHexBytes(Hash.data(), Hash.size(), KeyHash.Hash))
-			{
-				return {};
-			}
-			return KeyHash;
+		return ToLower(Name);
+	}
+
+	std::optional<IoHash> GetValidIoHash(std::string_view Hash)
+	{
+		if (Hash.length() != IoHash::StringLength)
+		{
+			return {};
 		}
 
-		std::optional<CacheRecordPolicy> Convert(const OptionalCacheRecordPolicy& Policy)
+		IoHash KeyHash;
+		if (!ParseHexBytes(Hash.data(), Hash.size(), KeyHash.Hash))
 		{
-			return Policy.IsValid() ? Policy.Get() : std::optional<CacheRecordPolicy>{};
-		};
-	}  // namespace
+			return {};
+		}
+		return KeyHash;
+	}
+
+	std::optional<CacheRecordPolicy> Convert(const OptionalCacheRecordPolicy& Policy)
+	{
+		return Policy.IsValid() ? Policy.Get() : std::optional<CacheRecordPolicy>{};
+	};
 
 	std::optional<std::string> GetRequestNamespace(const CbObjectView& Params)
 	{
@@ -923,16 +923,18 @@ namespace cacherequests {
 		return true;
 	}
 
-	bool HttpRequestParseRelativeUri(std::string_view Key, HttpRequestData& Data)
+	bool HttpRequestParseRelativeUri(std::string_view Key, std::string_view DefaultNamespace, HttpRequestData& Data)
 	{
 		std::vector<std::string_view> Tokens;
-		uint32_t					  TokenCount = zen::ForEachStrTok(Key, '/', [&](const std::string_view& Token) {
+		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();
@@ -947,7 +949,8 @@ namespace cacherequests {
 						{
 							return false;
 						}
-						Data.HashKey = PossibleHashKey;
+						Data.HashKey   = PossibleHashKey;
+						Data.Namespace = DefaultNamespace;
 						return true;
 					}
 					Data.Namespace = GetValidNamespaceName(Tokens[0]);
@@ -979,6 +982,7 @@ namespace cacherequests {
 						{
 							return false;
 						}
+						Data.Namespace = DefaultNamespace;
 						return true;
 					}
 					Data.Namespace = GetValidNamespaceName(Tokens[0]);
@@ -1552,85 +1556,104 @@ namespace cacherequests {
 		CHECK(FullResult == FullResultCopy);
 	}
 
-	TEST_CASE("z$service.parse.relative.Uri")
+	TEST_CASE("cachrequests.parse.relative.Uri")
 	{
+		using namespace std::literals;
+
+		HttpRequestData RootRequest;
+		CHECK(HttpRequestParseRelativeUri("", "!default!", RootRequest));
+		CHECK(!RootRequest.Namespace.has_value());
+		CHECK(!RootRequest.Bucket.has_value());
+		CHECK(!RootRequest.HashKey.has_value());
+		CHECK(!RootRequest.ValueContentId.has_value());
+
+		RootRequest = {};
+		CHECK(HttpRequestParseRelativeUri("/", "!default!", 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");
+		CHECK(HttpRequestParseRelativeUri("test", "!default!", 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);
-		CHECK(LegacyHashKeyRequest.Bucket == "test");
-		CHECK(LegacyHashKeyRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"));
+		CHECK(HttpRequestParseRelativeUri("test/0123456789abcdef12340123456789abcdef1234", "!default!", LegacyHashKeyRequest));
+		CHECK(LegacyHashKeyRequest.Namespace == "!default!");
+		CHECK(LegacyHashKeyRequest.Bucket == "test"sv);
+		CHECK(LegacyHashKeyRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"sv));
 		CHECK(!LegacyHashKeyRequest.ValueContentId.has_value());
 
 		HttpRequestData LegacyValueContentIdRequest;
 		CHECK(HttpRequestParseRelativeUri("test/0123456789abcdef12340123456789abcdef1234/56789abcdef12345678956789abcdef123456789",
+										  "!default!",
 										  LegacyValueContentIdRequest));
-		CHECK(!LegacyValueContentIdRequest.Namespace);
-		CHECK(LegacyValueContentIdRequest.Bucket == "test");
-		CHECK(LegacyValueContentIdRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"));
-		CHECK(LegacyValueContentIdRequest.ValueContentId == IoHash::FromHexString("56789abcdef12345678956789abcdef123456789"));
+		CHECK(LegacyValueContentIdRequest.Namespace == "!default!");
+		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(HttpRequestParseRelativeUri("ue4.ddc", "!default!", 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");
+		CHECK(HttpRequestParseRelativeUri("nicenamespace", "!default!", 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(HttpRequestParseRelativeUri("ue4.ddc/test", "!default!", V2BucketRequestWithDefaultNamespace));
 		CHECK(V2BucketRequestWithDefaultNamespace.Namespace == "ue4.ddc");
-		CHECK(V2BucketRequestWithDefaultNamespace.Bucket == "test");
+		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");
-		CHECK(V2BucketRequestWithNamespace.Bucket == "test");
+		CHECK(HttpRequestParseRelativeUri("nicenamespace/test", "!default!", 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);
+		CHECK(HttpRequestParseRelativeUri("test/0123456789abcdef12340123456789abcdef1234", "!default!", V2HashKeyRequest));
+		CHECK(V2HashKeyRequest.Namespace == "!default!");
 		CHECK(V2HashKeyRequest.Bucket == "test");
-		CHECK(V2HashKeyRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"));
+		CHECK(V2HashKeyRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"sv));
 		CHECK(!V2HashKeyRequest.ValueContentId.has_value());
 
 		HttpRequestData V2ValueContentIdRequest;
 		CHECK(HttpRequestParseRelativeUri(
 			"nicenamespace/test/0123456789abcdef12340123456789abcdef1234/56789abcdef12345678956789abcdef123456789",
+			"!default!",
 			V2ValueContentIdRequest));
-		CHECK(V2ValueContentIdRequest.Namespace == "nicenamespace");
-		CHECK(V2ValueContentIdRequest.Bucket == "test");
-		CHECK(V2ValueContentIdRequest.HashKey == IoHash::FromHexString("0123456789abcdef12340123456789abcdef1234"));
-		CHECK(V2ValueContentIdRequest.ValueContentId == IoHash::FromHexString("56789abcdef12345678956789abcdef123456789"));
+		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("", Invalid));
-		CHECK(!HttpRequestParseRelativeUri("/", 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("bad\2_namespace", "!default!", Invalid));
+		CHECK(!HttpRequestParseRelativeUri("nice/\2\1bucket", "!default!", Invalid));
+		CHECK(!HttpRequestParseRelativeUri("namespace/bucket/0123456789a", "!default!", Invalid));
+		CHECK(!HttpRequestParseRelativeUri("namespace/bucket/0123456789abcdef12340123456789abcdef1234/56789abcdef1234",
+										   "!default!",
+										   Invalid));
+		CHECK(!HttpRequestParseRelativeUri("namespace/bucket/pppppppp89abcdef12340123456789abcdef1234", "!default!", Invalid));
+		CHECK(!HttpRequestParseRelativeUri("namespace/bucket/0123456789abcdef12340123456789abcdef1234/56789abcd", "!default!", Invalid));
 		CHECK(!HttpRequestParseRelativeUri(
 			"namespace/bucket/0123456789abcdef12340123456789abcdef1234/ppppppppdef12345678956789abcdef123456789",
+			"!default!",
 			Invalid));
 	}
 #endif