Beispiel #1
0
        public async Task SegmentControllerUpdateReturnsSuccessForExistingItem(string mediaTypeName)
        {
            // Arrange
            const HttpStatusCode expectedResponse = HttpStatusCode.OK;
            var controller = BuildSegmentController(mediaTypeName);

            var existingModel = A.Fake <CurrentOpportunitiesSegmentModel>();
            var modelToUpsert = A.Fake <CurrentOpportunitiesSegmentModel>();

            existingModel.SequenceNumber = 123;
            modelToUpsert.SequenceNumber = existingModel.SequenceNumber + 1;

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByIdAsync(A <Guid> .Ignored)).Returns(existingModel);
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.UpsertAsync(A <CurrentOpportunitiesSegmentModel> .Ignored)).Returns(expectedResponse);

            // Act
            var result = await controller.Put(modelToUpsert).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByIdAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.UpsertAsync(A <CurrentOpportunitiesSegmentModel> .Ignored)).MustHaveHappenedOnceExactly();

            var statusCodeResult = Assert.IsType <StatusCodeResult>(result);

            Assert.Equal((int)expectedResponse, statusCodeResult.StatusCode);

            controller.Dispose();
        }
        public async Task SegmentControllerBodyReturnsNotAcceptable(string mediaTypeName)
        {
            // Arrange
            var documentId         = Guid.NewGuid();
            var expectedResult     = A.Fake <CurrentOpportunitiesSegmentModel>();
            var dummyBodyViewModel = A.Dummy <BodyViewModel>();

            dummyBodyViewModel.Data         = A.Dummy <BodyDataViewModel>();
            dummyBodyViewModel.Data.Courses = A.Dummy <BodyCoursesViewModel>();

            var controller = BuildSegmentController(mediaTypeName);

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByIdAsync(A <Guid> .Ignored)).Returns(expectedResult);
            A.CallTo(() => FakeMapper.Map <BodyViewModel>(A <CurrentOpportunitiesSegmentModel> .Ignored)).Returns(dummyBodyViewModel);

            // Act
            var result = await controller.Body(documentId).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByIdAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeMapper.Map <BodyViewModel>(A <CurrentOpportunitiesSegmentModel> .Ignored)).MustHaveHappenedOnceExactly();

            var statusResult = Assert.IsType <StatusCodeResult>(result);

            Assert.Equal((int)HttpStatusCode.NotAcceptable, statusResult.StatusCode);

            controller.Dispose();
        }
        public async Task SegmentControllerBodyJsonReturnsSuccess(string mediaTypeName)
        {
            // Arrange
            var documentId     = Guid.NewGuid();
            var expectedResult = A.Fake <CurrentOpportunitiesSegmentModel>();

            expectedResult.Data = A.Dummy <CurrentOpportunitiesSegmentDataModel>();
            var dummyBodyViewModel = A.Dummy <BodyViewModel>();

            dummyBodyViewModel.Data         = A.Dummy <BodyDataViewModel>();
            dummyBodyViewModel.Data.Courses = A.Dummy <BodyCoursesViewModel>();

            var controller = BuildSegmentController(mediaTypeName);

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByIdAsync(A <Guid> .Ignored)).Returns(expectedResult);
            A.CallTo(() => FakeMapper.Map <BodyViewModel>(A <CurrentOpportunitiesSegmentModel> .Ignored)).Returns(dummyBodyViewModel);

            // Act
            var result = await controller.Body(documentId).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByIdAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeMapper.Map <BodyViewModel>(A <CurrentOpportunitiesSegmentModel> .Ignored)).MustHaveHappenedOnceExactly();

            var jsonResult = Assert.IsType <OkObjectResult>(result);
            var model      = Assert.IsAssignableFrom <CurrentOpportunitiesSegmentDataModel>(jsonResult.Value);

            controller.Dispose();
        }
Beispiel #4
0
        public async Task ReturnsSuccessForHtmlMediaType(string mediaTypeName)
        {
            // Arrange
            var controller = BuildSegmentController(mediaTypeName);
            var dbModels   = GetSegmentModels();

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetAllAsync()).Returns(dbModels);

            // Act
            var result = await controller.RefreshDocuments().ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeJobProfileSegmentRefreshService.SendMessageListAsync(A <List <RefreshJobProfileSegmentServiceBusModel> > .Ignored)).MustHaveHappenedOnceExactly();
            var res = Assert.IsType <JsonResult>(result);

            Assert.Equal(dbModels.Count, (res.Value as List <RefreshJobProfileSegmentServiceBusModel>).Count);

            controller.Dispose();
        }
Beispiel #5
0
        public async Task HealthControllerHealthReturnsServiceUnavailableWhenException()
        {
            // Arrange
            var controller = BuildHealthController(MediaTypeNames.Application.Json);

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.PingAsync()).Throws <Exception>();

            // Act
            var result = await controller.Health().ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.PingAsync()).MustHaveHappenedOnceExactly();

            var statusResult = Assert.IsType <StatusCodeResult>(result);

            Assert.Equal((int)HttpStatusCode.ServiceUnavailable, statusResult.StatusCode);

            controller.Dispose();
        }
Beispiel #6
0
        public async Task ReturnsNoContentWhenNoData(string mediaTypeName)
        {
            // Arrange
            List <CurrentOpportunitiesSegmentModel> expectedResult = null;
            var controller = BuildSegmentController(mediaTypeName);

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetAllAsync()).Returns(expectedResult);

            // Act
            var result = await controller.RefreshDocuments().ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeJobProfileSegmentRefreshService.SendMessageListAsync(A <List <RefreshJobProfileSegmentServiceBusModel> > .Ignored)).MustNotHaveHappened();
            var statusResult = Assert.IsType <NoContentResult>(result);

            A.CallTo(() => FakeLogger.LogWarning(A <string> .Ignored)).MustHaveHappenedOnceExactly();
            Assert.Equal((int)HttpStatusCode.NoContent, statusResult.StatusCode);

            controller.Dispose();
        }
Beispiel #7
0
        public async Task SegmentControllerCreateReturnsAlreadyReportedForExisting(string mediaTypeName)
        {
            // Arrange
            var currentOpportunitiesSegmentModel = A.Fake <CurrentOpportunitiesSegmentModel>();
            var controller = BuildSegmentController(mediaTypeName);

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByIdAsync(A <Guid> .Ignored)).Returns(A.Fake <CurrentOpportunitiesSegmentModel>());

            // Act
            var result = await controller.Post(currentOpportunitiesSegmentModel).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByIdAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();

            var statusCodeResult = Assert.IsType <StatusCodeResult>(result);

            Assert.Equal((int)HttpStatusCode.AlreadyReported, statusCodeResult.StatusCode);

            controller.Dispose();
        }
Beispiel #8
0
        public async Task SegmentControllerPatchJobProfileSocReturnsNotFound(string mediaTypeName)
        {
            // Arrange
            const HttpStatusCode expectedResponse = HttpStatusCode.NotFound;
            var patchModel = A.Fake <PatchJobProfileSocModel>();
            var documentId = Guid.NewGuid();
            var controller = BuildSegmentController(mediaTypeName);

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.PatchJobProfileSocAsync(patchModel, documentId)).Returns(expectedResponse);

            // Act
            var result = await controller.PatchJobProfileSoc(patchModel, documentId).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.PatchJobProfileSocAsync(patchModel, documentId)).MustHaveHappenedOnceExactly();
            var statusResult = Assert.IsType <StatusCodeResult>(result);

            Assert.Equal((int)expectedResponse, statusResult.StatusCode);

            controller.Dispose();
        }
Beispiel #9
0
        public async Task SegmentControllerDeleteReturnsNotFound(string mediaTypeName)
        {
            // Arrange
            Guid documentId = Guid.NewGuid();
            CurrentOpportunitiesSegmentModel expectedResult = null;
            var controller = BuildSegmentController(mediaTypeName);

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByIdAsync(A <Guid> .Ignored)).Returns(expectedResult);

            // Act
            var result = await controller.Delete(documentId).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByIdAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();

            var statusResult = Assert.IsType <NotFoundResult>(result);

            Assert.Equal((int)HttpStatusCode.NotFound, statusResult.StatusCode);

            controller.Dispose();
        }
Beispiel #10
0
        public async Task SegmentControllerUpdateReturnsNotFoundForNonExisting(string mediaTypeName)
        {
            // Arrange
            const HttpStatusCode expectedResponse = HttpStatusCode.NotFound;
            var currentOpportunitiesSegmentModel  = A.Fake <CurrentOpportunitiesSegmentModel>();
            var controller = BuildSegmentController(mediaTypeName);

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByIdAsync(A <Guid> .Ignored)).Returns((CurrentOpportunitiesSegmentModel)null);

            // Act
            var result = await controller.Put(currentOpportunitiesSegmentModel).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByIdAsync(A <Guid> .Ignored)).MustHaveHappenedOnceExactly();

            var statusCodeResult = Assert.IsType <StatusCodeResult>(result);

            Assert.Equal((int)expectedResponse, statusCodeResult.StatusCode);

            controller.Dispose();
        }
Beispiel #11
0
        public async Task SegmentControllerDocumentHtmlReturnsNoContentWhenNoData(string mediaTypeName)
        {
            // Arrange
            const string article = "an-article-name";
            CurrentOpportunitiesSegmentModel expectedResult = null;
            var controller = BuildSegmentController(mediaTypeName);

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByNameAsync(A <string> .Ignored)).Returns(expectedResult);

            // Act
            var result = await controller.Document(article).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByNameAsync(A <string> .Ignored)).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeMapper.Map <DocumentViewModel>(A <CurrentOpportunitiesSegmentModel> .Ignored)).MustNotHaveHappened();

            var statusResult = Assert.IsType <NoContentResult>(result);

            Assert.Equal((int)HttpStatusCode.NoContent, statusResult.StatusCode);

            controller.Dispose();
        }
Beispiel #12
0
        public async Task HealthControllerHealthReturnsSuccessWhenhealthy()
        {
            // Arrange
            var controller = BuildHealthController(MediaTypeNames.Application.Json);

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.PingAsync()).Returns(true);

            // Act
            var result = await controller.Health().ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.PingAsync()).MustHaveHappenedOnceExactly();

            var jsonResult = Assert.IsType <OkObjectResult>(result);
            var model      = Assert.IsAssignableFrom <HealthViewModel>(jsonResult.Value);

            Assert.True(model.HealthItems.Count > 0);
            Assert.True(!string.IsNullOrWhiteSpace(model.HealthItems.First().Service));
            Assert.True(!string.IsNullOrWhiteSpace(model.HealthItems.First().Message));

            controller.Dispose();
        }
Beispiel #13
0
        public async Task SegmentControllerDocumentHtmlReturnsSuccess(string mediaTypeName)
        {
            // Arrange
            var expectedResult    = A.Fake <CurrentOpportunitiesSegmentModel>();
            var controller        = BuildSegmentController(mediaTypeName);
            var documentViewModel = GetDocumentViewModel();

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByNameAsync(A <string> .Ignored)).Returns(expectedResult);
            A.CallTo(() => FakeMapper.Map <DocumentViewModel>(A <CurrentOpportunitiesSegmentModel> .Ignored)).Returns(documentViewModel);

            // Act
            var result = await controller.Document(Article).ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByNameAsync(A <string> .Ignored)).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeMapper.Map <DocumentViewModel>(A <CurrentOpportunitiesSegmentModel> .Ignored)).MustHaveHappenedOnceExactly();

            var viewResult = Assert.IsType <ViewResult>(result);

            Assert.IsAssignableFrom <DocumentViewModel>(viewResult.ViewData.Model);

            controller.Dispose();
        }
        public async Task JobTitlePrefixDefaultTests(string jobTitle, string titlePrefix, string expectedTitle)
        {
            //Arrange
            var documentId = Guid.NewGuid();

            testSegmentModel.Data.JobTitle    = jobTitle;
            testSegmentModel.Data.TitlePrefix = titlePrefix;

            var controller = BuildSegmentController(MediaTypeNames.Text.Html);

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetByIdAsync(A <Guid> .Ignored)).Returns(testSegmentModel);
            A.CallTo(() => FakeMapper.Map <BodyViewModel>(A <CurrentOpportunitiesSegmentModel> .Ignored)).Returns(testBodyViewModel);

            // Act
            var result = await controller.Body(documentId).ConfigureAwait(false);

            //Asserts
            var viewResult = Assert.IsType <ViewResult>(result);
            var model      = viewResult.Model as BodyViewModel;

            model.Data.JobTitleWithPrefix.Should().Be(expectedTitle);
            controller.Dispose();
        }
        public async Task SegmentControllerIndexHtmlReturnsSuccessWhenNoData(string mediaTypeName)
        {
            // Arrange
            const int resultsCount = 0;
            IEnumerable <CurrentOpportunitiesSegmentModel> expectedResults = null;
            var controller = BuildSegmentController(mediaTypeName);

            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetAllAsync()).Returns(expectedResults);
            A.CallTo(() => FakeMapper.Map <IndexDocumentViewModel>(A <CurrentOpportunitiesSegmentModel> .Ignored)).Returns(A.Fake <IndexDocumentViewModel>());

            // Act
            var result = await controller.Index().ConfigureAwait(false);

            // Assert
            A.CallTo(() => FakeCurrentOpportunitiesSegmentService.GetAllAsync()).MustHaveHappenedOnceExactly();
            A.CallTo(() => FakeMapper.Map <IndexDocumentViewModel>(A <CurrentOpportunitiesSegmentModel> .Ignored)).MustHaveHappened(resultsCount, Times.Exactly);

            var viewResult = Assert.IsType <ViewResult>(result);
            var model      = Assert.IsAssignableFrom <IndexViewModel>(viewResult.ViewData.Model);

            Assert.Null(model.Documents);

            controller.Dispose();
        }