public async Task OnPostAsync()
{
#region Arrange
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase("InMemoryDb");
var mockDb = new Mock <ApplicationDbContext>(optionsBuilder.Options);
var expectedUsers = ApplicationDbContext.GetSeedMentor();
var expectedUser = expectedUsers.FirstOrDefault();
var username = expectedUser.UserName;
mockDb.Setup(db => db.GetAppUserAsync(username))
.Returns(Task.FromResult(expectedUsers.FirstOrDefault()));
var pageModel = new CreateModel(mockDb.Object);
pageModel.Username = username;
pageModel.Input = new CreateModel.InputModel
{
About = ApplicationDbContext.GetSeedAbout().FirstOrDefault()
};
#endregion
#region Act
var result = await pageModel.OnPostAsync();
#endregion
#region Assert
Assert.IsType <RedirectResult>(result);
#endregion
}
public async Task OnPostAsync_PopulatesThePageModel_WithAnAssignment()
{
// Arrange
var pageModel = new CreateModel(MockAppDbContext.Object)
{
Assignment = ApplicationDbContext.GetSeedingAssignments().First(a => a.Id == 1),
AssignmentSpecificationUpload = UploadReferenceAssignment,
ReferenceSolutionUpload = UploadReferenceTestCases,
ReferenceTestCasesSolutionsUpload = UploadReferenceTestCasesSolutions
};
pageModel.Assignment.Id = 0;
pageModel.Assignment.Name = "Newly created assignment";
pageModel.ApplicationModes = await pageModel.GetApplicationModes(null);
pageModel.CoverageTypeOptions = await pageModel.GetCoverageTypeOptions(null);
// Act
await pageModel.OnPostAsync();
// Assert
var assignments = await MockAppDbContext.Object.GetAssignmentsAsync();
var actualAssignment = Assert.IsAssignableFrom <Assignment>(assignments.FirstOrDefault(a => a.Name == "Newly created assignment"));
Assert.NotNull(actualAssignment);
}
public async Task OnPostCreateLoanApplicationAsync_ReturnsARedirectToPageResult_WhenModelStateIsValid()
{
// Arrange
var authorizationService = new Mock <IAuthorizationService>();
authorizationService.Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <object>(), It.IsAny <IEnumerable <IAuthorizationRequirement> >()))
.ReturnsAsync(AuthorizationResult.Success());
var store = new Mock <IUserStore <IdentityUser> >();
var mgr = new Mock <UserManager <IdentityUser> >(store.Object, null, null, null, null, null, null, null, null);
var httpContext = new DefaultHttpContext();
var modelState = new ModelStateDictionary();
var actionContext = new ActionContext(httpContext, new RouteData(), new PageActionDescriptor(), modelState);
var modelMetadataProvider = new EmptyModelMetadataProvider();
var viewData = new ViewDataDictionary(modelMetadataProvider, modelState);
var tempData = new TempDataDictionary(httpContext, Mock.Of <ITempDataProvider>());
var pageContext = new PageContext(actionContext)
{
ViewData = viewData
};
var pageModel = new CreateModel(AppDbContext, authorizationService.Object, mgr.Object)
{
PageContext = pageContext,
TempData = tempData,
Url = new UrlHelper(actionContext),
LoanApplication = new LoanApplication()
};
// Act
// A new ModelStateDictionary is valid by default.
var result = await pageModel.OnPostAsync();
// Assert
Assert.IsType <RedirectToPageResult>(result);
}
public async void Createテスト１(string Id, string pass, string note, DateTime last, PUBLICITY pub, EXCHA excha, WRITA writa, DateTime retTime, string exid)
{
//POSTデータのバインド
model.Diary = new Diary(Id, pass, note, last, pub, excha, writa, retTime, exid);
//POST時の処理
await model.OnPostAsync();
//DBからデータの取り出し
var d = await context.diaries.FindAsync(Id);
//入力とDBの値が一致するか
Assert.Equal(Id, d.Id); //(expected, actual)
Assert.Equal(note, d.note);
Assert.Equal(DateTime.Today, d.last.Date); //日付だけ確認
Assert.Equal(pub, d.pub);
//パスワードはハッシュ化されているか
Assert.True(PBKDF2.Verify(pass, d.pass));
//入力に関わらず、初期値が入っているか
Assert.Equal(EXCHA.disable, d.excha);
Assert.Equal(WRITA.able, d.writa);
Assert.Equal(DateTime.Today, d.retTime.Date);
Assert.Null(d.exid);
}
public async Task OnPost_CreateNewNonExistingArticle_ShouldCreateArticleAndRedirect()
{
var topic = "test topic";
var content = "test content";
var authorId = Guid.NewGuid().ToString();
this.mockArticleService
.Setup(x => x.IsArticleExist(topic));
this.mockMediator
.Setup(m => m.Send(It.IsAny <CreateNewArticleCommand>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(default(CommandResult)));
var createModel = new CreateModel(this.mockMediator.Object, this.mockLogger.Object)
{
Article = new CreateArticleDto
{
Topic = topic,
Content = content
}
};
createModel.AddPageContext("username", authorId);
var result = await createModel.OnPostAsync();
Assert.IsType <RedirectResult>(result);
Assert.Equal("./Index", ((RedirectResult)result).Url);
this.mockLogger.Verify(x => x.Log(LogLevel.Information, 0, It.IsAny <FormattedLogValues>(), It.IsAny <Exception>(), It.IsAny <Func <object, Exception, string> >()));
}
public async Task OnPostCreateProyectosPersonales_VerSiRealmenteCrea()
{
// Arrange
//Preparamos un contexto que guarde la base de datos en memoria ram.
var OptionsBuilder = new DbContextOptionsBuilder <IdentityContext>()
.UseInMemoryDatabase("InMemoryDb");
IdentityContext TestIdentityContext = new IdentityContext(OptionsBuilder.Options);
//Creamos un Proyecto Personal Esperado
ProyectoPersonal ProyectoPersonalEsperado = new ProyectoPersonal()
{
ID = 1, Descripcion = "Book", FechaComienzo = DateTime.Parse("2019/02/12"), FechaFinalizacion = DateTime.Parse("2019/02/12"), TipoDeProyecto = "Foto"
};
// Act
//Creamos una pagina de tipo CreateModel (de ProyectosPersonales), la cual es la que se encarga de la logica
//de crear Proyectos Personales en bd.
CreateModel PageCreateModel = new CreateModel(TestIdentityContext);
//Introducimos un Proyecto Personal en el modelo de la pagina que creamos, a mano Seteamos los valores del
// Proyecto Personal de esa página
PageCreateModel.ProyectoPersonal = new ProyectoPersonal()
{
ID = 1, Descripcion = "Book", FechaComienzo = DateTime.Parse("2019/02/12"), FechaFinalizacion = DateTime.Parse("2019/02/12"), TipoDeProyecto = "Foto"
};
//Simulamos un post que envíe el formulario de la pagina y por ende guarde en bd, el Proyecto Personal que ingresamos en esa pagina
await PageCreateModel.OnPostAsync();
// Assert
//Buscamos usando el contexto del Proyecto Personal recien creada por id
ProyectoPersonal ProyectoPersonalRecibida = await TestIdentityContext.ProyectoPersonal.FindAsync(1);
//Comparamos que la que creamos en el modelo de la pagina y por ende mandamos a crear en bd,
//y el Proyecto Personal que recibimos de bd con id 1, tengan igual Descripcion, FechaComienzo, FechaFinalizada, Tipo de proyecto
Assert.Equal(
ProyectoPersonalEsperado.Descripcion.ToString(),
ProyectoPersonalRecibida.Descripcion.ToString());
Assert.Equal(
ProyectoPersonalEsperado.FechaComienzo.ToString(),
ProyectoPersonalRecibida.FechaComienzo.ToString());
Assert.Equal(
ProyectoPersonalEsperado.FechaFinalizacion.ToString(),
ProyectoPersonalRecibida.FechaFinalizacion.ToString());
Assert.Equal(
ProyectoPersonalEsperado.TipoDeProyecto.ToString(),
ProyectoPersonalRecibida.TipoDeProyecto.ToString());
//Si esto no falla, concluimos que la pagina de Proyectos Personales (de tener bien seteado el modelo),
//guarda sin problemas un Proyecto Personal en bd cuando no hay nada ingresado
}
public async void CanCreatePost()
{
await WithTestDatabase.Run(async (BlogDbContext context) =>
{
var pageModel = new CreateModel(context);
pageModel.BlogPost = DbUtil.GetTestPost();
await pageModel.OnPostAsync();
Assert.Equal(1, context.Blog.Count());
});
}
public async Task OnPostAsync()
{
// Arrange
var user = new User {
Id = Guid.NewGuid()
};
var role = new Role
{
Id = Guid.NewGuid(),
Name = "Name",
UserRoles = new List <UserRole>
{
new UserRole
{
User = user,
UserId = user.Id
}
}
};
_userManager.Setup(x => x.FindByIdAsync($"{user.Id}")).ReturnsAsync(user);
var create = new CreateModel(_roleManager.Object, _userManager.Object)
{
Role = role
};
// Act
var post = await create.OnPostAsync().ConfigureAwait(false);
// Assert
foreach (var userRole in role.UserRoles)
{
_userManager.Verify(x => x.FindByIdAsync($"{userRole.UserId}"), Times.Once);
_userManager.Verify(
x => x.AddClaimAsync(userRole.User, It.Is <Claim>(
y => y.Type == ClaimTypes.Role && y.Value == role.Name)),
Times.Once);
}
_roleManager.Verify(
x => x.CreateAsync(It.Is <Role>(y => y.Name.Equals(role.Name))),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("./Details/Index", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Role.Id), key);
Assert.Equal(role.Id, value);
});
}
public async Task ShouldCreateNewNonExistingArticleAndRedirect_GivenUserIsAuthenticated()
{
var expectedCommand = new CreateNewArticleCommand
{
Topic = _topic,
AuthorId = userId,
Content = _content,
AuthorName = username
};
_mediator.Setup(mediator => mediator.Send(It.IsAny <CreateNewArticleCommand>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(new CommandResult {
Successful = true, ObjectId = _expectedSlug
}));
_mediator.Setup(mediator => mediator.Send(It.IsAny <GetIsTopicAvailableQuery>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(false));
_mediator.Setup(mediator => mediator.Send(It.IsAny <GetArticlesToCreateFromArticleQuery>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult((_expectedSlug, new string[] { })));
_sut = new CreateModel(_mediator.Object, _mapper, new NullLoggerFactory())
{
Article = new ArticleCreate
{
Topic = _topic,
Content = _content
}
};
//we depend on a valid ClaimsPrinciple!! No check on User yet before sending the command
_sut.AddPageContext(username, userId);
var result = await _sut.OnPostAsync();
Assert.IsType <RedirectToPageResult>(result);
Assert.Equal(_expectedSlug, ((RedirectToPageResult)result).RouteValues["slug"]);
_mediator.Verify(m => m.Send(
It.Is <GetIsTopicAvailableQuery>(request =>
request.ArticleId.Equals(0) &&
request.Topic.Equals(_topic)),
It.Is <CancellationToken>(token => token.Equals(CancellationToken.None))), Times.Once
);
_mediator.Verify(m => m.Send(
It.Is <CreateNewArticleCommand>(request =>
request.Topic.Equals(expectedCommand.Topic) &&
request.AuthorName.Equals(expectedCommand.AuthorName) &&
request.Content.Equals(expectedCommand.Content) &&
request.AuthorId.Equals(userId)),
It.Is <CancellationToken>(token => token.Equals(CancellationToken.None))), Times.Once);
}
public async Task OnPostCreateEspecialidades_VerSiRealmenteCrea()
{
// Arrange
//Preparamos un contexto que guarde la base de datos en memoria ram.
var OptionsBuilder = new DbContextOptionsBuilder <IdentityContext>()
.UseInMemoryDatabase("InMemoryDb");
IdentityContext TestIdentityContext = new IdentityContext(OptionsBuilder.Options);
//Creamos una Especialidad esperada
Especialidad EspecialidadEsperada = new Especialidad()
{
ID = 1, Area = "Foto Fija", Nivel = "Basico"
};
// Act
//Creamos una pagina de tipo CreateModel (de Especialidades), la cual es la que se encarga de la logica
//de crear Especialidades en bd.
CreateModel PageCreateModel = new CreateModel(TestIdentityContext);
//Introducimos una Especialidad en el modelo de la pagina que creamos, a mano Seteamos los valores de
//la Especialidad de esa página
PageCreateModel.Especialidad = new Especialidad()
{
ID = 1, Area = "Foto Fija", Nivel = "Basico"
};
//Simulamos un post que envíe el formulario de la pagina y por ende guarde en bd la Especialidad que ingresamos en esa pagina
await PageCreateModel.OnPostAsync();
// Assert
//Buscamos usando el contexto la Especialidad recien creada por id
Especialidad EspecialidadRecibida = await TestIdentityContext.Especialidad.FindAsync(1);
//Comparamos que la que creamos en el modelo de la pagina y por ende mandamos a crear en bd,
//y la Especialidad que recibimos de bd con id 1, tengan igual Nivel y Area
Assert.Equal(
EspecialidadEsperada.Nivel.ToString(),
EspecialidadRecibida.Nivel.ToString());
Assert.Equal(
EspecialidadEsperada.Area.ToString(),
EspecialidadRecibida.Area.ToString());
//Si esto no falla, concluimos que la pagina de Especialidades (de tener bien seteado el modelo),
//guarda sin problemas una Especialidad en bd cuando no hay nada ingresado
}
public async Task OnPostCreateCalificaciones_VerSiRealmenteCrea()
{
// Arrange
//Preparamos un contexto que guarde la base de datos en memoria ram.
var OptionsBuilder = new DbContextOptionsBuilder <IdentityContext>()
.UseInMemoryDatabase("InMemoryDb");
IdentityContext TestIdentityContext = new IdentityContext(OptionsBuilder.Options);
//Creamos una calificacion esperada
Calificacion CalificacionEsperada = new Calificacion()
{
ID = 1, Nota = 5, Descripcion = "Descripcion de prueba"
};
// Act
//Creamos una pagina de tipo CreateModel (de Calificaciones), la cual es la que se encarga de la logica
//de crear calificaciones en bd.
CreateModel PageCreateModel = new CreateModel(TestIdentityContext);
//Introducimos una calificacion en el modelo de la pagina que creamos, a mano Seteamos los valores de
//la calificacion de esa página
PageCreateModel.Calificacion = new Calificacion()
{
ID = 1, Nota = 5, Descripcion = "Descripcion de prueba"
};
//Simulamos un post que envíe el formulario de la pagina y por ende guarde en bd la calificacion que ingresamos en esa pagina
await PageCreateModel.OnPostAsync();
// Assert
//Buscamos usando el contexto la Calificacion recien creada por id
Calificacion CalificacionRecibida = await TestIdentityContext.Calificacion.FindAsync(1);
//Comparamos que la que creamos en el modelo de la pagina y por ende mandamos a crear en bd,
//y la calificacion que recibimos de bd con id 1, tengan igual descripcion y nota
Assert.Equal(
CalificacionEsperada.Descripcion.ToString(),
CalificacionRecibida.Descripcion.ToString());
Assert.Equal(
CalificacionEsperada.Nota.ToString(),
CalificacionRecibida.Nota.ToString());
//Si esto no falla, concluimos que la pagina de calificaciones (de tener bien seteado el modelo),
//guarda sin problemas una calificacion en bd cuando no hay nada ingresado
}
public async void Creates_a_Student()
{
// Arrange
var mockRepository = new Mock <IStudentRepository>();
var mockUnitOfWork = new Mock <IUnitOfWork>();
mockUnitOfWork.SetupGet(u => u.Student).Returns(mockRepository.Object);
var createModel = new CreateModel(mockUnitOfWork.Object);
// Act
var result = await createModel.OnPostAsync();
// Assert
Assert.IsType <RedirectToPageResult>(result);
mockUnitOfWork.Verify(u => u.Student.Add(It.IsAny <Student>()), Times.Once);
mockUnitOfWork.Verify(u => u.CompleteAsync(), Times.Once);
}
public async Task OnPostAsync()
{
// Arrange
var clients = new Mock <DbSet <Client> >();
var context = new Mock <IConfigurationDbContext>();
context.Setup(x => x.Clients).Returns(clients.Object);
var client = new Client
{
ClientName = "ClientName",
ClientId = "ClientId",
Id = new Random().Next()
};
var create = new CreateModel(context.Object)
{
Client = client
};
// Act
var post = await create.OnPostAsync().ConfigureAwait(false);
// Assert
clients.Verify(
x => x.Add(It.Is <Client>(y => y.ClientName.Equals(create.Client.ClientName) &&
y.ClientId.Equals(create.Client.ClientId))),
Times.Once);
context.Verify(
x => x.SaveChangesAsync(),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("./Details/Index", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(Client.Id), key);
Assert.Equal(create.Client.Id, value);
});
}
public async Task OnPostAsync()
{
// Arrange
var apiResources = new Mock <DbSet <ApiResource> >();
var context = new Mock <IConfigurationDbContext>();
context.Setup(x => x.ApiResources).Returns(apiResources.Object);
var apiResource = new ApiResource
{
Name = "Name",
Id = new Random().Next()
};
var create = new CreateModel(context.Object)
{
ApiResource = apiResource
};
// Act
var post = await create.OnPostAsync().ConfigureAwait(false);
// Assert
apiResources.Verify(
x => x.Add(It.Is <ApiResource>(y => y.Name.Equals(apiResource.Name))),
Times.Once);
context.Verify(
x => x.SaveChangesAsync(),
Times.Once);
var result = Assert.IsType <RedirectToPageResult>(post);
Assert.Equal("./Details/Index", result.PageName);
Assert.Collection(result.RouteValues, routeValue =>
{
var(key, value) = routeValue;
Assert.Equal(nameof(ApiResource.Id), key);
Assert.Equal(create.ApiResource.Id, value);
});
}
public async Task OnPostAsync_ModelStateInvalid()
{
#region Arrange
var optionsBuilder = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase("InMemoryDb");
var mockDb = new Mock <ApplicationDbContext>(optionsBuilder.Options);
var expectedUsers = ApplicationDbContext.GetSeedMentor();
var expectedUser = expectedUsers.FirstOrDefault();
var username = expectedUser.UserName;
mockDb.Setup(db => db.GetAppUserAsync(username))
.Returns(Task.FromResult(expectedUsers.FirstOrDefault()));
var pageModel = new CreateModel(mockDb.Object);
pageModel.Username = username;
pageModel.Input = new CreateModel.InputModel
{
About = ApplicationDbContext.GetSeedAbout().FirstOrDefault()
};
var modelState = new ModelStateDictionary();
pageModel.ModelState.AddModelError("Fake Error", "This is a fake error for unit testing");
#endregion
#region Act
var result = await pageModel.OnPostAsync();
#endregion
#region Assert
Assert.IsType <PageResult>(result);
#endregion
}
