public void BinaryDeserialize_ConvertedHandWithInitializedPlayer_ReturnsSameHand()
{
var convertedHand = InitializeConvertedHandWithSomeValidValues();
convertedHand.AddPlayer(ConvertedFactory.InitializeConvertedPokerPlayerWithSomeValidValues());
Affirm.That(convertedHand.BinaryDeserializedInMemory()).IsEqualTo(convertedHand);
}
public RecordsToExtract(string tableName, string where)
{
Affirm.NotNullOrEmpty(tableName, "tableName");
TableName = tableName;
Where = where;
}
public ErrorHandlingMiddleware(RequestDelegate next, ILogger <ErrorHandlingMiddleware> logger)
{
Affirm.ArgumentNotNull(logger, "logger");
_next = next;
_logger = logger;
}
private ITransition GetNextTransition(IStateMachine sm, ISMParameters parameters)
{
Affirm.ArgumentNotNull(sm, "sm");
var possibleTransitions = sm.Definition.GetTransitions(sm.CurrentState);
if (possibleTransitions == null)
{
throw new InvalidOperationException("{0}: no transitions found {1}".FormIt(sm));
}
var triggers = possibleTransitions.Select(_ => new { trigger = _.Trigger, tran = _ }).ToList();
var theOne = triggers.Where(_ => _.trigger.Invoke(_.tran, parameters)).ToList();
if (!theOne.Any())
{
throw new NoTrueTriggerException(sm.SmId, "{0}: no true trigger result found for state {1}".FormIt(sm, sm.CurrentStateId));
}
if (theOne.Count() > 1)
{
throw new TooManyTriggersException(theOne.Select(_ => _.trigger).ToList(), sm.SmId, "{0}: too many triggers are true {1}".FormIt(sm, sm.CurrentStateId));
}
return(theOne.First().tran);
}
public IStateMachine Start(IStateMachineDefinition def, ISMParameters parameters, string key)
{
Affirm.ArgumentNotNull(key, "key");
var sm = _sMFactory.Get(key);
return(Start(def, parameters, sm));
}
public void AffirmIsEqualTo_InitializedHandsAreEqual_Passes()
{
var hand1 = InitializeConvertedHandWithSomeValidValues();
var hand2 = InitializeConvertedHandWithSomeValidValues();
Affirm.That(hand1).IsEqualTo(hand2);
}
public void BinaryDeserialized_SerializedPlayerWithSequence_ReturnsSamePlayer()
{
DecapsulatedConvertedPlayer player = ConvertedFactory.InitializeConvertedPokerPlayerWithSomeValidValues();
player.SequenceStrings = new[] { "some", "someMore" };
Affirm.That(player.BinaryDeserializedInMemory()).IsEqualTo(player);
}
public void BinaryDeserialized_SerializedPlayerWithOneEmptyRound_ReturnsSamePlayer()
{
DecapsulatedConvertedPlayer player = ConvertedFactory.InitializeConvertedPokerPlayerWithSomeValidValues();
player.Add(new ConvertedPokerRound());
Affirm.That(player.BinaryDeserializedInMemory()).IsEqualTo(player);
}
public void BinaryDeserialized_SerializedPlayerWithMBefore_ReturnsSamePlayer()
{
DecapsulatedConvertedPlayer player = ConvertedFactory.InitializeConvertedPokerPlayerWithSomeValidValues();
player.MBefore = _stub.Some(20);
Affirm.That(player.BinaryDeserializedInMemory()).IsEqualTo(player);
}
public void BinaryDeserialized_SerializedPlayerWithInPosition_ReturnsSamePlayer()
{
DecapsulatedConvertedPlayer player = ConvertedFactory.InitializeConvertedPokerPlayerWithSomeValidValues();
player.InPosition = new bool?[] { true, false, true };
Affirm.That(player.BinaryDeserializedInMemory()).IsEqualTo(player);
}
public void AffirmIsNotEqualTo_HandsAntesAreDifferent_Passes()
{
var hand1 = InitializeConvertedHandWithSomeValidValues();
var hand2 = InitializeConvertedHandWithSomeValidValues();
hand2.Ante = hand1.Ante + 1;
Affirm.That(hand1).IsNotEqualTo(hand2);
}
public IUnitOfWork GetUnitOfWork()
{
var connection = ConfigurationManager.ConnectionStrings["SourceDB"]?.ConnectionString;
Affirm.NotNullOrEmpty(connection, "Connection string can not be null or empty!");
return(GetUnitOfWork(connection));
}
public void AffirmIsNotEqualTo_HandsTableNamesAreDifferent_Passes()
{
var hand1 = InitializeConvertedHandWithSomeValidValues();
var hand2 = InitializeConvertedHandWithSomeValidValues();
hand2.TableName = hand1.TableName + "difference";
Affirm.That(hand1).IsNotEqualTo(hand2);
}
public MSSQLSourceSchema(IUnitOfWorkFactory uowf, IExtractConfiguration globalConfiguration)
{
Affirm.ArgumentNotNull(uowf, "uowf");
_uowFactory = uowf;
_globalConfiguration = globalConfiguration;
WasInit = false;
}
public void AffirmIsNotEqualTo_HandsBigBlindsAreDifferent_Passes()
{
var hand1 = InitializeConvertedHandWithSomeValidValues();
var hand2 = new ConvertedPokerHand(
hand1.Site, hand1.GameId, hand1.TimeStamp, hand1.BB + 1, hand1.SB, hand1.TotalPlayers);
Affirm.That(hand1).IsNotEqualTo(hand2);
}
/// <summary>
/// Executes action on instance of <see cref="ISMBaseElement"/>
/// </summary>
public static T Setup <T>(this T t, Action <T> action) where T : IRoot
{
Affirm.ArgumentNotNull(action, "action");
action(t);
return(t);
}
public void SetDefinition(IStateMachineDefinition definition)
{
Affirm.ArgumentNotNull(definition, "definition");
definition.Validate();
Definition = definition;
}
public void ExitState(IState state, ISMParameters parameters)
{
Affirm.ArgumentNotNull(state, "state");
if (state.ExitActions != null)
{
InvokeActionList(state, parameters, state.ExitActions);
}
}
public ObjectMetaDataProvider(IUnitOfWorkFactory uowf, ILog log, IMetaDataInitializer initializer)
{
Affirm.ArgumentNotNull(uowf, "uowf");
Affirm.ArgumentNotNull(log, "log");
_log = log;
_uowFactory = uowf;
_initializer = initializer;
}
public TableToExtract(string tableName, ExtractStrategy extractStrategy, SqlBuildStrategy sqlBuildStrategy)
{
Affirm.NotNullOrEmpty(tableName, "tableName");
Affirm.ArgumentNotNull(extractStrategy, "extractStrategy");
Affirm.ArgumentNotNull(sqlBuildStrategy, "sqlBuildStrategy");
TableName = tableName;
ExtractStrategy = extractStrategy;
SqlBuildStrategy = sqlBuildStrategy;
}
public void BinaryDeserialized_SerializedPlayerWithTwoNonEmptyRounds_ReturnsSamePlayer()
{
DecapsulatedConvertedPlayer player = ConvertedFactory.InitializeConvertedPokerPlayerWithSomeValidValues();
player.Add(
new ConvertedPokerRound()
.Add(new ConvertedPokerAction(ActionTypes.R, 2.0))
.Add(new ConvertedPokerAction(ActionTypes.C, 1.0)));
Affirm.That(player.BinaryDeserializedInMemory()).IsEqualTo(player);
}
public void Parse_PlayerHasOneActionWithoutRatio_AddsActionWithoutRatioToPlayerActions(
[Values(ActionTypes.F, ActionTypes.X)] ActionTypes actionType)
{
var aquiredPokerAction = new AquiredPokerAction(actionType, 0);
string streetHistory = OneNonRatioActionFor(PlayerName, aquiredPokerAction);
_parser.Parse(streetHistory, PlayerName);
Affirm.That(_parser.PlayerActions.First().What).IsEqualTo(aquiredPokerAction.What);
}
public void Parse_PlayerDidNotShowAndCollected_AddsWinningActionAsLastToPlayerActions()
{
const double ratio = 1.0;
var winningAction = new AquiredPokerAction(ActionTypes.W, ratio);
string streetHistory = DidNotShowAndCollectedFor(PlayerName, ratio);
_parser.Parse(streetHistory, PlayerName);
Affirm.That(_parser.PlayerActions.Last()).IsEqualTo(winningAction);
}
public void AffirmIsEqualTo_AreEqual_Passes()
{
var player1 = new ConvertedPokerPlayer {
Name = "player1"
};
var player2 = new ConvertedPokerPlayer {
Name = "player1"
};
Affirm.That(player1).IsEqualTo(player2);
}
public void AffirmIsNotEqualTo_DifferentNames_Passes()
{
IConvertedPokerPlayer player1 = new ConvertedPokerPlayer {
Name = "player1"
};
IConvertedPokerPlayer player2 = new ConvertedPokerPlayer {
Name = "player2"
};
Affirm.That(player1).IsNotEqualTo(player2);
}
public static IList <ITransition> GetTransitions(this IStateMachineDefinition def, IState state)
{
Affirm.ArgumentNotNull(state, "state");
if (def.Transitions == null)
{
return(null);
}
return(GetTransitions(def, state.id));
}
public void Parse_PlayerAllinActionAndWinningAction_AddsWinningActionAsLastToPlayerActions()
{
const double ratio = 1.0;
var winningAction = new AquiredPokerAction(ActionTypes.W, ratio);
string streetHistory = AllinBetActionFor(PlayerName, ratio) + " \n" +
ShowedAndWonFor(PlayerName, ratio);
_parser.Parse(streetHistory, PlayerName);
Affirm.That(_parser.PlayerActions.Last()).IsEqualTo(winningAction);
}
public void Parse_TwoActions_AddsSecondActionAsLastToPlayerActions()
{
var action1 = new AquiredPokerAction(ActionTypes.B, 1.0);
var action2 = new AquiredPokerAction(ActionTypes.R, 2.0);
string streetHistory = OneBetOrCallActionFor(PlayerName, action1) + " \n" +
OneRaiseActionFor(PlayerName, action2);
_parser.Parse(streetHistory, PlayerName);
Affirm.That(_parser.PlayerActions.Last()).IsEqualTo(action2);
}
public void Parse_PlayerHasOneBetOrCallAction_AddsActionWithRatioToPlayerActions(
[Values(ActionTypes.B, ActionTypes.C)] ActionTypes actionType)
{
const double someRatio = 1.0;
var aquiredPokerAction = new AquiredPokerAction(actionType, someRatio);
string streetHistory = OneBetOrCallActionFor(PlayerName, aquiredPokerAction);
_parser.Parse(streetHistory, PlayerName);
Affirm.That(_parser.PlayerActions.First()).IsEqualTo(aquiredPokerAction);
}
public PackageProcessorController(ISourceSchema schema, ILog log, ISqlBuilder sqlBuilder, IDependencyBuilder dependencyBuilder)
{
Affirm.ArgumentNotNull(schema, "schema");
Affirm.ArgumentNotNull(log, "log");
Affirm.ArgumentNotNull(sqlBuilder, "sqlBuilder");
Affirm.ArgumentNotNull(dependencyBuilder, "dependencyBuilder");
_schema = schema;
_sqlBuilder = sqlBuilder;
_log = log;
_dependencyBuilder = dependencyBuilder;
}
