/// <summary>
/// Generate a single <see cref="OpenApiCallback"/> matching the given <see cref="WebHookTrigger"/>
/// </summary>
/// <param name="trigger"></param>
/// <param name="context"></param>
/// <returns></returns>
protected OpenApiCallback Generate(WebHookTrigger trigger, OperationFilterContext context)
{
var schema = context.SchemaGenerator.GenerateSchema(trigger.PayloadType, context.SchemaRepository);
var result = new OpenApiCallback();
result.AddPathItem(RuntimeExpression.Build($"{{$request.body#/{PseudoCamelCase(nameof(IWebHook.Callback))}}}"), new OpenApiPathItem
{
Operations = new Dictionary <OperationType, OpenApiOperation>
{
[OperationType.Post] = new OpenApiOperation
{
OperationId = trigger.Id,
Description = trigger.Description,
Responses = _responses,
Parameters = _parameters,
RequestBody = new OpenApiRequestBody
{
Required = true,
Content = new Dictionary <string, OpenApiMediaType>
{
["application/json"] = new OpenApiMediaType {
Schema = schema
}
}
},
}
}
});
return(result);
}
public override RuntimeValueNode Evaluate()
{
var symbolNode = Operator.Left.Root as SymbolNode;
Type symbol;
RuntimeScope assignmentScope = RuntimeScope;
if (symbolNode == null && Operator.Left.Root is OperatorAccess)
{
var opAccess = Operator.Left.Root as OperatorAccess;
symbol = opAccess.ReturnSymbol;
var symbolValue = new RuntimeOperatorAccess(
opAccess,
RuntimeScope
).Evaluate();
assignmentScope = symbolValue.RuntimeScope;
}
else
{
symbol = symbolNode.Symbol;
}
var r = new RuntimeExpression(
Operator.Right,
RuntimeScope
).Evaluate();
assignmentScope.SetValue(symbol.Name, r);
return(r);
}
public override RuntimeValueNode Evaluate()
{
var left = new RuntimeExpression(
Operator.Left,
RuntimeScope
).Evaluate();
var right = (Operator.Right.Root as SymbolNode).Symbol;
if (left.Type == right)
{
return(left);
}
var casterFunction = left.RuntimeScope.GetValue($"!as_{ right.Name }");
var args = left.Type is PrimitiveType ? new RuntimeValueNode[] { left } : new RuntimeValueNode[] {};
var runtimeCasterFunction = new RuntimeFunction(
casterFunction.Value as FunctionType,
casterFunction.RuntimeScope,
args
);
return(runtimeCasterFunction.Evaluate());
}
private void Compile()
{
if (DataContext == null)
{
throw ExceptionBuilder.PropertyNotInitialized("DataContext");
}
if (Text == null || Text.Length == 0)
{
throw ExceptionBuilder.PropertyNotInitialized("Text");
}
// Compile expression
ClearCompiledState();
Compiler compiler = new Compiler(_errorCollector);
ExpressionNode expressionNode = compiler.CompileExpression(Text, _targetType, Scope);
if (_errorCollector.ErrorsSeen)
{
IList <CompilationError> errors = _errorCollector.GetErrors();
OnCompilationFailed(new CompilationFailedEventArgs(errors));
throw ExceptionBuilder.ExpressionCompilationFailed(errors);
}
OnCompilationSucceeded(EventArgs.Empty);
_runtimeExpression = ExpressionCompiler.CreateCompiled(expressionNode);
ILEmitContext.CompleteILCompilation();
}
public void ParseAdvancedCallbackWithReferenceShouldSucceed()
{
using (var stream = File.OpenRead(Path.Combine(SampleFolderPath, "advancedCallbackWithReference.yaml")))
{
// Act
var openApiDoc = new OpenApiStreamReader().Read(stream, out var context);
// Assert
var path = openApiDoc.Paths.First().Value;
var subscribeOperation = path.Operations[OperationType.Post];
var callback = subscribeOperation.Callbacks["simpleHook"];
context.ShouldBeEquivalentTo(new OpenApiDiagnostic());
callback.ShouldBeEquivalentTo(
new OpenApiCallback
{
Reference = new OpenApiReference
{
Type = ReferenceType.Callback,
Id = "simpleHook",
},
PathItems =
{
[RuntimeExpression.Build("$request.body#/url")]
= new OpenApiPathItem
{
Operations =
{
[OperationType.Post] =
new OpenApiOperation
{
RequestBody = new OpenApiRequestBody
{
Content =
{
["application/json"] = new OpenApiMediaType
{
Schema = new OpenApiSchema
{
Type = "object"
}
}
}
},
Responses = new OpenApiResponses
{
["200"] = new OpenApiResponse
{
Description = "Success"
}
}
}
}
}
}
});
}
}
public override RuntimeValueNode Evaluate()
{
var l = new RuntimeExpression(
Operator.Left,
RuntimeScope
).Evaluate();
var r = new RuntimeExpression(
Operator.Right,
RuntimeScope
).Evaluate();
RuntimeValueNode res;
res = l.OpEqual(r);
if ((bool)res.Value)
{
return(res);
}
res = l.OpSmaller(r);
if ((bool)res.Value)
{
return(res);
}
return(res);
}
public override RuntimeValueNode Evaluate()
{
var l = new RuntimeExpression(
Operator.Left,
RuntimeScope
).Evaluate();
var res = l.OpEqual(WrapBool(true, l));
if ((bool)res.Value)
{
return(WrapBool(true, res));
}
var r = new RuntimeExpression(
Operator.Right,
RuntimeScope
).Evaluate();
res = r.OpEqual(WrapBool(true, r));
if ((bool)res.Value)
{
return(WrapBool(true, res));
}
return(WrapBool(false, r));
}
public void BuildRuntimeExpressionThrowsNullOrWhiteSpace(string expression)
{
// Arrange & Act
Action test = () => RuntimeExpression.Build(expression);
// Assert
Assert.Throws <ArgumentException>("expression", test);
}
public void CompositeRuntimeExpressionWithInvalidRuntimeExpressions(string expression, string invalidExpression)
{
// Arrange & Act
Action test = () => RuntimeExpression.Build(expression);
// Assert
test.ShouldThrow <OpenApiException>().WithMessage(String.Format(SRResource.RuntimeExpressionHasInvalidFormat, invalidExpression));
}
public void CompareStaticRuntimeExpressionWorks(string expression)
{
// Arrange & Act
var runtimeExpression1 = RuntimeExpression.Build(expression);
var runtimeExpression2 = RuntimeExpression.Build(expression);
// Assert
Assert.Same(runtimeExpression1, runtimeExpression2);
}
public void BuildRuntimeExpressionTwiceCreatesNewEquivalentInstances(string expression)
{
// Arrange & Act
var runtimeExpression1 = RuntimeExpression.Build(expression);
var runtimeExpression2 = RuntimeExpression.Build(expression);
// Assert
Assert.NotSame(runtimeExpression1, runtimeExpression2);
Assert.Equal(runtimeExpression1, runtimeExpression2);
}
public void BuildRuntimeExpressionThrowsInvalidFormat(string expression)
{
// Arrange & Act
Action test = () => RuntimeExpression.Build(expression);
// Assert
OpenApiException exception = Assert.Throws <OpenApiException>(test);
Assert.Equal(String.Format(SRResource.RuntimeExpressionHasInvalidFormat, expression), exception.Message);
}
public void CompositeRuntimeExpressionContainsInvalidExpressions(string expression)
{
// Arrange
// Act
Action test = () => RuntimeExpression.Build(expression);
// Assert
Assert.Throws <OpenApiException>(test);
}
public void BuildRuntimeExpressionThrowsWithDollarPrefix(string expression)
{
// Arrange & Act
Action test = () => RuntimeExpression.Build(expression);
// Assert
OpenApiException exception = Assert.Throws <OpenApiException>(test);
Assert.Equal(String.Format(SRResource.RuntimeExpressionMustBeginWithDollar, expression), exception.Message);
}
public void ParseBasicCallbackShouldSucceed()
{
using (var stream = Resources.GetStream(Path.Combine(SampleFolderPath, "basicCallback.yaml")))
{
// Arrange
var yamlStream = new YamlStream();
yamlStream.Load(new StreamReader(stream));
var yamlNode = yamlStream.Documents.First().RootNode;
var context = new ParsingContext();
var diagnostic = new OpenApiDiagnostic();
var node = new MapNode(context, diagnostic, (YamlMappingNode)yamlNode);
// Act
var callback = OpenApiV3Deserializer.LoadCallback(node);
// Assert
diagnostic.ShouldBeEquivalentTo(new OpenApiDiagnostic());
callback.ShouldBeEquivalentTo(
new OpenApiCallback
{
PathItems =
{
[RuntimeExpression.Build("$request.body#/url")]
= new OpenApiPathItem
{
Operations =
{
[OperationType.Post] =
new OpenApiOperation
{
RequestBody = new OpenApiRequestBody
{
Content =
{
["application/json"] = null
}
},
Responses = new OpenApiResponses
{
["200"] = new OpenApiResponse
{
Description = "Success"
}
}
}
}
}
}
});
}
}
public override RuntimeValueNode Evaluate()
{
var l = new RuntimeExpression(
Operator.Left,
RuntimeScope
).Evaluate();
var r = new RuntimeExpression(
Operator.Right,
RuntimeScope
).Evaluate();
return(l.OpDivide(r));
}
public void BuildUrlRuntimeExpressionReturnsUrlExpression()
{
// Arrange
string expression = "$url";
// Act
var runtimeExpression = RuntimeExpression.Build(expression);
// Assert
Assert.NotNull(runtimeExpression);
var url = Assert.IsType <UrlExpression>(runtimeExpression);
Assert.Equal(expression, url.Expression);
}
public void BuildStatusCodeRuntimeExpressionReturnsStatusCodeExpression()
{
// Arrange
string expression = "$statusCode";
// Act
var runtimeExpression = RuntimeExpression.Build(expression);
// Assert
Assert.NotNull(runtimeExpression);
var statusCode = Assert.IsType <StatusCodeExpression>(runtimeExpression);
Assert.Equal(expression, statusCode.Expression);
}
public void BuildMethodRuntimeExpressionReturnsMethodExpression()
{
// Arrange
string expression = "$method";
// Act
var runtimeExpression = RuntimeExpression.Build(expression);
// Assert
Assert.NotNull(runtimeExpression);
var method = Assert.IsType <MethodExpression>(runtimeExpression);
Assert.Equal(expression, method.Expression);
}
/// <summary>
/// Generate a single <see cref="OpenApiCallback"/> matching the given <see cref="WebHookTrigger"/>
/// </summary>
/// <param name="trigger"></param>
/// <returns></returns>
protected OpenApiCallback Generate(WebHookTrigger trigger)
{
var triggerProperties = new Dictionary <string, OpenApiSchema>(trigger.Template.Properties)
{
[PseudoCamelCase(DefaultWebHookSender.TimestampKey)] = new OpenApiSchema {
Type = "string", Format = "date-time"
},
[PseudoCamelCase(DefaultWebHookSender.TriggerKey)] = new OpenApiSchema {
Type = "string"
},
[PseudoCamelCase(DefaultWebHookSender.UniqueIdKey)] = new OpenApiSchema {
Type = "string", Format = "uuid"
}
};
var result = new OpenApiCallback();
result.AddPathItem(RuntimeExpression.Build($"{{$request.body#/{PseudoCamelCase(nameof(IWebHook.Callback))}}}"), new OpenApiPathItem
{
Operations = new Dictionary <OperationType, OpenApiOperation>
{
[OperationType.Post] = new OpenApiOperation
{
OperationId = trigger.Id,
Description = trigger.Description,
Responses = _responses,
Parameters = _parameters,
RequestBody = new OpenApiRequestBody
{
Required = true,
Content = new Dictionary <string, OpenApiMediaType>
{
["application/json"] = new OpenApiMediaType
{
Schema = new OpenApiSchema
{
Type = "object",
Properties = triggerProperties
}
}
}
},
}
}
});
return(result);
}
public override RuntimeValueNode Evaluate()
{
var ifNode = Node as IfConditionNode;
var condition_ = new RuntimeExpression(
ifNode.Expression,
RuntimeScope
).Evaluate();
var condition = condition_ as RuntimeBoolValueNode;
if ((bool)condition.Value)
{
return(Subscope.Evaluate());
}
return(null);
}
private static RuntimeExpressionAnyWrapper LoadRuntimeExpressionAnyWrapper(ParseNode node)
{
var value = node.GetScalarValue();
if (value != null && value.StartsWith("$"))
{
return(new RuntimeExpressionAnyWrapper
{
Expression = RuntimeExpression.Build(value)
});
}
return(new RuntimeExpressionAnyWrapper
{
Any = node.CreateAny()
});
}
public void CompositeRuntimeExpressionContainsExpression()
{
// Arrange
string expression = "This is a composite expression {$url} yay";
// Act
var runtimeExpression = RuntimeExpression.Build(expression);
// Assert
Assert.NotNull(runtimeExpression);
var response = Assert.IsType <CompositeExpression>(runtimeExpression);
Assert.Equal(expression, response.Expression);
var compositeExpression = runtimeExpression as CompositeExpression;
Assert.Single(compositeExpression.ContainedExpressions);
}
public void CompositeRuntimeExpressionWithoutRecognizedRuntimeExpressions(string expression)
{
// Arrange
// Act
var runtimeExpression = RuntimeExpression.Build(expression);
// Assert
runtimeExpression.Should().NotBeNull();
runtimeExpression.Should().BeOfType(typeof(CompositeExpression));
var response = (CompositeExpression)runtimeExpression;
response.Expression.Should().Be(expression);
var compositeExpression = runtimeExpression as CompositeExpression;
// The whole string is treated as the template without any contained expressions.
compositeExpression.ContainedExpressions.Should().BeEmpty();
}
public override RuntimeValueNode Evaluate()
{
var left = new RuntimeExpression(Operator.Left, RuntimeScope).Evaluate();
if (left == null)
{
throw new Exceptions.NullReferenceException((Operator.Left.Root as SymbolNode)?.Symbol, DefiningToken);
}
if (!(left is IAccessible))
{
throw new Exceptions.RuntimeException($"Symbol is not accessible", left.DefiningToken);
}
var leftAccessible = left as IAccessible;
return(leftAccessible.AccessMember(
(Operator as OperatorAccess).MemberToAccess.Name
));
}
/// <summary>
/// Add a <see cref="OpenApiPathItem"/> into the <see cref="PathItems"/>.
/// </summary>
/// <param name="expression">The runtime expression.</param>
/// <param name="pathItem">The path item.</param>
public void AddPathItem(RuntimeExpression expression, OpenApiPathItem pathItem)
{
if (expression == null)
{
throw Error.ArgumentNull(nameof(expression));
}
if (pathItem == null)
{
throw Error.ArgumentNull(nameof(pathItem));
}
if (PathItems == null)
{
PathItems = new Dictionary <RuntimeExpression, OpenApiPathItem>();
}
PathItems.Add(expression, pathItem);
}
public override RuntimeValueNode Evaluate()
{
var l = new RuntimeExpression(
Operator.Left,
RuntimeScope
).Evaluate();
var r = new RuntimeExpression(
Operator.Right,
RuntimeScope
).Evaluate();
var res = l.OpEqual(r);
return(new RuntimeBoolValueNode(
new Parser.Syntax.Expressions.Nodes.Value.BoolValueNode(
res.DefiningToken,
!(bool)res.Value
),
res.RuntimeScope
));
}
public void CompositeRuntimeExpressionContainsMultipleExpressions()
{
// Arrange
string expression = "This is a composite expression {$url} yay and {$request.header.foo}";
// Act
var runtimeExpression = RuntimeExpression.Build(expression);
// Assert
Assert.NotNull(runtimeExpression);
var response = Assert.IsType <CompositeExpression>(runtimeExpression);
Assert.Equal(expression, response.Expression);
var compositeExpression = runtimeExpression as CompositeExpression;
Assert.Equal(2, compositeExpression.ContainedExpressions.Count);
Assert.IsType <UrlExpression>(compositeExpression.ContainedExpressions.First());
Assert.IsType <RequestExpression>(compositeExpression.ContainedExpressions.Last());
}
public void CompositeRuntimeExpressionForWebHook()
{
// Arrange
string expression = "http://notificationServer.com?transactionId={$request.body#/id}&email={$request.body#/email}";
// Act
var runtimeExpression = RuntimeExpression.Build(expression);
// Assert
Assert.NotNull(runtimeExpression);
var response = Assert.IsType <CompositeExpression>(runtimeExpression);
Assert.Equal(expression, response.Expression);
var compositeExpression = runtimeExpression as CompositeExpression;
Assert.Equal(2, compositeExpression.ContainedExpressions.Count);
Assert.IsType <RequestExpression>(compositeExpression.ContainedExpressions.First());
Assert.IsType <RequestExpression>(compositeExpression.ContainedExpressions.Last());
}
public void BuildResponseRuntimeExpressionReturnsResponseExpression()
{
// Arrange
string expression = "$response.body#/status";
// Act
var runtimeExpression = RuntimeExpression.Build(expression);
// Assert
Assert.NotNull(runtimeExpression);
var response = Assert.IsType <ResponseExpression>(runtimeExpression);
Assert.Equal(expression, response.Expression);
Assert.Equal("body#/status", response.Source.Expression);
Assert.NotNull(response.Source);
var body = Assert.IsType <BodyExpression>(response.Source);
Assert.Equal("/status", body.Fragment);
Assert.Equal("body#/status", body.Expression);
}