public void GetAssignmentStatus_GivenAssignmentSubmissionResults_ReturnsHighestScoringStatus()
{
var assignmentSubmissionResults = Collections.CreateList
(
CreateAssignmentSubmissionResult
(
score: 1.0,
status: new SubmissionStatus(Completion.Completed, late: false)
),
CreateAssignmentSubmissionResult
(
score: 0.0,
status: new SubmissionStatus(Completion.InProgress, late: true)
),
CreateAssignmentSubmissionResult
(
score: 0.0,
status: new SubmissionStatus(Completion.NotStarted, late: true)
)
);
var assignmentScoreCalculator = CreateAssignmentScoreCalculator();
var result = assignmentScoreCalculator.GetAssignmentStatus
(
assignmentSubmissionResults,
dueDate: null
);
Assert.Equal(assignmentSubmissionResults[0].Status, result);
}
public void GetAssignmentStatus_GivenQuestionResults_ReturnsAssignmentStatus()
{
var assignmentResults = Collections.CreateList
(
CreateAssignmentResult(status: new SubmissionStatus(Completion.Completed, late: false)),
CreateAssignmentResult(status: new SubmissionStatus(Completion.InProgress, late: true)),
CreateAssignmentResult(status: new SubmissionStatus(Completion.NotStarted, late: true))
);
var expectedResult = new SubmissionStatus(Completion.Completed, late: false);
var submissionStatusCalculator = CreateSubmissionStatusCalculator
(
assignmentResults.Select(qr => qr.Status),
expectedResult
);
var assignmentGroupScoreCalculator = CreateAssignmentGroupScoreCalculator
(
submissionStatusCalculator
);
var result = assignmentGroupScoreCalculator.GetAssignmentGroupStatus
(
assignmentResults
);
Assert.Equal(expectedResult, result);
}
public async Task ValidateSectionAsync_DuplicateSectionRecipients_Error()
{
var database = GetDatabase().Build();
var adminId = database.Context
.ClassroomMemberships
.Single(cm => cm.User.UserName == "Admin1")
.Id;
var errors = new MockErrorCollection();
var validator = new SectionValidator(database.Context);
var section = new Section()
{
SectionRecipients = Collections.CreateList
(
new SectionRecipient()
{
ClassroomMembershipId = adminId,
},
new SectionRecipient()
{
ClassroomMembershipId = adminId,
}
)
};
var result = await validator.ValidateSectionAsync(section, errors);
Assert.False(result);
Assert.True(errors.VerifyErrors("SectionRecipients"));
}
public void FilterSubmissions_UserSpecified_ReturnsUserSubmissionsForAssignment()
{
var assignments = CreateAssignments(1);
var user = new User()
{
Id = 10
};
var submissions = Collections.CreateList
(
CreateSubmission(assignmentId: 1, userId: 10),
CreateSubmission(assignmentId: 1, userId: 20),
CreateSubmission(assignmentId: 2, userId: 10)
);
var assignmentFilter = new AssignmentFilter();
var results = assignmentFilter.FilterSubmissions
(
assignments,
submissions,
user
);
Assert.Equal(1, results.Count);
Assert.Equal(submissions[0], results[0]);
}
public void FilterAssignments_OnlySectionGiven_FiltersToAssignedInSection()
{
var section1 = new Section()
{
Id = 1
};
var section2 = new Section()
{
Id = 2
};
var assignments = Collections.CreateList
(
CreateAssignment("Group2", section1, GetDate(5)),
CreateAssignment("Group1", section1, GetDate(5)),
CreateAssignment("Group1", section1, GetDate(4)),
CreateAssignment("Group1", section2, GetDate(2)),
CreateAssignment("Group2", section2, GetDate(1)),
CreateAssignment("Group1", section: null, dueDate: null)
);
var assignmentFilter = new AssignmentFilter();
var results = assignmentFilter.FilterAssignments
(
assignments,
section1,
assignmentGroupName: null
);
Assert.Equal(3, results.Count);
Assert.Equal(assignments[2], results[0]);
Assert.Equal(assignments[1], results[1]);
Assert.Equal(assignments[0], results[2]);
}
/// <summary>
/// Builds a database.
/// </summary>
private static TestDatabaseBuilder GetDatabase()
{
return(new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddQuestionCategory("Class1", "Category1")
.AddQuestion("Class1", "Category1", new RandomlySelectedQuestion()
{
ChoicesCategory = new QuestionCategory()
{
Questions = Collections.CreateList
(
new MethodQuestion()
{
Id = 100
},
new MethodQuestion()
{
Id = 200
},
new MethodQuestion()
{
Id = 300
}
).Cast <Question>().ToList()
}
}));
}
public void FilterAssignments_OnlyGroupNameGiven_ReturnsAllInGroup()
{
var section1 = new Section()
{
Id = 1
};
var section2 = new Section()
{
Id = 2
};
var assignments = Collections.CreateList
(
CreateAssignment("Group1", section1, GetDate(5)),
CreateAssignment("Group1", section1, GetDate(4)),
CreateAssignment("Group2", section1, GetDate(3)),
CreateAssignment("Group1", section2, GetDate(2)),
CreateAssignment("Group2", section2, GetDate(1)),
CreateAssignment("Group1", section: null, dueDate: null)
);
var assignmentFilter = new AssignmentFilter();
var results = assignmentFilter.FilterAssignments
(
assignments,
null /*section*/,
"Group1"
);
Assert.Equal(4, results.Count);
Assert.Equal(assignments[3], results[0]);
Assert.Equal(assignments[1], results[1]);
Assert.Equal(assignments[0], results[2]);
Assert.Equal(assignments[5], results[3]);
}
public async Task GetAttachmentAsync_ReturnsAttachment()
{
var database = GetDatabase()
.AddConversation("Class1", "Student1", "Student1", "Subject", SentDate,
Collections.CreateList
(
new KeyValuePair <string, byte[]>("Attachment.jpg", new byte[5])
))
.Build();
var studentId = GetUserId(database.Context, "Student1");
var conversationId = database.Context.Conversations.Single().Id;
var attachmentId = database.Context.Attachments.Single().Id;
database.Reload();
var messageService = CreateMessageService(database.Context);
var result = await messageService.GetAttachmentAsync
(
"Class1",
conversationId,
studentId,
false /* admin */,
attachmentId
);
Assert.Equal("Attachment.jpg", result.FileName);
Assert.Equal(5, result.AttachmentData.FileContents.Length);
}
/// <summary>
/// Returns the expected expression for executing a project job.
/// </summary>
private static Expression <Func <IProjectRunnerService, Task> > GetExecuteProjectJobExpression()
{
return(prs => prs.ExecuteProjectJobAsync
(
It.Is <ProjectJob>
(
job => job.ProjectName == "Project1" &&
job.TemplateRepo == "Project1_Template" &&
job.SubmissionRepo == "Project1_LastNameFirstName" &&
job.GitHubOrg == "GitHubOrg" &&
job.CommitSha == "NewCommitSha" &&
job.CallbackPath == "BuildResultCallbackUrl" &&
job.BuildRequestToken == "BuildRequestToken" &&
job.CopyPaths.SequenceEqual
(
Collections.CreateList
(
"Private1",
"Private2",
"Immutable1",
"Immutable2"
)
) &&
job.TestClasses.SequenceEqual
(
Collections.CreateList
(
"TestClass2",
"TestClass1"
)
)
),
"OperationId"
));
}
/// <summary>
/// Returns a new method question.
/// </summary>
public MethodQuestion GetMethodQuestion()
{
return(new MethodQuestion()
{
MethodName = "expectedMethod",
ImportedClasses = Collections.CreateList
(
new ImportedClass()
{
ClassName = "package.classToImport"
}
),
ParameterTypes = "int, int",
ReturnType = "int",
Tests = Collections.CreateList
(
new MethodQuestionTest()
{
Name = $"test1",
Order = 1,
ParameterValues = "1, 2",
ExpectedReturnValue = "expectedReturnValue",
ExpectedOutput = "expectedOutput"
}
)
});
}
/// <summary>
/// Returns a successful method job result.
/// </summary>
public MethodJobResult GetSuccessfulMethodJobResult()
{
return(new MethodJobResult()
{
Status = CodeJobStatus.Completed,
ClassCompilationResult = new CompilationResult()
{
Success = true
},
MethodDefinition = new MethodDefinition()
{
Name = "expectedMethod",
IsPublic = true,
IsStatic = true,
ParameterTypes = Collections.CreateList("int", "int"),
ReturnType = "int"
},
TestsCompilationResult = new CompilationResult()
{
Success = true
},
TestResults = Collections.CreateList
(
new CodeTestResult()
{
Name = "test1",
Completed = true,
Output = "expectedOutput",
ReturnValue = "expectedReturnValue"
}
)
});
}
public async Task GradeSubmissionAsync_WrongReturnType_Error()
{
var question = GetMethodQuestion();
var submission = new CodeQuestionSubmission()
{
Contents = "Submission"
};
var methodJobResult = GetFailedMethodJobResult
(
new MethodDefinition()
{
IsPublic = true,
IsStatic = true,
Name = "expectedMethod",
ParameterTypes = Collections.CreateList("int", "int"),
ReturnType = "boolean"
}
);
var codeRunnerService = GetCodeRunnerService(methodJobResult);
var grader = new MethodQuestionGrader(question, codeRunnerService);
var result = await grader.GradeSubmissionAsync(submission);
var codeQuestionResult = (CodeQuestionResult)result.Result;
var methodReturnTypeError = codeQuestionResult.Errors
.Cast <MethodReturnTypeError>()
.Single();
Assert.Equal(0.0, result.Score);
Assert.Equal("expectedMethod", methodReturnTypeError.MethodName);
Assert.Equal("int", methodReturnTypeError.ExpectedReturnType);
Assert.Equal("boolean", methodReturnTypeError.ActualReturnType);
}
public async Task GradeSubmissionAsync_BlankNamesContainCarriageReturns_ParsedCorrectly()
{
var question = new ShortAnswerQuestion()
{
Blanks = Collections.CreateList
(
new ShortAnswerQuestionBlank()
{
Name = "A\n", Answer = "One"
}
)
};
var submission = new ShortAnswerQuestionSubmission()
{
Blanks = Collections.CreateList
(
new SubmissionBlank()
{
Name = "A\r\n", Answer = "One"
}
)
};
var grader = new ShortAnswerQuestionGrader(question);
var result = await grader.GradeSubmissionAsync(submission);
Assert.Equal(new[] { true }, ((ShortAnswerQuestionResult)result.Result).Correct);
Assert.Equal(1.0, result.Score);
}
/// <summary>
/// Returns a new program question.
/// </summary>
public ProgramQuestion GetProgramQuestion()
{
return(new ProgramQuestion()
{
ProgramClassName = "ExpectedProgram",
ImportedClasses = Collections.CreateList
(
new ImportedClass()
{
ClassName = "package.classToImport"
}
),
Tests = Collections.CreateList
(
new ProgramQuestionTest()
{
Name = $"test1",
TestDescription = "Description",
Order = 1,
CommandLineArguments = "One Two",
ExpectedOutput = "expectedOutput"
}
)
});
}
public void ValidateAnnouncement_InvalidSection_ReturnsFalseWithError()
{
var validator = new AnnouncementValidator();
var modelErrors = new MockErrorCollection();
var result = validator.ValidateAnnouncement
(
new Classroom()
{
Sections = new List <Section>()
},
new Announcement()
{
Sections = Collections.CreateList
(
new AnnouncementSection()
{
SectionId = 1
}
)
},
modelErrors
);
Assert.False(result);
Assert.True(modelErrors.VerifyErrors("Sections"));
}
public void GetNewCommitsToProcess_ReturnsOnlyNewCommits()
{
var project = GetProject();
var studentPushEvents = GetPushEvents(userId: 2);
var existingCommits = Collections.CreateList
(
new CommitDescriptor
(
sha: "PreviousCommitSha",
projectId: 1,
userId: 2
)
);
var pushEventProcessor = GetPushEventProcessor();
var results = pushEventProcessor.GetNewCommitsToProcess
(
project,
existingCommits,
studentPushEvents
);
Assert.Equal(1, results.Count);
Assert.Equal(studentPushEvents[0].PushEvents[0], results[0].PushEvent);
Assert.Equal(1, results[0].Commit.ProjectId);
Assert.Equal(CommitDate.UtcDateTime, results[0].Commit.CommitDate);
Assert.Equal(PushDate.UtcDateTime, results[0].Commit.PushDate);
Assert.Equal("NewCommitSha", results[0].Commit.Sha);
Assert.Equal("NewCommitMessage", results[0].Commit.Message);
Assert.Equal(2, results[0].Commit.UserId);
Assert.NotNull(results[0].Commit.BuildRequestToken);
}
/// <summary>
/// Returns a mock push event retriever.
/// </summary>
private Mock <IPushEventRetriever> GetMockPushEventRetriever(GitHubPushEvent pushEvent)
{
var pushEventRetriever = new Mock <IPushEventRetriever>();
pushEventRetriever
.Setup
(
retriever => retriever.GetAllPushEventsAsync
(
It.Is <Project>
(
project => project.Name == "Project1"
),
It.Is <IList <ClassroomMembership> >
(
students =>
students.Count == 1 &&
students[0].GitHubTeam == "LastNameFirstName"
)
)
)
.Returns <Project, IList <ClassroomMembership> >
(
(project, students) => Task.FromResult <IList <StudentRepoPushEvents> >
(
Collections.CreateList
(
new StudentRepoPushEvents(students[0], Collections.CreateList(pushEvent))
)
)
);
return(pushEventRetriever);
}
/// <summary>
/// Returns build 3 for use during testing.
/// </summary>
private Build GetBuildAllTestsPass()
{
return(new Build()
{
Status = BuildStatus.Completed,
DateStarted = Commit1PushDate,
DateCompleted = Commit1PushDate + SuccessfulBuildDuration,
TestResults = Collections.CreateList
(
new TestResult()
{
ClassName = "TestClass1",
TestName = "Test1",
Succeeded = true,
PreviouslySucceeded = false
},
new TestResult()
{
ClassName = "TestClass2",
TestName = "Test2",
Succeeded = true,
PreviouslySucceeded = true
}
)
});
}
public async Task GenerateQuestionAsync_TestException_ReturnsError()
{
var question = GetGeneratedQuestionTemplate();
var classJobResult = GetSuccessfulClassJobResult();
classJobResult.TestResults = Collections.CreateList
(
new CodeTestResult()
{
Name = "QuestionGenerator",
Completed = false,
Exception = "TestException"
}
);
var questionGenerator = GetQuestionGenerator
(
question,
GetMockCodeRunnerService(classJobResult).Object
);
var result = await questionGenerator.GenerateQuestionAsync
(
question,
1 /*seed*/
);
Assert.NotNull(result.Error);
Assert.Contains("TestException", result.Error);
Assert.Null(result.SerializedQuestion);
}
/// <summary>
/// Builds a database.
/// </summary>
private static TestDatabaseBuilder GetDatabase()
{
return(new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddQuestionCategory("Class1", "Category1")
.AddQuestion("Class1", "Category1", new ClassQuestion()
{
FileTemplate = "%SUBMISSION%",
ImportedClasses = Collections.CreateList(new ImportedClass()
{
ClassName = "Imported"
}),
CodeConstraints = Collections.CreateList(new CodeConstraint()
{
Regex = "Regex"
}),
RequiredMethods = Collections.CreateList(new RequiredMethod()
{
Name = "Required"
}),
Tests = Collections.CreateList(new ClassQuestionTest()
{
Name = "Test"
})
}));
}
public void FilterAssignments_GroupNameAndSectionGiven_ReturnsAssignedInGroupToSection()
{
var section1 = new Section()
{
Id = 1
};
var section2 = new Section()
{
Id = 2
};
var assignments = Collections.CreateList
(
CreateAssignment("Group1", section1, GetDate(5)),
CreateAssignment("Group1", section1, GetDate(4)),
CreateAssignment("Group2", section1, GetDate(3)),
CreateAssignment("Group1", section2, GetDate(2)),
CreateAssignment("Group2", section2, GetDate(1)),
CreateAssignment("Group1", section: null, dueDate: null)
);
var assignmentFilter = new AssignmentFilter();
var results = assignmentFilter.FilterAssignments
(
assignments,
section1,
"Group1"
);
Assert.Equal(2, results.Count);
Assert.Equal(assignments[1], results[0]);
Assert.Equal(assignments[0], results[1]);
}
public void CreateQuestionResult_CompletedOptionalQuestion_ReturnsCorrectStatus()
{
var assignmentQuestion = CreateAssignmentQuestion(points: 0.0);
var user = CreateUser();
var scoredSubmissions = Collections.CreateList
(
CreateScoredSubmission(daysLate: 0, rawScore: 0.0, scoreInAssignment: 0.0, isLate: false),
CreateScoredSubmission(daysLate: 0, rawScore: 1.0, scoreInAssignment: 0.0, isLate: false)
);
var questionResultGenerator = CreateQuestionResultGenerator
(
assignmentQuestion,
scoredSubmissions
);
var result = questionResultGenerator.CreateQuestionResult
(
assignmentQuestion,
user,
scoredSubmissions.Select(s => s.Submission).ToList(),
DueDate
);
Assert.Equal(0.0, result.Score);
Assert.Equal(Completion.Completed, result.Status.Completion);
Assert.False(result.Status.Late);
}
public void FilterSubmissions_UserAndDateSpecified_ReturnsUserSubmissionsForAssignmentThroughDate()
{
var assignments = CreateAssignments(1);
var user = new User()
{
Id = 10
};
var submissions = Collections.CreateList
(
CreateSubmission(assignmentId: 1, userId: 10, dateSubmitted: GetDate(1)),
CreateSubmission(assignmentId: 1, userId: 20, dateSubmitted: GetDate(1)),
CreateSubmission(assignmentId: 2, userId: 10, dateSubmitted: GetDate(2))
);
var assignmentFilter = new AssignmentFilter();
var results = assignmentFilter.FilterSubmissions
(
assignments,
submissions,
user,
snapshotDate: GetDate(1)
);
Assert.Equal(1, results.Count);
Assert.Equal(submissions[0], results[0]);
}
/// <summary>
/// Sets up GetAllCommitsAsync.
/// </summary>
private static void SetupGetAllCommitsAsync(
Mock <IGitHubRepositoryClient> repoClient,
int numCommits)
{
repoClient
.Setup
(
rc => rc.GetAllCommitsAsync
(
"Class1GitHubOrg",
"Project1_LastNameFirstName"
)
).ReturnsAsync
(
new int[numCommits].Select
(
(value, index) => new GitHubCommit
(
$"Sha{index + 1}",
"Class1GitHubOrg",
"Project1_LastNameFirstName",
"GitHubUser",
$"Commit {index + 1}",
DateTimeOffset.UtcNow + TimeSpan.FromSeconds(index),
index == 0
? new List <string>()
: Collections.CreateList($"Sha{index}")
)
).ToList()
);
}
public async Task UpdateAllAsync_UpdatersInvoked()
{
var userQuestionDatas = Collections.CreateList
(
CreateUserQuestionData(0),
CreateUserQuestionData(1),
CreateUserQuestionData(2)
);
var impl1 = new MockUserQuestionDataUpdater();
var impl2 = new MockUserQuestionDataUpdater();
var mockImplFactory = new Mock <IUserQuestionDataUpdaterImplFactory>();
SetupMockImplFactory(mockImplFactory, userQuestionDatas[0], impl1);
SetupMockImplFactory(mockImplFactory, userQuestionDatas[1], impl1);
SetupMockImplFactory(mockImplFactory, userQuestionDatas[2], impl2);
var aggregateUpdater = new AggregateUserQuestionDataUpdater
(
mockImplFactory.Object
);
foreach (var uqd in userQuestionDatas)
{
aggregateUpdater.AddToBatch(uqd);
}
await aggregateUpdater.UpdateAllAsync();
Assert.True(impl1.VerifyUpdates(Collections.CreateList(0, 1)));
Assert.True(impl2.VerifyUpdates(Collections.CreateList(2)));
}
/// <summary>
/// Builds a database.
/// </summary>
private static TestDatabaseBuilder GetDatabase()
{
return(new TestDatabaseBuilder()
.AddClassroom("Class1")
.AddClassroom("Class2")
.AddQuestionCategory("Class1", "Category1")
.AddQuestionCategory("Class2", "Category2")
.AddQuestion("Class1", "Category1", new MultipleChoiceQuestion()
{
Name = "Question1"
})
.AddQuestion("Class1", "Category1", new MultipleChoiceQuestion()
{
Name = "Question2"
})
.AddQuestion("Class1", "Category1", new RandomlySelectedQuestion()
{
Name = "Question3",
ChoicesCategory = new QuestionCategory()
{
Name = "ChoiceCategory",
Questions = Collections.CreateList
(
new MultipleChoiceQuestion()
{
Name = "Choice1"
}
).Cast <Question>().ToList()
}
}));
}
public async Task ValidateSectionAsync_DuplicateSectionGradebooks_Error()
{
var database = GetDatabase().Build();
var classroomGradebookId = database.Context
.ClassroomGradebooks
.First()
.Id;
var errors = new MockErrorCollection();
var validator = new SectionValidator(database.Context);
var section = new Section()
{
SectionGradebooks = Collections.CreateList
(
new SectionGradebook()
{
ClassroomGradebookId = classroomGradebookId,
},
new SectionGradebook()
{
ClassroomGradebookId = classroomGradebookId,
}
)
};
var result = await validator.ValidateSectionAsync(section, errors);
Assert.False(result);
Assert.True(errors.VerifyErrors("SectionGradebooks"));
}
public void ValidateAnnouncement_ValidSections_ReturnsTrueWithNoError()
{
var validator = new AnnouncementValidator();
var modelErrors = new MockErrorCollection();
var result = validator.ValidateAnnouncement
(
new Classroom()
{
Sections = Collections.CreateList
(
new Section()
{
Id = 1
}
)
},
new Announcement()
{
Sections = Collections.CreateList
(
new AnnouncementSection()
{
SectionId = 1
}
)
},
modelErrors
);
Assert.True(result);
Assert.False(modelErrors.HasErrors);
}
public async Task DownloadSubmissionsAsync_ValidSubmission_DownloadsSubmission()
{
var classroom = GetClassroom();
var project = GetProject(classroom);
var checkpoint = GetCheckpoint(project);
var student = GetStudent(classroom, "Student1");
var studentRepo = new RepositoryContents
(
"Project1_Student1",
"Checkpoint1",
ArchiveStore.FileSystem
);
var repoClient = GetMockGitHubRepositoryClient(studentRepo);
var repoMetadataRetriever = GetMockRepositoryMetadataRetriever();
var downloader = GetSubmissionDownloader
(
repoClient,
repoMetadataRetriever
);
var result = await downloader.DownloadSubmissionsAsync
(
checkpoint,
Collections.CreateList
(
new StudentDownloadRequest(student, submitted: true)
)
);
Assert.Single(result);
Assert.Equal(student, result[0].Student);
Assert.Equal(studentRepo.Contents, result[0].Contents);
}
public async Task GradeSubmissionAsync_DefinitionMismatch_Error()
{
var question = GetCodeQuestion();
var submission = new CodeQuestionSubmission()
{
Contents = "A A B B C C"
};
var simulatedResult = new MethodJobResult()
{
Status = CodeJobStatus.Completed,
ClassCompilationResult = new CompilationResult()
{
Success = true
}
};
var expectedDefinitionErrors = Collections.CreateList <DefinitionError>
(
new MethodNameError("expectedMethod", "actualMethod"),
new MethodReturnTypeError("expectedMethod", "expectedReturnType", "actualReturnType")
);
var grader = GetCodeQuestionGrader(question, submission, simulatedResult, expectedDefinitionErrors);
var result = await grader.GradeSubmissionAsync(submission);
var codeQuestionResult = (CodeQuestionResult)result.Result;
var actualDefinitionErrors = codeQuestionResult.Errors
.Cast <DefinitionError>()
.ToList();
Assert.Equal(0.0, result.Score);
Assert.Equal(expectedDefinitionErrors, actualDefinitionErrors);
}
