public async Task CreateAsync()
        {
            var request = new CreateMethodologyRequest
            {
                Title = "Pupil absence statistics: methodology"
            };

            await using (var context = DbUtils.InMemoryApplicationDbContext())
            {
                var viewModel = (await BuildMethodologyService(
                                     context,
                                     Mocks())
                                 .CreateMethodologyAsync(request)).Right;

                var model = await context.Methodologies.FindAsync(viewModel.Id);

                Assert.False(model.Live);
                Assert.Equal("pupil-absence-statistics-methodology", model.Slug);
                Assert.False(model.Updated.HasValue);

                Assert.Null(viewModel.InternalReleaseNote);
                Assert.Null(viewModel.Published);
                Assert.Equal(Draft, viewModel.Status);
                Assert.Equal(request.Title, viewModel.Title);
            }
        }
        public async Task CreateAsync_SlugNotUnique()
        {
            var request = new CreateMethodologyRequest
            {
                Title = "Pupil absence statistics: methodology"
            };

            await using (var context = DbUtils.InMemoryApplicationDbContext("CreateSlugNotUnique"))
            {
                var createResult = await BuildMethodologyService(
                    context,
                    Mocks())
                                   .CreateMethodologyAsync(request);

                Assert.True(createResult.IsRight);

                var repeatedCreateResult = await BuildMethodologyService(
                    context,
                    Mocks())
                                           .CreateMethodologyAsync(request);

                Assert.True(repeatedCreateResult.IsLeft);
                AssertValidationProblem(repeatedCreateResult.Left, SlugNotUnique);
            }
        }
        public async void CreateMethodologyAsync_Returns_Ok()
        {
            var request = new CreateMethodologyRequest();

            var methodologyService = new Mock <IMethodologyService>();

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

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

            AssertOkResult(result);
        }
        public async Task <Either <ActionResult, MethodologySummaryViewModel> > CreateMethodologyAsync(
            CreateMethodologyRequest request)
        {
            var slug = SlugFromTitle(request.Title);

            return(await _userService.CheckCanCreateMethodology()
                   .OnSuccess(() => ValidateMethodologySlugUnique(slug))
                   .OnSuccess(async() =>
            {
                var model = new Methodology
                {
                    Title = request.Title,
                    Slug = slug
                };

                var saved = await _context.Methodologies.AddAsync(model);
                await _context.SaveChangesAsync();
                return await GetSummaryAsync(saved.Entity.Id);
            }));
        }