public void GetLoadedAssignmentQuestionIds_ReturnsIdsInCorrectOrder()
{
var uqds = new Dictionary <int, UserQuestionData>()
{
[1] = new UserQuestionData()
{
AssignmentQuestion = new AssignmentQuestion()
{
Id = 1,
Order = 2
}
},
[2] = new UserQuestionData()
{
AssignmentQuestion = new AssignmentQuestion()
{
Id = 2,
Order = 1
}
},
};
var store = new UserQuestionDataStore(uqds);
Assert.Equal(new List <int> {
2, 1
}, store.GetLoadedAssignmentQuestionIds());
}
/// <summary>
/// Grades a question submission.
/// </summary>
public async Task <GradeSubmissionResult> GradeSubmissionAsync(
UserQuestionDataStore store,
QuestionSubmission submission,
DateTime dateSubmitted)
{
var userQuestionData = store.GetUserQuestionData
(
submission.AssignmentQuestionId
);
var userQuestionStatus = GetUserQuestionStatus(userQuestionData);
var resolvedQuestion = await ResolveUnsolvedQuestionAsync
(
userQuestionData
);
var scoredQuestionResult = await GradeSubmission
(
submission,
resolvedQuestion,
userQuestionData,
userQuestionStatus,
dateSubmitted
);
if (userQuestionData.AssignmentQuestion.IsInteractive())
{
return(new GradeSubmissionResult(scoredQuestionResult));
}
else
{
return(new GradeSubmissionResult(dateSubmitted));
}
}
/// <summary>
/// Returns a mock QuestionResolver.
/// </summary>
private IQuestionResolverFactory GetMockQuestionResolverFactory(
UserQuestionDataStore store,
Question resolvedQuestion = null,
UserQuestionSubmission submission = null)
{
var questionResolverFactory = new Mock <IQuestionResolverFactory>();
var userQuestionData = store.GetUserQuestionData
(
store.GetLoadedAssignmentQuestionIds()[0]
);
if (submission != null)
{
questionResolverFactory
.Setup
(
m => m
.CreateQuestionResolver(userQuestionData)
.ResolveSolvedQuestionAsync(submission)
).ReturnsAsync(resolvedQuestion);
}
else
{
questionResolverFactory
.Setup
(
m => m
.CreateQuestionResolver(userQuestionData)
.ResolveUnsolvedQuestionAsync()
).ReturnsAsync(resolvedQuestion);
}
return(questionResolverFactory.Object);
}
/// <summary>
/// Returns a mock UserQuestionDataLoaderFactory.
/// </summary>
private IUserQuestionDataLoaderFactory GetMockUserQuestionDataLoaderFactory(
string classroomName,
int assignmentId,
int userId,
int[] assignmentQuestionIds)
{
var factory = new Mock <IUserQuestionDataLoaderFactory>();
var store = new UserQuestionDataStore
(
assignmentQuestionIds.ToDictionary
(
id => id,
id => new UserQuestionData()
{
AssignmentQuestion = new AssignmentQuestion()
{
Id = id
}
}
)
);
if (assignmentQuestionIds.Length == 1)
{
factory
.Setup
(
m => m.CreateLoaderForSingleQuestion
(
classroomName,
assignmentId,
assignmentQuestionIds[0],
userId
).LoadUserQuestionDataAsync()
).ReturnsAsync(store);
}
else
{
factory
.Setup
(
m => m.CreateLoaderForAllAssignmentQuestions
(
classroomName,
assignmentId,
userId
).LoadUserQuestionDataAsync()
).ReturnsAsync(store);
}
return(factory.Object);
}
/// <summary>
/// Returns the submission result for the given submission.
/// </summary>
public async Task <SubmissionResult> GetSubmissionResultAsync(
UserQuestionDataStore store,
int assignmentQuestionId,
DateTime submissionDate,
DateTime?dueDate)
{
var userQuestionData = store.GetUserQuestionData(assignmentQuestionId);
var submission = userQuestionData.Submissions
?.FirstOrDefault
(
s => (s.DateSubmitted - submissionDate).Duration() <
TimeSpan.FromMilliseconds(1)
);
if (submission == null)
{
return(null);
}
var submissionContents = _jsonSerializer
.Deserialize <QuestionSubmission>(submission.SubmissionContents);
var resolvedQuestion = await ResolveSolvedQuestionAsync
(
userQuestionData,
submission
);
var questionToSolve = await GetQuestionToSolveAsync
(
userQuestionData,
resolvedQuestion,
submissionContents
);
var scoredQuestionResult = await GradeQuestionAsync
(
resolvedQuestion,
submissionContents
);
return(new SubmissionResult
(
questionToSolve,
scoredQuestionResult.Result,
GetSubmissionScore(submission, dueDate, withLateness: false),
GetSubmissionScore(submission, dueDate, withLateness: true),
submission.UserQuestionData.AssignmentQuestion.Points,
submission.DateSubmitted
));
}
public void GetUserQuestionData_ReturnsUserQuestionData()
{
var uqds = new Dictionary <int, UserQuestionData>()
{
[1] = new UserQuestionData()
{
Id = 12345
}
};
var store = new UserQuestionDataStore(uqds);
Assert.Equal(12345, store.GetUserQuestionData(1).Id);
}
/// <summary>
/// Returns the question with the given ID.
/// </summary>
public async Task <QuestionToSolve> GetQuestionToSolveAsync(
UserQuestionDataStore userQuestionDataStore,
int assignmentQuestionId)
{
var userQuestionData = userQuestionDataStore
.GetUserQuestionData(assignmentQuestionId);
var lastSubmission = GetLastQuestionAttempt(userQuestionData);
var resolvedQuestion = await ResolveUnsolvedQuestionAsync(userQuestionData);
return(await GetQuestionToSolveAsync
(
userQuestionData,
resolvedQuestion,
lastSubmission
));
}
/// <summary>
/// Returns a mock QuestionStatusCalculator.
/// </summary>
private IQuestionStatusCalculator GetMockQuestionStatusCalculator(
UserQuestionDataStore store,
UserQuestionStatus userQuestionStatus = null)
{
var userQuestionData = store.GetUserQuestionData
(
store.GetLoadedAssignmentQuestionIds()[0]
);
var statusCalculator = new Mock <IQuestionStatusCalculator>();
statusCalculator
.Setup(m => m.GetQuestionStatus(userQuestionData))
.Returns(userQuestionStatus ?? CreateUserQuestionStatus());
return(statusCalculator.Object);
}
/// <summary>
/// Returns a mock assignment progress retriever.
/// </summary>
private IAssignmentProgressRetriever GetMockAssignmentProgressRetriever(
UserQuestionDataStore store,
AssignmentProgress assignmentProgress = null)
{
var assignmentProgressRetriever = new Mock <IAssignmentProgressRetriever>();
var uqd = store.GetUserQuestionData
(
store.GetLoadedAssignmentQuestionIds()[0]
);
assignmentProgressRetriever
.Setup
(
m => m.GetAssignmentProgressAsync
(
uqd.AssignmentQuestion.AssignmentId,
uqd.AssignmentQuestionId,
uqd.UserId
)
).ReturnsAsync(assignmentProgress);
return(assignmentProgressRetriever.Object);
}
