public async Task AddNewItemAsIncompleteWithDueDate()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>().UseInMemoryDatabase(databaseName: "Test_AddNewItem").Options;
using (var context = new ApplicationDbContext(options))
{
var service = new ToDoItemService(context);
var fakeUser = new ApplicationUser
{
Id = "fake-000",
UserName = "******"
};
await service.AddItemAsync(new ToDoItem
{
Title = "Testing?"
}, fakeUser);
}
using (var context = new ApplicationDbContext(options))
{
var itemsInDatabase = await context.Items.CountAsync();
Assert.Equal(1, itemsInDatabase);
var item = await context.Items.FirstAsync();
Assert.Equal("Testing?", item.Title);
Assert.False(item.IsDone);
var difference = DateTimeOffset.Now.AddDays(3) - item.DueAt;
Assert.True(difference < TimeSpan.FromSeconds(1));
}
}
public async Task AddItemAsyncWithPropertyNameIsNullShouldThrowException()
{
var service = new ToDoItemService(Context);
var thirdItem = new ToDoItem();
await Assert.ThrowsAsync <DbUpdateException>(() => service.AddItemAsync(thirdItem));
}
/*[Fact]*/
public async Task ReturnOwnItems()
{
//crea la base de datos en memoria.
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "Test_GetIncompletItemsAsync").Options;
//Crea el contexto necesario para realizar el test.
//En este caso se crea el servicio ToDoItemService() y tres usuarios ficticios,
//y se le van a agregar 5 items a cada uno.
using (var context = new ApplicationDbContext(options))
{
var service = new ToDoItemService(context);
for (int i = 0; i < 3; i++)
{
string usr = "******" + i;
string mail = "fake" + i + "@example.com";
var fakeUser = new ApplicationUser {
Id = usr, UserName = mail
};
for (int j = 0; j < 0; j++)
{
string itemTitle = "fake-00" + i;
var item = new ToDoItem {
Title = itemTitle
};
await service.AddItemAsync(item, fakeUser);
}
}
}
//Se crea otro contexto, y se verifica que solo tenga un Item.
//Luego se crea otro usuario y se intenta marcar como done el item almacenado
//en la base de datos y creado por el primer usuario.
//Se crea el servicio MarkDoneAsync() intentar marcar como completado al item
//con el segundo usuario.
using (var context = new ApplicationDbContext(options))
{
var service = new ToDoItemService(context);
var otherFkeUser = new ApplicationUser {
Id = "fake-000-ll", UserName = "******"
};
//var otherFkeUser = new ApplicationUser{ Id= "fake-000", UserName= "******"};
var itemsInDataBase = await context.Items.CountAsync();
Assert.Equal(1, itemsInDataBase);
var item = await context.Items.FirstAsync();
Assert.False(item.IsDone);
Assert.False(await service.MarkDoneAsync(item.Id, otherFkeUser));
Assert.False(item.IsDone);
}
}
public async Task AddItemAsyncShouldAddItem()
{
var service = new ToDoItemService(Context);
var thirdItem = new ToDoItem()
{
Name = "Third Item"
};
await service.AddItemAsync(thirdItem);
var itemsFromService = await service.GetItemsAsync();
Assert.Contains(itemsFromService, a => a.Id.Equals(thirdItem.Id));
Assert.Equal(3, itemsFromService.Count());
}
public async Task MarkDoneAnItemsWithGoodId()
{
//crea la base de datos en memoria.
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "Test_MarkDoneWrongUser").Options;
//Crea el contexto necesario para realizar el test.
//En este caso se crea el servicio ToDoItemService() y un usuario ficticio,
//y con esto se agrega un item a la base de datos.
using (var context = new ApplicationDbContext(options))
{
var service = new ToDoItemService(context);
var fakeUser = new ApplicationUser {
Id = "fake-000", UserName = "******"
};
var item = new ToDoItem {
Title = "Testing?"
};
await service.AddItemAsync(item, fakeUser);
//await service.MarkDoneAsync(item.Id, fakeUser);
}
//Se crea otro contexto, y se verifica que solo tenga un Item.
//Luego se crea otro usuario y se intenta marcar como done el item almacenado
//en la base de datos y creado por el primer usuario.
//Se crea el servicio MarkDoneAsync() intentar marcar como completado al item
//con el segundo usuario.
using (var context = new ApplicationDbContext(options))
{
var service = new ToDoItemService(context);
var otherFkeUser = new ApplicationUser {
Id = "fake-000-ll", UserName = "******"
};
//var otherFkeUser = new ApplicationUser{ Id= "fake-000", UserName= "******"};
var itemsInDataBase = await context.Items.CountAsync();
Assert.Equal(1, itemsInDataBase);
var item = await context.Items.FirstAsync();
Assert.False(item.IsDone);
Assert.False(await service.MarkDoneAsync(item.Id, otherFkeUser));
Assert.False(item.IsDone);
}
}
public async Task AddNewItemAsIncompleteWithDueDate()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "Test_AddNewItem")
.Options;
// Set up a context (connection to the "DB")
// for writing
using (var context = new ApplicationDbContext(options))
{
var service = new ToDoItemService(context);
var fakeUser = new ApplicationUser
{
Id = "fake-000",
UserName = "******"
};
await service.AddItemAsync(new NewToDoItem
{
Title = "Testing?",
DueAt = DateTimeOffset.Now.AddDays(3)
}, fakeUser);
}
// Use a separate context to read data back from the "DB"
using (var context = new ApplicationDbContext(options))
{
var itemsInDatabase =
await context.Items
.CountAsync();
Assert.Equal(1, itemsInDatabase);
var item = await context.Items.FirstAsync();
Assert.Equal("Testing?", item.Title);
Assert.False(item.IsDone);
// Item should be due 3 days
// from now (give or take a second)
var difference =
DateTimeOffset.Now.AddDays(3) - item.DueAt;
Assert.True(difference < TimeSpan.FromSeconds(50));
}
}
private async Task SetUp()
{
//Crea el contexto (conexion con la base de datos) para poder crear
//el servicio ToDoItemService. Luego se crea un usuario
//ficticio con el que se agrega un item a la base de datos mediante AddItemAsync().
using (var context = new ApplicationDbContext(ODB.Options))
{
var service = new ToDoItemService(context);
var fakeUser = new ApplicationUser {
Id = "fake-000", UserName = "******"
};
var item = new ToDoItem {
Title = "Testing?"
};
await service.AddItemAsync(item, fakeUser);
}
}
public async Task AddNewItemAsIncompleteWithDueDate()
{
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "Test_AddNewItem")
.Options;
using (var context = new ApplicationDbContext(options))
{
var service = new ToDoItemService(context);
var fakeUser = new ApplicationUser
{
Id = "fake-000",
UserName = "******"
};
await service.AddItemAsync(new NewToDoItem
{
Title = "Testing?",
DueAt = DateTimeOffset.Now.AddDays(3)
}, fakeUser);
}
}
public async Task AddNewItemAsIncompleteWhitDueDate()
{
//crea la base de datos en memoria.
var options = new DbContextOptionsBuilder <ApplicationDbContext>()
.UseInMemoryDatabase(databaseName: "Test_AddNewItem").Options;
//Crea el contexto necesario para realizar el test.
//En este caso ae crea el servicio ToDoItemService y el usuario ficticio
//y con esto se agrega un item a la base de datos.
using (var context = new ApplicationDbContext(options))
{
var service = new ToDoItemService(context);
var fakeUser = new ApplicationUser {
Id = "fake-000", UserName = "******"
};
await service.AddItemAsync(new ToDoItem { Title = "Testing?" }, fakeUser);
}
//Se crea otro contexto, para verificar que la base de datos
//se halla completado correctamente.
using (var context = new ApplicationDbContext(options))
{
var itemsInDataBase = await context.Items.CountAsync();
Assert.Equal(1, itemsInDataBase);
var item = await context.Items.FirstAsync();
Assert.Equal("Testing?", item.Title);
//Assert.Equal(false, item.IsDone);
Assert.True(false == item.IsDone);
var difference = DateTimeOffset.Now.AddDays(3) - item.DueAt;
Assert.True(difference < TimeSpan.FromSeconds(3));
}
}
[Fact] /**/
public async Task MarkDoneAnItemsWithWrongId()
{
await SetUp();
//Se crea otro contexto, y se verifica que solo tenga un Item.
//Luego se crea otro usuario (con el distinto Id) y se intenta marcar
//como done el item almacenado en la base de datos usando MarkDoneAsync().
using (var CDB = new ApplicationDbContext(ODB.Options))
{
var service = new ToDoItemService(CDB);
var otherFakeUser = new ApplicationUser {
Id = "fake-000-ll", UserName = "******"
};
var itemsInDataBase = await CDB.Items.CountAsync();
Assert.Equal(1, itemsInDataBase);
var item = await CDB.Items.FirstAsync();
Assert.False(item.IsDone);
bool result = await service.MarkDoneAsync(item.Id, otherFakeUser);
Assert.False(result);
Assert.False(item.IsDone);
}
}
[Fact]/**/
public async Task ReturnOwnItems()
{
//SetUp.
//Crea el contexto (conexion con la base de datos) para poder crear
//el servicio ToDoItemService.
//Luego se crean tres usuarios ficticios,
//y se agregar 5 items a cada uno en la base de datos.
using (var CDB = new ApplicationDbContext(ODB.Options))
{
var service = new ToDoItemService(CDB);
for (int i = 1; i < 4; i++)
{
string usr = "******" + i;
string mail = "fake" + i + "@example.com";
var fakeUser = new ApplicationUser {
Id = usr, UserName = mail
};
for (int j = 1; j < 6; j++)
{
string itemTitle = "Task_" + j;
var item = new ToDoItem {
Title = itemTitle
};
await service.AddItemAsync(item, fakeUser);
}
}
}
//Se crea otro contexto, y se verifica que tenga 15 Items.
//Luego se crea un usuario y se listan todas las tareas contando las tareas
//que le pertenecen al usuario creado(5) y a las de los otros usuarios(10).
using (var CDB = new ApplicationDbContext(ODB.Options))
{
var service = new ToDoItemService(CDB);
var FakeUser2 = new ApplicationUser {
Id = "fake-002", UserName = "******"
};
var itemsInDataBase = await CDB.Items.CountAsync();
Assert.Equal(15, itemsInDataBase);
int elementosFakeUser2 = 0;
int elementosOtherFakeUser = 0;
foreach (var elemento in CDB.Items)
{
if (elemento.UserId == FakeUser2.Id)
{
elementosFakeUser2++;
}
else
{
elementosOtherFakeUser++;
}
}
Assert.Equal(5, elementosFakeUser2);
Assert.Equal(10, elementosOtherFakeUser);
}
}
