public void LoadTest1()
{
var id = Guid.NewGuid();
var parent = new ProjectionElement {Name = "Parent"};
var relation = new Relation
{
ParentElement = parent,
Queries = new[]
{
Query.CreateTestStubQuery(null,k2=>new[]{id},"Parent")
}
};
ParameterNames names;
var q = _tester.FormGetter(relation, new BoundingParameter[0],out names);
var k = Guid.NewGuid();
Assert.AreEqual(k, q(new[] { k }, new Dictionary<string, object>()).First().Key);
Assert.AreEqual(id,q(new[] { k },new Dictionary<string, object>()).First().Value.First());
Assert.IsTrue(names.SequenceEqual(new string[0]));
q = _tester.FormGetter(relation, new[]{new BoundingParameter("sdsad",0) },out names);
k = Guid.NewGuid();
Assert.AreEqual(k, q(new[] { k }, new Dictionary<string, object>()).First().Key);
Assert.AreEqual(id, q(new[] { k }, new Dictionary<string, object>()).First().Value.First());
Assert.IsTrue(names.SequenceEqual(new string[0]));
}
public void ChoiceBetweenPhysicalAndNot()
{
var id = Guid.NewGuid();
var id2= Guid.NewGuid();
var parent = new ProjectionElement { Name = "Parent",Namespace = "T" };
var relation = new Relation
{
ParentElement = parent,
Queries = new[]
{
Query.CreateTestStubQuery("T", k2=>new[]{id},"Parent"),
Query.CreateTestStubQuery("",k2=>new[]{id2}, "Parent"),
}
};
ParameterNames names;
var q = _tester.FormGetter(relation, new BoundingParameter[0], out names);
var k = Guid.NewGuid();
var res = q(new[] {k}, new Dictionary<string, object>()).First();
Assert.AreEqual(k, res.Key);
Assert.AreEqual(id, res.Value.First());
Assert.IsTrue(names.SequenceEqual(new string[0]));
q = _tester.FormGetter(relation, new[] { new BoundingParameter("sdsad", 0) }, out names);
k = Guid.NewGuid();
Assert.AreEqual(k, q(new[] { k }, new Dictionary<string, object>()).First().Key);
Assert.AreEqual(id, q(new[] { k }, new Dictionary<string, object>()).First().Value.First());
Assert.IsTrue(names.SequenceEqual(new string[0]));
}
private Getter FormGetterByRelation(Relation relation, BoundingParameter[] parameters, out ParameterNames parameterNames,out Query query)
{
Getter getter;
if (relation.HasTrivialQuery)
{
getter =
(keys, parPairs) =>
keys.Select(k => new KeyValuePair<Guid, IEnumerable<Guid>>(k, new[] {k})).ToArray();
parameterNames = new ParameterNames(new string[0]);
query = null;
}
else
{
var targetQuery =
relation.SelectTheBestQuery(parameters)
.FirstOrDefault();
if (targetQuery == null)
throw new InvalidOperationException(
string.Format("Нет запроса для построения дерева: род. {0}, доч. {1} ",
relation.ParentElement.Name,
relation.ChildElement.Name));
query = targetQuery;
getter = (keys, parPairs) =>
targetQuery.GetMultipleChildResourceQuery(relation.ParentElement.Name,
parPairs.Keys.ToArray())(keys,parPairs.Values.ToArray());
parameterNames = new ParameterNames(targetQuery.Arguments.Where(k=>!StringComparer.InvariantCultureIgnoreCase.Equals(k,relation.ParentElement.Name)));
}
return getter;
}
private Accumulator<FrameNode, IEnumerable<Guid>> GetAccumulator(Relation relation,Query query)
{
var factory = new AccumulatorFactory();
var plan = new FramingPlan(relation.ParentElement);
var acc = factory.GetOrCreateAccumulator(plan,
(keys, parPairs) =>
query.GetMultipleChildResourceQuery(relation.ParentElement.Name,parPairs.Select(k=>k.Key).ToArray())(keys,parPairs.Select(k=>k.Value).ToArray()),
relation.ParentElement, relation.ChildElement, new ParameterNames());
return acc;
}
public void RecursiveCommendationTest()
{
var sElement = new ResourceProjectionElement
{
Name = "Attribute",
FillingInfo = new FillingInfo {{"Name", FillingInfo.FillType.Native}},
ResourceType = "Attribute",
Namespace = "Test"
};
var sGroup = new ResourceProjectionElement
{
Name = "Element",
FillingInfo = new FillingInfo {{"Name", FillingInfo.FillType.Native}},
ResourceType = "Element",
Namespace = "Test",
};
var gToGRelation = new Relation {ChildElement = sGroup, ParentElement = sGroup};
var eFromEQuery = Query.CreateTestStubQuery(null,null,"element");
gToGRelation.Queries = new[] {eFromEQuery};
sGroup.UpRelations.Add(gToGRelation);
sGroup.DownRelations.Add(gToGRelation);
var eToGRelation = new Relation {ChildElement = sElement, ParentElement = sGroup};
var aFromEQuery = Query.CreateTestStubQuery(null,null,"element");
eToGRelation.Queries = new[] {aFromEQuery};
sElement.UpRelations.Add(eToGRelation);
sGroup.DownRelations.Add(eToGRelation);
var cc = new CommendationCollection();
var acc = GetAccumulator(gToGRelation, eFromEQuery);
cc.AddNewStep(new PlanStep(sGroup, sGroup, new ParameterNames(), acc, new ParameterNames(), 0));
acc = GetAccumulator(eToGRelation, aFromEQuery);
cc.AddNewStep(new PlanStep(sGroup, sElement, new ParameterNames(), acc, new ParameterNames(), 0));
var root = new FrameNodeGroup(sGroup,
new[] {new FrameNode(Guid.Empty, sGroup, 0, new Dictionary<string, object>())},
new ParameterNames());
var nodes = cc.GetNewGroups(new[] {root});
Assert.AreEqual(2,nodes.Count());
nodes = cc.GetNewGroups(nodes);
Assert.AreEqual(2, nodes.Count());
nodes = cc.GetNewGroups(nodes);
Assert.AreEqual(2, nodes.Count());
}
public void QuerySelectionWithParamsAndNot2()
{
var parent = new ProjectionElement { Name = "parent" };
var child = new ProjectionElement { Name = "child" };
var query1 = Query.CreateTestStubQuery("", null, "parent");
var query2 = Query.CreateTestStubMultipleQuery(parent.Name);
var relation = new Relation
{
ParentElement = parent,
ChildElement = child,
Queries = new[]
{
query1, query2
}
};
var bestQuery = relation.SelectTheBestQuery(new[] { new BoundingParameter("name", 1) }).First();
Assert.AreSame(query2, bestQuery);
}
public void SimplePlan1()
{
var sAttr = new ResourceProjectionElement
{
Name = "Attribute",
FillingInfo = new FillingInfo { { "Name", FillingInfo.FillType.Native } },
ResourceType = "Attribute",
Namespace = "Test"
};
var sElement = new ResourceProjectionElement
{
Name = "Element",
FillingInfo = new FillingInfo { { "Name", FillingInfo.FillType.Native } },
ResourceType = "Element",
Namespace = "Test",
};
var relation = new Relation {ChildElement = sAttr, ParentElement = sElement};
sAttr.UpRelations.Add(relation);
sElement.DownRelations.Add(relation);
var query = MakeStubQuery(typeof(Attribute), "element");
relation.Queries = new[]
{
query
};
var commendations = _tester.CheckVariantsForNodes(sElement, 2, new ParameterNames());
Assert.AreEqual(1,commendations.Count());
var elementCommendation = commendations.FirstOrDefault(k => k.MatchedElement == sElement) as TestPlanStep;
Assert.IsNotNull(elementCommendation);
Assert.AreEqual(0, elementCommendation.UsedParameters.Count());
Assert.AreEqual(sAttr, elementCommendation.ProducedChildElement);
Assert.AreEqual(query, elementCommendation.Query);
}
private void TestSerialGetters(ParameterNames parameters,int depth = -1)
{
// Е (Е)
// A (A) |
// V(V)
// V (E)
//
var sAttr = new ResourceProjectionElement
{
Name = "Attribute",
FillingInfo = new FillingInfo { { "Name", FillingInfo.FillType.Native } },
ResourceType = "Attribute",
Namespace = "Test"
};
var sElement = new ResourceProjectionElement
{
Name = "Element",
FillingInfo = new FillingInfo { { "Name", FillingInfo.FillType.Native } },
ResourceType = "Element",
Namespace = "Test",
};
var sValue = new ResourceProjectionElement
{
Name = "Value",
FillingInfo = new FillingInfo { { "Name", FillingInfo.FillType.Native } },
ResourceType = "Value",
Namespace = "Test",
};
var sValue2 = new ResourceProjectionElement
{
Name = "Value",
FillingInfo = new FillingInfo { { "Name", FillingInfo.FillType.Native } },
ResourceType = "Element",
Namespace = "Test",
};
var attrFromElementQuery = MakeStubQuery("Element", typeof(Data.Attribute));
var valueFromElementQuery = MakeStubQuery("Element", typeof(Data.Value));
var valueFromAttrQuery = MakeStubQuery("Attribute", typeof(Data.Value));
var elementFromValueQuery = MakeStubQuery("Value",typeof(Element));
var relation = new Relation { ChildElement = sAttr, ParentElement = sElement };
sAttr.UpRelations.Add(relation);
sElement.DownRelations.Add(relation);
relation.Queries = new[] { attrFromElementQuery };
relation = new Relation { ChildElement = sValue, ParentElement = sElement };
sValue.UpRelations.Add(relation);
sElement.DownRelations.Add(relation);
relation.Queries = new[] { valueFromElementQuery };
relation = new Relation { ChildElement = sValue, ParentElement = sAttr };
sValue.UpRelations.Add(relation);
sAttr.DownRelations.Add(relation);
relation.Queries = new[] { valueFromAttrQuery };
relation = new Relation { ChildElement = sValue2, ParentElement = sValue };
sValue2.UpRelations.Add(relation);
sValue.DownRelations.Add(relation);
relation.Queries = new[] { elementFromValueQuery };
var commendations = _tester.CheckVariantsForNodes(sElement, depth, parameters);
Assert.AreEqual(4, commendations.Count());
var elementCommendations = commendations.Where(k => k.MatchedElement == sElement).OfType<TestPlanStep>().ToArray();
Assert.AreEqual(2,elementCommendations.Count());
var aFromE = elementCommendations.FirstOrDefault(k => k.ProducedChildElement == sAttr);
Assert.IsNotNull(aFromE);
Assert.IsTrue(!aFromE.UsedParameters.Any());
Assert.AreEqual(attrFromElementQuery, aFromE.Query);
var vFromE = elementCommendations.FirstOrDefault(k => k.ProducedChildElement == sValue);
Assert.IsNotNull(vFromE);
Assert.IsTrue(!vFromE.UsedParameters.Any());
Assert.AreEqual(valueFromElementQuery, vFromE.Query);
var attrCommendation = commendations.SingleOrDefault(k => k.MatchedElement == sAttr) as TestPlanStep;
Assert.IsNotNull(attrCommendation);
Assert.IsTrue(!attrCommendation.UsedParameters.Any());
Assert.AreEqual(valueFromAttrQuery, attrCommendation.Query);
Assert.AreEqual(sValue, attrCommendation.ProducedChildElement);
var value1Commendation = commendations.SingleOrDefault(k => k.MatchedElement == sValue) as TestPlanStep;
Assert.IsNotNull(value1Commendation);
Assert.IsTrue(!value1Commendation.UsedParameters.Any());
Assert.AreEqual(elementFromValueQuery, value1Commendation.Query);
Assert.AreEqual(sValue2, value1Commendation.ProducedChildElement);
}
public void RecursivePlanWithSimpleGetters()
{
var sElement = new ResourceProjectionElement
{
Name = "Attribute",
FillingInfo = new FillingInfo { { "Name", FillingInfo.FillType.Native } },
ResourceType = "Attribute",
Namespace = "Test"
};
var sGroup = new ResourceProjectionElement
{
Name = "Element",
FillingInfo = new FillingInfo { { "Name", FillingInfo.FillType.Native } },
ResourceType = "Element",
Namespace = "Test",
};
var relation = new Relation { ChildElement = sGroup, ParentElement = sGroup };
var eFromEQuery = MakeStubQuery(typeof (Element), "Element");
relation.Queries = new[] { eFromEQuery };
sGroup.UpRelations.Add(relation);
sGroup.DownRelations.Add(relation);
relation = new Relation { ChildElement = sElement, ParentElement = sGroup };
var aFromEQuery = MakeStubQuery(typeof(Attribute), "element");
relation.Queries = new[] { aFromEQuery };
sElement.UpRelations.Add(relation);
sGroup.DownRelations.Add(relation);
var commendations = _tester.CheckVariantsForNodes(sGroup, -1, new ParameterNames());
Assert.AreEqual(2, commendations.Count());
var elementCommendations = commendations.Where(k => k.MatchedElement == sGroup).OfType<TestPlanStep>().ToArray();
Assert.AreEqual(2, elementCommendations.Count());
var eFromE = elementCommendations.FirstOrDefault(k => k.ProducedChildElement == sGroup);
Assert.IsNotNull(eFromE);
Assert.IsTrue(!eFromE.UsedParameters.Any());
Assert.AreEqual(eFromEQuery, eFromE.Query);
var aFromE = elementCommendations.FirstOrDefault(k => k.ProducedChildElement == sElement);
Assert.IsNotNull(aFromE);
Assert.IsTrue(!aFromE.UsedParameters.Any());
Assert.AreEqual(aFromEQuery, aFromE.Query);
}
private Relation CreateRelation(ProjectionElement parent, ProjectionElement child)
{
var newRelation = new Relation { ChildElement = child, ParentElement = parent };
if (child.SchemeType != null)
{
var queries = _queries.FindAppropriateQueries(parent.Namespace,parent.Name, child.SchemeType);
newRelation.Queries = queries;
}
else
{
newRelation.Queries = null;
}
_relations.Add(newRelation);
return newRelation;
}
public void ChoiceBetweenPhysicalAndNotWithParameters()
{
var id = Guid.NewGuid();
var id2 = Guid.NewGuid();
var parent = new ProjectionElement { Name = "Parent",Namespace = "T" };
var relation = new Relation
{
ParentElement = parent,
Queries = new[]
{
Query.CreateTestStubQuery("T", k2=>new[]{id},"Parent"),
Query.CreateTestStubQuery("", k2=>k2.OfType<Guid>(),"Parent", "Option2", "Option")
}
};
ParameterNames names;
var q = _tester.FormGetter(relation, new BoundingParameter[0], out names);
var k = Guid.NewGuid();
Assert.AreEqual(k, q(new[] { k }, new Dictionary<string, object>()).First().Key);
Assert.AreEqual(id, q(new[] { k }, new Dictionary<string, object>()).First().Value.First());
Assert.IsTrue(names.SequenceEqual(new string[0]));
q = _tester.FormGetter(relation,new[] {new BoundingParameter( "Option",0)}, out names);
Assert.AreEqual(k, q(new[] { k }, new Dictionary<string, object>()).First().Key);
Assert.AreEqual(id, q(new[] { k }, new Dictionary<string, object>()).First().Value.First());
Assert.IsTrue(names.SequenceEqual(new string[0]));
q = _tester.FormGetter(relation, new[] { new BoundingParameter("Option", 2), new BoundingParameter("Option2", 2) }, out names);
k = Guid.NewGuid();
var result = q(new[] {k}, new Dictionary<string, object> {{"Option2", id2},
{"Option", id}}).First();
Assert.AreEqual(k,result.Key);
Assert.AreEqual(id, result.Value.First());
//Assert.AreEqual(id2, result.Value.Skip(1).First());
//Assert.AreEqual(id, result.Value.Skip(2).First());
Assert.IsTrue(names.SequenceEqual(new string[0]));
}
public Getter FormGetter(Relation relation, BoundingParameter[] parameters, out ParameterNames parameterNames)
{
var testBuilder = new FramingPlanBuilder();
Query query;
return testBuilder.FormGetterByRelation(relation, parameters,out parameterNames,out query);
}
public void QuerySelectionForParentWithNoQuery()
{
var parent = new ProjectionElement { Name = "parent" };
var child = new ProjectionElement { Name = "child" };
var query1 = Query.CreateTestStubQuery("", null);
var relation = new Relation
{
ParentElement = parent,
ChildElement = child,
Queries = new[]
{
query1
}
};
var bestQuery = relation.SelectTheBestQuery(new BoundingParameter[0]).First();
Assert.AreSame(query1, bestQuery);
}
public void QuerySelectionWithParamsAtDifferentDepths()
{
var parent = new ProjectionElement { Name = "parent" };
var child = new ProjectionElement { Name = "child" };
var query1 = Query.CreateTestStubQuery("", null, "parent","closer");
var query2 = Query.CreateTestStubQuery("", null, "parent","further");
var relation = new Relation
{
ParentElement = parent,
ChildElement = child,
Queries = new[]
{
query1, query2
}
};
var bestQuery = relation.SelectTheBestQuery(new[] { new BoundingParameter("closer", 1), new BoundingParameter("further", 2) }).First();
Assert.AreSame(query1, bestQuery);
}
