public void ImageVisibility()
{
// arrange
var vm = new ImageFieldViewModel();
Mock.NonPublic.Arrange<bool>(vm, "IsImageExists", new object[] { ArgExpr.IsAny<object>() }).Returns(true);
// act
var imageVisibility = vm.ImageVisibility;
// assert
Assert.IsTrue(imageVisibility);
}
protected override DriverResult Editor(ContentPart part, Fields.ImageField field, dynamic shapeHelper)
{
var settings = field.PartFieldDefinition.Settings.GetModel <ImageFieldSettings>();
AssignDefaultMediaFolder(settings);
var viewModel = new ImageFieldViewModel {
Settings = settings,
Field = field,
AlternateText = field.AlternateText
};
return(ContentShape("Fields_Contrib_Image_Edit", GetDifferentiator(field, part),
() => shapeHelper.EditorTemplate(TemplateName: TemplateName, Model: viewModel, Prefix: GetPrefix(field, part))));
}
public void MaxFileSize()
{
// arrange
var vm = new ImageFieldViewModel();
// act
var privateAccessor = new PrivateAccessor(vm);
var maxFileSize = privateAccessor.GetProperty("MaxFileSize");
// assert
Assert.AreEqual((ulong)0, maxFileSize);
// arrange
var systemOptions = Mock.Create<ISystemOptionsInfo>(Behavior.Loose);
systemOptions.MaxFileSize = 10 * 10 * 1024;
Mock.Arrange(() => SystemOptionsInfo.SystemOptions).Returns(systemOptions);
// act
maxFileSize = privateAccessor.GetProperty("MaxFileSize");
// assert
Assert.AreEqual((ulong)10 * 10 * 1024, maxFileSize);
}
public void Init()
{
// arrange
var vm = new ImageFieldViewModel();
var editableRoot = Mock.Create<IEditableRoot>(Behavior.Loose);
Mock.Arrange(() => vm.Property).Returns(GetType().GetProperty("Image1"));
// act
vm.Init(editableRoot, null, null);
// assert
Assert.AreEqual(320, vm.ImageSize.Width);
Assert.AreEqual(240, vm.ImageSize.Height);
// arrange
Mock.Arrange(() => vm.Property).Returns(GetType().GetProperty("Image2"));
// act
vm.Init(editableRoot, null, null);
// assert
Assert.AreEqual(400, vm.ImageSize.Width);
Assert.AreEqual(400, vm.ImageSize.Height);
}
public void OnImageFailed()
{
// arrange
var vm = new ImageFieldViewModel();
var exception = Mock.Create<ExceptionRoutedEventArgs>(Behavior.CallOriginal);
var popupFactory = new PopupFactory();
var notifyFailureCalled = false;
Mock.Arrange(() => popupFactory.NotifyFailure(Arg.IsAny<Exception>(), "Popup_Error", false)).DoInstead(() => notifyFailureCalled = true);
vm.ThePopupFactory = popupFactory;
// act
new PrivateAccessor(vm).CallMethod("OnImageFailed", new object[] { null, exception });
// assert
Assert.IsTrue(notifyFailureCalled);
}
public void IsImageExists()
{
// arrange
var vm = new ImageFieldViewModel
{
Value = new byte[] { 1, 2, 3 }
};
// act
var isImageExists = new PrivateAccessor(vm).CallMethod("IsImageExists", new object[] { null } );
// assert
Assert.IsTrue((bool)isImageExists);
}
public void ShowImageCommand()
{
// arrange
var vm = new ImageFieldViewModel
{
Value = new byte[] {1, 2, 3}
};
var imageViewerViewModel = Mock.Create<IImageViewerViewModel>(Behavior.Loose);
vm.TheImageViewerFactory = new ExportFactory<IImageViewerViewModel>(() => new Tuple<IImageViewerViewModel, Action>(imageViewerViewModel, null));
var okCalled = false;
var popupFactory = Mock.Create<PopupFactory>();
var popupBuilder = new PopupBuilder();
Mock.Arrange(() => popupBuilder.Show(Arg.IsAny<Action>(), Arg.IsAny<Func<bool>>())).DoInstead((Action ok, Action cancel) =>
{
ok();
okCalled = true;
});
Mock.Arrange(() => popupFactory.Popup()).Returns(popupBuilder);
vm.ThePopupFactory = popupFactory;
// act
vm.ShowImageCommand.Execute(null);
// assert
CollectionAssert.AreEqual(new byte[] { 1, 2, 3 }, (ICollection)imageViewerViewModel.Image);
Assert.IsTrue(okCalled);
}
public void ClearImageCommand()
{
// arrange
var vm = new ImageFieldViewModel();
var imageVisibilityRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", ArgExpr.IsAny<Expression<Func<bool>>>()).DoInstead(() => imageVisibilityRaises = true);
var downloadImageCommandRaises = false;
Mock.Arrange(() => vm.DownloadImageCommand.RaiseCanExecuteChanged()).DoInstead(() => downloadImageCommandRaises = true);
var clearImageCommandRaises = false;
Mock.Arrange(() => vm.ClearImageCommand.RaiseCanExecuteChanged()).DoInstead(() => clearImageCommandRaises = true);
vm.Value = new byte[] { 1, 2, 3 };
// act
vm.ClearImageCommand.Execute(null);
// assert
Assert.IsNull(vm.Value);
Assert.IsTrue(imageVisibilityRaises);
Assert.IsTrue(downloadImageCommandRaises);
Assert.IsTrue(clearImageCommandRaises);
}
public void DownloadImageCommand()
{
// arrange
var vm = new ImageFieldViewModel();
var saveFileDialog = Mock.Create<SaveFileDialog>(Behavior.CallOriginal);
Mock.Arrange(() => saveFileDialog.ShowDialog()).Returns(false);
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.SetField("_saveFileDialog", saveFileDialog);
Mock.NonPublic.Arrange<bool>(vm, "IsImageExists", new object[] { ArgExpr.IsAny<object>() }).Returns(true);
var editableRoot = Mock.Create<IEditableRoot>(Behavior.Loose);
Mock.Arrange(() => editableRoot.ProcessName).Returns("eCar_p");
Mock.Arrange(() => editableRoot.Id).Returns(1);
Mock.Arrange(() => vm.ParentModel).Returns(editableRoot);
Mock.Arrange(() => vm.Property).Returns(GetType().GetProperty("Image2"));
// act
try
{
vm.DownloadImageCommand.Execute(null);
}
catch(Exception ex)
{
// assert
Assert.Fail("Expected no exception, but got: " + ex.Message);
}
// arrange
Mock.Arrange(() => saveFileDialog.ShowDialog()).Returns(true);
Mock.Arrange(() => saveFileDialog.OpenFile()).Returns(new MemoryStream());
var array = new byte[8 * 1024 + 1];
for (var i = 0; i < array.Length; i++)
{
array[i] = new byte();
}
vm.Value = array;
var popupFactory = new PopupFactory();
var notifySuccessCalled = false;
Mock.Arrange(() => popupFactory.NotifySuccess(LanguageService.Translate("Msg_SuccessfullySaved"), "Popup_Success")).DoInstead(() => notifySuccessCalled = true);
vm.ThePopupFactory = popupFactory;
// act
vm.DownloadImageCommand.Execute(null);
// assert
Assert.IsTrue(notifySuccessCalled);
Assert.IsNull(privateAccessor.GetField("_saveFileDialog"));
}
public void DownloadImageCommandThrowException()
{
// arrange
var vm = new ImageFieldViewModel();
Mock.NonPublic.Arrange<bool>(vm, "IsImageExists", new object[] { ArgExpr.IsAny<object>() }).Returns(true);
var editableRoot = Mock.Create<IEditableRoot>(Behavior.Loose);
Mock.Arrange(() => vm.ParentModel).Returns(editableRoot);
Mock.Arrange(() => vm.Property).Returns(GetType().GetProperty("Image2"));
try
{
// act
vm.DownloadImageCommand.Execute(null);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(SecurityException), "Dialogs must be user-initiated.");
return;
}
Assert.IsFalse(true);
}
public void UploadImageCommand()
{
// arrange
var vm = new ImageFieldViewModel();
var openFileDialog = Mock.Create<OpenFileDialog>(Behavior.CallOriginal);
Mock.Arrange(() => openFileDialog.ShowDialog()).Returns(false);
var privateAccessor = new PrivateAccessor(vm);
privateAccessor.SetField("_openFileDialog", openFileDialog);
try
{
// act
vm.UploadImageCommand.Execute(null);
}
catch (Exception ex)
{
// assert
Assert.Fail("Expected no exception, but got: " + ex.Message);
}
// arrange
Mock.Arrange(() => openFileDialog.ShowDialog()).Returns(true);
var file = Mock.Create<FileInfo>(Behavior.CallOriginal);
Mock.Arrange(() => file.Length).Returns(8 * 1024);
Mock.Arrange(() => openFileDialog.File).Returns(file);
var popupFactory = new PopupFactory();
var notifyFailureCalled = false;
Mock.Arrange(() => popupFactory.NotifyFailure(Arg.AnyString, "Popup_Error", 3, false)).DoInstead(() => notifyFailureCalled = true);
vm.ThePopupFactory = popupFactory;
// act
vm.UploadImageCommand.Execute(null);
// assert
Assert.IsTrue(notifyFailureCalled);
// arrange
Mock.NonPublic.Arrange<ulong>(vm, "MaxFileSize").Returns((ulong)file.Length + 1);
var fileStream = Mock.Create<FileStream>(Behavior.Loose);
var exit = false;
Mock.Arrange(() => fileStream.Read(Arg.IsAny<byte[]>(), 0, Arg.AnyInt)).Returns(() =>
{
if (!exit)
{
exit = true;
return 1;
}
return 0;
});
Mock.Arrange(() => file.OpenRead()).Returns(fileStream);
var imageVisibilityRaises = false;
Mock.NonPublic.Arrange(vm, "RaisePropertyChanged", ArgExpr.IsAny<Expression<Func<bool>>>()).DoInstead(() => imageVisibilityRaises = true);
var downloadImageCommandRaises = false;
Mock.Arrange(() => vm.DownloadImageCommand.RaiseCanExecuteChanged()).DoInstead(() => downloadImageCommandRaises = true);
var clearImageCommandRaises = false;
Mock.Arrange(() => vm.ClearImageCommand.RaiseCanExecuteChanged()).DoInstead(() => clearImageCommandRaises = true);
// act
vm.UploadImageCommand.Execute(null);
// assert
Assert.AreEqual(8 * 1024, ((byte[])vm.Value).Length);
Assert.IsTrue(imageVisibilityRaises);
Assert.IsTrue(downloadImageCommandRaises);
Assert.IsTrue(clearImageCommandRaises);
Assert.IsNull(privateAccessor.GetField("_openFileDialog"));
}
public void UploadImageCommandThrowException()
{
// arrange
var vm = new ImageFieldViewModel();
try
{
// act
vm.UploadImageCommand.Execute(null);
}
catch (Exception ex)
{
Assert.IsInstanceOfType(ex, typeof(SecurityException), "Dialogs must be user-initiated.");
return;
}
Assert.IsFalse(true);
}
protected override DriverResult Editor(ContentPart part, Fields.ImageField field, IUpdateModel updater, dynamic shapeHelper)
{
var settings = field.PartFieldDefinition.Settings.GetModel <ImageFieldSettings>();
var viewModel = new ImageFieldViewModel {
Settings = settings,
Field = field,
Removed = false
};
if (updater.TryUpdateModel(viewModel, GetPrefix(field, part), null, null))
{
var postedFile = ((Controller)updater).Request.Files["ImageField-" + field.Name];
AssignDefaultMediaFolder(settings);
var mediaFolder = FormatWithTokens(settings.MediaFolder, part.ContentItem.ContentType, field.Name, part.ContentItem.Id);
if (postedFile != null && postedFile.ContentLength != 0)
{
// read the file in memory in case we need to apply some transformation
var postedFileLength = postedFile.ContentLength;
var postedFileStream = postedFile.InputStream;
var postedFileData = new byte[postedFileLength];
var postedFileName = Path.GetFileName(postedFile.FileName);
postedFileStream.Read(postedFileData, 0, postedFileLength);
if (_mediaService.FileAllowed(postedFile))
{
string uploadedFileName = String.Empty;
Image image;
using (var stream = new MemoryStream(postedFileData)) {
image = Image.FromStream(stream);
}
// apply transformation
int newWidth = settings.MaxWidth > 0 && image.Width > settings.MaxWidth
? settings.MaxWidth
: image.Width;
float widthFactor = image.Width / (float)newWidth;
int newHeight = settings.MaxHeight > 0 && image.Height > settings.MaxHeight
? settings.MaxHeight
: image.Height;
float heightFactor = image.Height / (float)newHeight;
if (widthFactor != heightFactor)
{
if (widthFactor > heightFactor)
{
newHeight = Convert.ToInt32(image.Height / widthFactor);
}
else
{
newWidth = Convert.ToInt32(image.Width / heightFactor);
}
}
// create a unique file name
string uniqueFileName = postedFileName;
try {
// try to create the folder before uploading a file into it
_mediaService.CreateFolder(null, mediaFolder);
}
catch {
// the folder can't be created because it already exists, continue
}
var existingFiles = _mediaService.GetMediaFiles(mediaFolder);
bool found = true;
var index = 0;
while (found)
{
index++;
uniqueFileName = String.Format("{0}-{1}{2}", Path.GetFileNameWithoutExtension(postedFileName), index, Path.GetExtension(postedFileName));
found = existingFiles.Any(f => 0 == String.Compare(uniqueFileName, f.Name, StringComparison.OrdinalIgnoreCase));
}
// resize the image
Image target = null;
switch (settings.ResizeAction)
{
case ResizeActions.Validate:
if ((settings.MaxWidth > 0 && image.Width > settings.MaxWidth) ||
(settings.MaxHeight > 0 && image.Height > settings.MaxHeight))
{
updater.AddModelError("File",
T("The file is bigger than the allowed size: {0}x{1}",
image.Width, image.Height));
}
target = new Bitmap(image);
break;
case ResizeActions.Resize:
target = new Bitmap(newWidth, newHeight);
using (var graphics = Graphics.FromImage(target)) {
graphics.CompositingQuality = CompositingQuality.HighSpeed;
graphics.InterpolationMode = InterpolationMode.HighQualityBicubic;
graphics.CompositingMode = CompositingMode.SourceCopy;
graphics.DrawImage(image, 0, 0, newWidth, newHeight);
}
Services.Notifier.Information(T("The image {0} has been resized to {1}x{2}",
field.Name.CamelFriendly(), newWidth, newHeight));
break;
case ResizeActions.Scale:
target = new Bitmap(image);
break;
case ResizeActions.Crop:
target = new Bitmap(newWidth, newHeight);
using (var graphics = Graphics.FromImage(target)) {
graphics.DrawImage(image, 0, 0, new Rectangle(0, 0, newWidth, newHeight), GraphicsUnit.Pixel);
}
Services.Notifier.Information(T("The image {0} has been cropped to {1}x{2}",
field.Name.CamelFriendly(), newWidth, newHeight));
break;
}
if (target != null)
{
using (var imageStream = new MemoryStream()) {
// keeps the original format
ImageFormat imageFormat;
switch (Path.GetExtension(postedFileName).ToLower())
{
case ".bmp":
imageFormat = ImageFormat.Bmp;
break;
case ".gif":
imageFormat = ImageFormat.Gif;
break;
case ".jpg":
imageFormat = ImageFormat.Jpeg;
break;
default:
imageFormat = ImageFormat.Png;
break;
}
target.Save(imageStream, imageFormat);
uploadedFileName = _mediaService.UploadMediaFile(mediaFolder, uniqueFileName, imageStream.ToArray(), false);
}
// assigning actual size to be rendered in html
field.Width = newWidth;
field.Height = newHeight;
// don't convert the url to ~/ if it's a fully qualified
// as it might be stored on a remote storage (cdn, blob, ...)
field.FileName = VirtualPathUtility.IsAbsolute(uploadedFileName)
? VirtualPathUtility.ToAppRelative(uploadedFileName)
: uploadedFileName;
}
else
{
field.Width = 0;
field.Height = 0;
field.FileName = String.Empty;
}
}
else
{
updater.AddModelError("File", T("The file type is not allowed for: {0}.", postedFile.FileName));
}
}
else
{
if (settings.Required && string.IsNullOrWhiteSpace(field.FileName))
{
updater.AddModelError("File", T("You must provide an image file for {0}.", field.Name.CamelFriendly()));
}
if (!settings.Required && viewModel.Removed)
{
field.FileName = null;
field.Height = 0;
field.Width = 0;
Services.Notifier.Information(T("{0} was removed.", field.Name.CamelFriendly()));
}
}
// define alernate text
if (settings.AlternateText)
{
field.AlternateText = String.IsNullOrWhiteSpace(viewModel.AlternateText)
? postedFile == null || String.IsNullOrEmpty(postedFile.FileName) ? String.Empty : VirtualPathUtility.GetFileName(postedFile.FileName)
: viewModel.AlternateText;
}
}
return(Editor(part, field, shapeHelper));
}
