public void GeneratePDFTest()
{
string templateId = "tpl_000000000000000001";
var submissionData = new SubmissionData(
test: false,
data: new {
title = "Test PDF",
description = "This PDF is great!"
},
fieldOverrides: new {
title = new {
required = false
}
}
);
var response = instance.GeneratePDF(templateId, submissionData);
Assert.IsInstanceOf <CreateSubmissionResponse> (response, "response is CreateSubmissionResponse");
Assert.AreEqual(
CreateSubmissionResponse.StatusEnum.Success,
response.Status);
var submission = response.Submission;
StringAssert.StartsWith("sub_", submission.Id);
Assert.AreEqual(false, submission.Expired);
Assert.AreEqual(
Submission.StateEnum.Pending,
submission.State);
}
public AbstractSyntaxTreeNode CreateFromFile(SubmissionData data, string path)
{
using (var handler =
new DirectoryHandler(GetCompilationDirectory(data)))
{
var process = GetEngineProcess(GetEngineProcessData(handler.Directory, path));
var exitCode = process.Run();
if (exitCode == 0)
{
process.Stop();
using (var reader = new StreamReader(GetOutputFile(handler.Directory)))
{
return(Extractor.Extract(reader));
}
}
EngineReportExceptionData exception;
using (var reader = process.StandardError)
{
exception = new EngineReportExceptionData(reader.ReadToEnd())
{
Type = "Compilation",
};
}
process.Stop();
throw exception;
}
}
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 Dispose_CheckRootFolderIsCreated()
{
using (var data = new SubmissionData(Submission, Root))
{
Assert.IsTrue(Directory.Exists(Root));
}
}
protected virtual async Task <bool> BindDataAsync(SubmissionData model, Dictionary <string, StringValues> dataToBind)
{
var formValueProvider = new FormValueProvider(BindingSource.Form, new FormCollection(dataToBind), CultureInfo.CurrentCulture);
var bindingSuccessful = await TryUpdateModelAsync(model, "", formValueProvider);
return(bindingSuccessful);
}
public void Dispose_CheckRootFolderIsRemove()
{
using (var data = new SubmissionData(Submission, Root))
{
}
Assert.IsFalse(Directory.Exists(Root));
}
public async Task <IList <Snapshot> > Generate(SubmissionData data, DevAssignment assignment)
{
var newSnapshots = new List <Snapshot>();
var generateObj = new SnapshotGeneratorObj(data, assignment, this);
var solutionNode = GetSolutionAbstractSyntaxTreeNode(data, assignment);
foreach (var snapshotName in generateObj.SnapshotNames())
{
if (generateObj.IsNewSnapshot(snapshotName))
{
var snapshotSubmission = await generateObj.AddSubmissionToStudentSubmission(snapshotName);
var snapshot = new Snapshot()
{
StudentId = generateObj.Data.Student.Id,
AssignmentId = generateObj.Assignment.Id,
SnapshotSubmission = snapshotSubmission,
Report = await ReportGenerator.Generate(generateObj.Data, snapshotName, assignment, solutionNode),
};
await Snapshots.Add(snapshot);
newSnapshots.Add(snapshot);
generateObj.LastSnapshot = snapshot;
}
}
return(newSnapshots);
}
public SnapshotGeneratorObj(SubmissionData data, DevAssignment assignment, SnapshotGenerator parent)
{
Data = data;
Assignment = assignment;
Parent = parent;
LastSnapshot = GetLastSnapshotOrDefault(data, assignment);
}
public void HasSourceFile_ShouldThrowExceptionForBadSnapshotName()
{
using (var data = new SubmissionData(Submission, Root))
{
data.HasSourceFile("Random", MockSnapshots.GetCalculatorFile());
}
}
public async Task <ICollection <UnitTestResult> > GenerateResultsImpl(SubmissionData data, string snapshot, DevAssignment assignment,
ICollection <SnapshotMethod> snapshotMethods)
{
using (var handler =
new DirectoryHandler(GetTestDirectory(data)))
{
var testProject = new TestProjectObj(handler.Directory, assignment.TestProject);
testProject.MoveFilesToProject(data.SnapshotSourceFiles(snapshot));
var preprocessorArguments = GetPreprocessorArguments(snapshotMethods);
var process = new EngineProcess(GetEngineProcessData(handler.Directory,
testProject, preprocessorArguments));
var exitCode = process.Run();
if (exitCode == 0)
{
process.Stop();
return(GetUnitTestResults(assignment.TestProject,
ResultsFile(handler.Directory)));
}
EngineReportExceptionData exception;
using (var reader = process.StandardError)
{
exception = new EngineReportExceptionData(reader.ReadToEnd())
{
Type = "Build",
};
}
process.Stop();
throw exception;
}
}
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 Arrange()
{
_fixture = new Fixture();
var collectionPeriods = new List <CollectionCalendarPeriod>()
{
new CollectionCalendarPeriod(new CollectionPeriod(1, _fixture.Create <short>()), _fixture.Create <byte>(), _fixture.Create <short>(), _fixture.Create <DateTime>(), _fixture.Create <DateTime>(), true, false),
};
var collectionCalendar = new CollectionCalendar(collectionPeriods);
_mockCollectionCalendarService = new Mock <ICollectionCalendarService>();
_mockCollectionCalendarService.Setup(m => m.Get()).ReturnsAsync(collectionCalendar);
_sutModel = _fixture.Build <ApprenticeshipIncentiveModel>().With(x => x.Status, IncentiveStatus.Active).Create();
_sutModel.PendingPaymentModels = new List <PendingPaymentModel>();
_sutModel.PendingPaymentModels.Add(_fixture.Build <PendingPaymentModel>().With(x => x.DueDate, new DateTime(2021, 1, 1)).With(x => x.ClawedBack, false).With(x => x.PaymentMadeDate, (DateTime?)null).Create());
_sutModel.PendingPaymentModels.Add(_fixture.Build <PendingPaymentModel>().With(x => x.DueDate, new DateTime(2021, 2, 28)).With(x => x.ClawedBack, false).With(x => x.PaymentMadeDate, (DateTime?)null).Create());
_sutModel.PaymentModels = new List <PaymentModel>();
_sutModel.ClawbackPaymentModels = new List <ClawbackPaymentModel>();
_sut = Sut(_sutModel);
var learningData = new LearningData(true);
learningData.SetIsStopped(new LearningStoppedStatus(true, _sutModel.PendingPaymentModels.Last().DueDate.AddDays(-1)));
var submissionData = new SubmissionData();
submissionData.SetSubmissionDate(DateTime.Now);
submissionData.SetLearningData(learningData);
_learner = Learner.New(_fixture.Create <Guid>(), _sutModel.Id, _fixture.Create <long>(), _fixture.Create <long>(), _fixture.Create <long>());
_learner.SetSubmissionData(submissionData);
}
public AbstractSyntaxTreeNode GetStudentSnapshot(SubmissionData data, string snapshot, Assignment assignment)
{
var root = AbstractSyntaxTreeGenerator.CreateFromFile(data, data.SnapshotSourceFileFullPath(snapshot, assignment.Filename));
var classNode = ClassExtractor.Extract(root, assignment.Solution.Name);
return(classNode);
}
public async Task <SnapshotReport> GenerateImpl(SubmissionData data, string snapshot, Assignment assignment,
AbstractSyntaxTreeNode solutionNode)
{
var studentNode = GetStudentSnapshot(data, snapshot, assignment);
var snapshotMethods = assignment
.Solution
.MethodDeclarations
.Select(methodDeclaration =>
MethodGenerator.Generate(studentNode, solutionNode, methodDeclaration))
.ToList();
var unitTests = await UnitTestGenerator.GenerateResults(data, snapshot,
assignment, snapshotMethods);
var report = new SnapshotSuccessReport()
{
SnapshotMethods = snapshotMethods,
UnitTestResults = unitTests,
};
await SnapshotReports.Add(report);
return(report);
}
public void Arrange()
{
_fixture = new Fixture();
_collectionYear = _fixture.Create <short>();
_collectionPeriod = new CollectionPeriod(1, _collectionYear);
_fixture.Build <PendingPaymentModel>().With(p => p.PendingPaymentValidationResultModels, new List <PendingPaymentValidationResultModel>()).Create();
_sutModel = _fixture
.Build <ApprenticeshipIncentiveModel>()
.With(a => a.PendingPaymentModels, new List <PendingPaymentModel>()
{
_fixture.Build <PendingPaymentModel>().With(p => p.PendingPaymentValidationResultModels, new List <PendingPaymentValidationResultModel>()).Create()
})
.Create();
_sutModel.Apprenticeship.SetProvider(_fixture.Create <Provider>());
_learner = Learner.New(
Guid.NewGuid(),
_sutModel.Id,
_sutModel.Apprenticeship.Id,
_sutModel.Apprenticeship.Provider.Ukprn,
_sutModel.Apprenticeship.UniqueLearnerNumber);
var submisssionData = new SubmissionData();
submisssionData.SetSubmissionDate(DateTime.Now);
_learner.SetSubmissionData(submisssionData);
_sut = Sut(_sutModel);
}
public async Task <EmailData> RunSubmission(SubmissionData data)
{
data.Student = await GetStudent(data);
data.Course = await GetCourseClass(data.Student, data);
return(await GetEmailData(data));
}
public void HasSourceFile_ShouldFailForNonFileName()
{
using (var data = new SubmissionData(Submission, Root))
{
var first = data.SnapshotFolderNames().First();
Assert.IsFalse(data.HasSourceFile(first, "Random.hpp"));
}
}
private async Task SetDcJobSucceeded(SubmissionData submission, string dcJobSucceeded)
{
var isValid = bool.TryParse(dcJobSucceeded, out var dcJobSucceededVal);
submission.JobModel.DcJobSucceeded = (isValid == false ? (bool?)null : dcJobSucceededVal);
submissionDataContext.Jobs.Update(submission.JobModel);
await submissionDataContext.SaveChangesAsync();
}
public void SnapshotFolderNames_CheckThatSnapshotExists()
{
using (var data = new SubmissionData(Submission, Root))
{
var folder = data.SnapshotFolderNames();
Assert.IsTrue(folder.Any());
}
}
public async Task Handle(RefreshLearnerCommand command, CancellationToken cancellationToken = default)
{
var incentive = await _incentiveDomainRepository.Find(command.ApprenticeshipIncentiveId);
var learner = await _learnerDomainRepository.GetOrCreate(incentive);
_logger.LogInformation("Start Learner data refresh from Learner match service for ApprenticeshipIncentiveId: {ApprenticeshipIncentiveId}, ApprenticeshipId: {ApprenticeshipId}, UKPRN: {UKPRN}, ULN: {ULN}",
learner.ApprenticeshipIncentiveId, learner.ApprenticeshipId, learner.Ukprn, learner.UniqueLearnerNumber);
SubmissionData submissionData = new SubmissionData();
var learnerData = await _learnerService.Get(learner);
_logger.LogInformation("End Learner data refresh from Learner match service for ApprenticeshipIncentiveId: {ApprenticeshipIncentiveId}, ApprenticeshipId: {ApprenticeshipId}, UKPRN: {UKPRN}, ULN: {ULN}",
learner.ApprenticeshipIncentiveId, learner.ApprenticeshipId, learner.Ukprn, learner.UniqueLearnerNumber);
if (learnerData != null)
{
if (LearnerAndEarningsHaveNotChanged(learnerData, learner, incentive))
{
return;
}
submissionData.SetSubmissionDate(learnerData.IlrSubmissionDate);
var learningFoundStatus = learnerData.LearningFound(incentive);
submissionData.SetLearningData(new LearningData(learningFoundStatus.LearningFound, learningFoundStatus.NotFoundReason));
if (learningFoundStatus.LearningFound)
{
submissionData.LearningData.SetStartDate(learnerData.LearningStartDate(incentive));
submissionData.LearningData.SetHasDataLock(learnerData.HasProviderDataLocks(incentive));
submissionData.LearningData.SetIsInLearning(learnerData.IsInLearning(incentive));
submissionData.LearningData.SetIsStopped(learnerData.IsStopped(incentive));
}
submissionData.SetRawJson(learnerData.RawJson);
}
if (submissionData.HasChangeOfCircumstances(learner.SubmissionData))
{
incentive.SetHasPossibleChangeOfCircumstances(true);
}
learner.SetSubmissionData(submissionData);
incentive.LearnerRefreshCompleted();
learner.SetLearningPeriods(learnerData.LearningPeriods(incentive));
if (!learner.SubmissionData.LearningData.LearningFound)
{
_logger.LogInformation("Matching ILR record not found for ApprenticeshipIncentiveId: {ApprenticeshipIncentiveId}, ApprenticeshipId: {ApprenticeshipId}, UKPRN: {UKPRN}, ULN: {ULN} with reason: {NotFoundReason}",
learner.ApprenticeshipIncentiveId, learner.ApprenticeshipId, learner.Ukprn, learner.UniqueLearnerNumber, learner.SubmissionData.LearningData.NotFoundReason);
}
await _learnerDomainRepository.Save(learner);
await _incentiveDomainRepository.Save(incentive);
}
public async Task GetStudent_ShouldThrowForStudentNotInRepository()
{
Submission.StudentName = "Random Student";
Submission.ClassName = ClassName;
using (var data = new SubmissionData(Submission, Root))
{
await Runner.GetStudent(data);
}
}
public void GeneratePDFWithDataRequestsTest()
{
string templateId = "tpl_000000000000000001";
var submissionData = new SubmissionData(
test: false,
data: new {
title = "Test PDF",
},
dataRequests: new List <CreateSubmissionDataRequestData> {
new CreateSubmissionDataRequestData(
name: "John Smith",
email: "*****@*****.**",
fields: new List <string> {
"description"
},
order: 1,
authType: CreateSubmissionDataRequestData.AuthTypeEnum.Emaillink
)
}
);
var response = instance.GeneratePDF(templateId, submissionData);
Assert.IsInstanceOf <CreateSubmissionResponse> (response, "response is CreateSubmissionResponse");
Assert.AreEqual(
CreateSubmissionResponse.StatusEnum.Success,
response.Status);
var submission = response.Submission;
StringAssert.StartsWith("sub_", submission.Id);
Assert.AreEqual(submission.Expired, false);
Assert.AreEqual(
submission.State,
Submission.StateEnum.Waitingfordatarequests);
var dataRequests = submission.DataRequests;
Assert.That(dataRequests, Has.Count.EqualTo(1));
var dataRequest = dataRequests.First();
Assert.IsInstanceOf <SubmissionDataRequest> (dataRequest, "dataRequest is SubmissionDataRequest");
StringAssert.StartsWith("drq_", dataRequest.Id);
Assert.AreEqual(
dataRequest.State,
SubmissionDataRequest.StateEnum.Pending);
CollectionAssert.AreEqual(
new List <string> {
"description"
},
dataRequest.Fields);
Assert.AreEqual(1, dataRequest.Order);
Assert.AreEqual("John Smith", dataRequest.Name);
Assert.AreEqual("*****@*****.**", dataRequest.Email);
}
private async Task RunImplementation(StudentSubmissionDto submission)
{
using (var data = new SubmissionData(submission,
Path.Combine(Options.RootDirectory, GetUniqueFolderName(Options.RootDirectory))))
{
var email = await Runner.RunSubmission(data);
await EmailService.Send(email);
}
}
public EmailData GetNoAssignmentsEmail(SubmissionData data)
{
return(new EmailData(data.Student)
{
Subject = $"{data.Course.Name} has no assignments",
Content = $"On {DateTime.Today.ToShortDateString()},\n" +
$"you submitted a snapshot package, however" +
$"the class \'{data.Course.Name}\' has no assignments currently.\n"
});
}
public void SetSubmissionData(SubmissionData submissionData)
{
if (submissionData == null)
{
Model.SubmissionData = new SubmissionData();
}
else
{
Model.SubmissionData = submissionData;
}
}
public void HasSourceFile_ShouldPassForEachSnapshot()
{
using (var data = new SubmissionData(Submission, Root))
{
foreach (var folder in data.SnapshotFolderNames())
{
Assert.IsTrue(data.HasSourceFile(folder,
MockSnapshots.GetCalculatorFile()));
}
}
}
protected override Task <bool> BindDataAsync(SubmissionData model, Dictionary <string, StringValues> dataToBind)
{
foreach (var item in dataToBind)
{
var propertyInfo = typeof(SubmissionData).GetProperty(item.Key);
var value = Convert.ChangeType(item.Value.ToString(), propertyInfo.PropertyType);
propertyInfo.SetValue(model, value);
}
return(Task.FromResult(true));
}
public EmailData NoSnapshotsToReport(SubmissionData data)
{
return(new EmailData(data.Student)
{
Subject = "No Survey Report",
Content = $"No snapshots to report. " +
$"Either the files haven't changed or the snapshots doesn't contain the required assignments.\n" +
$"Below is a list of assignment's files that we're looking for:\n" +
$"{data.Course.Assignments.Select(s => $"- {s.Name}, {s.Filename}").Join("\n")}\n"
});
}
public async Task <EmailData> GetEmailData(SubmissionData data)
{
switch (data.Course.Assignments.Count)
{
case 0:
return(GetNoAssignmentsEmail(data));
default:
return(await GenerateAssignments(data));
}
}
public async Task <Student> GetStudent(SubmissionData data)
{
var student = await StudentRepository.SingleOrDefault(s => s.Name.Equals(data.StudentName));
if (student == null)
{
throw new EngineExceptionData($"Student '{data.StudentName}' does not exists in the database", data);
}
return(student);
}
