starred/WireMock.Net-wiremock
1
0
Fork 0
mirror of https://github.com/wiremock/WireMock.Net.git synced 2026-03-31 22:23:05 +02:00
Code Issues 32 Packages Projects Releases 10 Wiki Activity

Use new Handlebars.Net.Helpers (#581)

Browse Source
This commit is contained in:
Stef Heyenrath
2021-02-09 20:35:44 +01:00
committed by GitHub
parent 3b0dc46771
commit 23709fa587
36 changed files with 557 additions and 1101 deletions
Download Patch File Download Diff File Expand all files Collapse all files

27
src/WireMock.Net/Transformers/Handlebars/FileHelpers.cs Normal file
View File

@@ -0,0 +1,27 @@
using System;
using HandlebarsDotNet;
using HandlebarsDotNet.Helpers.Attributes;
using HandlebarsDotNet.Helpers.Enums;
using HandlebarsDotNet.Helpers.Helpers;
using WireMock.Handlers;
namespace WireMock.Transformers.Handlebars
{
internal class FileHelpers : BaseHelpers, IHelpers
{
private readonly IFileSystemHandler _fileSystemHandler;
public FileHelpers(IHandlebars context, IFileSystemHandler fileSystemHandler) : base(context)
{
_fileSystemHandler = fileSystemHandler ?? throw new ArgumentNullException(nameof(fileSystemHandler));
}
[HandlebarsWriter(WriterType.String, usage: HelperUsage.Both, passContext: true, name: "File")]
public string Read(Context context, string path)
{
var templateFunc = Context.Compile(path);
string transformed = templateFunc(context.Value);
return _fileSystemHandler.ReadResponseBodyAsString(transformed);
}
}
}

3
src/WireMock.Net/Transformers/Handlebars/HandlebarsContext.cs
View File

@@ -1,6 +1,6 @@
using HandlebarsDotNet;
using WireMock.Handlers;
namespace WireMock.Transformers.Handlebars
{
internal class HandlebarsContext : IHandlebarsContext
@@ -12,7 +12,6 @@ namespace WireMock.Transformers.Handlebars
public string ParseAndRender(string text, object model)
{
var template = Handlebars.Compile(text);
return template(model);
}
}

7
src/WireMock.Net/Transformers/Handlebars/HandlebarsContextFactory.cs
View File

@@ -7,11 +7,6 @@ namespace WireMock.Transformers.Handlebars
{
internal class HandlebarsContextFactory : ITransformerContextFactory
{
private static readonly HandlebarsConfiguration HandlebarsConfiguration = new HandlebarsConfiguration
{
UnresolvedBindingFormatter = "{0}"
};
private readonly IFileSystemHandler _fileSystemHandler;
private readonly Action<IHandlebars, IFileSystemHandler> _action;
@@ -23,7 +18,7 @@ namespace WireMock.Transformers.Handlebars
public ITransformerContext Create()
{
var handlebars = HandlebarsDotNet.Handlebars.Create(HandlebarsConfiguration);
var handlebars = HandlebarsDotNet.Handlebars.Create();
WireMockHandlebarsHelpers.Register(handlebars, _fileSystemHandler);

41
src/WireMock.Net/Transformers/Handlebars/HandlebarsFile.cs
View File

@@ -1,41 +0,0 @@
using HandlebarsDotNet;
using System;
using WireMock.Handlers;
using WireMock.Validation;
namespace WireMock.Transformers.Handlebars
{
internal static class HandlebarsFile
{
public static void Register(IHandlebars handlebarsContext, IFileSystemHandler fileSystemHandler)
{
handlebarsContext.RegisterHelper("File", (writer, context, arguments) =>
{
string value = ParseArgumentAndReadFileFragment(handlebarsContext, context, fileSystemHandler, arguments);
writer.Write(value);
});
handlebarsContext.RegisterHelper("File", (writer, options, context, arguments) =>
{
string value = ParseArgumentAndReadFileFragment(handlebarsContext, context, fileSystemHandler, arguments);
options.Template(writer, value);
});
}
private static string ParseArgumentAndReadFileFragment(IHandlebars handlebarsContext, dynamic context, IFileSystemHandler fileSystemHandler, object[] arguments)
{
Check.Condition(arguments, args => args.Length == 1, nameof(arguments));
Check.NotNull(arguments[0], "arguments[0]");
switch (arguments[0])
{
case string path:
var templateFunc = handlebarsContext.Compile(path);
string transformed = templateFunc(context);
return fileSystemHandler.ReadResponseBodyAsString(transformed);
}
throw new NotSupportedException($"The value '{arguments[0]}' with type '{arguments[0]?.GetType()}' cannot be used in Handlebars File.");
}
}
}

79
src/WireMock.Net/Transformers/Handlebars/HandlebarsJsonPath.cs
View File

@@ -1,79 +0,0 @@
using HandlebarsDotNet;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using System;
using System.Collections;
using System.Linq;
using WireMock.Util;
using WireMock.Validation;
namespace WireMock.Transformers.Handlebars
{
internal static class HandlebarsJsonPath
{
public static void Register(IHandlebars handlebarsContext)
{
handlebarsContext.RegisterHelper("JsonPath.SelectToken", (writer, context, arguments) =>
{
(JToken valueToProcess, string jsonPath) = ParseArguments(arguments);
try
{
var result = valueToProcess.SelectToken(jsonPath);
writer.WriteSafeString(result);
}
catch (JsonException)
{
// Ignore JsonException
}
});
handlebarsContext.RegisterHelper("JsonPath.SelectTokens", (writer, options, context, arguments) =>
{
(JToken valueToProcess, string jsonPath) = ParseArguments(arguments);
try
{
var values = valueToProcess.SelectTokens(jsonPath);
if (values != null)
{
options.Template(writer, values.ToDictionary(value => value.Path, value => value));
}
}
catch (JsonException)
{
// Ignore JsonException
}
});
}
private static (JToken valueToProcess, string jsonpath) ParseArguments(object[] arguments)
{
Check.Condition(arguments, args => args.Length == 2, nameof(arguments));
Check.NotNull(arguments[0], "arguments[0]");
Check.NotNullOrEmpty(arguments[1] as string, "arguments[1]");
JToken valueToProcess;
switch (arguments[0])
{
case JToken tokenValue:
valueToProcess = tokenValue;
break;
case string stringValue:
valueToProcess = JsonUtils.Parse(stringValue);
break;
case IEnumerable enumerableValue:
valueToProcess = JArray.FromObject(enumerableValue);
break;
default:
throw new NotSupportedException($"The value '{arguments[0]}' with type '{arguments[0]?.GetType()}' cannot be used in Handlebars JsonPath.");
}
return (valueToProcess, (string)arguments[1]);
}
}
}

86
src/WireMock.Net/Transformers/Handlebars/HandlebarsLinq.cs
View File

@@ -1,86 +0,0 @@
using System;
using System.Linq;
using System.Linq.Dynamic.Core;
using System.Linq.Dynamic.Core.Exceptions;
using HandlebarsDotNet;
using Newtonsoft.Json.Linq;
using WireMock.Util;
using WireMock.Validation;
namespace WireMock.Transformers.Handlebars
{
internal static class HandlebarsLinq
{
public static void Register(IHandlebars handlebarsContext)
{
handlebarsContext.RegisterHelper("Linq", (writer, context, arguments) =>
{
(JToken valueToProcess, string linqStatement) = ParseArguments(arguments);
try
{
object result = ExecuteDynamicLinq(valueToProcess, linqStatement);
writer.WriteSafeString(result);
}
catch (ParseException)
{
// Ignore ParseException
}
});
handlebarsContext.RegisterHelper("Linq", (writer, options, context, arguments) =>
{
(JToken valueToProcess, string linqStatement) = ParseArguments(arguments);
try
{
var result = ExecuteDynamicLinq(valueToProcess, linqStatement);
options.Template(writer, result);
}
catch (ParseException)
{
// Ignore ParseException
}
});
}
private static dynamic ExecuteDynamicLinq(JToken value, string linqStatement)
{
// Convert a single object to a Queryable JObject-list with 1 entry.
var queryable1 = new[] { value }.AsQueryable();
// Generate the DynamicLinq select statement.
string dynamicSelect = JsonUtils.GenerateDynamicLinqStatement(value);
// Execute DynamicLinq Select statement.
var queryable2 = queryable1.Select(dynamicSelect);
// Execute the Select(...) method and get first result with FirstOrDefault().
return queryable2.Select(linqStatement).FirstOrDefault();
}
private static (JToken valueToProcess, string linqStatement) ParseArguments(object[] arguments)
{
Check.Condition(arguments, args => args.Length == 2, nameof(arguments));
Check.NotNull(arguments[0], "arguments[0]");
Check.NotNullOrEmpty(arguments[1] as string, "arguments[1]");
JToken valueToProcess;
switch (arguments[0])
{
case string jsonAsString:
valueToProcess = new JValue(jsonAsString);
break;
case JToken jsonAsJObject:
valueToProcess = jsonAsJObject;
break;
default:
throw new NotSupportedException($"The value '{arguments[0]}' with type '{arguments[0]?.GetType()}' cannot be used in Handlebars Linq.");
}
return (valueToProcess, (string) arguments[1]);
}
}
}

113
src/WireMock.Net/Transformers/Handlebars/HandlebarsRandom.cs
View File

@@ -1,113 +0,0 @@
using System;
using System.Collections.Generic;
using System.Globalization;
using System.Linq;
using HandlebarsDotNet;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using RandomDataGenerator.FieldOptions;
using RandomDataGenerator.Randomizers;
using WireMock.Validation;
namespace WireMock.Transformers.Handlebars
{
internal static class HandlebarsRandom
{
public static void Register(IHandlebars handlebarsContext)
{
handlebarsContext.RegisterHelper("Random", (writer, context, arguments) =>
{
object value = GetRandomValue(arguments);
writer.Write(value);
});
handlebarsContext.RegisterHelper("Random", (writer, options, context, arguments) =>
{
object value = GetRandomValue(arguments);
options.Template(writer, value);
});
}
private static object GetRandomValue(object[] arguments)
{
var fieldOptions = GetFieldOptionsFromArguments(arguments);
dynamic randomizer = RandomizerFactory.GetRandomizerAsDynamic(fieldOptions);
// Format DateTime as ISO 8601
if (fieldOptions is IFieldOptionsDateTime)
{
DateTime? date = randomizer.Generate();
return date?.ToString("s", CultureInfo.InvariantCulture);
}
// If the IFieldOptionsGuid defines Uppercase, use the 'GenerateAsString' method.
if (fieldOptions is IFieldOptionsGuid fieldOptionsGuid)
{
return fieldOptionsGuid.Uppercase ? randomizer.GenerateAsString() : randomizer.Generate();
}
return randomizer.Generate();
}
private static FieldOptionsAbstract GetFieldOptionsFromArguments(object[] arguments)
{
Check.Condition(arguments, args => args.Length > 0, nameof(arguments));
Check.NotNull(arguments[0], "arguments[0]");
var properties = (Dictionary<string, object>)arguments[0];
var newProperties = new Dictionary<string, object>();
foreach (KeyValuePair<string, object> property in properties.Where(p => p.Key != "Type"))
{
if (property.Value.GetType().Name == "UndefinedBindingResult")
{
if (TryParseSpecialValue(property.Value, out object parsedValue))
{
newProperties.Add(property.Key, parsedValue);
}
}
else
{
newProperties.Add(property.Key, property.Value);
}
}
return FieldOptionsFactory.GetFieldOptions((string)properties["Type"], newProperties);
}
/// <summary>
/// In case it's an UndefinedBindingResult, just try to convert the value using Json
/// This logic adds functionality like parsing an array
/// </summary>
/// <param name="value">The property value</param>
/// <param name="parsedValue">The parsed value</param>
/// <returns>true in case parsing is ok, else false</returns>
private static bool TryParseSpecialValue(object value, out object parsedValue)
{
parsedValue = null;
string propertyValueAsString = value.ToString();
try
{
JToken jToken = JToken.Parse(propertyValueAsString);
switch (jToken)
{
case JArray jTokenArray:
parsedValue = jTokenArray.ToObject<string[]>().ToList(); // Just convert to a String List to enable Random StringList
break;
default:
return jToken.ToObject<dynamic>();
}
return true;
}
catch (JsonException)
{
// Ignore and don't add this value
}
return false;
}
}
}

64
src/WireMock.Net/Transformers/Handlebars/HandlebarsRegex.cs
View File

@@ -1,64 +0,0 @@
using System;
using System.Linq;
using System.Text.RegularExpressions;
using HandlebarsDotNet;
using WireMock.Util;
using WireMock.Validation;
namespace WireMock.Transformers.Handlebars
{
internal static class HandlebarsRegex
{
public static void Register(IHandlebars handlebarsContext)
{
handlebarsContext.RegisterHelper("Regex.Match", (writer, context, arguments) =>
{
(string stringToProcess, string regexPattern, object defaultValue) = ParseArguments(arguments);
Match match = Regex.Match(stringToProcess, regexPattern);
if (match.Success)
{
writer.WriteSafeString(match.Value);
}
else if (defaultValue != null)
{
writer.WriteSafeString(defaultValue);
}
});
handlebarsContext.RegisterHelper("Regex.Match", (writer, options, context, arguments) =>
{
(string stringToProcess, string regexPattern, object defaultValue) = ParseArguments(arguments);
var regex = new Regex(regexPattern);
var namedGroups = RegexUtils.GetNamedGroups(regex, stringToProcess);
if (namedGroups.Any())
{
options.Template(writer, namedGroups);
}
else if (defaultValue != null)
{
options.Template(writer, defaultValue);
}
});
}
private static (string stringToProcess, string regexPattern, object defaultValue) ParseArguments(object[] arguments)
{
Check.Condition(arguments, args => args.Length == 2 || args.Length == 3, nameof(arguments));
string ParseAsString(object arg)
{
if (arg is string argAsString)
{
return argAsString;
}
throw new NotSupportedException($"The value '{arg}' with type '{arg?.GetType()}' cannot be used in Handlebars Regex.");
}
return (ParseAsString(arguments[0]), ParseAsString(arguments[1]), arguments.Length == 3 ? arguments[2] : null);
}
}
}

102
src/WireMock.Net/Transformers/Handlebars/HandlebarsXPath.cs
View File

@@ -1,102 +0,0 @@
using HandlebarsDotNet;
using System;
using System.Text;
using System.Xml;
using System.Xml.XPath;
using WireMock.Validation;
#if !NETSTANDARD1_3
using Wmhelp.XPath2;
#endif
namespace WireMock.Transformers.Handlebars
{
internal static class HandlebarsXPath
{
public static void Register(IHandlebars handlebarsContext)
{
handlebarsContext.RegisterHelper("XPath.SelectSingleNode", (writer, context, arguments) =>
{
(XPathNavigator nav, string xpath) = ParseArguments(arguments);
try
{
#if NETSTANDARD1_3
var result = nav.SelectSingleNode(xpath);
#else
var result = nav.XPath2SelectSingleNode(xpath);
#endif
writer.WriteSafeString(result.OuterXml);
}
catch (Exception)
{
// Ignore Exception
}
});
handlebarsContext.RegisterHelper("XPath.SelectNodes", (writer, context, arguments) =>
{
(XPathNavigator nav, string xpath) = ParseArguments(arguments);
try
{
#if NETSTANDARD1_3
var result = nav.Select(xpath);
#else
var result = nav.XPath2SelectNodes(xpath);
#endif
var resultXml = new StringBuilder();
foreach (XPathNavigator node in result)
{
resultXml.Append(node.OuterXml);
}
writer.WriteSafeString(resultXml);
}
catch (Exception)
{
// Ignore Exception
}
});
handlebarsContext.RegisterHelper("XPath.Evaluate", (writer, context, arguments) =>
{
(XPathNavigator nav, string xpath) = ParseArguments(arguments);
try
{
#if NETSTANDARD1_3
var result = nav.Evaluate(xpath);
#else
var result = nav.XPath2Evaluate(xpath);
#endif
writer.WriteSafeString(result);
}
catch (Exception)
{
// Ignore Exception
}
});
}
private static (XPathNavigator nav, string xpath) ParseArguments(object[] arguments)
{
Check.Condition(arguments, args => args.Length == 2, nameof(arguments));
Check.NotNull(arguments[0], "arguments[0]");
Check.NotNullOrEmpty(arguments[1] as string, "arguments[1]");
XPathNavigator nav;
switch (arguments[0])
{
case string stringValue:
nav = new XmlDocument { InnerXml = stringValue }.CreateNavigator();
break;
default:
throw new NotSupportedException($"The value '{arguments[0]}' with type '{arguments[0]?.GetType()}' cannot be used in Handlebars XPath.");
}
return (nav, (string)arguments[1]);
}
}
}

39
src/WireMock.Net/Transformers/Handlebars/HandlebarsXeger.cs
View File

@@ -1,39 +0,0 @@
using System;
using Fare;
using HandlebarsDotNet;
using WireMock.Validation;
namespace WireMock.Transformers.Handlebars
{
internal static class HandlebarsXeger
{
public static void Register(IHandlebars handlebarsContext)
{
handlebarsContext.RegisterHelper("Xeger", (writer, context, arguments) =>
{
string value = ParseArgumentAndGenerate(arguments);
writer.Write(value);
});
handlebarsContext.RegisterHelper("Xeger", (writer, options, context, arguments) =>
{
string value = ParseArgumentAndGenerate(arguments);
options.Template(writer, value);
});
}
private static string ParseArgumentAndGenerate(object[] arguments)
{
Check.Condition(arguments, args => args.Length == 1, nameof(arguments));
Check.NotNull(arguments[0], "arguments[0]");
switch (arguments[0])
{
case string pattern:
return new Xeger(pattern).Generate();
}
throw new NotSupportedException($"The value '{arguments[0]}' with type '{arguments[0]?.GetType()}' cannot be used in Handlebars Xeger.");
}
}
}

64
src/WireMock.Net/Transformers/Handlebars/WireMockHandlebarsHelpers.cs
View File

@@ -1,30 +1,36 @@
using HandlebarsDotNet;
using HandlebarsDotNet.Helpers;
using WireMock.Handlers;
namespace WireMock.Transformers.Handlebars
{
internal static class WireMockHandlebarsHelpers
{
public static void Register(IHandlebars handlebarsContext, IFileSystemHandler fileSystemHandler)
{
// Register https://github.com/StefH/Handlebars.Net.Helpers
HandlebarsHelpers.Register(handlebarsContext);
// Register WireMock.Net specific helpers
HandlebarsRegex.Register(handlebarsContext);
HandlebarsJsonPath.Register(handlebarsContext);
HandlebarsLinq.Register(handlebarsContext);
HandlebarsRandom.Register(handlebarsContext);
HandlebarsXeger.Register(handlebarsContext);
HandlebarsXPath.Register(handlebarsContext);
HandlebarsFile.Register(handlebarsContext, fileSystemHandler);
}
}
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Reflection;
using HandlebarsDotNet;
using HandlebarsDotNet.Helpers;
using HandlebarsDotNet.Helpers.Helpers;
using WireMock.Handlers;
namespace WireMock.Transformers.Handlebars
{
internal static class WireMockHandlebarsHelpers
{
public static void Register(IHandlebars handlebarsContext, IFileSystemHandler fileSystemHandler)
{
// Register https://github.com/StefH/Handlebars.Net.Helpers
HandlebarsHelpers.Register(handlebarsContext, o =>
{
o.CustomHelperPaths = new string[]
{
Directory.GetCurrentDirectory()
#if !NETSTANDARD1_3
, Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location)
#endif
}
.Distinct()
.ToList();
o.CustomHelpers = new Dictionary<string, IHelpers>
{
{ "File", new FileHelpers(handlebarsContext, fileSystemHandler) }
};
});
}
}
}