public async Task <CodeAnalysisResult> Analyse(TestingCode code)
{
var tempFolder = Path.Combine(Configuration.TempFolderPath, Guid.NewGuid().ToString());
await CreateDirectoryForAnalysis(code, tempFolder);
ExecutableCode executableCode = _codeFactory.GetExecutableCode(code);
Command executionCommand = GetCompilationCommand(executableCode, tempFolder);
Command analysisCommand = ModifyCommandForAnalysis(executionCommand);
ContainerExecutionResult containerExecutionResult = await _executor.ExecuteAsync(analysisCommand);
CodeAnalysisResult codeAnalysis = new CodeAnalysisResult();
if (containerExecutionResult.Result == ExecutionResult.Success)
{
codeAnalysis = AnalyseOutput(containerExecutionResult);
}
Directory.Delete(tempFolder, true);
return(codeAnalysis);
}
protected virtual async Task CreateDirectoryForAnalysis(TestingCode code, string tempFolder)
{
Directory.CreateDirectory(tempFolder);
await File.WriteAllTextAsync(
Path.Combine(tempFolder, Configuration.FileName + code.Language.GetExtension()), code.Text);
}
private ExecutableCode GetCodeType <T>(TestingCode code) where T : ExecutableCode
{
var executableCode = _serviceProvider.GetRequiredService <T>();
_mapper.Map(code, executableCode);
return(executableCode);
}
public void SetUp()
{
_mockStack = Substitute.For <IStackTraceView>();
_mockCode = Substitute.For <ICodeView>();
_code = new TestingCode(_mockStack, _mockCode);
return;
}
public void SetUp()
{
_mockStack = Substitute.For<IStackTraceView>();
_mockCode = Substitute.For<ICodeView>();
_code = new TestingCode(_mockStack, _mockCode);
return;
}
public Task <CodeExecutionResult> ExecuteCodeAsync(TestingCode code)
{
var results = new[]
{
GetErrorResult(),
GetSuccessResult()
};
return(Task.FromResult(results[Random.Next(results.Length)]));
}
public async Task <CodeTestingResult> TestCode(TestingCode code)
{
var result = new CodeTestingResult
{
CodeAnalysisResult = await _codeAnalysisApi.AnalyzeCodeAsync(code),
Score = (byte)Random.Next(1, 100 + 1)
};
if (result.CodeAnalysisResult.IsSuccessful)
{
result.CodeExecutionResult = await _codeExecutionApi.ExecuteCodeAsync(code);
}
return(result);
}
public void SetUp()
{
Panel fakeStackControl = new Panel();
Panel fakeCodeControl = new Panel();
_mockStack = new DynamicMock(typeof(IStackTraceView));
_mockCode = new DynamicMock(typeof(ICodeView));
_mockStack.SetReturnValue("ToControl", fakeStackControl);
_mockCode.SetReturnValue("ToControl", fakeCodeControl);
_code = new TestingCode(
(IStackTraceView)_mockStack.MockInstance,
(ICodeView)_mockCode.MockInstance);
return;
}
public void SetUp()
{
Panel fakeStackControl = new Panel();
Panel fakeCodeControl = new Panel();
_mockStack = new DynamicMock(typeof(IStackTraceView));
_mockCode = new DynamicMock(typeof(ICodeView));
_mockStack.SetReturnValue("ToControl", fakeStackControl);
_mockCode.SetReturnValue("ToControl", fakeCodeControl);
_code = new TestingCode(
(IStackTraceView)_mockStack.MockInstance,
(ICodeView)_mockCode.MockInstance);
return;
}
public ExecutableCode GetExecutableCode(TestingCode code)
{
switch (code.Language)
{
case Language.Js:
return(GetCodeType <JavaScriptCode>(code));
case Language.Php:
return(GetCodeType <PhpCode>(code));
case Language.Pascal:
return(GetCodeType <PascalCode>(code));
case Language.CPlusPlus:
return(GetCodeType <CPlusPlusCode>(code));
default:
throw new ArgumentOutOfRangeException();
}
}
public CodeAnalyzer GetCodeAnalyzer(TestingCode code)
{
switch (code.Language)
{
case Language.Unspecified:
throw new ArgumentException($"Programming language is unspecified", nameof(code));
case Language.Js:
return(_serviceProvider.GetRequiredService <JavaScriptCodeAnalyzer>());
case Language.Php:
return(_serviceProvider.GetRequiredService <PhpCodeAnalyzer>());
case Language.Pascal:
return(_serviceProvider.GetRequiredService <PascalCodeAnalyzer>());
case Language.CPlusPlus:
return(_serviceProvider.GetRequiredService <CPlusPlusCodeAnalyzer>());
default:
throw new NotImplementedException("Current programming language is not supported yet");
}
}
public async Task <CodeTestingResult> GetCodeQuality(TestingCode code)
{
var codeAnalyzer = _codeAnalyzerFactory.GetCodeAnalyzer(code);
var codeAnalysisResult = await codeAnalyzer.Analyse(code);
var codeTestingResult = new CodeTestingResult
{
CodeAnalysisResult = codeAnalysisResult
};
if (!codeAnalysisResult.IsSuccessful)
{
return(codeTestingResult);
}
var executableCode = _executableCodeFactory.GetExecutableCode(code);
codeTestingResult.CodeExecutionResult = await _codeExecutor.ExecuteAsync(executableCode);
codeTestingResult.Score = GetFinalScore(codeTestingResult, code.Language);
return(codeTestingResult);
}
public async Task <CodeAnalysisResult> AnalyzeCodeAsync(TestingCode code) => await PostToApi <CodeAnalysisResult>(_codeAnalysisApiPath, code);
public async Task <CodeAnalysisResult> AnalyzeCodeAsync([FromBody] TestingCode code)
{
CodeAnalyzer codeAnalyzer = _codeAnalyzerFactory.GetCodeAnalyzer(code);
return(await codeAnalyzer.Analyse(code));
}
protected override async Task CreateDirectoryForAnalysis(TestingCode code, string tempFolder)
{
await base.CreateDirectoryForAnalysis(code, tempFolder);
Configuration.EsLintFolder.CopyFolderTo(tempFolder);
}
public Task <CodeAnalysisResult> AnalyzeCodeAsync(TestingCode code)
{
return(Task.FromResult(GetCodeAnalysisResult()));
}
public async Task <CodeExecutionResult> ExecuteCodeAsync(TestingCode code)
{
var executableCode = _codeFactory.GetExecutableCode(code);
return(await _codeExecutor.ExecuteAsync(executableCode));
}
public Task <CodeTestingResult> TestCode([FromBody] TestingCode code) => _codeQualityRater.GetCodeQuality(code);
public async Task <CodeExecutionResult> ExecuteCodeAsync(TestingCode code) => await PostToApi <CodeExecutionResult>(_codeExecutionApiPath, code);
public async Task <CodeTestingResult> TestCode(TestingCode code) => await PostToApi <CodeTestingResult>(_codeTesterApiPath, code);
