public static void SeedData(TimeTrackingDbContext context)
{
context.Issues.AddRange(IssuesDbSet.Get().ToList());
context.Projects.AddRange(ProjectsDbSet.Get().ToList());
context.Milestones.AddRange(MilestonesDbSet.Get().ToList());
context.Teams.AddRange(TeamsDbSet.Get().ToList());
context.WorkLogs.AddRange(WorklogsDbSet.Get().ToList());
context.Users.AddRange(UsersDbSet.Get().ToList());
context.SaveChanges();
}
public static DbContextOptions <TimeTrackingDbContext> GetTimeTrackingDbOptions()
{
var options = new DbContextOptionsBuilder <TimeTrackingDbContext>()
.UseInMemoryDatabase(Guid.NewGuid().ToString())
.Options;
using var context = new TimeTrackingDbContext(options);
SeedHelper.SeedData(context);
return(options);
}
public async Task IssueRepository_GetAllAsync_ReturnsAllValues()
{
await using var context = new TimeTrackingDbContext(_dbOptions);
var issueRepository = new IssueRepository(context);
var expected = IssuesDbSet.Get();
var actual = await issueRepository.GetAllAsync();
Assert.That(actual.OrderBy(e => e.Id), Is.EqualTo(expected.OrderBy(e => e.Id))
.Using(EqualityComparers.IssueComparer));
}
public async Task ProjectRepository_GetAllAsync_ReturnsAllValues()
{
await using var context = new TimeTrackingDbContext(_dbOptions);
var projectRepository = new ProjectRepository(context);
var expected = ProjectsDbSet.Get();
var actual = await projectRepository.GetAllAsync();
Assert.That(actual.OrderBy(x => x.Id), Is.EqualTo(expected.OrderBy(x => x.Id))
.Using(EqualityComparers.ProjectComparer));
}
public async Task WorklogRepository_UpdateAsync_UpdateEntity()
{
await using var context = new TimeTrackingDbContext(_dbOptions);
var workLogRepository = new WorklogRepository(context);
var entityToUpdate = WorklogsDbSet.Get().First();
entityToUpdate.Description = "New description";
var actual = await workLogRepository.UpdateAsync(entityToUpdate);
actual.Should().BeEquivalentTo(entityToUpdate);
}
public async Task UserRepository_UpdateAsync_UpdateEntity()
{
await using var context = new TimeTrackingDbContext(_dbOptions);
var userRepository = new UserRepository(context);
var entityToUpdate = UsersDbSet.Get().First();
entityToUpdate.FirstName = "New first name";
var actual = await userRepository.UpdateAsync(entityToUpdate);
actual.Should().BeEquivalentTo(entityToUpdate);
}
public async Task TeamRepository_UpdateAsync_UpdateEntity()
{
await using var context = new TimeTrackingDbContext(_dbOptions);
var teamRepository = new TeamRepository(context);
var entityToUpdate = TeamsDbSet.Get().First();
entityToUpdate.Name = "New name";
var actual = await teamRepository.UpdateAsync(entityToUpdate);
Assert.That(actual, Is.EqualTo(entityToUpdate).Using(EqualityComparers.TeamComparer));
}
public async Task ProjectRepository_GetById_ShouldReturnCorrectItem(string id)
{
var guidId = Guid.Parse(id);
await using var context = new TimeTrackingDbContext(_dbOptions);
var expected = ProjectsDbSet.Get().First(x => x.Id == guidId);
var projectRepository = new ProjectRepository(context);
var actual = await projectRepository.GetByIdAsync(guidId);
Assert.That(actual, Is.EqualTo(expected).Using(EqualityComparers.ProjectComparer));
}
public async Task IssueRepository_GetById_ShouldReturnCorrectItem(string id)
{
var guidId = Guid.Parse(id);
await using var context = new TimeTrackingDbContext(_dbOptions);
var expected = IssuesDbSet.Get().First(x => x.Id == guidId);
var issueRepository = new IssueRepository(context);
var issue = await issueRepository.GetByIdAsync(guidId);
Assert.That(issue, Is.EqualTo(expected).Using(EqualityComparers.IssueComparer));
}
public async Task MilestoneRepository_UpdateAsync_UpdateEntity()
{
await using var context = new TimeTrackingDbContext(_dbOptions);
var milestoneRepository = new MilestoneRepository(context);
var entityToUpdate = MilestonesDbSet.Get().First();
entityToUpdate.Description = "New description";
var actual = await milestoneRepository.UpdateAsync(entityToUpdate);
Assert.That(actual, Is.EqualTo(entityToUpdate).Using(EqualityComparers.MilestoneComparer));
}
public async Task IssueRepository_UpdateAsync_UpdateEntity()
{
await using var context = new TimeTrackingDbContext(_dbOptions);
var issueRepository = new IssueRepository(context);
var entityToUpdate = IssuesDbSet.Get().First();
entityToUpdate.Title = "New title";
var actual = await issueRepository.UpdateAsync(entityToUpdate);
Assert.That(actual, Is.EqualTo(entityToUpdate).Using(EqualityComparers.IssueComparer));
}
public async Task IssueRepository_DeleteAsync_DeletesEntity()
{
var guidId = Guid.Parse("EC3CB528-45E3-4ABA-8E6E-DB40D0C0A400");
var entityToDelete = IssuesDbSet.Get().First(x => x.Id == guidId);
var expectedCount = IssuesDbSet.Get().ToList().Count - 1;
await using var context = new TimeTrackingDbContext(_dbOptions);
var issueRepository = new IssueRepository(context);
await issueRepository.DeleteAsync(entityToDelete);
context.Issues.Should().HaveCount(expectedCount);
}
public async Task WorklogRepository_DeleteAsync_DeletesEntity()
{
var guidId = Guid.Parse("29C2F600-4F76-4753-A54D-A422DEF8EB9E");
var entityToDelete = WorklogsDbSet.Get().First(x => x.Id == guidId);
var expectedCount = WorklogsDbSet.Get().ToList().Count - 1;
await using var context = new TimeTrackingDbContext(_dbOptions);
var workLogRepository = new WorklogRepository(context);
await workLogRepository.DeleteAsync(entityToDelete);
context.WorkLogs.Should().HaveCount(expectedCount);
}
public async Task UserRepository_DeleteAsync_DeletesEntity()
{
var guidId = Guid.Parse("57C10EE7-4108-4FD9-BCE9-5477FE8BFF9B");
var entityToDelete = UsersDbSet.Get().First(x => x.Id == guidId);
var expectedCount = UsersDbSet.Get().ToList().Count - 1;
await using var context = new TimeTrackingDbContext(_dbOptions);
var userRepository = new UserRepository(context);
await userRepository.DeleteAsync(entityToDelete);
context.Users.Should().HaveCount(expectedCount);
}
public async Task ProjectRepository_UpdateAsync_UpdateEntity()
{
await using var context = new TimeTrackingDbContext(_dbOptions);
var projectRepository = new ProjectRepository(context);
var entityToUpdate = ProjectsDbSet.Get().First();
entityToUpdate.Description = "New description";
var actual = await projectRepository.UpdateAsync(entityToUpdate);
actual.Should().BeEquivalentTo(entityToUpdate);
//Assert.That( actual, Is.EqualTo(entityToUpdate).Using(EqualityComparers.ProjectComparer));
}
public async Task ProjectRepository_DeleteAsync_DeletesEntity()
{
var guidId = Guid.Parse("9245950B-0F82-4B9E-9AF7-DEC9ACF171FA");
var entityToDelete = ProjectsDbSet.Get().First(x => x.Id == guidId);
var expectedCount = ProjectsDbSet.Get().ToList().Count - 1;
await using var context = new TimeTrackingDbContext(_dbOptions);
var projectRepository = new ProjectRepository(context);
await projectRepository.DeleteAsync(entityToDelete);
context.Milestones.Should().HaveCount(expectedCount);
}
public async Task IssueRepository_AddAsync_AddsValueToDatabase()
{
var expectedCount = IssuesDbSet.Get().ToList().Count + 1;
var entityToAdd = IssuesDbSet.IssueBuilder().Create();
await using var context = new TimeTrackingDbContext(_dbOptions);
var issueRepository = new IssueRepository(context);
await issueRepository.AddAsync(entityToAdd);
context.Issues.Should().HaveCount(expectedCount);
var entityFound = context.Issues.Find(entityToAdd.Id);
entityFound.Should().BeEquivalentTo(entityFound);
}
public async Task MilestoneRepository_AddAsync_AddsValueToDatabase()
{
var expectedCount = MilestonesDbSet.Get().ToList().Count + 1;
var entityToAdd = MilestonesDbSet.MilestoneBuilder().Create();
await using var context = new TimeTrackingDbContext(_dbOptions);
var milestoneRepository = new MilestoneRepository(context);
await milestoneRepository.AddAsync(entityToAdd);
context.Milestones.Should().HaveCount(expectedCount);
var entityFound = await context.Milestones.FindAsync(entityToAdd.Id);
Assert.That(entityFound, Is.EqualTo(entityToAdd).Using(EqualityComparers.MilestoneComparer));
}
public async Task WorklogRepository_AddAsync_AddsValueToDatabase()
{
var expectedCount = WorklogsDbSet.Get().ToList().Count + 1;
var entityToAdd = WorklogsDbSet.WorkLogBuilder().Create();
await using var context = new TimeTrackingDbContext(_dbOptions);
var workLogRepository = new WorklogRepository(context);
await workLogRepository.AddAsync(entityToAdd);
context.WorkLogs.Should().HaveCount(expectedCount);
var entityFound = await context.WorkLogs.FindAsync(entityToAdd.Id);
entityFound.Should().BeEquivalentTo(entityFound);
}
public async Task TeamRepository_GetByIdWithDetails_ReturnsTeamWithProjectById()
{
var teamId = new Guid("40B40CF5-46E1-4F03-8968-FA1F5DA459B3");
await using var context = new TimeTrackingDbContext(_dbOptions);
var teamRepository = new TeamRepository(context);
var expected = TeamsDbSet.Get()
.Include(e => e.Project)
.First(e => e.Id.Equals(teamId));
var actual = await teamRepository.GetByIdWithDetails(teamId);
Assert.That(actual, Is.EqualTo(expected).Using(EqualityComparers.TeamComparer));
Assert.That(actual.Project, Is.EqualTo(expected.Project).Using(EqualityComparers.ProjectComparer));
}
public async Task ProjectRepository_AddAsync_AddsValueToDatabase()
{
var expectedCount = ProjectsDbSet.Get().ToList().Count + 1;
var entityToAdd = ProjectsDbSet.ProjectBuilder().Create();
await using var context = new TimeTrackingDbContext(_dbOptions);
var projectRepository = new ProjectRepository(context);
await projectRepository.AddAsync(entityToAdd);
context.Projects.Should().HaveCount(expectedCount);
var entityFound = await context.Projects.FindAsync(entityToAdd.Id);
entityFound.Should().BeEquivalentTo(entityToAdd);
// Assert.That(entityFound, Is.EqualTo(entityToAdd).Using(EqualityComparers.ProjectComparer));
}
public async Task WorklogRepository_GetByIdWithUserAsync_ReturnsWorkLogForWithUser()
{
var workLogId = new Guid("29C2F600-4F76-4753-A54D-A422DEF8EB9E");
await using var context = new TimeTrackingDbContext(_dbOptions);
var workLogRepository = new WorklogRepository(context);
var expected = WorklogsDbSet.Get().Where(e => e.Id == workLogId)
.Include(e => e.TimeTrackingUser)
.FirstOrDefault();
var actual = await workLogRepository.GetByIdWithUserAsync(workLogId);
Assert.That(actual, Is.EqualTo(expected).Using(EqualityComparers.WorkLogComparer));
Assert.That(actual.TimeTrackingUser,
Is.EqualTo(expected.TimeTrackingUser).Using(EqualityComparers.TimeTrackingUserComparer));
}
public async Task WorklogRepository_GetActivitiesWithDetailsByUserId_ReturnstActivitiesWithDetails()
{
var userId = new Guid("57C10EE7-4108-4FD9-BCE9-5477FE8BFF9B");
var projectId = new Guid("40B40CF5-46E1-4F03-8968-FA1F5DA459B3");
await using var context = new TimeTrackingDbContext(_dbOptions);
var workLogRepository = new WorklogRepository(context);
var expected = WorklogsDbSet.Get().Where(e => e.UserId == userId)
.Include(x => x.Issue)
.ThenInclude(e => e.Project)
.Where(e => e.Issue.ProjectId.Equals(projectId))
.ToList();
var actual = await workLogRepository.GetActivitiesWithDetailsByUserId(userId, projectId);
Assert.That(actual.OrderBy(e => e.Id), Is.EqualTo(expected.OrderBy(e => e.Id))
.Using(EqualityComparers.WorkLogComparer));
}
public async Task WorklogRepository_GetAllPagedAsync_ReturnsAllResultsPaged()
{
var page = 1;
var size = 6;
await using var context = new TimeTrackingDbContext(_dbOptions);
var workLogRepository = new WorklogRepository(context);
var expected = WorklogsDbSet.Get().Take(size).ToList();
var actual = await workLogRepository.GetAllPagedAsync(page, size);
actual.EnsurePagedResult(WorklogsDbSet.Get().ToList().Count, size, page);
var actualItems = actual.Items.ToList();
actualItems.Should().BeEquivalentTo(expected, options => options
.Excluding(e => e.TimeTrackingUser)
.Excluding(e => e.Issue));
}
public async Task ProjectRepository_GetAllPagedAsync_ReturnsAllResultsPaged()
{
var page = 1;
var size = 2;
await using var context = new TimeTrackingDbContext(_dbOptions);
var projectRepository = new ProjectRepository(context);
var expected = ProjectsDbSet.Get().Take(size).ToList();
var actual = await projectRepository.GetAllPagedAsync(page, size);
actual.EnsurePagedResult(ProjectsDbSet.Get().ToList().Count, size, page);
var actualItems = actual.Items.ToList();
actualItems.Should().BeEquivalentTo(expected, options => options
.Excluding(e => e.Milestones)
.Excluding(e => e.Issues)
.Excluding(e => e.Teams));
}
public static void SeedData(TimeTrackingDbContext context)
{
using (var transaction = context.Database.BeginTransaction())
{
//context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT OFF");
if (!context.Projects.Any())
{
context.Projects.AddRange(ProjectsData.Projects);
context.SaveChanges();
}
if (!context.Teams.Any())
{
context.Teams.AddRange(TeamsData.Teams);
context.SaveChanges();
}
if (!context.Users.Any())
{
context.Users.AddRange(TimeTrackingUsers.Users);
context.SaveChanges();
}
if (!context.Milestones.Any())
{
context.Milestones.AddRange(MilestonesData.Milestones);
context.SaveChanges();
}
if (!context.Issues.Any())
{
context.Issues.AddRange(IssuesData.Issues);
context.SaveChanges();
}
if (!context.WorkLogs.Any())
{
context.WorkLogs.AddRange(WorkLogsData.WorkLogs);
context.SaveChanges();
}
context.SaveChanges();
//context.Database.ExecuteSqlCommand("SET IDENTITY_INSERT [dbo].[User] ON");
transaction.Commit();
}
}
public async Task IssueRepository_GetIssueWithDetails_ShouldReturnCorrectItem(string id)
{
var guidId = Guid.Parse(id);
await using var context = new TimeTrackingDbContext(_dbOptions);
var issueRepository = new IssueRepository(context);
var expected = IssuesDbSet.Get().First(x => x.Id == guidId);
var expectedMilestone = MilestonesDbSet.Get().First(e => e.Id == expected.MilestoneId);
var expectedWorkLogs = WorklogsDbSet.Get().Where(e => e.IssueId == expected.Id).OrderBy(e => e.Id).ToList();
var expectedTimeTrackingUserReporter = UsersDbSet.Get().First(e => e.Id == expected.ReportedByUserId);
var expectedTimeTrackingUserAssigned = UsersDbSet.Get().First(e => e.Id == expected.AssignedToUserId);
var issue = await issueRepository.GetIssueWithDetails(guidId);
Assert.That(issue, Is.EqualTo(expected).Using(EqualityComparers.IssueComparer));
Assert.That(issue.Milestone, Is.EqualTo(expectedMilestone).Using(EqualityComparers.MilestoneComparer));
Assert.That(issue.WorkLogs.ToList(), Is.EqualTo(expectedWorkLogs).Using(EqualityComparers.WorkLogComparer));
Assert.That(issue.TimeTrackingUserReporter, Is.EqualTo(expectedTimeTrackingUserReporter).Using(EqualityComparers.TimeTrackingUserComparer));
Assert.That(issue.TimeTrackingUserAssigned, Is.EqualTo(expectedTimeTrackingUserAssigned).Using(EqualityComparers.TimeTrackingUserComparer));
}
public async Task UserRepository_GetAllPagedAsync_ReturnsAllResultsPaged()
{
var page = 1;
var size = 3;
await using var context = new TimeTrackingDbContext(_dbOptions);
var userRepository = new UserRepository(context);
var expected = UsersDbSet.Get()
.Skip(0)
.Take(size)
.OrderBy(e => e.Id)
.ToList();
var actual = await userRepository.GetAllPagedAsync();
actual.EnsurePagedResult(UsersDbSet.Get().ToList().Count, size, page);
var actualItems = actual.Items.ToList();
Assert.That(actualItems.OrderBy(e => e.Id), Is.EqualTo(expected.OrderBy(e => e.Id))
.Using(EqualityComparers.TimeTrackingUserComparer));
}
public async Task IssueRepository_GetAllIssueWithDetails_ShouldReturnPagedResult()
{
var page = 1;
var size = 1;
await using var context = new TimeTrackingDbContext(_dbOptions);
var issueRepository = new IssueRepository(context);
var expected = IssuesDbSet.Get()
.Skip(0)
.Take(size)
.OrderBy(e => e.Id)
.ToList();
var issues = await issueRepository.GetAllIssueWithDetails(page, size);
issues.EnsurePagedResult(IssuesDbSet.Get().ToList().Count, size, page);
var actualItems = issues.Items.ToList();
Assert.That(actualItems.OrderBy(e => e.Id), Is.EqualTo(expected.OrderBy(e => e.Id))
.Using(EqualityComparers.IssueComparer));
}
