public void GetGalleriesWithunconfirmedImages_FromDatabase_AndRenderDefaultView()
{
// Arrange
var mockedCollection = new List <ImageGalleryModel>();
var mockedImageGalleryService = new Mock <IImageGalleryService>();
mockedImageGalleryService.Setup(s => s.GetGalleriesWithUnconfirmedImages())
.Returns(mockedCollection)
.Verifiable();
var mockedImageFactory = new Mock <IImageFactory>();
var mockedDateProvider = new Mock <IDateProvider>();
var mockedLakeService = new Mock <ILakeService>();
var mockedImageGalleryFactory = new Mock <IImageGalleryFactory>();
var mockedDirectoryHelper = new Mock <IDirectoryHelper>();
var controller = new PicturesController(
mockedImageGalleryService.Object,
mockedImageFactory.Object,
mockedDateProvider.Object,
mockedLakeService.Object,
mockedImageGalleryFactory.Object,
mockedDirectoryHelper.Object);
// Act
var result = controller.Confirm() as ViewResult;
var model = result.Model as IEnumerable <ImageGalleryModel>;
// Assert
Assert.AreEqual(mockedCollection, model);
Assert.IsTrue(result.ViewName == "");
mockedImageGalleryService.Verify(s => s.GetGalleriesWithUnconfirmedImages(), Times.Once);
}
public void ReturnCorrectResult()
{
// Arrange
var mockedGalleryCollection = new List <ImageGalleryModel>()
{
new ImageGalleryModel()
};
var mockedImageGalleryService = new Mock <IImageGalleryService>();
mockedImageGalleryService.Setup(g => g.GetByLake(It.IsAny <string>()))
.Returns(mockedGalleryCollection)
.Verifiable();
var mockedImageFactory = new Mock <IImageFactory>();
var mockedDateProvider = new Mock <IDateProvider>();
var mockedLakeService = new Mock <ILakeService>();
var mockedImageGalleryFactory = new Mock <IImageGalleryFactory>();
var mockedDirectoryHelper = new Mock <IDirectoryHelper>();
var controller = new PicturesController(
mockedImageGalleryService.Object,
mockedImageFactory.Object,
mockedDateProvider.Object,
mockedLakeService.Object,
mockedImageGalleryFactory.Object,
mockedDirectoryHelper.Object);
var result = controller.GetGalleries("test") as string;
var expectedResult = JsonConvert.SerializeObject(mockedGalleryCollection);
// Assert
Assert.AreEqual(expectedResult, result);
mockedImageGalleryService.Verify(s => s.GetByLake("test"), Times.Once);
}
public void GetReturnsProductWithSameId()
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <Picture, PictureDTO>() // automatski će mapirati Author.Name u AuthorName
.ForMember(dest => dest.GalleryName, opt => opt.MapFrom(src => src.Galery.Name)); // ako želimo eksplicitno zadati mapiranje
});
// Arrange
var mockRepository = new Mock <IPictureRepo>();
mockRepository.Setup(x => x.GetById(42)).Returns(new Picture {
Id = 42
});
var controller = new PicturesController(mockRepository.Object);
// Act
IHttpActionResult actionResult = controller.GetById(42);
var contentResult = actionResult as OkNegotiatedContentResult <PictureDTO>;
// Assert
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual(42, contentResult.Content.Id);
}
public void AddErrorToModelState_IfFileIsNull()
{
// Arrange
var mockedImageGalleryService = new Mock <IImageGalleryService>();
var mockedImageFactory = new Mock <IImageFactory>();
var mockedDateProvider = new Mock <IDateProvider>();
var mockedLakeService = new Mock <ILakeService>();
mockedLakeService.Setup(s => s.GetAll()).Verifiable();
var mockedImageGalleryFactory = new Mock <IImageGalleryFactory>();
var mockedDirectoryHelper = new Mock <IDirectoryHelper>();
var controller = new PicturesController(
mockedImageGalleryService.Object,
mockedImageFactory.Object,
mockedDateProvider.Object,
mockedLakeService.Object,
mockedImageGalleryFactory.Object,
mockedDirectoryHelper.Object);
var model = new AddImageViewModel();
// Act
var result = controller.Add(null, model) as ViewResult;
// Assert
Assert.AreEqual(
GlobalMessages.NoFileErrorMessage,
result.ViewData.ModelState[""].Errors.First().ErrorMessage);
}
public void PicturesController_Details()
{
//Arrange
var pictureRepo = new FakeRepository <Picture>(p => p.PictureID);
var tagsRepo = new FakeRepository <Tag>(e => e.TagID);
var postedfilesKeyCollection = new Mock <HttpFileCollectionBase>();
var fakeFileKeys = new List <string>()
{
"file"
};
var postedfile = new Mock <HttpPostedFileBase>();
Request.Setup(req => req.Files).Returns(postedfilesKeyCollection.Object);
postedfilesKeyCollection.Setup(keys => keys.GetEnumerator()).Returns(fakeFileKeys.GetEnumerator());
postedfilesKeyCollection.Setup(keys => keys["file"]).Returns(postedfile.Object);
postedfile.Setup(e => e.InputStream).Returns(new MemoryStream(TEST_BMP));
postedfile.Setup(e => e.FileName).Returns("filename");
postedfile.Setup(e => e.ContentLength).Returns(TEST_BMP.Length);
postedfile.Verify(f => f.SaveAs(It.IsAny <string>()), Times.AtMostOnce());
//Act
var controller = new PicturesController(pictureRepo, tagsRepo);
controller.ControllerContext = new ControllerContext(Context.Object, new RouteData(), controller);
var result = controller.Create(postedfile.Object, "tag1, tag2, tag3", "custom name") as RedirectToRouteResult;
var inserted = pictureRepo.GetAll().FirstOrDefault();
var detailsResult = controller.Details(inserted.PictureID) as ViewResult;
//Assert
Assert.IsNotNull(result); // Check if the view returned a valid result
Assert.IsNotNull(inserted); // Check if the picture was inserted
Assert.IsTrue(new string[] { "tag1", "tag2", "tag3" }.SequenceEqual(inserted.Tags.Select(t => t.TagLabel))); // Check if the tags were set correctly
Assert.IsNotNull(detailsResult);
}
public void GetReturnsMultipleObjectsSearch()
{
//Mapper.Initialize(cfg =>
//{
// cfg.CreateMap<Picture, PictureDTO>() // automatski će mapirati Author.Name u AuthorName
// .ForMember(dest => dest.GalleryName, opt => opt.MapFrom(src => src.Galery.Name)); // ako želimo eksplicitno zadati mapiranje
//});
// Arrange
List <Picture> pictures = new List <Picture>();
pictures.Add(new Picture {
Id = 1, Name = "Picture1", Galery = new Gallery {
Id = 1, Name = "blabla"
}
});
pictures.Add(new Picture {
Id = 2, Name = "Picture2", Galery = new Gallery {
Id = 2, Name = "blabla"
}
});
var mockRepository = new Mock <IPictureRepo>();
mockRepository.Setup(x => x.GetAll()).Returns(pictures.AsQueryable);
var controller = new PicturesController(mockRepository.Object);
// Act
var result = controller.Get();
// Assert
Assert.IsNotNull(result);
Assert.AreEqual(pictures.Count, result.ToList().Count);
Assert.AreEqual(pictures.ElementAt(0).Id, result.ElementAt(0).Id);
Assert.AreEqual(pictures.ElementAt(1).Id, result.ElementAt(1).Id);
}
public void ReturnSuccess_IfConfirmingImageNotFailed()
{
// Arrange
var mockedImageGalleryService = new Mock <IImageGalleryService>();
mockedImageGalleryService.Setup(s => s.ConfirmImage(It.IsAny <string>()))
.Verifiable();
var mockedImageFactory = new Mock <IImageFactory>();
var mockedDateProvider = new Mock <IDateProvider>();
var mockedLakeService = new Mock <ILakeService>();
var mockedImageGalleryFactory = new Mock <IImageGalleryFactory>();
var mockedDirectoryHelper = new Mock <IDirectoryHelper>();
var controller = new PicturesController(
mockedImageGalleryService.Object,
mockedImageFactory.Object,
mockedDateProvider.Object,
mockedLakeService.Object,
mockedImageGalleryFactory.Object,
mockedDirectoryHelper.Object);
var mockedImageId = "Mocked Image Id";
// Act
var result = controller.Confirm(mockedImageId);
// Assert
StringAssert.Contains("success", result);
StringAssert.Contains(GlobalMessages.ConfirmImageSuccessMessage, result);
mockedImageGalleryService.Verify(s => s.ConfirmImage(mockedImageId), Times.Once);
}
public async Task Should_AttachPictureProduct_ForNonExistingProduct_Returns404()
{
//arrange
var command = GetCreateProductCommand();
await CreateProductAsync(command);
var addPictureCommand = new AddPictureCommand
{
Description = "Picture from Wadowice",
Url = "http://ubiquitous.com/api/product/picture/2137",
MimeTypeId = MimeType.Jpg.Id,
Filename = "Picture #1"
};
//act
var addPicturePath = PicturesController.AddPicture();
var addResponse = await Client.PostAsJsonAsync(addPicturePath, addPictureCommand);
var postStringResult = await addResponse.Content.ReadAsStringAsync();
var pictureResult = JsonConvert.DeserializeObject <PictureViewModel>(postStringResult);
var attachPictureToProduct = ProductController.AttachPicture(Guid.NewGuid(), pictureResult.Id);
var attachResponse = await Client.PostAsJsonAsync(attachPictureToProduct, new {});
//assert
attachResponse.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
public void ReturnError_IfConfirmingImageFailed()
{
// Arrange
var mockedImageGalleryService = new Mock <IImageGalleryService>();
mockedImageGalleryService.Setup(s => s.ConfirmImage(It.IsAny <string>()))
.Throws <NullReferenceException>();
var mockedImageFactory = new Mock <IImageFactory>();
var mockedDateProvider = new Mock <IDateProvider>();
var mockedLakeService = new Mock <ILakeService>();
var mockedImageGalleryFactory = new Mock <IImageGalleryFactory>();
var mockedDirectoryHelper = new Mock <IDirectoryHelper>();
var controller = new PicturesController(
mockedImageGalleryService.Object,
mockedImageFactory.Object,
mockedDateProvider.Object,
mockedLakeService.Object,
mockedImageGalleryFactory.Object,
mockedDirectoryHelper.Object);
// Act
var result = controller.Confirm(It.IsAny <string>());
// Assert
StringAssert.Contains("error", result);
StringAssert.Contains(GlobalMessages.ConfirmImageErrorMessage, result);
}
public void TestMethod1()
{
Mapper.Initialize(cfg =>
{
cfg.CreateMap <Picture, PictureDTO>()
.ForMember(dest => dest.GaleryName, opt => opt.MapFrom(src => src.Galery.Name))
.ForMember(dest => dest.GaleryId, opt => opt.MapFrom(src => src.Galery.Id));
});
var mockRepository = new Mock <IPictureRepository>();
mockRepository.Setup(x => x.GetById(4)).Returns(new Picture()
{
Id = 4
});
var controller = new PicturesController(mockRepository.Object);
IHttpActionResult actionResult = controller.GetById(4);
var contentResult = actionResult as OkNegotiatedContentResult <PictureDTO>;
Assert.IsNotNull(contentResult);
Assert.IsNotNull(contentResult.Content);
Assert.AreEqual(4, contentResult.Content.Id);
}
public async Task Should_UpdatePicture_Returns200()
{
//arrange
var pictureAdded = await AddPicture();
//act
var command = new UpdatePictureCommand
{
Description = pictureAdded.Description + " Updated",
Filename = pictureAdded.FileName + "Updated",
Url = pictureAdded.Url + "Updated",
PictureId = pictureAdded.Id,
FileStorageUploadId = Guid.NewGuid(),
MimeTypeId = MimeType.Bitmap.Id
};
var putPicture = await Client.PutAsJsonAsync(PicturesController.UpdatePicture(pictureAdded.Id), command);
var getPicture = await Client.GetAsync(PicturesController.GetPicture(pictureAdded.Id));
var getResult = JsonConvert.DeserializeObject <PictureViewModel>(await getPicture.Content.ReadAsStringAsync());
//assert
putPicture.StatusCode.Should().Be(HttpStatusCode.OK);
getPicture.StatusCode.Should().Be(HttpStatusCode.OK);
getResult.Id.Should().Be(command.PictureId);
getResult.Description.Should().Be(command.Description);
getResult.Url.Should().Be(command.Url);
getResult.FileName.Should().Be(command.Filename);
getResult.MimeTypeId.Should().Be(command.MimeTypeId);
getResult.FileStorageUploadId.Should().Be(command.FileStorageUploadId);
}
public void ShouldDeleteAPicture()
{
var id = Guid.NewGuid();
var mockPictureRepository = new Mock <IPictureRepository>();
mockPictureRepository.Setup(r => r.Get(id)).Returns(() =>
{
return(new Picture()
{
Tags = "tag1,tag2"
});
});
var mockTagRepository = new Mock <ITagRepository>();
var pictureController = new PicturesController(mockPictureRepository.Object, mockTagRepository.Object);
pictureController.Delete(id);
mockPictureRepository.Verify(r => r.Get(id), Times.Once());
mockPictureRepository.Verify(r => r.Delete(id), Times.Once());
mockTagRepository.Verify(r => r.DecrementPictureCount("tag1"), Times.Once());
mockTagRepository.Verify(r => r.DecrementPictureCount("tag2"), Times.Once());
mockTagRepository.Verify(r => r.DecrementPictureCount(It.IsAny <string>()), Times.Exactly(2));
}
public void ShouldSaveAPictureWithFileName()
{
var id = Guid.NewGuid();
var mockPictureRepository = new Mock <IPictureRepository>();
mockPictureRepository.Setup(r => r.Save(It.IsAny <Picture>(), It.IsAny <byte[]>())).Returns <Picture, byte[]>((p, i) =>
{
p.Id = id;
p.Url = new Uri("http://foo", UriKind.Absolute);
return(p);
});
var mockTagRepository = new Mock <ITagRepository>();
var pictureController = new PicturesController(mockPictureRepository.Object, mockTagRepository.Object);
var content = new StreamContent(File.OpenRead(Path.Combine(Environment.CurrentDirectory, "multipartStreamEmpty.txt")));
content.Headers.Add("Content-Type", "multipart/form-data; boundary=---------------------------7dcfd134057c");
pictureController.Request = new HttpRequestMessage()
{
Content = content
};
var picture = pictureController.Post();
Assert.AreEqual(picture.Id, id);
Assert.AreEqual(picture.Url.ToString(), "http://foo/");
Assert.AreEqual(picture.Name, "test.txt");
Assert.IsNull(picture.Description);
Assert.IsNull(picture.Tags);
mockTagRepository.Verify(r => r.IncrementPictureCount(It.IsAny <string>()), Times.Never());
}
public void InitTest()
{
this.mock = new MockContainer();
this.mock.PrepareMocks();
this.fakePictures = this.mock.PictureRepositoryMock.Object.All();
this.mockContext = new Mock<IPhotoContestData>();
this.mockContext.Setup(c => c.Pictures.All())
.Returns(this.fakePictures);
this.pictureController = new PicturesController(this.mockContext.Object);
}
public void ReturnCorrectInstance_WhenParametersAreValid()
{
// Arrange
var mockedMappingService = new Mock <IMappingService>();
var mockedPictureService = new Mock <IPictureService>();
// Act
var controller = new PicturesController(mockedMappingService.Object, mockedPictureService.Object);
// Assert
Assert.IsInstanceOf <PicturesController>(controller);
}
public void Test_Get_Pictures_For_Given_User()
{
Thread.CurrentPrincipal =
new GenericPrincipal(new GenericIdentity("cw"), null);
var pc = new PicturesController(
new TodoItemRepository());
var pics = pc.Get().ToList();
Assert.IsNotNull(pics);
Assert.IsTrue(pics.Count > 0);
}
public void CallGetAllPicturesOnce()
{
// Arrange
var mockedMappingService = new Mock <IMappingService>();
var mockedPictureService = new Mock <IPictureService>();
var controller = new PicturesController(mockedMappingService.Object, mockedPictureService.Object);
// Act
controller.Index();
// Assert
mockedPictureService.Verify(x => x.GetAllPictures(), Times.Once);
}
public void CallMapOnce()
{
// Arrange
var mockedMappingService = new Mock <IMappingService>();
var mockedPictureService = new Mock <IPictureService>();
var controller = new PicturesController(mockedMappingService.Object, mockedPictureService.Object);
// Act
controller.Index();
// Assert
mockedMappingService.Verify(x => x.Map <IEnumerable <PictureViewModel> >(It.IsAny <IEnumerable <Picture> >()), Times.Once);
}
public void TestMethod2()
{
// Arrange
var mockRepository = new Mock <IPictureRepository>();
var controller = new PicturesController(mockRepository.Object);
// Act
IHttpActionResult actionResult = controller.Put(10, new Picture {
Id = 9, Name = "Picture2"
});
// Assert
Assert.IsInstanceOfType(actionResult, typeof(BadRequestResult));
}
public async Task Should_DeletePicture_Returns200()
{
//arrange
var pictureAdded = await AddPicture();
//act
var path = PicturesController.DeletePicture(pictureAdded.Id);
var deleteResponse = await Client.DeleteAsync(path);
var getPicture = await Client.GetAsync(PicturesController.GetPicture(pictureAdded.Id));
//assert
deleteResponse.StatusCode.Should().Be(HttpStatusCode.OK);
getPicture.StatusCode.Should().Be(HttpStatusCode.NotFound);
}
public void PicturesController_Index()
{
//Arrange
var pictureRepo = new FakeRepository <Picture>(p => p.PictureID);
var tagsRepo = new FakeRepository <Tag>(e => e.TagID);
//Act
var controller = new PicturesController(pictureRepo, tagsRepo);
controller.ControllerContext = new ControllerContext(Context.Object, new RouteData(), controller);
var result = controller.Index() as ViewResult;
//Assert
Assert.IsNotNull(result);
}
public void ShouldThrowWhenMimeIsNotFormData()
{
try
{
var controller = new PicturesController();
controller.Request = new HttpRequestMessage()
{
Content = new StreamContent(new MemoryStream())
};
controller.Post();
}
catch (HttpResponseException ex)
{
Assert.AreEqual(ex.Response.StatusCode, HttpStatusCode.UnsupportedMediaType);
}
}
public void ShouldRetrieveAllPictures()
{
var mockRepository = new Mock <IPictureRepository>();
mockRepository.Setup(r => r.GetAll()).Returns(() =>
{
var result = new List <Picture>();
result.Add(new Picture());
result.Add(new Picture());
return(result.AsQueryable());
});
var pictureController = new PicturesController(mockRepository.Object, null);
var pictures = pictureController.Get();
Assert.AreEqual(pictures.Count(), 2);
}
public void TestMethod4()
{
List <Picture> lista1 = new List <Picture>();
lista1.Add(new Picture()
{
Id = 1,
Name = "test1",
Price = 120m,
Galery = new Galery()
{
Id = 1, Name = "Galery1"
}
});
lista1.Add(new Picture()
{
Id = 2,
Name = "test2",
Price = 130m,
Galery = new Galery()
{
Id = 2, Name = "Galery2"
}
});
var mockRepository = new Mock <IPictureRepository>();
mockRepository.Setup(x => x.PostSearch(101m, 150m)).Returns(lista1.AsQueryable());
var controller = new PicturesController(mockRepository.Object);
IHttpActionResult result = controller.PostSearch(101m, 150m);
var finalResult = result as OkNegotiatedContentResult <IQueryable <PictureDTO> >;
Assert.IsNotNull(finalResult);
Assert.AreEqual(lista1.Count, finalResult.Content.ToList().Count);
Assert.AreEqual(lista1.ElementAt(0).Id, finalResult.Content.ToList().ElementAt(0).Id);
Assert.AreEqual(lista1.ElementAt(0).Name, finalResult.Content.ToList().ElementAt(0).Name);
Assert.AreEqual(lista1.ElementAt(0).Galery.Name, finalResult.Content.ToList().ElementAt(0).GaleryName);
Assert.AreEqual(lista1.ElementAt(1).Id, finalResult.Content.ToList().ElementAt(1).Id);
Assert.AreEqual(lista1.ElementAt(1).Name, finalResult.Content.ToList().ElementAt(1).Name);
Assert.AreEqual(lista1.ElementAt(1).Galery.Name, finalResult.Content.ToList().ElementAt(1).GaleryName);
}
public void AddErrorMessageToModel_IfAddingImageFail()
{
// Arrange
var mockedImageGalleryService = new Mock <IImageGalleryService>();
var mockedImageFactory = new Mock <IImageFactory>();
var mockedDateProvider = new Mock <IDateProvider>();
mockedDateProvider.Setup(d => d.GetDate()).Throws(new ArgumentException(message: "Test"));
var mockedLakeService = new Mock <ILakeService>();
mockedLakeService.Setup(s => s.GetAll()).Verifiable();
var mockedImageGalleryFactory = new Mock <IImageGalleryFactory>();
var mockedDirectoryHelper = new Mock <IDirectoryHelper>();
var mockedHttpContext = new Mock <ControllerContext>();
mockedHttpContext.Setup(c => c.HttpContext.Server.MapPath(It.IsAny <string>())).Returns("Test");
mockedHttpContext.Setup(c => c.HttpContext.User.IsInRole(It.IsAny <string>())).Returns(true);
var controller = new PicturesController(
mockedImageGalleryService.Object,
mockedImageFactory.Object,
mockedDateProvider.Object,
mockedLakeService.Object,
mockedImageGalleryFactory.Object,
mockedDirectoryHelper.Object);
controller.ControllerContext = mockedHttpContext.Object;
var model = new AddImageViewModel();
var mockedFile = new MockHttpPostedFileBase();
mockedFile.SetContentLength(Constants.ImageMaxSize);
// Act
var result = controller.Add(mockedFile, model) as ViewResult;
// Assert
Assert.AreEqual(
"Test",
result.ViewData.ModelState[""].Errors.First().ErrorMessage);
}
protected async Task <PictureViewModel> AddPicture()
{
var addPictureCommand = new AddPictureCommand
{
Description = "Picture from Wadowice",
Url = "http://ubiquitous.com/api/product/picture/2137",
MimeTypeId = MimeType.Jpg.Id,
Filename = "Picture #1"
};
var addPicturePath = PicturesController.AddPicture();
var addResponse = await Client.PostAsJsonAsync(addPicturePath, addPictureCommand);
var addStringResult = await addResponse.Content.ReadAsStringAsync();
var pictureResult = JsonConvert.DeserializeObject <PictureViewModel>(addStringResult);
addResponse.StatusCode.Should().Be(HttpStatusCode.Created);
return(pictureResult);
}
public void ShouldRetrieveAPicture()
{
var id = Guid.NewGuid();
var mockRepository = new Mock <IPictureRepository>();
mockRepository.Setup(r => r.Get(id)).Returns(() =>
{
return(new Picture()
{
Id = id
});
});
var pictureController = new PicturesController(mockRepository.Object, null);
var pictures = pictureController.Get(id);
Assert.AreEqual(pictures.Id, id);
}
public void TestMethod3()
{
List <Picture> lista = new List <Picture>();
lista.Add(new Picture()
{
Id = 1,
Name = "test1",
Galery = new Galery()
{
Id = 1, Name = "Galery1"
}
});
lista.Add(new Picture()
{
Id = 2,
Name = "test2",
Galery = new Galery()
{
Id = 2, Name = "Galery2"
}
});
var mockRepository = new Mock <IPictureRepository>();
mockRepository.Setup(x => x.GetAll()).Returns(lista.AsQueryable());
var controller = new PicturesController(mockRepository.Object);
IQueryable <PictureDTO> result = controller.GetAll();
Assert.IsNotNull(result);
Assert.AreEqual(lista.Count, result.ToList().Count);
Assert.AreEqual(lista.ElementAt(0).Id, result.ToList().ElementAt(0).Id);
Assert.AreEqual(lista.ElementAt(0).Name, result.ToList().ElementAt(0).Name);
Assert.AreEqual(lista.ElementAt(0).Galery.Name, result.ToList().ElementAt(0).GaleryName);
Assert.AreEqual(lista.ElementAt(1).Id, result.ToList().ElementAt(1).Id);
Assert.AreEqual(lista.ElementAt(1).Name, result.ToList().ElementAt(1).Name);
Assert.AreEqual(lista.ElementAt(1).Galery.Name, result.ToList().ElementAt(1).GaleryName);
}
public void ApiPicturesController_Details()
{
//Arrange
var picturesRepo = new FakeRepository <Picture>(e => e.PictureID);
picturesRepo.Create(new Picture()
{
PictureID = 1,
OwnerID = "OwnerID",
Name = "Testing",
Hash = "Testing",
ThumbnailData = TEST_BMP
});
//Act
var controller = new PicturesController(picturesRepo);
var result = controller.GetPicture(1) as OkNegotiatedContentResult <PictureApi>;
//Assert
Assert.IsNotNull(result);
}
public void GetLakesFromService_AndRetunDefaultView()
{
// Arrange
var mockedLakesCollection = new List <LakeModel>()
{
new LakeModel()
{
Name = "Test"
}
};
var mockedImageGalleryService = new Mock <IImageGalleryService>();
var mockedImageFactory = new Mock <IImageFactory>();
var mockedDateProvider = new Mock <IDateProvider>();
var mockedLakeService = new Mock <ILakeService>();
mockedLakeService.Setup(s => s.GetAll()).Returns(mockedLakesCollection).Verifiable();
var mockedImageGalleryFactory = new Mock <IImageGalleryFactory>();
var mockedDirectoryHelper = new Mock <IDirectoryHelper>();
var controller = new PicturesController(
mockedImageGalleryService.Object,
mockedImageFactory.Object,
mockedDateProvider.Object,
mockedLakeService.Object,
mockedImageGalleryFactory.Object,
mockedDirectoryHelper.Object);
// Act
var result = controller.Add() as ViewResult;
var model = result.Model as AddImageViewModel;
// Assert
Assert.AreEqual("", result.ViewName);
Assert.AreEqual(mockedLakesCollection, model.Lakes);
mockedLakeService.Verify(s => s.GetAll(), Times.Once);
}
public void ApiPicturesController_Index()
{
//Arrange
var picturesRepo = new FakeRepository <Picture>(e => e.PictureID);
picturesRepo.Create(new Picture()
{
PictureID = 1,
OwnerID = "OwnerID",
Name = "Testing",
Hash = "Testing",
ThumbnailData = TEST_BMP
});
//Act
var controller = new PicturesController(picturesRepo);
var result = controller.GetPictures() as IEnumerable <PictureApi>;
//Assert
Assert.IsNotNull(result);
Assert.IsNotNull(result.ToList());
Assert.IsTrue(result.ToList().Count() > 0);
}
