public void Should_exclude_nhibernate_assemblies()
{
CollectionAssert.AreEquivalent(new string[0],
foundAssemblies.Where(a => a.FullName.ToLower().StartsWith("nhibernate")).ToArray());
}
private void AssertSplitEquivalent(string name, params string[] words)
{
CollectionAssert.AreEquivalent(name.SplitCamelCaseToWords().ToList(), words);
}
public ConfigurationTransformTestCaseBuilder BeTransFormedBy(params string[] transformFiles)
{
CollectionAssert.AreEquivalent(transformFiles, mostRecentResult);
return(this);
}
public void MultipleStronglyConnectedComponents()
{
var edge12 = new Edge <int>(1, 2);
var edge23 = new Edge <int>(2, 3);
var edge24 = new Edge <int>(2, 4);
var edge25 = new Edge <int>(2, 5);
var edge31 = new Edge <int>(3, 1);
var edge34 = new Edge <int>(3, 4);
var edge46 = new Edge <int>(4, 6);
var edge56 = new Edge <int>(5, 6);
var edge57 = new Edge <int>(5, 7);
var edge64 = new Edge <int>(6, 4);
var edge75 = new Edge <int>(7, 5);
var edge78 = new Edge <int>(7, 8);
var edge86 = new Edge <int>(8, 6);
var edge87 = new Edge <int>(8, 7);
var graph = new AdjacencyGraph <int, Edge <int> >();
graph.AddVerticesAndEdgeRange(new[]
{
edge12, edge23, edge24, edge25, edge31, edge34, edge46,
edge56, edge57, edge64, edge75, edge78, edge86, edge87
});
graph.AddVertex(10);
IMutableBidirectionalGraph <AdjacencyGraph <int, Edge <int> >, CondensedEdge <int, Edge <int>, AdjacencyGraph <int, Edge <int> > > > condensedGraph =
graph.CondensateStronglyConnected <int, Edge <int>, AdjacencyGraph <int, Edge <int> > >();
Assert.IsNotNull(condensedGraph);
Assert.AreEqual(4, condensedGraph.VertexCount);
Assert.AreEqual(3, condensedGraph.EdgeCount);
// Condensed edge
CollectionAssert.AreEquivalent(
new[] { edge56, edge86 },
condensedGraph.Edges.ElementAt(0).Edges);
CollectionAssert.AreEquivalent(
new[] { edge24, edge34 },
condensedGraph.Edges.ElementAt(1).Edges);
CollectionAssert.AreEquivalent(
new[] { edge25 },
condensedGraph.Edges.ElementAt(2).Edges);
// Components
CollectionAssert.AreEquivalent(
new[] { 4, 6 },
condensedGraph.Vertices.ElementAt(0).Vertices);
CollectionAssert.AreEquivalent(
new[] { edge46, edge64 },
condensedGraph.Vertices.ElementAt(0).Edges);
CollectionAssert.AreEquivalent(
new[] { 5, 7, 8 },
condensedGraph.Vertices.ElementAt(1).Vertices);
CollectionAssert.AreEquivalent(
new[] { edge57, edge75, edge78, edge87 },
condensedGraph.Vertices.ElementAt(1).Edges);
CollectionAssert.AreEquivalent(
new[] { 1, 2, 3 },
condensedGraph.Vertices.ElementAt(2).Vertices);
CollectionAssert.AreEquivalent(
new[] { edge12, edge23, edge31 },
condensedGraph.Vertices.ElementAt(2).Edges);
CollectionAssert.AreEquivalent(
new[] { 10 },
condensedGraph.Vertices.ElementAt(3).Vertices);
CollectionAssert.IsEmpty(condensedGraph.Vertices.ElementAt(3).Edges);
}
public static void EnsureAllTypesAreMapped() => CollectionAssert.AreEquivalent(Enum.GetValues(typeof(ClickHouseTypeCode)), TypeConverter.RegisteredTypes.Distinct());
public static void MatchesUnsorted <T>(this IEnumerable <T> actual, IEnumerable <T> expected)
{
CollectionAssert.AreEquivalent(expected.ToArray(), actual.ToArray(), $"{Environment.NewLine}expected:{expected.Join()}{Environment.NewLine}actual :{actual.Join()}{Environment.NewLine}");
}
public void TestListAll()
{
_mockStore1.Setup(x => x.ListAll()).Returns(new[] { _digest1 });
_mockStore2.Setup(x => x.ListAll()).Returns(new[] { _digest2 });
CollectionAssert.AreEquivalent(new[] { _digest1, _digest2 }, _testStore.ListAll(), "Should combine results from all stores");
}
private async Task ProducerConsumerMultithreadedTest(
int producerTotalCount,
int producerChunkCount,
int consumerTotalCount,
int consumerChunkCount)
{
var producerBuffer = new byte[producerTotalCount];
var consumerBuffer = new byte[consumerTotalCount];
var random = new Random();
random.NextBytes(producerBuffer);
int producerPosition = 0;
int consumerPosition = 0;
using (var ct = new CancellationTokenSource())
{
using (var s = new PayloadStream(null))
{
Func <Task> reader = async() =>
{
while (consumerPosition < consumerBuffer.Length)
{
int readCount = Math.Min(consumerChunkCount, consumerBuffer.Length - consumerPosition);
var bytesRead = await s.ReadAsync(consumerBuffer, consumerPosition, readCount, ct.Token);
if (bytesRead == 0)
{
break;
}
consumerPosition += bytesRead;
}
};
Func <Task> writer = async() =>
{
while (producerPosition < producerBuffer.Length)
{
int writeCount = Math.Min(producerChunkCount, producerBuffer.Length - producerPosition);
await s.WriteAsync(producerBuffer, producerPosition, writeCount, ct.Token);
producerPosition += writeCount;
await Task.Yield();
}
};
var readTask = reader();
var writetask = writer();
await Task.WhenAll(readTask, writetask);
}
}
Assert.AreEqual(producerTotalCount, producerPosition);
var consumableCount = Math.Min(producerTotalCount, consumerTotalCount);
Assert.AreEqual(consumableCount, consumerPosition);
CollectionAssert.AreEquivalent(producerBuffer.Take(consumableCount).ToArray(), consumerBuffer.Take(consumableCount).ToArray());
}
public void GetMemberNames_NewExpression()
{
var actual = ExpressionHelper.GetMemberNames(((Expression <Func <dynamic> >)(() => new { Col1 = "1", Col4 = "4" })).Body).ToArray();
CollectionAssert.AreEquivalent(new[] { "Col1", "Col4" }, actual);
}
public void WithSpaceFixedColumnWidthLineSplit()
{
ILineSplitter splitter = new FixedColumnWidthLineSplitter(-2, -5, -3, -6);
CollectionAssert.AreEquivalent(new[] { "2 ", "5 ", "3 ", "6 " }, splitter.Split("2 5 3 6 ").ToArray());
}
public void TokenAwarePolicyReturnsLocalReplicasFirst()
{
var hostList = new List <Host>
{
//5 local nodes and 4 remote
TestHelper.CreateHost("0.0.0.1", "dc1"),
TestHelper.CreateHost("0.0.0.2", "dc1"),
TestHelper.CreateHost("0.0.0.3", "dc2"),
TestHelper.CreateHost("0.0.0.4", "dc2"),
TestHelper.CreateHost("0.0.0.5", "dc1"),
TestHelper.CreateHost("0.0.0.6", "dc1"),
TestHelper.CreateHost("0.0.0.7", "dc2"),
TestHelper.CreateHost("0.0.0.8", "dc2"),
TestHelper.CreateHost("0.0.0.9", "dc1")
};
var n = 2;
var clusterMock = new Mock <ICluster>();
clusterMock
.Setup(c => c.AllHosts())
.Returns(hostList)
.Verifiable();
clusterMock
.Setup(c => c.GetReplicas(It.IsAny <string>(), It.IsAny <byte[]>()))
.Returns <string, byte[]>((keyspace, key) =>
{
var i = key[0];
return(hostList.Where(h =>
{
//The host at with address == k || address == k + n
var address = TestHelper.GetLastAddressByte(h);
return address == i || address == i + n;
}).ToList());
})
.Verifiable();
var policy = new TokenAwarePolicy(new DCAwareRoundRobinPolicy("dc1", 2));
policy.Initialize(clusterMock.Object);
//key for host :::1 and :::3
var k = new RoutingKey {
RawRoutingKey = new byte[] { 1 }
};
var hosts = policy.NewQueryPlan(null, new SimpleStatement().SetRoutingKey(k)).ToList();
//5 local hosts + 2 remote hosts
Assert.AreEqual(7, hosts.Count);
//local replica first
Assert.AreEqual(1, TestHelper.GetLastAddressByte(hosts[0]));
clusterMock.Verify();
//key for host :::2 and :::5
k = new RoutingKey {
RawRoutingKey = new byte[] { 2 }
};
n = 3;
hosts = policy.NewQueryPlan(null, new SimpleStatement().SetRoutingKey(k)).ToList();
Assert.AreEqual(7, hosts.Count);
//local replicas first
CollectionAssert.AreEquivalent(new[] { 2, 5 }, hosts.Take(2).Select(TestHelper.GetLastAddressByte));
//next should be local nodes
Assert.AreEqual("dc1", hosts[2].Datacenter);
Assert.AreEqual("dc1", hosts[3].Datacenter);
Assert.AreEqual("dc1", hosts[4].Datacenter);
clusterMock.Verify();
}
public void FixedColumnWidthLineSplit()
{
ILineSplitter splitter = new FixedColumnWidthLineSplitter(2, 5, 3, 6);
CollectionAssert.AreEquivalent(new[] { "22", "55555", "333", "666666" }, splitter.Split("2255555333666666").ToArray());
}
public void VerifyRevisionCount()
{
CollectionAssert.AreEquivalent(new[] { 1 }, AuditReader().GetRevisions(typeof(ContainedEntity), cce1_id));
CollectionAssert.AreEquivalent(new[] { 1 }, AuditReader().GetRevisions(typeof(SetEntity), cse1_id));
}
[Test] public void LoadPlugins()
{
//
// In this test, we're going to check overall LoadPlugins behavior,
// as well as the specific case of selective loading, where non-editor
// plugins and non-plugins are filtered out before loading.
//
using (MockPluginLoader pluginLoader = new MockPluginLoader())
{
// Set up some mock data for available assemblies
MockAssembly[] mockPlugins = new MockAssembly[]
{
new MockAssembly("MockDir/MockPluginA.editor.dll", typeof(MockEditorPlugin)),
new MockAssembly("MockDir/MockPluginB.editor.dll", typeof(MockEditorPlugin)),
new MockAssembly("MockDir2/MockPluginC.editor.dll", typeof(MockEditorPlugin))
};
MockAssembly[] mockNoise = new MockAssembly[]
{
new MockAssembly("MockDir/MockAuxillaryA.dll"),
new MockAssembly("MockDir/MockPluginD.core.dll", typeof(MockEditorPlugin)),
new MockAssembly("MockDir/MockPluginE.editor.dll"),
new MockAssembly("MockDir2/MockAuxillaryB.dll", typeof(MockEditorPlugin)),
MockAssembly.CreateInvalid("MockDir2/MockPluginF.editor.dll"),
MockAssembly.CreateInvalid("MockDir2/MockAuxillaryC.dll")
};
string[] mockLoadedPaths = new string[] {
mockPlugins[0].Location, mockPlugins[1].Location, mockPlugins[2].Location,
mockNoise[2].Location, mockNoise[4].Location
};
pluginLoader.AddBaseDir("MockDir");
pluginLoader.AddBaseDir("MockDir2");
for (int i = 0; i < mockPlugins.Length; i++)
{
pluginLoader.AddPlugin(mockPlugins[i]);
}
for (int i = 0; i < mockNoise.Length; i++)
{
pluginLoader.AddPlugin(mockNoise[i]);
}
pluginLoader.AddIncompatibleDll("MockDir2/MockAuxillaryD.dll");
// Set up a plugin manager using the mock loader
EditorPluginManager pluginManager = new EditorPluginManager();
pluginManager.Init(pluginLoader);
// Load all plugins
pluginManager.LoadPlugins();
EditorPlugin[] loadedPlugins = pluginManager.LoadedPlugins.ToArray();
// Assert that we loaded all expected plugins, but nothing more
Assert.AreEqual(3, loadedPlugins.Length);
CollectionAssert.AreEquivalent(mockPlugins, loadedPlugins.Select(plugin => plugin.PluginAssembly));
// Assert that we properly assigned all plugin properties
Assert.IsTrue(loadedPlugins.All(plugin => plugin.AssemblyName == plugin.PluginAssembly.GetShortAssemblyName()));
// Assert that we loaded core plugin and auxilliary libraries, but not editor plugins
CollectionAssert.AreEquivalent(
mockLoadedPaths,
pluginLoader.LoadedAssemblies);
// Assert that we can access all assemblies and types from plugins
foreach (MockAssembly mockAssembly in mockPlugins)
{
CollectionAssert.Contains(pluginManager.GetAssemblies(), mockAssembly);
}
CollectionAssert.Contains(pluginManager.GetTypes(typeof(object)), typeof(MockEditorPlugin));
Assert.AreEqual(3, pluginManager.GetTypes(typeof(MockEditorPlugin)).Count());
pluginManager.Terminate();
}
}
public void GetAzureStoreAddOnAvailableAddOnsSuccessfull()
{
// Setup
List <WindowsAzureOffer> actualWindowsAzureOffers = new List <WindowsAzureOffer>();
mockCommandRuntime.Setup(f => f.WriteObject(It.IsAny <object>(), true))
.Callback <object, bool>((o, b) => actualWindowsAzureOffers = (List <WindowsAzureOffer>)o);
List <Plan> plans = new List <Plan>();
plans.Add(new Plan()
{
PlanIdentifier = "Bronze"
});
plans.Add(new Plan()
{
PlanIdentifier = "Silver"
});
plans.Add(new Plan()
{
PlanIdentifier = "Gold"
});
plans.Add(new Plan()
{
PlanIdentifier = "Silver"
});
plans.Add(new Plan()
{
PlanIdentifier = "Gold"
});
List <Offer> expectedOffers = new List <Offer>()
{
new Offer()
{
ProviderIdentifier = "Microsoft", OfferIdentifier = "Bing Translate",
ProviderId = new Guid("f8ede0df-591f-4722-b646-e5eb86f0ae52")
},
new Offer()
{
ProviderIdentifier = "NotExistingCompany", OfferIdentifier = "Not Existing Name",
ProviderId = new Guid("723138c2-0676-4bf6-80d4-0af31479dac4")
},
new Offer()
{
ProviderIdentifier = "OneSDKCompany", OfferIdentifier = "Windows Azure PowerShell",
ProviderId = new Guid("1441f7f7-33a1-4dcf-aeea-8ed8bc1b2e3d")
}
};
List <WindowsAzureOffer> expectedWindowsAzureOffers = new List <WindowsAzureOffer>();
expectedOffers.ForEach(o => expectedWindowsAzureOffers.Add(new WindowsAzureOffer(
o,
plans,
new List <string>()
{
"West US", "East US"
})));
mockMarketplaceClient.Setup(f => f.GetAvailableWindowsAzureOffers(It.IsAny <string>()))
.Returns(expectedWindowsAzureOffers);
mockMarketplaceClient.Setup(f => f.IsKnownProvider(It.IsAny <Guid>())).Returns(true);
mockStoreClient.Setup(f => f.GetLocations())
.Returns(new List <Location>()
{
new Location()
{
Name = "West US"
},
new Location()
{
Name = "East US"
}
});
cmdlet.ListAvailable = true;
// Test
cmdlet.ExecuteCmdlet();
// Assert
mockMarketplaceClient.Verify(f => f.GetAvailableWindowsAzureOffers(null), Times.Once());
CollectionAssert.AreEquivalent(expectedWindowsAzureOffers, actualWindowsAzureOffers);
}
public void Ctor_ShouldInitLayoutsCorrectly_WhenRequired()
{
CollectionAssert.AreEquivalent(new[] { LayoutDescriptor.Simple, LayoutDescriptor.Pattern }, mSut.Layouts);
}
public void TestSimpleBlockchainSplit()
{
using (var daemon1 = new TestDaemon())
{
// add some simple blocks
var block1 = daemon1.MineAndAddEmptyBlock(daemon1.GenesisBlock);
var block2 = daemon1.MineAndAddEmptyBlock(block1);
// introduce a tie split
var block3a = daemon1.MineAndAddEmptyBlock(block2);
var block3b = daemon1.MineAndAddEmptyBlock(block2);
// check that 3a is current as it was first
daemon1.WaitForDaemon();
AssertMethods.AssertDaemonAtBlock(3, block3a.Hash, daemon1.BlockchainDaemon);
// continue split
var block4a = daemon1.MineAndAddEmptyBlock(block3a);
var block4b = daemon1.MineAndAddEmptyBlock(block3b);
// check that 4a is current as it was first
daemon1.WaitForDaemon();
AssertMethods.AssertDaemonAtBlock(4, block4a.Hash, daemon1.BlockchainDaemon);
// resolve tie split, with other chain winning
var block5b = daemon1.MineAndAddEmptyBlock(block4b);
// check that blockchain reorged to the winning chain
daemon1.WaitForDaemon();
AssertMethods.AssertDaemonAtBlock(5, block5b.Hash, daemon1.BlockchainDaemon);
// continue on winning fork
var block6b = daemon1.MineAndAddEmptyBlock(block5b);
// check that blockchain continued on the winning chain
daemon1.WaitForDaemon();
AssertMethods.AssertDaemonAtBlock(6, block6b.Hash, daemon1.BlockchainDaemon);
// create a second blockchain, reusing the genesis from the first
using (var daemon2 = new TestDaemon(daemon1.GenesisBlock))
{
// add only the winning blocks to the second blockchain
daemon2.AddBlock(block1);
daemon2.AddBlock(block2);
daemon2.AddBlock(block3b);
daemon2.AddBlock(block4b);
daemon2.AddBlock(block5b);
daemon2.AddBlock(block6b);
// check second blockchain
daemon2.WaitForDaemon();
AssertMethods.AssertDaemonAtBlock(6, block6b.Hash, daemon2.BlockchainDaemon);
// verify that re-organized blockchain matches winning-only blockchain
using (var expectedChainSate = daemon2.BlockchainDaemon.GetChainState())
using (var actualChainSate = daemon1.BlockchainDaemon.GetChainState())
{
var expectedUtxo = expectedChainSate.Utxo;
var expectedUnspentTransactions = ImmutableDictionary.CreateRange <UInt256, UnspentTx>(expectedUtxo.GetUnspentTransactions());
var expectedUnspentOutputs = ImmutableDictionary.CreateRange <TxOutputKey, TxOutput>(expectedUtxo.GetUnspentOutputs());
var actualUtxo = actualChainSate.Utxo;
var actualUnspentTransactions = ImmutableDictionary.CreateRange <UInt256, UnspentTx>(actualUtxo.GetUnspentTransactions());
var actualUnspentOutputs = ImmutableDictionary.CreateRange <TxOutputKey, TxOutput>(actualUtxo.GetUnspentOutputs());
CollectionAssert.AreEquivalent(expectedUnspentTransactions, actualUnspentTransactions);
CollectionAssert.AreEquivalent(expectedUnspentOutputs, actualUnspentOutputs);
}
}
}
}
public void Ctor_ShouldInitLayoutsCorrectly_WhenNotRequired()
{
mSut = new Layout(new ReadOnlyCollection <IProperty>(new List <IProperty>()), mHistoryManager, false);
CollectionAssert.AreEquivalent(new[] { LayoutDescriptor.None, LayoutDescriptor.Simple, LayoutDescriptor.Pattern }, mSut.Layouts);
}
public void TestRuleValuesReturnsProperTags()
{
var item = new ContainsComparer();
CollectionAssert.AreEquivalent(new[] { "contains" }, item.RuleKeys.ToList());
}
public void VerifyRevisionCount()
{
CollectionAssert.AreEquivalent(new[] { 1, 2 }, AuditReader().GetRevisions(typeof(PrimitiveCustomTypeEntity), pctec_id));
}
public void TestListAllTemp()
{
_mockStore1.Setup(x => x.ListAllTemp()).Returns(new[] { "abc" });
_mockStore2.Setup(x => x.ListAllTemp()).Returns(new[] { "def" });
CollectionAssert.AreEquivalent(new[] { "abc", "def" }, _testStore.ListAllTemp(), "Should combine results from all stores");
}
public void getLessonByGroup()
{
CollectionAssert.AreEquivalent(ct.GetLessonByGroup(ld.group), ldl);
}
public void FeedTest()
{
var feed1 = new Feed();
feed1.FeedType = FeedType.News;
feed1.Caption = "aaa";
feed1.Text = "bbb";
var feed1Id = feedStorage.SaveFeed(feed1, TODO, TODO).Id;
feedStorage.SaveFeed(feed1, TODO, TODO);
var feed2 = new Feed();
feed2.FeedType = FeedType.Order;
feed2.Caption = "ccca";
feed2.Text = "ddd";
var feed2Id = feedStorage.SaveFeed(feed2, TODO, TODO).Id;
var feeds = feedStorage.GetFeeds(FeedType.News, Guid.Empty, 0, 0);
CollectionAssert.AreEquivalent(new[] { feed1 }, feeds);
feeds = feedStorage.GetFeeds(FeedType.Order, Guid.Empty, 0, 0);
CollectionAssert.AreEquivalent(new[] { feed2 }, feeds);
feeds = feedStorage.GetFeeds(FeedType.Advert, Guid.Empty, 0, 0);
CollectionAssert.IsEmpty(feeds);
feeds = feedStorage.GetFeeds(FeedType.All, Guid.NewGuid(), 0, 0);
CollectionAssert.IsEmpty(feeds);
feeds = feedStorage.SearchFeeds("c", FeedType.All, Guid.Empty, 0, 0);
CollectionAssert.AreEquivalent(new[] { feed2 }, feeds);
feeds = feedStorage.SearchFeeds("a");
CollectionAssert.AreEquivalent(new[] { feed1, feed2 }, feeds);
var feedTypes = feedStorage.GetUsedFeedTypes();
CollectionAssert.AreEquivalent(new[] { FeedType.News, FeedType.Order }, feedTypes);
feed2 = feedStorage.GetFeed(feed2Id);
Assert.IsAssignableFrom(typeof(FeedNews), feed2);
Assert.AreEqual(FeedType.Order, feed2.FeedType);
Assert.AreEqual("ccca", feed2.Caption);
Assert.AreEqual("ddd", feed2.Text);
var c1 = new FeedComment(feed1Id)
{
Comment = "c1", Inactive = true
};
var c2 = new FeedComment(feed1Id)
{
Comment = "c2"
};
var c3 = new FeedComment(feed2Id)
{
Comment = "c3"
};
var c1Id = feedStorage.SaveFeedComment(c1).Id;
var c2Id = feedStorage.SaveFeedComment(c2).Id;
feedStorage.SaveFeedComment(c3);
feedStorage.SaveFeedComment(c3);
var comments = feedStorage.GetFeedComments(feed2Id);
CollectionAssert.AreEquivalent(new[] { c3 }, comments);
comments = feedStorage.GetFeedComments(feed1Id);
CollectionAssert.AreEquivalent(new[] { c1, c2 }, comments);
feedStorage.RemoveFeedComment(c2Id);
comments = feedStorage.GetFeedComments(feed1Id);
CollectionAssert.AreEquivalent(new[] { c1 }, comments);
c1 = feedStorage.GetFeedComment(c1Id);
Assert.AreEqual("c1", c1.Comment);
Assert.IsTrue(c1.Inactive);
feedStorage.ReadFeed(feed2Id, SecurityContext.CurrentAccount.ID.ToString());
feedStorage.RemoveFeed(feed2Id);
feedStorage.RemoveFeed(feed1Id);
feed1 = feedStorage.GetFeed(feed1Id);
Assert.IsNull(feed1);
comments = feedStorage.GetFeedComments(feed1Id);
CollectionAssert.IsEmpty(comments);
}
public void getLessonByTeacher()
{
CollectionAssert.AreEquivalent(ct.GetLessonByTeacher(ld.teacher), ldl);
}
public void VerifyRevisionCounts()
{
CollectionAssert.AreEquivalent(new[] { 1, 2 }, AuditReader().GetRevisions(typeof(StrTestEntity), id));
}
public void getLessonByAuditory()
{
CollectionAssert.AreEquivalent(ct.GetLessonByAuditory(ld.auditory), ldl);
}
public void VerifyRevisionCount()
{
CollectionAssert.AreEquivalent(new[] { 1, 2 }, AuditReader().GetRevisions(typeof(OptimisticLockEntity), id));
}
public void getLessonByDiscipline()
{
CollectionAssert.AreEquivalent(ct.GetLessonByDiscipline(ld.discipline), ldl);
}
public async Task ItShouldChargeAllNecessaryUsers()
{
this.timestampCreator.SetupSequence(v => v.Now()).Returns(Now1).Returns(Now2);
this.guidCreator.SetupSequence(v => v.CreateSqlSequential()).Returns(TransactionReference1.Value).Returns(TransactionReference2.Value);
var userId1 = UserId.Random();
var userId2 = UserId.Random();
var userId3 = UserId.Random();
var userId4 = UserId.Random();
var userId5 = UserId.Random();
var input = new List <CalculatedAccountBalanceResult>
{
new CalculatedAccountBalanceResult(DateTime.UtcNow, UserId.Random(), LedgerAccountType.FifthweekCredit, TopUpUserAccountsWithCredit.MinimumAccountBalanceBeforeCharge),
new CalculatedAccountBalanceResult(DateTime.UtcNow, UserId.Random(), LedgerAccountType.Stripe, 0),
new CalculatedAccountBalanceResult(DateTime.UtcNow, userId1, LedgerAccountType.FifthweekCredit, TopUpUserAccountsWithCredit.MinimumAccountBalanceBeforeCharge - 1),
new CalculatedAccountBalanceResult(DateTime.UtcNow, userId2, LedgerAccountType.FifthweekCredit, -1m),
};
var usersRequiringRetry = new List <UserId> {
userId3, userId4, userId5
};
this.getUsersRequiringPaymentRetry.Setup(v => v.ExecuteAsync()).ReturnsAsync(usersRequiringRetry);
var usersRequiringCharge = new List <UserId> {
userId1, userId2, userId3, userId4, userId5
};
this.incrementPaymentStatus.Setup(v => v.ExecuteAsync(It.IsAny <IReadOnlyList <UserId> >()))
.Callback <IReadOnlyList <UserId> >(v => CollectionAssert.AreEquivalent(usersRequiringCharge, v.ToList()))
.Returns(Task.FromResult(0)).Verifiable();
this.getUserWeeklySubscriptionsCost.Setup(v => v.ExecuteAsync(userId1)).ReturnsAsync(TopUpUserAccountsWithCredit.MinimumPaymentAmount - 1);
this.getUserWeeklySubscriptionsCost.Setup(v => v.ExecuteAsync(userId2)).ReturnsAsync(TopUpUserAccountsWithCredit.MinimumPaymentAmount + 1);
this.getUserWeeklySubscriptionsCost.Setup(v => v.ExecuteAsync(userId3)).ReturnsAsync(0);
this.getUserWeeklySubscriptionsCost.Setup(v => v.ExecuteAsync(userId4)).ReturnsAsync(TopUpUserAccountsWithCredit.MinimumPaymentAmount * 2);
this.getUserWeeklySubscriptionsCost.Setup(v => v.ExecuteAsync(userId5)).ReturnsAsync(TopUpUserAccountsWithCredit.MinimumPaymentAmount * 2);
this.getUserPaymentOrigin.Setup(v => v.ExecuteAsync(userId1))
.ReturnsAsync(new UserPaymentOriginResult("customer1", PaymentOriginKeyType.Stripe, null, null, null, null, PaymentStatus.Retry1));
this.getUserPaymentOrigin.Setup(v => v.ExecuteAsync(userId2))
.ReturnsAsync(new UserPaymentOriginResult("customer2", PaymentOriginKeyType.Stripe, null, null, null, null, PaymentStatus.Retry1));
// Test PaymentOriginKeyType with no key.
this.getUserPaymentOrigin.Setup(v => v.ExecuteAsync(userId4))
.ReturnsAsync(new UserPaymentOriginResult(null, PaymentOriginKeyType.Stripe, null, null, null, null, PaymentStatus.Retry1));
this.getUserPaymentOrigin.Setup(v => v.ExecuteAsync(userId5))
.ReturnsAsync(new UserPaymentOriginResult("customer5", PaymentOriginKeyType.Stripe, null, null, null, null, PaymentStatus.None));
this.applyUserCredit.Setup(v => v.ExecuteAsync(userId1, Now1, TransactionReference1, PositiveInt.Parse(TopUpUserAccountsWithCredit.MinimumPaymentAmount), null, UserType.StandardUser))
.Returns(Task.FromResult(0))
.Verifiable();
this.applyUserCredit.Setup(v => v.ExecuteAsync(userId2, Now2, TransactionReference2, PositiveInt.Parse(TopUpUserAccountsWithCredit.MinimumPaymentAmount + 1), null, UserType.StandardUser))
.Returns(Task.FromResult(0))
.Verifiable();
var result = await this.target.ExecuteAsync(input, new List <PaymentProcessingException>(), CancellationToken.None);
this.incrementPaymentStatus.Verify();
this.applyUserCredit.Verify();
Assert.IsTrue(result);
}
public void Should_exclude_system_assemblies()
{
CollectionAssert.AreEquivalent(new string[0],
foundAssemblies.Where(a => a.FullName.StartsWith("System")).ToArray());
}