public void CallingAddPlayerWithValidDataShouldReturnOkAndObject()
{
var model = new PlayerDto
{
Name = "Test player",
Affiliation = "umbrella"
};
var mockRepository = new Mock <IPlayerRepository>();
mockRepository.Setup(r => r.Add(It.IsAny <int>(), It.IsAny <PlayerDto>()))
.Returns <int, PlayerDto>((tournamentId, data) => new Player {
Name = data.Name, Affiliation = data.Affiliation, Active = true
});
var ctrl = new TournamentController(null, mockRepository.Object, null, null);
var result = ctrl.AddPlayer(1, model);
Assert.IsAssignableFrom <OkObjectResult>(result);
var player = (result as OkObjectResult).Value as PlayerDto;
Assert.Equal(model.Name, player.Name);
Assert.Equal(model.Affiliation, player.Affiliation);
Assert.True(player.Active);
}
public void CallingPostWithValidDataShouldReturnOkAndObject()
{
var model = new TournamentDto
{
Name = "Test tournament",
Date = DateTimeOffset.Now.AddDays(2)
};
var mockRepository = new Mock <ITournamentRepository>();
mockRepository.Setup(r => r.Add(It.IsAny <TournamentDto>()))
.Returns <TournamentDto>((data) => new Tournament {
Name = data.Name, Date = data.Date.Value
});
var ctrl = new TournamentController(mockRepository.Object, null, null, null);
var result = ctrl.CreateTournament(model);
Assert.IsAssignableFrom <OkObjectResult>(result);
var tournament = (result as OkObjectResult).Value as TournamentDto;
Assert.Equal(model.Name, tournament.Name);
Assert.Equal(model.Date.Value, tournament.Date);
}
public void FetchingMatchupsWhenThereIsAnActiveRoundShouldReturnICollectionOfMatchup()
{
var mockRepository = new Mock <IRoundRepository>();
mockRepository.Setup(r => r.GetAllMatchups(It.IsAny <int>()))
.Returns(() => new List <IGrouping <int, Matchup> >
{
new Grouping <int, Matchup>(1, new List <Matchup>
{
new Matchup
{
Id = 1,
RoundId = 1,
Player1Id = 1,
Player2Id = 2
}
})
});
mockRepository.Setup(r => r.GetScoresForTournament(It.IsAny <int>()))
.Returns(new List <Score>());
var ctrl = new TournamentController(null, null, mockRepository.Object, null);
var result = ctrl.GetMatchups(1);
Assert.IsAssignableFrom <OkObjectResult>(result);
Assert.IsAssignableFrom <IEnumerable <RoundMatchupDto> >((result as OkObjectResult).Value);
var list = (result as OkObjectResult).Value as IEnumerable <RoundMatchupDto>;
Assert.NotEmpty(list);
}
public static TournamentController getInstance()
{
if (!_Instance)
{
_Instance = new TournamentController();
}
return(_Instance);
}
public ChoosePhotoUndoable(TournamentController controller, PhotoChoice choice)
{
this.controller = controller;
this.choice = choice;
this.savedState = controller.Tournament.SaveState();
this.versionIdBefore = controller.memoryVersionId;
this.versionIdAfter = ++controller.lastVersionId;
}
public void CallingGetOnNonExistingIdShouldReturnNotFound()
{
var mockRepository = new Mock <ITournamentRepository>();
var ctrl = new TournamentController(mockRepository.Object, null, null, null);
var result = ctrl.Get(-1);
Assert.IsAssignableFrom <NotFoundResult>(result);
}
public async Task CallFilterTournamentsAsync_WhenCalled()
{
// Arrange
Mock <ITournamentService> tournamentServiceMock = new Mock <ITournamentService>();
Mock <IPDFService> pDFServiceMock = new Mock <IPDFService>();
Mock <IMemoryCache> memoryCacheMock = new Mock <IMemoryCache>();
IList <string> validFileParameters = typeof(ChampionDownloadViewModel).GetProperties().Select(p => p.Name.ToString()).ToList();
string validCollection = "champions";
string validSortOrder = string.Empty;
string validFilter = string.Empty;
int validPageNumber = 1;
int validPageSize = 10;
string validFileName = string.Empty;
byte[] validFileBytes = new byte[0];
IPagedList <Tournament> tournaments = new PagedList <Tournament>(
new List <Tournament>().AsQueryable(),
validPageNumber,
validPageSize);
IPagedList <TournamentDownloadViewModel> tournamentDownloadViewModels = new PagedList <TournamentDownloadViewModel>(
new List <TournamentDownloadViewModel>().AsQueryable(),
validPageNumber,
validPageSize);
tournamentServiceMock.Setup(mock => mock.FilterTournamentsAsync(validSortOrder, validFilter, validPageNumber, validPageSize))
.Returns(Task.FromResult(tournaments));
pDFServiceMock
.Setup(mock => mock.CreatePDF(tournamentDownloadViewModels, validFileParameters, validCollection))
.Returns(validFileName);
pDFServiceMock
.Setup(mock => mock.GetFileBytesAsync(validFileName))
.Returns(Task.FromResult(validFileBytes));
pDFServiceMock
.Setup(mock => mock.DeleteFile(validFileName));
TournamentController SUT = new TournamentController(
tournamentServiceMock.Object,
pDFServiceMock.Object,
memoryCacheMock.Object);
// Act
await SUT.Download(validSortOrder, validFilter, validPageNumber, validPageSize);
// Assert
tournamentServiceMock.Verify(mock =>
mock.FilterTournamentsAsync(validSortOrder, validFilter, validPageNumber, validPageSize),
Times.Once);
}
public void CallingAddPlayerWithInvalidDataShouldReturBadRequest()
{
var ctrl = new TournamentController(null, null, null, null);
ctrl.ModelState.AddModelError("", "Error!");
var result = ctrl.AddPlayer(1, null);
Assert.IsAssignableFrom <BadRequestResult>(result);
}
public void Constructor_ShouldCreateController_WhenNoValuesArePassed()
{
// Arrange
var controller = new TournamentController();
// Act & Assert
Assert.IsInstanceOf <TournamentController>(controller);
Assert.IsInstanceOf <IApplicationDbContext>(controller.Db);
Assert.IsInstanceOf <IClubContext>(controller.LiteDb);
}
static void Main(string[] args)
{
bool isDoubleElimination = Messenger.ReadDoubleEliminationFlag();
int numberOfPlayers = Messenger.ReadNumberOfPlayers();
string[] playerNames = Messenger.ReadNames(numberOfPlayers);
var tournament = new TournamentController(numberOfPlayers, playerNames, isDoubleElimination);
Messenger.Play(tournament);
}
public void Report_ShouldRenderDefaultView_WhenCalled()
{
// Arrange
var mockedDbContext = ContextCreator.CreateMockedApllicationDbContext();
var mockedLiteDbContext = new Mock <IClubContext>();
var controller = new TournamentController(mockedDbContext.Object, mockedLiteDbContext.Object);
// Act & Assert
Assert.IsInstanceOf <ViewAsPdf>(controller.ReportTournament(3));
}
public override void ViewDidLoad()
{
base.ViewDidLoad();
// Do any additional setup after loading the view.
tournamentController = new TournamentController(new IO(new MacFile(), new MacMessage()));
App.MainViewController = this;
}
public void AddTournament_ShouldReturn_WhenNullIsPassed()
{
// Arrange
var mockedDbContext = ContextCreator.CreateMockedApllicationDbContext();
var mockedLiteDbContext = new Mock <IClubContext>();
var controller = new TournamentController(mockedDbContext.Object, mockedLiteDbContext.Object);
// Act & Assert
controller.WithCallTo(x => x.AddTournament(null))
.ShouldRenderDefaultView();
}
public void ValidateEntryFee_SymbolInput()
{
//Arrange
TournamentController tournamentController = new TournamentController();
//Act
bool valid = tournamentController.validateEntryFee("!0") != -1;
//Assert
Assert.IsFalse(valid);
}
public void Delete_ShouldRenderDefaultView_WhenCalled()
{
// Arrange
var mockedDbContext = ContextCreator.CreateMockedApllicationDbContext();
var mockedLiteDbContext = new Mock <IClubContext>();
var controller = new TournamentController(mockedDbContext.Object, mockedLiteDbContext.Object);
// Act & Assert
controller.WithCallTo(x => x.DeleteTournament(3))
.ShouldRenderDefaultView();
}
public async void BroadcastTournamentStateChange_WhenStateChangesDueToBellCounter()
{
// Arrange
var tournamentRepositoryFake = new Mock <ITournamentRepository>();
var mapper = Helper.SetupMapper();
var tournament =
new Tournament {
Id = new Guid(),
PreplayGameId = null,
InplayGameId = null,
PostplayGameId = null,
CluesPerGame = 1,
BellCounter = 1,
BellStateLookupMatrix = new List <BellStateLookup>
{
new BellStateLookup
{
BellCounter = 1,
State = TournamentState.PrePlay
},
new BellStateLookup
{
BellCounter = 2,
State = TournamentState.InPlay
},
new BellStateLookup
{
BellCounter = 3,
State = TournamentState.InPlay
}
}
};
tournamentRepositoryFake.Setup(p => p.Get(It.IsAny <Guid>())).Returns(tournament);
var gameLogicFake = new Mock <IGameLogic>();
var tournamentLogicFake = new Mock <ITournamentLogic>();
tournamentLogicFake.Setup(t => t.AddBell(It.IsAny <Tournament>())).Returns(new TournamentStateUpdateModel {
State = TournamentState.PrePlay
});
Game g = new Game();
tournamentLogicFake.Setup(t => t.SetPreplay(It.IsAny <Tournament>(), out g)).Returns(new Tournament {
PreplayGameId = new Guid(), InplayGameId = null, PostplayGameId = null
});
var tournamentBroadcastMock = new Mock <ITournamentBroadcast>();
var tournamentController = new TournamentController(tournamentRepositoryFake.Object, mapper, gameLogicFake.Object, tournamentLogicFake.Object, tournamentBroadcastMock.Object);
// Act
var actionResult = await tournamentController.AddTournamentStateBell(new Guid());
// Assert
tournamentBroadcastMock.Verify(mocks => mocks.TournamentStateChangeAsync(It.IsAny <Guid>(), It.IsAny <TournamentState>(), It.IsAny <Guid?>(), It.IsAny <Guid?>(), It.IsAny <Guid?>()), Times.Once);
}
public void ValidateEntryFee_ValidIntegerInput()
{
//Arrange
TournamentController tournamentController = new TournamentController();
//Act
bool valid = tournamentController.validateEntryFee("100") != -1;
//Assert
Assert.IsTrue(valid);
}
public void Delete_ShouldRedirectToTurnament_WhenNullProvided()
{
// Arrange
var mockedDbContext = ContextCreator.CreateMockedApllicationDbContext();
var mockedLiteDbContext = new Mock <IClubContext>();
var controller = new TournamentController(mockedDbContext.Object, mockedLiteDbContext.Object);
// Act & Assert
controller.WithCallTo(x => x.DeleteTournament(33))
.ShouldRedirectTo(x => x.Tournaments);
}
public GameController(
ITournamentPersistence tournamentPersistence,
IOutgoingPlayerChannelFactory channelFactory,
IApplicationConfiguration applicationConfiguration,
IActionScheduler actionScheduler)
{
Tournament = tournamentPersistence.LoadTournament();
_channelFactory = channelFactory;
_applicationConfiguration = applicationConfiguration;
_actionScheduler = actionScheduler;
}
public void Tournament_ShouldReturnUpcomingPassedTournamentsViewModel_WhenCalled()
{
// Arrange
var mockedDbContext = ContextCreator.CreateMockedApllicationDbContext();
var mockedLiteDbContext = new Mock <IClubContext>();
var controller = new TournamentController(mockedDbContext.Object, mockedLiteDbContext.Object);
// Act & Assert
controller.WithCallTo(x => x.Tournaments())
.ShouldRenderDefaultView()
.WithModel <UpcomingPassedTournamentsViewModel>();
}
public void CallingPostWithInvalidInputDataShouldReturn400()
{
var mockRepository = new Mock <ITournamentRepository>();
var ctrl = new TournamentController(mockRepository.Object, null, null, null);
ctrl.ModelState.AddModelError("", "error");
var result = ctrl.CreateTournament(new TournamentDto());
Assert.IsAssignableFrom <BadRequestResult>(result);
}
public static void SaveTournament(TournamentController info)
{
BinaryFormatter bin = new BinaryFormatter();
string path = Application.persistentDataPath + "/tour.bin";
FileStream stream = new FileStream(path, FileMode.Create);
TourInfo tourData = new TourInfo(info);
bin.Serialize(stream, tourData);
stream.Close();
}
public void Can_Paginate()
{
TournamentController tournamentController = new TournamentController(GetRepositoryStub());
tournamentController.PageSize = 2;
TournamentsListViewModel result = tournamentController.List(null, 3).ViewData.Model as TournamentsListViewModel;
Tournament[] tournaments = result.Tournaments.ToArray();
Assert.True(tournaments.Length == 2); // 2 tournaments in the third page ( 2 + 2 + 2 )
Assert.Equal(5, tournaments[0].TournamentID); // order by tournament name
}
public void ReturnAnInstanceOfTournamentService_WhenDbContextAndDivisionTypeServiceArePassed()
{
//Arrange
var tournamentServiceMock = new Mock <ITournamentService>();
var divisionServiceMock = new Mock <IDivisionService>();
//Act
var controller = new TournamentController(tournamentServiceMock.Object, divisionServiceMock.Object);
//Assert
Assert.IsInstanceOfType(controller, typeof(TournamentController));
}
public PlanetDetailsTournamentsViewModule(PlanetDetailsScreen screen) : base(screen)
{
base.EvtManager.RegisterObserver(this, EventId.TournamentRedeemed, EventPriority.Default);
base.EvtManager.RegisterObserver(this, EventId.GalaxyPlanetInfoButton, EventPriority.Default);
base.EvtManager.RegisterObserver(this, EventId.ScreenClosing, EventPriority.Default);
this.tournamentController = Service.TournamentController;
this.isLoaded = false;
this.planetUpcomingTextColor = new Color(1f, 0.753f, 0f);
this.planetUpcomingTextGlowColor = new Color(0.471f, 0.353f, 0f);
this.planetActiveTextColor = new Color(0.733f, 0.075f, 0.075f);
this.planetActiveTextGlowColor = new Color(0.733f, 0.075f, 0.075f, 0.588f);
}
public void Constructor_ShouldCreateController_WhenValuesArePassed()
{
// Arrange
var mockedDbContext = ContextCreator.CreateMockedApllicationDbContext();
var mockedLiteDbContext = new Mock <IClubContext>();
var controller = new TournamentController(mockedDbContext.Object, mockedLiteDbContext.Object);
// Act & Assert
Assert.IsInstanceOf <TournamentController>(controller);
Assert.AreSame(controller.Db, mockedDbContext.Object);
Assert.AreSame(controller.LiteDb, mockedLiteDbContext.Object);
}
public void GeneratingMatchupsBeforeRoundIsFinishedShouldReturnBadRequest()
{
var matchupManagerMock = new Mock <IMatchupManager>();
matchupManagerMock.Setup(x => x.GenerateMatchups(It.IsAny <int>()))
.Throws <CantGenerateNewRoundException>();
var ctrl = new TournamentController(null, null, null, matchupManagerMock.Object);
var result = ctrl.GenerateMatchupsForNextRound(1);
Assert.IsAssignableFrom <BadRequestResult>(result);
}
public void HostTournament(string pbnTournament)
{
this.HostedTournament = TournamentLoader.LoadAsync(File.OpenRead(pbnTournament)).Result;
this.c = new TMController(this, this.HostedTournament, new ParticipantInfo()
{
ConventionCardNS = this.clients[Seats.North].teamName, ConventionCardWE = this.clients[Seats.East].teamName, MaxThinkTime = 120, UserId = Guid.NewGuid(), PlayerNames = new Participant(this.clients[Seats.North].teamName, this.clients[Seats.East].teamName, this.clients[Seats.North].teamName, this.clients[Seats.East].teamName)
}, this.EventBus);
this.allReadyForStartOfBoard = false;
this.ThinkTime[Directions.NorthSouth].Reset();
this.ThinkTime[Directions.EastWest].Reset();
this.c.StartTournament();
}
public void Can_Filter_Tournaments()
{
TournamentController tournamentController = new TournamentController(GetRepositoryStub());
tournamentController.PageSize = 2;
TournamentsListViewModel result = tournamentController.List("C", 1).ViewData.Model as TournamentsListViewModel;
Tournament[] tournaments = result.Tournaments.ToArray();
Assert.True(tournaments.Length == 2); // 2 tournaments in the "C" category
Assert.True(tournaments[0].TournamentID == 5 && tournaments[0].Category == "C");
Assert.True(tournaments[1].TournamentID == 6 && tournaments[0].Category == "C");
}
public void GetTest()
{
// Arrange
TournamentRepository tournamentRepository = new TournamentRepository();
TournamentController controller = new TournamentController(tournamentRepository);
// Act
IEnumerable <Tournament> result = controller.Get();
// Assert
Assert.IsNotNull(result);
Assert.AreNotEqual(0, result.Count());
}
