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 _Init()
{
_stub = new StubBuilder();
_container = new UnityContainer()
.RegisterType <IEventAggregator, EventAggregator>()
.RegisterInstance(_stub.Out <IDatabaseSettings>())
.RegisterInstance(_stub.Out <IDataProvider>())
.RegisterInstance(_stub.Out <IDatabaseConnector>());
}
protected override IActionSequenceStatisticsSet NewActionSequenceSetStatistics(
IPercentagesCalculator percentagesCalculator,
IEnumerable <IActionSequenceStatistic> statistics,
string playerName,
Streets street,
ActionSequences actionSequence,
bool inPosition)
{
return(_stub.Out <IActionSequenceStatisticsSet>());
}
public void Constructor_DatabaseManagerFindsNoPokerTellDatabases_AvailableDatabasesIsEmpty()
{
_databaseManagerMock
.Setup(dm => dm.GetAllPokerTellDatabases())
.Returns(Enumerable.Empty <string>);
var sut = new ChooseDatabaseViewModel(_eventAggregator, _databaseManagerMock.Object, _stub.Out <IDatabaseConnector>());
Assert.That(sut.AvailableItems.Count, Is.EqualTo(0));
}
public void ChooseDatabase_DatabaseDoesNotExist_ThrowsDatabaseDoesNotExistException()
{
const bool databaseExists = false;
var databaseStub = new Mock <IManagedDatabase>();
databaseStub.Setup(db => db.DatabaseExists(DatabaseName)).Returns(databaseExists);
var manager = new DatabaseManager(databaseStub.Object, _stub.Out <IDatabaseSettings>());
Assert.Throws <DatabaseDoesNotExistException>(() => manager.ChooseDatabase(DatabaseName));
}
public void TotalCounts_FirstMatchingPlayersEmptySecondMatchingPlayersContainOne_ReturnsOne()
{
_sut.SetMatchingPlayers(new[]
{
new List <IAnalyzablePokerPlayer>(),
new List <IAnalyzablePokerPlayer> {
_stub.Out <IAnalyzablePokerPlayer>()
}
}).CalculateCounts();
_sut.TotalCounts.ShouldBeEqualTo(1);
}
public void _Init()
{
_stub = new StubBuilder();
_preFlopStatisticsViewModelStub = _stub.Out <IDetailedPreFlopStatisticsViewModel>();
_postFlopActionStatisticsViewModelStub = _stub.Out <IDetailedPostFlopHeroActsStatisticsViewModel>();
_postFlopReactionStatisticsViewModelStub = _stub.Out <IDetailedPostFlopHeroReactsStatisticsViewModel>();
_repositoryBrowserVM_Mock = new Mock <IRepositoryHandBrowserViewModel>();
_sut =
new DetailedStatisticsAnalyzerViewModel(
new Constructor <IDetailedPreFlopStatisticsViewModel>(() => _preFlopStatisticsViewModelStub),
new Constructor <IDetailedPostFlopHeroActsStatisticsViewModel>(() => _postFlopActionStatisticsViewModelStub),
new Constructor <IDetailedPostFlopHeroReactsStatisticsViewModel>(() => _postFlopReactionStatisticsViewModelStub), _repositoryBrowserVM_Mock.Object);
}
public void ProcessRound_InvalidActionType_SetsFoundActionToTrue(
[Values(Streets.PreFlop, Streets.Flop, Streets.Turn, Streets.River)] Streets street)
{
IAquiredPokerRound aquiredPokerRoundStub = new AquiredPokerRound()
.Add(new AquiredPokerAction(ActionTypes.E, _stub.Some <double>()));
// This will log an error (illegal action) after found action was set to true and not rethrow
NotLogged(
() => _converter.InvokeProcessRound(
street,
aquiredPokerRoundStub,
_stub.Out <IConvertedPokerPlayer>()));
Assert.That(_converter.FoundActionProp, Is.True);
}
public void _Init()
{
_stub = new StubBuilder();
_aquiredHand = new AquiredPokerHand().InitializeWith(
_stub.Valid(For.Site, "site"),
_stub.Out <ulong>(For.GameId),
_stub.Out <DateTime>(For.TimeStamp),
_stub.Valid(For.SB, 1.0),
_stub.Valid(For.BB, 2.0),
_stub.Valid(For.TotalPlayers, 2));
_convertedHand = new ConvertedPokerHand(_aquiredHand);
_convertedPlayerMake
= new Constructor <IConvertedPokerPlayer>(() => new ConvertedPokerPlayer());
}
public void GetAvailableProviders_NoProvidersSupported_ReturnsEmpty()
{
var dataProviders = new DataProviderInfos();
var databaseSettings = new DatabaseSettings(_stub.Out <ISettings>(), dataProviders);
IEnumerable <IDataProviderInfo> availableProviders = databaseSettings.GetAvailableProviders();
Assert.That(availableProviders.Count(), Is.EqualTo(0));
}
public void DatabaseInUseChangedEventWasRaised_AnalyzablePlayersNotEmpty_ReinitializesAnalyzablePlayers()
{
_sut.AnalyzablePlayers.Add(_stub.Out <IAnalyzablePokerPlayer>());
_eventAggregator.GetEvent <DatabaseInUseChangedEvent>()
.Publish(_stub.Out <IDataProvider>());
_sut.AnalyzablePlayers.ShouldBeEmpty();
}
public void Filter_NoFilterActivated_ReturnsAllPassedPlayers()
{
var player1 = _stub.Out <IAnalyzablePokerPlayer>();
var players = new List <IAnalyzablePokerPlayer> {
player1
};
var filteredPlayers = _sut.Filter(players);
filteredPlayers.ShouldHaveCount(players.Count);
}
public void CommitActionComandExecute_Always_PublishesUserConfirmActionEvent()
{
bool confirmActionEventWasPublished = false;
_eventAggregator
.GetEvent <UserConfirmActionEvent>()
.Subscribe(arg => confirmActionEventWasPublished = true);
var sut = new ClearDatabaseViewModel(_eventAggregator, _stub.Out <IDatabaseManager>());
sut.CommitActionCommand.Execute(null);
Assert.That(confirmActionEventWasPublished, Is.True);
}
public LiveTrackerSettingsDesignModel(ILiveTrackerSettingsXDocumentHandler xDocumentHandler)
: base(
new EventAggregator(),
xDocumentHandler,
Stub.Out <IPokerRoomSettingsDetector>(),
Stub.Out <IHandHistoryFolderAutoDetectResultsViewModel>(),
Stub.Out <IHandHistoryFolderAutoDetectResultsWindowManager>(),
Stub.Out <ILayoutAutoConfigurator>(),
Stub.Out <IPokerRoomInfoLocator>())
{
AutoTrack = true;
ShowLiveStatsWindowOnStartup = false;
ShowTableOverlay = true;
ShowMyStatistics = true;
ShowHoleCardsDuration = 5;
HandHistoryFilesPaths = new ObservableCollection <string>
{
@"C:\Program Files\PokerStars\HandHistory",
@"C:\Program Files\Full Tilt Poker\HandHistory",
@"C:\Documents and Settings\Owner.LapThor\Application Data\PokerStars\HandHistory",
};
}
public void UpdateWith_OneStatisticOneRowAddedBefore_DoesNotCreateExtraRow()
{
_statisticsSetStub
.SetupGet(ss => ss.ActionSequenceStatistics)
.Returns(new List <IActionSequenceStatistic> {
_actionSequenceStatisticStub
});
_sut.Rows.Add(_stub.Out <IStatisticsSetSummaryRowViewModel>());
_sut.UpdateWith(_statisticsSetStub.Object);
_sut.Rows.ShouldHaveCount(1);
}
public void AnalyzeUsingDataFrom_HeroXOppBHeroR_OppReraisesFourTimes_OpponentRaiseSizeIsStandardizedToFive()
{
IConvertedPokerRound sequence = "[2]X,[1]B,[2]R3.0,[1]R4.0,[2]R3.0".ToConvertedPokerRoundWithIds();
_analyzationPreparer.PrepareAnalyzationFor(sequence, HeroPosition, ActionSequences.HeroXOppBHeroR);
_sut.AnalyzeUsingDataFrom(_stub.Out <IAnalyzablePokerPlayer>(), _analyzationPreparer, true, _raiseSizes);
_sut.ConsideredRaiseSize.ShouldBeEqualTo(5);
}
public void _Init()
{
_stub = new StubBuilder();
_pokerHandDaoStub = new Mock <IConvertedPokerHandDao>();
_pokerPlayerDaoStub = new Mock <IConvertedPokerPlayerDao>();
_playerIdentityDaoStub = new Mock <IPlayerIdentityDao>();
_transactionManagerMock = new Mock <ITransactionManager>();
_transactionManagerMock
.Setup(tm => tm.BatchExecute(It.IsAny <Action <IStatelessSession> >()))
.Returns(_transactionManagerMock.Object);
_transactionManagerMock
.Setup(tm => tm.Execute(It.IsAny <Action>()))
.Returns(_transactionManagerMock.Object);
_sut = new Repository(_pokerHandDaoStub.Object,
_pokerPlayerDaoStub.Object,
_playerIdentityDaoStub.Object,
_transactionManagerMock.Object,
_stub.Out <IRepositoryParser>());
}
public void ConnectToServer_ExternalDatabaseInvalidServerConnectStringFoundInSettings_DoesNotConnectDataProvider()
{
var settingsStub = new Mock <IDatabaseSettings>();
settingsStub
.Setup(ds => ds.ProviderIsAvailable(It.IsAny <IDataProviderInfo>()))
.Returns(true);
settingsStub
.Setup(ds => ds.GetServerConnectStringFor(It.IsAny <IDataProviderInfo>()))
.Returns("invalid serverConnectString");
var sut = new DatabaseConnector(_eventAggregator, settingsStub.Object, _dataProviderMock.Object)
.InitializeWith(_stub.Out <IDataProviderInfo>())
.ConnectToServer();
_dataProviderMock.Verify(dp => dp.Connect(It.IsAny <string>(), It.IsAny <IDataProviderInfo>()), Times.Never());
}
public void CalculateCumulativePercentages_Always_InitializesCumulativePercentagesByRowToStatisticsCount()
{
var sut = new ActionSequenceStatisticsSetMock(
new[]
{
_stub.Out <IActionSequenceStatistic>(),
_stub.Out <IActionSequenceStatistic>()
},
_stub.Out <IPercentagesCalculator>());
sut.CalculateCumulativePercentagesInvoke();
sut.CumulativePercentagesByRow.ShouldHaveCount(2);
}
public void Constructor_EmptyParserList_ThrowsUnrecognizedHandHistoryFormatException()
{
Assert.Throws <ArgumentException>(
() =>
new RepositoryParser(_parsers, _stub.Out <IConstructor <IPokerHandConverter> >()));
}
public void _Init()
{
_stub = new StubBuilder();
SetupMySqlConnection("data source = localhost; user id = root; database=firstnh;");
_container = new UnityContainer()
.RegisterInstance <IEventAggregator>(new EventAggregator())
// Converted Constructors
.RegisterConstructor <IConvertedPokerAction, ConvertedPokerAction>()
.RegisterConstructor <IConvertedPokerActionWithId, ConvertedPokerActionWithId>()
.RegisterConstructor <IConvertedPokerRound, ConvertedPokerRound>()
.RegisterConstructor <IConvertedPokerPlayer, ConvertedPokerPlayer>()
.RegisterConstructor <IConvertedPokerHand, ConvertedPokerHand>()
// Daos
.RegisterType <IPlayerIdentityDao, PlayerIdentityDao>()
.RegisterType <IConvertedPokerPlayerDao, ConvertedPokerPlayerDao>()
.RegisterType <IConvertedPokerHandDao, ConvertedPokerHandDao>()
// Repository
.RegisterInstance(_stub.Out <IRepositoryParser>())
.RegisterType <ITransactionManager, TransactionManager>()
.RegisterType <IRepository, Repository>()
// Database
.RegisterInstance(_sessionFactoryManagerStub.Object)
/*
* Statistics
*/
.RegisterType <IPlayerStatistics, PlayerStatistics>()
// RaiseReactionAnalyzation
.RegisterType <IReactionAnalyzationPreparer, ReactionAnalyzationPreparer>()
.RegisterTypeAndConstructor <IRaiseReactionAnalyzer, RaiseReactionAnalyzer>()
.RegisterType <IRaiseReactionsAnalyzer, RaiseReactionsAnalyzer>()
.RegisterType <IRaiseReactionStatistics, RaiseReactionStatistics>()
.RegisterType <IRaiseReactionStatisticsBuilder, RaiseReactionStatisticsBuilder>()
// RepositoryHandBrowser
.RegisterType <IRepositoryHandBrowser, RepositoryHandBrowser>()
.RegisterType <IHandHistoryViewModel, HandHistoryViewModel>()
.RegisterType <IRepositoryHandBrowserViewModel, RepositoryHandBrowserViewModel>()
// Detailed Statistics Describers
.RegisterType <IDetailedPreFlopStatisticsDescriber, DetailedPreFlopStatisticsDescriber>()
.RegisterType <IDetailedPostFlopHeroActsStatisticsDescriber, DetailedPostFlopHeroActsStatisticsDescriber>()
.RegisterType <IDetailedPostFlopHeroReactsStatisticsDescriber, DetailedPostFlopHeroReactsStatisticsDescriber>()
// Raise Reaction Statistics Describers
.RegisterType <IPreFlopRaiseReactionDescriber, PreFlopRaiseReactionDescriber>()
.RegisterType <IPostFlopHeroActsRaiseReactionDescriber, PostFlopHeroActsRaiseReactionDescriber>()
.RegisterType <IPostFlopHeroReactsRaiseReactionDescriber, PostFlopHeroReactsRaiseReactionDescriber>()
// Raise Reaction Statistics ViewModels
.RegisterType <IPreFlopRaiseReactionStatisticsViewModel, PreFlopRaiseReactionStatisticsViewModel>()
.RegisterType <IPostFlopHeroActsRaiseReactionStatisticsViewModel, PostFlopHeroActsRaiseReactionStatisticsViewModel>()
.RegisterType <IPostFlopHeroReactsRaiseReactionStatisticsViewModel, PostFlopHeroReactsRaiseReactionStatisticsViewModel>()
// Valued HoleCards
.RegisterConstructor <IValuedHoleCards, ValuedHoleCards>()
.RegisterType <IValuedHoleCardsAverage, ValuedHoleCardsAverage>()
// Preflop HandStrength Statistics
.RegisterType <IPreFlopHandStrengthStatistics, PreFlopHandStrengthStatistics>()
// Preflop HandStrengths Statistics Describers
.RegisterType <IPreFlopUnraisedPotCallingHandStrengthDescriber, PreFlopUnraisedPotCallingHandStrengthDescriber>()
.RegisterType <IPreFlopRaisedPotCallingHandStrengthDescriber, PreFlopRaisedPotCallingHandStrengthDescriber>()
.RegisterType <IPreFlopRaisingHandStrengthDescriber, PreFlopRaisingHandStrengthDescriber>()
// Preflop HandStrengths Statistics ViewModels
.RegisterType <IPreFlopUnraisedPotCallingHandStrengthStatisticsViewModel, PreFlopUnraisedPotCallingHandStrengthStatisticsViewModel>()
.RegisterType <IPreFlopRaisedPotCallingHandStrengthStatisticsViewModel, PreFlopRaisedPotCallingHandStrengthStatisticsViewModel>()
.RegisterType <IPreFlopRaisingHandStrengthStatisticsViewModel, PreFlopRaisingHandStrengthStatisticsViewModel>()
// Preflop HandStrengths Visualizing
.RegisterType <IPreFlopStartingHandsVisualizer, PreFlopStartingHandsVisualizer>()
.RegisterType <IPreFlopStartingHandsVisualizerViewModel, PreFlopStartingHandsVisualizerViewModel>();
}
public void ConvertedRoundFrom_OneInactiveAction_ReturnsRoundWithThatAction(
[Values(ActionTypes.A, ActionTypes.F, ActionTypes.X)] ActionTypes actionType)
{
_stub.Value(For.Ratio).Is(1.0);
string csvString = actionType.ToString();
IConvertedPokerRound expectedRound = new ConvertedPokerRound()
.Add(new ConvertedPokerAction(actionType, _stub.Out <double>(For.Ratio)));
IConvertedPokerRound round = _converter.ConvertedRoundFrom(csvString);
Assert.That(round, Is.EqualTo(expectedRound));
}
public void _Init()
{
_stub = new StubBuilder();
_sut = new DetailedStatisticsViewModelImpl(_stub.Out <IRepositoryHandBrowserViewModel>(), _stub.Out <IDetailedStatisticsDescriber>());
}
public void AddViewModel_Always_SetsCurrentViewModelToAddedViewModel()
{
var addedViewModel = _stub.Out <IDetailedStatisticsViewModel>();
_sut.AddViewModel(addedViewModel)
.CurrentViewModel.ShouldBeEqualTo(addedViewModel);
}
public void InsertHand_Always_ExecutesTransaction()
{
_sut.InsertHand(_stub.Out <IConvertedPokerHand>());
_transactionManagerMock.Verify(tx => tx.Execute(It.IsAny <Action>()));
}
public void AddPlayersFrom_NoPlayers_AddsNoPlayers()
{
_convertedHand.AddPlayersFrom(_aquiredHand, _stub.Out <double>(For.StartingPot), _convertedPlayerMake);
Assert.That(_convertedHand.Players.Count, Is.EqualTo(0));
}