public void VerifyThatOptionDependencyIsHandled(IViewModelBase <Thing> container, string scenario)
{
var newDef = new ElementDefinition(Guid.NewGuid(), this.cache, this.uri);
var newUsage = new ElementUsage(Guid.NewGuid(), this.cache, this.uri)
{
ElementDefinition = newDef
};
this.elementDef2.ContainedElement.Add(newUsage);
var vm = new ElementUsageRowViewModel(this.elementUsage, this.option, this.session.Object, container);
Assert.IsTrue(vm.ContainedRows.Select(x => x.Thing).Contains(newUsage));
var revisionProperty = typeof(ElementDefinition).GetProperty("RevisionNumber");
revisionProperty.SetValue(newUsage, 20);
newUsage.ExcludeOption.Add(this.option);
CDPMessageBus.Current.SendObjectChangeEvent(newUsage, EventKind.Updated);
Assert.IsFalse(vm.ContainedRows.Select(x => x.Thing).Contains(newUsage));
revisionProperty.SetValue(newUsage, 30);
newUsage.ExcludeOption.Clear();
CDPMessageBus.Current.SendObjectChangeEvent(newUsage, EventKind.Updated);
Assert.IsTrue(vm.ContainedRows.Select(x => x.Thing).Contains(newUsage));
}
public void VerifyCreateParameterOverride()
{
var vm = new ProductTreeViewModel(this.option, this.session.Object, this.thingDialogNavigationService.Object, this.panelNavigationService.Object, this.dialogNavigationService.Object, null);
var revisionNumber = typeof(Iteration).GetProperty("RevisionNumber");
revisionNumber.SetValue(this.iteration, 50);
var elementdef = new ElementDefinition(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Container = this.iteration
};
var boolParamType = new BooleanParameterType(Guid.NewGuid(), this.assembler.Cache, this.uri);
var elementUsage = new ElementUsage(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Container = elementdef,
ElementDefinition = elementdef
};
var parameter = new Parameter(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Owner = this.domain, Container = elementUsage, ParameterType = boolParamType
};
elementdef.Parameter.Add(parameter);
var published = new ValueArray <string>(new List <string> {
"published"
});
var paramValueSet = new ParameterValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Published = published,
Manual = published,
Computed = published,
ValueSwitch = ParameterSwitchKind.COMPUTED
};
parameter.ValueSet.Add(paramValueSet);
var usageRow = new ElementUsageRowViewModel(elementUsage, this.option, this.session.Object, null);
var parameterRow = new ParameterRowViewModel(parameter, this.option, this.session.Object, usageRow);
this.iteration.TopElement = elementdef;
vm.SelectedThing = parameterRow;
Assert.IsTrue(vm.CreateOverrideCommand.CanExecute(null));
vm.SelectedThing = null;
vm.CreateOverrideCommand.Execute(null);
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()), Times.Never);
vm.SelectedThing = vm.TopElement.Single();
vm.CreateOverrideCommand.Execute(null);
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()), Times.Never);
vm.SelectedThing = parameterRow;
vm.CreateOverrideCommand.Execute(parameter);
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()));
vm.PopulateContextMenu();
Assert.AreEqual(6, vm.ContextMenu.Count);
}
public void VerifyThatExceptionThrownNullComparer()
{
var list = new ReactiveList <IRowViewModelBase <Thing> >();
var usage1 = this.elementUsage.Clone(false);
usage1.Name = "def";
var usageRow1 = new ElementUsageRowViewModel(usage1, this.option, this.session.Object, null);
Assert.Throws <ArgumentNullException>(() => list.SortedInsert(usageRow1, null));
}
public void VerifyThatCategoryIsCollectedCorrectlyForElementUsage6()
{
var row = new ElementUsageRowViewModel(this.elementUsage6, this.option, this.session.Object, null);
Assert.AreEqual(1, row.Category.Count());
var expectedCategories = new List <Category>
{
this.category1
};
CollectionAssert.AreEquivalent(expectedCategories, row.Category);
}
public void VerifyThatPropertiesAreSet()
{
var vm = new ElementUsageRowViewModel(this.elementUsage, this.option, this.session.Object, null);
Assert.IsNotNull(vm.ElementDefinition);
Assert.That(vm.Name, Is.Not.Null.Or.Empty);
Assert.That(vm.ShortName, Is.Not.Null.Or.Empty);
Assert.AreEqual("Element usage 1 : Element definition 1", vm.Name);
Assert.AreEqual("EU1 : ED1", vm.ShortName);
Assert.AreSame(this.elementDef2, vm.ElementDefinition);
Assert.AreEqual("domain", vm.OwnerName);
Assert.AreEqual("dom", vm.OwnerShortName);
}
public void VerifyThatDragOverWorks2()
{
this.permissionService.Setup(x => x.CanWrite(It.IsAny <ClassKind>(), It.IsAny <Thing>())).Returns(true);
var vm = new ElementUsageRowViewModel(this.elementUsage, this.option, this.session.Object, null);
var dropinfo = new Mock <IDropInfo>();
dropinfo.Setup(x => x.Payload).Returns(this.elementDef);
dropinfo.SetupProperty(x => x.Effects);
vm.DragOver(dropinfo.Object);
Assert.AreEqual(DragDropEffects.None, dropinfo.Object.Effects);
}
public void VerifyThatDropWorks()
{
this.permissionService.Setup(x => x.CanWrite(It.IsAny <ClassKind>(), It.IsAny <Thing>())).Returns(true);
var vm = new ElementUsageRowViewModel(this.elementUsage, this.option, this.session.Object, null);
var dropinfo = new Mock <IDropInfo>();
dropinfo.Setup(x => x.Payload).Returns(this.elementDef3);
dropinfo.Setup(x => x.Effects).Returns(DragDropEffects.Copy);
dropinfo.SetupProperty(x => x.Effects);
vm.Drop(dropinfo.Object).Wait();
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()));
}
public async Task VerifyThatDropWorks()
{
this.permissionService.Setup(x => x.CanWrite(It.IsAny <ClassKind>(), It.IsAny <Thing>())).Returns(true);
var vm = new ElementUsageRowViewModel(this.elementUsage, this.option, this.session.Object, null);
var dropinfo = new Mock <IDropInfo>();
dropinfo.Setup(x => x.Payload).Returns(this.elementDef3);
dropinfo.Setup(x => x.Effects).Returns(DragDropEffects.Copy);
dropinfo.SetupProperty(x => x.Effects);
await vm.Drop(dropinfo.Object);
this.thingCreator.Verify(x => x.CreateElementUsage(this.elementUsage.ElementDefinition, It.IsAny <ElementDefinition>(), It.IsAny <DomainOfExpertise>(), It.IsAny <ISession>()));
}
public void VerifyThatCategoryIsCollectedCorrectlyForElementUsage1()
{
this.elementDefinitionForUsage1.Parameter.Add(this.parameter1);
var elementUsageRow = new ElementUsageRowViewModel(this.elementUsage1, this.activeDomain, this.session.Object, null, this.obfuscationService.Object);
var row = new ParameterRowViewModel(this.parameter1, this.session.Object, elementUsageRow, false);
Assert.AreEqual(2, row.Category.Count());
var expectedCategories = new List <Category>
{
this.category1,
this.category1
};
CollectionAssert.AreEquivalent(expectedCategories, row.Category);
}
public void VerifyThatDragOverParameterGroupInUSageIsForbidden()
{
this.elementDefinition.ContainedElement.Add(this.elementUsage1);
this.elementDefinitionForUsage1.ParameterGroup.Add(this.parameterGroup1ForUsage1);
// ***************************************
var row = new ElementUsageRowViewModel(this.elementUsage1, this.activeDomain, this.session.Object, null, this.obfuscationService.Object);
var simpleQuantityKind = new SimpleQuantityKind(Guid.NewGuid(), null, null);
var ratioScale = new RatioScale(Guid.NewGuid(), null, null);
simpleQuantityKind.DefaultScale = ratioScale;
var payload = new Tuple <ParameterType, MeasurementScale>(simpleQuantityKind, ratioScale);
var dropInfo = new Mock <IDropInfo>();
dropInfo.Setup(x => x.Payload).Returns(payload);
dropInfo.SetupProperty(x => x.Effects);
var groupRow = row.ContainedRows.OfType <ParameterGroupRowViewModel>().Single();
groupRow.DragOver(dropInfo.Object);
Assert.AreEqual(dropInfo.Object.Effects, DragDropEffects.None);
}
public void VerifyThatExcludingOptionsPopulatesWorks()
{
this.elementDefinition.ContainedElement.Add(this.elementUsage1);
// ***************************************
var row = new ElementUsageRowViewModel(this.elementUsage1, this.activeDomain, this.session.Object, null, this.obfuscationService.Object);
var container = new TestMessageBusHandlerContainerViewModel();
var row2 = new ElementUsageRowViewModel(this.elementUsage1, this.activeDomain, this.session.Object, container, this.obfuscationService.Object);
Assert.AreEqual(2, row.AllOptions.Count);
Assert.AreEqual(2, row2.AllOptions.Count);
Assert.AreEqual(0, row.ExcludedOptions.Count);
Assert.IsTrue(row.HasExcludes.HasValue);
Assert.IsFalse(row.HasExcludes.Value);
Assert.AreEqual("This ElementUsage is used in all options.", row.OptionToolTip);
var newOption = new Option(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
ShortName = "3"
};
this.iteration.Option.Add(newOption);
CDPMessageBus.Current.SendObjectChangeEvent(newOption, EventKind.Added);
Assert.AreEqual(3, row.AllOptions.Count);
Assert.AreEqual(3, row2.AllOptions.Count);
row.SelectedOptions = new ReactiveList <Option> {
this.option1, newOption
};
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()), Times.Exactly(1));
row.Thing.ExcludeOption = new List <Option> {
this.option2
};
Assert.AreEqual(1, row.ExcludedOptions.Count);
Assert.IsTrue(row.HasExcludes.HasValue);
Assert.IsTrue(row.HasExcludes.Value);
Assert.AreSame(this.option2, row.ExcludedOptions.Single());
row.SelectedOptions = new ReactiveList <Option>();
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()), Times.Exactly(2));
row.Thing.ExcludeOption = new List <Option> {
this.option2, this.option1, newOption
};
row.SelectedOptions = new ReactiveList <Option> {
newOption
};
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()), Times.Exactly(3));
row.Thing.ExcludeOption = new List <Option> {
this.option1, this.option2
};
// re-ordering
row.AllOptions = new ReactiveList <Option> {
this.option2, newOption, this.option1
};
row.SelectedOptions = new ReactiveList <Option> {
newOption
};
this.session.Verify(x => x.Write(It.IsAny <OperationContainer>()), Times.Exactly(3));
Assert.AreEqual(2, row.ExcludedOptions.Count);
Assert.IsTrue(row.HasExcludes.HasValue);
}
public void VerifyThatParameterBaseElementAreHandledCorrectly(IViewModelBase <Thing> container, string scenario)
{
var revision = typeof(Thing).GetProperty("RevisionNumber");
// Test input
var valueSet = new ParameterValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri);
var valueSetOverride = new ParameterOverrideValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
ParameterValueSet = valueSet
};
var manualSet = new ValueArray <string>(new List <string> {
"manual"
});
var referenceSet = new ValueArray <string>(new List <string> {
"ref"
});
var computedSet = new ValueArray <string>(new List <string> {
"computed"
});
var publishedSet = new ValueArray <string>(new List <string> {
"published"
});
valueSet.Manual = manualSet;
valueSet.Reference = referenceSet;
valueSet.Computed = computedSet;
valueSet.Published = publishedSet;
valueSetOverride.Manual = manualSet;
valueSetOverride.Reference = referenceSet;
valueSetOverride.Computed = computedSet;
valueSetOverride.Published = publishedSet;
this.parameter6ForOverride.ValueSet.Add(valueSet);
this.parameter1.ValueSet.Add(valueSet);
this.parameter6Override.ValueSet.Add(valueSetOverride);
this.elementDefinitionForUsage1.Parameter.Add(this.parameter6ForOverride);
this.elementDefinitionForUsage1.Parameter.Add(this.parameter1);
this.elementUsage1.ParameterOverride.Add(this.parameter6Override);
this.elementDefinition.ContainedElement.Add(this.elementUsage1);
// ***************************************
var row = new ElementUsageRowViewModel(this.elementUsage1, this.activeDomain, this.session.Object, container, this.obfuscationService.Object);
// Verify That Override is displayed instead of parameter
Assert.AreEqual(2, row.ContainedRows.Count);
var overrideRow = row.ContainedRows.SingleOrDefault(x => x.Thing == this.parameter6Override);
var parameterRow = row.ContainedRows.SingleOrDefault(x => x.Thing == this.parameter1);
Assert.IsNotNull(overrideRow);
Assert.IsNotNull(parameterRow);
// **********************************
// Add a subscription to parameter and see that its replaced.
var subscription = new ParameterSubscription(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Owner = this.activeDomain
};
subscription.ValueSet.Add(new ParameterSubscriptionValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
SubscribedValueSet = valueSet
});
this.parameter1.ParameterSubscription.Add(subscription);
revision.SetValue(this.elementDefinitionForUsage1, 1);
CDPMessageBus.Current.SendObjectChangeEvent(this.elementDefinitionForUsage1, EventKind.Updated);
Assert.AreEqual(2, row.ContainedRows.Count);
var subscriptionRow = row.ContainedRows.SingleOrDefault(x => x.Thing == subscription);
Assert.IsNotNull(subscriptionRow);
parameterRow = row.ContainedRows.SingleOrDefault(x => x.Thing == this.parameter1);
Assert.IsNull(parameterRow);
// Add a subscription to the override of the usage
var subscriptionOverride = new ParameterSubscription(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
Owner = this.activeDomain
};
subscriptionOverride.ValueSet.Add(new ParameterSubscriptionValueSet(Guid.NewGuid(), this.assembler.Cache, this.uri)
{
SubscribedValueSet = valueSet
});
this.parameter6Override.ParameterSubscription.Add(subscriptionOverride);
revision.SetValue(this.elementUsage1, 1);
CDPMessageBus.Current.SendObjectChangeEvent(this.elementUsage1, EventKind.Updated);
Assert.AreEqual(2, row.ContainedRows.Count);
var subscriptionOverrideRow = row.ContainedRows.SingleOrDefault(x => x.Thing == subscriptionOverride);
subscriptionRow = row.ContainedRows.SingleOrDefault(x => x.Thing == subscription);
Assert.IsNotNull(subscriptionRow);
Assert.IsNotNull(subscriptionOverrideRow);
// removes the subscriptions
this.parameter6Override.ParameterSubscription.Clear();
revision.SetValue(this.elementUsage1, 2);
CDPMessageBus.Current.SendObjectChangeEvent(this.elementUsage1, EventKind.Updated);
Assert.AreEqual(2, row.ContainedRows.Count);
overrideRow = row.ContainedRows.SingleOrDefault(x => x.Thing == this.parameter6Override);
Assert.IsNotNull(overrideRow);
this.parameter1.ParameterSubscription.Clear();
revision.SetValue(this.elementDefinitionForUsage1, 2);
CDPMessageBus.Current.SendObjectChangeEvent(this.elementDefinitionForUsage1, EventKind.Updated);
Assert.AreEqual(2, row.ContainedRows.Count);
parameterRow = row.ContainedRows.SingleOrDefault(x => x.Thing == this.parameter1);
Assert.IsNotNull(parameterRow);
}
public void VerifyThatRowsAreInsertedCorrectly()
{
var list = new ReactiveList <IRowViewModelBase <Thing> >();
var comparer = new ElementBaseChildRowComparer();
var parameter1 = new Parameter(Guid.NewGuid(), this.cache, this.uri)
{
ParameterType = this.type, Owner = this.domain, Container = this.elementDef
};
parameter1.ValueSet.Add(this.valueSet);
var parameterRow1 = new ParameterRowViewModel(parameter1, this.session.Object, null, false);
var typeClone = this.type.Clone(false);
typeClone.Name = "b";
var paraClone = parameter1.Clone(false);
paraClone.ParameterType = typeClone;
var parameterRow2 = new ParameterRowViewModel(paraClone, this.session.Object, null, false)
{
Name = "b"
};
var group1 = new ParameterGroup(Guid.NewGuid(), this.cache, this.uri)
{
Name = "a"
};
var groupRow1 = new ParameterGroupRowViewModel(group1, this.domain, this.session.Object, null);
var group2 = new ParameterGroup(Guid.NewGuid(), this.cache, this.uri)
{
Name = "b"
};
var groupRow2 = new ParameterGroupRowViewModel(group2, this.domain, this.session.Object, null);
var usage1 = this.elementUsage.Clone(false);
usage1.Name = "def";
var usageRow1 = new ElementUsageRowViewModel(usage1, this.domain, this.session.Object, null);
var usage2 = this.elementUsage.Clone(false);
usage2.Name = "abc";
var usageRow2 = new ElementUsageRowViewModel(usage2, this.domain, this.session.Object, null);
var usage3 = this.elementUsage.Clone(false);
usage3.Name = "ghi";
var usageRow3 = new ElementUsageRowViewModel(usage3, this.domain, this.session.Object, null);
list.SortedInsert(usageRow1, comparer);
list.SortedInsert(usageRow3, comparer);
list.SortedInsert(parameterRow1, comparer);
list.SortedInsert(groupRow1, comparer);
list.SortedInsert(parameterRow2, comparer);
list.SortedInsert(groupRow2, comparer);
list.SortedInsert(usageRow2, comparer);
Assert.AreSame(parameterRow1, list[0]);
Assert.AreSame(parameterRow2, list[1]);
Assert.AreSame(groupRow1, list[2]);
Assert.AreSame(groupRow2, list[3]);
Assert.AreSame(usageRow2, list[4]);
Assert.AreSame(usageRow1, list[5]);
Assert.AreSame(usageRow3, list[6]);
}
public void VerifyThatPopulateParameterOrOverrideWorks(IViewModelBase <Thing> container, string scenario)
{
var revisionProperty = typeof(ElementUsage).GetProperty("RevisionNumber");
// TEST DATA
var group1 = new ParameterGroup(Guid.NewGuid(), this.cache, this.uri);
var group11 = new ParameterGroup(Guid.NewGuid(), this.cache, this.uri)
{
ContainingGroup = group1
};
this.elementDef.ParameterGroup.Add(group1);
this.elementDef.ParameterGroup.Add(group11);
this.elementUsage.ElementDefinition = this.elementDef;
this.elementDef.ContainedElement.Clear();
var type1 = new EnumerationParameterType(Guid.NewGuid(), this.cache, this.uri)
{
Name = "type1"
};
var parameter1 = new Parameter(Guid.NewGuid(), this.cache, this.uri)
{
ParameterType = type1, Owner = this.domain
};
parameter1.ValueSet.Add(this.valueSet);
var parameter2 = new Parameter(Guid.NewGuid(), this.cache, this.uri)
{
ParameterType = type1, Owner = this.domain
};
parameter2.ValueSet.Add(this.valueSet);
this.elementDef.Parameter.Add(parameter2);
this.elementDef.Parameter.Add(parameter1);
var override1 = new ParameterOverride(Guid.NewGuid(), this.cache, this.uri)
{
Parameter = parameter1, Owner = this.domain
};
override1.ValueSet.Add(this.valueSetOverride);
this.elementUsage.ParameterOverride.Add(override1);
var vm = new ElementUsageRowViewModel(this.elementUsage, this.option, this.session.Object, container);
// **************************************************************************************
// check added parameter
Assert.AreEqual(2, vm.ContainedRows.OfType <ParameterOrOverrideBaseRowViewModel>().Count());
var param2row = vm.ContainedRows.OfType <ParameterRowViewModel>().Single();
var override1row = vm.ContainedRows.OfType <ParameterOverrideRowViewModel>().Single();
Assert.AreSame(param2row.Thing, parameter2);
Assert.AreSame(override1, override1row.Thing);
// move parameter1, check update is correct
parameter1.Group = group11;
revisionProperty.SetValue(parameter1, 10);
CDPMessageBus.Current.SendObjectChangeEvent(parameter1, EventKind.Updated);
Assert.AreEqual(1, vm.ContainedRows.OfType <ParameterOrOverrideBaseRowViewModel>().Count());
var group11row = vm.ContainedRows.OfType <ParameterGroupRowViewModel>().Single().ContainedRows.OfType <ParameterGroupRowViewModel>().Single();
Assert.AreSame(override1, group11row.ContainedRows.OfType <ParameterOrOverrideBaseRowViewModel>().Single().Thing);
// move parameter1 under group1, check update
parameter1.Group = group1;
revisionProperty.SetValue(parameter1, 20);
CDPMessageBus.Current.SendObjectChangeEvent(parameter1, EventKind.Updated);
Assert.AreEqual(1, vm.ContainedRows.OfType <ParameterOrOverrideBaseRowViewModel>().Count());
var group1row = vm.ContainedRows.OfType <ParameterGroupRowViewModel>().Single();
Assert.AreSame(override1, group1row.ContainedRows.OfType <ParameterOrOverrideBaseRowViewModel>().Single().Thing);
// move parameter1 back to top, check update is correct
parameter1.Group = null;
revisionProperty.SetValue(parameter1, 30);
CDPMessageBus.Current.SendObjectChangeEvent(parameter1, EventKind.Updated);
Assert.AreEqual(2, vm.ContainedRows.OfType <ParameterOrOverrideBaseRowViewModel>().Count());
Assert.AreEqual(0, group11row.ContainedRows.OfType <ParameterOrOverrideBaseRowViewModel>().Count());
// remove override1
this.elementUsage.ParameterOverride.Clear();
revisionProperty.SetValue(this.elementUsage, 40);
CDPMessageBus.Current.SendObjectChangeEvent(this.elementUsage, EventKind.Updated);
Assert.AreEqual(2, vm.ContainedRows.OfType <ParameterOrOverrideBaseRowViewModel>().Count());
var param1row = vm.ContainedRows.OfType <ParameterRowViewModel>().SingleOrDefault(x => x.Thing == parameter1);
Assert.IsNotNull(param1row);
}
public void VerifyThatPopulateGroupWorks(IViewModelBase <Thing> container, string scenario)
{
var revisionProperty = typeof(ElementUsage).GetProperty("RevisionNumber");
var group1 = new ParameterGroup(Guid.NewGuid(), this.cache, this.uri);
var group11 = new ParameterGroup(Guid.NewGuid(), this.cache, this.uri)
{
ContainingGroup = group1
};
this.elementDef.ParameterGroup.Add(group1);
this.elementDef.ParameterGroup.Add(group11);
this.elementUsage.ElementDefinition = this.elementDef;
this.elementDef.ContainedElement.Clear();
var vm = new ElementUsageRowViewModel(this.elementUsage, this.option, this.session.Object, container);
var group1row = vm.ContainedRows.OfType <ParameterGroupRowViewModel>().Single();
Assert.AreSame(group1, group1row.Thing);
var group11row = group1row.ContainedRows.OfType <ParameterGroupRowViewModel>().Single();
Assert.AreSame(group11, group11row.Thing);
// move group11
group11.ContainingGroup = null;
revisionProperty.SetValue(group11, 10);
CDPMessageBus.Current.SendObjectChangeEvent(group11, EventKind.Updated);
Assert.AreEqual(2, vm.ContainedRows.OfType <ParameterGroupRowViewModel>().Count());
Assert.AreEqual(0, group1row.ContainedRows.OfType <ParameterGroupRowViewModel>().Count());
// move group11 under group1
group11.ContainingGroup = group1;
revisionProperty.SetValue(group11, 20);
CDPMessageBus.Current.SendObjectChangeEvent(group11, EventKind.Updated);
Assert.AreEqual(1, vm.ContainedRows.OfType <ParameterGroupRowViewModel>().Count());
Assert.AreSame(group11, group1row.ContainedRows.OfType <ParameterGroupRowViewModel>().Single().Thing);
// add group2 and move group11 under group2
var group2 = new ParameterGroup(Guid.NewGuid(), this.cache, this.uri);
group11.ContainingGroup = group2;
this.elementDef.ParameterGroup.Add(group2);
revisionProperty.SetValue(this.elementDef, 30);
revisionProperty.SetValue(group11, 30);
CDPMessageBus.Current.SendObjectChangeEvent(this.elementDef, EventKind.Updated);
CDPMessageBus.Current.SendObjectChangeEvent(group11, EventKind.Updated);
Assert.AreEqual(2, vm.ContainedRows.OfType <ParameterGroupRowViewModel>().Count());
Assert.AreEqual(0, group1row.ContainedRows.OfType <ParameterGroupRowViewModel>().Count());
var group2row = vm.ContainedRows.OfType <ParameterGroupRowViewModel>().Single(x => x.Thing == group2);
Assert.AreEqual(1, group2row.ContainedRows.OfType <ParameterGroupRowViewModel>().Count());
// remove group11
this.elementDef.ParameterGroup.Remove(group11);
revisionProperty.SetValue(this.elementDef, 40);
CDPMessageBus.Current.SendObjectChangeEvent(this.elementDef, EventKind.Updated);
Assert.AreEqual(2, vm.ContainedRows.OfType <ParameterGroupRowViewModel>().Count());
Assert.AreEqual(0, group1row.ContainedRows.OfType <ParameterGroupRowViewModel>().Count());
Assert.AreEqual(0, group2row.ContainedRows.OfType <ParameterGroupRowViewModel>().Count());
}
public void VerifyThatGetPathWorks()
{
var vm = new ElementUsageRowViewModel(this.elementUsage, this.option, this.session.Object, null);
Assert.AreEqual(this.nestedElementPath, vm.GetPath());
}
