public async Task Generate_ShouldReturnWithIdNotEqualZero()
{
var report = await Generator.Generate(Data, MockSnapshots.GetFirstCalculatorSnapshotName(),
Assignment, new AbstractSyntaxTreeNode("Root"));
Assert.AreNotEqual(0, report.Id);
}
public async Task Generate_ShouldReturnASucessfulReport()
{
var report = await Generator.Generate(Data, MockSnapshots.GetFirstCalculatorSnapshotName(),
Assignment, new AbstractSyntaxTreeNode("Root"));
Assert.AreEqual(SnapshotReport.SnapshotReportTypes.Success, report.Type);
}
public void Init()
{
Root = Path.Combine(MockSnapshots.GetShortRoot(), "Powershell");
Data = new SubmissionData(new StudentSubmissionDto()
{
StudentName = "StudentName",
ClassName = "ClassName",
SnapshotFolder = MockSnapshots.GetCalculatorSnapshots(),
}, Root);
Assignment = new Assignment()
{
TestProject = new TestProject()
{
Id = 1,
Files = MockSnapshots.GetCalculatorTestProjectFiles(),
TestFolder = MockSnapshots.GetCalculatorTestProjectFolder(),
TestDllFile = MockSnapshots.GetCalculatorTestProjectDll(),
TestProjectFile = MockSnapshots.GetCalculatorTestProjectFile(),
UnitTests = MockSnapshots.GetCalculatorUnitTests(),
},
TestProjectId = 1,
};
Generator = new PowershellUnitTestGenerator(
Microsoft.Extensions.Options.Options.Create(
new PowershellOptions()
{
CommandPath = MockSnapshots.PowershellScript(),
PassedValue = MockSnapshots.PowershellPassedValue(),
ResultsFile = "test_results.txt",
}));
}
public void HasSourceFile_ShouldThrowExceptionForBadSnapshotName()
{
using (var data = new SubmissionData(Submission, Root))
{
data.HasSourceFile("Random", MockSnapshots.GetCalculatorFile());
}
}
public void Create_ShouldThrowExceptionForInvalidFile()
{
Generator.CreateFromFile(Data,
Path.Combine(Data.SnapshotFolder,
MockSnapshots.GetFirstCalculatorSnapshotName(),
"Random.hpp"));
}
public async Task AddSubmissionToStudentSubmission_ShouldPassForAlreadyInCollection()
{
var snapshotSubmission = await GeneratorObj.AddSubmissionToStudentSubmission(
MockSnapshots.GetFirstCalculatorSnapshotName());
Assert.AreEqual(FirstCalculatorSubmissionId, snapshotSubmission.Id);
}
public void Init()
{
Root = Path.Combine(Directory.GetCurrentDirectory(), nameof(SnapshotReportGeneratorTests));
AbstractSyntaxTreeGenerator = new MockAbstractSyntaxTreeGenerator {
Throw = false
};
Reports = new MockRepository <SnapshotReport, int>();
Generator = new SnapshotReportGenerator(
AbstractSyntaxTreeGenerator,
new MockAbstractSyntaxTreeClassExtractor(), Reports,
new MockSnapshotMethodGenerator(),
new MockUnitTestGenerator()
);
Data = new SubmissionData(new StudentSubmissionDto()
{
ClassName = "ClassName",
StudentName = "StudentName",
SnapshotFolder = MockSnapshots.GetCalculatorSnapshots(),
}, Root);
Assignment = new Assignment()
{
Filename = MockSnapshots.GetCalculatorFile(),
Solution = new AssignmentSolution()
{
Name = MockSnapshots.GetCalculatorClassName(),
},
};
}
public void Create_ShouldReturnValidNodeForCalculatorSnapshot()
{
var node = Generator.CreateFromFile(Data,
Data.SnapshotSourceFileFullPath(MockSnapshots.GetFirstCalculatorSnapshotName(),
MockSnapshots.GetCalculatorFile()));
Assert.AreEqual(ValidNode, node.Value);
}
public void Extract_GetClassWithDefaultParameterShouldHaveHeight()
{
using (var reader = MockSnapshots.GetClassWithDefaultParameterAbstractSyntaxTreeReader())
{
var node = Extractor.Extract(reader);
Assert.AreEqual(MockSnapshots.GetClassWithDefaultParameterHeight(), node.Height);
}
}
public async Task Generate_ShouldGenerateSnapshotsForTheRemaining()
{
var expected = MockSnapshots.GetNumberOfNewSnapshotsAfterSecond();
var actual = (await Generator.Generate(Data, Assignment)).Count;
Assert.AreEqual(expected, actual);
}
public async Task AddSubmissionToStudentSubmission_ShouldReturnIdNotNull()
{
await GeneratorObj.AddSubmissionToStudentSubmission(
MockSnapshots.GetThirdCalculatorSnapshotName());
var actual = (await SnapshotSubmission.GetAll()).Count();
Assert.AreNotEqual(0, actual);
}
public async Task Generate_ShouldReturnAFailureReportForTreeGeneratorThrow()
{
AbstractSyntaxTreeGenerator.Throw = true;
var report = await Generator.Generate(Data,
MockSnapshots.GetFirstCalculatorSnapshotName(),
Assignment, new AbstractSyntaxTreeNode("Root"));
Assert.AreEqual(SnapshotReport.SnapshotReportTypes.Failure, report.Type);
}
public void Extract_ShouldFindMethod()
{
var node = Extractor.ExtractOrDefault(Root, MethodDeclaration);
var visitor = new MockClangAbstractSyntaxTreeMethodExtractorSearchVisitor(
MockSnapshots.GetCalculatorAbstractSyntaxTreeAddValue());
node.PreOrder(visitor);
Assert.IsTrue(visitor.Found);
}
public async Task Generate_ShouldAddToReports()
{
var expected = (await Reports.GetAll()).Count() + 1;
await Generator.Generate(Data, MockSnapshots.GetFirstCalculatorSnapshotName(),
Assignment, new AbstractSyntaxTreeNode("Root"));
var actual = (await Reports.GetAll()).Count();
Assert.AreEqual(expected, actual);
}
public async Task AddSubmissionToStudentSubmission_ShouldAddToStudentCollection()
{
var expected = (await SnapshotSubmission.GetAll()).Count() + 1;
await GeneratorObj.AddSubmissionToStudentSubmission(
MockSnapshots.GetThirdCalculatorSnapshotName());
var actual = (await SnapshotSubmission.GetAll()).Count();
Assert.AreEqual(expected, actual);
}
public void Extract_ShouldFindNodeWithDivLine()
{
var visitor = new MockClangAbstractSyntaxTreeClassExtractorSearchVisitor(
MockSnapshots.GetCalculatorAbstractSyntaxTreeDivValue());
var node = Extractor.Extract(Root, MockSnapshots.GetCalculatorClassName());
node.PreOrder(visitor);
Assert.IsTrue(visitor.Found);
}
public void HasSourceFile_ShouldPassForEachSnapshot()
{
using (var data = new SubmissionData(Submission, Root))
{
foreach (var folder in data.SnapshotFolderNames())
{
Assert.IsTrue(data.HasSourceFile(folder,
MockSnapshots.GetCalculatorFile()));
}
}
}
public void Init()
{
Submission = new StudentSubmissionDto()
{
StudentName = StudentName,
ClassName = ClassName,
SnapshotFolder = MockSnapshots.GetCalculatorSnapshots(),
};
Root = Path.Combine(Directory.GetCurrentDirectory(), nameof(SubmissionDataTests));
}
public async Task Generate_ShouldHaveOneFailTestForDivisionNotDeclared()
{
var methods = new CalculatorSnapshotMethods()
{
Addition = true,
Division = false,
Multiplication = true,
Subtraction = true,
}.GetMethods();
var results = await Generator.GenerateResults(Data, MockSnapshots.GetLastCalculatorSnpahostName(),
Assignment, methods);
Assert.AreEqual(1, results.Count(r => !r.Passed));
}
public async Task AddSubmissionToStudentSubmission_UnzipFilesShouldGetFile()
{
var snapshotSubmission = await GeneratorObj.AddSubmissionToStudentSubmission(
MockSnapshots.GetThirdCalculatorSnapshotName());
var files = (await SnapshotSubmission.Get(snapshotSubmission.Id)).Files;
var snapshot = "Snapshot";
EngineFileUtilities.ExtractZip(Data.Root, snapshot, files);
var path = Path.Combine(Data.Root, snapshot, MockSnapshots.GetCalculatorFile());
Assert.IsTrue(File.Exists(path));
}
public async Task Generate_ShouldReturnSameNumberOfTestsAsTestProject()
{
var methods = new CalculatorSnapshotMethods()
{
Addition = true,
Division = true,
Multiplication = true,
Subtraction = true,
}.GetMethods();
var results = await Generator.GenerateResults(Data, MockSnapshots.GetLastCalculatorSnpahostName(),
Assignment, methods);
Assert.AreEqual(Assignment.TestProject.UnitTests.Count, results.Count);
}
public void Create_ShouldThrowAndCleanupDirectoryForInvalidFile()
{
try
{
Generator.CreateFromFile(Data,
Path.Combine(Data.SnapshotFolder,
MockSnapshots.GetFirstCalculatorSnapshotName(),
"Random.hpp"));
Assert.Fail();
}
catch (EngineReportExceptionData)
{
Assert.IsFalse(Directory.Exists(Generator.GetCompilationDirectory(Data)));
}
}
public async Task Generate_ShouldReturnPassedForAllTests()
{
var methods = new CalculatorSnapshotMethods()
{
Addition = true,
Division = true,
Multiplication = true,
Subtraction = true,
}.GetMethods();
var results = await Generator.GenerateResults(Data, MockSnapshots.GetLastCalculatorSnpahostName(),
Assignment, methods);
foreach (var result in results)
{
Assert.IsTrue(result.Passed);
}
}
public void Init()
{
Root = Path.Combine(Directory.GetCurrentDirectory(), nameof(ClangAbstractSyntaxTreeGeneratorTests));
Data = new SubmissionData(new StudentSubmissionDto()
{
SnapshotFolder = MockSnapshots.GetCalculatorSnapshots(),
StudentName = "Student",
ClassName = "Class",
}, Root);
Generator = new ClangAbstractSyntaxTreeGenerator(
Microsoft.Extensions.Options.Options.Create(new ClangOptions()
{
Command = MockSnapshots.ClangCommand,
Arguments = MockSnapshots.ClangArguments,
OutputFile = MockSnapshots.ClangOutputFile,
}), new MockClangAbstractSyntaxTreeExtractor());
}
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 Init()
{
Students = new MockRepository <Student, string>(
new List <Student>()
{
new Student()
{
Id = StudentId,
Name = StudentName,
StudentCourseClasses = new List <StudentCourseClass>()
{
new StudentCourseClass()
{
Class = new CourseClass()
{
Id = ClassId,
Name = ClassName,
}
}
}
}
});
Surveys = new MockRepository <Survey, string>();
SnapshotGenerator = new MockSnapshotGenerator();
Runner = new EngineRunner(Microsoft.Extensions.Options.Options.Create(
new EngineRunnerOptions()
{
SurveyUrl = "Blank",
}), Students, Surveys,
SnapshotGenerator, new MockAssignmentGenerator(), new MockMarkovModelGenerator());
Root = Path.Combine(Directory.GetCurrentDirectory(), nameof(EngineRunnerTests));
Submission = new StudentSubmissionDto()
{
SnapshotFolder = MockSnapshots.GetCalculatorSnapshots(),
};
}
public void Init()
{
Root = MockSnapshots.GetCalculatorFullAbstractSyntaxTreeNode();
Extractor = new ClangAbstractSyntaxTreeClassExtractor(
new ClangLineSplitter());
}
public void AreSnapshotsSame_ShouldReturnFalseForDifferentSnapshot()
{
Assert.IsFalse(GeneratorObj.AreSnapshotsTheSame(
Data.SnapshotSourceFileFullPath(MockSnapshots.GetThirdCalculatorSnapshotName(),
MockSnapshots.GetCalculatorFile()), MockSnapshots.GetCalculatorFile()));
}
public void Init()
{
Root = MockSnapshots.GetCalculatorClassAbstractSyntaxTreeNode();
Extractor = new ClangAbstractSyntaxTreeMethodExtractor(new ClangLineSplitter());
MethodDeclaration = MockSnapshots.GetCalculatorAddMethodDeclaration();
}
public void Init()
{
Root = Path.Combine(Directory.GetCurrentDirectory(), nameof(SnapshotGeneratorTests));
Submission = new StudentSubmissionDto()
{
SnapshotFolder = MockSnapshots.GetCalculatorSnapshots(),
StudentName = StudentName,
ClassName = "Class",
};
Assignment = new Assignment()
{
Id = AssignmentId,
Filename = MockSnapshots.GetCalculatorFile(),
Solution = new AssignmentSolution()
{
Files = MockSnapshots.GetCalculatorSolutionFiles(),
Name = MockSnapshots.GetCalculatorClassName(),
}
};
Student =
new Student()
{
Id = StudentId,
Name = StudentName,
Submissions = new List <SnapshotSubmission>()
{
new SnapshotSubmission()
{
Id = FirstCalculatorSubmissionId,
CreatedDateTime = MockSnapshots.GetFirstCalculatorSnapshotTime(),
}
},
Snapshots = new List <Snapshot>()
{
new Snapshot()
{
Id = FirstCalculatorSubmissionId,
SnapshotSubmission = new SnapshotSubmission()
{
Id = FirstCalculatorSubmissionId,
CreatedDateTime = MockSnapshots.GetFirstCalculatorSnapshotTime(),
Files = MockSnapshots.GetFirstCalculatorSnapshotFile(),
},
AssignmentId = AssignmentId
},
new Snapshot()
{
Id = LastSnapshotId,
SnapshotSubmission = new SnapshotSubmission()
{
Id = 2,
CreatedDateTime = MockSnapshots.GetSecondCalculatorSnapshotTime(),
Files = MockSnapshots.GetSecondCalculatorSnapshotFile(),
},
AssignmentId = AssignmentId
}
}
};
Students = new MockRepository <Student, string>();
Students.Add(Student);
Snapshots = new MockRepository <Snapshot, int>();
SnapshotSubmission = new MockRepository <SnapshotSubmission, int>(
new List <SnapshotSubmission>()
{
new SnapshotSubmission()
{
Id = FirstCalculatorSubmissionId,
CreatedDateTime = MockSnapshots.GetFirstCalculatorSnapshotTime()
}
});
Generator = new SnapshotGenerator(new MockSnapshotDateConverter(), SnapshotSubmission,
Snapshots, new MockSnapshotReportGenerate(), Students,
new MockAbstractSyntaxClassTreeExtractor(),
new MockAbstractSyntaxTreeGenerator());
Data = new SubmissionData(Submission, Root)
{
Student = Student
};
GeneratorObj = new SnapshotGenerator.SnapshotGeneratorObj(Data, Assignment, Generator);
}
