public async Task Analyze_EslintBridgeClientNotInitializedResponse_FollowedByParsingError_ParsingErrorIsLogged()
{
var logger = new TestLogger();
var linterNotInitializedResponse = CreateLinterNotInitializedResponse();
var parsingErrorResponse = new AnalysisResponse
{
ParsingError = new ParsingError
{
Code = ParsingErrorCode.MISSING_TYPESCRIPT,
Line = 5,
Message = "some message"
}
};
var client = new Mock <IEslintBridgeClient>();
client
.SetupSequence(x => x.Analyze("some path", "some config", CancellationToken.None))
.ReturnsAsync(linterNotInitializedResponse)
.ReturnsAsync(parsingErrorResponse);
var testSubject = CreateTestSubject(client.Object, logger: logger);
await testSubject.Analyze("some path", "some config", CancellationToken.None);
logger.AssertPartialOutputStringExists(Resources.ERR_ParsingError_MissingTypescript);
}
private string AnalysisResponseToString(AnalysisResponse analysis)
{
var intention = analysis.Intentions?[0];
var entities = analysis.Entities;
return($"{analysis.Text}\t{intention?.Id}\t{intention?.Score:P}\t{EntitiesToString(entities?.ToList())}");
}
public async Task ExecuteAnalysis_ResponseWithIssues_ConsumerCalled()
{
var response = new AnalysisResponse
{
Issues = new List <Issue>
{
new Issue {
Message = "issue1"
},
new Issue {
Message = "issue2"
}
}
};
var convertedIssues = new[] { Mock.Of <IAnalysisIssue>(), Mock.Of <IAnalysisIssue>() };
var issueConverter = new Mock <IEslintBridgeIssueConverter>();
SetupConvertedIssue(issueConverter, "some path", response.Issues.First(), convertedIssues[0]);
SetupConvertedIssue(issueConverter, "some path", response.Issues.Last(), convertedIssues[1]);
var eslintBridgeClient = SetupEslintBridgeClient(response: response);
var consumer = new Mock <IIssueConsumer>();
var logger = new TestLogger();
var testSubject = CreateTestSubject(eslintBridgeClient.Object, issueConverter.Object, logger: logger);
await testSubject.ExecuteAnalysis("some path", consumer.Object, CancellationToken.None);
consumer.Verify(x => x.Accept("some path", convertedIssues));
}
public async Task ExecuteAnalysis_ResponseWithParsingError_IssuesIgnoredAndConsumerNotCalled()
{
var response = new AnalysisResponse
{
ParsingError = new ParsingError
{
Code = ParsingErrorCode.PARSING,
Line = 5,
Message = "some message"
},
Issues = new List <Issue>
{
new Issue {
Message = "issue1"
},
new Issue {
Message = "issue2"
}
}
};
var eslintBridgeClient = SetupEslintBridgeClient(response: response);
var consumer = new Mock <IIssueConsumer>();
var issueConverter = new Mock <IEslintBridgeIssueConverter>();
var testSubject = CreateTestSubject(eslintBridgeClient.Object, issueConverter.Object);
await testSubject.ExecuteAnalysis("some path", consumer.Object, CancellationToken.None);
issueConverter.VerifyNoOtherCalls();
consumer.VerifyNoOtherCalls();
}
public async Task Analyze_EslintBridgeClientNotInitializedResponse_FollowedByValidResponse_ConvertedIssuesReturnedAndParsingErrorNotLogged()
{
var linterNotInitializedResponse = CreateLinterNotInitializedResponse();
var validResponse = new AnalysisResponse {
Issues = new List <Issue> {
new Issue()
}
};
var logger = new TestLogger();
var client = new Mock <IEslintBridgeClient>();
client
.SetupSequence(x => x.Analyze("some path", "some config", CancellationToken.None))
.ReturnsAsync(linterNotInitializedResponse)
.ReturnsAsync(validResponse);
var convertedIssues = new[] { Mock.Of <IAnalysisIssue>() };
var issueConverter = new Mock <IEslintBridgeIssueConverter>();
SetupConvertedIssue(issueConverter, "some path", validResponse.Issues.First(), convertedIssues[0]);
var testSubject = CreateTestSubject(client.Object, issueConverter: issueConverter.Object, logger: logger);
var result = await testSubject.Analyze("some path", "some config", CancellationToken.None);
result.Should().BeEquivalentTo(convertedIssues);
logger.AssertNoOutputMessages();
client.Verify(x => x.Analyze("some path", "some config", CancellationToken.None), Times.Exactly(2));
}
public async Task Analyze_ResponseWithIssues_ReturnsConvertedIssues()
{
var response = new AnalysisResponse
{
Issues = new List <Issue>
{
new Issue {
Message = "issue1"
},
new Issue {
Message = "issue2"
}
}
};
var convertedIssues = new[] { Mock.Of <IAnalysisIssue>(), Mock.Of <IAnalysisIssue>() };
var issueConverter = new Mock <IEslintBridgeIssueConverter>();
SetupConvertedIssue(issueConverter, "some path", response.Issues.First(), convertedIssues[0]);
SetupConvertedIssue(issueConverter, "some path", response.Issues.Last(), convertedIssues[1]);
var eslintBridgeClient = SetupEslintBridgeClient(response: response);
var testSubject = CreateTestSubject(eslintBridgeClient.Object, issueConverter: issueConverter.Object);
var result = await testSubject.Analyze("some path", "some config", CancellationToken.None);
result.Should().BeEquivalentTo(convertedIssues);
}
public async Task Analyze_ResponseWithParsingError_IssuesIgnoredAndEmptyListReturned()
{
var response = new AnalysisResponse
{
ParsingError = new ParsingError
{
Code = ParsingErrorCode.PARSING,
Line = 5,
Message = "some message"
},
Issues = new List <Issue>
{
new Issue {
Message = "issue1"
},
new Issue {
Message = "issue2"
}
}
};
var eslintBridgeClient = SetupEslintBridgeClient(response: response);
var issueConverter = new Mock <IEslintBridgeIssueConverter>();
var testSubject = CreateTestSubject(eslintBridgeClient.Object, issueConverter: issueConverter.Object);
var result = await testSubject.Analyze("some path", "some config", CancellationToken.None);
issueConverter.VerifyNoOtherCalls();
result.Should().BeEmpty();
}
public JsonResult Analyze(string x1, string y1, string h1, string w1, string x2, string y2, string h2, string w2)
{
//generate Rectangles
Rectangle.Models.Rectangle rectangleBlue = new Rectangle.Models.Rectangle(Convert.ToInt32(x1), Convert.ToInt32(y1), Convert.ToInt32(Regex.Replace(h1, @"[^\d]", "")), Convert.ToInt32(Regex.Replace(w1, @"[^\d]", "")), "Blue");
Rectangle.Models.Rectangle rectangleRed = new Rectangle.Models.Rectangle(Convert.ToInt32(x2), Convert.ToInt32(y2), Convert.ToInt32(Regex.Replace(h2, @"[^\d]", "")), Convert.ToInt32(Regex.Replace(w2, @"[^\d]", "")), "Red");
//analyze rectangles
AnalysisResponse response = new AnalysisResponse(rectangleBlue, rectangleRed);
return Json(response);
}
private async Task SetupAnalysisWithParsingError(ParsingError parsingError, ILogger logger)
{
var response = new AnalysisResponse {
ParsingError = parsingError
};
var eslintBridgeClient = SetupEslintBridgeClient(response: response);
var testSubject = CreateTestSubject(eslintBridgeClient.Object, logger: logger);
await testSubject.Analyze("some path", "some config", CancellationToken.None);
}
public void When_NLPAnalyse_Input_IsPhrase_Then_AnalysePhrase()
{
//Arrange
var authKey = "key1";
var input = "This is a phrase";
var output = "outpath";
var analysisResponse = new AnalysisResponse
{
Id = Guid.NewGuid().ToString(),
Text = input
};
var blipAIClient = Substitute.For <IBlipAIClient>();
blipAIClient.AnalyseForMetrics(Arg.Any <string>()).Returns(Task.FromResult(analysisResponse));
var blipAIClientFactory = Substitute.For <IBlipClientFactory>();
blipAIClientFactory.GetInstanceForAI(Arg.Is <string>(s => s.Equals(authKey))).Returns(blipAIClient);
var fileService = Substitute.For <IFileManagerService>();
var logger = Substitute.For <IInternalLogger>();
var analyseService = new NLPAnalyseService(blipAIClientFactory, fileService, logger);
var handler = new NLPAnalyseHandler(analyseService, logger)
{
Authorization = new MyNamedParameter <string> {
Value = authKey
},
Input = new MyNamedParameter <string> {
Value = input
},
ReportOutput = new MyNamedParameter <string> {
Value = output
},
Verbose = new MySwitch {
IsSet = false
},
VeryVerbose = new MySwitch {
IsSet = false
},
DoContentCheck = new MySwitch {
IsSet = false
},
Raw = new MySwitch {
IsSet = false
},
};
//Act
var status = handler.RunAsync(null).Result;
//Assert
blipAIClient.Received(1).AnalyseForMetrics(input);
}
public async Task ExecuteAnalysis_ResponseWithNoIssues_ConsumerNotCalled()
{
var response = new AnalysisResponse();
var eslintBridgeClient = SetupEslintBridgeClient(response: response);
var consumer = new Mock <IIssueConsumer>();
var testSubject = CreateTestSubject(eslintBridgeClient.Object);
await testSubject.ExecuteAnalysis("some path", consumer.Object, CancellationToken.None);
consumer.VerifyNoOtherCalls();
}
private async Task SetupAnalysisWithParsingError(ParsingError parsingError, ILogger logger)
{
var response = new AnalysisResponse {
ParsingError = parsingError
};
var eslintBridgeClient = SetupEslintBridgeClient(response: response);
var consumer = new Mock <IIssueConsumer>();
var testSubject = CreateTestSubject(eslintBridgeClient.Object, logger: logger);
await testSubject.ExecuteAnalysis("some path", consumer.Object, CancellationToken.None);
consumer.VerifyNoOtherCalls();
}
public async Task Analyze_HasResponse_DeserializedResponse()
{
var analysisResponse = new AnalysisResponse {
Issues = new[] { new Issue {
Column = 1, EndColumn = 2
} }
};
var httpWrapper = SetupHttpWrapper(AnalyzeEndpoint, JsonConvert.SerializeObject(analysisResponse));
var testSubject = CreateTestSubject(httpWrapper.Object);
var result = await testSubject.Analyze("some path", "some config", CancellationToken.None);
result.Should().BeEquivalentTo(analysisResponse);
}
public void Analyse_Command()
{
//Arrange
var authKey = "key1";
var input = "file.txt";
var output = "result.txt";
var args = new string[] { "analyse", "-a", authKey, "-i", input, "-o", output };
var serviceProvider = Program.GetServiceCollection();
var analysisResponse = new AnalysisResponse
{
Id = Guid.NewGuid().ToString(),
Text = input,
Intentions = new List <IntentionResponse> {
new IntentionResponse {
Id = "a", Score = 0.5f
}
}.ToArray(),
Entities = new List <EntityResponse> {
new EntityResponse {
Id = "e", Value = "v"
}
}.ToArray()
};
var inputList = new List <string> {
"a", "b", "c"
};
var blipAIClient = Substitute.For <IBlipAIClient>();
blipAIClient.AnalyseForMetrics(Arg.Any <string>()).Returns(Task.FromResult(analysisResponse));
var blipAIClientFactory = Substitute.For <IBlipClientFactory>();
blipAIClientFactory.GetInstanceForAI(Arg.Is <string>(s => s.Equals(authKey))).Returns(blipAIClient);
var fileService = Substitute.For <IFileManagerService>();
fileService.IsDirectory(input).Returns(true);
fileService.IsFile(input).Returns(true);
fileService.GetInputsToAnalyseAsync(input).Returns(inputList);
serviceProvider.AddSingleton <IBlipClientFactory>(blipAIClientFactory);
serviceProvider.AddSingleton <IFileManagerService>(fileService);
Program.ServiceProvider = serviceProvider.BuildServiceProvider();
//Act
int result = Program.Main(args);
//Assert
Assert.AreEqual(result, 0);
}
public async Task Analyze_ResponseWithNoIssues_ReturnsEmptyList()
{
var response = new AnalysisResponse {
Issues = null
};
var eslintBridgeClient = SetupEslintBridgeClient(response: response);
var issueConverter = new Mock <IEslintBridgeIssueConverter>();
var testSubject = CreateTestSubject(eslintBridgeClient.Object, issueConverter: issueConverter.Object);
var result = await testSubject.Analyze("some path", "some config", CancellationToken.None);
issueConverter.VerifyNoOtherCalls();
result.Should().BeEmpty();
}
private Mock <IEslintBridgeClient> SetupEslintBridgeClient(AnalysisResponse response = null, Exception exceptionToThrow = null)
{
var eslintBridgeClient = new Mock <IEslintBridgeClient>();
var setup = eslintBridgeClient.Setup(x => x.Analyze(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <CancellationToken>()));
if (exceptionToThrow == null)
{
setup.ReturnsAsync(response);
}
else
{
setup.ThrowsAsync(exceptionToThrow);
}
return(eslintBridgeClient);
}
public async Task Analyze_EslintBridgeClientNotInitializedResponse_CallsInitLinter()
{
var validResponse = new AnalysisResponse {
Issues = new List <Issue>()
};
var linterNotInitializedResponse = CreateLinterNotInitializedResponse();
var client = new Mock <IEslintBridgeClient>();
// First analysis: response is valid, InitLinter should be called once (first initialization)
// Second analysis: response is still valid, InitLinter should not be called
// Third analysis: response is invalid, InitLinter should be called. Next response is valid, InitLinter not should be called.
// Forth analysis: because previous response succeeded, init InitLinter should not be called
client
.SetupSequence(x => x.Analyze("some path", "some config", CancellationToken.None))
.ReturnsAsync(validResponse)
.ReturnsAsync(validResponse)
.ReturnsAsync(linterNotInitializedResponse)
.ReturnsAsync(validResponse)
.ReturnsAsync(validResponse);
var activeRules = new[] { new Rule {
Key = "rule1"
}, new Rule {
Key = "rule2"
} };
var activeRulesProvider = SetupActiveRulesProvider(activeRules);
var testSubject = CreateTestSubject(client.Object, rulesProvider: activeRulesProvider.Object);
await testSubject.Analyze("some path", "some config", CancellationToken.None);
client.Verify(x => x.InitLinter(It.IsAny <IEnumerable <Rule> >(), It.IsAny <CancellationToken>()), Times.Once);
await testSubject.Analyze("some path", "some config", CancellationToken.None);
client.Verify(x => x.InitLinter(It.IsAny <IEnumerable <Rule> >(), It.IsAny <CancellationToken>()), Times.Once);
await testSubject.Analyze("some path", "some config", CancellationToken.None);
client.Verify(x => x.InitLinter(It.IsAny <IEnumerable <Rule> >(), It.IsAny <CancellationToken>()), Times.Exactly(2));
await testSubject.Analyze("some path", "some config", CancellationToken.None);
client.Verify(x => x.InitLinter(It.IsAny <IEnumerable <Rule> >(), It.IsAny <CancellationToken>()), Times.Exactly(2));
activeRulesProvider.Verify(x => x.GetActiveRulesConfiguration(), Times.Exactly(2));
}
public async Task ReceiveAsync(Message message, CancellationToken cancellationToken = default(CancellationToken))
{
if (!message.Content.ToString().ToLower().Contains("blip"))
{
await _sender.SendMessageAsync("Mensagem Padrão", message.From, cancellationToken);
return;
}
ArtificialIntelligenceExtension ia = new ArtificialIntelligenceExtension(_sender);
AnalysisResponse resposta = await ia.AnalyzeAsync(new AnalysisRequest()
{
Text = message.Content.ToString()
});
await _sender.SendMessageAsync(resposta.Intentions.First().Answer.Value, message.From, cancellationToken);
}
public IEnumerable <Rectangle> ExtractFaces()
{
if (_facesResponse == null)
{
var responseMessage = _client.PostAsync(string.Format(BaseUrl, _endpoint, FaceDetection), _content)
.Result;
var stream = responseMessage.Content.ReadAsStreamAsync().Result;
if (stream == null)
{
return(null);
}
using var reader = new StreamReader(stream, Encoding.UTF8);
var response = reader.ReadToEnd();
_facesResponse = JsonConvert.DeserializeObject <AnalysisResponse>(response, ObjectSettings);
}
return(_facesResponse?.Faces.Select(face => face.FaceRectangle.AsRectangle()));
}
public IEnumerable <Rectangle> ExtractLicensePlates()
{
if (_objectsResponse == null)
{
var responseMessage =
_client.PostAsync(string.Format(BaseUrl, _endpoint, ObjectDetection), _content).Result;
var stream = responseMessage.Content.ReadAsStreamAsync().Result;
if (stream == null)
{
return(null);
}
using var reader = new StreamReader(stream, Encoding.UTF8);
var response = reader.ReadToEnd();
_objectsResponse = JsonConvert.DeserializeObject <AnalysisResponse>(response, ObjectSettings);
}
return(_objectsResponse?.Objects
.Where(obj => obj.Object.Equals("Vehicle registration plate"))
.Select(person => person.Rectangle.AsRectangle()));
}
public async Task <IEnumerable <Rectangle> > ExtractLicensePlatesAsync()
{
if (_objectsResponse == null)
{
var responseMessage =
await _client.PostAsync(string.Format(BaseUrl, _endpoint, ObjectDetection), _content);
var stream = await responseMessage.Content.ReadAsStreamAsync();
if (stream == null)
{
return(null);
}
using var reader = new StreamReader(stream, Encoding.UTF8);
var response = await reader.ReadToEndAsync();
_objectsResponse = JsonConvert.DeserializeObject <AnalysisResponse>(response, ObjectSettings);
}
return(ExtractLicensePlates());
}
private static bool LinterNotInitializedResponse(AnalysisResponse analysisResponse)
{
return(analysisResponse.ParsingError != null &&
analysisResponse.ParsingError.Message.Contains(LinterIsNotInitializedError));
}
public void When_NLPAnalyse_Input_IsFile_Then_AnalyseFile()
{
//Arrange
var authKey = "key1";
var input = "file.txt";
var output = "outpath";
var analysisResponse = new AnalysisResponse
{
Id = Guid.NewGuid().ToString(),
Text = input,
Intentions = new List <IntentionResponse> {
new IntentionResponse {
Id = "a", Score = 0.5f
}
}.ToArray(),
Entities = new List <EntityResponse> {
new EntityResponse {
Id = "e", Value = "v"
}
}.ToArray()
};
var inputList = new List <string> {
"a", "b", "c"
};
var blipAIClient = Substitute.For <IBlipAIClient>();
blipAIClient.AnalyseForMetrics(Arg.Any <string>()).Returns(Task.FromResult(analysisResponse));
var blipAIClientFactory = Substitute.For <IBlipClientFactory>();
blipAIClientFactory.GetInstanceForAI(Arg.Is <string>(s => s.Equals(authKey))).Returns(blipAIClient);
var fileService = Substitute.For <IFileManagerService>();
fileService.IsDirectory(input).Returns(true);
fileService.IsFile(input).Returns(true);
fileService.GetInputsToAnalyseAsync(input).Returns(inputList);
var logger = Substitute.For <IInternalLogger>();
var analyseService = new NLPAnalyseService(blipAIClientFactory, fileService, logger);
var handler = new NLPAnalyseHandler(analyseService, logger)
{
Authorization = new MyNamedParameter <string> {
Value = authKey
},
Input = new MyNamedParameter <string> {
Value = input
},
ReportOutput = new MyNamedParameter <string> {
Value = output
},
Verbose = new MySwitch {
IsSet = false
},
DoContentCheck = new MySwitch {
IsSet = false
}
};
//Act
var status = handler.RunAsync(null).Result;
//Assert
foreach (var item in inputList)
{
blipAIClient.Received().AnalyseForMetrics(item);
}
blipAIClient.Received(inputList.Count).AnalyseForMetrics(Arg.Any <string>());
}
