public async Task Get()
        {
            var fileStorageService = new Mock <IFileStorageService>();

            fileStorageService.Setup(
                s =>
                s.GetDeserialized <MethodologyViewModel>("methodology/methodologies/test-slug.json"
                                                         )
                )
            .ReturnsAsync(
                new MethodologyViewModel
            {
                Content = new List <ContentSectionViewModel>
                {
                    new ContentSectionViewModel()
                },
                Annexes = new List <ContentSectionViewModel>
                {
                    new ContentSectionViewModel()
                }
            }
                );

            var controller = new MethodologyController(fileStorageService.Object);

            var result = await controller.Get("test-slug");

            var methodologyViewModel = result.Value;

            Assert.IsType <MethodologyViewModel>(methodologyViewModel);

            Assert.Single(methodologyViewModel.Content);
            Assert.Single(methodologyViewModel.Annexes);
        }
        public async void GetMethodologySummaryAsync_Returns_NotFound()
        {
            var methodologyService = new Mock <IMethodologyService>();

            methodologyService.Setup(s => s.GetSummaryAsync(It.Is <Guid>(guid => guid != _methodologyId)))
            .ReturnsAsync(new NotFoundResult());
            var controller = new MethodologyController(methodologyService.Object);

            // Method under test
            var result = await controller.GetMethodologySummaryAsync(Guid.NewGuid());

            Assert.IsAssignableFrom <NotFoundResult>(result.Result);
        }
        public async void GetMethodologySummaryAsync_Returns_Ok()
        {
            var methodologyService = new Mock <IMethodologyService>();

            methodologyService.Setup(s => s.GetSummaryAsync(_methodologyId))
            .ReturnsAsync(new MethodologySummaryViewModel());
            var controller = new MethodologyController(methodologyService.Object);

            // Method under test
            var result = await controller.GetMethodologySummaryAsync(_methodologyId);

            AssertOkResult(result);
        }
        public async void GetMethodologiesAsync_Returns_Ok()
        {
            var methodologyService = new Mock <IMethodologyService>();

            methodologyService.Setup(s => s.ListAsync())
            .ReturnsAsync(
                new Either <ActionResult, List <MethodologySummaryViewModel> >(new List <MethodologySummaryViewModel>()));
            var controller = new MethodologyController(methodologyService.Object);

            // Method under test
            var result = await controller.GetMethodologiesAsync();

            AssertOkResult(result);
        }
        public async Task Get_NotFound()
        {
            var fileStorageService = new Mock <IFileStorageService>();

            fileStorageService
            .Setup(s => s.GetDeserialized <MethodologyViewModel>(It.IsAny <string>()))
            .ReturnsAsync(new NotFoundResult());

            var controller = new MethodologyController(fileStorageService.Object);

            var result = await controller.Get("unknown-slug");

            Assert.IsType <NotFoundResult>(result.Result);
        }
        public async void UpdateMethodologyAsync_Returns_Ok()
        {
            var request = new UpdateMethodologyRequest();

            var methodologyService = new Mock <IMethodologyService>();

            methodologyService.Setup(s => s.UpdateMethodologyAsync(It.IsAny <Guid>(), request))
            .ReturnsAsync(new Either <ActionResult, MethodologySummaryViewModel>(new MethodologySummaryViewModel()));
            var controller = new MethodologyController(methodologyService.Object);

            // Method under test
            var result = await controller.UpdateMethodologyAsync(Guid.NewGuid(), request);

            AssertOkResult(result);
        }
        public async Task GetLatestMethodologyBySlug_NotFound()
        {
            var methodologyService = new Mock <IMethodologyService>(MockBehavior.Strict);

            methodologyService.Setup(mock => mock.GetLatestMethodologyBySlug(It.IsAny <string>()))
            .ReturnsAsync(new NotFoundResult());

            var controller = new MethodologyController(methodologyService.Object);

            var result = await controller.GetLatestMethodologyBySlug("unknown-slug");

            Assert.IsType <NotFoundResult>(result.Result);

            MockUtils.VerifyAllMocks(methodologyService);
        }
        public async Task GetLatestMethodologyBySlug()
        {
            var methodologyId = Guid.NewGuid();

            var methodologyService = new Mock <IMethodologyService>(MockBehavior.Strict);

            methodologyService.Setup(mock => mock.GetLatestMethodologyBySlug("test-slug"))
            .ReturnsAsync(new MethodologyVersionViewModel
            {
                Id = methodologyId
            });

            var controller = new MethodologyController(methodologyService.Object);

            var result = await controller.GetLatestMethodologyBySlug("test-slug");

            var methodologyViewModel = result.Value;

            Assert.Equal(methodologyId, methodologyViewModel.Id);

            MockUtils.VerifyAllMocks(methodologyService);
        }