Add test to validate the urls

Author: EmandM

com.unity.netcode.gameobjects/Runtime/HelpUrls.cs

@@ -6,6 +6,7 @@ internal static class HelpUrls
         private const string k_BaseManualUrl = k_BaseUrl + "manual/";
         private const string k_BaseApiUrl = k_BaseUrl + "api/Unity.Netcode";
 
+        // The HelpUrls have to be defined as public for the test to work
         public const string NetworkManager = k_BaseManualUrl + "components/core/networkmanager.html";
         public const string NetworkObject = k_BaseManualUrl + "components/core/networkobject.html";
         public const string NetworkAnimator = k_BaseManualUrl + "components/helper/networkanimator.html";
@@ -15,8 +16,7 @@ internal static class HelpUrls
         public const string NetworkTransform = k_BaseManualUrl + "components/helper/networktransform.html";
         public const string AnticipatedNetworkTransform = k_BaseManualUrl + "advanced-topics/client-anticipation.html";
         public const string UnityTransport = k_BaseApiUrl + ".Transports.UTP.UnityTransport.html";
-        public const string SecretsLoaderHelper = k_BaseManualUrl + ".Transports.UTP.SecretsLoaderHelper.html";
+        public const string SecretsLoaderHelper = k_BaseApiUrl + ".Transports.UTP.SecretsLoaderHelper.html";
         public const string SinglePlayerTransport = k_BaseApiUrl + ".Transports.SinglePlayer.SinglePlayerTransport.html";
-        public const string NotValid = k_BaseApiUrl + ".SomeObject.NotValid.html";
     }
 }

com.unity.netcode.gameobjects/Tests/Runtime/HelpUrlTests.cs

@@ -5,6 +5,7 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Net.Http;
+using System.Text.RegularExpressions;
 using System.Threading.Tasks;
 using NUnit.Framework;
 using Unity.Netcode.Runtime;
@@ -15,14 +16,18 @@ namespace Unity.Netcode.RuntimeTests
 {
     internal class HelpUrlTests
     {
-        private static readonly HttpClient k_HttpClient = new HttpClient();
+        private const string k_PackageName = "com.unity.netcode.gameobjects";
+        private static readonly HttpClient k_HttpClient = new();
+
+        private bool m_VerboseLogging = false;
 
         [UnityTest]
         public IEnumerator ValidateUrlsAreValid()
         {
             var names = new List<string>();
             var allUrls = new List<string>();
 
+            // GetFields() can only see public strings. Ensure each HelpUrl is public.
             foreach (var constant in typeof(HelpUrls).GetFields())
             {
                 if (constant.IsLiteral && !constant.IsInitOnly)
@@ -31,12 +36,13 @@ public IEnumerator ValidateUrlsAreValid()
                     allUrls.Add((string)constant.GetValue(null));
                 }
             }
-            Debug.Log($"Found {allUrls.Count} URLs");
+
+            VerboseLog($"Found {allUrls.Count} URLs");
 
             var tasks = new List<Task<bool>>();
             foreach (var url in allUrls)
             {
-                tasks.Add(IsRemoteFileAvailable(url));
+                tasks.Add(AreUnityDocsAvailableAt(url));
             }
 
             while (tasks.Any(task => !task.IsCompleted))
@@ -46,7 +52,42 @@ public IEnumerator ValidateUrlsAreValid()
 
             for (int i = 0; i < allUrls.Count; i++)
             {
-                Assert.IsTrue(tasks[i].Result, $"HelpUrls.{names[i]} is an invalid path!");
+                Assert.IsTrue(tasks[i].Result, $"HelpUrls.{names[i]} has an invalid path! Path: {allUrls[i]}");
+            }
+        }
+
+        private async Task<bool> AreUnityDocsAvailableAt(string url)
+        {
+            try
+            {
+                var split = url.Split('#');
+                url = split[0];
+
+                var stream = await GetContentFromRemoteFile(url);
+
+                var redirectUrl = CalculateRedirectURl(url, stream);
+                VerboseLog($"Calculated Redirect URL: {redirectUrl}");
+
+                var content = await GetContentFromRemoteFile(redirectUrl);
+
+                // If original url had an anchor part (e.g. some/url.html#anchor)
+                if (split.Length > 1)
+                {
+                    var anchorString = split[1];
+
+                    // All headings will have an id with the anchorstring (e.g. <h2 id="anchor">)
+                    if (!content.Contains($"id=\"{anchorString}\">"))
+                    {
+                        return false;
+                    }
+                }
+
+                return true;
+            }
+            catch (Exception e)
+            {
+                VerboseLog(e.Message);
+                return false;
             }
         }
 
@@ -55,29 +96,68 @@ public IEnumerator ValidateUrlsAreValid()
         /// </summary>
         /// <param name="url">URL to a remote file.</param>
         /// <returns>True if the file at the <paramref name="url"/> is able to be downloaded, false if the file does not exist, or if the file is restricted.</returns>
-        private static async Task<bool> IsRemoteFileAvailable(string url)
+        private async Task<string> GetContentFromRemoteFile(string url)
         {
             //Checking if URI is well formed is optional
             var uri = new Uri(url);
             if (!uri.IsWellFormedOriginalString())
             {
-                Debug.LogError($"URL {url} is not well formed");
-                return false;
+                throw new Exception($"URL {url} is not well formed");
             }
 
             try
             {
-                using var request = new HttpRequestMessage(HttpMethod.Head, uri);
+                using var request = new HttpRequestMessage(HttpMethod.Get, uri);
                 using var response = await k_HttpClient.SendAsync(request);
+                if (!response.IsSuccessStatusCode || response.Content.Headers.ContentLength <= 0)
+                {
+                    throw new Exception($"Failed to get remote file from URL {url}");
+                }
 
-                var exists = response.IsSuccessStatusCode && response.Content.Headers.ContentLength > 0;
-                Debug.Log($"url {url} returned status code {response.StatusCode}");
-                return exists;
+                return await response.Content.ReadAsStringAsync();
             }
             catch
             {
-                Debug.LogError($"URL {url} request failed");
-                return false;
+                throw new Exception($"URL {url} request failed");
+            }
+        }
+
+        private string CalculateRedirectURl(string originalRequest, string content)
+        {
+            var uri = new Uri(originalRequest);
+            var baseRequest = $"{uri.Scheme}://{uri.Host}";
+            foreach (var segment in uri.Segments)
+            {
+                if (segment.Contains(k_PackageName))
+                {
+                    break;
+                }
+                baseRequest += segment;
+            }
+
+            var subfolderRegex = new Regex(@"[?&](\w[\w.]*)=([^?&]+)").Match(uri.Query);
+            var subfolder = "";
+            foreach (Group match in subfolderRegex.Groups)
+            {
+                subfolder = match.Value;
+            }
+
+            string pattern = @"com.unity.netcode.gameobjects\@(\d+.\d+)";
+            var targetDestination = "";
+            foreach (Match match in Regex.Matches(content, pattern))
+            {
+                targetDestination = match.Value;
+                break;
+            }
+
+            return baseRequest + targetDestination + subfolder;
+        }
+
+        private void VerboseLog(string message)
+        {
+            if (m_VerboseLogging)
+            {
+                Debug.unityLogger.Log(message);
             }
         }