public void FindRoomsByCriteriaTest_level()
{
//Arrange
NoLimitHoldem config = new NoLimitHoldem();
int level = 4;
Player creator;
var expRoom = gameCenter.CreateNewRoom(level, config, out creator);
Exception expE = null;
expRoom.Preferences.Name = "test room";
TestContext.WriteLine("min level {0} max level {1}", gameCenter.Leagues.Single().MinLevel, gameCenter.Leagues.Single().MaxLevel);
//Act
var actRoom = gameCenter.FindRoomsByCriteria(45);
try
{
gameCenter.FindRoomsByCriteria(0);
Assert.Fail("exception missing");
}
catch (CrossUtility.Exceptions.RoomNotFoundException e)
{
expE = e;
}
//Assert
Assert.IsNotNull(expE);
TestContext.WriteLine("exception message: {0}", expE.Message);
Assert.AreEqual(1, actRoom.Count);
Assert.AreEqual(expRoom, actRoom.Single());
}
public void RoomTest2() // (:Player)
{
//Arrange
var player = new Player();
var expPlayer = player;
var expConfig = new NoLimitHoldem();
//Act
var actual = new Room(player);
//Assert
Assert.AreEqual(1, actual.Players.Count, "one player in new room");
Assert.AreEqual(expPlayer, actual.Players.First(), "the creator is first");
Assert.AreEqual(Player.State.Passive, player.CurrentState, "the creator is passive");
Assert.AreEqual(1, actual.PassivePlayers.Count, "one passive player");
Assert.AreEqual(0, actual.ActivePlayers.Count, "zero active players");
Assert.IsTrue(actual.PassivePlayers.Contains(expPlayer), "the creator found in passive players collection at room");
Assert.AreEqual(null, actual.CurrentHand, "current hand null");
Assert.AreEqual(false, actual.IsTableFull, "table not full");
// 8 Configurations of game-config
Assert.AreEqual(expConfig.BuyInCost, actual.Preferences.BuyInCost, "default buy in");
Assert.AreEqual(true, actual.Preferences.IsSpactatorsAllowed, "default spectators allowed");
Assert.AreEqual(expConfig.MaxNumberOfPlayers, actual.Preferences.MaxNumberOfPlayers, "default max players number");
Assert.AreEqual(expConfig.MinimumBet, actual.Preferences.MinimumBet, "minimum bet default");
Assert.AreEqual(expConfig.MinNumberOfPlayers, actual.Preferences.MinNumberOfPlayers, "min players default");
Assert.AreEqual(expConfig.Name, actual.Preferences.Name, "default name");
// TODO: idan - add assert for default game preferences.
}
public void CreateNewRoomTest()
{
//Arrange
var expPlayer = new Player()
{
Nickname = "test player"
};
var expRoom = new Room(expPlayer);
NoLimitHoldem inConfig = new NoLimitHoldem();
int inLevel = 3;
//Act
Player actCreator;
var actual = gameCenter.CreateNewRoom(inLevel, inConfig, out actCreator);
actCreator.Nickname = "test player";
//Assert
Assert.AreEqual(expPlayer, actCreator, "eq creators");
Assert.AreEqual(1, gameCenter.Rooms.Count, "rooms count");
Assert.AreEqual(1, gameCenter.Players.Count, "players count");
Assert.AreEqual(1, gameCenter.Leagues.Count, "leagues count");
Assert.AreEqual(actual, gameCenter.Rooms.First(), "room is registered");
Assert.AreEqual(expPlayer, gameCenter.Players.First(), "player is registered");
Assert.IsTrue(gameCenter.Leagues.First().Rooms.Contains(actual), "league is registered and contain room");
}
public void FindRoomsByCriteriaTest_multiple_rooms()
{
//Arrange
NoLimitHoldem config = new NoLimitHoldem();
int level = 4;
Player creator, creator2;
var expRoom = gameCenter.CreateNewRoom(level, config, out creator).Preferences.Name = "test room 1";
var expRoom2 = gameCenter.CreateNewRoom(level, config, out creator2).Preferences.Name = "test room 2";
//Act
var actual = gameCenter.FindRoomsByCriteria(25);
//Assert
Assert.AreEqual(2, actual.Count);
}
public FindRoomsByCriteriaResult FindRoomsByCriteria(FindRoomsByCriteriaRequest request)
{
var result = new FindRoomsByCriteriaResult();
try
{
// arrange search criteria
double betSize = request.Criterias.Contains(FindRoomsByCriteriaRequest.BET_SIZE) ? request.BetSize : -1;
GamePreferences preferences =
new NoLimitHoldem()
{
MaxNumberOfPlayers = request.Criterias.Contains(FindRoomsByCriteriaRequest.MAX_NUMBER_OF_PLAYERS) ? request.MaxNumberOfPlayers : -1,
AntesValue = request.Criterias.Contains(FindRoomsByCriteriaRequest.ANTES_VALUE) ? request.Antes : -1,
BuyInCost = request.Criterias.Contains(FindRoomsByCriteriaRequest.BUY_IN_COST) ? request.BuyInCost : -1,
Name = request.Criterias.Contains(FindRoomsByCriteriaRequest.NAME) ? request.Name : "",
MinimumBet = request.Criterias.Contains(FindRoomsByCriteriaRequest.MIN_BET) ? request.MinimumBet : -1,
MinNumberOfPlayers = request.Criterias.Contains(FindRoomsByCriteriaRequest.MIN_NUMBER_OF_PLAYERS) ? request.MinNumberOfPlayers : -1,
};
Player player = null;
if (request.Criterias.Contains(FindRoomsByCriteriaRequest.PLAYER))
{
player = _cache.RefreshAndGet(
Players,
request.Player,
new PlayerNotFoundException(string.Format("player id: {0} not found, please re-enter the room.", request.Player))
);
}
int level = request.Criterias.Contains(FindRoomsByCriteriaRequest.LEVEL) ? request.Level : -1;
// call search
var domainRooms = GameCenter.FindRoomsByCriteria(level, player, preferences, betSize);
// assemble result
result.Rooms = DomainRoomsToRoomsResults(domainRooms);
result.Success = true;
}
catch (PokerException e)
{
result.Success = false;
result.ErrorMessage = e.Message;
Logger.Error(e, this);
}
return(result);
}
public void Before()
{
_level = 20;
_userManager = UserManager.Instance;
_gameCenter = GameCenter.Instance;
_user = new User();
_userManager.Users.Add(_user.UserName, _user);
_securityKey = 1;
_user.Connect(_securityKey);
_ctrl = new RoomController()
{
Request = new System.Net.Http.HttpRequestMessage(),
Configuration = new System.Web.Http.HttpConfiguration()
};
_config = new NoLimitHoldem();
}
public void FindRoomsByCriteriaTest_perf_success()
{
//Arrange
var pref = new NoLimitHoldem()
{
Name = "test room",
};
Player expPlayer;
var expRoom = gameCenter.CreateNewRoom(6, pref, out expPlayer);
//Act
var actual = gameCenter.FindRoomsByCriteria(-1, null, pref);
//Assert
Assert.AreEqual(1, actual.Count);
Assert.AreEqual(expRoom, actual.Single());
}
public void PlayMoveTest()
{
//Arrange
var player1 = new Player()
{
Nickname = "test player 1", Lock = this
};
var player2 = new Player()
{
Nickname = "test player 2", Lock = this
};
var player3 = new Player()
{
Nickname = "test player 3", Lock = this
};
player1.AddMoney(500);
player2.AddMoney(350);
player3.AddMoney(600);
var activeUnfoldedPlayers = new List <Player>();
activeUnfoldedPlayers.Add(player1);
activeUnfoldedPlayers.Add(player2);
activeUnfoldedPlayers.Add(player3);
var pot = new Pot(null);
var gameConfig = new NoLimitHoldem();
var round = new Round(player2, activeUnfoldedPlayers, pot, true, gameConfig);
Exception expectedException1 = new Exception();
Exception expectedException2 = new Exception();
//Act
round.PlayMove(Round.Move.Check, 0);
var res0 = round.CurrentPlayer == player1 && round.LiveBets[player3] == 0 &&
pot.AmountToClaim == 0 && pot.Value == 0 && round.LastRaise == 0 && round.TotalRaise == 0;
round.PlayMove(Round.Move.Bet, 50);
var res1 = round.CurrentPlayer == player2 && pot.PlayersClaimPot.Contains(player1) && round.LiveBets[player1] == 50 &&
pot.AmountToClaim == 50 && pot.Value == 50 && round.LastRaise == 50 && round.TotalRaise == 50;
round.PlayMove(Round.Move.Call, 0);
var res2 = round.CurrentPlayer == player3 && pot.PlayersClaimPot.Contains(player2) && round.LiveBets[player2] == 50 &&
pot.AmountToClaim == 50 && pot.Value == 100 && round.LastRaise == 50 && round.TotalRaise == 50;
try
{
round.PlayMove(Round.Move.Raise, 20);
}
catch (GameRulesException e)
{
expectedException1 = e;
}
round.PlayMove(Round.Move.Raise, 70);
var res3 = round.CurrentPlayer == player1 && pot.PlayersClaimPot.Contains(player3) && round.LiveBets[player3] == 120 &&
pot.AmountToClaim == 120 && pot.Value == 220 && round.LastRaise == 70 && round.TotalRaise == 120;
round.PlayMove(Round.Move.Allin, 0);
var res4 = round.CurrentPlayer == player2 && pot.PlayersClaimPot.Contains(player1) && round.LiveBets[player1] == 500 &&
pot.AmountToClaim == 500 && pot.Value == 670 && round.LastRaise == 380 && round.TotalRaise == 500 &&
pot.PartialPot != null && pot.PartialPot.AmountToClaim == 0 && pot.PartialPot.Value == 0;
round.PlayMove(Round.Move.Allin, 0);
var res5 = round.CurrentPlayer == player3 && round.CurrentPot.PlayersClaimPot.Contains(player1) && round.CurrentPot.PlayersClaimPot.Contains(player2) &&
!round.CurrentPot.PartialPot.PlayersClaimPot.Contains(player2) && round.CurrentPot.PartialPot.PlayersClaimPot.Contains(player1) &&
round.LiveBets[player2] == 350 && round.CurrentPot.AmountToClaim == 350 && round.CurrentPot.Value == 820 &&
round.CurrentPot.PartialPot.Value == 150 && round.CurrentPot.PartialPot.AmountToClaim == 150;
try
{
round.PlayMove(Round.Move.Allin, 0);
}
catch (GameRulesException e)
{
expectedException2 = e;
}
round.PlayMove(Round.Move.Fold, 0);
var res6 = round.CurrentPlayer == player1 && !round.CurrentPot.PlayersClaimPot.Contains(player3) && !round.CurrentPot.PartialPot.PlayersClaimPot.Contains(player3) &&
round.LiveBets[player3] == 120 && round.CurrentPot.AmountToClaim == 350 && round.CurrentPot.Value == 820 &&
round.CurrentPot.PartialPot.Value == 150 && round.CurrentPot.PartialPot.AmountToClaim == 150;
//Assert
Assert.IsTrue(res0);
Assert.IsTrue(res1);
Assert.IsTrue(res2);
Assert.AreEqual(expectedException1.Message, "Can't raise less than last raise");
Assert.IsTrue(res3);
Assert.IsTrue(res4);
Assert.IsTrue(res5);
Assert.AreEqual(expectedException2.Message, "all-in is bigger than the highest other player's all-in... use bet\raise move");
Assert.IsTrue(res6);
}
public void RoomTest3() // (:Player, :GameConfig)
{
//Arrange
#region Arrange
var expPlayer = new Player();
const string expName = "test room 3";
const bool expIsSpecAllowed = false;
GamePreferences expGamePreferences = new NoLimitHoldem();
const int expMinPlayers = 3;
// changed parameters
const double insertBuyinCost = 50.2;
const int insertMaxNumberPlayers = 9;
const double insertMinBet = 8.6;
// expected results by the parameters
double expBuyinCost = Math.Max(insertBuyinCost, insertMinBet);
double expMinBet = Math.Min(insertMinBet, insertBuyinCost);
int expMaxNumberPlayers = insertMaxNumberPlayers;
var expConfig = new NoLimitHoldem()
{
BuyInCost = insertBuyinCost,
IsSpactatorsAllowed = expIsSpecAllowed,
MaxNumberOfPlayers = insertMaxNumberPlayers,
MinimumBet = insertMinBet,
MinNumberOfPlayers = expMinPlayers,
Name = expName,
};
#endregion
//Act
var actual = new Room(expPlayer, expConfig);
//Assert
#region Default asserts
Assert.AreEqual(1, actual.Players.Count, "one player in new room");
Assert.AreEqual(expPlayer, actual.Players.First(), "the creator is first");
Assert.AreEqual(Player.State.Passive, expPlayer.CurrentState, "the creator is passive");
Assert.AreEqual(1, actual.PassivePlayers.Count, "one passive player");
Assert.AreEqual(0, actual.ActivePlayers.Count, "zero active players");
Assert.IsTrue(actual.PassivePlayers.Contains(expPlayer), "the creator found in passive players collection at room");
Assert.AreEqual(null, actual.CurrentHand, "current hand null");
Assert.AreEqual(false, actual.IsTableFull, "table not full");
#endregion
// 8 Configurations of game-config
Assert.AreEqual <double>(expBuyinCost, actual.Preferences.BuyInCost, "exp buy in");
Assert.AreEqual(expIsSpecAllowed, actual.Preferences.IsSpactatorsAllowed, "exp spectators not allowed");
Assert.AreEqual(expMaxNumberPlayers, actual.Preferences.MaxNumberOfPlayers, "max players number");
Assert.AreEqual(expMinBet, actual.Preferences.MinimumBet, "minimum bet default");
Assert.AreEqual(expMinPlayers, actual.Preferences.MinNumberOfPlayers, "min players default");
Assert.IsFalse(actual.Preferences.MinimumBet > actual.Preferences.BuyInCost, "minBet <= buyIn");
Assert.IsNotNull(actual.Preferences.Name, "name not null");
Assert.AreEqual(expName, actual.Preferences.Name, "default name");
// TODO: idan - add assert for default game preferences.
}
public CreateNewRoomResult CreateNewRoom(CreateNewRoomRequest request)
{
var result = new CreateNewRoomResult();
try
{
var user = _cache.RefreshAndGet(
Users,
request.UserName,
new UserNotFoundException("User was not found, can't create room")
);
UserManager.SecurityCheck(request.SecurityKey, user);
Player creator = null;
Room room = null;
NoLimitHoldem noLimitPreferences = new NoLimitHoldem(request.Name, request.BuyInCost, request.MinimumBet, request.Antes,
request.MinNumberOfPlayers, request.MaxNumberOfPlayers, request.IsSpactatorsAllowed);
if (request.Limit == 0)
{
room = user.CreateNewRoom(request.Level, noLimitPreferences, out creator);
}
else if (request.Limit == -1)
{
PotLimitHoldem potPreferences = new PotLimitHoldem(noLimitPreferences);
room = user.CreateNewRoom(request.Level, potPreferences, out creator);
}
else if (request.Limit > 0)
{
LimitHoldem limitPreferences = new LimitHoldem(noLimitPreferences, request.Limit);
room = user.CreateNewRoom(request.Level, limitPreferences, out creator);
}
if (creator == null || room == null)
{
throw new WrongIOException("Limit field in the request is not valid");
}
Rooms.Add(room.GetHashCode(), room);
Players.Add(creator.GetHashCode(), creator);
result.Player = creator.GetHashCode();
result.Room = room.GetHashCode();
//Request's info
result.Name = request.Name;
result.BuyInCost = request.BuyInCost;
result.MinimumBet = request.MinimumBet;
result.Antes = request.Antes;
result.MinNumberOfPlayers = request.MinNumberOfPlayers;
result.MaxNumberOfPlayers = request.MaxNumberOfPlayers;
result.IsSpactatorsAllowed = request.IsSpactatorsAllowed;
result.Limit = request.Limit;
result.Success = true;
}
catch (PokerException e)
{
result.Success = false;
result.ErrorMessage = e.Message;
Logger.Error(e, this);
}
return(result);
}