public void RefreshTest()
        {
            // Arrange.
            var windowManager = Mock.Create<IShell>(Behavior.Loose);
            var list = new InfoListBase { TotalRowCount = 100, PageNumber = 0 };
            PagedCriteria criteria = null;
            var dtm = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
            Mock.Arrange(() => dtm.GetListAsync<IInfoList>(Arg.IsAny<PagedCriteria>()))
                .DoInstead<PagedCriteria>(c => criteria = c)
                .Returns(TaskEx.FromResult<IInfoList>(list));

            var popupFactory = Mock.Create<PopupFactory>(Behavior.Loose);

            var viewModel = new IntegrationEventListViewModel
                            {
                                WindowManager = new Lazy<IShell>(() => windowManager),
                                TheDynamicTypeManager = new Lazy<IDynamicTypeManager>(() => dtm),
                                ThePopupFactory = new Lazy<PopupFactory>(() => popupFactory)
                            };

            // Act.
            viewModel.Refresh();
            
            // Assert.
            Assert.IsNotNull(criteria);
            Assert.AreEqual(Constants.IntegrationEventProcessName, criteria.ProcessName);
            Assert.AreEqual(0, criteria.PageNumber);
            Assert.AreEqual(25, criteria.PageSize);
            Assert.IsTrue(string.IsNullOrEmpty(criteria.Filter));
            Assert.IsTrue(string.IsNullOrEmpty(criteria.FilterDefinition));
            Assert.IsTrue(criteria.LimitResultColumns);
            Assert.IsNotNull(criteria.SortColumns);
            Assert.AreEqual(1, criteria.SortColumns.Count);
            Assert.AreEqual("TimeCreated", criteria.SortColumns[0].ColumnName);
            Assert.AreEqual(SortDirection.Descending, criteria.SortColumns[0].Direction);
            Assert.IsTrue(criteria.ResultColumns.Contains("Id"));
            Assert.IsTrue(criteria.ResultColumns.Contains("Process"));
            Assert.IsTrue(criteria.ResultColumns.Contains("Service"));
            Assert.IsTrue(criteria.ResultColumns.Contains("Username"));
            Assert.IsTrue(criteria.ResultColumns.Contains("TimeCreated"));
            Assert.IsTrue(criteria.ResultColumns.Contains("IsSuccessful"));

            Assert.AreEqual(100, viewModel.TotalRowCount);
            Assert.AreEqual(0, viewModel.PageIndex);
            Assert.AreSame(list, viewModel.Model);
        }
        public void CalculateNewValueWithChildMappings()
        {
            // Arrange.
            var dtm = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
            var updater = new SingleCrossReferenceFieldUpdater
                          {
                              FieldName = ReflectionHelper.GetPropertyName<TestEdit>(x => x.Person),
                              ReferencedProcessName = Constants.BasePersonProcessName,
                              DynamicTypeManager = dtm
                          };

            var sourceData = new DataTriggerSourceData();
            var destination = new TestEdit();
            
            var childUpdater1 = Mock.Create<IFieldUpdater>(Behavior.Loose);
            Mock.Arrange(() => childUpdater1.IsKey).Returns(true);

            var childUpdater2 = Mock.Create<IFieldUpdater>(Behavior.Loose);
            Mock.Arrange(() => childUpdater2.IsKey).Returns(false);

            updater.ChildMappings.Add(childUpdater1);
            updater.ChildMappings.Add(childUpdater2);

            var filter = Mock.Create<IFilterDescriptor>(Behavior.Loose);
            Mock.Arrange(() => childUpdater1.TryCreateFilter(sourceData, destination, out filter)).Returns(true);

            var infoItem = Mock.Create<IInfoClass>(Behavior.Loose);
            Mock.Arrange(() => infoItem.Id).Returns(123);
            var infoList = new InfoListBase { infoItem };

            Mock.Arrange(
                () => dtm.GetList<IInfoList>(Constants.BasePersonProcessName, string.Empty, 0, int.MaxValue, null, Arg.IsAny<FilterList>(), false))
                .Returns<string, string, int, int, SortList, FilterList, bool>(
                    (processName, filterString, pageNumber, pageSize, sortList, filterList, security) =>
                    {
                        if (filterList != null && filterList.Count == 1 && filterList.Contains(filter))
                            return infoList;

                        return null;
                    });

            // Act.
            updater.CalculateNewValue(sourceData, destination);

            // Assert.
            Assert.AreEqual(123, updater.NewValue);
        }