public void Should_normalize_tags()
{
A.CallTo(() => tagService.GetTagIdsAsync(appId.Id, TagGroups.Schemas(schemaId.Id), A <HashSet <string> > .That.Contains("name1")))
.Returns(new Dictionary <string, string> {
["name1"] = "id1"
});
var source = FilterBuilder.Eq("data.tags2.iv", "name1");
var result = FilterTagTransformer.Transform(source, appId.Id, schema, tagService);
Assert.Equal("data.tags2.iv == 'id1'", result.ToString());
}
public override FilterNode <ClrValue>?Visit(CompareFilter <ClrValue> nodeIn)
{
if (nodeIn.Value.Value is string stringValue && IsDataPath(nodeIn.Path) && IsTagField(nodeIn.Path))
{
var tagNames = Task.Run(() => tagService.GetTagIdsAsync(appId, TagGroups.Schemas(schema.Id), HashSet.Of(stringValue))).Result;
if (tagNames.TryGetValue(stringValue, out var normalized))
{
return(new CompareFilter <ClrValue>(nodeIn.Path, nodeIn.Operator, normalized));
}
}
return(nodeIn);
}
public override FilterNode Visit(FilterComparison nodeIn)
{
if (nodeIn.Rhs.Value is string stringValue && IsDataPath(nodeIn.Lhs) && IsTagField(nodeIn.Lhs))
{
var tagNames = Task.Run(() => tagService.GetTagIdsAsync(appId, TagGroups.Schemas(schema.Id), HashSet.Of(stringValue))).Result;
if (tagNames.TryGetValue(stringValue, out var normalized))
{
return(new FilterComparison(nodeIn.Lhs, nodeIn.Operator, new FilterValue(normalized)));
}
}
return(nodeIn);
}
public async Task Should_normalize_tags_with_old_data()
{
var newData = GenerateData("n_raw");
var oldData = GenerateData("o_raw");
A.CallTo(() => tagService.NormalizeTagsAsync(appId, TagGroups.Schemas(schemaId),
A <HashSet <string> > .That.Is("n_raw2_1", "n_raw2_2", "n_raw4"),
A <HashSet <string> > .That.Is("o_raw2_1", "o_raw2_2", "o_raw4")))
.Returns(new Dictionary <string, string>
{
["n_raw2_2"] = "id2_2",
["n_raw2_1"] = "id2_1",
["n_raw4"] = "id4"
});
await tagService.NormalizeAsync(appId, schemaId, schema, newData, oldData);
Assert.Equal(JsonValue.Array("id2_1", "id2_2"), newData["tags2"] !["iv"]);
public async Task Should_denormalize_tags()
{
var newData = GenerateData("id");
A.CallTo(() => tagService.NormalizeTagsAsync(appId, TagGroups.Schemas(schemaId),
A <HashSet <string> > .That.IsSameSequenceAs("id2_1", "id2_2", "id4"),
A <HashSet <string> > .That.IsEmpty()))
.Returns(new Dictionary <string, string>
{
["id2_2"] = "name2_2",
["id2_1"] = "name2_1",
["id4"] = "name4"
});
await tagService.NormalizeAsync(appId, schemaId, schema, newData, null);
Assert.Equal(new JArray("name2_1", "name2_2"), newData["tags2"]["iv"], JTokenEqualityComparer);
Assert.Equal(new JArray("name4"), newData["array"]["iv"][0]["nestedTags2"], JTokenEqualityComparer);
}
public async Task Should_normalize_tags_without_old_data()
{
var newData = GenerateData("name");
A.CallTo(() => tagService.NormalizeTagsAsync(appId, TagGroups.Schemas(schemaId),
A <HashSet <string> > .That.IsSameSequenceAs("name2_1", "name2_2", "name4"),
A <HashSet <string> > .That.IsEmpty()))
.Returns(new Dictionary <string, string>
{
["name2_2"] = "id2_2",
["name2_1"] = "id2_1",
["name4"] = "id4"
});
await tagService.NormalizeAsync(appId, schemaId, schema, newData, null);
Assert.Equal(JsonValue.Array("id2_1", "id2_2"), newData["tags2"]["iv"]);
Assert.Equal(JsonValue.Array("id4"), GetNestedTags(newData));
}
