public void Should_compute_md5_hash()
{
const string script = @"
return md5(value);
";
var vars = new ScriptVars
{
["value"] = "HelloWorld"
};
var result = sut.Execute(vars, script).ToString();
Assert.Equal("HelloWorld".ToMD5(), result);
}
public void Evaluate_should_return_true_when_expression_match()
{
const string script = @"
value.i == 2
";
var context = new ScriptVars
{
["value"] = new { i = 2 }
};
var result = sut.Evaluate(context, script);
Assert.True(result);
}
public void Should_count_characters()
{
const string script = @"
return characterCount(value);
";
var vars = new ScriptVars
{
["value"] = "Hello, World"
};
var result = ((JsonNumber)sut.Execute(vars, script)).Value;
Assert.Equal(10, result);
}
public void Should_slugify_value_with_single_char()
{
const string script = @"
return slugify(value, true);
";
var vars = new ScriptVars
{
["value"] = "4 Häuser"
};
var result = sut.Interpolate(vars, script);
Assert.Equal("4-hauser", result);
}
public void Should_convert_html_to_text()
{
const string script = @"
return html2Text(value);
";
var vars = new ScriptVars
{
["value"] = "<script>Invalid</script><STYLE>Invalid</STYLE><p>Hello World</p>"
};
var result = sut.Execute(vars, script).ToString();
Assert.Equal("Hello World", result);
}
public void Evaluate_should_return_true_when_status_match()
{
const string script = @"
value.status == 'Published'
";
var context = new ScriptVars
{
["value"] = new { status = Status.Published }
};
var result = ((IScriptEngine)sut).Evaluate(context, script);
Assert.True(result);
}
public void Evaluate_should_return_false_when_script_is_invalid()
{
const string script = @"
function();
";
var context = new ScriptVars
{
["value"] = new { i = 2 }
};
var result = ((IScriptEngine)sut).Evaluate(context, script);
Assert.False(result);
}
public void Evaluate_should_return_true_if_expression_match()
{
var vars = new ScriptVars
{
["value"] = new { i = 2 }
};
const string script = @"
value.i == 2
";
var result = ((IScriptEngine)sut).Evaluate(vars, script);
Assert.True(result);
}
public async Task ExecuteAndTransformAsync_should_return_original_content_when_not_replaced()
{
var content = new NamedContentData();
var context = new ScriptVars {
Data = content
};
const string script = @"
var x = 0;
";
var result = await sut.ExecuteAndTransformAsync(context, script);
Assert.Empty(result);
}
public async Task TransformAsync_should_return_original_content_if_not_replaced()
{
var vars = new ScriptVars
{
["data"] = new ContentData()
};
const string script = @"
var x = 0;
";
var result = await sut.TransformAsync(vars, script, contentOptions);
Assert.Empty(result);
}
public async Task TransformAsync_should_return_original_content_when_script_failed()
{
var content = new ContentData();
var context = new ScriptVars {
Data = content
};
const string script = @"
x => x
";
var result = await sut.TransformAsync(context, script, contentOptions);
Assert.Empty(result);
}
public void Evaluate_should_return_false_when_expression_match()
{
const string script = @"
value.i == 3
";
var context = new ScriptVars
{
["value"] = new { i = 2 }
};
var result = ((IScriptEngine)sut).Evaluate(context, script);
Assert.False(result);
}
public void Should_camel_case_value()
{
const string script = @"
return toCamelCase(value);
";
var vars = new ScriptVars
{
["value"] = "Hello World"
};
var result = sut.Execute(vars, script).ToString();
Assert.Equal("helloWorld", result);
}
public void Should_slugify_value()
{
const string script = @"
return slugify(value);
";
var vars = new ScriptVars
{
["value"] = "4 Häuser"
};
var result = sut.Execute(vars, script).ToString();
Assert.Equal("4-haeuser", result);
}
public void Should_pascal_case_value()
{
const string script = @"
return toPascalCase(value);
";
var vars = new ScriptVars
{
["value"] = "Hello World"
};
var result = sut.Interpolate(vars, script);
Assert.Equal("HelloWorld", result);
}
public void Should_convert_markdown_to_text()
{
const string script = @"
return markdown2Text(value);
";
var vars = new ScriptVars
{
["value"] = "## Hello World"
};
var result = sut.Execute(vars, script).ToString();
Assert.Equal("Hello World", result);
}
private async Task TransformAsync(ScriptVars rootVars, string script, ContentEntity content,
CancellationToken ct)
{
var vars = new ScriptVars(rootVars)
{
[ScriptKeys.ContentId] = content.Id,
[ScriptKeys.Data] = content.Data,
};
var options = new ScriptOptions
{
AsContext = true
};
content.Data = await scriptEngine.TransformAsync(vars, script, options, ct);
}
public bool Trigger(EnrichedEvent @event, RuleContext context)
{
var trigger = (SchemaChangedTrigger)context.Rule.Trigger;
if (string.IsNullOrWhiteSpace(trigger.Condition))
{
return(true);
}
var vars = new ScriptVars
{
["event"] = @event
};
return(scriptEngine.Evaluate(vars, trigger.Condition));
}
public async Task Should_throw_validation_exception_when_calling_reject()
{
const string script = @"
reject()
";
var options = new ScriptOptions
{
CanReject = true
};
var vars = new ScriptVars();
var ex = await Assert.ThrowsAsync <ValidationException>(() => sut.ExecuteAsync(vars, script, options));
Assert.NotEmpty(ex.Errors);
}
public async Task Should_throw_security_exception_when_calling_reject_with_message()
{
const string script = @"
disallow('Operation not allowed')
";
var options = new ScriptOptions
{
CanDisallow = true
};
var vars = new ScriptVars();
var ex = await Assert.ThrowsAsync <DomainForbiddenException>(() => sut.ExecuteAsync(vars, script, options));
Assert.Equal("Operation not allowed", ex.Message);
}
public void Should_handle_domain_id_as_string()
{
var id = DomainId.NewGuid();
var vars = new ScriptVars
{
["value"] = id
};
const string script = @"
return value;
";
var result = sut.Execute(vars, script);
Assert.Equal(id.ToString(), result.ToString());
}
public async Task Should_throw_security_exception_if_calling_reject()
{
const string script = @"
disallow()
";
var options = new ScriptOptions
{
CanDisallow = true
};
var vars = new ScriptVars();
var ex = await Assert.ThrowsAsync <DomainForbiddenException>(() => sut.ExecuteAsync(vars, script, options));
Assert.Equal("Script has forbidden the operation.", ex.Message);
}
public async Task Should_throw_validation_exception_when_calling_reject_with_message()
{
const string script = @"
reject('Not valid')
";
var options = new ScriptOptions
{
CanReject = true
};
var vars = new ScriptVars();
var ex = await Assert.ThrowsAsync <ValidationException>(() => sut.ExecuteAsync(vars, script, options));
Assert.Equal("Not valid", ex.Errors.Single().Message);
}
public async ValueTask <string?> FormatAsync(string text, EnrichedEvent @event)
{
if (string.IsNullOrWhiteSpace(text))
{
return(text);
}
if (TryGetTemplate(text.Trim(), out var template))
{
var vars = new TemplateVars
{
["event"] = @event
};
return(await templateEngine.RenderAsync(template, vars));
}
if (TryGetScript(text.Trim(), out var script))
{
var vars = new ScriptVars
{
["event"] = @event
};
#pragma warning disable MA0042 // Do not use blocking calls in an async method
var result = scriptEngine.Execute(vars, script).ToString();
#pragma warning restore MA0042 // Do not use blocking calls in an async method
if (result == "undefined")
{
return(GlobalFallback);
}
return(result);
}
var parts = BuildParts(text, @event);
if (parts.Any(x => !x.Var.IsCompleted))
{
await ValueTaskEx.WhenAll(parts.Select(x => x.Var));
}
return(CombineParts(text, parts));
}
private async Task TransformAsync(Context context, string script, ContentEntity content)
{
var vars = new ScriptVars
{
ContentId = content.Id,
Data = content.Data,
AppId = context.App.Id,
AppName = context.App.Name,
User = context.User
};
var options = new ScriptOptions
{
AsContext = true
};
content.Data = await scriptEngine.TransformAsync(vars, script, options);
}
public async Task EnrichAsync(Context context, IEnumerable <ContentEntity> contents, ProvideSchema schemas,
CancellationToken ct)
{
if (!ShouldEnrich(context))
{
return;
}
foreach (var group in contents.GroupBy(x => x.SchemaId.Id))
{
var(schema, _) = await schemas(group.Key);
var script = schema.SchemaDef.Scripts.Query;
if (string.IsNullOrWhiteSpace(script))
{
continue;
}
var vars = new ScriptVars
{
[ScriptKeys.AppId] = context.App.Id,
[ScriptKeys.AppName] = context.App.Name,
[ScriptKeys.User] = context.User
};
var preScript = schema.SchemaDef.Scripts.QueryPre;
if (!string.IsNullOrWhiteSpace(preScript))
{
var options = new ScriptOptions
{
AsContext = true
};
await scriptEngine.ExecuteAsync(vars, preScript, options, ct);
}
await AsyncHelper.WhenAllThrottledAsync(group, async (content, _) =>
{
await TransformAsync(vars, script, content, ct);
}, ct : ct);
}
}
public async Task Should_resolve_references()
{
var referenceId1 = DomainId.NewGuid();
var reference1 = CreateReference(referenceId1, 1);
var referenceId2 = DomainId.NewGuid();
var reference2 = CreateReference(referenceId1, 2);
var user = new ClaimsPrincipal();
var data =
new ContentData()
.AddField("references",
new ContentFieldData()
.AddInvariant(JsonValue.Array(referenceId1, referenceId2)));
A.CallTo(() => contentQuery.QueryAsync(
A<Context>.That.Matches(x => x.App.Id == appId.Id && x.User == user), A<Q>.That.HasIds(referenceId1, referenceId2), A<CancellationToken>._))
.Returns(ResultList.CreateFrom(2, reference1, reference2));
var vars = new ScriptVars
{
["appId"] = appId.Id,
["data"] = data,
["dataOld"] = null,
["user"] = user
};
var expected = @"
Text: Hello 1 World 1
Text: Hello 2 World 2
";
var script = @"
getReferences(data.references.iv, function (references) {
var result1 = `Text: ${references[0].data.field1.iv} ${references[0].data.field2.iv}`;
var result2 = `Text: ${references[1].data.field1.iv} ${references[1].data.field2.iv}`;
complete(`${result1}\n${result2}`);
})";
var result = (await sut.ExecuteAsync(vars, script)).ToString();
Assert.Equal(Cleanup(expected), Cleanup(result));
}
private async Task TransformAsync(Context context, string script, ContentEntity content,
CancellationToken ct)
{
var vars = new ScriptVars
{
[ScriptKeys.AppId] = context.App.Id,
[ScriptKeys.AppName] = context.App.Name,
[ScriptKeys.ContentId] = content.Id,
[ScriptKeys.Data] = content.Data,
[ScriptKeys.User] = context.User
};
var options = new ScriptOptions
{
AsContext = true
};
content.Data = await scriptEngine.TransformAsync(vars, script, options, ct);
}
public async Task TransformAsync_should_timeout_if_replace_never_called()
{
var content = new ContentData();
var context = new ScriptVars {
Data = content, Operation = "MyOperation"
};
const string script = @"
async = true;
var data = ctx.data;
getJSON('http://squidex.io', function(result) {
data.operation = { iv: result.key };
});
";
await Assert.ThrowsAnyAsync <OperationCanceledException>(() => sut.TransformAsync(context, script, contentOptions));
}
public async Task TransformAsync_should_transform_content_with_old_content()
{
var content =
new ContentData()
.AddField("number0",
new ContentFieldData()
.AddInvariant(3.0));
var oldContent =
new ContentData()
.AddField("number0",
new ContentFieldData()
.AddInvariant(5.0));
var expected =
new ContentData()
.AddField("number0",
new ContentFieldData()
.AddInvariant(13.0));
var userIdentity = new ClaimsIdentity();
var userPrincipal = new ClaimsPrincipal(userIdentity);
userIdentity.AddClaim(new Claim(OpenIdClaims.ClientId, "2"));
var vars = new ScriptVars
{
["data"] = content,
["dataOld"] = oldContent,
["user"] = userPrincipal
};
const string script = @"
ctx.data.number0.iv = ctx.data.number0.iv + ctx.dataOld.number0.iv * parseInt(ctx.user.id, 10);
replace(ctx.data);
";
var result = await sut.TransformAsync(vars, script, contentOptions);
Assert.Equal(expected, result);
}
