public void Init()
{
// arrange
var vm = new FieldFileViewModel();
var editableRoot = Mock.Create<IEditableRoot>(Behavior.Loose);
var getSystemOptionsMethodWasCalled = false;
Mock.NonPublic.Arrange(vm, "GetSystemOptions").DoInstead(() => getSystemOptionsMethodWasCalled = true);
var setStateWasCalled = false;
Mock.NonPublic.Arrange(vm, "SetState").DoInstead(() => setStateWasCalled = true);
var value = Mock.Create<ICloneable>(Behavior.Loose);
Mock.Arrange(() => value.Clone()).Returns(new object());
var detailsViewModel = Mock.Create<IDetailsViewModel>(Behavior.Loose);
// act
vm.Init(editableRoot, value, detailsViewModel);
// assert
Assert.IsTrue(getSystemOptionsMethodWasCalled);
Assert.IsTrue(setStateWasCalled);
Assert.IsNotNull(new PrivateAccessor(vm).GetField("_originalFileProcess"));
}
public void Width()
{
// arrange
var vm = new FieldFileViewModel();
var widthWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "Width").DoInstead(() => { widthWasRaises = true; });
// act
vm.Width = 0;
// assert
Assert.IsFalse(widthWasRaises);
// act
vm.Width = 39;
// assert
Assert.IsTrue(widthWasRaises);
Assert.AreEqual(200, vm.Width);
// act
vm.Width = double.PositiveInfinity;
// assert
Assert.AreEqual(200, vm.Width);
// act
vm.Width = 41;
// assert
Assert.AreEqual(1, vm.Width);
}
public void CurrentFileProcess()
{
// arrange
var vm = new FieldFileViewModel();
var privateAccessor = new PrivateAccessor(vm);
// act
var currentFileProcess = privateAccessor.GetProperty("CurrentFileProcess");
// assert
Assert.IsNull(currentFileProcess);
// arrange
var fileProcess = Mock.Create<IFileProcess>(Behavior.CallOriginal);
vm.Value = fileProcess;
// act
currentFileProcess = privateAccessor.GetProperty("CurrentFileProcess");
// assert
Assert.AreEqual(fileProcess, currentFileProcess);
}
public void PropertiesTests()
{
var vm = new FieldFileViewModel();
TestsHelper.TestPublicPropertiesGetSet(vm, x => vm.Width, x => vm.VisibilityRules, x => vm.MaxFileSize);
}
public void NavigateUri()
{
// arrange
var vm = new FieldFileViewModel();
// act
var navigateUri = vm.NavigateUri;
// assert
Assert.IsNull(navigateUri);
// arrange
var fileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
fileProcess.Id = 123;
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.doc";
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
vm.DocHandlerUrl = "http://localhost:5558/";
// act
navigateUri = vm.NavigateUri;
// assert
Assert.AreEqual("http://localhost:5558/DocHandler.ashx?FileId=123", navigateUri);
}
public void Message11()
{
// arrange
var vm = new FieldFileViewModel();
var fileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
fileProcess.OriginalFileName = "1.txt";
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
// act
var value = new PrivateAccessor(vm).GetProperty("Message11");
// assert
Assert.AreEqual("The process cannot access file '1.txt' because it is being used by another process.", value);
}
public void Message9()
{
// arrange
var vm = new FieldFileViewModel();
// act
var value = new PrivateAccessor(vm).GetProperty("Message9");
// assert
Assert.AreEqual(string.Format("Uploaded file in temp location was not found{0}Please verify System Options\\System Paths", Environment.NewLine), value);
}
public void Message1()
{
// arrange
var vm = new FieldFileViewModel();
var fileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
fileProcess.OriginalFileName = "1.txt";
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
// act
var value = new PrivateAccessor(vm).GetProperty("Message1");
// assert
Assert.AreEqual("File '1.txt' uploaded successfully.", value);
}
public void SaveObjectState()
{
// arrange
var vm = new FieldFileViewModel();
var fileProcess = Mock.Create<IFileProcess>(x => x.Implements<ITrackStatus>());
fileProcess.FileName = "32613DE4-8B08-4AD6-A05B-E711226006DB.txt";
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
var parentModel = Mock.Create<IModel>(Behavior.Loose);
Mock.Arrange(() => parentModel.IsNew).Returns(true);
Mock.Arrange(() => parentModel.CanWriteProperty(Arg.AnyString)).Returns(true);
Mock.Arrange(() => vm.ParentModel).Returns(parentModel);
vm.Property = ReflectionHelper.GetProperty<IModel>(x => x.File);
// act
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.CallMethod("SetState");
// assert
Assert.AreEqual("Please save to see the file options.", vm.Message);
Assert.AreEqual(FileControlMode.NotifySuccess, vm.CurrentState);
}
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 RestrictedRightsState()
{
// arrange
var vm = new FieldFileViewModel();
var fileProcess = Mock.Create<IFileProcess>(x => x.Implements<ITrackStatus>());
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
var parentModel = Mock.Create<IEditableRoot>(x => x.Implements<Csla.Security.IAuthorizeReadWrite>());
Mock.Arrange(() => ((Csla.Security.IAuthorizeReadWrite)parentModel).CanWriteProperty(Arg.AnyString)).Returns(true);
Mock.Arrange(() => vm.ParentModel).Returns(parentModel);
vm.Property = Mock.Create<PropertyInfo>(Behavior.Loose);
var privateAccessor = new PrivateAccessor(vm);
Mock.Arrange(() => fileProcess.FileName).Throws<Exception>();
try
{
// act
privateAccessor.CallMethod("SetState");
}
catch { }
Assert.AreNotEqual(FileControlMode.View, vm.CurrentState);
Assert.AreNotEqual(FileControlMode.Empty, vm.CurrentState);
// arrange
Mock.Arrange(() => fileProcess.FileName).Returns("32613DE4-8B08-4AD6-A05B-E711226006DB.txt");
Mock.Arrange(() => ((Csla.Security.IAuthorizeReadWrite)parentModel).CanWriteProperty(Arg.AnyString)).Returns(false);
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.AreEqual(FileControlMode.View, vm.CurrentState);
// arrange
Mock.Arrange(() => fileProcess.FileName).Returns((string)null);
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.AreEqual(FileControlMode.Empty, vm.CurrentState);
}
public void SetStateUseReport()
{
// arrange
var vm = new FieldFileViewModel();
var fileProcess = Mock.Create<IFileProcess>(x => x.Implements<ITrackStatus>());
fileProcess.UseReport = true;
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
var privateAccessor = new PrivateAccessor(vm);
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.AreEqual("Invalid setup.", privateAccessor.GetProperty("ExceptionMessage"));
Assert.AreEqual(FileControlMode.Error, vm.CurrentState);
// arrange
fileProcess.ReportName = "eCarProcessMainReport.trdx";
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.IsNotNull(fileProcess.FileName);
Assert.AreEqual("Save item to view file.", vm.Message);
Assert.AreEqual(FileControlMode.NotifySuccess, vm.CurrentState);
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.AreEqual(FileControlMode.View, vm.CurrentState);
}
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 WhenFileIncludeInCheckList()
{
// 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>(Behavior.CallOriginal);
var newValue = Mock.Create<IFileProcess>(Behavior.Loose);
newValue.Id = 1;
var setStateWasCalled = false;
Mock.Arrange(() => dynamicManager.BeginGetEditableRoot(Constants.FileProcessName, Arg.AnyInt, Arg.IsAny<Action<object, DataPortalResult<IEditableRoot>>>()))
.DoInstead<string, int, Action<object, DataPortalResult<IEditableRoot>>>((processName, id, callback) =>
{
Mock.NonPublic.Arrange(vm, "SetState").DoInstead(() => setStateWasCalled = true);
callback(null, new DataPortalResult<IEditableRoot>(newValue, null, null));
});
vm.TheDynamicTypeManager = dynamicManager;
// act
new PrivateAccessor(vm).CallMethod("SetState");
// assert
Assert.AreEqual(newValue, vm.Value);
Assert.IsTrue(setStateWasCalled);
}
public void SetStateFirstReturn()
{
// arrange
var vm = new FieldFileViewModel();
var privateAccessor = new PrivateAccessor(vm);
try
{
// act
privateAccessor.CallMethod("SetState");
}
catch (Exception ex)
{
// assert
Assert.Fail("Expected no exception, but got: " + ex.Message);
}
}
public void ClipboardCopyErrorVisibility()
{
// arrange
var vm = new FieldFileViewModel();
// act
var clipboardCopyErrorVisibility = vm.ClipboardCopyErrorVisibility;
// assert
Assert.IsFalse(clipboardCopyErrorVisibility);
// arrange
vm.Value = new object();
// act
clipboardCopyErrorVisibility = vm.ClipboardCopyErrorVisibility;
// assert
Assert.IsFalse(clipboardCopyErrorVisibility);
// arrange
new PrivateAccessor(vm).SetProperty("ExceptionMessage", new FileNotFoundException().ToString());
// act
clipboardCopyErrorVisibility = vm.ClipboardCopyErrorVisibility;
// assert
Assert.IsTrue(clipboardCopyErrorVisibility);
}
public void SelectedFileTemplateId()
{
// arrange
var vm = new FieldFileViewModel();
var selectedFileTemplateIdWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "SelectedFileTemplateId").DoInstead(() => { selectedFileTemplateIdWasRaises = true; });
var selectTemplateFileCommandWasRaises = false;
Mock.Arrange(() => vm.SelectTemplateFileCommand.RaiseCanExecuteChanged()).DoInstead(() => selectTemplateFileCommandWasRaises = true);
// act
vm.SelectedFileTemplateId = 1;
// assert
Assert.IsTrue(selectedFileTemplateIdWasRaises);
Assert.IsTrue(selectTemplateFileCommandWasRaises);
Assert.AreEqual(1, vm.SelectedFileTemplateId);
// arrange
selectedFileTemplateIdWasRaises = false;
// act
vm.SelectedFileTemplateId = 1;
// assert
Assert.IsFalse(selectedFileTemplateIdWasRaises);
}
public void Upload()
{
// arrange
var vm = new FieldFileViewModel();
var fileProcess = Mock.Create<IFileProcess>(x => x.Implements<ITrackStatus>());
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
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);
// act
new PrivateAccessor(vm).CallMethod("SetState");
// assert
Assert.AreEqual(FileControlMode.Upload, vm.CurrentState);
Assert.IsTrue(vm.UploadCancelButtonIsHidden);
}
public void PrivateMessageFields()
{
// arrange
var vm = new FieldFileViewModel();
var privateAccessor = new PrivateAccessor(vm);
// act
var message2 = privateAccessor.GetField("_message2");
var message3 = privateAccessor.GetField("_message3");
var message4 = privateAccessor.GetField("_message4");
var message5 = privateAccessor.GetField("_message5");
var message6 = privateAccessor.GetField("_message6");
var message8 = privateAccessor.GetField("_message8");
var message13 = privateAccessor.GetField("_message13");
// assert
Assert.AreEqual(LanguageService.Translate("Msg_TemplateNotFound"), message2);
Assert.AreEqual(LanguageService.Translate("Msg_SaveToSeeFileOptions"), message3);
Assert.AreEqual(LanguageService.Translate("Msg_SystemPathsIsEmpty"), message4);
Assert.AreEqual(LanguageService.Translate("Msg_InvalidSystemPath"), message5);
Assert.AreEqual(LanguageService.Translate("Msg_DocumentProcessorNotResponding"), message6);
Assert.AreEqual(LanguageService.Translate("Msg_FileUploadError"), message8);
Assert.AreEqual(LanguageService.Translate("Msg_FileNotFound"), message13);
}
public void LockedState()
{
// arrange
var vm = new FieldFileViewModel();
var fileProcess = Mock.Create<IFileProcess>(x => x.Implements<ITrackStatus>());
fileProcess.FileName = Guid.NewGuid() + ".txt";
fileProcess.Locked = true;
fileProcess.LockedByAccountId = 2;
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
Mock.Arrange(() => Utils.CurrentUserAccountId).Returns(2);
var parentModel = Mock.Create<IModel>(Behavior.Loose);
Mock.Arrange(() => parentModel.CanWriteProperty(Arg.AnyString)).Returns(false);
Mock.Arrange(() => vm.ParentModel).Returns(parentModel);
vm.Property = ReflectionHelper.GetProperty<IModel>(x => x.File);
// act
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.CallMethod("SetState");
// assert
Assert.AreEqual(FileControlMode.View, vm.CurrentState);
// arrange
Mock.Arrange(() => parentModel.CanWriteProperty(Arg.AnyString)).Returns(true);
// act
privateAccessor.CallMethod("SetState");
// assert
Assert.AreEqual(FileControlMode.Locked, vm.CurrentState);
}
public void Message10()
{
// arrange
var vm = new FieldFileViewModel();
// act
var value = new PrivateAccessor(vm).GetProperty("Message10");
// 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), value);
}
public void LockedByMessage()
{
// arrange
var vm = new FieldFileViewModel();
// act
var lockedByMessage = vm.LockedByMessage;
// assert
Assert.IsNull(lockedByMessage);
// arrange
var fileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
Mock.Arrange(() => vm.CanEdit).Returns(false);
// act
lockedByMessage = vm.LockedByMessage;
// assert
Assert.IsNull(lockedByMessage);
// arrange
Mock.Arrange(() => vm.CanEdit).Returns(true);
fileProcess.Locked = false;
// act
lockedByMessage = vm.LockedByMessage;
// assert
Assert.IsNull(lockedByMessage);
// arrange
fileProcess.Locked = true;
fileProcess.LockedByAccountId = -1;
// act
lockedByMessage = vm.LockedByMessage;
// assert
Assert.AreEqual("Checked Out By: admin", lockedByMessage);
// arrange
fileProcess.LockedByAccountId = 1;
// act
lockedByMessage = vm.LockedByMessage;
// assert
Assert.AreEqual("Checked Out By: unknown", lockedByMessage);
// arrange
fileProcess.LockedByAccountName = "esmirnov";
// act
lockedByMessage = vm.LockedByMessage;
// assert
Assert.AreEqual("Checked Out By: esmirnov", lockedByMessage);
// arrange
fileProcess.LockedDate = DateTime.Today;
// act
lockedByMessage = vm.LockedByMessage;
// assert
Assert.AreEqual(string.Format("Checked Out By: esmirnov{0}Checked Out Date: {1}", Environment.NewLine, fileProcess.LockedDate.Value.ToShortDateString()), lockedByMessage);
// arrange
Mock.NonPublic.Arrange<bool>(vm, "Orientation").Returns(true);
// act
lockedByMessage = vm.LockedByMessage;
// assert
Assert.AreEqual(string.Format("Checked Out By: esmirnov\tChecked Out Date: {0}", fileProcess.LockedDate.Value.ToShortDateString()), lockedByMessage);
}
public void TemplateWasSelectedMessage()
{
// arrange
var vm = new FieldFileViewModel();
var fileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
fileProcess.OriginalFileName = "1.txt";
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
// act
var templateWasSelectedMessage = vm.TemplateWasSelectedMessage;
// assert
Assert.AreEqual("Template File '1.txt' was loaded", templateWasSelectedMessage);
}
public void LockedByMessageVisibility()
{
// arrange
var vm = new FieldFileViewModel();
// act
var lockedByMessageVisibility = vm.LockedByMessageVisibility;
// assert
Assert.IsFalse(lockedByMessageVisibility);
// arrange
Mock.NonPublic.Arrange<string>(vm, "LockedByMessage").Returns("Checked Out By: esmirnov");
// act
lockedByMessageVisibility = vm.LockedByMessageVisibility;
// assert
Assert.IsTrue(lockedByMessageVisibility);
}
public void DialogFilter()
{
// arrange
var vm = new FieldFileViewModel();
// act
var value = vm.DialogFilter;
// assert
Assert.AreEqual(string.Empty, value);
// arranage
var fileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual(string.Empty, value);
// arrange
fileProcess.FileName = string.Empty;
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual(string.Empty, value);
// arrange
fileProcess.FileName = " ";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual(string.Empty, value);
// arrange
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual(string.Empty, value);
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.pdf";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("Adobe Reader File (*.pdf)|*.pdf", value);
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.doc";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("MS Word File (*.doc)|*.doc", value);
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.docx";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("MS Word File (*.docx)|*.docx", value);
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.rtf";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("MS Word File (*.rtf)|*.rtf", value);
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.scv";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("MS Excel File (*.scv)|*.scv", value);
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.xlt";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("MS Excel File (*.xlt)|*.xlt", value);
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.xltx";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("MS Excel File (*.xltx)|*.xltx", value);
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.txt";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("Text File (*.txt)|*.txt", value);
// arrange
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.txt";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("Text File (*.txt)|*.txt", value);
// arrange
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.jpg";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("Image File (*.jpg)|*.jpg", value);
// arrange
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.jpeg";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("Image File (*.jpeg)|*.jpeg", value);
// arrange
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.bmp";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("Image File (*.bmp)|*.bmp", value);
// arrange
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.tif";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("Image File (*.tif)|*.tif", value);
// arrange
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.tiff";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("Image File (*.tiff)|*.tiff", value);
// arrange
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.htm";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("Web Page (*.htm)|*.htm", value);
// arrange
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.html";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("Web Page (*.html)|*.html", value);
// arrange
fileProcess.FileName = "603512C1-87D1-48BA-9C3F-13DA0C9EF5C0.dll";
// act
value = vm.DialogFilter;
// assert
Assert.AreEqual("File (*.dll)|*.dll", value);
}
public void FileSavedMessageVisibility()
{
// arrange
var vm = new FieldFileViewModel();
// act
var fileSavedMessageVisibility = vm.FileSavedMessageVisibility;
// assert
Assert.IsFalse(fileSavedMessageVisibility);
// arrange
new PrivateAccessor(vm).SetField("_dialog", Mock.Create<SaveFileDialog>(Behavior.CallOriginal));
// act
fileSavedMessageVisibility = vm.FileSavedMessageVisibility;
// assert
Assert.IsTrue(fileSavedMessageVisibility);
}
public void MaxFileSize()
{
// arrange
var vm = new FieldFileViewModel();
var logger = Mock.Create<ILogger>(Behavior.CallOriginal);
var logWasCalled = false;
Mock.Arrange(() => logger.Log(LogSeverity.Error, typeof(FieldFileViewModel).ToString(), "There is no cached SystemOptions.")).DoInstead(() => logWasCalled = true);
vm.Logger = logger;
// act
var maxFileSize = vm.MaxFileSize;
// assert
Assert.IsTrue(logWasCalled);
Assert.AreEqual((ulong)0, maxFileSize);
// arrange
logWasCalled = false;
var systemOptions = Mock.Create<ISystemOptionsInfo>(Behavior.Loose);
systemOptions.MaxFileSize = 10 * 1024;
Mock.Arrange(() => SystemOptionsInfo.SystemOptions).Returns(systemOptions);
// act
maxFileSize = vm.MaxFileSize;
// assert
Assert.IsFalse(logWasCalled);
Assert.AreEqual((ulong)10 * 1024, maxFileSize);
}
public void FileNameMessage()
{
// arrange
var vm = new FieldFileViewModel();
// act
var fileNameMessage = vm.FileNameMessage;
// assert
Assert.IsNull(fileNameMessage);
// arrange
var fileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
vm.Value = fileProcess;
// act
fileNameMessage = vm.FileNameMessage;
// assert
Assert.IsNull(fileNameMessage);
// arrange
fileProcess.OriginalFileName = "1.txt";
// act
fileNameMessage = vm.FileNameMessage;
// assert
Assert.AreEqual("File Name: 1.txt", fileNameMessage);
}
public void GetFileCommandThrowException()
{
// arrange
var vm = new FieldFileViewModel();
var fileProcess = Mock.Create<IFileProcess>(Behavior.Loose);
Mock.NonPublic.Arrange<IFileProcess>(vm, "CurrentFileProcess").Returns(fileProcess);
try
{
// act
vm.GetFileCommand.Execute(null);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(SecurityException), "Dialogs must be user-initiated.");
return;
}
Assert.IsFalse(true);
}
public void GetSystemOptions()
{
// arrange
var vm = new FieldFileViewModel();
Mock.Arrange(() => Arg.IsAny<SystemPathsInfo>().BeginGetSystemPathsAsync()).Throws<Exception>();
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;
var privateAccessor = new PrivateAccessor(vm);
// act
privateAccessor.CallMethod("GetSystemOptions");
// assert
Assert.AreEqual("Invalid System Paths. Contact your administrator, please.", vm.Message);
var exceptionMessage = (string)privateAccessor.GetProperty("ExceptionMessage");
Assert.IsTrue(exceptionMessage.StartsWith(new Exception().ToString()));
Assert.AreEqual(FileControlMode.NotifyFail, vm.CurrentState);
Assert.IsTrue(logWasCalled);
// arrange
vm.Message = null;
privateAccessor.SetProperty("ExceptionMessage", new Exception().ToString());
vm.CurrentState = FileControlMode.Download;
var systemPathsInfo = Mock.Create<SystemPathsInfo>(Behavior.Loose);
var task = new Task<SystemPathsInfo>(() => systemPathsInfo);
task.RunSynchronously();
Mock.Arrange(() => Arg.IsAny<SystemPathsInfo>().BeginGetSystemPathsAsync()).Returns(() => task);
// act
privateAccessor.CallMethod("GetSystemOptions");
// assert
Assert.AreEqual("System Paths in System Option menu is empty. Please fill in before using FileControl", vm.Message);
Assert.IsNull(privateAccessor.GetProperty("ExceptionMessage"));
Assert.AreEqual(FileControlMode.NotifyFail, vm.CurrentState);
// arrange
vm.Message = null;
privateAccessor.SetProperty("ExceptionMessage", new Exception().ToString());
vm.CurrentState = FileControlMode.Download;
Mock.Arrange(() => systemPathsInfo.FileUploadURI).Returns("http://*****:*****@"D:\Projects\Cebos\Veyron\Cebos.Veyron.Web\FileStorage");
var navigateUriWasRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", "NavigateUri").DoInstead(() => navigateUriWasRaises = true);
// act
privateAccessor.CallMethod("GetSystemOptions");
Assert.AreEqual("http://localhost:5558/FileUploadHandler.ashx", vm.UploadServiceUrl);
Assert.AreEqual("/FileStorage", vm.TargetFolder);
Assert.AreEqual("http://localhost:5558/", vm.DocHandlerUrl);
Assert.IsTrue(navigateUriWasRaises);
}
