public void ProcessPublishEvent_MarksFieldAsPublished()
        {
            // Arrange.
            var fieldEdit = Mock.Create<FieldEdit>(Behavior.Loose);
            var section = Mock.Create<ProcessSectionViewModel>(Constructor.Mocked, Behavior.Loose);
            var eventAggregator = Mock.Create<IEventAggregator>(Behavior.Loose);
            var processEdit = Mock.Create<ProcessEdit>(Behavior.Loose);
            var publishTask = Mock.Create<Task>(Behavior.Loose);

            Mock.Arrange(() => fieldEdit.GetParent<ProcessEdit>()).Returns(processEdit);
            Mock.Arrange(() => fieldEdit.IsPublished).Returns(false);
            Mock.Arrange(() => fieldEdit.MarkPublished()).DoInstead(() => Mock.Arrange(() => fieldEdit.IsPublished).Returns(true));

            var fieldViewModel = new ProcessFieldViewModel(fieldEdit, section) { EventAggregator = eventAggregator };

            bool? isPublished = null;
            fieldViewModel.PropertyChanged += (sender, args) =>
                {
                    if (args.PropertyName == TestsHelper.ExtractPropertyName(() => fieldViewModel.IsPublished))
                        isPublished = fieldViewModel.IsPublished;
                };

            // Act.
            fieldViewModel.HandleEvent(new ProcessPublishEvent(processEdit, publishTask));

            // Assert.
            Assert.AreEqual(true, isPublished);
            Mock.Assert(() => fieldEdit.MarkPublished(), Occurs.Once());
        }
 /// <summary>
 /// The create field vm.
 /// </summary>
 /// <param name="field">The field.</param>
 /// <param name="parentSection">The parent section.</param>
 /// <returns>The <see cref="ProcessFieldViewModel" />.</returns>
 public ProcessFieldViewModel CreateFieldVM(FieldEdit field, ProcessSectionViewModel parentSection)
 {
     var fieldVm = new ProcessFieldViewModel(field, parentSection);
     //DeploymentService.Container.ComposeParts(fieldVM);
     DeploymentService.Container.SatisfyImportsOnce(fieldVm);
     return fieldVm;
 }
        public void RichTextEvent()
        {
            // arrange
            var commonStepEdit = DataPortal.CreateChild<CommonStepEdit>();
            var fieldTypeInfo = new FieldTypeInfo();
            var fieldEdit = DataPortal.CreateChild<FieldEdit>();
            fieldEdit.FieldType = fieldTypeInfo;
            var processFieldViewModel = new ProcessFieldViewModel(fieldEdit, null);
            var vm = new ProcessFieldCommonStepViewModel(commonStepEdit, new StepInfo(), processFieldViewModel);

            // act
            vm.HandleEvent(new IsRichTextAllowedChangedEvent(true));
            
            // assert
            Assert.IsFalse(vm.IsEnabledWidth);
            Assert.AreEqual(8, vm.Data.RowSpan);
            Assert.IsTrue(vm.Data.IsRichTextAllowed);

            // act
            vm.HandleEvent(new IsRichTextAllowedChangedEvent(false));

            // assert
            Assert.IsTrue(vm.IsEnabledWidth);
            Assert.AreEqual(1, vm.Data.RowSpan);
            Assert.IsFalse(vm.Data.IsRichTextAllowed);
        }
        public void PropertiesTest()
        {
            var approvalStep = DataPortal.CreateChild<ApprovalOptionsStepEdit>();
            var stepInfo = Mock.Create<StepInfo>();
            var fieldEdit = DataPortal.CreateChild<FieldEdit>();
            var fieldVM = new ProcessFieldViewModel(fieldEdit, null);

            var vm = new ProcessFieldApprovalOptionsStepViewModel(approvalStep, stepInfo, fieldVM);

            TestsHelper.TestPublicPropertiesGetSet(vm);
        }
        public void PropertiesTest()
        {
            var documentationStep = DataPortal.CreateChild<DocumentationStepEdit>();
            var stepInfo = Mock.Create<StepInfo>();
            var fieldEdit = DataPortal.CreateChild<FieldEdit>();
            var fieldVM = new ProcessFieldViewModel(fieldEdit, null);

            var vm = new ProcessFieldDocumentationStepViewModel(documentationStep, stepInfo, fieldVM);

            TestsHelper.TestPublicPropertiesGetSet(vm);
        }
        public void Ctor()
        {
            // arrange
            var textOptionsStepEdit = new TextOptionsStepEdit();
            var stepInfo = new StepInfo(1);
            var processFieldViewModel = new ProcessFieldViewModel(null, null);

            // act
            var vm = new ProcessFieldTextOptionsStepViewModel(textOptionsStepEdit, stepInfo, processFieldViewModel);

            // assert
            Assert.IsNotNull(vm);
        }
        public void MaskEvent()
        {
            // arrange
            var commonStepEdit = DataPortal.CreateChild<CommonStepEdit>();
            var fieldTypeInfo = new FieldTypeInfo();
            var fieldEdit = DataPortal.CreateChild<FieldEdit>();
            fieldEdit.FieldType = fieldTypeInfo;
            var processFieldViewModel = new ProcessFieldViewModel(fieldEdit, null);
            var vm = new ProcessFieldCommonStepViewModel(commonStepEdit, new StepInfo(), processFieldViewModel);

            // act
            vm.HandleEvent(new MaskChangedEvent("00000", "Standart"));

            // assert
            Assert.AreEqual("00000", vm.Data.Mask);
            Assert.AreEqual("Standart", vm.Data.MaskType);
        }
        public void SetSecurity_RaisesPropertyChanged()
        {
            // Arrange.
            var fieldEdit = Mock.Create<FieldEdit>();
            var section = Mock.Create<ProcessSectionViewModel>(Constructor.Mocked);
            var eventAggregator = Mock.Create<IEventAggregator>();

            var vm = new ProcessFieldViewModel(fieldEdit, section) { EventAggregator = eventAggregator };
            var changedProperties = new HashSet<string>();
            vm.PropertyChanged += (sender, e) => changedProperties.Add(e.PropertyName);

            // Act.
            vm.SetSecurity(!vm.IsVisible, !vm.IsEditable);

            // Assert.
            Assert.IsTrue(changedProperties.Contains(TestsHelper.ExtractPropertyName<ProcessFieldViewModel>(x => x.IsVisible)));
            Assert.IsTrue(changedProperties.Contains(TestsHelper.ExtractPropertyName<ProcessFieldViewModel>(x => x.IsEditable)));
        }
Example #9
0
        /// <summary>
        /// Creates the step vm.
        /// </summary>
        /// <param name="stepEdit">The step edit.</param>
        /// <param name="typeEditor">The type editor.</param>
        /// <param name="processFieldViewModel">The process field view model.</param>
        /// <returns>IProcessFieldStepViewModel.</returns>
        public virtual IProcessFieldStepViewModel CreateStepVM(IStepEdit stepEdit, StepInfo typeEditor, ProcessFieldViewModel processFieldViewModel)
        {
            //if there is a specific ViewModel defined for the passed step type - create it otherwise use base "ProcessFeieldStepViewModel" class
            var step =
                (from lazyStepVM in StepViewModels
                 where lazyStepVM.Metadata.StepType == stepEdit.GetType()
                 select lazyStepVM).Select(result =>
                                           (IProcessFieldStepViewModel)
                                           Activator.CreateInstance(result.Metadata.DeclaringType, stepEdit, typeEditor, processFieldViewModel))
                    .FirstOrDefault() ?? new ProcessFieldStepViewModel<IStepEdit>(stepEdit, typeEditor, processFieldViewModel);
            //DeploymentService.Container.ComposeParts(step);
            DeploymentService.Container.SatisfyImportsOnce(step);

        	foreach (var stepModifier in StepModifiers)
        		if (processFieldViewModel.Model.FieldType.ColumnType == stepModifier.Metadata.ColumnType && stepModifier.Metadata.StepType == stepEdit.GetType())
        			stepModifier.Value.Modify(stepEdit);

            return step;
        }
        public void OnImportsSatisfied()
        {
            // arrange
            var commonStepEdit = DataPortal.CreateChild<CommonStepEdit>();
            var fieldTypeInfo = new FieldTypeInfo();
            var fieldEdit = DataPortal.CreateChild<FieldEdit>();
            fieldEdit.FieldType = fieldTypeInfo;
            var processFieldViewModel = new ProcessFieldViewModel(fieldEdit, null);
            var vm = new ProcessFieldCommonStepViewModel(commonStepEdit, new StepInfo(), processFieldViewModel)
                {
                    EventAggregator = new EventAggregatorService(),
                    Model = new ProcessFieldsViewModel { SelectedSection = new ProcessSectionViewModel(DataPortal.CreateChild<SectionEdit>()) }
                };

            // act
            vm.OnImportsSatisfied();

            // assert
            Assert.IsNotNull(vm.SelectedSection);
        }
        public void SwitchUseRichTextBoxTest()
        {
            var documentationStep = DataPortal.CreateChild<DocumentationStepEdit>();
            var stepInfo = Mock.Create<StepInfo>();
            var fieldEdit = DataPortal.CreateChild<FieldEdit>();
            var fieldVM = new ProcessFieldViewModel(fieldEdit, null);

            var vm = new ProcessFieldDocumentationStepViewModel(documentationStep, stepInfo, fieldVM);

            const string plainText = "plain text";
            const string richText = "rich text";

            documentationStep.UseRichText = false;
            documentationStep.Documentation = plainText;
            vm.UseRichText = true;
            documentationStep.Documentation = richText;
            vm.UseRichText = false;
            Assert.IsTrue(vm.Documentation.Equals(plainText));
            vm.Documentation = "Wrong text";
            vm.UseRichText = true;
            Assert.IsTrue(vm.Documentation.Equals(richText));
        }
 /// <summary>
 /// Initializes a new instance of the <see cref="FieldListChangedEvent"/> class.
 /// </summary>
 /// <param name="operation">The operation.</param>
 /// <param name="fieldVM">The field vm.</param>
 /// <param name="propertyName">The property name.</param>
 public FieldListChangedEvent(FieldOperation operation, ProcessFieldViewModel fieldVM, string propertyName = null)
 {
     Operation = operation;
     FieldViewModel = fieldVM;
     PropertyName = propertyName;
 }
        /// <summary>
        /// Moves the index of the field to.
        /// </summary>
        /// <param name="fieldVM">The field vm.</param>
        /// <param name="newIndex">The new index.</param>
        /// <exception cref="System.ArgumentException"></exception>
        internal void MoveFieldToIndex(ProcessFieldViewModel fieldVM, int newIndex)
        {
            if (newIndex < 0 || newIndex >= FieldList.Count) throw new ArgumentException(string.Format("New Index is out of range. Please specify index in range of 0..{0}", FieldList.Count - 1));
            var selectedField = SelectedField;

            FieldList.Remove(fieldVM);
            FieldList.Insert(newIndex, fieldVM);
            var field = Fields.FirstOrDefault(f => f.Model.SystemName == fieldVM.Model.SystemName);
            if (field != null)
            {
                Fields.Remove(field);
                Fields.Insert(newIndex, field);
            }

            //re-numerate field positions
            UpdateFieldPositions();

            SelectedField = selectedField;
        }
        public void RemoveField(ProcessFieldViewModel field, bool isSectionChanging = false)
        {
            FieldList.Remove(field);

            TheProcessFieldsViewModel.Model.SectionList.RemoveField(field.Model);

            var fldExp = Fields.FirstOrDefault(f => f.Model.Guid == field.Model.Guid);
            if (fldExp != null) Fields.Remove(fldExp);

            TheProcessFieldsViewModel.FieldList.Remove(field.Model.Guid);

            if (!isSectionChanging)
            {
                this.EventAggregator.Publish(new FieldListChangedEvent(FieldOperation.Removed, field));
            }

            RaisePropertyChanged(() => HaseBaseFieldsOnly);
        }
        public void FilterOptionsCommandShouldUpdatProcessFieldAfterPopupIsClosed()
        {
            var filter = Mock.Create<IFilterDescriptor>(Behavior.Loose);
            var stepEdit = DisplayListRequiredStepEdit.NewStep(1);
            stepEdit.SelectedFields = new DisplayListStepFields();

            var processFieldViewModel = new ProcessFieldViewModel(new FieldEdit(), new ProcessSectionViewModel(Mock.Create<ISectionEdit>()));

            var vm = new ProcessFieldDisplayListRequiredStepViewModel(stepEdit, new StepInfo(1), processFieldViewModel);

            Mock.Arrange(() => vm.GetProcessedFilter()).IgnoreInstance().Returns(Mock.Create<IFilterDescriptor>());

            var processEdit = Mock.Create<ProcessEdit>(Behavior.Loose);
            var fieldsViewModel = new ProcessFieldsViewModel { Model = processEdit };
            vm.Model = fieldsViewModel;

            var popupFactory = Mock.Create<PopupFactory>(Behavior.Loose);
            var popupBuilder = Mock.Create<PopupBuilder>(Behavior.CallOriginal);
            Mock.Arrange(() => popupFactory.Popup()).Returns(popupBuilder);
            Mock.Arrange(() => popupBuilder.Show(Arg.IsAny<Action>(), Arg.IsAny<Func<bool>>())).DoInstead((Action ok, Action cancel) => ok());
            vm.ThePopupFactory = popupFactory;

            var filterOptions = Mock.Create<FilterOptionsViewModel>(Behavior.Loose);
            vm.FilterOptionsVM = new Lazy<FilterOptionsViewModel>(() => filterOptions);

            var procField = new ProcessField("test", "test");
            filterOptions.IsProcessField = true;
            filterOptions.SelectedProcessField = procField;

            var filterValue = new FilterValue { Type = FilterValueType.ProcessField };
            Mock.Arrange(() => filter.Value).Returns(filterValue);

            vm.FilterOptionsCommand.Execute(filter);
            Assert.AreEqual("FLD: test", filterValue.ProvidedValue.ToString());

            Mock.Arrange(() => filter.Value).Returns((FilterValue)null);
            vm.FilterOptionsCommand.Execute(filter);
            Mock.AssertSet(() => filter.Value = Arg.IsAny<FilterValue>());
        }
        public void RemoveApprovalLevelCommand_Test()
        {
            var approvalStep = DataPortal.CreateChild<ApprovalOptionsStepEdit>();
            var stepInfo = Mock.Create<StepInfo>();
            var fieldEdit = DataPortal.CreateChild<FieldEdit>();
            var fieldVM = new ProcessFieldViewModel(fieldEdit, null);

            var level1 = DataPortal.CreateChild<ApprovalLevelDefinitionEdit>();
            var level2 = DataPortal.CreateChild<ApprovalLevelDefinitionEdit>();

            approvalStep.LevelDefinitions.Add(level1);
            approvalStep.LevelDefinitions.Add(level2);

            var levelViewModel1 = Mock.Create<IApprovalLevelDefinitionViewModel>();
            Mock.Arrange(() => levelViewModel1.Model).Returns(level1);

            var levelViewModel2 = Mock.Create<IApprovalLevelDefinitionViewModel>();
            Mock.Arrange(() => levelViewModel2.Model).Returns(level2);

            var vm = new ProcessFieldApprovalOptionsStepViewModel(approvalStep, stepInfo, fieldVM);
            vm.LevelDefinitions.Add(levelViewModel1);
            vm.LevelDefinitions.Add(levelViewModel2);

            Assert.IsFalse(vm.RemoveApprovalLevelCommand.CanExecute(null));
            Assert.IsTrue(vm.RemoveApprovalLevelCommand.CanExecute(levelViewModel2));

            vm.RemoveApprovalLevelCommand.Execute(levelViewModel2);

            Assert.AreEqual(1, vm.Data.LevelDefinitions.Count);
            Assert.IsFalse(vm.Data.LevelDefinitions.Contains(level2));
            Assert.IsFalse(vm.LevelDefinitions.Contains(levelViewModel2));
        }
        public void NewApprovalLevelCommand_Test()
        {
            var approvalStep = DataPortal.CreateChild<ApprovalOptionsStepEdit>();
            var stepInfo = Mock.Create<StepInfo>(Behavior.Loose);
            var fieldEdit = DataPortal.CreateChild<FieldEdit>();
            var fieldVM = new ProcessFieldViewModel(fieldEdit, null);

            var level1 = DataPortal.CreateChild<ApprovalLevelDefinitionEdit>();
            var level2 = DataPortal.CreateChild<ApprovalLevelDefinitionEdit>();

            approvalStep.LevelDefinitions.Add(level1);
            approvalStep.LevelDefinitions.Add(level2);

            var levelViewModel = Mock.Create<IApprovalLevelDefinitionViewModel>(Behavior.Loose);

            var levelViewModelFactory =
                new ExportFactory<IApprovalLevelDefinitionViewModel>(
                    () => new Tuple<IApprovalLevelDefinitionViewModel, Action>(levelViewModel, () => { }));

            var fieldsViewModel = Mock.Create<IProcessFieldsViewModel>(Behavior.Loose);

            var vm = new ProcessFieldApprovalOptionsStepViewModel(approvalStep, stepInfo, fieldVM) { LevelViewModelFactory = levelViewModelFactory, FieldsViewModel = fieldsViewModel };

            Assert.AreEqual(2, vm.Data.LevelDefinitions.Count);

            Assert.IsTrue(vm.NewApprovalLevelCommand.CanExecute(null));

            vm.NewApprovalLevelCommand.Execute(null);

            Assert.AreEqual(3, vm.Data.LevelDefinitions.Count);
            Assert.IsTrue(vm.LevelDefinitions.Contains(levelViewModel));
        }
        public void ShowInListChanged(ProcessFieldViewModel parentField)
        {
            if (!IsPersonLevelSecurity || parentField.ShowInList == false)
                return;

            foreach (var field in _config.FieldList.Where(field => field.FieldGuid == parentField.Model.Guid && field.CanView))
            {
                SetFieldSecurity(parentField.Model.Guid, false, null);

                _parent.ThePopupFactory.NotifyInfo("Person Level security has been turned off.");
            }
        }
        public void RemoveFieldDoNotPersistLayoutChangingIfTheFieldIsMovingToAnotherSection()
        {
            var section = new ProcessSectionViewModel(new SectionEdit()) { TheProcessFieldsViewModel = new ProcessFieldsViewModel { Model = Mock .Create<ProcessEdit>() } };
            var sectionList = new ProcessSections();
            var sectionFields = new ObservableCollection<ExpandableStepPropBag>();
            Mock.Arrange(() => section.Fields).Returns(sectionFields);
            Mock.Arrange(() => sectionList.RemoveField(Arg.IsAny<FieldEdit>())).DoNothing();
            Mock.Arrange(() => section.TheProcessFieldsViewModel.Model.SectionList).Returns(sectionList);
            var processFieldList = new Dictionary<Guid, Tuple<ProcessFieldViewModel, ExpandableStepPropBag>>();
            Mock.Arrange(() => section.TheProcessFieldsViewModel.FieldList).Returns(processFieldList);
            var field = new ProcessFieldViewModel(new FieldEdit(), section);

            var eventCalled = false;
            Mock.Arrange(() => section.EventAggregator.Publish(Arg.IsAny<FieldListChangedEvent>())).DoInstead(() => eventCalled = true);
            section.RemoveField(field);
            Assert.IsTrue(eventCalled);
            
            eventCalled = false;
            section.RemoveField(field, true);
            Assert.IsFalse(eventCalled);
        }
        public void FilterOptionsCommandShouldShowFilterOptionsPopup()
        {
            var filter = Mock.Create<IFilterDescriptor>(Behavior.Loose);
            var stepEdit = DisplayListRequiredStepEdit.NewStep(1);
            stepEdit.SelectedFields = new DisplayListStepFields();

            var processFieldViewModel = new ProcessFieldViewModel(new FieldEdit(), new ProcessSectionViewModel(Mock.Create<ISectionEdit>()));

            var vm = new ProcessFieldDisplayListRequiredStepViewModel(stepEdit, new StepInfo(1), processFieldViewModel);

            var processEdit = Mock.Create<ProcessEdit>(Behavior.Loose);
            var fieldsViewModel = new ProcessFieldsViewModel { Model = processEdit };
            vm.Model = fieldsViewModel;

            var popupFactory = Mock.Create<PopupFactory>(Behavior.Loose);
            var popupBuilder = Mock.Create<PopupBuilder>(Behavior.CallOriginal);
            Mock.Arrange(() => popupFactory.Popup()).Returns(popupBuilder);
            Mock.Arrange(() => popupBuilder.Show(Arg.IsAny<Action>(), Arg.IsAny<Func<bool>>())).DoNothing();
            vm.ThePopupFactory = popupFactory;

            var filterOptions = Mock.Create<FilterOptionsViewModel>(Behavior.Loose);
            vm.FilterOptionsVM = new Lazy<FilterOptionsViewModel>(() => filterOptions);
            vm.FilterOptionsCommand.Execute(filter);

            Assert.IsTrue(filterOptions.IsUdpEditMode);
            Assert.IsFalse(filterOptions.ShowUdPs);
            Assert.IsFalse(filterOptions.ShowProcessFields);

            Mock.Assert(() => filterOptions.CleanUp(), Occurs.Once());
            Mock.AssertSet(() => filterOptions.FilterDescriptor = filter, Occurs.Once());
        }
        public void PropertyIsEnabledWidth()
        {
            // arrange
            var commonStepEdit = DataPortal.CreateChild<CommonStepEdit>();
            var fieldTypeInfo = new FieldTypeInfo();
            var fieldEdit = DataPortal.CreateChild<FieldEdit>();
            fieldEdit.FieldType = fieldTypeInfo;
            var processFieldViewModel = new ProcessFieldViewModel(fieldEdit, null);
            var vm = new ProcessFieldCommonStepViewModel(commonStepEdit, new StepInfo(), processFieldViewModel);

            // act
            vm.IsEnabledWidth = false;

            // assert
            Assert.AreEqual(100, vm.Data.Width);

            // act
            vm.IsEnabledWidth = true;

            // assert
            Assert.AreEqual(50, vm.Data.Width);
        }
        [Ignore]//TODO: Unignore    
        public void PopulateFields_Test()
        {
            const int basePersonProcessId = 1;
            const int baseBusinessUnitProcessId = 2;
            const string personFieldName = "Person";
            const string buFieldName = "BusinessUnits";

            var basePersonProcessInfo = Mock.Create<PublishedProcessInfo>();

            Mock.Arrange(() => basePersonProcessInfo.Id).Returns(basePersonProcessId);
            Mock.Arrange(() => basePersonProcessInfo.SystemName).Returns(Constants.BasePersonProcessName);

            var baseBUProcessInfo = Mock.Create<PublishedProcessInfo>();

            Mock.Arrange(() => baseBUProcessInfo.Id).Returns(baseBusinessUnitProcessId);
            Mock.Arrange(() => baseBUProcessInfo.SystemName).Returns(Constants.BaseBusinessUnitProcessName);

            var crossRefStep = DataPortal.CreateChild<CrossRefRequiredStepEdit>();

            crossRefStep.CrossRefProcess = basePersonProcessInfo;

            var personField = DataPortal.CreateChild<FieldEdit>();

            personField.SystemName = personFieldName;
            personField.StepList.Add(crossRefStep);
            personField.FieldType = new FieldTypeInfoMock("Reference", "Reference");

            crossRefStep = DataPortal.CreateChild<CrossRefRequiredStepEdit>();

            crossRefStep.CrossRefProcess = baseBUProcessInfo;

            var buField = DataPortal.CreateChild<FieldEdit>();

            buField.SystemName = buFieldName;
            buField.StepList.Add(crossRefStep);
            buField.FieldType = new FieldTypeInfoMock("MultiReference", "MultiReference");

            var sectionEdit = DataPortal.CreateChild<SectionEdit>();

            sectionEdit.FieldList.Add(personField);
            sectionEdit.FieldList.Add(buField);

            var sectionList = new ProcessSections {sectionEdit};

            var processEditMock = Mock.Create<ProcessEdit>();

            Mock.Arrange(() => processEditMock.SectionList).Returns(sectionList);

            var uow = new ProcessEditRetrieverMock(processEditMock, new[] { basePersonProcessInfo, baseBUProcessInfo });

            var approvalStep = DataPortal.CreateChild<ApprovalOptionsStepEdit>();
            var stepInfo = Mock.Create<StepInfo>();
            var fieldEdit = DataPortal.CreateChild<FieldEdit>();
            var fieldVM = new ProcessFieldViewModel(fieldEdit, null);
            var fieldsVM = new ProcessFieldsViewModel { Model = processEditMock, UnitOfWork = uow };

            var vm = new ProcessFieldApprovalOptionsStepViewModel(approvalStep, stepInfo, fieldVM) { Model = fieldsVM };

            Assert.IsNotNull(vm.SortedLevels);
            Assert.IsNotNull(vm.Roles);
            Assert.IsNotNull(vm.ApprovalMembersFields);
            Assert.IsNotNull(vm.BusinessUnitFields);

            var eventAggregatorMock = Mock.Create<IEventAggregator>();

            vm.EventAggregator = eventAggregatorMock;

            var role1Mock = Mock.Create<IRoleInfo>();

            Mock.Arrange(() => role1Mock.Id).Returns(3);

            var role2Mock = Mock.Create<IRoleInfo>();

            Mock.Arrange(() => role2Mock.Id).Returns(5);

            var roles = new List<IRoleInfo> { role1Mock, role2Mock };

            var organizationInfoMock = Mock.Create<IOrganizationInfo>();

            Mock.Arrange(() => organizationInfoMock.Roles).Returns(roles);

            var processfieldsVMMock = Mock.Create<ProcessFieldsViewModel>();

            vm.OrganizationInfo = organizationInfoMock;
            vm.TheProcessFieldsVM = processfieldsVMMock;

            vm.OnImportsSatisfied();

            Assert.AreEqual(2, vm.ApprovalMembersFields.Count);
            Assert.IsTrue(vm.ApprovalMembersFields.Any(f => f.SystemName == personField.SystemName));

            Assert.AreEqual(2, vm.BusinessUnitFields.Count);
            Assert.IsTrue(vm.BusinessUnitFields.Any(f => f.SystemName == buField.SystemName));

            Assert.AreEqual(3, vm.Roles.Count);
            Assert.IsTrue(vm.Roles.Any(r => r.Id == role1Mock.Id));
            Assert.IsTrue(vm.Roles.Any(r => r.Id == role2Mock.Id));
        }