public static void CollectionOfFake(
int count,
IList<ICollectionItem> fakes)
{
"When creating a collection of {0} fakes"
.x(() => fakes = A.CollectionOfFake<ICollectionItem>(count));
"Then {0} items should be created"
.x(() => fakes.Should().HaveCount(count));
"And all items should extend the specified type"
.x(() => fakes.Should().ContainItemsAssignableTo<ICollectionItem>());
"And all items should be fakes"
.x(() => fakes.Should().OnlyContain(item => Fake.GetFakeManager(item) != null));
}
private static void TestResults(IList<string> results, int numberToReturn, int length,
string charactersAllowed)
{
results.Should().Not.Be.Null();
results.Count.Should().Equal(numberToReturn);
foreach (var result in results)
{
result.Length.Should().Be.LessThanOrEqualTo(length);
result.ToCharArray().Should().Contain.Any(charactersAllowed.Contains);
}
}
private static void TestResults(IList<decimal> results, int numberToReturn, int numberOfDecimalPlaces)
{
results.Should().Not.Be.Null();
results.Count().Should().Equal(numberToReturn);
foreach (var result in results)
{
result.Should().Be.GreaterThan(0m);
result.Should().Be.LessThan(1m);
result.ToString(CultureInfo.InvariantCulture).Length.Should().Be.LessThanOrEqualTo(numberOfDecimalPlaces + 2); // the "+2" takes into account the "0." at the beginning of returned value
}
}
private static void TestResults(IList<int> results, int numberToReturn, int minNumber,
int maxNumber, bool allowDuplicates)
{
results.Should().Not.Be.Null();
results.Count().Should().Equal(numberToReturn);
// Ensure there are no duplicates
if (!allowDuplicates)
CollectionAssert.AllItemsAreUnique(results.ToArray());
foreach (var result in results)
result.Should().Be.InRange(minNumber, maxNumber);
}
private void ValidateResult(IList<ReleaseInfo> reports, bool hasSize = false, bool hasInfoUrl = false)
{
reports.Should().NotBeEmpty();
reports.Should().OnlyContain(c => c.Title.IsNotNullOrWhiteSpace());
reports.Should().OnlyContain(c => c.PublishDate.Year > 2000);
reports.Should().OnlyContain(c => c.DownloadUrl.IsNotNullOrWhiteSpace());
reports.Should().OnlyContain(c => c.DownloadUrl.StartsWith("http"));
if (hasInfoUrl)
{
reports.Should().OnlyContain(c => c.InfoUrl.IsNotNullOrWhiteSpace());
}
if (hasSize)
{
reports.Should().OnlyContain(c => c.Size > 0);
}
}
public void WhenRefreshWhitelist_AndActivePeersAvailable_ThenWhitelistContainsActivePeers()
{
// Arrange.
Mock <IDateTimeProvider> mockDateTimeProvider = new Mock <IDateTimeProvider>();
Mock <ILogger> mockLogger = new Mock <ILogger>();
Mock <ILoggerFactory> mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object);
ILoggerFactory loggerFactory = mockLoggerFactory.Object;
mockDateTimeProvider.Setup(d => d.GetTimeOffset()).Returns(new DateTimeOffset(new DateTime(2017, 8, 30, 1, 2, 3))).Verifiable();
IDateTimeProvider dateTimeProvider = mockDateTimeProvider.Object;
int inactiveTimePeriod = 2000;
IPAddress activeIpAddressOne = IPAddress.Parse("::ffff:192.168.0.1");
var activeEndpointOne = new IPEndPoint(activeIpAddressOne, 80);
IPAddress activeIpAddressTwo = IPAddress.Parse("::ffff:192.168.0.2");
var activeEndpointTwo = new IPEndPoint(activeIpAddressTwo, 80);
IPAddress activeIpAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
var activeEndpointThree = new IPEndPoint(activeIpAddressThree, 80);
IPAddress activeIpAddressFour = IPAddress.Parse("::ffff:192.168.0.4");
var activeEndpointFour = new IPEndPoint(activeIpAddressFour, 80);
IPAddress activeIpAddressFive = IPAddress.Parse("2607:f8b0:4009:80e::200e");
var activeEndpointFive = new IPEndPoint(activeIpAddressFive, 80);
var testDataSet = new List <Tuple <IPEndPoint, DateTimeOffset> >()
{
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointOne, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(10)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointTwo, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(20)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointThree, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(30)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointFour, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(40)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointFive, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(50))
};
// PeerAddressManager does not support IPv4 addresses that are not represented as embedded IPv4 addresses in an IPv6 address.
IPeerAddressManager peerAddressManager = this.CreateTestPeerAddressManager(testDataSet);
IMasterFile spiedMasterFile = null;
Mock <IDnsServer> mockDnsServer = new Mock <IDnsServer>();
mockDnsServer.Setup(d => d.SwapMasterfile(It.IsAny <IMasterFile>()))
.Callback <IMasterFile>(m =>
{
spiedMasterFile = m;
})
.Verifiable();
NodeSettings nodeSettings = NodeSettings.Default();
DnsSettings dnsSettings = new Mock <DnsSettings>().Object;
dnsSettings.DnsPeerBlacklistThresholdInSeconds = inactiveTimePeriod;
dnsSettings.DnsHostName = "stratis.test.com";
ConnectionManagerSettings connectionSettings = new ConnectionManagerSettings();
connectionSettings.Load(nodeSettings);
WhitelistManager whitelistManager = new WhitelistManager(dateTimeProvider, loggerFactory, peerAddressManager, mockDnsServer.Object, connectionSettings, dnsSettings);
// Act.
whitelistManager.RefreshWhitelist();
// Assert.
spiedMasterFile.Should().NotBeNull();
// Check for A records (IPv4 embedded in IPv6 and IPv4 addresses).
Question question4 = new Question(new Domain(dnsSettings.DnsHostName), RecordType.A);
IList <IResourceRecord> resourceRecordsIpv4 = spiedMasterFile.Get(question4);
resourceRecordsIpv4.Should().NotBeNullOrEmpty();
IList <IPAddressResourceRecord> ipAddressResourceRecords4 = resourceRecordsIpv4.OfType <IPAddressResourceRecord>().ToList();
ipAddressResourceRecords4.Should().HaveCount(4);
// Check for AAAA records (IPv6 addresses).
Question question6 = new Question(new Domain(dnsSettings.DnsHostName), RecordType.AAAA);
IList <IResourceRecord> resourceRecordsIpv6 = spiedMasterFile.Get(question6);
resourceRecordsIpv6.Should().NotBeNullOrEmpty();
IList <IPAddressResourceRecord> ipAddressResourceRecords6 = resourceRecordsIpv6.OfType <IPAddressResourceRecord>().ToList();
ipAddressResourceRecords6.Should().HaveCount(1);
foreach (Tuple <IPEndPoint, DateTimeOffset> testData in testDataSet)
{
if (testData.Item1.Address.IsIPv4MappedToIPv6)
{
ipAddressResourceRecords4.SingleOrDefault(i => i.IPAddress.Equals(testData.Item1.Address.MapToIPv4())).Should().NotBeNull();
}
else
{
ipAddressResourceRecords6.SingleOrDefault(i => i.IPAddress.Equals(testData.Item1.Address)).Should().NotBeNull();
}
}
}
public void WhenRefreshWhitelist_AndInactivePeersInWhitelist_ThenWhitelistDoesNotContainInactivePeers()
{
// Arrange.
var mockDateTimeProvider = new Mock <IDateTimeProvider>();
var mockLogger = new Mock <ILogger>();
var mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object);
ILoggerFactory loggerFactory = mockLoggerFactory.Object;
mockDateTimeProvider.Setup(d => d.GetTimeOffset()).Returns(new DateTimeOffset(new DateTime(2017, 8, 30, 1, 2, 3))).Verifiable();
IDateTimeProvider dateTimeProvider = mockDateTimeProvider.Object;
int inactiveTimePeriod = 3000;
IPAddress activeIpAddressOne = IPAddress.Parse("::ffff:192.168.0.1");
var activeEndpointOne = new IPEndPoint(activeIpAddressOne, 80);
IPAddress activeIpAddressTwo = IPAddress.Parse("::ffff:192.168.0.2");
var activeEndpointTwo = new IPEndPoint(activeIpAddressTwo, 80);
IPAddress activeIpAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
var activeEndpointThree = new IPEndPoint(activeIpAddressThree, 80);
IPAddress activeIpAddressFour = IPAddress.Parse("::ffff:192.168.0.4");
var activeEndpointFour = new IPEndPoint(activeIpAddressFour, 80);
var activeTestDataSet = new List <Tuple <IPEndPoint, DateTimeOffset> >()
{
new Tuple <IPEndPoint, DateTimeOffset> (activeEndpointOne, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(10)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointTwo, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(20)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointThree, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(30)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointFour, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(40))
};
IPAddress inactiveIpAddressOne = IPAddress.Parse("::ffff:192.168.100.1");
var inactiveEndpointOne = new IPEndPoint(inactiveIpAddressOne, 80);
IPAddress inactiveIpAddressTwo = IPAddress.Parse("::ffff:192.168.100.2");
var inactiveEndpointTwo = new IPEndPoint(inactiveIpAddressTwo, 80);
IPAddress inactiveIpAddressThree = IPAddress.Parse("::ffff:192.168.100.3");
var inactiveEndpointThree = new IPEndPoint(inactiveIpAddressThree, 80);
var inactiveTestDataSet = new List <Tuple <IPEndPoint, DateTimeOffset> >()
{
new Tuple <IPEndPoint, DateTimeOffset> (inactiveEndpointOne, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(-10)),
new Tuple <IPEndPoint, DateTimeOffset>(inactiveEndpointTwo, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(-20)),
new Tuple <IPEndPoint, DateTimeOffset>(inactiveEndpointThree, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(-30))
};
IPeerAddressManager peerAddressManager = this.CreateTestPeerAddressManager(activeTestDataSet.Concat(inactiveTestDataSet).ToList());
IMasterFile spiedMasterFile = null;
var mockDnsServer = new Mock <IDnsServer>();
mockDnsServer.Setup(d => d.SwapMasterfile(It.IsAny <IMasterFile>()))
.Callback <IMasterFile>(m =>
{
spiedMasterFile = m;
})
.Verifiable();
NodeSettings nodeSettings = NodeSettings.Default(this.Network);
DnsSettings dnsSettings = new DnsSettings(NodeSettings.Default(this.Network));
dnsSettings.DnsPeerBlacklistThresholdInSeconds = inactiveTimePeriod;
dnsSettings.DnsHostName = "stratis.test.com";
ConnectionManagerSettings connectionSettings = new ConnectionManagerSettings(nodeSettings);
var whitelistManager = new WhitelistManager(dateTimeProvider, loggerFactory, peerAddressManager, mockDnsServer.Object, connectionSettings, dnsSettings, this.peerBanning);
// Act.
whitelistManager.RefreshWhitelist();
// Assert.
spiedMasterFile.Should().NotBeNull();
var question = new Question(new Domain(dnsSettings.DnsHostName), RecordType.A);
IList <IResourceRecord> resourceRecords = spiedMasterFile.Get(question);
resourceRecords.Should().NotBeNullOrEmpty();
IList <IPAddressResourceRecord> ipAddressResourceRecords = resourceRecords.OfType <IPAddressResourceRecord>().ToList();
ipAddressResourceRecords.Should().HaveSameCount(activeTestDataSet);
foreach (Tuple <IPEndPoint, DateTimeOffset> testData in activeTestDataSet)
{
ipAddressResourceRecords.SingleOrDefault(i => i.IPAddress.Equals(testData.Item1.Address.MapToIPv4())).Should().NotBeNull("the ip address is active and should be in DNS");
}
foreach (Tuple <IPEndPoint, DateTimeOffset> testData in inactiveTestDataSet)
{
ipAddressResourceRecords.SingleOrDefault(i => i.IPAddress.Equals(testData.Item1.Address.MapToIPv4())).Should().BeNull("the ip address is inactive and should not be returned from DNS");
}
}
public void Assert_MatchingSubmissionSummaries_AreReturned(IList <SubmissionSummaryModel> result)
{
result.Count.Should().Be(matchingSubmissionSummaries.Count);
matchingSubmissionSummaries.ForEach(x => result.Should().Contain(x));
nonMatchingSubmissionSummaries.ForEach(x => result.Should().NotContain(x));
}
/// <summary>
/// Checks to make sure that the selected GIT commits are equal to each other.
/// </summary>
/// <param name="repoCommits">The commits coming from LibGit2.</param>
/// <param name="commits">The commits coming from the GIT command line BranchManager.</param>
private static void CheckCommits(IList <string> repoCommits, IList <GitCommit> commits)
{
repoCommits.Should().BeEquivalentTo(commits.Select(x => x.MessageShort));
}
public void CanGetAListOfSlackBillablePeople()
{
_response.Should().BeOfType <List <SlackBillablePerson> >();
_response.Should().HaveCount(2);
}
public void IfValidationSetFractionIsZero_ShouldPassFullTrainingSet()
{
_mockTrainer.Object.Train(_trainingSet, _nn);
_trainingSubSet.Should().Equal(_trainingSet);
}
public void Then_Returns_Expected_Results()
{
_result.Should().NotBeNull();
_result.Count.Should().NotBe(0);
_result.Should().BeInAscendingOrder(x => x.DisplayName);
}
public void AssertNoOutputMessages()
{
outputStrings.Should().HaveCount(0);
}
private static void TestResults(IList<decimal> results, int numberToReturn)
{
results.Should().Not.Be.Null();
results.Count().Should().Equal(numberToReturn);
}
public void Then_No_Items_Are_Returned() => _result.Should().BeEmpty();
public void Should_Not_Contain_Ignored_Entities()
{
_crds.Should()
.NotContain(crd => crd.Name().Contains("ignored", StringComparison.InvariantCultureIgnoreCase));
}
public void ThenResultShouldBeAsExpected() => _conversations.Should().BeEquivalentTo(_expectedConversations);
public void Then_the_results_are_correct()
{
actual.Should().NotBeNull();
actual.Count.Should().Be(1);
actual.First().YearOfRelease.Should().Be(2000);
}
private void VerifyMetricsAreOk(IList<XMetric> xMetrics, int expectedCount)
{
xMetrics.ShouldNotBeNullAndHaveCount(expectedCount);
xMetrics.Should().OnlyContain(aMetric => aMetric.Name.IsNotNullOrEmpty() &&
aMetric.Value.IsNotNullOrEmpty());
}
public void AssertExpectedUrlsRequested(params string[] urls)
{
requestedUrls.Should().BeEquivalentTo(urls, "Unexpected urls requested");
}
public void Then_Returns_Expected_Results()
{
_result.Should().NotBeNull();
_result.Count().Should().Be(0);
}
public void ShouldHaveExpectedOrder()
=> traverseResult.Should().ContainInOrder(expectedOrder);
public void Works(string s, string p, int[] expected)
{
IList <int> result = AnagramFinder.FindAnagrams(s, p);
result.Should().BeEquivalentTo(expected);
}
public void ThenUsedConversationIdsShouldBeAsExpected() => _usedConversationIds.Should() .BeEquivalentTo(_conversationParticipants.Select(ptcp => ptcp.ConversationId).ToList());
public void AssertExpectedTargetFileNamesSupplied(params string[] urls)
{
targetFileNames.Should().BeEquivalentTo(urls, "Unexpected target files names supplied");
}
public void Then_the_results_are_correct()
{
actual.Should().NotBeNull();
actual.Count.Should().Be(1);
actual.First().Title.Should().Be("FooMovie");
}
/// <summary>
/// Creates a <see cref="IReadOnlyCollection{T}" /> wrapper collection around <paramref name="list" />.
/// </summary>
/// <typeparam name="T">The type parameter of the items in the list.</typeparam>
/// <param name="list">A list object.</param>
public static IReadOnlyList <T> ToReadOnlyWrappedList <T>(this IList <T> list)
{
list.Should().NotBeNull("collection must not be null");
return(new ListReadOnlyWrapper <T>(list));
}
protected override void SingleFieldAssertion(IList <string> result, Test persisted)
{
result.Should().Contain(persisted.Name);
}
public void WhenRefreshWhitelist_AndActivePeersAvailable_ThenWhitelistContainsActivePeers()
{
// Arrange.
Mock <IDateTimeProvider> mockDateTimeProvider = new Mock <IDateTimeProvider>();
Mock <ILogger> mockLogger = new Mock <ILogger>();
Mock <ILoggerFactory> mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object);
ILoggerFactory loggerFactory = mockLoggerFactory.Object;
mockDateTimeProvider.Setup(d => d.GetTimeOffset()).Returns(new DateTimeOffset(new DateTime(2017, 8, 30, 1, 2, 3))).Verifiable();
IDateTimeProvider dateTimeProvider = mockDateTimeProvider.Object;
int inactiveTimePeriod = 2000;
IPAddress activeIpAddressOne = IPAddress.Parse("::ffff:192.168.0.1");
NetworkAddress activeNetworkAddressOne = new NetworkAddress(activeIpAddressOne, 80);
IPAddress activeIpAddressTwo = IPAddress.Parse("::ffff:192.168.0.2");
NetworkAddress activeNetworkAddressTwo = new NetworkAddress(activeIpAddressTwo, 80);
IPAddress activeIpAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
NetworkAddress activeNetworkAddressThree = new NetworkAddress(activeIpAddressThree, 80);
IPAddress activeIpAddressFour = IPAddress.Parse("::ffff:192.168.0.4");
NetworkAddress activeNetworkAddressFour = new NetworkAddress(activeIpAddressFour, 80);
List <Tuple <NetworkAddress, DateTimeOffset> > testDataSet = new List <Tuple <NetworkAddress, DateTimeOffset> >()
{
new Tuple <NetworkAddress, DateTimeOffset> (activeNetworkAddressOne, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(10)),
new Tuple <NetworkAddress, DateTimeOffset>(activeNetworkAddressTwo, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(20)),
new Tuple <NetworkAddress, DateTimeOffset>(activeNetworkAddressThree, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(30)),
new Tuple <NetworkAddress, DateTimeOffset>(activeNetworkAddressFour, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(40))
};
IPeerAddressManager peerAddressManager = this.CreateTestPeerAddressManager(testDataSet);
IMasterFile spiedMasterFile = null;
Mock <IDnsServer> mockDnsServer = new Mock <IDnsServer>();
mockDnsServer.Setup(d => d.SwapMasterfile(It.IsAny <IMasterFile>()))
.Callback <IMasterFile>(m =>
{
spiedMasterFile = m;
})
.Verifiable();
NodeSettings nodeSettings = NodeSettings.Default();
nodeSettings.DnsPeerBlacklistThresholdInSeconds = inactiveTimePeriod;
nodeSettings.DnsHostName = "stratis.test.com";
WhitelistManager whitelistManager = new WhitelistManager(dateTimeProvider, loggerFactory, peerAddressManager, mockDnsServer.Object, nodeSettings);
// Act.
whitelistManager.RefreshWhitelist();
// Assert.
spiedMasterFile.Should().NotBeNull();
Question question = new Question(new Domain(nodeSettings.DnsHostName), RecordType.AAAA);
IList <IResourceRecord> resourceRecords = spiedMasterFile.Get(question);
resourceRecords.Should().NotBeNullOrEmpty();
IList <IPAddressResourceRecord> ipAddressResourceRecords = resourceRecords.OfType <IPAddressResourceRecord>().ToList();
ipAddressResourceRecords.Should().HaveSameCount(testDataSet);
foreach (Tuple <NetworkAddress, DateTimeOffset> testData in testDataSet)
{
ipAddressResourceRecords.SingleOrDefault(i => i.IPAddress.Equals(testData.Item1.Endpoint.Address)).Should().NotBeNull();
}
}
public void Then_the_results_are_correct()
{
actual.Should().NotBeNull();
actual.Count.Should().Be(1);
actual.First().Genre.Should().Be("Romance");
}
public async Task TestDataExportImport()
{
// Arrange
var firstSubscriptionCriteria = new SubscriptionSearchCriteria {
Take = 0, ResponseGroup = SubscriptionResponseGroup.Default.ToString()
};
var firstSubscriptionResult = new SubscriptionSearchResult {
TotalCount = TestSubscriptions.Count
};
_subscriptionSearchService
.Setup(subscriptionSearchService => subscriptionSearchService.SearchSubscriptionsAsync(firstSubscriptionCriteria))
.ReturnsAsync(firstSubscriptionResult);
var secondSubscriptionCriteria = new SubscriptionSearchCriteria {
Skip = 0, Take = ExpectedBatchSize, ResponseGroup = SubscriptionResponseGroup.Default.ToString()
};
var secondSubscriptionResult = new SubscriptionSearchResult {
TotalCount = TestSubscriptions.Count, Results = TestSubscriptions
};
_subscriptionSearchService
.Setup(subscriptionSearchService => subscriptionSearchService.SearchSubscriptionsAsync(secondSubscriptionCriteria))
.ReturnsAsync(secondSubscriptionResult);
var firstPaymentPlanCriteria = new PaymentPlanSearchCriteria {
Take = 0
};
var firstPaymentPlanResult = new PaymentPlanSearchResult {
TotalCount = TestPaymentPlans.Count
};
_paymentPlanSearchService.Setup(service => service.SearchPlansAsync(firstPaymentPlanCriteria))
.ReturnsAsync(firstPaymentPlanResult);
var secondPaymentPlanCriteria = new PaymentPlanSearchCriteria {
Skip = 0, Take = ExpectedBatchSize
};
var secondPaymentPlanResult = new PaymentPlanSearchResult {
TotalCount = TestPaymentPlans.Count, Results = TestPaymentPlans
};
_paymentPlanSearchService.Setup(service => service.SearchPlansAsync(secondPaymentPlanCriteria))
.ReturnsAsync(secondPaymentPlanResult);
Subscription[] actualSubscriptions = null;
_subscriptionService.Setup(service => service.SaveSubscriptionsAsync(It.IsAny <Subscription[]>()))
.Callback <Subscription[]>(subscriptions => actualSubscriptions = subscriptions)
.Returns(Task.CompletedTask);
PaymentPlan[] actualPaymentPlans = null;
_paymentPlanService.Setup(service => service.SavePlansAsync(It.IsAny <PaymentPlan[]>()))
.Callback <PaymentPlan[]>(paymentPlans => actualPaymentPlans = paymentPlans)
.Returns(Task.CompletedTask);
// Act
string actualJson;
using (var targetStream = new MemoryStream())
{
await _subscriptionExportImport.DoExportAsync(targetStream, IgnoreProgressInfo, _cancellationToken.Object);
// DoExportAsync() closes targetStream, so extracting data from it is a bit tricky...
var streamContents = targetStream.ToArray();
using (var copiedStream = new MemoryStream(streamContents))
using (var textReader = new StreamReader(copiedStream))
{
actualJson = await textReader.ReadToEndAsync();
}
}
var importStream = GetStreamFromString(actualJson);
await _subscriptionExportImport.DoImportAsync(importStream, IgnoreProgressInfo, _cancellationToken.Object);
//Assert
TestSubscriptions.Should().BeEquivalentTo(actualSubscriptions);
TestPaymentPlans.Should().BeEquivalentTo(actualPaymentPlans);
}
public void ThenErrorsShouldBeAsExpected() => _result.Should().BeEquivalentTo(_expectedErrors);
public void WhenRefreshWhitelist_AndOwnIPInPeers_AndAreRunningFullNode_ThenWhitelistDoesContainOwnIP()
{
// Arrange.
Mock <IDateTimeProvider> mockDateTimeProvider = new Mock <IDateTimeProvider>();
Mock <ILogger> mockLogger = new Mock <ILogger>();
Mock <ILoggerFactory> mockLoggerFactory = new Mock <ILoggerFactory>();
mockLoggerFactory.Setup(l => l.CreateLogger(It.IsAny <string>())).Returns(mockLogger.Object);
ILoggerFactory loggerFactory = mockLoggerFactory.Object;
mockDateTimeProvider.Setup(d => d.GetTimeOffset()).Returns(new DateTimeOffset(new DateTime(2017, 8, 30, 1, 2, 3))).Verifiable();
IDateTimeProvider dateTimeProvider = mockDateTimeProvider.Object;
int inactiveTimePeriod = 5000;
IPAddress activeIpAddressOne = IPAddress.Parse("::ffff:192.168.0.1");
var activeEndpointOne = new IPEndPoint(activeIpAddressOne, 80);
IPAddress activeIpAddressTwo = IPAddress.Parse("::ffff:192.168.0.2");
var activeEndpointTwo = new IPEndPoint(activeIpAddressTwo, 80);
IPAddress activeIpAddressThree = IPAddress.Parse("::ffff:192.168.0.3");
var activeEndpointThree = new IPEndPoint(activeIpAddressThree, 80);
IPAddress externalIPAdress = IPAddress.Parse("::ffff:192.168.99.99");
int externalPort = 80;
var externalEndpoint = new IPEndPoint(externalIPAdress, externalPort);
var activeTestDataSet = new List <Tuple <IPEndPoint, DateTimeOffset> >()
{
new Tuple <IPEndPoint, DateTimeOffset> (activeEndpointOne, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(10)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointTwo, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(20)),
new Tuple <IPEndPoint, DateTimeOffset>(activeEndpointThree, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(30)),
new Tuple <IPEndPoint, DateTimeOffset> (externalEndpoint, dateTimeProvider.GetTimeOffset().AddSeconds(-inactiveTimePeriod).AddSeconds(40))
};
IPeerAddressManager peerAddressManager = this.CreateTestPeerAddressManager(activeTestDataSet);
string[] args = new string[] {
$"-dnspeeractivethreshold={inactiveTimePeriod.ToString()}",
$"-externalip={externalEndpoint.Address.ToString()}",
$"-port={externalPort.ToString()}",
};
IMasterFile spiedMasterFile = null;
Mock <IDnsServer> mockDnsServer = new Mock <IDnsServer>();
mockDnsServer.Setup(d => d.SwapMasterfile(It.IsAny <IMasterFile>()))
.Callback <IMasterFile>(m =>
{
spiedMasterFile = m;
})
.Verifiable();
Network network = Network.StratisTest;
NodeSettings nodeSettings = new NodeSettings(network, args: args);
DnsSettings dnsSettings = new Mock <DnsSettings>().Object;
dnsSettings.DnsFullNode = true;
dnsSettings.DnsPeerBlacklistThresholdInSeconds = inactiveTimePeriod;
dnsSettings.DnsHostName = "stratis.test.com";
ConnectionManagerSettings connectionSettings = new ConnectionManagerSettings();
connectionSettings.Load(nodeSettings);
WhitelistManager whitelistManager = new WhitelistManager(dateTimeProvider, loggerFactory, peerAddressManager, mockDnsServer.Object, connectionSettings, dnsSettings);
// Act.
whitelistManager.RefreshWhitelist();
// Assert.
spiedMasterFile.Should().NotBeNull();
Question question = new Question(new Domain(dnsSettings.DnsHostName), RecordType.A);
IList <IResourceRecord> resourceRecords = spiedMasterFile.Get(question);
resourceRecords.Should().NotBeNullOrEmpty();
IList <IPAddressResourceRecord> ipAddressResourceRecords = resourceRecords.OfType <IPAddressResourceRecord>().ToList();
ipAddressResourceRecords.Should().HaveSameCount(activeTestDataSet);
foreach (Tuple <IPEndPoint, DateTimeOffset> testData in activeTestDataSet)
{
ipAddressResourceRecords.SingleOrDefault(i => i.IPAddress.Equals(testData.Item1.Address.MapToIPv4())).Should().NotBeNull();
}
}
private static void AssertTextDoesNotAppearInLog(string text, IList <string> logEntries)
{
logEntries.Should().NotContain(e => e.IndexOf(text, StringComparison.OrdinalIgnoreCase) > -1,
"Specified text should not appear anywhere in the log file: {0}", text);
}
private void ValidateTorrentResult(IList<ReleaseInfo> reports, bool hasSize = false, bool hasInfoUrl = false, bool hasMagnet = false)
{
reports.Should().OnlyContain(c => c.GetType() == typeof(TorrentInfo));
ValidateResult(reports, hasSize, hasInfoUrl);
reports.Should().OnlyContain(c => c.DownloadProtocol == DownloadProtocol.Torrent);
if (hasMagnet)
{
reports.Cast<TorrentInfo>().Should().OnlyContain(c => c.MagnetUrl.StartsWith("magnet:"));
}
}
public void ThenResultShouldBeAsExpected() => _participantIds.Should().BeEquivalentTo(_conversationParticipants.Select(participant => participant.UserId).ToList());
public void ParseZeroBuildInfoFromNotFullBuildInfosInTriageIssue(string body)
{
IList <TriageItem> result = _sut.GetTriageItems(body);
result.Should().BeEmpty();
}
RegisterNewUserCommand_WithValidEmail_HasValidEmail_MustReturnSuccess()
{
//Arrange
DomainEvent.Register <DomainNotification>(dn => _notifications.Add(dn));
var registerNewUserCommand = (UserRegisterCommand) new UserRegisterCommandBuilder()
.WithEmail("*****@*****.**");
//Act
//Assert
registerNewUserCommand.HasValidEmail().Should().BeTrue();
_notifications.Should().BeEmpty();
}
