public void DeleteAll()
{
IList <Party> userParties =
PartyTestData.CreateParties(NumberOfPartiesToCreate, true);
IList <Party> botParties =
PartyTestData.CreateParties(NumberOfPartiesToCreate, true);
IList <Party> aggregationParties =
PartyTestData.CreateParties(NumberOfPartiesToCreate, false);
// TODO: Connections
foreach (IRoutingDataManager routingDataManager in _routingDataManagers)
{
Trace.WriteLine($"--- Starting test \"{GetCurrentMethodName()}\" for {routingDataManager.GetType().Name}");
foreach (Party party in userParties)
{
routingDataManager.AddParty(party, true);
}
foreach (Party party in botParties)
{
routingDataManager.AddParty(party, false);
}
foreach (Party party in aggregationParties)
{
routingDataManager.AddAggregationParty(party);
}
Assert.AreEqual((int)NumberOfPartiesToCreate, routingDataManager.GetUserParties().Count);
Assert.AreEqual((int)NumberOfPartiesToCreate, routingDataManager.GetBotParties().Count);
Assert.AreEqual((int)NumberOfPartiesToCreate, routingDataManager.GetAggregationParties().Count);
// TODO: Connections
routingDataManager.DeleteAll();
Assert.AreEqual(0, routingDataManager.GetUserParties().Count);
Assert.AreEqual(0, routingDataManager.GetBotParties().Count);
Assert.AreEqual(0, routingDataManager.GetAggregationParties().Count);
Assert.AreEqual(0, routingDataManager.GetConnectedParties().Count);
Trace.WriteLine($"--- Test \"{GetCurrentMethodName()}\" done for {routingDataManager.GetType().Name}");
}
}
private void AddAndRemovePartiesValidData(PartyType partyType)
{
IList <Party> parties =
PartyTestData.CreateParties(
NumberOfPartiesToCreate, (partyType != PartyType.Aggregation));
int numberOPartiesExpected = 0;
foreach (IRoutingDataManager routingDataManager in _routingDataManagers)
{
Trace.WriteLine($"--- Starting test \"{GetCurrentMethodName()}\" for {routingDataManager.GetType().Name}");
int currentActualPartyCount = 0;
foreach (Party party in parties)
{
bool wasAdded = false;
switch (partyType)
{
case PartyType.User:
case PartyType.Bot:
wasAdded = routingDataManager.AddParty(party, (partyType == PartyType.User));
currentActualPartyCount = (partyType == PartyType.User)
? routingDataManager.GetUserParties().Count
: routingDataManager.GetBotParties().Count;
break;
case PartyType.Aggregation:
wasAdded = routingDataManager.AddAggregationParty(party);
currentActualPartyCount = routingDataManager.GetAggregationParties().Count;
break;
}
numberOPartiesExpected++;
Assert.AreEqual(true, wasAdded);
Assert.AreEqual(numberOPartiesExpected, currentActualPartyCount);
if (partyType == PartyType.Aggregation)
{
Assert.AreEqual(true, routingDataManager.IsAssociatedWithAggregation(party));
}
}
// Try adding duplicates
foreach (Party party in parties)
{
bool wasAdded = false;
switch (partyType)
{
case PartyType.User:
case PartyType.Bot:
wasAdded = routingDataManager.AddParty(party, (partyType == PartyType.User));
break;
case PartyType.Aggregation:
wasAdded = routingDataManager.AddAggregationParty(party);
break;
}
Assert.AreEqual(false, wasAdded);
}
// Since duplicates should not be added, the number should stay the same
Assert.AreEqual(numberOPartiesExpected, currentActualPartyCount);
numberOPartiesExpected = currentActualPartyCount;
if (numberOPartiesExpected > 0)
{
foreach (Party party in parties)
{
switch (partyType)
{
case PartyType.User:
case PartyType.Bot:
IList <MessageRouterResult> messageRouterResults =
messageRouterResults = routingDataManager.RemoveParty(party);
// The party had no pending requests and no connections so the only
// outcome should be a result with OK indicating the party was
// removed successfully
Assert.AreEqual(1, messageRouterResults.Count);
Assert.AreEqual(MessageRouterResultType.OK, messageRouterResults[0].Type);
currentActualPartyCount = (partyType == PartyType.User)
? routingDataManager.GetUserParties().Count
: routingDataManager.GetBotParties().Count;
break;
case PartyType.Aggregation:
bool wasRemoved = routingDataManager.RemoveAggregationParty(party);
Assert.AreEqual(true, wasRemoved);
currentActualPartyCount = routingDataManager.GetAggregationParties().Count;
break;
}
numberOPartiesExpected--;
Assert.AreEqual(numberOPartiesExpected, currentActualPartyCount);
}
}
else
{
Assert.Fail($"The storage does not contain any parties - cannot hence test removal");
}
Trace.WriteLine($"--- Test \"{GetCurrentMethodName()}\" done for {routingDataManager.GetType().Name}");
}
}
public void ConnectAndDisconnectValidData()
{
int numberOfEachClientAndOwnerParties = (int)NumberOfPartiesToCreate / 2;
IList <Party> clientParties =
PartyTestData.CreateParties((uint)numberOfEachClientAndOwnerParties, true);
IList <Party> ownerParties =
PartyTestData.CreateParties((uint)numberOfEachClientAndOwnerParties, true);
IList <Party> connectedClientParties = new List <Party>();
IList <Party> connectedOwnerParties = new List <Party>();
foreach (IRoutingDataManager routingDataManager in _routingDataManagers)
{
Trace.WriteLine($"--- Starting test \"{GetCurrentMethodName()}\" for {routingDataManager.GetType().Name}");
// 1. No pending requests (should be successful anyhow)
for (int i = 0; i < numberOfEachClientAndOwnerParties; ++i)
{
DateTime expectedConnectionEstablishedTime =
(_globalTimeProvider as TestGlobalTimeProvider).NextDateTimeToProvide;
MessageRouterResult messageRouterResult =
routingDataManager.ConnectAndClearPendingRequest(ownerParties[i], clientParties[i]);
Assert.AreEqual(MessageRouterResultType.Connected, messageRouterResult.Type);
Assert.AreNotEqual(null, messageRouterResult.ConversationClientParty);
Assert.AreNotEqual(null, messageRouterResult.ConversationOwnerParty);
connectedClientParties.Add(messageRouterResult.ConversationClientParty);
connectedOwnerParties.Add(messageRouterResult.ConversationOwnerParty);
Dictionary <Party, Party> connectedParties = routingDataManager.GetConnectedParties();
Assert.AreEqual((i + 1), connectedParties.Count);
bool conversationClientPartyWasFound = false;
foreach (Party conversationClientParty in connectedParties.Values)
{
if (conversationClientParty.Equals(messageRouterResult.ConversationClientParty))
{
Assert.AreEqual(
expectedConnectionEstablishedTime,
conversationClientParty.ConnectionEstablishedTime);
conversationClientPartyWasFound = true;
break;
}
}
Assert.AreEqual(true, conversationClientPartyWasFound);
}
Assert.AreEqual(numberOfEachClientAndOwnerParties, routingDataManager.GetConnectedParties().Count);
foreach (Party conversationOwnerParty in connectedOwnerParties)
{
Assert.AreEqual(true, routingDataManager.IsConnected(conversationOwnerParty, ConnectionProfile.Owner));
}
foreach (Party conversationClientParty in connectedClientParties)
{
Assert.AreEqual(true, routingDataManager.IsConnected(conversationClientParty, ConnectionProfile.Client));
}
foreach (Party conversationOwnerParty in connectedOwnerParties)
{
IList <MessageRouterResult> messageRouterResults =
routingDataManager.Disconnect(conversationOwnerParty, ConnectionProfile.Owner);
foreach (MessageRouterResult messageRouterResult in messageRouterResults)
{
Assert.AreEqual(MessageRouterResultType.Disconnected, messageRouterResult.Type);
}
}
Assert.AreEqual(0, routingDataManager.GetConnectedParties().Count);
foreach (Party conversationOwnerParty in connectedOwnerParties)
{
Assert.AreEqual(false, routingDataManager.IsConnected(conversationOwnerParty, ConnectionProfile.Owner));
}
foreach (Party conversationClientParty in connectedClientParties)
{
Assert.AreEqual(false, routingDataManager.IsConnected(conversationClientParty, ConnectionProfile.Client));
}
connectedClientParties.Clear();
connectedOwnerParties.Clear();
// 2. With pending requests
for (int i = 0; i < numberOfEachClientAndOwnerParties; ++i)
{
MessageRouterResult messageRouterResult =
routingDataManager.AddPendingRequest(clientParties[i], false);
Assert.AreEqual(MessageRouterResultType.ConnectionRequested, messageRouterResult.Type);
Assert.AreEqual(1, routingDataManager.GetPendingRequests().Count);
messageRouterResult =
routingDataManager.ConnectAndClearPendingRequest(ownerParties[i], clientParties[i]);
Assert.AreNotEqual(null, messageRouterResult.ConversationClientParty);
connectedClientParties.Add(messageRouterResult.ConversationClientParty);
Assert.AreEqual(MessageRouterResultType.Connected, messageRouterResult.Type);
Assert.AreEqual(0, routingDataManager.GetPendingRequests().Count);
}
Assert.AreEqual(numberOfEachClientAndOwnerParties, routingDataManager.GetConnectedParties().Count);
for (int i = 0; i < connectedClientParties.Count; ++i)
{
Party conversationClientParty = connectedClientParties[i];
if (i % 2 == 0)
{
// Disconnect this time by using the client instead of the owner
IList <MessageRouterResult> messageRouterResults =
routingDataManager.Disconnect(conversationClientParty, ConnectionProfile.Client);
foreach (MessageRouterResult messageRouterResult in messageRouterResults)
{
Assert.AreEqual(MessageRouterResultType.Disconnected, messageRouterResult.Type);
}
}
else
{
// Removing the client party should do a disconnect too
IList <MessageRouterResult> messageRouterResults =
routingDataManager.RemoveParty(conversationClientParty);
bool wasDisconnected = false;
foreach (MessageRouterResult messageRouterResult in messageRouterResults)
{
if (messageRouterResult.Type == MessageRouterResultType.Disconnected)
{
wasDisconnected = true;
break;
}
}
Assert.AreEqual(true, wasDisconnected);
}
}
Assert.AreEqual(0, routingDataManager.GetConnectedParties().Count);
connectedClientParties.Clear();
Trace.WriteLine($"--- Test \"{GetCurrentMethodName()}\" done for {routingDataManager.GetType().Name}");
}
}
public void AddAndRemovePendingRequestValidData()
{
IList <Party> userParties =
PartyTestData.CreateParties(NumberOfPartiesToCreate, true);
foreach (IRoutingDataManager routingDataManager in _routingDataManagers)
{
Trace.WriteLine($"--- Starting test \"{GetCurrentMethodName()}\" for {routingDataManager.GetType().Name}");
foreach (Party party in userParties)
{
DateTime expectedConnectionRequestTime =
(_globalTimeProvider as TestGlobalTimeProvider).NextDateTimeToProvide;
MessageRouterResult messageRouterResult =
routingDataManager.AddPendingRequest(party, false);
Assert.AreEqual(MessageRouterResultType.ConnectionRequested, messageRouterResult.Type);
Assert.AreEqual(party, messageRouterResult.ConversationClientParty);
IList <Party> pendingRequests = routingDataManager.GetPendingRequests();
if (pendingRequests.Count > 0)
{
Assert.AreEqual(
expectedConnectionRequestTime,
pendingRequests[pendingRequests.Count - 1].ConnectionRequestTime);
}
else
{
Assert.Fail("No pending requests although we just should have successfully added one");
}
}
Assert.AreEqual((int)NumberOfPartiesToCreate, routingDataManager.GetPendingRequests().Count);
// The requestor parties should've been added to the list of user parties as well
Assert.AreEqual((int)NumberOfPartiesToCreate, routingDataManager.GetUserParties().Count);
// Try to add duplicates
foreach (Party party in userParties)
{
MessageRouterResult messageRouterResult =
routingDataManager.AddPendingRequest(party, false);
Assert.AreEqual(MessageRouterResultType.ConnectionAlreadyRequested, messageRouterResult.Type);
Assert.AreEqual(party, messageRouterResult.ConversationClientParty);
}
// We should still have the original number
Assert.AreEqual((int)NumberOfPartiesToCreate, routingDataManager.GetPendingRequests().Count);
IList <Party> userPartiesInStorage = routingDataManager.GetUserParties();
int numberOfPartiesRemovedFromUserParties = 0;
for (int i = 0; i < NumberOfPartiesToCreate; ++i)
{
if (i % 2 == 0)
{
MessageRouterResult messageRouterResult =
routingDataManager.RemovePendingRequest(userParties[i]);
Assert.AreEqual(MessageRouterResultType.ConnectionRejected, messageRouterResult.Type);
Assert.AreEqual(userParties[i], messageRouterResult.ConversationClientParty);
}
else
{
// RemoveParty() should also remove the pending request
routingDataManager.RemoveParty(userParties[i]);
numberOfPartiesRemovedFromUserParties++;
}
}
Assert.AreEqual(0, routingDataManager.GetPendingRequests().Count);
Assert.AreEqual(
(int)(NumberOfPartiesToCreate - numberOfPartiesRemovedFromUserParties),
routingDataManager.GetUserParties().Count);
Trace.WriteLine($"--- Test \"{GetCurrentMethodName()}\" done for {routingDataManager.GetType().Name}");
}
}
