protected static void ResetDatabase(DbContextOptions <MiniURLDbContext> dbOptions, IDateTime dateTime)
{
using (var ctx = new MiniURLDbContext(dbOptions, dateTime))
{
ctx.Database.EnsureDeleted();
}
}
public async Task Handle_RequestKnownShortURL_ReturnsCorrectly()
{
var originalURL = "https://github.com/MathiasLorenz";
var shortURL = "iodfetry";
using (var ctx = new MiniURLDbContext(DbOptions, DateTimeService))
{
ctx.PersistedURLs.Add(new PersistedURL
{
URL = originalURL,
ShortURL = shortURL,
});
await ctx.SaveChangesAsync();
}
using (var ctx = new MiniURLDbContext(DbOptions, DateTimeService))
{
var handler = new GetPersistedURLQueryHandler(ctx);
var query = new GetPersistedURLQuery {
ShortURL = shortURL
};
var result = await handler.Handle(query, new System.Threading.CancellationToken());
result.ShouldNotBeNull();
result.ShouldBeOfType <PersistedURLVm>();
result.URL.ShouldBe(originalURL);
result.ShortURL.ShouldBe(shortURL);
}
}
private async Task RunUserQuery(List <User> users,
List <PersistedURL> persistedURLs,
MiniURLDbContext ctx)
{
for (int i = 0; i < 2; i++)
{
bool includedDeleted = i == 0 ? true : false;
foreach (var user in users)
{
var query = new GetURLsForUserQuery
{
UserId = user.Id,
IncludeDeleted = includedDeleted
};
var handler = new GetURLsForUserQueryHandler(ctx);
var result = await handler.Handle(query, new System.Threading.CancellationToken());
result.ShouldNotBeNull();
result.ShouldBeOfType <URLsForUserVm>();
result.UserId.ShouldBe(user.Id);
result.URLs.ShouldBeOfType <List <URLsForUserDto> >();
int relevantPersistedURLsCount = includedDeleted
? persistedURLs.Where(x => x.UserId == user.Id).Count()
: persistedURLs.Where(x => x.UserId == user.Id && x.Deleted == false).Count();
result.URLs.Count.ShouldBe(relevantPersistedURLsCount);
}
}
}
private async Task <int> SetupHandlerAndHandle(string mockedShortURL,
string originalURL,
int?userId = null,
string?desiredShortURL = null)
{
var mockTokenGenerator = new Mock <ITokenGenerator>();
mockTokenGenerator.Setup(x => x.GetUniqueKey()).Returns(mockedShortURL);
using (var ctx = new MiniURLDbContext(DbOptions, DateTimeService))
{
var request = new CreatePersistedURLCommand
{
URL = originalURL,
UserId = userId ?? null,
DesiredShortURL = desiredShortURL ?? null
};
var handler = new CreatePersistedURLCommandHandler(ctx, mockTokenGenerator.Object);
var result = await handler.Handle(request, new System.Threading.CancellationToken());
result.ShouldNotBeNull();
result.ShouldBeGreaterThan(0);
return(result);
}
}
protected static async Task <int> CreateAUser(DbContextOptions <MiniURLDbContext> dbOptions, IDateTime dateTime)
{
using (var ctx = new MiniURLDbContext(dbOptions, dateTime))
{
var entity = SeedData.Users()[0];
ctx.Users.Add(entity);
await ctx.SaveChangesAsync();
return(entity.Id);
}
}
public async Task GetURLsForUser_SeededDb_ReturnsCorrect()
{
ResetDatabase(DbOptions, DateTimeService);
await SeedDb(DbOptions, DateTimeService);
var users = SeedData.Users();
var persistedURLs = SeedData.PersistedURLs();
using (var ctx = new MiniURLDbContext(DbOptions, DateTimeService))
{
await RunUserQuery(users, persistedURLs, ctx);
}
}
protected static async Task SeedDb(DbContextOptions <MiniURLDbContext> dbOptions, IDateTime dateTime)
{
using (var ctx = new MiniURLDbContext(dbOptions, dateTime))
{
var seeder = new MiniURLDbContextSeeder(ctx);
try
{
await seeder.SeedAllAsync(new System.Threading.CancellationToken());
}
catch (Exception ex)
{
throw ex;
}
}
}
public async Task GetURLsForUser_InvalidUser_ThrowsException()
{
ResetDatabase(DbOptions, DateTimeService);
var userId = await CreateAUser(DbOptions, DateTimeService);
using (var ctx = new MiniURLDbContext(DbOptions, DateTimeService))
{
var query = new GetURLsForUserQuery {
UserId = userId + 1
};
var handler = new GetURLsForUserQueryHandler(ctx);
await Should.ThrowAsync <NotFoundException>(
handler.Handle(query, new System.Threading.CancellationToken()));
}
}
public async Task Handle_RequestUnknownShortURL_ThrowsException()
{
var unknwnShortURL = "ThisShortURLIsNotKnown";
await SeedDb(DbOptions, DateTimeService);
using (var ctx = new MiniURLDbContext(DbOptions, DateTimeService))
{
var handler = new GetPersistedURLQueryHandler(ctx);
await Should.ThrowAsync <NotFoundException>(
handler.Handle(new GetPersistedURLQuery {
ShortURL = unknwnShortURL
},
new System.Threading.CancellationToken()));
}
}
public async Task CreatePersistedURL_NoUser()
{
ResetDatabase(DbOptions, DateTimeService);
var mockedShortURL = "xyz";
var originalURL = "www.averyknownwebsite.com";
var persistedURLId = await SetupHandlerAndHandle(mockedShortURL, originalURL);
using (var ctx = new MiniURLDbContext(DbOptions, DateTimeService))
{
var persistedURL = await ctx.PersistedURLs.SingleAsync(x => x.ShortURL == mockedShortURL);
persistedURL.ShortURL.ShouldBe(mockedShortURL);
persistedURL.URL.ShouldBe(originalURL);
persistedURL.UserId.ShouldBeNull();
}
}
public async Task CreatePersistedURL_WithDesiredURL_ReturnsCorrectly()
{
ResetDatabase(DbOptions, DateTimeService);
var mockedShortURL = "a";
var desiredShortURL = "b";
var originalURL = "www.someotherwebsite.com";
var persistedURLId = await SetupHandlerAndHandle(mockedShortURL, originalURL, desiredShortURL : desiredShortURL);
using (var ctx = new MiniURLDbContext(DbOptions, DateTimeService))
{
var persistedURL = await ctx.PersistedURLs
.SingleAsync(x => x.ShortURL == desiredShortURL);
persistedURL.Id.ShouldBe(persistedURLId);
persistedURL.ShortURL.ShouldBe(desiredShortURL);
}
}
public async Task CreatePersistedURL_WithUser()
{
ResetDatabase(DbOptions, DateTimeService);
var mockedShortURL = "abcdefgh";
var originalURL = "www.somewebsite.com";
var userId = await CreateAUser(DbOptions, DateTimeService);
var persistedURLId = await SetupHandlerAndHandle(mockedShortURL, originalURL, userId);
using (var ctx = new MiniURLDbContext(DbOptions, DateTimeService))
{
var persistedURL = await ctx.PersistedURLs
.Include(x => x.User)
.SingleAsync(x => x.ShortURL == mockedShortURL);
persistedURL.ShortURL.ShouldBe(mockedShortURL);
persistedURL.URL.ShouldBe(originalURL);
persistedURL.User.ShouldNotBeNull();
persistedURL.User.ShouldBeOfType <User>();
persistedURL.UserId.ShouldNotBeNull();
persistedURL.UserId.ShouldBe(userId);
}
}
