public async Task <ActionResult <TestsModel> > PostTestsModel(TestsModel testsModel)
{
_context.TestsModels.Add(testsModel);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetTestsModel", new { id = testsModel.Id }, testsModel));
}
public static TestsModel TranslateAsTests(this SqlDataReader reader, bool isList = false)
{
if (!isList)
{
if (!reader.HasRows)
{
return(null);
}
reader.Read();
}
var item = new TestsModel();
if (reader.IsColumnExists("Id"))
{
item.Id = SqlHelper.GetNullableInt32(reader, "Id");
}
if (reader.IsColumnExists("Title"))
{
item.Title = SqlHelper.GetNullableString(reader, "Title");
}
if (reader.IsColumnExists("Discription"))
{
item.Discription = SqlHelper.GetNullableString(reader, "Discription");
}
if (reader.IsColumnExists("CurseId"))
{
item.CurseId = SqlHelper.GetNullableInt32(reader, "CurseId");
}
return(item);
}
public async Task <IActionResult> PutTestsModel(int id, TestsModel testsModel)
{
if (id != testsModel.Id)
{
return(BadRequest());
}
_context.Entry(testsModel).State = EntityState.Modified;
try
{
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!TestsModelExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public JsonResult Post([FromBody] TestsModel item)
{
if (ModelState.IsValid)
{
_testGenerator.GenerateFile(item.FileName, item.Content, item.ProblemName);
return(Json("File generated"));
}
return(Json("Failed Response"));
}
public IActionResult EditTest(TestsModel TestsModel)
{
var fromDB = _TestDbConxextcs.TestsModels.Find(TestsModel.Id);
fromDB.isActive = TestsModel.isActive;
fromDB.Name = TestsModel.Name;
fromDB.Description = TestsModel.Description;
fromDB.Created = TestsModel.Created;
fromDB.Owner = TestsModel.Owner;
fromDB.Updated = TestsModel.Updated;
_TestDbConxextcs.SaveChanges();
return(View());
}
public IHttpActionResult Create(TestsModel test)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var newTest = new Test
{
CourseId = test.CourseId
};
this.data.Tests.Add(newTest);
this.data.SaveChanges();
test.Id = newTest.Id;
return(Ok(test));
}
private async Task <List <ProfilesAndTestModelOeModel> > GetProfileAndTestOeModelFromSearchResultsAsync
(GenericTwoListModel searchResults)
{
var profileAndTestOeDataList = new List <ProfilesAndTestModelOeModel>();
var profiles = (List <ProfileDatabaseModel>)searchResults.T1; //Liver
var ProfileTests = (List <ProfileTestsDatabaseModel>)searchResults.U1; //TBIL, DBIL, ....
return(await Task.Run(() =>
{
foreach (var profile in profiles)
{
var profileAndTestOeData = new ProfilesAndTestModelOeModel();
profileAndTestOeData.Id = profile.Id;
profileAndTestOeData.Description = profile.Description;
profileAndTestOeData.IsProfile = profile.IsProfile;
//Get Tests in profile
var testsInProfile = ProfileTests.Where((pt) =>
{
return pt.ProfileId == profile.Id;
}).ToList();
foreach (var test in testsInProfile)
{
var readyTestsInProfile = new TestsModel()
{
Id = test.TestId,
Description = test.Test,
IsReportable = test.IsReportable,
Mask = test.Mask,
ResultDataType = test.ResultDataType
};
profileAndTestOeData.TestsInProfile.Add(readyTestsInProfile);
}
profileAndTestOeDataList.Add(profileAndTestOeData);
}
return profileAndTestOeDataList;
}));
}
public FileInfo Unparse(TestsModel <TTestCase> model, FileInfo artefact)
{
if (artefact.DirectoryName != null && !Directory.Exists(artefact.DirectoryName))
{
Directory.CreateDirectory(artefact.DirectoryName);
}
using (FileStream stream = artefact.Open(FileMode.OpenOrCreate, FileAccess.Write))
{
using (StreamWriter writer = new StreamWriter(stream))
{
var serializer = JsonSerializer.Create(new JsonSerializerSettings {
Formatting = Formatting.Indented
});
serializer.Serialize(writer, model);
}
}
return(artefact);
}
public async Task <StructuralDelta <TestsModel <MSTestTestcase>, MSTestTestcase> > GetTestsDelta(TDelta programDelta, Func <MSTestTestcase, bool> filterFunction, CancellationToken token)
{
var oldTestsModel = testsModelAdapter.Parse(GetTestsStorage(programDelta.OldModel.VersionId));
if (!runConfiguration.DiscoverNewTests && oldTestsModel != null)
{
return(new StructuralDelta <TestsModel <MSTestTestcase>, MSTestTestcase>(oldTestsModel, oldTestsModel));
}
if (oldTestsModel == null)
{
oldTestsModel = new TestsModel <MSTestTestcase>
{
TestSuite = new HashSet <MSTestTestcase>(),
VersionId = programDelta.OldModel.VersionId
};
}
var parsingResult = await assembliesAdapter.Parse(programDelta.NewModel.AbsoluteSolutionPath, token);
token.ThrowIfCancellationRequested();
var sources = parsingResult.Select(x => x.AbsolutePath).Where(x => x.EndsWith(settingsProvider.TestAssembliesFilter));
var vsTestCases = await DiscoverTests(sources, token);
var newTestsModel = new TestsModel <MSTestTestcase>
{
TestSuite = new HashSet <MSTestTestcase>(vsTestCases.Select(x => vsTestCaseAdapter.Parse(x)).Where(x => !x.Ignored && filterFunction(x))),
VersionId = programDelta.NewModel.VersionId
};
testsModelAdapter.Unparse(newTestsModel, GetTestsStorage(programDelta.NewModel.VersionId));
var testsDelta = new StructuralDelta <TestsModel <MSTestTestcase>, MSTestTestcase>(oldTestsModel, newTestsModel);
testsDelta.AddedElements.AddRange(newTestsModel.TestSuite.Except(oldTestsModel.TestSuite));
testsDelta.DeletedElements.AddRange(oldTestsModel.TestSuite.Except(newTestsModel.TestSuite));
return(testsDelta);
}
private async Task <bool> GenerateInputFile(TestsModel testsModel)
{
var client = new HttpClient();
var serializedInputData = JsonConvert.SerializeObject(testsModel);
var httpContent = new StringContent(serializedInputData, Encoding.UTF8, "application/json");
var response = await client.PostAsync(_testApi, httpContent);
if (response.StatusCode == System.Net.HttpStatusCode.OK)
{
var result = await response.Content.ReadAsStringAsync();
var resultDeserialized = JsonConvert.DeserializeObject(result);
if (result.Contains("File generated"))
{
//we generated successfuly the input file. we need to generate the output file
return(true);
}
return(false);
}
return(false);
}
public IHttpActionResult Update(int id, TestsModel test)
{
if (!this.ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var existingTest = this.data.Tests
.All()
.FirstOrDefault(x => x.Id == id);
if (existingTest == null)
{
return(BadRequest("Test with id: " + id + " do not exists"));
}
existingTest.CourseId = test.CourseId;
this.data.SaveChanges();
test.Id = id;
return(Ok(test));
}
//TODO: Artefact Adapter
public Task <StructuralDelta <TestsModel <CsvFileTestcase>, CsvFileTestcase> > GetTestsDelta(TProgramDelta programDelta, Func <CsvFileTestcase, bool> filterFunction, CancellationToken token)
{
var csvFile = runConfigurationProvider.CsvTestsFile;
if (!File.Exists(csvFile))
{
throw new ArgumentException($"The CSV file '{csvFile}' does not exist!");
}
var oldTestsModel = testsModelAdapter.Parse(GetTestsStorage(programDelta.OldModel.VersionId));
if (oldTestsModel == null)
{
oldTestsModel = new TestsModel <CsvFileTestcase>
{
TestSuite = new HashSet <CsvFileTestcase>(),
VersionId = programDelta.OldModel.VersionId
};
}
TestsModel <CsvFileTestcase> newTestsModel = new TestsModel <CsvFileTestcase>
{
TestSuite = new HashSet <CsvFileTestcase>(),
VersionId = programDelta.NewModel.VersionId
};
foreach (string line in File.ReadAllLines(csvFile))
{
token.ThrowIfCancellationRequested();
string testName = line.Substring(0, line.IndexOf(';'));
string linkedClass = line.Substring(line.IndexOf(';') + 1);
var testCase = new CsvFileTestcase
{
Id = testName,
AssociatedClasses = new List <string> {
linkedClass
}
};
if (filterFunction(testCase))
{
var exisitingTest = newTestsModel.TestSuite.SingleOrDefault(x => x.Id == testCase.Id);
if (exisitingTest != null)
{
exisitingTest.AssociatedClasses.AddRange(testCase.AssociatedClasses);
}
else
{
newTestsModel.TestSuite.Add(testCase);
}
}
}
testsModelAdapter.Unparse(newTestsModel, GetTestsStorage(programDelta.NewModel.VersionId));
var testsDelta = new StructuralDelta <TestsModel <CsvFileTestcase>, CsvFileTestcase>(oldTestsModel, newTestsModel);
testsDelta.AddedElements.AddRange(newTestsModel.TestSuite.Except(oldTestsModel.TestSuite));
testsDelta.DeletedElements.AddRange(oldTestsModel.TestSuite.Except(newTestsModel.TestSuite));
return(Task.FromResult(testsDelta));
}
public Models.CorrespondenceModel GetCorrespondenceModel <TTestCase>(TModel programModel, TestsModel <TTestCase> testsModel)
where TTestCase : ITestCase
{
string testType = typeof(TTestCase).Name;
var artefact = GetFile(testType, programModel.VersionId);
var defaultModel = new Models.CorrespondenceModel
{
ProgramVersionId = Path.GetFileNameWithoutExtension(artefact.FullName),
TestType = testType
};
var model = correspondenceModelAdapter.Parse(artefact) ?? defaultModel;
return(model);
}
public async Task <IActionResult> Add([FromForm] TestsViewModel test)
{
if (ModelState.IsValid)
{
string testInputContent = string.Empty;
string testOutputContent = string.Empty;
Tuple <string, long> fileContentInput = await FileHelpers.ProcessFormFile(test.FileInput, ModelState);
Tuple <string, long> fileContentOutput = await FileHelpers.ProcessFormFile(test.FileOutput, ModelState);
testInputContent = fileContentInput.Item1;
testOutputContent = fileContentOutput.Item1;
var newTest = new Tests
{
TestNumber = test.TestNumber,
Scor = test.Scor,
FisierIn = test.FisierIn,
FisierOk = test.FisierOk,
TestId = Guid.NewGuid(),
ProblemId = test.ProblemId,
TestInput = testInputContent,
TestOutput = testOutputContent
};
//save to server the test.
var problem = _problemRepository.GetItem(newTest.ProblemId);
//first we save the .in file the the ok file
TestsModel testsInputModel = new TestsModel
{
Content = newTest.TestInput,
FileName = newTest.FisierIn,
ProblemName = problem.ProblemName
};
var inputFileGenerated = await GenerateInputFile(testsInputModel);
if (inputFileGenerated == true)
{
//generate for the .ok file
var testOkModel = new TestsModel
{
Content = newTest.TestOutput,
FileName = newTest.FisierOk,
ProblemName = problem.ProblemName
};
var outputFileGenerated = await GenerateInputFile(testOkModel);
if (outputFileGenerated == true)
{
//ok, we can save in the database
_testRepository.Create(newTest);
_testRepository.Save();
return(RedirectToAction(nameof(Index), new { id = test.ProblemId }));
}
else
{
return(View());
}
}
else
{
return(View());
}
}
return(View());
}
