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()); }