internal static IPlayerStatistics PlayerStatisticsStubFor(string name)
{
var stub = new StubBuilder();
var playerIdentityStub = stub.Setup <IPlayerIdentity>()
.Get(pi => pi.Name).Returns(name).Out;
return(stub.Setup <IPlayerStatistics>()
.Get(ps => ps.PlayerIdentity).Returns(playerIdentityStub).Out);
}
public void A_Init()
{
var stub = new StubBuilder();
var valuedHoleCards1 = stub.Setup <IValuedHoleCards>()
.Get(vhc => vhc.ChenValue).Returns(1)
.Get(vhc => vhc.SklanskyMalmuthGrouping).Returns(1).Out;
var valuedHoleCards2 = stub.Setup <IValuedHoleCards>()
.Get(vhc => vhc.ChenValue).Returns(2)
.Get(vhc => vhc.SklanskyMalmuthGrouping).Returns(3).Out;
_sut = new ValuedHoleCardsAverage();
_sut.InitializeWith(new [] { valuedHoleCards1, valuedHoleCards2 });
}
static Mock <IPokerHandParser> ParserThatRecognizesAndSeparatesHandsAndParseSetsAquiredHandTo(ulong gameId)
{
const string extractedHistory = "someHistory";
const int extractedGameId = 1;
var extractedHistories = new Dictionary <ulong, string> {
{ extractedGameId, extractedHistory }
};
Mock <IPokerHandParser> stubParser =
ParserThatRecognizesHandsAndWhenExtractingHandsReturns(extractedHistories, SomeHandHistoriesString);
var stub = new StubBuilder();
IAquiredPokerHand stubAquiredHand = stub.Setup <IAquiredPokerHand>()
.Get(p => p.GameId)
.Returns(gameId).Out;
stubParser
.Setup(p => p.AquiredPokerHand)
.Returns(stubAquiredHand);
stubParser
.Setup(p => p.IsValid)
.Returns(true);
stubParser
.Setup(p => p.ParseHand(It.IsAny <string>()))
.Returns(stubParser.Object);
return(stubParser);
}
public void _Init()
{
_stub = new StubBuilder();
_convertedPlayerMake = new Constructor <IConvertedPokerPlayer>(() => new ConvertedPokerPlayer());
_container = new UnityContainer();
_container
.RegisterConstructor <IConvertedPokerAction, ConvertedPokerAction>()
.RegisterConstructor <IConvertedPokerActionWithId, ConvertedPokerActionWithId>()
.RegisterConstructor <IConvertedPokerRound, ConvertedPokerRound>()
.RegisterType <IPokerActionConverter, PokerActionConverter>()
.RegisterType <IPokerRoundsConverter, MockPokerRoundsConverter>();
_converter = (MockPokerRoundsConverter)_container.Resolve <IPokerRoundsConverter>();
_converter
.InitializeWith(
_stub.Setup <IAquiredPokerHand>()
.Get(hand => hand.TotalPot).Returns(_stub.Valid(For.TotalPot, 1.0)).Out,
_stub.Out <IConvertedPokerHand>(),
_stub.Valid(For.Pot, 1.0),
_stub.Out <double>(For.ToCall));
}
public void InitializeWith_StreetIsPreFlop_CurrentViewModelIsDetailedPreFlopStatisticsViewModel()
{
var statisticsSetStub = _stub.Setup <IActionSequenceStatisticsSet>()
.Get(s => s.Street).Returns(Streets.PreFlop)
.Out;
_sut.InitializeWith(statisticsSetStub);
_sut.CurrentViewModel.ShouldBeEqualTo(_preFlopStatisticsViewModelStub);
}
public void GetFilteredAnalyzablePlayers_FilterSet_ReturnsPlayersPassedBackByFilterMethodOfFilter()
{
IAnalyzablePokerPlayer analyzablePlayerStub1 = _stub.Setup <IAnalyzablePokerPlayer>()
.Get(ap => ap.Id).Returns(1)
.Get(ap => ap.ActionSequences).Returns(new[] { ActionSequences.PreFlopFrontRaise })
.Out;
IAnalyzablePokerPlayer analyzablePlayerStub2 = _stub.Setup <IAnalyzablePokerPlayer>()
.Get(ap => ap.Id).Returns(2)
.Get(ap => ap.ActionSequences).Returns(new[] { ActionSequences.PreFlopFrontRaise })
.Out;
_sut.AnalyzablePlayers = new List <IAnalyzablePokerPlayer> {
analyzablePlayerStub1, analyzablePlayerStub2
};
var filterStub = new Mock <IAnalyzablePokerPlayersFilter>();
filterStub
.Setup(f => f.Filter(_sut.AnalyzablePlayers))
.Returns(new List <IAnalyzablePokerPlayer> {
analyzablePlayerStub1
});
_sut.Filter = filterStub.Object;
IEnumerable <IAnalyzablePokerPlayer> filteredPlayers = _sut.GetFilteredAnalyzablePlayersInvoke();
filteredPlayers.ShouldContain(analyzablePlayerStub1);
filteredPlayers.ShouldNotContain(analyzablePlayerStub2);
}
public void _Init()
{
_stub = new StubBuilder();
_eventAggregator = new EventAggregator();
_repositoryMock = new Mock <IRepository>();
_playerIdentityStub = _stub.Setup <IPlayerIdentity>()
.Get(pi => pi.Id).Returns(Id)
.Out;
_sut = new PlayerStatisticsSut(_eventAggregator, _repositoryMock.Object);
_sut.InitializePlayer(Name, Site);
}
public void _Init()
{
_sut = new StatisticsSetSummaryViewModel();
_stub = new StubBuilder();
_statisticsSetStub = new Mock <IActionSequenceStatisticsSet>();
_cumulativePercentages = new[] { 1, 2, 3, 4, 5 };
_statisticsSetStub
.SetupGet(ss => ss.CumulativePercentagesByRow)
.Returns(_cumulativePercentages);
_actionSequenceStatisticStub = _stub.Setup <IActionSequenceStatistic>()
.Get(s => s._actionSequence).Returns(ActionSequences.HeroB).Out;
}
CalculateCumulativePercentages_TotalCount1_1_TotalCount2_1_TotalCount3_2_Sets_Perc1_25_Perc2_25_Perc3_50()
{
const int TotalCount1 = 1;
const int TotalCount2 = 1;
const int TotalCount3 = 2;
IActionSequenceStatistic statisticStub1 = _stub.Setup <IActionSequenceStatistic>()
.Get(s => s.TotalCounts).Returns(TotalCount1).Out;
IActionSequenceStatistic statisticStub2 = _stub.Setup <IActionSequenceStatistic>()
.Get(s => s.TotalCounts).Returns(TotalCount2).Out;
IActionSequenceStatistic statisticStub3 = _stub.Setup <IActionSequenceStatistic>()
.Get(s => s.TotalCounts).Returns(TotalCount3).Out;
var sut = new ActionSequenceStatisticsSetMock(
new[] { statisticStub1, statisticStub2, statisticStub3 },
_stub.Out <IPercentagesCalculator>());
sut.CalculateCumulativePercentagesInvoke();
sut.CumulativePercentagesByRow[0].ShouldBeEqualTo(25);
sut.CumulativePercentagesByRow[1].ShouldBeEqualTo(25);
sut.CumulativePercentagesByRow[2].ShouldBeEqualTo(50);
}
static Mock <IPokerHandConverter> ConverterThatReturnsConvertedHandWith(ulong extractedGameId)
{
var stub = new StubBuilder();
IConvertedPokerHand stubConvertedHand = stub.Setup <IConvertedPokerHand>()
.Get(hand => hand.GameId)
.Returns(extractedGameId).Out;
var mockConverter = new Mock <IPokerHandConverter>();
mockConverter
.Setup(c => c.ConvertAquiredHand(It.IsAny <IAquiredPokerHand>()))
.Returns(stubConvertedHand);
return(mockConverter);
}
public void UpdateWith_OneStatistic_UpdatesRowWithDataFromActionSequenceStatistic()
{
var statisticStub = _stub.Setup <IActionSequenceStatistic>()
.Get(s => s.Percentages).Returns(new[] { 1, 2 })
.Out;
_statisticsSetStub
.SetupGet(ss => ss.ActionSequenceStatistics)
.Returns(new List <IActionSequenceStatistic> {
statisticStub
});
var statisticsSetRowMock = new Mock <IStatisticsSetSummaryRowViewModel>();
_sut.Rows.Add(statisticsSetRowMock.Object);
_sut.UpdateWith(_statisticsSetStub.Object);
statisticsSetRowMock.Verify(row => row.UpdateWith(_cumulativePercentages[0], statisticStub.Percentages));
}
public void AddPlayersFrom_TwoPlayers_AddsTwoPlayers()
{
_stub.Value(For.HoleCards).Is(string.Empty);
var player1Stub = _stub.Setup <IAquiredPokerPlayer>()
.Get(p => p.Name).Returns("player1")
.Get(p => p.Holecards).Returns(_stub.Out <string>(For.HoleCards));
var player2Stub = _stub.Setup <IAquiredPokerPlayer>()
.Get(p => p.Name).Returns("player2")
.Get(p => p.Holecards).Returns(_stub.Out <string>(For.HoleCards));
_aquiredHand
.AddPlayer(player1Stub.Out)
.AddPlayer(player2Stub.Out);
_convertedHand.AddPlayersFrom(_aquiredHand, _stub.Out <double>(For.StartingPot), _convertedPlayerMake);
Assert.That(_convertedHand.Players.Count, Is.EqualTo(2));
}
public void Filter_OnlyMFilterActivated_ReturnsPlayersPassingThroughIt()
{
const int max = 1;
var inRangePlayer = _stub.Setup <IAnalyzablePokerPlayer>()
.Get(ap => ap.MBefore).Returns(max)
.Out;
var outOfRangePlayer = _stub.Setup <IAnalyzablePokerPlayer>()
.Get(ap => ap.MBefore).Returns(max + 1)
.Out;
var players = new List <IAnalyzablePokerPlayer> {
inRangePlayer, outOfRangePlayer
};
_sut.MFilter.ActivateWith(0, max);
var filteredPlayers = _sut.Filter(players);
filteredPlayers.ShouldContain(inRangePlayer);
filteredPlayers.ShouldNotContain(outOfRangePlayer);
}