protected FileProcessorRuleEngine()
{
Rules = new List<FileProcessorRule>();
ParameterResolver = new ParameterResolver();
Errors = new List<string>();
}
public double Calculate(ParameterResolver parameters)
{
// RPN記法で取得
string parsedExpression = Root.TraversePostorder();
Stack<double> calcStack = new Stack<double>();
foreach (char c in parsedExpression)
{
}
return 0.0;
}
public void UnsortedPathParametersThrowsException()
{
Assert.Throws <ArgumentException>(() =>
{
return(new RequestHandlerFake(
Method.Get,
"/user/{userId}",
new List <IParameterResolver>
{
ParameterResolver.Body <NameData>(), ParameterResolver.Path <string>(0)
}));
});
}
public void InvokeFactoryTest()
{
var fact = new Mock <IFactory>();
var inputParams = new object[] { new EventArgs() };
var par = new FrameworkElement();
par.DataContext = fact.Object;
fact.SetupGet(i => i.TargetType).Returns(typeof(string));
fact.Setup(i => i.Create(It.IsAny <IDIIntegration>(), par, inputParams)).Returns("FooBar");
Assert.True(ParameterResolver.ResolveParameter(typeof(string), par, inputParams, out var result));
Assert.Equal("FooBar", result.Create(null, par, inputParams).ToString());
}
public RequestHandler4 <T, TR, TU, TI> Body <TI>(MediaTypeMapper mediaTypeMapper)
{
MediaTypeMapper = mediaTypeMapper;
return(new RequestHandler4 <T, TR, TU, TI>(
Method,
Path,
ResolverParam1,
ResolverParam2,
ResolverParam3,
ParameterResolver.Body <TI>(mediaTypeMapper),
ErrorHandler,
mediaTypeMapper));
}
public NewSlnCommandStrategy(IFileSystem fileSystem)
{
_fileSystem = fileSystem;
_resolver = new ParameterResolver <ParamId>(Constants.CommandName.New + " " + Name, new []
{
new StringParameterSpecification <ParamId>
{
Identifier = ParamId.SolutionName,
Short = Constants.NewCommandOptions.Name,
Verbose = Constants.NewCommandOptions.VerboseName
}
});
}
public void AddingHandlerQuery()
{
var request = Request.Has(Method.Get)
.And("/user?filter=abc".ToMatchableUri())
.And(Version.Http1_1);
var mappedParameters =
new Action.MappedParameters(1, Method.Get, "ignored", new List <Action.MappedParameter>());
var handler = new RequestHandler0(Method.Get, "/user").Query("filter");
AssertResolvesAreEquals(ParameterResolver.Query <string>("filter"), handler.Resolver);
Assert.Equal("abc", handler.Resolver.Apply(request, mappedParameters));
}
public void ActionSignature()
{
var handler = CreateRequestHandler(
Method.Get,
"/posts/{postId}/comment/{commentId}/user/{userId}",
ParameterResolver.Path <string>(0),
ParameterResolver.Path <string>(1),
ParameterResolver.Path <string>(2),
ParameterResolver.Query("page", 10),
ParameterResolver.Query("pageSize", 10));
Assert.Equal("String postId, String commentId, String userId", handler.ActionSignature);
}
private RequestHandler2 <T, R> CreateRequestHandler <T, R>(Method method,
string path,
ParameterResolver <T> parameterResolver1,
ParameterResolver <R> parameterResolver2)
{
return(new RequestHandler2 <T, R>(
method,
path,
parameterResolver1,
parameterResolver2,
ErrorHandler.HandleAllWith(Response.ResponseStatus.InternalServerError),
DefaultMediaTypeMapper.Instance));
}
public string ToMethodCall(string objectName, string statement)
{
if (string.IsNullOrWhiteSpace(statement)) { return string.Empty; }
var signatureParams = new ParameterResolver(statement).Parameters;
return string.Concat(
objectName.TrimEnd(new[] { '.' }),
".",
statement.ToMethodName(),
"(",
string.Join(", ", signatureParams.Select(d => d.Name)),
")");
}
public void BodyWithContentTypeMapper()
{
var mediaTypeMapper = new MediaTypeMapper.Builder()
.AddMapperFor(ContentMediaType.Json, DefaultJsonMapper.Instance)
.Build();
var resolver = ParameterResolver.Body <NameData>(mediaTypeMapper);
var result = resolver.Apply(_request, _mappedParameters);
var expected = new NameData("John", "Doe");
Assert.Equal(expected.ToString(), result.ToString());
Assert.Equal(ParameterResolver.Type.Body, resolver.Type);
}
internal RequestHandler2(
Method method,
string path,
ParameterResolver <T> resolverParam1,
ParameterResolver <TR> resolverParam2,
IErrorHandler errorHandler,
MediaTypeMapper mediaTypeMapper)
: base(method, path, new List <IParameterResolver> {
resolverParam1, resolverParam2
}, errorHandler, mediaTypeMapper)
{
ResolverParam1 = resolverParam1;
ResolverParam2 = resolverParam2;
}
public static ParameterResolver <T> Path <T>(int position)
=> ParameterResolver <T> .Create(
Type.Path,
(request, mappedParameters) =>
{
var value = mappedParameters.Mapped[position].Value;
if (value is T)
{
return((T)value !);
}
throw new ArgumentException(
$"Value {value} is of mimeType {mappedParameters.Mapped[position].Type} instead of {typeof(T).Name}");
});
public void ThrowExceptionWhenNoHandlerIsDefined()
{
var handler = CreateRequestHandler(
Method.Get,
"/posts/{postId}/comment/{commentId}",
ParameterResolver.Path <string>(0),
ParameterResolver.Path <string>(1));
var exception = Assert.Throws <HandlerMissingException>(() => handler.Execute(Request.WithMethod(Method.Get),
"my-post",
"my-comment", Logger));
Assert.Equal("No handler defined for GET /posts/{postId}/comment/{commentId}",
exception.Message);
}
public void AddingHandlerHeader()
{
var hostHeader = RequestHeader.Of("Host", "www.vlingo.io");
var request = Request.Has(Method.Get)
.And("/user?filter=abc".ToMatchableUri())
.And(Headers.Of(hostHeader))
.And(Version.Http1_1);
var mappedParameters =
new Action.MappedParameters(1, Method.Get, "ignored", new List <Action.MappedParameter>());
var handler = new RequestHandler0(Method.Get, "/user").Header("Host");
AssertResolvesAreEquals(ParameterResolver.Header("Host"), handler.Resolver);
Assert.Equal(hostHeader, handler.Resolver.Apply(request, mappedParameters));
}
/// <summary>
/// Builds the descriptor for given type.
/// </summary>
/// <param name="type">The type.</param>
/// <param name="resolver">The generic parameter resolver.</param>
/// <param name="builder">The <see cref="TypeDescriptor"/> builder.</param>
/// <returns>Built descriptor.</returns>
public static TypeDescriptor BuildDescriptor(TypeAdapterBase type, ParameterResolver resolver, TypeDescriptorBuilder builder = null)
{
if (builder == null)
{
builder = new TypeDescriptorBuilder();
}
var director = new TypeHierarchyDirector(builder, resolver);
director.buildType(type);
var result = builder.BuildDescriptor();
return(result);
}
/// <summary>
/// Sets the value of all properties on this <see cref="Response{TModel}"/> that have the <see cref="ResponseValueAttribute"/> with the given name applied to them. If no such properties exist, no action will occur.
/// </summary>
/// <param name="name">The name given to the <see cref="ResponseValueAttribute"/> on the properties to set</param>
/// <param name="value">The string value to assign to that property</param>
/// <remarks>
/// This method will attempt to convert the string value to a supported type if the type of the matching property is not string.
/// </remarks>
public void SetString(string name, string value)
{
if (name == null)
{
throw new ArgumentNullException(nameof(name));
}
PropertyInfo[] Matching = this.Properties.Where(p => p.GetCustomAttribute <ResponseValueAttribute>()?.Name == name).ToArray();
foreach (PropertyInfo ToSet in Matching)
{
ToSet.GetSetMethod()?.Invoke(
this,
new[] { ParameterResolver.ParseParameter(value, ToSet.PropertyType) });
this.SetProperties.Add(ToSet);
}
}
public void Setup()
{
_resolver = new ParameterResolver <Identifiers>(string.Empty, new[]
{
new StringParameterSpecification <Identifiers> {
Identifier = Identifiers.Server, Short = "-S", Verbose = "--server"
},
new StringParameterSpecification <Identifiers> {
Identifier = Identifiers.Client, Short = "-C", Verbose = "--client"
},
new StringParameterSpecification <Identifiers> {
Identifier = Identifiers.Type, Short = "-t", Verbose = "--type", Default = "ClientServer"
}
});
}
public void AddingHandlerParam()
{
var request = Request.Has(Method.Get)
.And("/user/admin".ToMatchableUri())
.And(Version.Http1_1);
var mappedParameters =
new Action.MappedParameters(1, Method.Get, "ignored", new List <Action.MappedParameter>
{
new Action.MappedParameter("String", "admin")
});
var handler = new RequestHandler0(Method.Get, "/user/{userId}").Param <string>();
AssertResolvesAreEquals(ParameterResolver.Path <string>(0), handler.Resolver);
Assert.Equal("admin", handler.Resolver.Apply(request, mappedParameters));
}
public GenerateInformationModelStrategy(string commandName, IFileSystem fileSystem, IModelValidator modelValidator, INodesetGenerator nodesetGenerator)
{
Name = commandName;
_fileSystem = fileSystem;
_nodesetGenerator = nodesetGenerator;
_resolver = new ParameterResolver <ParamId>(Constants.CommandName.Generate + " " + Name, new []
{
new StringParameterSpecification <ParamId>
{
Identifier = ParamId.AppName,
Short = Constants.GenerateCommandOptions.Name,
Verbose = Constants.GenerateCommandOptions.VerboseName
}
});
}
public void ExecuteWithRequestAndMappedParametersWithWrongSignatureType()
{
var request = Request.Has(Method.Get)
.And("/posts/my-post".ToMatchableUri())
.And(Version.Http1_1);
var mappedParameters =
new Action.MappedParameters(1, Method.Get, "ignored", new List <Action.MappedParameter>
{
new Action.MappedParameter("String", "my-post")
});
var handler = CreateRequestHandler(Method.Get, "/posts/{postId}", ParameterResolver.Path <int>(0))
.Handle(postId => Completes.WithSuccess(Response.Of(Response.ResponseStatus.Ok, JsonSerialization.Serialized("it is my-post"))));
var exception = Assert.Throws <ArgumentException>(() => handler.Execute(request, mappedParameters, Logger));
Assert.Equal("Value my-post is of mimeType String instead of Int32", exception.Message);
}
public void AddingHandlerBody()
{
var request = Request.Has(Method.Post)
.And("/user/admin/name".ToMatchableUri())
.And(Body.From("{\"given\":\"John\",\"family\":\"Doe\"}"))
.And(Version.Http1_1);
var mappedParameters =
new Action.MappedParameters(1, Method.Post, "ignored", new List <Action.MappedParameter>
{
new Action.MappedParameter("String", "admin")
});
var handler = new RequestHandler0(Method.Get, "/user/admin/name").Body <NameData>();
AssertResolvesAreEquals(ParameterResolver.Body <NameData>(), handler.Resolver);
Assert.Equal(new NameData("John", "Doe"), handler.Resolver.Apply(request, mappedParameters));
}
public void Setup()
{
_resolver = new ParameterResolver <Identifiers>(string.Empty, new[]
{
new StringParameterSpecification <Identifiers> {
Identifier = Identifiers.Server, Short = "-S", Verbose = "--server", Default = "NoServer"
},
new StringParameterSpecification <Identifiers> {
Identifier = Identifiers.Client, Short = "-C", Verbose = "--client", Default = "NoClient"
}
}, new[]
{
new BoolParameterSpecification <Identifiers> {
Identifier = Identifiers.Help, Short = "-h", Verbose = "--help"
}
});
}
protected bool ExecuteCommon(IEnumerable <string> inputParams)
{
var resolver = new ParameterResolver <ParamId>(Constants.CommandName.Reference + " " + Name, new []
{
new StringParameterSpecification <ParamId>
{
Identifier = ParamId.ClientName,
Short = Constants.ReferenceCommandOptions.Client,
Verbose = Constants.ReferenceCommandOptions.VerboseClient
},
new StringParameterSpecification <ParamId>
{
Identifier = ParamId.ServerName,
Short = Constants.ReferenceCommandOptions.Server,
Verbose = Constants.ReferenceCommandOptions.VerboseServer
}
});
var(error, stringParams, _) = resolver.ResolveParams(inputParams);
if (error != null)
{
_outputMessages = new MessageLines {
{ error, string.Empty }
};
return(false);
}
_serverName = stringParams[ParamId.ServerName];
_clientName = stringParams[ParamId.ClientName];
_outputMessages = new MessageLines();
// check if client appioproj file exists
_clientFullName = _fileSystem.CombinePaths(_clientName, _clientName + Constants.FileExtension.Appioproject);
if (!_fileSystem.FileExists(_clientFullName))
{
AppioLogger.Warn(LoggingText.ReferenceClientAppioprojFileNotFound);
_outputMessages.Add(string.Format(OutputText.ReferenceClientAppioprojFileNotFound, _clientFullName), string.Empty);
return(false);
}
// exit with success
return(true);
}
public void AddingHandlerQuery()
{
var request = Request.Has(Method.Post)
.And("/user/admin?filter=abc".ToMatchableUri())
.And(Version.Http1_1);
var mappedParameters =
new Action.MappedParameters(1, Method.Get, "ignored",
Enumerable.Empty <Action.MappedParameter>().ToList());
var handler = CreateRequestHandler(
Method.Get,
"/user/{userId}",
ParameterResolver.Path <string>(0))
.Query("filter");
AssertResolvesAreEquals(ParameterResolver.Query <string>("filter"), handler.ResolverParam2);
Assert.Equal("abc", handler.ResolverParam2.Apply(request, mappedParameters));
}
public void Setup()
{
_resolver = new ParameterResolver <Identifiers>(string.Empty, new[]
{
new StringParameterSpecification <Identifiers> {
Identifier = Identifiers.Server, Short = "-S", Verbose = "--server"
},
new StringParameterSpecification <Identifiers> {
Identifier = Identifiers.Client, Short = "-C", Verbose = "--client"
},
new StringParameterSpecification <Identifiers> {
Identifier = Identifiers.Url, Verbose = "--url"
},
new StringParameterSpecification <Identifiers> {
Identifier = Identifiers.Quiet, Short = "-q"
}
});
}
public SlnOperationCommandStrategy(SlnOperationData operationData)
{
Name = operationData.CommandName;
_fileSystem = operationData.FileSystem;
_subcommand = operationData.Subcommand;
SuccessLoggerMessage = operationData.SuccessLoggerMessage;
SuccessOutputMessage = operationData.SuccessOutputMessage;
HelpText = operationData.HelpText;
_resolver = new ParameterResolver <ParamId>(Constants.CommandName.Sln + " " + Name, new []
{
new StringParameterSpecification <ParamId>
{
Identifier = ParamId.SolutionName,
Short = Constants.SlnCommandOptions.Solution,
Verbose = Constants.SlnCommandOptions.VerboseSolution
}
});
}
public SlnRemoveCommandStrategy(IFileSystem fileSystem)
{
_fileSystem = fileSystem;
_resolver = new ParameterResolver <ParamId>(Constants.CommandName.Sln + " " + Name, new []
{
new StringParameterSpecification <ParamId>
{
Identifier = ParamId.SolutionName,
Short = Constants.SlnCommandOptions.Solution,
Verbose = Constants.SlnCommandOptions.VerboseSolution
},
new StringParameterSpecification <ParamId>
{
Identifier = ParamId.ProjectName,
Short = Constants.SlnCommandOptions.Project,
Verbose = Constants.SlnCommandOptions.VerboseProject
}
});
}
private RequestHandler5 <T, R, U, I, J> CreateRequestHandler <T, R, U, I, J>(Method method,
string path,
ParameterResolver <T> parameterResolver1,
ParameterResolver <R> parameterResolver2,
ParameterResolver <U> parameterResolver3,
ParameterResolver <I> parameterResolver4,
ParameterResolver <J> parameterResolver5)
{
return(new RequestHandler5 <T, R, U, I, J>(
method,
path,
parameterResolver1,
parameterResolver2,
parameterResolver3,
parameterResolver4,
parameterResolver5,
ErrorHandler.HandleAllWith(ResponseStatus.InternalServerError),
DefaultMediaTypeMapper.Instance));
}
public NewOpcuaAppCommandStrategy(IFileSystem fileSystem, AbstractCertificateGenerator certificateGenerator)
{
_fileSystem = fileSystem;
_certificateGenerator = certificateGenerator;
_resolver = new ParameterResolver <ParamId>(Constants.CommandName.New + " " + Name, new []
{
new StringParameterSpecification <ParamId>
{
Identifier = ParamId.OpcuaAppName,
Short = Constants.NewCommandOptions.Name,
Verbose = Constants.NewCommandOptions.VerboseName
},
new StringParameterSpecification <ParamId>
{
Identifier = ParamId.ApplicationType,
Short = Constants.NewCommandOptions.Type,
Verbose = Constants.NewCommandOptions.VerboseType,
Default = Constants.ApplicationType.ClientServer
},
new StringParameterSpecification <ParamId>
{
Identifier = ParamId.Url,
Short = Constants.NewCommandOptions.Url,
Verbose = Constants.NewCommandOptions.VerboseUrl,
Default = string.Empty
},
new StringParameterSpecification <ParamId>
{
Identifier = ParamId.Port,
Short = Constants.NewCommandOptions.Port,
Verbose = Constants.NewCommandOptions.VerbosePort,
Default = string.Empty
}
}, new []
{
new BoolParameterSpecification <ParamId>
{
Identifier = ParamId.NoCert,
Verbose = Constants.NewCommandOptions.VerboseNoCert
}
});
}
public void AddingHandlerHeader()
{
var hostHeader = RequestHeader.Of("Host", "www.vlingo.io");
var request = Request.Has(Method.Get)
.And("/user/admin".ToMatchableUri())
.And(Headers.Of(hostHeader))
.And(Version.Http1_1);
var mappedParameters =
new Action.MappedParameters(1, Method.Get, "ignored",
Enumerable.Empty <Action.MappedParameter>().ToList());
var handler = CreateRequestHandler(
Method.Get,
"/user/{userId}",
ParameterResolver.Path <string>(0))
.Header("Host");
AssertResolvesAreEquals(ParameterResolver.Header("Host"), handler.ResolverParam2);
Assert.Equal(hostHeader, handler.ResolverParam2.Apply(request, mappedParameters));
}
public void HandlerWithOneParam()
{
var handler = CreateRequestHandler(
Method.Get,
"/posts/{postId}",
ParameterResolver.Path <string>(0))
.Handle(postId =>
Completes.WithSuccess(Response.Of(Response.ResponseStatus.Ok, JsonSerialization.Serialized(
$"{postId}"))));
var response = handler
.Execute(Request.WithMethod(Method.Get), "my-post", Logger).Outcome;
Assert.NotNull(handler);
Assert.Equal(Method.Get, handler.Method);
Assert.Equal("/posts/{postId}", handler.Path);
Assert.Equal(typeof(string), handler.Resolver.ParamClass);
AssertResponsesAreEquals(
Response.Of(Response.ResponseStatus.Ok, JsonSerialization.Serialized("my-post")), response);
}
public void AddingHandlerBodyWithMediaTypeMapper()
{
var request = Request.Has(Method.Post)
.And("/user/admin/name".ToMatchableUri())
.And(Body.From("{\"given\":\"John\",\"family\":\"Doe\"}"))
.And(RequestHeader.Of(RequestHeader.ContentType, "application/json"))
.And(Version.Http1_1);
var mappedParameters =
new Action.MappedParameters(1, Method.Post, "ignored", new List <Action.MappedParameter>
{
new Action.MappedParameter("String", "admin")
});
#pragma warning disable 618
var handler = new RequestHandler0(Method.Get, "/user/admin/name").Body <NameData>(typeof(TestMapper));
#pragma warning restore 618
AssertResolvesAreEquals(ParameterResolver.Body <NameData>(new TestMapper()), handler.Resolver);
Assert.Equal(new NameData("John", "Doe"), handler.Resolver.Apply(request, mappedParameters));
}
private static string GenerateDeclarationForStatement(
int extraTabs,
string statement)
{
if (string.IsNullOrWhiteSpace(statement)) { return string.Empty; }
var signatureParams = new ParameterResolver(statement).Parameters;
var totalTabs = 3 + extraTabs;
var tabs = new string('\t', totalTabs);
var code = new StringBuilder();
foreach (var p in signatureParams)
{
code.Append(tabs);
code.Append("var ");
code.Append(p.Name);
code.Append(" = ");
var holderValue = p.Holder.Trim(TrimmedHOlderEdges);
if (p.Type == ParameterType.Regex)
{
code.Append("@\"");
code.Append(holderValue);
code.Append("\"");
}
else if (p.Type == ParameterType.String)
{
code.Append("\"");
code.Append(holderValue);
code.Append("\"");
}
else if (p.Type == ParameterType.Int)
{
var parsedDefault = string.Format("default({0})", p.Type.ToString().ToLowerInvariant());
var auxValue = default(int);
if (int.TryParse(holderValue, out auxValue))
{
code.Append(auxValue);
}
else
{
code.Append(holderValue);
}
}
code.Append(string.Concat(";", Environment.NewLine));
}
return code.ToString();
}
protected FileProcessorRule()
{
ParameterResolver = new ParameterResolver();
Errors = new List<string>();
}
private static string GenerateStatementMethodSignature(
string statement)
{
var builder = new StringBuilder();
builder.Append("\t\t");
builder.Append("public void ");
builder.Append(statement.ToMethodName());
builder.Append("(");
var signatureParams = new ParameterResolver(statement).Parameters;
var first = true;
foreach (var p in signatureParams)
{
if (!first) { builder.Append(", "); }
else { first = false; }
builder.Append(p);
}
builder.Append(")");
builder.Append(Environment.NewLine);
return builder.ToString();
}
