private void Client_FetchLineagesCompleted(object sender, DataPortalResult<ReadOnlyLineages> e)
{
fetchingLineages = false;
if (e.Error != null)
{
if (e.Error.InnerException != null)
throw e.Error.InnerException;
else
throw e.Error;
}
DataFetched = true;
Lineages = e.Object;
if (FetchLineagesCompleted != null)
FetchLineagesCompleted(this, e);
}
public void PropertiesGetSetTest()
{
var vm = new FrequencyFieldViewModel();
var property = Mock.Create<PropertyInfo>();
Mock.Arrange(() => property.Name).Returns("test");
var model = new EditModeMock();
var dvm = Mock.Create<IDetailsViewModel>();
var dtm = Mock.Create<IDynamicTypeManager>();
Mock.Arrange(
() =>
dtm.BeginGetList(
Constants.FilterProcessName,
Arg.IsAny<Action<object, DataPortalResult<IInfoList>>>(),
Arg.IsAny<SortList>(),
Arg.IsAny<int>(),
Arg.IsAny<string>(),
Arg.IsAny<int>(),
Arg.IsAny<string>(),
Arg.IsAny<string>(),
Arg.IsAny<IEnumerable<string>>()))
.DoInstead<string, Action<object, DataPortalResult<IInfoList>>, SortList, int, string, int, string, string, IEnumerable<string>>(
(process, callback, sortDescriptor, pageSize, filterString, pageNumber, filtersList, groupColumn, nonFilteredColumns) =>
{
var result = new DataPortalResult<IInfoList>(null, null, null);
callback(null, result);
});
vm.Property = property;
vm.DynamicTypeManager = dtm;
vm.Init(model, null, dvm);
TestsHelper.TestPublicPropertiesGetSet(vm, x=>vm.TypeFrequency, x=>vm.SelectedEvent, x=>vm.VisibilityRules);
}
private void HtmlContent_FetchCompleted(object sender, DataPortalResult<HtmlContent> e)
{
DataSource = e.Object;
IsBusy = false;
}
public void ExecuteResetLayoutTest()
{
var layoutViewModel = new Mock<LayoutViewModel>();
var layout = new LayoutViewModel();
var dtm = new Mock<IDynamicTypeManager>();
dtm.Setup(x => x.BeginGetList(Constants.FilterProcessName,
It.IsAny<Action<object, DataPortalResult<IFilterList>>>(),
It.IsAny<SortList>(),
It.IsAny<int>(),
It.IsAny<string>(),
It.IsAny<int>(),
It.IsAny<string>(),
It.IsAny<string>(),
It.IsAny<IEnumerable<string>>())).Callback
<string, Action<object, DataPortalResult<IFilterList>>, SortList, int, string, int, string, string, IEnumerable<string>>
((process, callback, sortDescriptor, pageSize, filterString, pageNumber, filtersList, groupColumn, nonFilteredColumns) =>
{
var result = new DataPortalResult<IFilterList>(new FilterListStub(), null, null);
callback(null, result);
});
var vm = new SearchViewModelTests.SearchViewModelTest(
"test", FilterType.ProcessFilter, "", "", QuickFilters.Filter1) { TheDynamicTypeManager = new Lazy<IDynamicTypeManager>(() => dtm.Object) };
vm.LayoutViewModel = new Lazy<LayoutViewModel>(() => layoutViewModel.Object);
vm.LayoutViewModel.Value.Model = vm;
layout.Model = vm;
layout.ResetLayoutCommand.Execute(null);
}
private void LineageGroups_FetchCompleted(object sender, DataPortalResult<ReadOnlyLineageGroups> e)
{
LineageGroupComboBox.DataContext = e.Object;
}
private void BranchFetchCompleted(DataPortalResult<ReadOnlyLineages> e)
{
myBusyAnimation.IsRunning = false;
DataSource = e.Object;
if (CurrentRootLineageId == 0)
CurrentRootLineageId = LookupRootLineageId();
//if there's no selected lineage and we're not looking at the home tree (the ultimate root), select the root
if (!SelectedLineageId.HasValue && CurrentRootLineage.ParentLineageId.HasValue)
SelectedLineageId = CurrentRootLineageId;
InitForRoot(CurrentRootLineageId);
}
public void WhenFileIncludeInCheckListFileNotFound()
{
// arrange
var vm = new FieldFileViewModel();
var fileProcess = Mock.Create<IFileProcess>(x => x.Implements<ITrackStatus>());
Mock.Arrange(() => ((ITrackStatus)fileProcess).IsChild).Returns(true);
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
var dynamicManager = Mock.Create<IDynamicTypeManager>();
var dataPortalResult = new DataPortalResult<IEditableRoot>(null, new Exception(), null);
Mock.Arrange(() => dynamicManager.BeginGetEditableRoot(Constants.FileProcessName, Arg.AnyInt, Arg.IsAny<Action<object, DataPortalResult<IEditableRoot>>>()))
.DoInstead<string, int, Action<object, DataPortalResult<IEditableRoot>>>((processName, id, callback) => callback(null, dataPortalResult));
vm.TheDynamicTypeManager = dynamicManager;
var logger = Mock.Create<ILogger>(Behavior.CallOriginal);
var wasLogged = false;
Mock.Arrange(() => logger.Log(LogSeverity.Error, typeof(FieldFileViewModel).FullName, Arg.IsAny<Exception>())).DoInstead(() => wasLogged = true);
vm.Logger = logger;
var privateAccessor = new PrivateAccessor(vm);
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.AreEqual("File not found", vm.Message);
Assert.AreEqual(new Exception().ToString(), privateAccessor.GetProperty("ExceptionMessage"));
Assert.AreEqual(FileControlMode.NotifyFail, vm.CurrentState);
Assert.IsTrue(wasLogged);
// arrange
vm.Message = null;
vm.CurrentState = FileControlMode.Download;
wasLogged = false;
dataPortalResult = new DataPortalResult<IEditableRoot>(Mock.Create<IEditableRoot>(Behavior.Loose), null, null);
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.AreEqual("File not found", vm.Message);
Assert.IsNull(privateAccessor.GetProperty("ExceptionMessage"));
Assert.AreEqual(FileControlMode.NotifyFail, vm.CurrentState);
Assert.IsTrue(wasLogged);
}
public void SelectTemplateFileCommand()
{
// arrange
var vm = new FieldFileViewModel
{
SelectedFileTemplateId = 1,
TemplateData = new FileProcessAttribute("eCar_p", "DoNotExistingPropertyName", null, null)
};
var parentModel = Mock.Create<IEditableRoot>(Behavior.Loose);
Mock.NonPublic.Arrange<IEditableRoot>(vm, "ParentModel").Returns(parentModel);
var dynamicManager = Mock.Create<IDynamicTypeManager>(Behavior.CallOriginal);
var dataPortalResult = new DataPortalResult<IEditableRoot>(null, new Exception(), null);
Mock.Arrange(() => dynamicManager.BeginGetEditableRoot(Arg.AnyString, 1, Arg.IsAny<Action<object, DataPortalResult<IEditableRoot>>>()))
.DoInstead<string, int, Action<object, DataPortalResult<IEditableRoot>>>((processName, id, callback) =>
callback(null, dataPortalResult));
vm.TheDynamicTypeManager = dynamicManager;
var logWasCalled = false;
var logger = Mock.Create<ILogger>(Behavior.CallOriginal);
Mock.Arrange(() => logger.Log(LogSeverity.Error, vm.GetType().FullName, Arg.IsAny<Exception>())).DoInstead(() => logWasCalled = true);
vm.Logger = logger;
// act
vm.SelectTemplateFileCommand.Execute(null);
// assert
Assert.AreEqual(LanguageService.Translate("Msg_TemplateNotFound"), vm.Message);
Assert.AreEqual(new Exception().ToString(), new PrivateAccessor(vm).GetProperty("ExceptionMessage"));
Assert.AreEqual(FileControlMode.NotifyFail, vm.CurrentState);
Assert.IsTrue(logWasCalled);
// arrange
vm.Message = null;
vm.CurrentState = FileControlMode.Download;
logWasCalled = false;
var editableRoot = Mock.Create<IEditableRoot>(Behavior.CallOriginal);
dataPortalResult = new DataPortalResult<IEditableRoot>(editableRoot, null, null);
// act
vm.SelectTemplateFileCommand.Execute(null);
// assert
Assert.AreEqual(LanguageService.Translate("Msg_TemplateNotFound"), vm.Message);
Assert.AreEqual(FileControlMode.NotifyFail, vm.CurrentState);
Assert.IsFalse(logWasCalled);
// arrange
var currentFileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
currentFileProcess.Locked = true;
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(currentFileProcess);
var templateFileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
templateFileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.txt";
templateFileProcess.OriginalFileName = "1.txt";
Mock.Arrange(() => editableRoot.GetValueByPropertyName(Arg.IsAny<string>())).Returns(templateFileProcess);
var navigateUriWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "NavigateUri").DoInstead(() => { navigateUriWasRaises = true; });
var templateWasSelectedMessageWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "TemplateWasSelectedMessage").DoInstead(() => { templateWasSelectedMessageWasRaises = true; });
// act
vm.SelectTemplateFileCommand.Execute(null);
// act
Assert.AreEqual("603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.txt", currentFileProcess.FileName);
Assert.AreEqual("1.txt", currentFileProcess.OriginalFileName);
Assert.IsFalse(currentFileProcess.Locked.Value);
Assert.AreEqual(FileControlMode.TemplateWasSelected, vm.CurrentState);
Assert.IsTrue(navigateUriWasRaises);
Assert.IsTrue(templateWasSelectedMessageWasRaises);
}
public void LockCommand()
{
// arrange
var vm = new FieldFileViewModel();
var value = Mock.Create<IFileProcess>(Behavior.CallOriginal);
var dataPortalResult = new DataPortalResult<IEditableRoot>(value, null, null);
var fileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
Mock.Arrange(() => fileProcess.BeginLock(Arg.IsAny<Action<object, IDataPortalResult>>()))
.DoInstead<Action<object, IDataPortalResult>>(a => a(null, dataPortalResult));
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
var parentModel = Mock.Create<IEditableRoot>(Behavior.Loose);
Mock.NonPublic.Arrange<IEditableRoot>(vm, "ParentModel").Returns(parentModel);
// act
vm.LockCommand.Execute(null);
// assert
Assert.AreEqual(value, vm.Value);
Assert.AreEqual(FileControlMode.SaveFile, vm.CurrentState);
// arrange
dataPortalResult = new DataPortalResult<IEditableRoot>(null, new Exception(), null);
var logger = Mock.Create<ILogger>(Behavior.CallOriginal);
var logWasCalled = false;
Mock.Arrange(() => logger.Log(LogSeverity.Error, typeof(FieldFileViewModel).FullName, Arg.IsAny<Exception>())).DoInstead(() => logWasCalled = true);
vm.Logger = logger;
// act
vm.LockCommand.Execute(null);
// assert
Assert.IsTrue(logWasCalled);
}
public void OnChecklistInfoLoaded_SetDataProcessName_MethodTest()
{
//Mock step edit
var stepEditMock = Mock.Create<GageRROptionsStepEdit>(Behavior.CallOriginal);
//Create view model
var vm = new GageRROptionsStepViewModel(stepEditMock, null, null);
var vmPrivateAccessor = new PrivateAccessor(vm);
//Arrange
var fieldInfoMock = Mock.Create<ChecklistFieldInfo>(Behavior.Loose);
Mock.Arrange(() => fieldInfoMock.CrossRefProcessSystemName).Returns("AnswerProcessSysName");
var result = new DataPortalResult<ChecklistFieldInfo>(fieldInfoMock, null, null);
var processInfoMock = Mock.Create<PublishedProcessInfo>(Behavior.Loose);
Mock.Arrange(() => processInfoMock.SystemName).Returns("AnswerProcessSysName");
Mock.Arrange(() => vm.AvailableProcesses).Returns(new List<PublishedProcessInfo> { processInfoMock });
Mock.NonPublic.Arrange(vm, "SetupAnswerProcess", ArgExpr.IsAny<int>()).DoNothing().OccursOnce();
Mock.NonPublic.Arrange(vm, "LoadAnswerProcessFilters", ArgExpr.IsAny<int>()).DoNothing().OccursOnce();
//Act: Call OnChecklistInfoLoaded method
vmPrivateAccessor.CallMethod("OnChecklistInfoLoaded", result);
//Assert
Assert.AreEqual("AnswerProcessSysName", vm.Data.GageRRDataProcessSysName);
Mock.NonPublic.Assert(vm, "SetupAnswerProcess", ArgExpr.IsAny<int>());
Mock.NonPublic.Assert(vm, "LoadAnswerProcessFilters", ArgExpr.IsAny<int>());
}
public void OnAnswerProcessFieldsRetrieved_Filtering_MethodTest()
{
//Mock step edit
var stepEditMock = Mock.Create<GageRROptionsStepEdit>(Behavior.CallOriginal);
//Create view model
var vm = new GageRROptionsStepViewModel(stepEditMock, null, null);
var vmPrivateAccessor = new PrivateAccessor(vm);
//Arrange
var fieldTypeInfo1 = Mock.Create<FieldTypeInfo>(Behavior.Loose);
Mock.Arrange(() => fieldTypeInfo1.ColumnType).Returns(ColumnTypes.Sample);
var field1 = Mock.Create<FieldInfo>(Behavior.Loose);
Mock.Arrange(() => field1.FieldType).Returns(fieldTypeInfo1);
var fieldTypeInfo2 = Mock.Create<FieldTypeInfo>(Behavior.Loose);
Mock.Arrange(() => fieldTypeInfo2.ColumnType).Returns(ColumnTypes.String);
var field2 = Mock.Create<FieldInfo>(Behavior.Loose);
Mock.Arrange(() => field2.FieldType).Returns(fieldTypeInfo2);
var fieldTypeInfo3 = Mock.Create<FieldTypeInfo>(Behavior.Loose);
Mock.Arrange(() => fieldTypeInfo3.ColumnType).Returns(ColumnTypes.Integer);
var field3 = Mock.Create<FieldInfo>(Behavior.Loose);
Mock.Arrange(() => field3.FieldType).Returns(fieldTypeInfo3);
var result = new DataPortalResult<FieldList>(null, null, null);
Mock.Arrange(() => result.Object).ReturnsCollection(new List<FieldInfo> { field1, field2, field3 });
//var viewMock = Mock.Create<ICollectionView>();
//Mock.Arrange(() => viewMock.Refresh()).IgnoreInstance().DoNothing().MustBeCalled();
//Act: Call OnAnswerProcessFieldsRetrieved method
vmPrivateAccessor.CallMethod("OnAnswerProcessFieldsRetrieved", result);
//Assert
Assert.IsNotNull(vm.AnswerProcessAvailableFields);
Assert.AreEqual(3, vm.AnswerProcessAvailableFields.Count);
var view = vm.AnswerProcessSampleFields.View;
Assert.AreEqual(1, view.CountItems());
view.MoveCurrentToFirst();
Assert.AreEqual(ColumnTypes.Sample, ((FieldInfo)view.CurrentItem).FieldType.ColumnType);
view = vm.AnswerProcessTextFields.View;
Assert.AreEqual(1, view.CountItems());
view.MoveCurrentToFirst();
Assert.AreEqual(ColumnTypes.String, ((FieldInfo)view.CurrentItem).FieldType.ColumnType);
view = vm.AnswerProcessNumericFields.View;
Assert.AreEqual(1, view.CountItems());
view.MoveCurrentToFirst();
Assert.AreEqual(ColumnTypes.Integer, ((FieldInfo)view.CurrentItem).FieldType.ColumnType);
//Mock.Assert(() => viewMock.Refresh(), Occurs.Exactly(2));
}
public void OnAnswerProcessFieldsRetrieved_FieldValidationFailed_MethodTest()
{
//Mock step edit
var stepEditMock = Mock.Create<GageRROptionsStepEdit>(Behavior.CallOriginal);
//Create view model
var vm = new GageRROptionsStepViewModel(stepEditMock, null, null);
var vmPrivateAccessor = new PrivateAccessor(vm);
//Arrange
var field1 = Mock.Create<FieldInfo>(Behavior.Loose);
Mock.Arrange(() => field1.ColumnType).Returns(ColumnTypes.SPCChart);
var field2 = Mock.Create<FieldInfo>(Behavior.Loose);
Mock.Arrange(() => field2.ColumnType).Returns(ColumnTypes.Reference);
var result = new DataPortalResult<FieldList>(null, null, null);
Mock.Arrange(() => result.Object).ReturnsCollection(new List<FieldInfo> { field1, field2 });
//var viewMock = Mock.Create<ICollectionView>();
//Mock.Arrange(() => viewMock.Refresh()).IgnoreInstance().DoNothing().MustBeCalled();
//Act: Call OnAnswerProcessFieldsRetrieved method
vmPrivateAccessor.CallMethod("OnAnswerProcessFieldsRetrieved", result);
//Assert
Assert.IsNotNull(vm.AnswerProcessAvailableFields);
Assert.AreEqual(0, vm.AnswerProcessAvailableFields.Count);
Assert.AreEqual(
vm.AnswerProcessAvailableFields,
((CollectionViewSource)vmPrivateAccessor.GetField("_answerProcessSampleFields")).Source);
Assert.AreEqual(
vm.AnswerProcessAvailableFields,
((CollectionViewSource)vmPrivateAccessor.GetField("_answerProcessTextFields")).Source);
Assert.AreEqual(
vm.AnswerProcessAvailableFields,
((CollectionViewSource)vmPrivateAccessor.GetField("_answerProcessNumericFields")).Source);
//Mock.Assert(() => viewMock.Refresh(), Occurs.Once());
}
public void OnFieldListLoaded_Filtering_MethodTest()
{
//Mock step edit
var stepEditMock = Mock.Create<GageRROptionsStepEdit>(Behavior.CallOriginal);
//Create view model
var vm = new GageRROptionsStepViewModel(stepEditMock, null, null);
var vmPrivateAccessor = new PrivateAccessor(vm);
//Arrange
var fieldTypeInfo1 = Mock.Create<FieldTypeInfo>(Behavior.Loose);
Mock.Arrange(() => fieldTypeInfo1.ColumnType).Returns(ColumnTypes.Numeric);
var field1 = Mock.Create<FieldInfo>(Behavior.Loose);
Mock.Arrange(() => field1.FieldType).Returns(fieldTypeInfo1);
var fieldTypeInfo2 = Mock.Create<FieldTypeInfo>(Behavior.Loose);
Mock.Arrange(() => fieldTypeInfo2.ColumnType).Returns(ColumnTypes.Checklist);
var field2 = Mock.Create<FieldInfo>(Behavior.Loose);
Mock.Arrange(() => field2.FieldType).Returns(fieldTypeInfo2);
var result = new DataPortalResult<FieldList>(null, null, null);
Mock.Arrange(() => result.Object).ReturnsCollection(new List<FieldInfo> { field1, field2 });
//var viewMock = Mock.Create<ICollectionView>();
//Mock.Arrange(() => viewMock.Refresh()).IgnoreInstance().DoNothing().MustBeCalled();
//Act: Call OnFieldListLoaded method
//SelectedChecklistField remains unset
vmPrivateAccessor.CallMethod("OnFieldListLoaded", result);
//Assert
Assert.IsNotNull(vm.SelectedProcessAvailableFields);
Assert.AreEqual(2, vm.SelectedProcessAvailableFields.Count);
Assert.AreEqual(
vm.SelectedProcessAvailableFields,
((CollectionViewSource)vmPrivateAccessor.GetField("_selectedProcessChecklistFields")).Source);
var view = vm.SelectedProcessChecklistFields.View;
Assert.AreEqual(1, view.CountItems());
view.MoveCurrentToFirst();
Assert.AreEqual(ColumnTypes.Checklist, ((FieldInfo)view.CurrentItem).FieldType.ColumnType);
Assert.IsNull(vm.SelectedChecklistField);
//Arrange
Mock.Arrange(() => field2.SystemName).Returns("ChecklistFieldSystemName");
vm.Data.ChecklistFieldName = "ChecklistFieldSystemName";
//Act: Call OnFieldListLoaded method
//SelectedChecklistField gets the value
vmPrivateAccessor.CallMethod("OnFieldListLoaded", result);
//Assert
Assert.IsNotNull(vm.SelectedChecklistField);
Assert.AreEqual(field2, vm.SelectedChecklistField);
//Mock.Assert(() => viewMock.Refresh(), Occurs.Exactly(2));
}
private void OnFieldRemoved(DataPortalResult<AllowFieldRemoveCommand> e)
{
this.ThePopupFactory.HidePopup();
if (e.Error == null)
{
if (string.IsNullOrEmpty(e.Object.DependendProcesses))
{
this.RemoveField(this.SelectedField);
this.RaisePropertyChanged(() => this.HaseBaseFieldsOnly);
}
else
{
var message = string.Format(LanguageService.Translate("Msg_FieldInUse"), this.SelectedField.Name, Environment.NewLine, e.Object.DependendProcesses);
this.ThePopupFactory.Popup().SetPosition(PopupPosition.Center).Message(message).SetCaption(LanguageService.Translate("Msg_Warning")).SetIsModal(true).Show();
}
}
else
{
this.ThePopupFactory.NotifyFailure(e.Error.Message, LanguageService.Translate("Popup_Error"), 5);
}
}
private void FetchComplete(object sender, DataPortalResult<ChildList> result)
{
this.DataContext = result.Object;
// BindDetails();
}
/// <summary>
/// Called by <see cref="DataPortal" /> to create a
/// new business object.
/// </summary>
/// <param name="objectType">Type of business object to create.</param>
/// <param name="criteria">Criteria object describing business object.</param>
/// <param name="context">
/// <see cref="Server.DataPortalContext" /> object passed to the server.
/// </param>
/// <param name="isSync">True if the client-side proxy should synchronously invoke the server.</param>
public async Task <DataPortalResult> Create(Type objectType, object criteria, DataPortalContext context, bool isSync)
{
#if !SILVERLIGHT && !NETFX_CORE
ChannelFactory <IWcfPortal> cf = GetChannelFactory();
var proxy = GetProxy(cf);
WcfResponse response = null;
#if NET40
try
{
var request = new CreateRequest(objectType, criteria, context);
if (isSync)
{
response = proxy.Create(request);
}
else
{
var worker = new Csla.Threading.BackgroundWorker();
var tcs = new TaskCompletionSource <WcfResponse>();
worker.RunWorkerCompleted += (o, e) =>
{
tcs.SetResult((WcfResponse)e.Result);
};
worker.DoWork += (o, e) =>
{
e.Result = proxy.Create(request);
};
worker.RunWorkerAsync();
response = await tcs.Task;
}
if (cf != null)
{
cf.Close();
}
object result = response.Result;
if (result is Exception)
{
throw (Exception)result;
}
return((DataPortalResult)result);
}
catch
{
cf.Abort();
throw;
}
#else
try
{
var request = new CreateRequest(objectType, criteria, context);
if (isSync)
{
response = proxy.Create(request);
}
else
{
response = await proxy.CreateAsync(request);
}
if (cf != null)
{
cf.Close();
}
}
catch
{
cf.Abort();
throw;
}
object result = response.Result;
if (result is Exception)
{
throw (Exception)result;
}
return((DataPortalResult)result);
#endif
#else
var request = GetBaseCriteriaRequest();
request.TypeName = objectType.AssemblyQualifiedName;
if (!(criteria is IMobileObject))
{
criteria = new PrimitiveCriteria(criteria);
}
request.CriteriaData = MobileFormatter.Serialize(criteria);
request = ConvertRequest(request);
var proxy = GetProxy();
DataPortalResult result = null;
#if !NETFX_CORE
var tcs = new TaskCompletionSource <DataPortalResult>();
proxy.CreateCompleted += (s, e) =>
{
try
{
Csla.WcfPortal.WcfResponse response = null;
if (e.Error == null)
{
response = ConvertResponse(e.Result);
}
ContextDictionary globalContext = null;
if (response != null)
{
globalContext = (ContextDictionary)MobileFormatter.Deserialize(response.GlobalContext);
}
if (e.Error == null && response != null && response.ErrorData == null)
{
var obj = MobileFormatter.Deserialize(response.ObjectData);
result = new DataPortalResult(obj, null, globalContext);
}
else if (response != null && response.ErrorData != null)
{
var ex = new DataPortalException(response.ErrorData);
result = new DataPortalResult(null, ex, globalContext);
}
else
{
result = new DataPortalResult(null, e.Error, globalContext);
}
}
catch (Exception ex)
{
result = new DataPortalResult(null, ex, null);
}
finally
{
tcs.SetResult(result);
}
};
proxy.CreateAsync(request);
var finalresult = await tcs.Task;
if (finalresult.Error != null)
{
throw finalresult.Error;
}
return(finalresult);
#else
try
{
var response = await proxy.CreateAsync(request);
response = ConvertResponse(response);
if (response == null)
{
throw new DataPortalException("null response", null);
}
var globalContext = (ContextDictionary)MobileFormatter.Deserialize(response.GlobalContext);
if (response.ErrorData == null)
{
var obj = MobileFormatter.Deserialize(response.ObjectData);
result = new DataPortalResult(obj, null, globalContext);
}
else
{
var ex = new DataPortalException(response.ErrorData);
result = new DataPortalResult(null, ex, globalContext);
}
}
catch (Exception ex)
{
result = new DataPortalResult(null, ex, null);
}
if (result.Error != null)
{
throw result.Error;
}
return(result);
#endif
#endif
}
public void OnRefreshed()
{
// arrange
var vm = new CalendarDetailsViewModel();
var unitOfWork = Mock.Create<IUnitOfWork<ICalendar>>(Behavior.Loose);
var calendar = Mock.Create<ICalendar>(Behavior.Loose);
var interval = Mock.Create<ICalendarWorkingInterval>(Behavior.Loose);
interval.Weekday = DayOfWeek.Friday.ToString();
var intervalList = new List<ICalendarWorkingInterval> { interval };
Mock.Arrange(() => calendar.WorkingIntervals).Returns(intervalList);
Mock.Arrange(() => unitOfWork.Model).Returns(calendar);
var dataportalResult = new DataPortalResult<IUnitOfWork<ICalendar>>(unitOfWork, null, null);
var shell = Mock.Create<IShell>(Behavior.CallOriginal);
var baseMethodWasCalled = false;
Mock.Arrange(() => shell.ShowStatus(Arg.IsAny<Status>(), false)).DoInstead(() => baseMethodWasCalled = true);
vm.WindowManager = new Lazy<IShell>(() => shell);
// act
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.CallMethod("OnRefreshed", new object[] { null, dataportalResult });
// assert
Assert.AreEqual(DayOfWeek.Friday, vm.SelectedDayOfWeek);
CollectionAssert.AreEqual(intervalList, (List<ICalendarWorkingInterval>)vm.WorkingIntervals.Source);
Assert.IsTrue(baseMethodWasCalled);
// arrange
baseMethodWasCalled = false;
Mock.Arrange(() => calendar.IsNew).Returns(true);
((IList<ICalendarWorkingInterval>)vm.WorkingIntervals.Source).Clear();
// act
privateAccessor.CallMethod("OnRefreshed", new object[] { null, dataportalResult });
// assert
Assert.AreEqual(DayOfWeek.Sunday, vm.SelectedDayOfWeek);
CollectionAssert.AreEqual(intervalList, (List<ICalendarWorkingInterval>)vm.WorkingIntervals.Source);
Assert.IsTrue(baseMethodWasCalled);
// arrange
baseMethodWasCalled = false;
dataportalResult = new DataPortalResult<IUnitOfWork<ICalendar>>(null, new Exception(), null);
var loggerWasCalled = false;
var logger = new ClientLogger();
Mock.Arrange(() => logger.Log(LogSeverity.Error, typeof(CalendarDetailsViewModel).ToString(), Arg.IsAny<Exception>())).DoInstead(() => loggerWasCalled = true);
vm.Logger = logger;
var popupMock = PopupMock.Create().NotifyFailureMustBeCalled(Arg.IsAny<Exception>());
vm.ThePopupFactory = popupMock.TheLazyPopupFactory;
// act
privateAccessor.CallMethod("OnRefreshed", new object[] { null, dataportalResult });
// assert
Assert.IsTrue(loggerWasCalled);
popupMock.AssertNotifyFailureCalled();
Assert.IsTrue(baseMethodWasCalled);
}
public void MoveCurrentTo()
{
var vm = GetNewSearchListVm();
IInfoList iInfoList = new DetailsViewModelTests.InfoList();
var result = new DataPortalResult<IInfoList>(iInfoList, null, null);
var list = new CollectionViewSource { Source = result.Object };
var collectionView = list.View;
Mock.Arrange(() => vm.InfoListViewSource).Returns(collectionView);
var infoClass0 = Mock.Create<IInfoClass>();
var infoClass1 = Mock.Create<IInfoClass>();
var infoClass2 = Mock.Create<IInfoClass>();
Mock.Arrange(() => infoClass0.Id).Returns(0);
Mock.Arrange(() => infoClass1.Id).Returns(1);
Mock.Arrange(() => infoClass2.Id).Returns(2);
var infoList = new List<IInfoClass>
{
infoClass0,
infoClass1,
infoClass2
};
Mock.Arrange(() => collectionView.SourceCollection).Returns(infoList);
collectionView.Refresh();
vm.MoveCurrentTo(0);
Assert.AreEqual(0, vm.CurrentPosition);
vm.MoveCurrentTo(1);
Assert.AreEqual(1, vm.CurrentPosition);
vm.MoveCurrentTo(2);
Assert.AreEqual(2, vm.CurrentPosition);
}
public void UnlockCommand()
{
// arrange
var vm = new FieldFileViewModel();
var value = Mock.Create<IFileProcess>(Behavior.Loose);
var dataPortalResult = new DataPortalResult<IEditableRoot>(value, null, null);
var fileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
Mock.Arrange(() => fileProcess.BeginUnlock(Arg.IsAny<Action<object, IDataPortalResult>>()))
.DoInstead<Action<object, IDataPortalResult>>(a => a(null, dataPortalResult));
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
var parentModel = Mock.Create<IEditableRoot>(Behavior.Loose);
Mock.NonPublic.Arrange<IEditableRoot>(vm, "ParentModel").Returns(parentModel);
// act
vm.UnlockCommand.Execute(null);
// assert
Assert.AreEqual(value, vm.Value);
Assert.AreEqual(FileControlMode.Unlocked, vm.CurrentState);
}
public void GetNextItemAndGetPreviousItem()
{
var vm = GetNewSearchListVm();
IInfoList iInfoList = new DetailsViewModelTests.InfoList();
var result = new DataPortalResult<IInfoList>(iInfoList, null, null);
var list = new CollectionViewSource { Source = result.Object };
var collectionView = list.View;
Mock.Arrange(() => vm.InfoListViewSource).Returns(collectionView);
vm.TotalRowCount = 3;
var infoClass0 = Mock.Create<IInfoClass>();
var infoClass1 = Mock.Create<IInfoClass>();
var infoClass2 = Mock.Create<IInfoClass>();
Mock.Arrange(() => infoClass0.Id).Returns(0);
Mock.Arrange(() => infoClass1.Id).Returns(1);
Mock.Arrange(() => infoClass2.Id).Returns(2);
var infoList = new List<IInfoClass>
{
infoClass0,
infoClass1,
infoClass2
};
Mock.Arrange(() => collectionView.SourceCollection).Returns(infoList);
Mock.Arrange(() => vm.GoToDetails()).DoNothing();
collectionView.Refresh();
vm.SelectedItem = infoClass0;
vm.MoveNextItem();
Assert.AreEqual(infoClass1, vm.SelectedItem);
vm.MoveNextItem();
Assert.AreEqual(infoClass2, vm.SelectedItem);
vm.MoveNextItem();
Assert.AreEqual(infoClass2, vm.SelectedItem);
vm.MovePrevItem();
Assert.AreEqual(infoClass1, vm.SelectedItem);
vm.MovePrevItem();
Assert.AreEqual(infoClass0, vm.SelectedItem);
vm.MovePrevItem();
Assert.AreEqual(infoClass0, vm.SelectedItem);
}
public void Save()
{
// arrange
var vm = new FieldFileViewModel();
var fileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
fileProcess.OriginalFileName = "1.txt";
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
var newValue = Mock.Create<IFileProcess>(Behavior.Loose);
var dataPortalResult = new DataPortalResult<IFileProcess>(newValue, null, null);
Mock.Arrange(() => fileProcess.BeginSaveNew(Arg.IsAny<Action<object, IDataPortalResult>>()))
.DoInstead<Action<object, IDataPortalResult>>(a => a(null, dataPortalResult));
var privateAccessor = new PrivateAccessor(vm);
// act
privateAccessor.CallMethod("Save");
// assert
Assert.AreEqual(newValue, vm.Value);
Assert.AreEqual("File '1.txt' uploaded successfully.", vm.Message);
Assert.AreEqual(FileControlMode.NotifySuccess, privateAccessor.GetField("_previousState"));
// arrange
dataPortalResult = new DataPortalResult<IFileProcess>(null, new Exception(), null);
// act
privateAccessor.CallMethod("Save");
// assert
Assert.AreEqual("Error uploading file.", vm.Message);
Assert.AreEqual(new Exception().ToString(), privateAccessor.GetProperty("ExceptionMessage"));
Assert.AreEqual(FileControlMode.NotifyFail, privateAccessor.GetField("_previousState"));
// arrange
fileProcess.Id = 1;
vm.Value = null;
dataPortalResult = new DataPortalResult<IFileProcess>(newValue, null, null);
Mock.Arrange(() => fileProcess.BeginUnlock(Arg.IsAny<Action<object, IDataPortalResult>>()))
.DoInstead<Action<object, IDataPortalResult>>(a => a(null, dataPortalResult));
// act
privateAccessor.CallMethod("Save");
// assert
Assert.AreEqual(newValue, vm.Value);
Assert.AreEqual("File '1.txt' uploaded successfully.", vm.Message);
Assert.AreEqual(FileControlMode.NotifySuccess, vm.CurrentState);
// arrange
vm.Message = null;
privateAccessor.SetProperty("ExceptionMessage", null);
dataPortalResult = new DataPortalResult<IFileProcess>(null, new Exception(), null);
var logger = Mock.Create<ILogger>(Behavior.CallOriginal);
var logWasCalled = false;
Mock.Arrange(() => logger.Log(LogSeverity.Error, typeof(FieldFileViewModel).ToString(), Arg.IsAny<Exception>())).DoInstead(() => logWasCalled = true);
vm.Logger = logger;
// act
privateAccessor.CallMethod("Save");
// assert
Assert.AreEqual(string.Format(@"Error saving instance of new uploaded file{0}Please try again{0}If the problem persists, try to create a new record, and re-check the System Options\System Paths", Environment.NewLine), vm.Message);
Assert.AreEqual(new Exception().ToString(), privateAccessor.GetProperty("ExceptionMessage"));
Assert.AreEqual(FileControlMode.NotifyFail, vm.CurrentState);
Assert.IsTrue(logWasCalled);
}
private void Callback(object sender, DataPortalResult<SendEmailCommand> e)
{
if (e.Error != null)
ThePopupFactory.NotifyFailure(e.Error);
else
ThePopupFactory.NotifySuccess("Connection successful!");
}
public void TemplateState()
{
// arrange
var vm = new FieldFileViewModel
{
TemplateData = new FileProcessAttribute("eCar_p", "DocumentType_f", "92EC314E-B4E2-4738-B965-21A363C12BC8", @"{
""FilterGuid"": ""3732f424-216c-4fab-a2dc-a50c405512c3"",
""TimeStamp"": ""09/20/2013 15:05:08"",
""Version"": ""100.1"",
""Body"": {
""ColumnName"": ""Notes_f"",
""Operator"": ""IsEqualTo"",
""Value"": ""%{\""Type\"":\""Udp\"",\""DisplayName\"":\""Value for Notes:\"",\""SystemName\"":\""Notes_f\"",\""DefaultValue\"":\""\""}%"",
""MemberType"": ""System.String""
}
}")
};
var fileProcess = Mock.Create<IFileProcess>(x => x.Implements<ITrackStatus>());
Mock.Arrange(() => fileProcess.IsNew).Returns(true);
fileProcess.Locked = true;
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
var dynamicManager = Mock.Create<IDynamicTypeManager>(Behavior.Loose);
var dataPortalResult = new DataPortalResult<IInfoList>(null, new Exception(), null);
Mock.Arrange(() => dynamicManager.BeginGetList(Arg.AnyString, Arg.IsAny<Action<object, DataPortalResult<IInfoList>>>(), Arg.IsAny<SortList>(), Arg.AnyInt, Arg.AnyString, Arg.AnyInt, Arg.AnyString, Arg.AnyString, Arg.IsAny<IEnumerable<string>>()))
.DoInstead<string, Action<object, DataPortalResult<IInfoList>>, SortList, int, string, int, string, string, IEnumerable<string>>(
(processSystemName, callback, sortList, pageSize, filterString, pageNumber, groupColumn, filterExpression, noFilteredColumns) => callback(null, dataPortalResult));
vm.TheDynamicTypeManager = dynamicManager;
var privateAccessor = new PrivateAccessor(vm);
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.AreEqual(LanguageService.Translate("Msg_TemplateNotFound"), vm.Message);
Assert.AreEqual(FileControlMode.NotifyFail, vm.CurrentState);
// arrange
dataPortalResult = new DataPortalResult<IInfoList>(new CustomInfoList(), null, null);
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.IsNotNull(vm.TemplateList);
Assert.AreEqual(FileControlMode.LoadTemplate, vm.CurrentState);
// arrange
vm.TemplateList = null;
vm.CurrentState = FileControlMode.Download;
vm.TemplateData = new FileProcessAttribute("eCar_p", "DocumentType_f", null, null);
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.IsNotNull(vm.TemplateList);
Assert.AreEqual(FileControlMode.LoadTemplate, vm.CurrentState);
// arrange
vm.TemplateList = null;
vm.CurrentState = FileControlMode.Download;
vm.TemplateData = new FileProcessAttribute("eCar_p", "DocumentType_f", "CC5899F0-015C-4666-8F18-EFF073D99DE5", null);
Mock.Arrange(() => dynamicManager.GetFilterInfoType(Arg.AnyString)).Returns((Type)null);
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.IsNotNull(vm.TemplateList);
Assert.AreEqual(FileControlMode.LoadTemplate, vm.CurrentState);
// arrange
vm.TemplateList = null;
vm.CurrentState = FileControlMode.Download;
Mock.Arrange(() => dynamicManager.GetFilterInfoType(Arg.AnyString)).Returns(new InfoList().GetType());
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.IsNotNull(vm.TemplateList);
Assert.AreEqual(FileControlMode.LoadTemplate, vm.CurrentState);
// arrange
vm.TemplateList = null;
vm.CurrentState = FileControlMode.Download;
InfoList.FilterList = new Filter[1];
InfoList.FilterList[0] = new Filter("Only Approved Items", Guid.NewGuid(), string.Empty);
var parentModel = Mock.Create<IModel>(Behavior.Loose);
Mock.Arrange(() => parentModel.CanWriteProperty(Arg.AnyString)).Returns(true);
Mock.Arrange(() => vm.ParentModel).Returns(parentModel);
vm.Property = ReflectionHelper.GetProperty<IModel>(x => x.File);
Mock.Arrange(() => dynamicManager.GetFilterInfoType(Arg.AnyString)).Returns(new InfoList().GetType());
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.IsNull(vm.TemplateList);
Assert.AreNotEqual(FileControlMode.LoadTemplate, vm.CurrentState);
// arrange
InfoList.FilterList[0] = new Filter("Only Approved Items", Guid.Parse("CC5899F0-015C-4666-8F18-EFF073D99DE5"), string.Empty);
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.IsNotNull(vm.TemplateList);
Assert.AreEqual(FileControlMode.LoadTemplate, vm.CurrentState);
}
public void AcknowledgeCollapseTest()
{
var actionManagerVM = Mock.Create<ActionManagerViewModel>();
var actionItemInfo = new ActionItemInfo(
123,
"ProcessName",
"7FA27365-AF0A-4F98-A927-368D21A8175A",
321,
"Name",
"Subject",
"Message",
ActionTypes.Approval,
"GroupName",
DateTime.MinValue,
true,
false);
var vm = new ActionItemViewModel();
var dynamicManagerMock = Mock.Create<IDynamicTypeManager>();
Mock.Arrange(() => dynamicManagerMock.BeginGetEditableRoot(Constants.ActionItemsProcessName, 1, Arg.IsAny<Action<object, DataPortalResult<IEditableRoot>>>()))
.DoInstead<string, int, Action<object, DataPortalResult<IEditableRoot>>>(
(processName, id, callback) =>
{
var result = new DataPortalResult<IEditableRoot>(null, null, null);
callback(null, result);
});
vm.DynamicManager = dynamicManagerMock;
vm.Initialize(actionItemInfo, actionManagerVM);
Assert.AreEqual(Visibility.Visible, vm.AcknowledgeCollapse);
actionItemInfo = new ActionItemInfo(
123,
"ProcessName",
"7FA27365-AF0A-4F98-A927-368D21A8175A",
321,
"Name",
"Subject",
"Message",
ActionTypes.Assignment,
"GroupName",
DateTime.MinValue,
true,
false);
vm.Initialize(actionItemInfo, actionManagerVM);
Assert.AreEqual(Visibility.Collapsed, vm.AcknowledgeCollapse);
}
private void LineagesCache_FetchLineagesCompleted(object sender, DataPortalResult<ReadOnlyLineages> e)
{
BranchFetchCompleted(e);
}
public void OpenScreenCommandTest()
{
var actionManagerVM = Mock.Create<ActionManagerViewModel>();
var actionItemInfo = new ActionItemInfo(
123,
"ProcessName",
"7FA27365-AF0A-4F98-A927-368D21A8175A",
321,
"Name",
"Subject",
"Message",
ActionTypes.Approval,
"GroupName",
DateTime.MinValue,
true,
false);
var detailsMock = Mock.Create<IDetailsViewModel>();
var shellMock = Mock.Create<IShell>();
var vm = new ActionItemViewModel
{
DetailsViewModelFactory = new ExportFactory<IDetailsViewModel>(() => new Tuple<IDetailsViewModel, Action>(detailsMock, () => { })),
WindowManager = shellMock
};
var dynamicManagerMock = Mock.Create<IDynamicTypeManager>();
Mock.Arrange(() => dynamicManagerMock.BeginGetEditableRoot(Constants.ActionItemsProcessName, 1, Arg.IsAny<Action<object, DataPortalResult<IEditableRoot>>>()))
.DoInstead<string, int, Action<object, DataPortalResult<IEditableRoot>>>(
(processName, id, callback) =>
{
var result = new DataPortalResult<IEditableRoot>(null, null, null);
callback(null, result);
});
vm.DynamicManager = dynamicManagerMock;
vm.Initialize(actionItemInfo, actionManagerVM);
vm.IsDetailOpen = true;
vm.OpenScreenCommand.Execute(null);
Assert.IsFalse(vm.IsDetailOpen);
Mock.Assert(() => detailsMock.Refresh(actionItemInfo.ProcessName, actionItemInfo.ItemId), Occurs.Once());
Mock.Assert(() => shellMock.ShowTaskWindow(detailsMock, true), Occurs.Once());
}
private void Lineage_FetchForBindCompleted(object sender, DataPortalResult<Lineage> e)
{
lineageIdBeingFetched = null;
if (e.Error != null)
throw e.Error;
DataSource = e.Object;
IsBusy = false;
}
public void InitializeTest()
{
var actionManagerVM = Mock.Create<ActionManagerViewModel>();
var actionItemInfo = new ActionItemInfo(123,
"ProcessName",
"7FA27365-AF0A-4F98-A927-368D21A8175A",
321,
"Name",
"Subject",
"Message",
ActionTypes.Approval,
"GroupName",
new DateTime(2012, 1, 16),
true,
false);
var vm = new ActionItemViewModel();
var changedProperties = new List<string>();
vm.PropertyChanged += (o, e) => changedProperties.Add(e.PropertyName);
var dynamicManagerMock = Mock.Create<IDynamicTypeManager>();
Mock.Arrange(() => dynamicManagerMock.BeginGetEditableRoot(Constants.ActionItemsProcessName, 1, Arg.IsAny<Action<object, DataPortalResult<IEditableRoot>>>()))
.DoInstead<string, int, Action<object, DataPortalResult<IEditableRoot>>>(
(processName, id, callback) =>
{
var result = new DataPortalResult<IEditableRoot>(null, null, null);
callback(null, result);
});
vm.DynamicManager = dynamicManagerMock;
vm.Initialize(actionItemInfo, actionManagerVM);
Assert.AreSame(actionItemInfo, vm.Model);
Assert.AreSame(actionManagerVM, vm.ParentViewModel);
Assert.AreEqual(actionItemInfo.Subject, vm.Subject);
Assert.AreEqual(actionItemInfo.Message, vm.Description);
Assert.AreEqual(actionItemInfo.GroupName, vm.GroupName);
Assert.AreEqual(actionItemInfo.DueDate, vm.DueDate);
Assert.AreEqual(actionItemInfo.IsActionNew, vm.IsActionNew);
Assert.IsTrue(changedProperties.Contains("Model"));
Assert.IsTrue(changedProperties.Contains("AcknowledgeVisible"));
Assert.IsTrue(changedProperties.Contains("AcknowledgeCollapse"));
Assert.IsTrue(changedProperties.Contains("Subject"));
Assert.IsTrue(changedProperties.Contains("Description"));
Assert.IsTrue(changedProperties.Contains("GroupName"));
Assert.IsTrue(changedProperties.Contains("DueDate"));
Assert.IsTrue(changedProperties.Contains("IsLate"));
Assert.IsTrue(changedProperties.Contains("IsActionNew"));
}
private void HtmlContentNameValues_FetchCompleted(object sender, DataPortalResult<HtmlContentNameValues> e)
{
HcNamesComboBox.ItemsSource = e.Object;
IsBusy = false;
}
private void OnItemsLoaded(object sender, DataPortalResult<IList> result)
{
IsBusy = false;
if (result.Error != null)
{
Logger.Log(LogSeverity.Error, GetType().FullName, result.Error);
PopupFactory.NotifyFailure(result.Error);
return;
}
try
{
IsPopulatingNewPageItems = true;
Items = result.Object;
foreach (var item in Items.Cast<ICrossRefItemInfo>())
{
var oldItem = SelectedItems.Cast<ICrossRefItemInfo>().FirstOrDefault(x => x.Id == item.Id);
if (oldItem == null)
continue;
var index = SelectedItems.IndexOf(oldItem);
SelectedItems[index] = item;
}
var itemCount = Items.GetType().GetProperty(Constants.TotalRowCountPropertyName);
if (itemCount != null)
ItemCount = (int)itemCount.GetValue(Items, BindingFlags.Instance, null, null, null);
var pageIndexProperty = Items.GetType().GetProperty(Constants.PageNumberPropertyName);
if (pageIndexProperty != null)
PageIndex = (int)pageIndexProperty.GetValue(Items, BindingFlags.Instance, null, null, null);
}
finally
{
IsPopulatingNewPageItems = false;
}
}
public void OnRefreshed()
{
// arrange
var vm = new FrequencyPatternDetailsViewModel();
var unitOfWork = Mock.Create<IUnitOfWork<IFrequencyPattern>>(Behavior.Loose);
var model = Mock.Create<IFrequencyPattern>(Behavior.Loose);
Mock.Arrange(() => model.IsNew).Returns(true);
Mock.Arrange(() => unitOfWork.Model).Returns(model);
var dataportalResult = new DataPortalResult<IUnitOfWork<IFrequencyPattern>>(unitOfWork, null, null);
var shell = Mock.Create<IShell>(Behavior.CallOriginal);
var baseMethodWasCalled = false;
Mock.Arrange(() => shell.ShowStatus(Arg.IsAny<Status>(), false)).DoInstead(() => baseMethodWasCalled = true);
vm.WindowManager = new Lazy<IShell>(() => shell);
// act
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.CallMethod("OnRefreshed", new object[] { null, dataportalResult });
// assert
Assert.AreEqual(model, vm.Model);
Assert.AreEqual(FrequencyPatternType.Daily.ToString(), model.PatternType);
// daily
Assert.AreEqual(DailyPatternVariant.NumberOfDays.ToString(), model.DailyPatternOption);
Assert.AreEqual(1, model.DailyPatternDaysToRecur);
// weekly
Assert.AreEqual(1, model.WeeklyPatternWeeksToRecur);
Assert.AreEqual(false, model.IsSundaySelected);
Assert.AreEqual(false, model.IsMondaySelected);
Assert.AreEqual(false, model.IsTuesdaySelected);
Assert.AreEqual(false, model.IsWednesdaySelected);
Assert.AreEqual(false, model.IsThursdaySelected);
Assert.AreEqual(false, model.IsFridaySelected);
Assert.AreEqual(false, model.IsSaturdaySelected);
// monthly
Assert.AreEqual(MonthlyPatternVariant.DayByDate.ToString(), model.MonPatOption);
Assert.AreEqual(1, model.MonPatRecurDate);
Assert.AreEqual(1, model.MonPatByDateOptionMonthsToRec);
Assert.AreEqual(TimeIntervalPosition.First.ToString(), model.MonPatTimeIntervalPosition);
Assert.AreEqual(1, model.MonPatByPositionOptionMonToRec);
Assert.AreEqual(1, model.MonPatMonthsToRec);
Assert.AreEqual(DayofWeek.Saturday.ToString(), model.MonPatDayOfWeek);
// yearly
Assert.AreEqual(1, model.YearPatYearsToRec);
Assert.AreEqual(YearlyPatternVariant.DayByDate.ToString(), model.YearPatOption);
Assert.AreEqual(Month.January.ToString(), model.YearPatByDateOptionSelectMon);
Assert.AreEqual(1, model.YearPatDayOfSelectMon);
Assert.AreEqual(TimeIntervalPosition.First.ToString(), model.YearPatTimeIntervalPosition);
Assert.AreEqual(DayofWeek.Saturday.ToString(), model.YearPatDayOfWeek);
Assert.AreEqual(Month.January.ToString(), model.YearPatByNameOptionSelectMon);
Assert.IsTrue(baseMethodWasCalled);
// arrange
baseMethodWasCalled = false;
dataportalResult = new DataPortalResult<IUnitOfWork<IFrequencyPattern>>(null, new Exception(), null);
var loggerWasCalled = false;
var logger = new ClientLogger();
Mock.Arrange(() => logger.Log(LogSeverity.Error, typeof(FrequencyPatternDetailsViewModel).ToString(), Arg.IsAny<Exception>())).DoInstead(() => loggerWasCalled = true);
vm.Logger = logger;
var popupMock = PopupMock.Create().NotifyFailureMustBeCalled(Arg.IsAny<Exception>());
vm.ThePopupFactory = popupMock.TheLazyPopupFactory;
// act
privateAccessor.CallMethod("OnRefreshed", new object[] { null, dataportalResult });
// assert
Assert.IsTrue(loggerWasCalled);
popupMock.AssertNotifyFailureCalled();
Assert.IsTrue(baseMethodWasCalled);
}
private void QueryCompleted(object sender, EventArgs e)
{
DataPortalResult <T> result = (DataPortalResult <T>)e;
_onCompletedQuery(result, _isCanceled);
}
