public AddExchangeResults CanAddExchangesTests(CanAddExchangesTestData testData)
{
var proposal = new DiplomaticProposal(BuildCivilization(), BuildCivilization());
foreach (var offer in testData.OfferedBySender)
{
proposal.AddAsOffer(BuildExchange(offer));
}
foreach (var demand in testData.DemandedOfReceiver)
{
proposal.AddAsDemand(BuildExchange(demand));
}
foreach (var bilateral in testData.BilateralExchanges)
{
proposal.AddAsBilateralExchange(BuildExchange(bilateral));
}
var newExchange = BuildExchange(testData.ExchangeToAdd);
return(new AddExchangeResults()
{
CanAddAsOffer = proposal.CanAddAsOffer(newExchange),
CanAddAsDemand = proposal.CanAddAsDemand(newExchange),
CanAddAsBilateral = proposal.CanAddAsBilateralExchange(newExchange),
});
}
public IDiplomaticProposal DecomposeProposal(SerializableProposalData proposalData)
{
var sender = CivFactory.AllCivilizations.Where(civ => civ.Template.Name.Equals(proposalData.Sender)).FirstOrDefault();
var receiver = CivFactory.AllCivilizations.Where(civ => civ.Template.Name.Equals(proposalData.Receiver)).FirstOrDefault();
if (sender == null)
{
throw new InvalidOperationException("Could not find a sender of the specified name");
}
if (receiver == null)
{
throw new InvalidOperationException("Could not find a receiver of the specified name");
}
var retval = new DiplomaticProposal(sender, receiver);
foreach (var offerData in proposalData.OfferedBySender)
{
retval.AddAsOffer(ExchangeComposer.DecomposeExchange(offerData));
}
foreach (var demandData in proposalData.DemandedOfReceiver)
{
retval.AddAsDemand(ExchangeComposer.DecomposeExchange(demandData));
}
foreach (var bilateralData in proposalData.BilateralExchanges)
{
retval.AddAsBilateralExchange(ExchangeComposer.DecomposeExchange(bilateralData));
}
return(retval);
}
public bool CanPerformProposalTests(CanPerformProposalTestData testData)
{
var sender = BuildCivilization();
var receiver = BuildCivilization();
var proposal = new DiplomaticProposal(sender, receiver);
foreach (var offer in testData.OfferedBySender)
{
var mockExchange = BuildMockExchange();
proposal.AddAsOffer(mockExchange.Object);
mockExchange.Setup(
exchange => exchange.CanExecuteBetweenCivs(sender, receiver)
).Returns(offer.CanBeExecuted);
}
foreach (var demand in testData.DemandedOfReceiver)
{
var mockExchange = BuildMockExchange();
proposal.AddAsDemand(mockExchange.Object);
mockExchange.Setup(
exchange => exchange.CanExecuteBetweenCivs(receiver, sender)
).Returns(demand.CanBeExecuted);
}
foreach (var bilateral in testData.BilateralExchanges)
{
var mockExchange = BuildMockExchange();
proposal.AddAsBilateralExchange(mockExchange.Object);
mockExchange.Setup(
exchange => exchange.CanExecuteBetweenCivs(sender, receiver)
).Returns(bilateral.CanBeExecuted);
}
return(proposal.CanPerformProposal());
}
public void PerformProposal_AllExchangesExecuted()
{
var sender = BuildCivilization();
var receiver = BuildCivilization();
var proposal = new DiplomaticProposal(sender, receiver);
var nonDemandExchangeMocks = new List <Mock <IDiplomaticExchange> >();
var demandExchangeMocks = new List <Mock <IDiplomaticExchange> >();
for (int i = 0; i < 3; i++)
{
var mockOffer = BuildMockExchange();
var mockDemand = BuildMockExchange();
var mockBilateral = BuildMockExchange();
proposal.AddAsOffer(mockOffer.Object);
proposal.AddAsDemand(mockDemand.Object);
proposal.AddAsBilateralExchange(mockBilateral.Object);
nonDemandExchangeMocks.Add(mockOffer);
nonDemandExchangeMocks.Add(mockBilateral);
demandExchangeMocks.Add(mockDemand);
}
proposal.PerformProposal();
foreach (var exchangeMock in nonDemandExchangeMocks)
{
exchangeMock.Verify(exchange => exchange.ExecuteBetweenCivs(sender, receiver), Times.Once);
}
foreach (var exchangeMock in demandExchangeMocks)
{
exchangeMock.Verify(exchange => exchange.ExecuteBetweenCivs(receiver, sender), Times.Once);
}
}
