public IViewComponentResult Invoke(PreAssignment assignment)
{
switch (assignment.PreAssignmentReport.Type)
{
case HumanErrorProject.Data.Models.PreAssignmentReport.PreAssignmentReportTypes.Pending:
return(View("PreAssignmentPendingReport", assignment));
case HumanErrorProject.Data.Models.PreAssignmentReport.PreAssignmentReportTypes.Success:
return(View("PreAssignmentSuccessReport", assignment));
case HumanErrorProject.Data.Models.PreAssignmentReport.PreAssignmentReportTypes.NoFileFailure:
return(View("PreAssignmentNoFileFailureReport", assignment));
case HumanErrorProject.Data.Models.PreAssignmentReport.PreAssignmentReportTypes.CompileFailure:
return(View("PreAssignmentCompileFailureReport", assignment));
case HumanErrorProject.Data.Models.PreAssignmentReport.PreAssignmentReportTypes.BuildFailure:
return(View("PreAssignmentBuildFailureReport", assignment));
case HumanErrorProject.Data.Models.PreAssignmentReport.PreAssignmentReportTypes.NoClassFailure:
return(View("PreAssignmentNoClassFailureReport", assignment));
case HumanErrorProject.Data.Models.PreAssignmentReport.PreAssignmentReportTypes.MissingMethodsFailure:
return(View("PreAssignmentMissingMethodsFailureReport", assignment));
case HumanErrorProject.Data.Models.PreAssignmentReport.PreAssignmentReportTypes.FailTestsFailure:
return(View("PreAssignmentFailTestsFailureReport", assignment));
case HumanErrorProject.Data.Models.PreAssignmentReport.PreAssignmentReportTypes.BadTestFolder:
return(View("PreAssignmentBadTestFolderReport", assignment));
default:
throw new ArgumentOutOfRangeException();
}
}
public async Task <IActionResult> OnGetAsync()
{
Assignment = await PreAssignments.FindAsync(Id);
if (Assignment == null)
{
return(NotFound());
}
Context.Entry(Assignment).Reference(x => x.Solution).Query()
.Include(x => x.MethodDeclarations).Load();
Context.Entry(Assignment).Reference(x => x.CourseClass).Load();
Context.Entry(Assignment).Reference(x => x.TestProject).Query()
.Include(x => x.UnitTests).Load();
Context.Entry(Assignment).Reference(x => x.PreAssignmentReport).Load();
switch (Assignment.PreAssignmentReport.Type)
{
case PreAssignmentReport.PreAssignmentReportTypes.FailTestsFailure:
Context.Entry((PreAssignmentFailTestsFailureReport)Assignment.PreAssignmentReport)
.Collection(x => x.FailUnitTests).Load();
break;
case PreAssignmentReport.PreAssignmentReportTypes.MissingMethodsFailure:
Context.Entry((PreAssignmentMissingMethodsFailureReport)Assignment.PreAssignmentReport)
.Collection(x => x.MissingMethodDeclarations).Load();
break;
}
return(Page());
}
private void LogException(Exception exception, PreAssignment assignment)
{
Logger.Log($"Class: '{assignment.CourseClass.Name}'\r\n" +
$"Assignment: '{assignment.Name}'\r\n" +
$"Timestamp: {DateTime.Now}\r\n" +
$"Engine Message - \r\n{exception.Message}\r\n");
}
private async Task RunImplementation(PreAssignment assignment)
{
using (var handler = new DirectoryHandler(
Path.Combine(Options.RootDirectory, GetUniqueFolderName(Options.RootDirectory))))
{
await Runner.RunPreAssignment(assignment, handler);
}
}
public async Task RunPreAssignment(PreAssignment assignment)
{
try
{
await RunImplementation(assignment);
}
catch (Exception exception)
{
LogException(exception, assignment);
}
}
public async Task <IActionResult> OnGetAsync()
{
Assignment = await PreAssignments.FindAsync(Id);
if (Assignment == null)
{
return(NotFound());
}
return(Page());
}
public async Task Generate(PreAssignment assignment, DirectoryHandler handler)
{
try
{
await GenerateImplementation(assignment, handler);
}
catch (EngineAssignmentExceptionData exceptionReport)
{
assignment.PreAssignmentReport = exceptionReport.Report;
await PreAssignmentRepository.Update(assignment);
}
}
public async Task Delete(PreAssignment preAssignment)
{
var testProjectId = preAssignment.TestProjectId;
var solutionId = preAssignment.AssignmentSolutionId;
var reportId = preAssignment.PreAssignmentReportId;
Context.PreAssignments.Remove(preAssignment);
await Context.SaveChangesAsync();
await Delete(await Context.TestProjects.FindAsync(testProjectId));
await Delete(await Context.AssignmentSolutions.FindAsync(solutionId));
await Delete(await Context.PreAssignmentReports.FindAsync(reportId));
}
public AbstractSyntaxTreeNode GetClassAbstractSyntaxTreeNode(PreAssignment assignment,
AbstractSyntaxTreeNode root)
{
try
{
return(AbstractSyntaxTreeClassExtractor.Extract(root, assignment.Solution.Name));
}
catch (EngineReportExceptionData)
{
throw new EngineAssignmentExceptionData()
{
Report = new PreAssignmentNoClassFailureReport()
};
}
}
public async Task <IActionResult> OnPostAsync()
{
Assignment = await PreAssignments.FindAsync(Id);
if (Assignment == null)
{
return(NotFound());
}
var courseId = Assignment.CourseClassId;
await DeleteHelper.Delete(Assignment);
return(RedirectToPage("/CourseClasses/Details", new { id = courseId }));
}
public async Task GenerateImplementation(PreAssignment assignment, DirectoryHandler handler)
{
var solutionRoot = EngineFileUtilities.ExtractZip(handler.Directory, "Solution",
assignment.Solution.Files);
var solution = AbstractSyntaxTreeGenerator.CreateFromFile(handler, Path.Combine(solutionRoot, assignment.Filename));
var solutionClass = GetClassAbstractSyntaxTreeNode(assignment, solution);
ValidateMethodDeclarations(assignment, solutionClass);
var unitTests = await UnitTestGenerator.GenerateResults(assignment, handler, solutionRoot);
assignment.TestProject.UnitTests = unitTests;
assignment.PreAssignmentReport = new PreAssignmentSucessReport();
await PreAssignmentRepository.Update(assignment);
}
public async Task <ICollection <UnitTest> > GenerateResults(PreAssignment assignment, DirectoryHandler handler, string root)
{
using (var testHandler = new DirectoryHandler(GetTestDirectory(handler.Directory)))
{
var testProject = new TestProjectObj(testHandler.Directory, assignment.TestProject);
if (!Directory.Exists(testProject.TestFolder))
{
throw new EngineAssignmentExceptionData()
{
Report = new PreAssignmentBadTestFolderReport()
}
}
;
testProject.MoveFilesToProject(root);
var preprocessorArguments = GetPreprocessorArguments(assignment.Solution.MethodDeclarations);
var process = new EngineProcess(GetEngineProcessData(testHandler.Directory,
testProject, preprocessorArguments));
var exitCode = process.Run();
if (exitCode == 0)
{
process.Stop();
return(GetUnitTestResults(ResultsFile(testHandler.Directory)));
}
EngineAssignmentExceptionData exception;
using (var reader = process.StandardError)
{
exception = new EngineAssignmentExceptionData()
{
Report = new PreAssignmentBuildFailureReport()
{
Report = reader.ReadToEnd(),
}
};
}
process.Stop();
throw exception;
}
}
public async Task <IActionResult> OnPostAsync()
{
Assignment = await PreAssignments.FindAsync(Id);
if (Assignment == null)
{
return(NotFound());
}
Context.Entry(Assignment).Reference(x => x.PreAssignmentReport).Load();
if (Assignment.PreAssignmentReport.Type == PreAssignmentReport.PreAssignmentReportTypes.Success)
{
Context.Entry(Assignment).Reference(x => x.Solution).Query()
.Include(x => x.MethodDeclarations).Load();
Context.Entry(Assignment).Reference(x => x.CourseClass).Query().Load();
Context.Entry(Assignment).Reference(x => x.TestProject).Query()
.Include(x => x.UnitTests).Load();
var assignment = new Assignment()
{
CourseClass = Assignment.CourseClass,
Filename = Assignment.Filename,
Name = Assignment.Name,
Solution = Assignment.Solution,
TestProject = Assignment.TestProject,
};
Assignments.Add(assignment);
PreAssignments.Remove(Assignment);
await Context.SaveChangesAsync();
return(RedirectToPage("/Assignments/Details", new { assignment.Id }));
}
else
{
Assignment.PreAssignmentReport = new PreAssignmentPendingReport();
PreAssignments.Update(Assignment);
await Context.SaveChangesAsync();
BackgroundJob.Enqueue(() => EngineService.RunPreAssignment(Id));
}
return(RedirectToPage(new { Id }));
}
public Task <ICollection <UnitTest> > GenerateResults(PreAssignment assignment, DirectoryHandler hander, string root)
{
switch (Type)
{
case PreAssignmentReport.PreAssignmentReportTypes.BuildFailure:
throw new EngineAssignmentExceptionData()
{
Report = new PreAssignmentBuildFailureReport()
};
case PreAssignmentReport.PreAssignmentReportTypes.FailTestsFailure:
throw new EngineAssignmentExceptionData()
{
Report = new PreAssignmentFailTestsFailureReport()
};
}
return(Task.FromResult <ICollection <UnitTest> >(assignment.Solution.MethodDeclarations.Select(m => new UnitTest()).ToList()));
}
public void Init()
{
Root = Path.Combine(Directory.GetCurrentDirectory(), nameof(AssignmentGeneratorTests));
Handler = new DirectoryHandler(Root);
PreAssignmentRepository = new MockRepository <PreAssignment, int>();
Assignment = new PreAssignment()
{
PreAssignmentReport = new PreAssignmentPendingReport(),
Filename = MockSnapshots.GetCalculatorFile(),
Solution = new AssignmentSolution()
{
Id = 1,
Name = MockSnapshots.GetCalculatorClassName(),
Files = MockSnapshots.GetCalculatorSolutionFiles(),
MethodDeclarations = MockSnapshots.GetCalculatorMethodDeclaration().ToList(),
},
AssignmentSolutionId = 1,
TestProject = new TestProject()
{
Files = MockSnapshots.GetCalculatorTestProjectFiles(),
TestFolder = MockSnapshots.GetCalculatorTestProjectFolder(),
TestDllFile = MockSnapshots.GetCalculatorTestProjectDll(),
TestProjectFile = MockSnapshots.GetCalculatorTestProjectFile()
}
};
PreAssignmentRepository.Add(Assignment);
AbstractSyntaxTreeGenerator = new MockAbstractSyntaxTreeGenerator();
AbstractSyntaxTreeClassExtractor = new MockAbstractSyntaxTreeClassExtractor();
AbstractSyntaxTreeMethodExtractor = new MockAbstractSyntaxTreeMethodExtractor();
UnitTestGenerator = new MockUnitTestGenerator();
Generator = new AssignmentGenerator(PreAssignmentRepository,
AbstractSyntaxTreeGenerator,
AbstractSyntaxTreeClassExtractor,
AbstractSyntaxTreeMethodExtractor,
UnitTestGenerator
);
}
public void ValidateMethodDeclarations(PreAssignment assignment, AbstractSyntaxTreeNode root)
{
var undeclaredMethods = new List <MethodDeclaration>();
foreach (var method in assignment.Solution.MethodDeclarations)
{
var methodNode = AbstractSyntaxTreeMethodExtractor.ExtractOrDefault(root, method);
if (methodNode == null)
{
undeclaredMethods.Add(method);
}
}
if (undeclaredMethods.Any())
{
throw new EngineAssignmentExceptionData()
{
Report = new PreAssignmentMissingMethodsFailureReport()
{
MissingMethodDeclarations = undeclaredMethods
}
};
}
}
public async Task RunPreAssignment(PreAssignment assignment, DirectoryHandler directory)
{
await AssignmentGenerator.Generate(assignment, directory);
}
public Task Generate(PreAssignment assignment, DirectoryHandler handler)
{
return(Task.CompletedTask);
}
public Task <ICollection <UnitTest> > GenerateResults(PreAssignment assignment, DirectoryHandler handler, string root)
{
throw new System.NotImplementedException();
}
