public async Task SpfRecordsPolledAndRecordsChangedEventsRaisedAndStateUpdated()
{
await PurgeAmazonSqsQueue(OutputQueueUrl);
await TruncateDatabase(ConnectionString);
await SetState(ConnectionString, new SpfEntityState(Id, 1, SpfState.PollPending, DateTime.Now));
SpfRecordsPolled spfRecordsPolled = new SpfRecordsPolled(Id,
CreateSpfRecords(), 1, TimeSpan.FromSeconds(1), new List <Contracts.SharedDomain.Message>());
InvokeLambda(spfRecordsPolled);
Message message1 = await ReadAmazonSqsEvent(OutputQueueUrl, ReadTimeoutSecond);
Assert.That(message1, Is.TypeOf <SpfRecordsPolled>());
SpfRecordsEvaluated spfRecordsEvaluated = (SpfRecordsEvaluated)message1;
Assert.That(spfRecordsEvaluated.Id, Is.EqualTo(Id));
Assert.That(spfRecordsEvaluated.Records, Is.EqualTo(spfRecordsPolled.Records));
Assert.That(spfRecordsEvaluated.DnsQueryCount, Is.EqualTo(spfRecordsPolled.DnsQueryCount));
Assert.That(spfRecordsEvaluated.ElapsedQueryTime, Is.EqualTo(spfRecordsPolled.ElapsedQueryTime));
CollectionAssert.AreEqual(spfRecordsEvaluated.Messages, spfRecordsPolled.Messages);
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, Is.EqualTo(spfRecordsPolled.Records));
Assert.That(spfEntityStates[0].DnsQueryCount, Is.EqualTo(spfRecordsPolled.DnsQueryCount));
Assert.That(spfEntityStates[0].ElapsedQueryTime, Is.EqualTo(spfRecordsPolled.ElapsedQueryTime));
CollectionAssert.AreEqual(spfEntityStates[0].Messages, spfRecordsPolled.Messages);
}
public async Task HandleSpfRecordsEvaluatedAndNewSpfRecordUpdatesHistoryWhichHasTwoPreviousRecord()
{
var spfRecords1 = CreateSpfRecords().Records[0].RecordsStrings;
var spfRecords2 = CreateSpfRecords("v=spf2......").Records[0].RecordsStrings;
var spfRecords3 = CreateSpfRecords("v=spf3......").Records[0].RecordsStrings;
A.CallTo(() => _spfHistoryEntityDao.Get(Id)).Returns(new SpfHistoryEntityState(Id,
new List <SpfHistoryRecord>
{
new SpfHistoryRecord(DateTime.UtcNow.AddDays(-2), null, spfRecords2),
new SpfHistoryRecord(DateTime.UtcNow.AddDays(-3), DateTime.UtcNow.AddDays(-2), spfRecords1)
}));
SpfRecordsPolled polled = new SpfRecordsPolled(Id, CreateSpfRecords("v=spf3......"), 1, TimeSpan.Zero, new List <Message>());
await _spfEntityHistory.Handle(polled);
A.CallTo(() => _spfHistoryEntityDao.Save(A <SpfHistoryEntityState> .That.Matches(_ =>
_.SpfHistory.Count == 3 &&
_.SpfHistory[0].EndDate == null &&
_.SpfHistory[0].SpfRecords.SequenceEqual(spfRecords3) &&
_.SpfHistory[1].EndDate == polled.Timestamp &&
_.SpfHistory[1].SpfRecords.SequenceEqual(spfRecords2) &&
_.SpfHistory[2].SpfRecords.SequenceEqual(spfRecords1)
))).MustHaveHappenedOnceExactly();
}
public void SpfRecordsWithSameReferencesTest()
{
SpfEntityState state =
new SpfEntityState(Id, 1, SpfState.Evaluated, DateTime.Now)
{
SpfRecords = NotifierTestUtil.CreateSpfRecords("spf1", terms:
new List <Term>
{
new Include(Qualifier.Fail, "spf2", "abc.com", NotifierTestUtil.CreateSpfRecords("spf2", terms:
new List <Term>
{
new Include(Qualifier.Fail, "spf3", "abc.com", NotifierTestUtil.CreateSpfRecords("spf3"), false)
}), false)
})
};
SpfRecordsPolled message =
new SpfRecordsPolled(Id, NotifierTestUtil.CreateSpfRecords("spf1", terms:
new List <Term>
{
new Include(Qualifier.Fail, "spf2", "abc.com", NotifierTestUtil.CreateSpfRecords("spf2", terms:
new List <Term>
{
new Include(Qualifier.Fail, "spf3", "abc.com", NotifierTestUtil.CreateSpfRecords("spf3"), false)
}), false)
}), 1, TimeSpan.FromSeconds(1));
_changeNotifier.Handle(state, message);
NotifierTestUtil.VerifyResults(_dispatcher, referencedChange: true);
}
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 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 HandleSpfRecordsEvaluatedAndExistingSpfRecordsHistoryStateNotUpdated()
{
A.CallTo(() => _spfHistoryEntityDao.Get(Id)).Returns(new SpfHistoryEntityState(Id, new List <SpfHistoryRecord>
{
new SpfHistoryRecord(DateTime.UtcNow.AddDays(-1), null, CreateSpfRecords().Records[0].RecordsStrings)
}));
SpfRecordsPolled polled = new SpfRecordsPolled(Id, CreateSpfRecords(), 1, TimeSpan.Zero, new List <Message>());
await _spfEntityHistory.Handle(polled);
A.CallTo(() => _spfHistoryEntityDao.Save(A <SpfHistoryEntityState> ._)).MustNotHaveHappened();
}
public void SpfRecordsAreSameTest()
{
SpfEntityState state =
new SpfEntityState(Id, 1, SpfState.Evaluated, DateTime.Now)
{
SpfRecords = NotifierTestUtil.CreateSpfRecords()
};
SpfRecordsPolled message =
new SpfRecordsPolled(Id, NotifierTestUtil.CreateSpfRecords(), 1, TimeSpan.FromSeconds(1));
_changeNotifier.Handle(state, message);
NotifierTestUtil.VerifyResults(_dispatcher);
}
public async Task Handle(SpfRecordsPolled message)
{
string messageId = message.Id.ToLower();
SpfHistoryEntityState entityHistory = await LoadHistoryState(messageId);
List <string> records = new List <string>();
message.Records?.Records.ForEach(x => records.AddRange(x.RecordsStrings));
if (entityHistory.UpdateHistory(records, message.Timestamp))
{
await _dao.Save(entityHistory);
}
}
public async Task HandleSpfRecordsEvaluatedAndUpdateWhenNoRecordsExistUpdatesHistoryState()
{
var spfRecords1 = CreateSpfRecords().Records[0].RecordsStrings;
A.CallTo(() => _spfHistoryEntityDao.Get(Id)).Returns(new SpfHistoryEntityState(Id));
SpfRecordsPolled polled = new SpfRecordsPolled(Id, CreateSpfRecords(), 1, TimeSpan.Zero, new List <Message>());
await _spfEntityHistory.Handle(polled);
A.CallTo(() => _spfHistoryEntityDao.Save(A <SpfHistoryEntityState> .That.Matches(_ =>
_.SpfHistory.Count == 1 &&
_.SpfHistory[0].EndDate == null &&
_.SpfHistory[0].SpfRecords.SequenceEqual(spfRecords1)
))).MustHaveHappenedOnceExactly();
}
public async Task Handle(SpfPollPending message)
{
try
{
SpfPollResult spfPollResult = await _processor.Process(message.Id);
_log.LogInformation("Polled SPF records for {Domain}", message.Id);
SpfRecordsPolled spfRecordsPolled = spfPollResult.ToSpfRecordsPolled(message.Id);
_dispatcher.Dispatch(spfRecordsPolled, _config.SnsTopicArn);
_log.LogInformation("Published SPF records for {Domain}", message.Id);
}
catch (System.Exception e)
{
string error = $"Error occurred polling domain {message.Id}";
_log.LogError(e, error);
throw;
}
}
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 HandleSpfRecordsEvaluatedWhenNewRecords()
{
var spfRecord = CreateSpfRecords("one,two");
spfRecord.Records.AddRange(CreateSpfRecords().Records);
var spfRecord2 = CreateSpfRecords("two,three");
spfRecord2.Records.Reverse();
A.CallTo(() => _spfHistoryEntityDao.Get(Id)).Returns(new SpfHistoryEntityState(Id,
new List <SpfHistoryRecord>
{
new SpfHistoryRecord(DateTime.UtcNow.AddDays(-2), null, spfRecord.Records[0].RecordsStrings)
}));
SpfRecordsPolled polled = new SpfRecordsPolled(Id, spfRecord2, 1, TimeSpan.Zero, new List <Message>());
await _spfEntityHistory.Handle(polled);
A.CallTo(() => _spfHistoryEntityDao.Save(A <SpfHistoryEntityState> ._)).MustHaveHappenedOnceExactly();
}
public async Task PollNxDomainReturnsExpectedResult()
{
await PurgeAmazonSqsQueue(OutputQueueUrl);
SpfPollPending spfRecordExpired = new SpfPollPending(DomainWithNxDomainResult);
InvokeLambda(spfRecordExpired);
List <Message> messages = await ReadAmazonSqsEvent(OutputQueueUrl, ReadTimeoutSecond);
Assert.That(messages.Count, Is.EqualTo(1));
Assert.That(messages[0], Is.TypeOf <SpfRecordsPolled>());
SpfRecordsPolled spfRecordsPolled = (SpfRecordsPolled)messages[0];
Assert.That(spfRecordsPolled.Id, Is.EqualTo(spfRecordsPolled.Id));
Assert.That(spfRecordsPolled.Records.Records, Is.Empty);
Assert.That(spfRecordsPolled.DnsQueryCount, Is.Null);
Assert.That(spfRecordsPolled.ElapsedQueryTime, Is.Null);
Assert.That(spfRecordsPolled.Messages.Count, Is.EqualTo(1));
StringAssert.StartsWith("Failed SPF record query for", spfRecordsPolled.Messages[0].Text);
}
public async Task PollDomainWithoutSpfReturnsExpectedResult()
{
await PurgeAmazonSqsQueue(OutputQueueUrl);
SpfPollPending spfRecordExpired = new SpfPollPending(DomainWithoutSpf);
InvokeLambda(spfRecordExpired);
List <Message> messages = await ReadAmazonSqsEvent(OutputQueueUrl, ReadTimeoutSecond);
Assert.That(messages.Count, Is.EqualTo(1));
Assert.That(messages[0], Is.TypeOf <SpfRecordsPolled>());
SpfRecordsPolled spfRecordsPolled = (SpfRecordsPolled)messages[0];
Assert.That(spfRecordsPolled.Id, Is.EqualTo(spfRecordsPolled.Id));
Assert.That(spfRecordsPolled.Records.Records, Is.Empty);
Assert.That(spfRecordsPolled.DnsQueryCount, Is.EqualTo(0));
Assert.That(spfRecordsPolled.ElapsedQueryTime, Is.Not.Null);
Assert.That(spfRecordsPolled.Records.Messages.Count, Is.EqualTo(1));
StringAssert.StartsWith("500.uk.com: Domain should have exactly 1 SPF record. This domain has 0.", spfRecordsPolled.Records.Messages[0].Text);
}
public async Task PollDomainWithSpfReturnsExpectedResult()
{
await PurgeAmazonSqsQueue(OutputQueueUrl);
SpfPollPending spfRecordExpired = new SpfPollPending(DomainWithSpf);
InvokeLambda(spfRecordExpired);
List <Message> messages = await ReadAmazonSqsEvent(OutputQueueUrl, ReadTimeoutSecond);
Assert.That(messages.Count, Is.EqualTo(1));
Assert.That(messages[0], Is.TypeOf <SpfRecordsPolled>());
SpfRecordsPolled spfRecordsPolled = (SpfRecordsPolled)messages[0];
Assert.That(spfRecordsPolled.Id, Is.EqualTo(spfRecordsPolled.Id));
Assert.That(spfRecordsPolled.DnsQueryCount, Is.EqualTo(2));
Assert.That(spfRecordsPolled.ElapsedQueryTime, Is.Not.Null);
Assert.That(spfRecordsPolled.Records.Records.Count, Is.EqualTo(1));
Assert.That(spfRecordsPolled.Records.PayloadSizeBytes, Is.EqualTo(ExpectedRecordSize));
Assert.That(spfRecordsPolled.Records.Records[0].Record, Is.EqualTo(ExpectedSpfRecord));
Assert.That(spfRecordsPolled.Records.Messages, Is.Empty);
}
