public async Task should_call_repo_to_save_new_cert_status_for_the_user_when_cert_is_valid()
{
var certStatusCursor = StubCursor <CertificationStatus>(CertificationStatusCollectionName);
StubNotFoundResult(certStatusCursor);
var certCursor = StubCursor <Certification>(CertCollectionName);
var cert = new Certification {
IsActive = true
};
StubSingleFoundResult(certCursor, cert);
var courseCursor = StubCursor <Course>(CourseCollectionName);
var course = new Course {
CertificationId = CertId, IsActive = true
};
StubSingleFoundResult(courseCursor, course);
var status = new CertificationStatus();
Repository.Setup(x => x.SaveAsync(CertificationStatusCollectionName, It.IsAny <CertificationStatus>()))
.ReturnsAsync(status);
var result = await _controller.CreateStatus(Id);
result.Data.Should().Be(status);
Repository.Verify(x => x.SaveAsync(CertificationStatusCollectionName, It.IsAny <CertificationStatus>()));
}
public void should_add_each_active_course_from_course_list()
{
_courses.Last().IsActive = false;
var certStatus = new CertificationStatus(_cert, _courses, _user);
_courses.Count.Should().BeGreaterThan(certStatus.Courses.Count);
certStatus.Courses.Count.Should().Be(_courses.Count - 1);
}
public void should_add_each_active_quiz_from_course()
{
_courses.First().Quizzes.Last().IsActive = false;
var certStatus = new CertificationStatus(_cert, _courses, _user);
var inputQuizCount = _courses.First().Quizzes.Count;
inputQuizCount.Should().BeGreaterThan(certStatus.Courses.First().Quizzes.Count);
certStatus.Courses.First().Quizzes.Count.Should().Be(inputQuizCount - 1);
}
public void should_add_initial_quiz_status_on_creation()
{
var certStatus = new CertificationStatus(_cert, _courses, _user);
foreach (var course in certStatus.Courses)
{
foreach (var quiz in course.Quizzes)
{
quiz.QuizStatuses.Count.Should().Be(1);
}
}
}
public void should_add_new_quiz_status_when_none_exist()
{
var certStatus = new CertificationStatus(_cert, _courses, _user);
var courseStatus = certStatus.Courses.First();
var quiz = courseStatus.Quizzes.First();
quiz.QuizStatuses.Clear();
courseStatus.RestartQuiz(quiz);
courseStatus.Quizzes.First().QuizStatuses.Should().HaveCount(1);
}
public void should_throw_exception_when_cert_status_already_exists()
{
var certId = new ObjectId();
var certStatusCursor = StubCursor <CertificationStatus>(CertificationStatusController.CollectionName);
var status = new CertificationStatus {
CertificationId = certId
};
StubSingleFoundResult(certStatusCursor, status);
_controller.Awaiting(x => x.CreateStatus(certId.ToString())).Should().Throw <HttpBadRequestException>()
.And.StatusCode.Should().Be(HttpStatusCode.BadRequest);
}
public void should_initialize_base_properties_from_cert()
{
var certStatus = new CertificationStatus(_cert, _courses, _user);
certStatus.TenantId.Should().Be(_cert.TenantId);
certStatus.CertificationId.Should().Be(_cert.Id);
certStatus.CertificationVersion.Should().Be(_cert.CertificationVersion);
certStatus.Name.Should().Be(_cert.Name);
certStatus.Description.Should().Be(_cert.Description);
certStatus.CreatedBy.Should().Be(_user);
certStatus.Language.Should().Be(_cert.Language);
certStatus.Expiration.Should().Be(_cert.Expiration);
}
private async Task <bool> CheckForCertificationCompletion(CertificationStatus certStatus)
{
if (certStatus.Courses.Any(c => !c.HasPassed))
{
return(false);
}
certStatus.IsComplete = true;
certStatus.CompletedAt = DateTime.UtcNow;
var result = await _repository.UpdateAsync(CertificationStatusController.CollectionName,
x => x.Id == certStatus.Id, certStatus);
return(await _messenger.SendMessage(CertificationCompletionName, certStatus.ToCertificationCompletion()));
}
public void should_initialize_base_properties_from_course()
{
var certStatus = new CertificationStatus(_cert, _courses, _user);
var course = _courses.First();
var courseStatus = certStatus.Courses.First();
courseStatus.TenantId.Should().Be(course.TenantId);
courseStatus.CertificationId.Should().Be(ObjectId.Parse(course.CertificationId));
courseStatus.CourseId.Should().Be(course.Id);
courseStatus.Name.Should().Be(course.Name);
courseStatus.Description.Should().Be(course.Description);
courseStatus.CreatedBy.Should().Be(_user);
}
private CourseStatus GetCourseStatus(CertificationStatus certStatus, ObjectId courseId)
{
var courseStatus = certStatus.Courses.SingleOrDefault(x => x.CourseId == courseId);
if (courseStatus == null)
{
throw new HttpNotFoundException(new ApiError(
nameof(NotFound),
$"Could not find {nameof(Course)} by $id",
additionalData: new Dictionary <string, string> {
{ "id", courseId.ToString() }
}));
}
return(courseStatus);
}
private static void AssertCertStatusIsNotCompleted(CertificationStatus status)
{
if (status.IsComplete)
{
throw new HttpStatusCodeException
(
HttpStatusCode.MethodNotAllowed,
new ApiError
(
nameof(BadRequest),
"May not modify a completed certification status"
)
);
}
}
public void SetUp()
{
_objectId = new ObjectId();
_user = new User
{
UserId = UserId,
Username = Username,
FirstName = FirstName,
LastName = LastName
};
var cert = CreateCertification();
var courses = CreateCourses();
_certStatus = new CertificationStatus(cert, courses, _user);
_courseStatus = _certStatus.Courses.First();
}
public async Task should_call_repo_to_find_cert_statuses()
{
var objectId = ObjectId.Parse(Id);
var certStatusCursor = StubCursor <CertificationStatus>(CertificationStatusCollectionName);
var certStatus1 = new CertificationStatus();
var certStatus2 = new CertificationStatus {
IsComplete = true
};
StubListOfResult(certStatusCursor, new List <CertificationStatus> {
certStatus1, certStatus2
});
var result = await _controller.GetStatus(Id);
Repository.Verify(x => x.FindAsync(CertificationStatusCollectionName,
It.Is <Expression <Func <CertificationStatus, bool> > >(e => Lambda.Eq(e, f => f.CertificationId == objectId && f.CreatedBy.UserId == UserId))));
result.Data.Count.Should().Be(2);
}
public static CertificationCompletion ToCertificationCompletion(this CertificationStatus status)
{
var now = DateTime.UtcNow;
var completion = new CertificationCompletion
{
CertificationVersion = status.CertificationVersion,
ProgramId = status.TenantId,
Id = status.CertificationId,
Name = status.Name,
Description = status.Description,
CreatedBy = status.CreatedBy,
CompletedAt = now
};
if (status.Expiration > 0)
{
completion.Expiration = now.AddMonths(status.Expiration);
}
return(completion);
}
public void should_close_old_quiz_status_and_add_new_quiz_status_when_one_already_exists()
{
var certStatus = new CertificationStatus(_cert, _courses, _user);
var courseStatus = certStatus.Courses.First();
var quiz = courseStatus.Quizzes.First();
courseStatus.RestartQuiz(quiz);
courseStatus.Quizzes.First().QuizStatuses.Should().HaveCount(2);
var oldQuiz = courseStatus.Quizzes.First().QuizStatuses.First();
oldQuiz.Status.Should().Be(QuizStatus.Restarted);
oldQuiz.IsComplete.Should().BeTrue();
oldQuiz.HasPassed.Should().BeFalse();
var newQuiz = courseStatus.Quizzes.First().QuizStatuses.Last();
newQuiz.Status.Should().Be(QuizStatus.NotStarted);
newQuiz.IsComplete.Should().BeFalse();
newQuiz.HasPassed.Should().BeFalse();
}
public CertificationStatus Update(CertificationStatus certStatus)
{
certStatus.UpdatedAt = DateTime.UtcNow;
foreach (var courseStatus in certStatus.Courses)
{
courseStatus.Quizzes.ForEach(ValidateQuizzes);
if (!AllQuizzesAreCompleted(courseStatus))
{
return(certStatus);
}
courseStatus.CompletedAt = DateTime.UtcNow;
courseStatus.HasPassed = AllQuizzesArePassed(courseStatus);
if (courseStatus.HasPassed)
{
courseStatus.IsLocked = true;
}
}
return(certStatus);
}
public void SetUp()
{
_objectIdString = new ObjectId().ToString();
_messenger = new Mock <IMessenger>();
_messenger.Setup(x => x.SendMessage(It.IsAny <string>(), It.IsAny <object>())).ReturnsAsync(true);
_handler = new CourseCompletionHandler(Repository.Object, _messenger.Object);
var courses = new List <Course>
{
new Course {
IsActive = true, CertificationId = _objectIdString
},
new Course {
IsActive = true, CertificationId = _objectIdString
}
};
_certStatus = new CertificationStatus(new Certification(), courses, new User {
UserId = UserId
});
_courseStatus = _certStatus.Courses.First();
}
public async Task <ApiResult <CertificationStatus> > CreateStatus([FromRoute] string id)
{
var certId = ParseCertId(id);
var userId = User.ToUserId();
var results = await _repository.FindAsync <CertificationStatus>(CertificationStatusController.CollectionName,
x => x.CertificationId == certId && !x.IsComplete && x.CreatedBy.UserId == userId);
if (results.Any())
{
throw new HttpBadRequestException(new ApiError(nameof(BadRequest), "A status already exists for this certification."));
}
var cert = await FindCertificationById(certId);
AssertCertificationIsActive(cert);
var courses = await FindCoursesByCertId(id);
AssertHasAnActiveCourse(courses);
var status = new CertificationStatus(cert, courses, User.ToUserInfo());
return(await _repository.SaveAsync(CertificationStatusController.CollectionName, status));
}
public async Task <bool> CompleteCourse(CertificationStatus certStatus, CourseStatus courseStatus)
{
await _messenger.SendMessage(CourseCompletionName, courseStatus.ToCourseCompletion());
return(await CheckForCertificationCompletion(certStatus));
}
public void SetUp()
{
_updator = new CertificationStatusUpdator();
_now = DateTime.UtcNow;
_status = new CertificationStatus(new Certification(), CreateCourses(), new User());
}
