public void Test8()
{
using (JobLoggerDbContext db = new JobLoggerDbContext())
{
int featureCount = db.Features.ToArray().Count();
int requirementCount = db.Requirements.ToArray().Count();
int taskCount = db.Tasks.ToArray().Count();
int taskLogCount = db.TaskLogs.ToArray().Count();
int checkInCount = db.CheckIns.ToArray().Count();
int taskCheckInCount = db.TaskCheckIns.ToArray().Count();
int taskCommentCount = db.TaskComments.ToArray().Count();
Task task = new TaskBF(db).Create(
new Task {
ID = 10, Title = "Task Number 10", TaskType = TaskType.Task, IsActive = true
});
Assert.AreEqual(featureCount + 0, db.Features.ToArray().Count());
Assert.AreEqual(requirementCount + 0, db.Requirements.ToArray().Count());
Assert.AreEqual(taskCount + 1, db.Tasks.ToArray().Count());
Assert.AreEqual(taskLogCount + 0, db.TaskLogs.ToArray().Count());
Assert.AreEqual(checkInCount + 0, db.CheckIns.ToArray().Count());
Assert.AreEqual(taskCheckInCount + 0, db.TaskCheckIns.ToArray().Count());
Assert.AreEqual(taskCommentCount + 0, db.TaskComments.ToArray().Count());
// need to decouple object from db context
Task taskUI = new Task
{
ID = task.ID,
IsActive = task.IsActive,
Requirement = task.Requirement,
RequirementID = task.RequirementID,
TaskType = task.TaskType,
Title = task.Title
};
taskUI.Comments = new List <TaskComment>
{
new TaskComment {
Comment = "Testing 1 two free"
}
};
taskUI = new TaskBF(db).Update(taskUI);
Assert.AreEqual(featureCount + 0, db.Features.ToArray().Count());
Assert.AreEqual(requirementCount + 0, db.Requirements.ToArray().Count());
Assert.AreEqual(taskCount + 1, db.Tasks.ToArray().Count());
Assert.AreEqual(taskLogCount + 0, db.TaskLogs.ToArray().Count());
Assert.AreEqual(checkInCount + 0, db.CheckIns.ToArray().Count());
Assert.AreEqual(taskCheckInCount + 0, db.TaskCheckIns.ToArray().Count());
Assert.AreEqual(taskCommentCount + 1, db.TaskComments.ToArray().Count());
Task fetchedTask = db.Tasks
.Where(t => t.ID == 10)
.Include(c => c.Comments)
.Single();
Assert.AreEqual(1, fetchedTask.Comments.Count());
}
}
public static void ClearData()
{
using (JobLoggerDbContext db = new JobLoggerDbContext())
{
db.Database.ExecuteSqlCommand("delete from CodeBranch");
db.Database.ExecuteSqlCommand("delete from TaskLog");
db.Database.ExecuteSqlCommand("delete from Task");
db.Database.ExecuteSqlCommand("delete from Requirement");
db.Database.ExecuteSqlCommand("delete from Feature");
new CodeBranchBF(db).Create(new CodeBranch {
Name = "Code Branch 1"
});
}
dataHasBeenCleared = true;
}
public void Test6()
{
using (JobLoggerDbContext db = new JobLoggerDbContext())
{
int featureCount = db.Features.ToArray().Count();
int requirementCount = db.Requirements.ToArray().Count();
int taskCount = db.Tasks.ToArray().Count();
int taskLogCount = db.TaskLogs.ToArray().Count();
int checkInCount = db.CheckIns.ToArray().Count();
int taskCheckInCount = db.TaskCheckIns.ToArray().Count();
Requirement requirement = new RequirementBF(db).Create(
new Requirement {
ID = 5, Title = "Requirement Number 5", Status = RequirementStatus.Active
});
Assert.AreEqual(featureCount + 0, db.Features.ToArray().Count());
Assert.AreEqual(requirementCount + 1, db.Requirements.ToArray().Count());
Assert.AreEqual(taskCount + 0, db.Tasks.ToArray().Count());
Assert.AreEqual(taskLogCount + 0, db.TaskLogs.ToArray().Count());
Assert.AreEqual(checkInCount + 0, db.CheckIns.ToArray().Count());
Assert.AreEqual(taskCheckInCount + 0, db.TaskCheckIns.ToArray().Count());
Task newTask = new Task
{
ID = 9,
Title = "Task Number 9",
IsActive = true,
TaskType = TaskType.Task,
RequirementID = 5
};
newTask = new TaskBF(db).Create(newTask);
Assert.AreEqual(featureCount + 0, db.Features.ToArray().Count());
Assert.AreEqual(requirementCount + 1, db.Requirements.ToArray().Count());
Assert.AreEqual(taskCount + 1, db.Tasks.ToArray().Count());
Assert.AreEqual(taskLogCount + 0, db.TaskLogs.ToArray().Count());
Assert.AreEqual(checkInCount + 0, db.CheckIns.ToArray().Count());
Assert.AreEqual(taskCheckInCount + 0, db.TaskCheckIns.ToArray().Count());
Requirement fetchedRequirement = db.Requirements
.Where(r => r.ID == 5)
.Include(t => t.Tasks)
.Single();
Assert.AreEqual(1, fetchedRequirement.Tasks.Count());
}
}
public void FeatureTest3()
{
using (JobLoggerDbContext db = new JobLoggerDbContext())
{
long codeBranchId = db.CodeBranches.First().ID;
FeatureAPI feature = GlobalCommon.NewFeature(7, "Feature Number 7");
feature.Requirements.Add(GlobalCommon.NewRequirement(11, "Requirement Number 11"));
feature.Requirements.Add(GlobalCommon.NewRequirement(12, "Requirement Number 12"));
feature.Requirements[0].Tasks.Add(GlobalCommon.NewTask(17, "Task Number 17"));
feature.Requirements[0].Tasks.Add(GlobalCommon.NewTask(18, "Task Number 18"));
feature.Requirements[1].Tasks.Add(GlobalCommon.NewTask(19, "Task Number 19"));
feature.Requirements[1].Tasks.Add(GlobalCommon.NewTask(20, "Task Number 20"));
feature.Requirements[1].Tasks.Add(GlobalCommon.NewTask(21, "Task Number 21"));
feature.Requirements[0].Comments.Add(new RequirementCommentAPI {
Comment = "Comment 1 for Requirement 11"
});
feature.Requirements[0].Comments.Add(new RequirementCommentAPI {
Comment = "Comment 2 for Requirement 11"
});
feature.Requirements[1].Comments.Add(new RequirementCommentAPI {
Comment = "Comment 1 for Requirement 12"
});
feature.Requirements[0].Tasks[0].Comments.Add(new TaskCommentAPI {
Comment = "Comment 1 for Task 11"
});
feature.Requirements[0].Tasks[0].Comments.Add(new TaskCommentAPI {
Comment = "Comment 2 for Task 11"
});
feature.Requirements[0].Tasks[0].Logs.Add(GlobalCommon.NewTaskLog(DateTime.Parse("4 Jul 2019 09:00")));
feature.Requirements[0].Tasks[1].Logs.Add(GlobalCommon.NewTaskLog(DateTime.Parse("4 Jul 2019 11:00")));
feature.Requirements[0].Tasks[0].Logs[0].Comments.Add(new TaskLogCommentAPI {
Comment = "Comment 1 for TaskLog 1 for Task 17"
});
feature.Requirements[0].Tasks[1].Logs[0].Comments.Add(new TaskLogCommentAPI {
Comment = "Comment 1 for TaskLog 1 for Task 18"
});
feature.Requirements[0].Tasks[0].Logs[0].CheckIns.Add(
GlobalCommon.NewCheckIn(3, DateTime.Parse("4 Jul 2019 10:45"), codeBranchId, feature.Requirements[0].Tasks[0].ID));
feature = FeatureAPI.From(new FeatureBF(db).Create(FeatureAPI.To(feature)));
FeatureAPI fetched = FeatureAPI.From(new FeatureBF(db).Get(7));
CheckObjectCount(fetched, 2, 3, 5, 2, 2, 2, 1, 1);
}
}
public void Test7()
{
using (JobLoggerDbContext db = new JobLoggerDbContext())
{
int featureCount = db.Features.ToArray().Count();
int requirementCount = db.Requirements.ToArray().Count();
int taskCount = db.Tasks.ToArray().Count();
int taskLogCount = db.TaskLogs.ToArray().Count();
int checkInCount = db.CheckIns.ToArray().Count();
int taskCheckInCount = db.TaskCheckIns.ToArray().Count();
Feature feature = new FeatureBF(db).Create(
new Feature {
ID = 4, Title = "Feature Number 4", Status = RequirementStatus.Active
});
Assert.AreEqual(featureCount + 1, db.Features.ToArray().Count());
Assert.AreEqual(requirementCount + 0, db.Requirements.ToArray().Count());
Assert.AreEqual(taskCount + 0, db.Tasks.ToArray().Count());
Assert.AreEqual(taskLogCount + 0, db.TaskLogs.ToArray().Count());
Assert.AreEqual(checkInCount + 0, db.CheckIns.ToArray().Count());
Assert.AreEqual(taskCheckInCount + 0, db.TaskCheckIns.ToArray().Count());
Requirement newRequirement = new Requirement
{
ID = 6,
Title = "Requirement Number 6",
Status = RequirementStatus.Active,
FeatureID = 4
};
newRequirement = new RequirementBF(db).Create(newRequirement);
Assert.AreEqual(featureCount + 1, db.Features.ToArray().Count());
Assert.AreEqual(requirementCount + 1, db.Requirements.ToArray().Count());
Assert.AreEqual(taskCount + 0, db.Tasks.ToArray().Count());
Assert.AreEqual(taskLogCount + 0, db.TaskLogs.ToArray().Count());
Assert.AreEqual(checkInCount + 0, db.CheckIns.ToArray().Count());
Assert.AreEqual(taskCheckInCount + 0, db.TaskCheckIns.ToArray().Count());
Feature fetchedFeature = db.Features
.Where(f => f.ID == 4)
.Include(r => r.Requirements)
.Single();
Assert.AreEqual(1, fetchedFeature.Requirements.Count());
}
}
public void FeatureTest1()
{
using (JobLoggerDbContext db = new JobLoggerDbContext())
{
FeatureAPI feature = GlobalCommon.NewFeature(5, "Feature Number 5");
feature.Requirements.Add(GlobalCommon.NewRequirement(7, "Requirement Number 7"));
feature.Requirements[0].Comments.Add(new RequirementCommentAPI {
Comment = "Comment Number 1"
});
feature.Requirements[0].Comments.Add(new RequirementCommentAPI {
Comment = "Comment Number 2"
});
feature.Requirements[0].Tasks.Add(GlobalCommon.NewTask(11, "Task Number 11"));
feature.Requirements[0].Tasks[0].Comments.Add(new TaskCommentAPI {
Comment = "Comment Number 1"
});
feature.Requirements[0].Tasks[0].Comments.Add(new TaskCommentAPI {
Comment = "Comment Number 2"
});
feature.Requirements[0].Tasks[0].Logs.Add(GlobalCommon.NewTaskLog(DateTime.Parse("1 Jan 2019 09:00")));
feature.Requirements[0].Tasks[0].Logs[0].Comments.Add(new TaskLogCommentAPI {
Comment = "TaskLog Comment Number 1"
});
feature.Requirements[0].Tasks[0].Logs[0].Comments.Add(new TaskLogCommentAPI {
Comment = "TaskLog Comment Number 2"
});
feature.Requirements.Add(GlobalCommon.NewRequirement(8, "Requirement Number 8"));
Assert.IsTrue(feature.IsNew);
Assert.IsTrue(feature.Requirements[0].IsNew);
Assert.IsTrue(feature.Requirements[1].IsNew);
Assert.IsTrue(feature.Requirements[0].Tasks[0].IsNew);
feature = FeatureAPI.From(new FeatureBF(db).Create(FeatureAPI.To(feature)));
Assert.IsFalse(feature.IsNew);
Assert.IsFalse(feature.Requirements[0].IsNew);
Assert.IsFalse(feature.Requirements[1].IsNew);
Assert.IsFalse(feature.Requirements[0].Tasks[0].IsNew);
FeatureAPI fetchedFeature = FeatureAPI.From(new FeatureBF(db).Get(5));
CompareFeatureToFetchedFeature(feature, fetchedFeature);
}
}
public ToolsBF(JobLoggerDbContext db)
{
this.db = db;
}
public ToolsController([FromServices] JobLoggerDbContext db) : base(db)
{
}
public CandidateBusiness()
{
JobLoggerDbContext dbContext = new JobLoggerDbContext();
_candidateData = new CandidateData(dbContext);
}
public FeatureController([FromServices] JobLoggerDbContext db) : base(db)
{
}
public RequirementController([FromServices] JobLoggerDbContext db) : base(db)
{
}
public CodeBranchBF(JobLoggerDbContext db)
{
this.db = db;
}
public void FeatureTest2()
{
FeatureAPI feature = GlobalCommon.NewFeature(6, "Feature Number 6");
using (JobLoggerDbContext db = new JobLoggerDbContext())
{
feature = FeatureAPI.From(new FeatureBF(db).Create(FeatureAPI.To(feature)));
Assert.IsFalse(feature.IsNew);
feature.Requirements.Add(GlobalCommon.NewRequirement(9, "Requirement Number 9"));
feature.Requirements[0].Comments.Add(new RequirementCommentAPI {
Comment = "Comment 1 for Requirement 9"
});
feature.Requirements[0].Comments.Add(new RequirementCommentAPI {
Comment = "Comment 2 for Requirement 9"
});
feature.Requirements[0].Tasks.Add(GlobalCommon.NewTask(12, "Task Number 12"));
feature.Requirements[0].Tasks[0].Comments.Add(new TaskCommentAPI {
Comment = "Comment 1 for Task 12"
});
feature.Requirements[0].Tasks[0].Comments.Add(new TaskCommentAPI {
Comment = "Comment 2 for Task 12"
});
feature.Requirements[0].Tasks[0].Logs.Add(GlobalCommon.NewTaskLog(DateTime.Parse("1 Jan 2019 09:00")));
feature.Requirements[0].Tasks[0].Logs[0].Comments.Add(new TaskLogCommentAPI {
Comment = "Comment 1 for Time Log 1 for Task 12"
});
feature.Requirements[0].Tasks[0].Logs[0].Comments.Add(new TaskLogCommentAPI {
Comment = "Comment 2 for Time Log 1 for Task 12"
});
feature.Requirements[0].Tasks[0].Logs.Add(GlobalCommon.NewTaskLog(DateTime.Parse("1 Jan 2019 11:30")));
feature.Requirements[0].Tasks[0].Logs[1].Comments.Add(new TaskLogCommentAPI {
Comment = "Comment 1 for Time Log 2 for Task 12"
});
feature.Requirements[0].Tasks[0].Logs[1].Comments.Add(new TaskLogCommentAPI {
Comment = "Comment 2 for Time Log 2 for Task 12"
});
feature.Requirements[0].Tasks.Add(GlobalCommon.NewTask(13, "Task Number 13"));
feature.Requirements[0].Tasks[1].Comments.Add(new TaskCommentAPI {
Comment = "Comment 1 for Task 13"
});
feature.Requirements[0].Tasks[1].Logs.Add(GlobalCommon.NewTaskLog(DateTime.Parse("1 Jan 2019 14:00")));
feature.Requirements[0].Tasks[1].Logs[0].Comments.Add(new TaskLogCommentAPI {
Comment = "Comment 1 for Time Log for Task 13"
});
feature.Requirements[0].Tasks[1].Logs[0].Comments.Add(new TaskLogCommentAPI {
Comment = "Comment 2 for Time Log for Task 13"
});
feature.Requirements[0].Tasks.Add(GlobalCommon.NewTask(14, "Task Number 14"));
feature.Requirements[0].Tasks[2].Comments.Add(new TaskCommentAPI {
Comment = "Comment 1 for Task 14"
});
feature.Requirements[0].Tasks[2].Logs.Add(GlobalCommon.NewTaskLog(DateTime.Parse("2 Jan 2019 09:00")));
feature.Requirements[0].Tasks[2].Logs[0].Comments.Add(new TaskLogCommentAPI {
Comment = "Comment 1 for Time Log for Task 14"
});
feature.Requirements[0].Tasks[2].Logs[0].Comments.Add(new TaskLogCommentAPI {
Comment = "Comment 2 for Time Log for Task 14"
});
feature.Requirements[0].Tasks[2].Logs.Add(GlobalCommon.NewTaskLog(DateTime.Parse("2 Jan 2019 11:00")));
feature.Requirements[0].Tasks[2].Logs[1].Comments.Add(new TaskLogCommentAPI {
Comment = "Comment 1 for Time Log 2 for Task 14"
});
feature.Requirements[0].Tasks[2].Logs[1].Comments.Add(new TaskLogCommentAPI {
Comment = "Comment 2 for Time Log 2 for Task 14"
});
feature = FeatureAPI.From(new FeatureBF(db).Update(FeatureAPI.To(feature)));
CheckObjectCount(feature, 1, 2, 3, 4, 5, 10, 0, 0);
Assert.IsFalse(feature.Requirements[0].IsNew);
feature.Requirements.Add(GlobalCommon.NewRequirement(10, "equirement Number 10"));
feature.Requirements[1].Comments.Add(new RequirementCommentAPI {
Comment = "Comment for Requirement Number 10"
});
feature.Requirements[1].Tasks.Add(GlobalCommon.NewTask(15, "Task Number 15"));
feature.Requirements[1].Tasks[0].Comments.Add(new TaskCommentAPI {
Comment = "Task Comment for Task 15"
});
feature.Requirements[1].Tasks[0].Logs.Add(GlobalCommon.NewTaskLog(DateTime.Parse("3 Jan 2019 09:00")));
feature.Requirements[1].Tasks[0].Logs[0].Comments.Add(new TaskLogCommentAPI {
Comment = "Comment 1 for Task 1 for Task Number 15"
});
feature = FeatureAPI.From(new FeatureBF(db).Update(FeatureAPI.To(feature)));
FeatureAPI fetchedFeature = FeatureAPI.From(new FeatureBF(db).Get(6));
CheckObjectCount(feature, 2, 3, 4, 5, 6, 11, 0, 0);
feature.Requirements[0].Comments.Add(new RequirementCommentAPI {
Comment = "Comment 3 for Requirement 9"
});
feature.Requirements[0].Title = "Updated Requirement Number 9";
feature.Requirements[0].Comments[0].Comment = "Updated Comment for Requirement Number 9";
feature = FeatureAPI.From(new FeatureBF(db).Update(FeatureAPI.To(feature)));
fetchedFeature = FeatureAPI.From(new FeatureBF(db).Get(6));
CheckObjectCount(feature, 2, 4, 4, 5, 6, 11, 0, 0);
Assert.AreEqual("Comment 3 for Requirement 9", fetchedFeature.Requirements[0].Comments[2].Comment);
Assert.AreEqual("Updated Requirement Number 9", fetchedFeature.Requirements[0].Title);
Assert.AreEqual("Updated Comment for Requirement Number 9", fetchedFeature.Requirements[0].Comments[0].Comment);
feature.Requirements[1].Tasks.Add(new TaskAPI
{
ID = 16,
Title = "Bug Number 16",
IsActive = true,
TaskType = TaskType.Bug,
IsNew = true
});
feature = FeatureAPI.From(new FeatureBF(db).Update(FeatureAPI.To(feature)));
fetchedFeature = FeatureAPI.From(new FeatureBF(db).Get(6));
CheckObjectCount(feature, 2, 4, 5, 5, 6, 11, 0, 0);
CheckObjectCount(fetchedFeature, 2, 4, 5, 5, 6, 11, 0, 0);
feature.Requirements[1].Tasks[1].Comments = new List <TaskCommentAPI>
{
new TaskCommentAPI {
Comment = "Comment 1 for Bug 16"
},
new TaskCommentAPI {
Comment = "Comment 2 for Bug 16"
}
};
feature.Requirements[1].Tasks[1].Logs = new List <TaskLogAPI>
{
new TaskLogAPI
{
LogDate = DateTime.Parse("2 Jan 2019"),
StartTime = TimeSpan.Parse("09:00"),
EndTime = TimeSpan.Parse("12:00"),
Description = "Task log 1 for Bug 16",
Comments = new List <TaskLogCommentAPI>
{
new TaskLogCommentAPI {
Comment = "Comment for Log 1 of Bug 16"
}
}
},
new TaskLogAPI
{
LogDate = DateTime.Parse("2 Jan 2019"),
StartTime = TimeSpan.Parse("13:00"),
EndTime = TimeSpan.Parse("15:00"),
Description = "Task log 2 for Bug 16",
Comments = new List <TaskLogCommentAPI>
{
new TaskLogCommentAPI {
Comment = "Comment for Log 2 of Bug 16"
}
},
CheckIns = new List <CheckInAPI>
{
new CheckInAPI
{
ID = 2,
CheckInTime = DateTime.Parse("2 Jan 2019 14:34"),
CodeBranchID = db.CodeBranches.Where(c => c.Name == "Code Branch 1").Single().ID,
Comment = "CheckIn Number 2",
IsNew = true,
TaskCheckIns = new List <TaskCheckInAPI>
{
new TaskCheckInAPI {
TaskID = feature.Requirements[1].Tasks[1].ID
}
}
}
}
}
};
feature = FeatureAPI.From(new FeatureBF(db).Update(FeatureAPI.To(feature)));
fetchedFeature = FeatureAPI.From(new FeatureBF(db).Get(6));
CheckObjectCount(feature, 2, 4, 5, 7, 8, 13, 1, 1);
CheckObjectCount(fetchedFeature, 2, 4, 5, 7, 8, 13, 1, 1);
}
}
public RequirementBF(JobLoggerDbContext db)
{
this.db = db;
}
public CheckInController([FromServices] JobLoggerDbContext db) : base(db)
{
}
public LogMessageBusiness()
{
JobLoggerDbContext dbContext = new JobLoggerDbContext();
_logMessageData = new LogMessageData(dbContext);
}
public TimesheetReportBF(JobLoggerDbContext db)
{
this.db = db;
}
public TimesheetReportsController([FromServices] JobLoggerDbContext db) : base(db)
{
}
public CodeBranchController([FromServices] JobLoggerDbContext db) : base(db)
{
}
public ReportsBF(JobLoggerDbContext db)
{
this.db = db;
}
public FeatureBF(JobLoggerDbContext db)
{
this.db = db;
}
public TaskLogBF(JobLoggerDbContext db)
{
this.db = db;
}
public RecluterUserBusiness()
{
JobLoggerDbContext dbContext = new JobLoggerDbContext();
_recluterUserData = new RecluterUserData(dbContext);
}
public CheckInBF(JobLoggerDbContext db)
{
this.db = db;
}
public void Test5()
{
using (JobLoggerDbContext db = new JobLoggerDbContext())
{
int featureCount = db.Features.ToArray().Count();
int requirementCount = db.Requirements.ToArray().Count();
int taskCount = db.Tasks.ToArray().Count();
int taskLogCount = db.TaskLogs.ToArray().Count();
int checkInCount = db.CheckIns.ToArray().Count();
int taskCheckInCount = db.TaskCheckIns.ToArray().Count();
Feature feature = new Feature
{
ID = 3, Title = "Feature Number 3", Status = RequirementStatus.Active,
Requirements = new List <Requirement>
{
new Requirement
{
ID = 4, Title = "Requirement Number 4", Status = RequirementStatus.Active,
Tasks = new List <Task>
{
new Task {
ID = 8, Title = "Task Number 8", TaskType = TaskType.Task, IsActive = true
}
}
}
}
};
feature = new FeatureBF(db).Create(feature);
Assert.AreEqual(featureCount + 1, db.Features.ToArray().Count());
Assert.AreEqual(requirementCount + 1, db.Requirements.ToArray().Count());
Assert.AreEqual(taskCount + 1, db.Tasks.ToArray().Count());
Assert.AreEqual(taskLogCount, db.TaskLogs.ToArray().Count());
Assert.AreEqual(checkInCount, db.CheckIns.ToArray().Count());
Assert.AreEqual(taskCheckInCount, db.TaskCheckIns.ToArray().Count());
TaskLog newTaskLog = new TaskLog
{
LogDate = DateTime.Parse("1-July-2019"),
StartTime = TimeSpan.Parse("08:30"),
EndTime = TimeSpan.Parse("10:15"),
Description = "TaskLog Number 1",
TaskID = 8
};
newTaskLog = new TaskLogBF(db).Create(newTaskLog);
Assert.AreEqual(featureCount + 1, db.Features.ToArray().Count());
Assert.AreEqual(requirementCount + 1, db.Requirements.ToArray().Count());
Assert.AreEqual(taskCount + 1, db.Tasks.ToArray().Count());
Assert.AreEqual(taskLogCount + 1, db.TaskLogs.ToArray().Count());
Assert.AreEqual(checkInCount, db.CheckIns.ToArray().Count());
Assert.AreEqual(taskCheckInCount, db.TaskCheckIns.ToArray().Count());
CheckIn newCheckIn = new CheckIn
{
ID = 1,
CheckInTime = DateTime.Parse("1-July-2019 09:43"),
Comment = "CheckIn Number 1",
CodeBranchID = db.CodeBranches.Where(c => c.Name == "Code Branch 1").Single().ID,
TaskCheckIns = new List <TaskCheckIn> {
new TaskCheckIn {
TaskID = 8
}
},
TaskLog = newTaskLog
};
newCheckIn = new CheckInBF(db).Create(newCheckIn);
Assert.AreEqual(featureCount + 1, db.Features.ToArray().Count());
Assert.AreEqual(requirementCount + 1, db.Requirements.ToArray().Count());
Assert.AreEqual(taskCount + 1, db.Tasks.ToArray().Count());
Assert.AreEqual(taskLogCount + 1, db.TaskLogs.ToArray().Count());
Assert.AreEqual(checkInCount + 1, db.CheckIns.ToArray().Count());
Assert.AreEqual(taskCheckInCount + 1, db.TaskCheckIns.ToArray().Count());
Task fetchedTask = db.Tasks
.Where(t => t.ID == 8)
.Include(l => l.Logs)
.ThenInclude(c => c.CheckIns)
.ThenInclude(t => t.TaskCheckIns)
.Single();
Assert.AreEqual(1, fetchedTask.Logs.Count());
Assert.AreEqual(1, fetchedTask.Logs.First().CheckIns.Count());
Assert.AreEqual(1, fetchedTask.Logs.First().CheckIns.First().TaskCheckIns.Count());
}
}
