public void DuplicateKeyScopeMatchingTest()
{
DataContext dc = new DataContext();
int val1 = 1, val2 = 2;
double d1 = 1.1, d2 = 2.2;
string s1 = "Top Object", s2 = "Double Tope";
SampleSimpleDataControl dataControl1 = new SampleSimpleDataControl(
new SimpleExpressionResolverDataObject(val1, s1, d1));
SampleSimpleDataControl dataControl2 = new SampleSimpleDataControl(
new SimpleExpressionResolverDataObject(val2, s2, d2));
string key = "foo";
dataControl1.Key = key;
dataControl2.Key = key;
dc.RegisterDataItem(dataControl1, "view1");
dc.RegisterDataItem(dataControl2, "secondview");
dc.ActiveViewScope = "view1";
string result;
string var = "${foo.MyString}";
result = dc.GetVariableValue(var);
Assert.IsNotNull(result);
Assert.AreEqual(s1, result, "view1 scope incorrect value");
dc.ActiveViewScope = "secondview";
result = dc.GetVariableValue(var);
Assert.IsNotNull(result);
Assert.AreEqual(s2, result, "secondview scope incorrect value");
}
public void TestJSONInvokeSingle()
{
string key = "foo";
DataContext context = new DataContext();
SampleSimpleDataControl ctl = Samples.GetSimpleDataControl();
int startingCount = context.DataItemCount;
context.RegisterDataItem(key, ctl);
context.SetAllowReflectiveSerialization(key, true);
Assert.AreEqual(startingCount + 1, context.DataItemCount);
//context.ResolveDataValues();
MemoryStream s = new MemoryStream();
StreamWriter writer = new StreamWriter(s);
context.WriteClientContext(writer);
writer.Flush();
string result = DataContext.GetStreamContent(s);
SimpleDataObject rawData = (SimpleDataObject)ctl.Value;
Assert.IsTrue(result.IndexOf(rawData.MyString) > -1, "Data not found in client context");
Assert.AreNotEqual(rawData.MyString, result, "Client context did not wrap");
}
public void InferredScopeVariableCallsOnAdding()
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject globalObject = new SimpleExpressionResolverDataObject(1, "Top Object", 2.2);
SimpleExpressionResolverDataObject templateMyScopeObject = new SimpleExpressionResolverDataObject(2, "My Template", 3.2);
SimpleExpressionResolverDataObject curLoopScopeObject = new SimpleExpressionResolverDataObject(3, "Current to loop", 5.2);
string globalKey = "foo";
string templateKey = "My";
string loopKey = "Cur";
string expression = "${MyString}";
string globalExpression = "${foo.MyString}";
SampleSimpleDataControl ctlGlobal = new SampleSimpleDataControl(globalObject);
dc.RegisterDataItem(globalKey, ctlGlobal);
string result = dc.CalculateVariableValue(globalExpression);
Assert.AreEqual(globalObject.MyString, result, "Global object wrong");
dc.RegisterLocalValue(templateKey, templateMyScopeObject);
result = dc.CalculateVariableValue(expression);
Assert.IsFalse(string.IsNullOrEmpty(result), "Scope value is null");
Assert.AreEqual(templateMyScopeObject.MyString, result, "Template scoped item wrong");
dc.RegisterLocalValue(loopKey, curLoopScopeObject);
result = dc.CalculateVariableValue(expression);
Assert.IsFalse(string.IsNullOrEmpty(result), "Scope value is null in loop");
Assert.AreEqual(curLoopScopeObject.MyString, result, "Loop scoped item wrong");
}
public void DuplicateKeyAcrossViews(string val1, string val2, string viewDef1, string viewDef2,
string ctlDef1, string ctlDef2,
string testView1, string testView2, bool expectedView2Defined)
{
string key = "foo";
DataContext dc = new DataContext();
SimpleDataObject data1 = new SimpleDataObject();
data1.MyString = val1;
SampleSimpleDataControl ctl1 = new SampleSimpleDataControl(data1);
ctl1.Key = key;
ctl1.RawTag = ctlDef1;
SimpleDataObject data2 = new SimpleDataObject();
data2.MyString = val2;
SampleSimpleDataControl ctl2 = new SampleSimpleDataControl(data2);
ctl2.Key = key;
ctl2.RawTag = ctlDef2;
dc.RegisterDataItem(ctl1, viewDef1);
dc.RegisterDataItem(ctl2, viewDef2);
Assert.AreEqual(true, dc.MasterData[key].IsValidForView(testView1), "View1 validity failed");
Assert.AreEqual(expectedView2Defined, dc.MasterData[key].IsValidForView(testView2), "View2 validity not expected");
string result;
string var = "${foo.MyString}";
dc.ActiveViewScope = testView1;
Assert.AreEqual(val1, dc.GetVariableValue(var), "Failed check on testView1");
dc.ActiveViewScope = testView2;
Assert.AreEqual(val2, dc.GetVariableValue(var), "Failed check on testView2");
}
public void InferredScopeParents()
{
DataContext dc = new DataContext();
SimpleExpressionResolverDataObject globalObject = new SimpleExpressionResolverDataObject(1, "Top Object", 2.2);
SimpleExpressionResolverDataObject templateValScopeObject = new SimpleExpressionResolverDataObject(2, "My Template", 3.2);
SimpleExpressionResolverDataObject nestObject = new SimpleExpressionResolverDataObject(5, "Nest Temp", 5.5);
Dictionary <string, object> nestedMyObject = new Dictionary <string, object>();
nestedMyObject.Add("nest", nestObject);
nestedMyObject.Add("simple", "value");
nestedMyObject.Add("one", 1);
Dictionary <string, object> templateMyObject = new Dictionary <string, object>();
templateMyObject.Add("val", templateValScopeObject);
templateMyObject.Add("x", "X");
SimpleExpressionResolverDataObject curLoopScopeObject = new SimpleExpressionResolverDataObject(3, "Current to loop", 5.2);
Dictionary <string, object> thirdMyObject = new Dictionary <string, object>();
thirdMyObject.Add("outer", "outside");
thirdMyObject.Add("two", "2");
thirdMyObject.Add("one", "All the way");
string globalKey = "foo";
string templateKey = "My";
//string fullParent = "${" + parentKey +
SampleSimpleDataControl ctlGlobal = new SampleSimpleDataControl(globalObject);
//Nest number 1
dc.RegisterDataItem(globalKey, ctlGlobal);
dc.RegisterLocalValue(templateKey, nestedMyObject);
Assert.AreEqual("value", dc.CalculateVariableValue("${My.simple}"));
Assert.AreEqual("value", dc.CalculateVariableValue("${simple}"));
Assert.AreEqual("Nest Temp", dc.CalculateVariableObjectValue("${My.nest.MyString}"));
Assert.AreEqual("Nest Temp", dc.CalculateVariableObjectValue("${nest.MyString}"));
//Nest #2
dc.RegisterLocalValue(templateKey, templateMyObject);
Assert.AreNotEqual("value", dc.CalculateVariableValue("${My.simple}"), "Explicit scope My.simple should now be empty");
Assert.AreEqual("value", dc.CalculateVariableValue("${simple}"), "Inferred simple in Parent is failing");
Assert.AreEqual("2", dc.CalculateVariableValue("${val.MyInt}"));
Assert.AreEqual("1", dc.CalculateVariableValue("${one}"));
Assert.AreEqual("X", dc.CalculateVariableValue("${My.x}"));
Assert.AreEqual("Nest Temp", dc.CalculateVariableValue("${nest.MyString}"), "Parent nested object failing");
//Nest #3
dc.RegisterLocalValue(templateKey, thirdMyObject);
Assert.AreEqual("value", dc.CalculateVariableValue("${simple}"), "Inferred simple in Parent.Parent is failing");
Assert.AreEqual("value", dc.CalculateVariableValue("${My.Parent.Parent.simple}"), "Explicit scope not working");
Assert.AreEqual("2", dc.CalculateVariableValue("${val.MyInt}"));
Assert.AreEqual("2", dc.CalculateVariableValue("${two}"));
Assert.AreEqual("2", dc.CalculateVariableValue("${My.two}"));
Assert.AreEqual("All the way", dc.CalculateVariableValue("${one}"));
Assert.AreEqual("1", dc.CalculateVariableValue("${My.Parent.Parent.one}"));
//Assert.AreEqual("2", dc.CalculateVariableValue("${val.MyInt}"));
//Unregister
dc.RemoveLocalValue(templateKey);
Assert.IsTrue(string.IsNullOrEmpty(dc.CalculateVariableValue("${two}")), "Remove outer didn't erase value");
Assert.AreEqual("X", dc.CalculateVariableValue("${My.x}"));
Assert.AreEqual("2", dc.CalculateVariableValue("${val.MyInt}"), "Parent objects not re-registering");
Assert.AreEqual("1", dc.CalculateVariableValue("${one}"));
}
