public async Task <DomainTlsEvaluatorResults> GetDomainTlsEvaluatorResults(string domain)
{
MxEntityState mxState = await _mxApiDao.GetMxEntityState(domain);
if (mxState == null)
{
_log.LogInformation($"Domain {domain} not found - publishing DomainMissing");
await _messagePublisher.Publish(new DomainMissing(domain), _config.MicroserviceOutputSnsTopicArn);
return(null);
}
if (mxState.HostMxRecords == null)
{
return(_domainTlsEvaluatorResultsFactory.CreatePending(domain));
}
List <string> hostNames = mxState.HostMxRecords.Select(x => x.Id).ToList();
Dictionary <string, TlsEntityState> tlsEntityStates = await _mxApiDao.GetTlsEntityStates(hostNames);
DomainTlsEvaluatorResults result = _domainTlsEvaluatorResultsFactory.Create(mxState, tlsEntityStates);
return(result);
}
public async Task MissingDomainPublished()
{
A.CallTo(() => _mxApiDao.GetMxEntityState("testDomain")).Returns((MxEntityState)null);
DomainTlsEvaluatorResults result = await _mxService.GetDomainTlsEvaluatorResults("testDomain");
A.CallTo(() => _messagePublisher.Publish(A <DomainMissing> .That.Matches(x => x.Id == "testDomain"), "SnsTopicArn")).MustHaveHappenedOnceExactly();
Assert.Null(result);
}
public async Task MissingHostMxRecordsReturnPending()
{
MxEntityState mxStateFromDao = new MxEntityState("");
DomainTlsEvaluatorResults pendingEvaluatorResultFromFactory = new DomainTlsEvaluatorResults("", true);
A.CallTo(() => _mxApiDao.GetMxEntityState("testDomain")).Returns(mxStateFromDao);
A.CallTo(() => _domainTlsEvaluatorResultsFactory.CreatePending("testDomain")).Returns(pendingEvaluatorResultFromFactory);
DomainTlsEvaluatorResults result = await _mxService.GetDomainTlsEvaluatorResults("testDomain");
A.CallTo(() => _messagePublisher.Publish(A <DomainMissing> ._, A <string> ._)).MustNotHaveHappened();
Assert.AreSame(pendingEvaluatorResultFromFactory, result);
}
public async Task <IActionResult> GetDomainTlsEvaluatorResults(DomainRequest domainRequest)
{
if (!ModelState.IsValid)
{
_log.LogWarning($"Bad request: {ModelState.GetErrorString()}");
return(BadRequest(new ErrorResponse(ModelState.GetErrorString())));
}
DomainTlsEvaluatorResults result = await _mxService.GetDomainTlsEvaluatorResults(domainRequest.Domain);
return(result == null
? NotFound(new ErrorResponse($"Domain {domainRequest.Domain} does not exist in Mail Check."))
: new ObjectResult(result));
}
public async Task <IActionResult> GetDomainTlsEvaluatorResults(DomainRequest domainRequest)
{
ValidationResult validationResult = await _domainRequestValidator.ValidateAsync(domainRequest);
if (!validationResult.IsValid)
{
_log.LogWarning($"Bad request: {validationResult.GetErrorString()}");
return(BadRequest(new ErrorResponse(validationResult.GetErrorString())));
}
DomainTlsEvaluatorResults domainTlsEvaluatorResults = await _domainStatusDao.GetDomainTlsEvaluatorResults(domainRequest.Id);
if (domainTlsEvaluatorResults == null)
{
_log.LogWarning($"Antispoofing for Domain with id: { domainRequest.Id } not found");
return(NotFound(new ErrorResponse($"No domain found for ID {domainRequest.Id}.")));
}
return(new ObjectResult(domainTlsEvaluatorResults));
}
public async Task EvaluatorResultsAreReturned()
{
MxEntityState mxStateFromDao = new MxEntityState("")
{
HostMxRecords = new List <HostMxRecord> {
new HostMxRecord("testHost1", 0, null)
}
};
Dictionary <string, TlsEntityState> tlsEntityStatesFromDao = new Dictionary <string, TlsEntityState>();
DomainTlsEvaluatorResults evaluatorResultFromFactory = new DomainTlsEvaluatorResults("", false);
A.CallTo(() => _mxApiDao.GetMxEntityState("testDomain")).Returns(mxStateFromDao);
A.CallTo(() => _mxApiDao.GetTlsEntityStates(A <List <string> > ._)).Returns(tlsEntityStatesFromDao);
A.CallTo(() => _domainTlsEvaluatorResultsFactory.Create(mxStateFromDao, tlsEntityStatesFromDao)).Returns(evaluatorResultFromFactory);
DomainTlsEvaluatorResults result = await _mxService.GetDomainTlsEvaluatorResults("testDomain");
A.CallTo(() => _messagePublisher.Publish(A <DomainMissing> ._, A <string> ._)).MustNotHaveHappened();
Assert.AreSame(evaluatorResultFromFactory, result);
}
public void CaseMismatchDoesNotBreakResultsConstruction()
{
_domainTlsEvaluatorResultsFactory = new DomainTlsEvaluatorResultsFactory();
MxEntityState mxState = new MxEntityState("exampledomain.co.uk");
mxState.HostMxRecords = new List <HostMxRecord>()
{
new HostMxRecord("MAILHOST.GOOGLE.COM.", 1, new List <string> {
""
})
};
Dictionary <string, TlsEntityState> tlsEntityStates = new Dictionary <string, TlsEntityState>
{
["mailhost.google.com."] = new TlsEntityState("Mailhost.google.com")
};
DomainTlsEvaluatorResults domainTlsEvaluatorResults = _domainTlsEvaluatorResultsFactory.Create(mxState, tlsEntityStates);
Assert.AreEqual("exampledomain.co.uk", domainTlsEvaluatorResults.Id);
Assert.AreEqual(1, domainTlsEvaluatorResults.MxTlsEvaluatorResults.Count);
Assert.AreEqual("mailhost.google.com.", domainTlsEvaluatorResults.MxTlsEvaluatorResults[0].Hostname.ToLower());
}
