Add ProtoDefinitionHelper.FromDirectory

WireMock.Net Solution.sln.DotSettings

@@ -35,6 +35,7 @@
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Jmes/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Levenstein/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=openapi/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=opentelemetry/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Pacticipant/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=protobuf/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=Raml/@EntryIndexedValue">True</s:Boolean>

src/WireMock.Net/Extensions/StringExtensions.cs

@@ -0,0 +1,31 @@
+using System.Globalization;
+
+namespace WireMock.Extensions;
+
+internal static class StringExtensions
+{
+    // See https://andrewlock.net/why-is-string-gethashcode-different-each-time-i-run-my-program-in-net-core/
+    public static string GetDeterministicHashCodeAsString(this string str)
+    {
+        unchecked
+        {
+            int hash1 = (5381 << 16) + 5381;
+            int hash2 = hash1;
+
+            for (int i = 0; i < str.Length; i += 2)
+            {
+                hash1 = ((hash1 << 5) + hash1) ^ str[i];
+                if (i == str.Length - 1)
+                {
+                    break;
+                }
+
+                hash2 = ((hash2 << 5) + hash2) ^ str[i + 1];
+            }
+
+            int result = hash1 + hash2 * 1566083941;
+
+            return result.ToString(CultureInfo.InvariantCulture).Replace('-', '_');
+        }
+    }
+}

src/WireMock.Net/Models/ProtoDefinitionData.cs

@@ -0,0 +1,39 @@
+// Copyright © WireMock.Net
+
+using System.Collections.Generic;
+using System.Linq;
+using Stef.Validation;
+
+namespace WireMock.Models;
+
+/// <summary>
+/// A placeholder class for Proto Definitions.
+/// </summary>
+public class ProtoDefinitionData
+{
+    private readonly IDictionary<string, string> _filenameMappedToProtoDefinition;
+
+    internal ProtoDefinitionData(IDictionary<string, string> filenameMappedToProtoDefinition)
+    {
+        _filenameMappedToProtoDefinition = filenameMappedToProtoDefinition;
+    }
+
+    /// <summary>
+    /// Get all the ProtoDefinitions.
+    /// Note: the main ProtoDefinition will be the first one in the list.
+    /// </summary>
+    /// <param name="mainProtoFilename">The main ProtoDefinition filename.</param>
+    public IReadOnlyList<string> ToList(string mainProtoFilename)
+    {
+        Guard.NotNullOrEmpty(mainProtoFilename);
+
+        if (!_filenameMappedToProtoDefinition.TryGetValue(mainProtoFilename, out var mainProtoDefinition))
+        {
+            throw new KeyNotFoundException($"The ProtoDefinition with filename '{mainProtoFilename}' was not found.");
+        }
+
+        var list = new List<string> { mainProtoDefinition };
+        list.AddRange(_filenameMappedToProtoDefinition.Where(kvp => kvp.Key != mainProtoFilename).Select(kvp => kvp.Value));
+        return list;
+    }
+}

src/WireMock.Net/RequestBuilders/Request.WithBodyAsProtoBuf.cs

@@ -1,5 +1,6 @@
 // Copyright © WireMock.Net
 
+using System;
 using System.Collections.Generic;
 using WireMock.Matchers;
 using WireMock.Matchers.Request;
@@ -12,7 +13,7 @@
     /// <inheritdoc />
     public IRequestBuilder WithBodyAsProtoBuf(string protoDefinition, string messageType, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
     {
-        return WithBodyAsProtoBuf([ protoDefinition ], messageType, matchBehaviour);
+        return WithBodyAsProtoBuf([protoDefinition], messageType, matchBehaviour);
     }
 
     /// <inheritdoc />
@@ -36,12 +37,25 @@
     /// <inheritdoc />
     public IRequestBuilder WithBodyAsProtoBuf(string messageType, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
     {
-        return Add(new RequestMessageProtoBufMatcher(matchBehaviour, () => Mapping.ProtoDefinition!.Value, messageType));
+        return Add(new RequestMessageProtoBufMatcher(matchBehaviour, ProtoDefinitionFunc(), messageType));
     }
 
     /// <inheritdoc />
     public IRequestBuilder WithBodyAsProtoBuf(string messageType, IObjectMatcher matcher, MatchBehaviour matchBehaviour = MatchBehaviour.AcceptOnMatch)
     {
-        return Add(new RequestMessageProtoBufMatcher(matchBehaviour, () => Mapping.ProtoDefinition!.Value, messageType, matcher));
+        return Add(new RequestMessageProtoBufMatcher(matchBehaviour, ProtoDefinitionFunc(), messageType, matcher));
+    }
+
+    private Func<IdOrTexts> ProtoDefinitionFunc()
+    {
+        return () =>
+        {
+            if (Mapping.ProtoDefinition == null)
+            {
+                throw new InvalidOperationException($"No ProtoDefinition defined on mapping '{Mapping.Guid}'. Please use the WireMockServerSettings to define ProtoDefinitions.");
+            }
+
+            return Mapping.ProtoDefinition.Value;
+        };
     }
 }

src/WireMock.Net/Server/RespondWithAProvider.cs

@@ -356,9 +356,12 @@
     {
         Guard.NotNull(protoDefinitionOrId);
 
+#if PROTOBUF
         ProtoDefinition = ProtoDefinitionHelper.GetIdOrTexts(_settings, protoDefinitionOrId);
-
         return this;
+#else
+        throw new NotSupportedException("The WithProtoDefinition method can not be used for .NETStandard1.3 or .NET Framework 4.6.1 or lower.");
+#endif
     }
 
     /// <inheritdoc />

src/WireMock.Net/Util/PathUtils.cs

@@ -23,7 +23,7 @@ internal static class PathUtils
     /// <param name="path">The path to remove the loading DirectorySeparatorChars</param>
     public static string? RemoveLeadingDirectorySeparators(string? path)
     {
-        return path?.TrimStart(new[] { Path.DirectorySeparatorChar });
+        return path?.TrimStart(Path.DirectorySeparatorChar);
     }
 
     /// <summary>
@@ -38,4 +38,49 @@ public static string Combine(string root, string? path)
         var result = RemoveLeadingDirectorySeparators(path);
         return result == null ? root : Path.Combine(root, result);
     }
+
+    /// <summary>
+    /// Returns a relative path from one path to another.
+    /// </summary>
+    /// <param name="relativeTo">The source path the result should be relative to. This path is always considered to be a directory..</param>
+    /// <param name="path">The destination path.</param>
+    /// <returns>The relative path, or path if the paths don't share the same root.</returns>
+    public static string GetRelativePath(string relativeTo, string path)
+    {
+#if NETCOREAPP3_1 || NET5_0_OR_GREATER || NETSTANDARD2_1
+        return Path.GetRelativePath(relativeTo, path);
+#else
+        Guard.NotNull(relativeTo);
+        Guard.NotNull(path);
+
+        static string AppendDirectorySeparatorChar(string path)
+        {
+            // Append a slash only if the path is a directory and does not have a slash.
+            if (!Path.HasExtension(path) && !path.EndsWith(Path.DirectorySeparatorChar.ToString()))
+            {
+                return path + Path.DirectorySeparatorChar;
+            }
+
+            return path;
+        }
+
+        var fromUri = new System.Uri(AppendDirectorySeparatorChar(relativeTo));
+        var toUri = new System.Uri(AppendDirectorySeparatorChar(path));
+
+        if (fromUri.Scheme != toUri.Scheme)
+        {
+            return path;
+        }
+
+        var relativeUri = fromUri.MakeRelativeUri(toUri);
+        var relativePath = System.Uri.UnescapeDataString(relativeUri.ToString());
+
+        if (string.Equals(toUri.Scheme, "FILE", System.StringComparison.OrdinalIgnoreCase))
+        {
+            relativePath = relativePath.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar);
+        }
+
+        return relativePath;
+#endif
+    }
 }

src/WireMock.Net/Util/ProtoDefinitionHelper.cs

@@ -1,12 +1,85 @@
 // Copyright © WireMock.Net
 
+#if PROTOBUF
+using System.Collections.Generic;
+using System.IO;
+using System.Threading;
+using System.Threading.Tasks;
+using ProtoBufJsonConverter;
+using ProtoBufJsonConverter.Models;
+using Stef.Validation;
 using WireMock.Models;
 using WireMock.Settings;
 
 namespace WireMock.Util;
 
-internal static class ProtoDefinitionHelper
+/// <summary>
+/// Some helper methods for Proto Definitions.
+/// </summary>
+public static class ProtoDefinitionHelper
 {
+    /// <summary>
+    /// Builds a dictionary of ProtoDefinitions from a directory.
+    /// - The key will be the filename without extension.
+    /// - The value will be the ProtoDefinition with an extra comment with the relative path to each <c>.proto</c> file so it can be used by the WireMockProtoFileResolver.
+    /// </summary>
+    /// <param name="directory">The directory to start from.</param>
+    /// <param name="cancellationToken">The token to monitor for cancellation requests. The default value is <c>System.Threading.CancellationToken.None</c>.</param>
+    public static async Task<ProtoDefinitionData> FromDirectory(string directory, CancellationToken cancellationToken = default)
+    {
+        Guard.NotNullOrEmpty(directory);
+
+        var fileNameMappedToProtoDefinition = new Dictionary<string, string>();
+        var filePaths = Directory.EnumerateFiles(directory, "*.proto", SearchOption.AllDirectories);
+
+        foreach (var filePath in filePaths)
+        {
+            // Get the relative path to the directory (note that this will be OS specific).
+            var relativePath = PathUtils.GetRelativePath(directory, filePath);
+
+            // Make it a valid proto import path
+            var protoRelativePath = relativePath.Replace(Path.DirectorySeparatorChar, '/');
+
+            // Build comment and get content from file.
+            var comment = $"// {protoRelativePath}";
+#if NETSTANDARD2_0
+            var content = File.ReadAllText(filePath);
+#else
+            var content = await File.ReadAllTextAsync(filePath, cancellationToken);
+#endif
+            // Only add the comment if it's not already defined.
+            var modifiedContent = !content.StartsWith(comment) ? $"{comment}\n{content}" : content;
+            var key = Path.GetFileNameWithoutExtension(filePath);
+
+            fileNameMappedToProtoDefinition.Add(key, modifiedContent);
+        }
+
+        var converter = SingletonFactory<Converter>.GetInstance();
+        var resolver = new WireMockProtoFileResolver(fileNameMappedToProtoDefinition.Values);
+
+        var messageTypeMappedToWithProtoDefinition = new Dictionary<string, string>();
+
+        foreach (var protoDefinition in fileNameMappedToProtoDefinition.Values)
+        {
+            var infoRequest = new GetInformationRequest(protoDefinition, resolver);
+
+            try
+            {
+                var info = await converter.GetInformationAsync(infoRequest, cancellationToken);
+                foreach (var messageType  in info.MessageTypes)
+                {
+                    messageTypeMappedToWithProtoDefinition[messageType.Key] = protoDefinition;
+                }
+            }
+            catch
+            {
+                // Ignore
+            }
+        }
+
+        return new ProtoDefinitionData(fileNameMappedToProtoDefinition);
+    }
+
     internal static IdOrTexts GetIdOrTexts(WireMockServerSettings settings, params string[] protoDefinitionOrId)
     {
         switch (protoDefinitionOrId.Length)
@@ -19,9 +92,10 @@
                 }
 
                 return new(null, protoDefinitionOrId);
-            
+
             default:
                 return new(null, protoDefinitionOrId);
         }
     }
-}
+}
+#endif

src/WireMock.Net/Util/WireMockProtoFileResolver.cs

@@ -7,18 +7,19 @@
 using System.Linq;
 using ProtoBufJsonConverter;
 using Stef.Validation;
+using WireMock.Extensions;
 
 namespace WireMock.Util;
 
 /// <summary>
 /// This resolver is used to resolve the extra ProtoDefinition files.
+/// 
 /// It assumes that:
-/// - the first ProtoDefinition file is the main ProtoDefinition file.
-/// - the first commented line of each extra ProtoDefinition file is the filename which is used in the import of the other ProtoDefinition file(s).
+/// - The first commented line of each ProtoDefinition file is the filepath which is used in the import of the other ProtoDefinition file(s).
 /// </summary>
 internal class WireMockProtoFileResolver : IProtoFileResolver
 {
-    private readonly Dictionary<string, string> _files = new();
+    private readonly Dictionary<string, string> _files = [];
 
     public WireMockProtoFileResolver(IReadOnlyCollection<string> protoDefinitions)
     {
@@ -27,12 +28,19 @@
             return;
         }
 
-        foreach (var extraProtoDefinition in protoDefinitions.Skip(1))
+        foreach (var extraProtoDefinition in protoDefinitions)
         {
             var firstNonEmptyLine = extraProtoDefinition.Split(['\r', '\n']).FirstOrDefault(l => !string.IsNullOrEmpty(l));
-            if (firstNonEmptyLine != null && TryGetValidFileName(firstNonEmptyLine.TrimStart(['/', ' ']), out var validFileName))
+            if (firstNonEmptyLine != null)
             {
-                _files.Add(validFileName, extraProtoDefinition);
+                if (TryGetValidPath(firstNonEmptyLine.TrimStart(['/', ' ']), out var validPath))
+                {
+                    _files.Add(validPath, extraProtoDefinition);
+                }
+                else
+                {
+                    _files.Add(extraProtoDefinition.GetDeterministicHashCodeAsString(), extraProtoDefinition);
+                }
             }
         }
     }
@@ -52,15 +60,15 @@
         throw new FileNotFoundException($"The ProtoDefinition '{path}' was not found.");
     }
 
-    private static bool TryGetValidFileName(string fileName, [NotNullWhen(true)] out string? validFileName)
+    private static bool TryGetValidPath(string path, [NotNullWhen(true)] out string? validPath)
     {
-        if (!fileName.Any(c => Path.GetInvalidFileNameChars().Contains(c)))
+        if (!path.Any(c => Path.GetInvalidPathChars().Contains(c)))
         {
-            validFileName = fileName;
+            validPath = path;
             return true;
         }
 
-        validFileName = null;
+        validPath = null;
         return false;
     }
 }