public void RenderPartialView_PublicationCommentPartial()
{
// Arrange
var mockedPublicationService = new Mock <IPublicationService>();
var mockedTextService = new Mock <ITextService>();
var mockedViewModelService = new Mock <IViewModelService>();
var comments = new List <CommentViewModel>()
{
new CommentViewModel(),
new CommentViewModel()
};
mockedViewModelService.Setup(x => x.GetMappedComments(It.IsAny <Publication>())).Returns(comments);
var publicationController = new PublicationController(
mockedPublicationService.Object,
mockedTextService.Object,
mockedViewModelService.Object);
int id = 5;
// Act & Assert
publicationController
.WithCallTo(x => x.Comments(id))
.ShouldRenderPartialView("_PublicationCommentPartial")
.WithModel <IList <CommentViewModel> >(m =>
{
Assert.AreEqual(comments, m);
});
}
public async void Task_Update_Publication_Return_OkResult()
{
//Arrange
var controller = new PublicationController(context);
int id = 2;
var publication = new Publication()
{
PublicationId = 2,
PublicationName = "New Delhi Publisher",
PublicationDescription = "New Delhi Publishers is an International repute publisher with an orientation towards research, practical and Technical Applications.",
PublicationImage = "http://ndpublisher.in/images/default-logo.png"
//PublicationId = 2,
//PublicationName = "Penguin Random House LLC.",
//PublicationDescription = "Random House is an American book publisher and the largest general-interest paperback publisher in the world. As of 2013, it is part of Penguin Random House, which is jointly owned by German media conglomerate Bertelsmann and British global education and publishing company Pearson PLC.",
//PublicationImage = "https://www.penguinrandomhouse.com/wp-content/themes/penguinrandomhouse/images/prh-logo.png"
};
//Act
var updateData = await controller.Put(id, publication);
//Assert
Assert.IsType <OkObjectResult>(updateData);
}
public void Task_Edit_Publication_Return_View()
{
Assert.Throws <NotImplementedException>(() =>
{
//Arrange
var controller = new PublicationController(context);
int id = 1;
var pub = new Publication()
{
PublicationId = 1,
PublicationName = "Penguin",
PublicationDescription = "description",
PublicationImage = "image"
};
//Act
var EditData = controller.Edit(id, pub);
//Assert
Assert.IsType <ViewResult>(EditData);
});
}
private PublicationController SetupControllerMultipleYearsChoiceSelection()
{
var frmServiceMock = new Mock <IReportsPublicationService>();
var yearModelList = new List <PeriodEndCalendarYearAndPeriodModel>();
yearModelList.Add(new PeriodEndCalendarYearAndPeriodModel
{
CollectionYear = 1920,
PeriodNumber = 1
});
yearModelList.Add(new PeriodEndCalendarYearAndPeriodModel
{
CollectionYear = 1819,
PeriodNumber = 1
});
frmServiceMock.Setup(x => x.GetReportsDataAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(yearModelList);
var yearList = new List <int>()
{
1819,
1920
};
frmServiceMock.Setup(x => x.GetLastTwoCollectionYearsAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(yearList);
var iIndex = new Mock <IIndex <PersistenceStorageKeys, IFileService> >();
var controller = new PublicationController(null, frmServiceMock.Object, null, null, null);
return(controller);
}
public async void CreatePublication_Ok()
{
var publicationService = new Mock <IPublicationService>();
publicationService
.Setup(s => s.CreatePublication(It.IsAny <SavePublicationViewModel>()))
.Returns <SavePublicationViewModel>(p =>
Task.FromResult(new Either <ActionResult, PublicationViewModel>(
new PublicationViewModel
{
TopicId = p.TopicId
})
)
);
var controller = new PublicationController(publicationService.Object);
var topicId = Guid.NewGuid();
// Method under test
var result = await controller.CreatePublication(new SavePublicationViewModel()
{
TopicId = topicId
});
Assert.IsType <PublicationViewModel>(result.Value);
Assert.Equal(topicId, result.Value.TopicId);
}
private PublicationController SetupControllerWithLogger(int periodNumber = 0, int collectionYear = 0)
{
var frmServiceMock = new Mock <IReportsPublicationService>();
frmServiceMock.Setup(x => x.RunValidationAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(100);
frmServiceMock.Setup(x => x.GetFrmStatusAsync(0, It.IsAny <CancellationToken>())).ReturnsAsync(6);
frmServiceMock.Setup(x => x.GetFrmStatusAsync(1, It.IsAny <CancellationToken>())).ReturnsAsync(5);
frmServiceMock.Setup(x => x.GetFrmStatusAsync(2, It.IsAny <CancellationToken>())).ReturnsAsync(8);
frmServiceMock.Setup(x => x.GetFrmStatusAsync(3, It.IsAny <CancellationToken>())).ReturnsAsync(4);
frmServiceMock.Setup(x => x.GetFrmStatusAsync(4, It.IsAny <CancellationToken>())).ReturnsAsync(3);
frmServiceMock.Setup(x => x.GetFileSubmittedDetailsAsync(It.IsAny <long>(), It.IsAny <CancellationToken>())).ReturnsAsync(
new JobDetails()
{
DateTimeSubmitted = new DateTime(2000, 2, 3),
CollectionYear = collectionYear,
PeriodNumber = periodNumber,
});
var iIndex = new Mock <IIndex <PersistenceStorageKeys, IFileService> >();
var logger = new Mock <ILogger>();
var controller = new PublicationController(logger.Object, frmServiceMock.Object, null, null, null);
var mockcontext = new Mock <HttpContext>();
var mockTempProvider = new Mock <ITempDataProvider>();
controller.TempData = new TempDataDictionary(mockcontext.Object, mockTempProvider.Object);
return(controller);
}
public async void CreatePublication_ValidationFailure()
{
var publicationService = new Mock <IPublicationService>();
var validationResponse =
new Either <ActionResult, PublicationViewModel>(
ValidationUtils.ValidationActionResult(ValidationErrorMessages.SlugNotUnique));
publicationService
.Setup(s => s.CreatePublication(It.IsAny <SavePublicationViewModel>()))
.Returns <SavePublicationViewModel>(p => Task.FromResult(validationResponse));
var controller = new PublicationController(publicationService.Object);
var topicId = Guid.NewGuid();
// Method under test
var result = await controller.CreatePublication(new SavePublicationViewModel()
{
TopicId = topicId
});
var badRequestObjectResult = Assert.IsType <BadRequestObjectResult>(result.Result);
var value = Assert.IsType <ValidationProblemDetails>(badRequestObjectResult.Value);
Assert.Contains("SLUG_NOT_UNIQUE", value.Errors.First().Value);
}
public async Task GetPublicationTitle()
{
var publicationId = Guid.NewGuid();
var fileStorageService = new Mock <IFileStorageService>();
fileStorageService
.Setup(s =>
s.GetDeserialized <PublicationTitleViewModel>("publications/publication-a/publication.json")
)
.ReturnsAsync(new PublicationTitleViewModel
{
Id = publicationId,
Title = "Test title"
});
var controller = new PublicationController(fileStorageService.Object);
var publicationTitleViewModel = (await controller.GetPublicationTitle("publication-a")).Value;
Assert.IsType <PublicationTitleViewModel>(publicationTitleViewModel);
Assert.Equal(publicationId, publicationTitleViewModel.Id);
Assert.Equal("Test title", publicationTitleViewModel.Title);
}
public void RenderPartialView_PublicationPartial()
{
// Arrange
var mockedPublicationService = new Mock <IPublicationService>();
var mockedTextService = new Mock <ITextService>();
var mockedViewModelService = new Mock <IViewModelService>();
var publications = new List <PublicationViewModel>()
{
new PublicationViewModel(),
new PublicationViewModel()
};
mockedViewModelService.Setup(x => x.GetMappedPublications(It.IsAny <IEnumerable <Publication> >())).Returns(publications);
var publicationController = new PublicationController(
mockedPublicationService.Object,
mockedTextService.Object,
mockedViewModelService.Object);
string id = "some-id";
int skip = 2;
int count = 5;
// Act & Assert
publicationController
.WithCallTo(x => x.Publications(id, skip, count))
.ShouldRenderPartialView("_PublicationPartial")
.WithModel <IEnumerable <PublicationViewModel> >(m =>
{
Assert.AreEqual(publications, m);
});
}
public async void Task_GetPublicationById_Return_OkResult()
{
var controller = new PublicationController(context);
var PublicationId = 2;
var data = await controller.Get(PublicationId);
Assert.IsType <OkObjectResult>(data);
}
public async void Task_GetPublicationById_Return_NotFound()
{
var controller = new PublicationController(context);
var PublicationId = 6;
var data = await controller.Get(PublicationId);
Assert.IsType <NotFoundResult>(data);
}
public void Task_GetBookById_Return_OkResult()
{
var controller = new PublicationController(context);
var BookId = 1;
var data = controller.Display(BookId);
Assert.IsType <ViewResult>(data);
}
// Event for when the user clicks the 'Reset' button in the PublicationListView
private void ResetFilter_Click(object sender, RoutedEventArgs e)
{
int yearFrom = 0;
int yearTo = 9999;
TextYearFrom.Text = "" + yearFrom;
TextYearTo.Text = "" + yearTo;
VisiblePublications = PublicationController.FilterPublications(yearFrom, yearTo, SelectedResearcher.Publications);
}
// Event for when the user changes their selection in the PublicationListView
private void PublicationsListView_SelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (PublicationsListView.Items.Count > 0 && PublicationsListView.SelectedItem != null)
{
Publication selected = VisiblePublications[PublicationsListView.SelectedIndex];
PublicationController.LoadFullPublicationDetails(selected);
SelectedPublication = selected;
}
}
) BuildControllerAndMocks()
{
var publicationService = new Mock <IPublicationService>(Strict);
var releaseService = new Mock <IReleaseService>(Strict);
var cacheKeyService = new Mock <ICacheKeyService>(Strict);
var controller = new PublicationController(
publicationService.Object, releaseService.Object, cacheKeyService.Object);
return(controller, (publicationService, releaseService, cacheKeyService, CacheService));
}
public void Task_Delete_Publication_Return_View()
{
//Arrange
var controller = new PublicationController(context);
var id = 1;
//Act
var data = controller.Delete(id);
//Assert
Assert.IsType <ViewResult>(data);
}
public void Task_Create_Publication_Return_OkResult()
{
//Arrange
var controller = new PublicationController(context);
//Act
var data = controller.Create();
//Assert
Assert.IsType <ViewResult>(data);
}
// Event for when the user clicks the 'Filter' button in the PublicationListView
private void FilterPublications_Click(object sender, RoutedEventArgs e)
{
if (!Int32.TryParse(TextYearFrom.Text, out int yearFrom) || !Int32.TryParse(TextYearTo.Text, out int yearTo))
{
MessageBox.Show("An error occured whilst parsing publication filter.\n\nPlease ensure that the entered text is a valid number.", Title, MessageBoxButton.OK, MessageBoxImage.Error);
}
else
{
VisiblePublications = PublicationController.FilterPublications(yearFrom, yearTo, SelectedResearcher.Publications);
}
}
private PublicationController SetupControllerNoDataChoiceSelection()
{
var frmServiceMock = new Mock <IReportsPublicationService>();
frmServiceMock.Setup(x => x.GetReportsDataAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(new List <PeriodEndCalendarYearAndPeriodModel>());
frmServiceMock.Setup(x => x.GetLastTwoCollectionYearsAsync(It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(new List <int>());
var iIndex = new Mock <IIndex <PersistenceStorageKeys, IFileService> >();
var controller = new PublicationController(null, frmServiceMock.Object, null, null, null);
return(controller);
}
public async void Task_DeletePublication_Return_BadRequest()
{
//Arrange
var controller = new PublicationController(context);
int?id = null;
//Act
var data = await controller.Get(id);
//Assert
Assert.IsType <BadRequestResult>(data);
}
public async void Task_DeletePublication_Return_OkResult()
{
//Arrange
var controller = new PublicationController(context);
var id = 17;
//Act
var data = await controller.Delete(id);
//Assert
Assert.IsType <OkObjectResult>(data);
}
public async void Task_Get_All_Publications_Return_OkResult()
{
//Arrange
var controller = new PublicationController(context);
//Act
var data = await controller.Get();
//Assert
Assert.IsType <OkObjectResult>(data);
}
private PublicationController SetupController()
{
var collectionServiceMock = new Mock <ICollectionsService>();
var frmServiceMock = new Mock <IReportsPublicationService>();
frmServiceMock.Setup(x => x.RunValidationAsync(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <int>(), It.IsAny <string>(), It.IsAny <CancellationToken>())).ReturnsAsync(100);
frmServiceMock.Setup(x => x.RunPublishAsync(It.IsAny <long>(), It.IsAny <CancellationToken>())).ReturnsAsync(100);
var iIndex = new Mock <IIndex <PersistenceStorageKeys, IFileService> >();
var controller = new PublicationController(null, frmServiceMock.Object, null, collectionServiceMock.Object, null);
return(controller);
}
public async Task GetPublicationMethodology_NotFound()
{
var fileStorageService = new Mock <IFileStorageService>();
fileStorageService
.Setup(s => s.GetDeserialized <PublicationMethodologyViewModel>(It.IsAny <string>()))
.ReturnsAsync(new NotFoundResult());
var controller = new PublicationController(fileStorageService.Object);
var result = await controller.GetPublicationMethodology("missing-publication");
Assert.IsType <NotFoundResult>(result.Result);
}
public async void Task_Delete_Return_NotFound()
{
//Arrange
var controller = new PublicationController(context);
var id = 10;
//Act
var data = await controller.Delete(id);
//Assert
Assert.IsType <NotFoundResult>(data);
}
private PublicationController SetupControllerError()
{
var frmServiceMock = new Mock <IReportsPublicationService>();
frmServiceMock.Setup(x => x.PublishSldAsync(It.IsAny <long>(), It.IsAny <CancellationToken>())).ThrowsAsync(new Exception());
frmServiceMock.Setup(x => x.UnpublishSldAsync(It.IsAny <string>(), It.IsAny <int>(), It.IsAny <CancellationToken>())).ThrowsAsync(new Exception());
var iIndex = new Mock <IIndex <PersistenceStorageKeys, IFileService> >();
var logger = new Mock <ILogger>();
var controller = new PublicationController(logger.Object, frmServiceMock.Object, null, null, null);
var mockcontext = new Mock <HttpContext>();
var mockTempProvider = new Mock <ITempDataProvider>();
controller.TempData = new TempDataDictionary(mockcontext.Object, mockTempProvider.Object);
return(controller);
}
public void PublicationController_Get()
{
// Arrange
var controller = new PublicationController(_mockCoreServiceProvider.Object);
controller.Request = _mockHttpRequestMessage.Object;
controller.Configuration = _mockHttpConfiguration.Object;
// Act
var id = "";
var response = controller.Get(id);
IEnumerable <Publication> result;
Assert.IsTrue(response.TryGetContentValue(out result));
// Assert
//Assert.That(result.FirstOrDefault().Title.Equals("test"));
}
public PublicationControllerTests()
{
publicationService = Mock.Create <IPublicationService>();
nomenclatureService = Mock.Create <INomenclatureService>();
sessionStorageService = Mock.Create <ISessionStorageService>();
publicationController = new PublicationController(
Logger,
Mapper,
ContextManager,
ResourceManager,
nomenclatureService,
publicationService,
sessionStorageService);
InitContext();
}
public void ReturnInstanceOfPublicationController_Correct()
{
// Arrange
var mockedPublicationService = new Mock <IPublicationService>();
var mockedTextService = new Mock <ITextService>();
var mockedViewModelService = new Mock <IViewModelService>();
// Act
var publicationController = new PublicationController(
mockedPublicationService.Object,
mockedTextService.Object,
mockedViewModelService.Object);
// Assert
Assert.IsNotNull(publicationController);
Assert.IsInstanceOf <PublicationController>(publicationController);
}
public async void Task_GetPublicationById_Return_MatchedData()
{
//Arrange
var controller = new PublicationController(context);
var PublicationId = 2;
//Act
var data = await controller.Get(PublicationId);
//Assert
Assert.IsType <OkObjectResult>(data);
var okResult = data.Should().BeOfType <OkObjectResult>().Subject;
var publication = okResult.Value.Should().BeAssignableTo <Publication>().Subject;
Assert.Equal("New Delhi Publisher", publication.PublicationName);
Assert.Equal("http://ndpublisher.in/images/default-logo.pn", publication.PublicationImage);
}
