public async Task MxTermErroredIfARecordLookUpFails()
{
string host1 = "host1";
A.CallTo(() => _dnsClient.GetMxRecords(A<string>._))
.Returns(Task.FromResult(new DnsResult<List<string>>
(new List<string> { host1 }, 200)));
A.CallTo(() => _dnsClient.GetARecords(A<string>._))
.ReturnsNextFromSequence(
Task.FromResult(new DnsResult<List<string>>("Error")));
Mx mx = new Mx("", Qualifier.Pass, new DomainSpec(""), new DualCidrBlock(new Ip4CidrBlock(32), new Ip6CidrBlock(128)));
SpfRecords spfRecords = await _spfMxTermExpander.Process("", mx);
Assert.That(spfRecords, Is.Null);
Assert.That(mx.MxHosts.Count, Is.EqualTo(1));
Assert.That(mx.MxHosts[0].Host, Is.EqualTo(host1));
Assert.That(mx.MxHosts[0].Ip4S, Is.Empty);
Assert.That(mx.AllErrors.Count, Is.EqualTo(1));
Assert.AreEqual("Failed A record query for host1 with error Error", mx.AllErrors[0].Message);
}
public async Task Process(SpfRecords root, params Func <SpfRecords, Task>[] jobs)
{
Stack <SpfRecords> spfRecordsStack = new Stack <SpfRecords>(new[] { root });
do
{
SpfRecords spfRecords = spfRecordsStack.Pop();
foreach (Func <SpfRecords, Task> job in jobs)
{
await job(spfRecords);
}
foreach (SpfRecord spfRecord in spfRecords.Records)
{
foreach (Term term in spfRecord.Terms)
{
if (term is Include include)
{
if (include.Records != null)
{
spfRecordsStack.Push(include.Records);
}
}
else if (term is Redirect redirect)
{
if (redirect.Records != null)
{
spfRecordsStack.Push(redirect.Records);
}
}
}
}
} while (spfRecordsStack.Count > 0);
}
public async Task NonFailAllTermEvaluated()
{
await PurgeAmazonSqsQueue(OutputQueueUrl);
List <Term> terms = new List <Term>
{
new All(Qualifier.Neutral, "?All", true, false)
};
SpfRecords spfRecords = CreateSpfRecords(terms, isRoot: true);
SpfRecordsPolled spfRecordsPolled = new SpfRecordsPolled(Id, spfRecords, 1, TimeSpan.FromSeconds(0),
new List <Contracts.SharedDomain.Message>());
InvokeLambda(spfRecordsPolled);
Message message = await ReadAmazonSqsEvent(OutputQueueUrl, ReadTimeoutSecond);
Assert.That(message, Is.Not.Null);
Assert.That(message, Is.TypeOf <SpfRecordsEvaluated>());
SpfRecordsEvaluated spfRecordsEvaluated = (SpfRecordsEvaluated)message;
Assert.That(spfRecordsEvaluated.Records.Records.Count, Is.EqualTo(1));
Assert.That(spfRecordsEvaluated.Records.Records[0].Messages.Count, Is.EqualTo(1));
StringAssert.StartsWith("Only \"-all\" (do not allow other ip addresses) or \"~all\" (allow but mark other ip addresses) protect", spfRecordsEvaluated.Records.Records[0].Messages[0].Text);
}
public async Task Process(SpfRecords spfRecords)
{
async Task EvaluationAdaptor(SpfRecords records)
{
foreach (SpfRecord spfRecord in records.Records)
{
EvaluationResult <SpfRecord> evaluationResult = await _evaluator.Evaluate(spfRecord);
spfRecord.Messages.AddRange(evaluationResult.Errors);
}
}
Task ExplanationAdaptor(SpfRecords records)
{
foreach (SpfRecord spfRecord in records.Records)
{
_recordExplainer.Explain(spfRecord);
}
return(Task.CompletedTask);
}
await _spfRecordsJobsProcessor.Process(spfRecords,
EvaluationAdaptor,
ExplanationAdaptor);
}
private async Task <List <SpfRecord> > Process(SpfRecords spfRecordRoot)
{
List <SpfRecord> allSpfRecords = new List <SpfRecord>();
Task AddToList(SpfRecords records)
{
if (records != null)
{
foreach (SpfRecord spfRecord in records.Records)
{
if (!spfRecordRoot.Records.Contains(spfRecord))
{
allSpfRecords.Add(spfRecord);
}
}
}
return(Task.CompletedTask);
}
SpfRecordsDepthFirstJobProcessor processor = new SpfRecordsDepthFirstJobProcessor();
await processor.Process(spfRecordRoot, AddToList);
return(allSpfRecords);
}
public async Task TermsExplained()
{
await PurgeAmazonSqsQueue(OutputQueueUrl);
List <Term> terms = new List <Term>
{
new All(Qualifier.Fail, "-All", true, false)
};
SpfRecords spfRecords = CreateSpfRecords(terms);
SpfRecordsPolled spfRecordsPolled = new SpfRecordsPolled(Id, spfRecords, 1, TimeSpan.FromSeconds(0),
new List <Contracts.SharedDomain.Message>());
InvokeLambda(spfRecordsPolled);
Message message = await ReadAmazonSqsEvent(OutputQueueUrl, ReadTimeoutSecond);
Assert.That(message, Is.Not.Null);
Assert.That(message, Is.TypeOf <SpfRecordsEvaluated>());
SpfRecordsEvaluated spfRecordsEvaluated = (SpfRecordsEvaluated)message;
Assert.That(spfRecordsEvaluated.Records.Records.Count, Is.EqualTo(1));
Assert.That(spfRecordsEvaluated.Records.Records[0].Terms.Count, Is.EqualTo(1));
StringAssert.StartsWith("Do not allow any (other) ip addresses.", spfRecordsEvaluated.Records.Records[0].Terms[0].Explanation);
}
public async Task RunsAllJobs()
{
SpfRecordsDepthFirstJobProcessor processor = new SpfRecordsDepthFirstJobProcessor();
SpfRecords spfRecords = CreateSpfRecords();
List <string> spfs = new List <string>();
Task GetSpfRecord(SpfRecords spfRecds)
{
foreach (SpfRecord spfRecord in spfRecds.Records)
{
spfs.Add(spfRecord.Record);
}
return(Task.CompletedTask);
}
await processor.Process(spfRecords, GetSpfRecord, GetSpfRecord);
Assert.That(spfs.Count, Is.EqualTo(6));
Assert.That(spfs[0], Is.EqualTo("one"));
Assert.That(spfs[1], Is.EqualTo("one"));
Assert.That(spfs[2], Is.EqualTo("two"));
Assert.That(spfs[3], Is.EqualTo("two"));
Assert.That(spfs[4], Is.EqualTo("three"));
Assert.That(spfs[5], Is.EqualTo("three"));
}
public async Task <SpfPollResult> Process(string domain)
{
Stopwatch stopwatch = Stopwatch.StartNew();
DnsResult <List <List <string> > > spfDnsRecords = await _dnsClient.GetSpfRecords(domain);
if (!_config.AllowNullResults && (spfDnsRecords.IsErrored ||
spfDnsRecords.Value.Count == 0 ||
spfDnsRecords.Value.TrueForAll(x =>
x.TrueForAll(string.IsNullOrWhiteSpace))))
{
throw new SpfPollerException($"Unable to retrieve spf records for {domain}.");
}
if (spfDnsRecords.IsErrored)
{
string message = string.Format(SpfProcessorResource.FailedSpfRecordQueryErrorMessage, domain, spfDnsRecords.Error);
string markdown = string.Format(SpfProcessorMarkdownResource.FailedSpfRecordQueryErrorMessage, domain, spfDnsRecords.Error);
Guid id = Guid.Parse("76390C8C-12D5-47FF-981E-D880D2B77216");
return(new SpfPollResult(new Error(id, ErrorType.Error, message, markdown)));
}
SpfRecords root = await _spfRecordsParser.Parse(domain, spfDnsRecords.Value, spfDnsRecords.MessageSize);
int lookupCount = await _spfRecordExpander.ExpandSpfRecords(domain, root);
SpfPollResult pollResult = new SpfPollResult(root, lookupCount, stopwatch.Elapsed);
EvaluationResult <SpfPollResult> errors = await _pollResultRulesEvaluator.Evaluate(pollResult);
pollResult.Errors.AddRange(errors.Errors);
return(pollResult);
}
public void SpfRecordsWithSameMessageIdAndDifferentMessageTypeDoesNotRaiseANotificationTest()
{
Guid id = Guid.NewGuid();
SpfRecords spfRecords =
NotifierTestUtil.CreateSpfRecords(messages: new List <Message>
{
new Message(id, "SPF", MessageType.warning, "hello", "markdown")
});
SpfEntityState state =
new SpfEntityState(Id, 1, SpfState.Evaluated, DateTime.Now)
{
SpfRecords =
NotifierTestUtil.CreateSpfRecords(messages: new List <Message>
{
new Message(id, "SPF", MessageType.error, "world", "markdown")
})
};
SpfRecordsEvaluated message = new SpfRecordsEvaluated(Id, spfRecords, 1, TimeSpan.MinValue, new List <Message>(), DateTime.UtcNow);
_changeNotifier.Handle(state, message);
NotifierTestUtil.VerifyResults(_dispatcher, removed: false, added: false);
FakeItEasy.A.CallTo(() => _dispatcher.Dispatch(A <SpfAdvisoryAdded> ._, A <string> ._))
.MustNotHaveHappened();
FakeItEasy.A.CallTo(() => _dispatcher.Dispatch(A <SpfAdvisoryRemoved> ._, A <string> ._))
.MustNotHaveHappened();
}
private static SpfRecords CreateSpfRecords()
{
SpfRecords spfRecords = new SpfRecords(new List <SpfRecord>
{
new SpfRecord(new List <string> {
"one"
}, new Version(string.Empty, true), new List <Term>
{
new Include(Qualifier.Pass, string.Empty, string.Empty, new SpfRecords(new List <SpfRecord>
{
new SpfRecord(new List <string> {
"two"
}, new Version(string.Empty, true), new List <Term>
{
new Include(Qualifier.Pass, string.Empty, string.Empty, new SpfRecords(new List <SpfRecord>
{
new SpfRecord(new List <string> {
"three"
}, new Version(string.Empty, true), new List <Term>(),
new List <Message>(), false)
}, 0, new List <Message>()), true)
}, new List <Message>(), false)
}, 0, new List <Message>()), true)
}, new List <Message>(), true)
}, 0, new List <Message>());
return(spfRecords);
}
public async Task <int> ExpandSpfRecords(string domain, SpfRecords root)
{
Stack <SpfRecords> spfRecordsStack = new Stack <SpfRecords>(new[] { root });
int lookupCount = 0;
do
{
SpfRecords spfRecords = spfRecordsStack.Pop();
foreach (SpfRecord spfRecord in spfRecords.Records)
{
foreach (Term term in spfRecord.Terms)
{
if (_strategies.Value.TryGetValue(term.GetType(), out ISpfTermExpanderStrategy spfTermExpanderStrategy))
{
SpfRecords records = await spfTermExpanderStrategy.Process(domain, term);
if (records != null)
{
spfRecordsStack.Push(records);
}
lookupCount++;
}
}
}
} while (spfRecordsStack.Count > 0 && lookupCount < _config.MaxDnsQueryCount);
return(lookupCount);
}
public void NullTermsDoesntErrorGetMessagesOut()
{
Message rootMessage = CreateInfoMessage();
Message recordsMessage = CreateInfoMessage();
Message spfRecordWithIncludeMessage = CreateInfoMessage();
SpfRecord spfRecordWithInclude = new SpfRecord(null, null, new List <Term> {
null
}, new List <Message> {
spfRecordWithIncludeMessage
}, false);
SpfRecords rootSpfRecords = new SpfRecords(new List <SpfRecord> {
spfRecordWithInclude
}, 100, new List <Message> {
recordsMessage
});
SpfRecordsEvaluated message = new SpfRecordsEvaluated("test.gov.uk", rootSpfRecords, null, null, new List <Message> {
rootMessage
}, DateTime.UtcNow);
A.CallTo(() => _domainStatusEvaluator.GetStatus(A <List <Message> > .That.Matches(x => x.Contains(rootMessage) && x.Contains(recordsMessage) && x.Contains(spfRecordWithIncludeMessage)))).Returns(Status.Error);
_domainStatusPublisher.Publish(message);
Expression <Func <DomainStatusEvaluation, bool> > predicate = x =>
x.Status == Status.Error &&
x.RecordType == "SPF" &&
x.Id == "test.gov.uk";
A.CallTo(() => _dispatcher.Dispatch(A <DomainStatusEvaluation> .That.Matches(predicate), "testSnsTopicArn")).MustHaveHappenedOnceExactly();
}
public async Task ExpandsUntilLimitMet()
{
A.CallTo(() => _spfPollerConfig.MaxDnsQueryCount).Returns(2);
A.CallTo(() => _spfTermExpanderStrategy.TermType).Returns(typeof(Include));
SpfRecords spfRecords1 = new SpfRecords(new List <SpfRecord>
{
new SpfRecord(new List <string>(), new Version(string.Empty), new List <Term> {
new Include(string.Empty, Qualifier.Pass, new DomainSpec(string.Empty))
})
}, 200);
SpfRecords spfRecords2 = new SpfRecords(new List <SpfRecord>
{
new SpfRecord(new List <string>(), new Version(string.Empty), new List <Term>())
}, 200);
A.CallTo(() => _spfTermExpanderStrategy.Process(A <string> ._, A <Term> ._)).ReturnsNextFromSequence(
spfRecords1,
spfRecords1,
spfRecords2
);
int count = await _spfRecordExpander.ExpandSpfRecords(string.Empty, spfRecords1);
Assert.That(count, Is.EqualTo(2));
}
public SpfInfoResponse(string id, SpfState spfState, SpfRecords spfRecords = null, List <Message> messages = null, DateTime?lastUpdated = null)
{
Id = id;
Status = spfState;
SpfRecords = spfRecords;
Messages = messages;
LastUpdated = lastUpdated;
}
public async Task SpfRecordsEvaluatedAndRecordsChangedEventsRaisedAndStateUpdated()
{
await PurgeAmazonSqsQueue(OutputQueueUrl);
await TruncateDatabase(ConnectionString);
SpfRecords spfRecords = CreateSpfRecords();
SpfEntityState spfEntityState = new SpfEntityState(Id, 1, SpfState.PollPending, DateTime.Now)
{
SpfRecords = spfRecords,
DnsQueryCount = 1,
ElapsedQueryTime = TimeSpan.FromSeconds(1),
Messages = new List <Contracts.SharedDomain.Message>(),
};
await SetState(ConnectionString, spfEntityState);
spfRecords.Records[0].Messages
.Add(new Contracts.SharedDomain.Message(Guid.Empty, MessageSources.SpfEvaluator, MessageType.error,
"EvaluationError", "markdown"));
spfRecords.Records[0].Terms[0].Explanation = "Explanation";
SpfRecordsEvaluated spfRecordsEvaluated = new SpfRecordsEvaluated(Id, spfRecords, 1,
TimeSpan.FromSeconds(0), new List <Contracts.SharedDomain.Message>(), DateTime.UtcNow);
InvokeLambda(spfRecordsEvaluated);
Message message = await ReadAmazonSqsEvent(OutputQueueUrl, ReadTimeoutSecond);
Assert.That(message, Is.TypeOf <SpfRecordEvaluationsChanged>());
SpfRecordEvaluationsChanged spfRecordEvaluationsChanged = message as SpfRecordEvaluationsChanged;
Assert.That(spfRecordEvaluationsChanged.Records.Records[0].Messages.Count, Is.EqualTo(1));
Assert.That(spfRecordEvaluationsChanged.Records.Records[0].Messages[0].Text,
Is.EqualTo(spfRecords.Records[0].Messages[0].Text));
Assert.That(spfRecordEvaluationsChanged.Records.Records[0].Terms[0].Explanation,
Is.EqualTo(spfRecords.Records[0].Terms[0].Explanation));
List <SpfEntityState> spfEntityStates = await GetStates(ConnectionString);
Assert.That(spfEntityStates.Count, Is.EqualTo(1));
Assert.That(spfEntityStates[0].Id, Is.EqualTo(Id));
Assert.That(spfEntityStates[0].Version, Is.EqualTo(2));
Assert.That(spfEntityStates[0].SpfRecords.Records[0].Messages.Count, Is.EqualTo(1));
Assert.That(spfEntityStates[0].SpfRecords.Records[0].Messages[0].Text,
Is.EqualTo(spfRecordsEvaluated.Records.Records[0].Messages[0].Text));
Assert.That(spfEntityStates[0].SpfRecords.Records[0].Terms[0].Explanation,
Is.EqualTo(spfRecordsEvaluated.Records.Records[0].Terms[0].Explanation));
}
private static SpfRecords CreateSpfRecords(List <Term> terms, bool isRoot = false)
{
SpfRecords spfRecords = new SpfRecords(new List <SpfRecord>
{
new SpfRecord(new List <string> {
"one"
}, new Contracts.SharedDomain.Version(string.Empty, true), terms, new List <Contracts.SharedDomain.Message>(), isRoot)
}, 0, new List <Contracts.SharedDomain.Message>());
return(spfRecords);
}
public SpfRecordsPolled(string id,
SpfRecords records,
int?dnsQueryCount,
TimeSpan?elapsedQueryTime,
List <Message> messages = null)
: base(id)
{
Records = records;
DnsQueryCount = dnsQueryCount;
ElapsedQueryTime = elapsedQueryTime;
Messages = messages ?? new List <Message>();
}
public Evnt UpdateSpfEvaluation(SpfRecords spfRecords, int?dnsQueryCount, TimeSpan?elapsedQueryTime,
List <Message> messages, DateTime lastUpdated)
{
SpfRecords = spfRecords;
DnsQueryCount = dnsQueryCount;
ElapsedQueryTime = elapsedQueryTime;
LastUpdated = lastUpdated;
Messages = messages;
LastUpdated = lastUpdated;
SpfState = SpfState.Evaluated;
return(new SpfRecordEvaluationsChanged(Id, spfRecords));
}
public async Task <SpfRecords> Parse(string domain, List <List <string> > spfRecordsStrings, int messageSize)
{
SpfRecord[] records = await Task.WhenAll(spfRecordsStrings.Select(_ => _spfRecordParser.Parse(domain, _)));
SpfRecords spfRecords = new SpfRecords(records.Where(_ => _ != null).ToList(), messageSize);
EvaluationResult <DomainSpfRecords> results =
await _spfRecordsRulesEvaluator.Evaluate(new DomainSpfRecords(domain, spfRecords));
spfRecords.AddErrors(results.Errors);
return(spfRecords);
}
public SpfRecordsEvaluated(string id,
SpfRecords records,
int?dnsQueryCount,
TimeSpan?elapsedQueryTime,
List <Message> messages,
DateTime lastUpdated)
: base(id)
{
Records = records;
DnsQueryCount = dnsQueryCount;
ElapsedQueryTime = elapsedQueryTime;
Messages = messages;
LastUpdated = lastUpdated;
}
public async Task HandleSpfRecordsEvaluatedAndNewEvaluationUpdatesStateAndPublishes()
{
A.CallTo(() => _spfEntityDao.Get(Id)).Returns(new SpfEntityState(Id, 2, SpfState.PollPending, DateTime.Now)
{
LastUpdated = DateTime.Now.AddDays(-1),
SpfRecords = CreateSpfRecords()
});
List <Term> terms =
new List <Term>
{
new Redirect("spf1", "abc.com",
CreateSpfRecords(new List <Message> {
new Message(Guid.Empty, "SPF", MessageType.info, "hello", "markdown")
}),
false),
};
SpfRecords spfRecords = CreateSpfRecords(terms: terms,
messages: new List <Message> {
new Message(Guid.Empty, "SPF", MessageType.info, "hello", "markdown")
});
spfRecords.Records[0].Messages
.Add(new Message(Guid.Empty, MessageSources.SpfEvaluator, MessageType.error, "EvaluationError", "markdown"));
spfRecords.Records[0].Terms[0].Explanation = "Explanation";
SpfRecordsEvaluated spfRecordsEvaluated = new SpfRecordsEvaluated(Id, spfRecords, 1, TimeSpan.MinValue, new List <Message>(), DateTime.UtcNow);
await _spfEntity.Handle(spfRecordsEvaluated);
A.CallTo(() => _changeNotifierComposite.Handle(A <SpfEntityState> ._, spfRecordsEvaluated))
.MustHaveHappenedOnceExactly();
A.CallTo(() => _dispatcher.Dispatch(A <SpfRecordEvaluationsChanged> .That.Matches(
_ => _.Records.Records[0].Messages[0].Text.Equals(spfRecords.Records[0].Messages[0].Text) &&
_.Records.Records[0].Terms[0].Explanation
.Equals(spfRecords.Records[0].Terms[0].Explanation)),
A <string> ._))
.MustHaveHappenedOnceExactly();
A.CallTo(() => _changeNotifierComposite.Handle(A <SpfEntityState> ._, spfRecordsEvaluated))
.MustHaveHappenedOnceExactly();
A.CallTo(() => _domainStatusPublisher.Publish(spfRecordsEvaluated))
.MustHaveHappenedOnceExactly();
A.CallTo(() => _spfEntityDao.Save(A <SpfEntityState> ._)).MustHaveHappenedOnceExactly();
}
public async Task RedirectTermErroredIfDnsFails()
{
A.CallTo(() => _dnsClient.GetSpfRecords(A <string> ._))
.Returns(Task.FromResult(new DnsResult <List <List <string> > >
("Error")));
Redirect redirect = new Redirect("", new DomainSpec("domain"));
SpfRecords spfRecords = await _spfRedirectTermExpander.Process("", redirect);
Assert.That(spfRecords, Is.Null);
Assert.That(redirect.AllErrors.Count, Is.EqualTo(1));
Assert.AreEqual("Failed SPF record query for domain with error Error", redirect.AllErrors[0].Message);
}
public void SpfRecordsWithSameMessageTest()
{
SpfRecords spfRecords =
NotifierTestUtil.CreateSpfRecords();
SpfEntityState state =
new SpfEntityState(Id, 1, SpfState.Evaluated, DateTime.Now)
{
SpfRecords = NotifierTestUtil.CreateSpfRecords()
};
SpfRecordsEvaluated message = new SpfRecordsEvaluated(Id, spfRecords, 1, TimeSpan.MinValue, new List <Message>(), DateTime.UtcNow);
_changeNotifier.Handle(state, message);
NotifierTestUtil.VerifyResults(_dispatcher);
}
public async Task MxTermErroredIfMxQueryFails()
{
A.CallTo(() => _dnsClient.GetMxRecords(A<string>._))
.Returns(Task.FromResult(new DnsResult<List<string>>("Error")));
Mx mx = new Mx("", Qualifier.Pass, new DomainSpec("domain"), new DualCidrBlock(new Ip4CidrBlock(32), new Ip6CidrBlock(128)));
SpfRecords spfRecords = await _spfMxTermExpander.Process("", mx);
Assert.That(spfRecords, Is.Null);
Assert.That(mx.MxHosts, Is.Null);
Assert.That(mx.AllErrors.Count, Is.EqualTo(1));
Assert.AreEqual("Failed MX record query for domain with error Error", mx.AllErrors[0].Message);
}
public async Task ATermWithDomainSpecifiedInDomainSpecErroredIfDnsFails()
{
A.CallTo(() => _dnsClient.GetARecords(A <string> ._))
.Returns(Task.FromResult(new DnsResult <List <string> >("Error")));
Domain.A term = new Domain.A("", Qualifier.Pass, new DomainSpec("domain"),
new DualCidrBlock(new Ip4CidrBlock(32), new Ip6CidrBlock(128)));
SpfRecords spfRecords = await _spfATermExpander.Process("", term);
Assert.That(spfRecords, Is.Null);
Assert.That(term.Ip4s, Is.Null);
Assert.That(term.AllErrors.Count, Is.EqualTo(1));
Assert.AreEqual("Failed A record query for domain with error Error", term.AllErrors[0].Message);
}
public async Task HandleSpfRecordsEvaluatedAndWithExistingEvaluationUpdatesStateTest()
{
A.CallTo(() => _spfEntityDao.Get(Id)).Returns(new SpfEntityState(Id, 2, SpfState.PollPending, DateTime.Now)
{
LastUpdated = DateTime.Now.AddDays(-1),
SpfRecords = CreateSpfRecords()
});
SpfRecords spfRecords = CreateSpfRecords();
SpfRecordsEvaluated spfRecordsEvaluated = new SpfRecordsEvaluated(Id, spfRecords, 1, TimeSpan.MinValue, new List <Message>(), DateTime.UtcNow);
await _spfEntity.Handle(spfRecordsEvaluated);
A.CallTo(() => _dispatcher.Dispatch(A <SpfRecordEvaluationsChanged> ._, A <string> ._)).MustHaveHappened();
A.CallTo(() => _changeNotifierComposite.Handle(A <SpfEntityState> ._, spfRecordsEvaluated))
.MustHaveHappenedOnceExactly();
A.CallTo(() => _domainStatusPublisher.Publish(spfRecordsEvaluated))
.MustHaveHappenedOnceExactly();
A.CallTo(() => _spfEntityDao.Save(A <SpfEntityState> ._)).MustHaveHappenedOnceExactly();
}
public async Task IncludeTermExpanded()
{
List <string> spfRecord = new List <string> {
"v=spf1"
};
A.CallTo(() => _dnsClient.GetSpfRecords(A <string> ._))
.Returns(Task.FromResult(new DnsResult <List <List <string> > >
(new List <List <string> > {
spfRecord
}, 200)));
Include include = new Include("", Qualifier.Pass, new DomainSpec(""));
SpfRecords spfRecords = await _spfIncludeTermExpander.Process("", include);
Assert.That(spfRecords, Is.Not.Null);
Assert.That(include.Records, Is.SameAs(spfRecords));
Assert.That(include.AllErrors, Is.Empty);
}
public async Task RedirectTermExpanded()
{
List <string> spfRecord = new List <string> {
"v=spf1"
};
A.CallTo(() => _dnsClient.GetSpfRecords(A <string> ._))
.Returns(Task.FromResult(new DnsResult <List <List <string> > >
(new List <List <string> > {
spfRecord
}, 200)));
Redirect redirect = new Redirect("", new DomainSpec(""));
SpfRecords spfRecords = await _spfRedirectTermExpander.Process("", redirect);
Assert.That(spfRecords, Is.Not.Null);
Assert.That(redirect.Records, Is.SameAs(spfRecords));
Assert.That(redirect.AllErrors, Is.Empty);
}
public async Task EvaluationOccursForNestedRecords()
{
await PurgeAmazonSqsQueue(OutputQueueUrl);
List <Term> innerTerms = new List <Term>
{
new All(Qualifier.Neutral, "?All", true, false)
};
List <Term> terms = new List <Term>
{
new Include(Qualifier.Pass, string.Empty, string.Empty, CreateSpfRecords(innerTerms), true)
};
SpfRecords spfRecords = CreateSpfRecords(terms);
SpfRecordsPolled spfRecordsPolled = new SpfRecordsPolled(Id, spfRecords, 1, TimeSpan.FromSeconds(0),
new List <Contracts.SharedDomain.Message>());
InvokeLambda(spfRecordsPolled);
Message message = await ReadAmazonSqsEvent(OutputQueueUrl, ReadTimeoutSecond);
Assert.That(message, Is.Not.Null);
Assert.That(message, Is.TypeOf <SpfRecordsEvaluated>());
SpfRecordsEvaluated spfRecordsEvaluated = (SpfRecordsEvaluated)message;
List <SpfRecord> records = spfRecordsEvaluated.Records.Records;
Assert.That(records.Count, Is.EqualTo(1));
Assert.That(records[0].Terms.Count, Is.EqualTo(1));
Assert.That(records[0].Terms[0].Explanation, Is.Not.Null);
Assert.That(records[0].Terms[0], Is.TypeOf <Include>());
List <SpfRecord> innerRecords = ((Include)records[0].Terms[0]).Records.Records;
Assert.That(innerRecords[0].Terms.Count, Is.EqualTo(1));
Assert.That(innerRecords[0].Terms[0].Explanation, Is.Not.Null);
}
public async Task MxTermErroredIfARecordHasTooManyResults()
{
string host1 = "host1";
string ip1 = "192.168.1.1";
string ip2 = "192.168.1.2";
string ip3 = "192.168.1.3";
string ip4 = "192.168.1.4";
string ip5 = "192.168.1.5";
string ip6 = "192.168.1.6";
string ip7 = "192.168.1.7";
string ip8 = "192.168.1.8";
string ip9 = "192.168.1.9";
string ip10 = "192.168.1.10";
string ip11 = "192.168.1.11";
A.CallTo(() => _dnsClient.GetMxRecords(A<string>._))
.Returns(Task.FromResult(new DnsResult<List<string>>
(new List<string> { host1 }, 200)));
A.CallTo(() => _dnsClient.GetARecords(A<string>._))
.ReturnsNextFromSequence(
Task.FromResult(new DnsResult<List<string>>(new List<string> { ip1, ip2, ip3, ip4, ip5, ip6, ip7, ip8, ip9, ip10, ip11 }, 200)));
Mx mx = new Mx("", Qualifier.Pass, new DomainSpec(""), new DualCidrBlock(new Ip4CidrBlock(32), new Ip6CidrBlock(128)));
SpfRecords spfRecords = await _spfMxTermExpander.Process("", mx);
Assert.That(spfRecords, Is.Null);
Assert.That(mx.MxHosts.Count, Is.EqualTo(1));
Assert.That(mx.MxHosts[0].Host, Is.EqualTo(host1));
Assert.That(mx.MxHosts[0].Ip4S, Is.Empty);
Assert.That(mx.AllErrors.Count, Is.EqualTo(1));
Assert.AreEqual("Too many A records 11 returned for host1. Limit is 10.", mx.AllErrors[0].Message);
}
