Пример #1
0
        public RoundEndPage()
        {
            InitializeComponent();

            viewModel = new RoundEndViewModel(AppContainer.Resolve <INavigationService>(), AppContainer.Resolve <IRoundRepository>(), AppContainer.Resolve <ITeamRepository>(), AppContainer.Resolve <IBackendService>());

            BindingContext = viewModel;
        }
        public void Constructor_ShouldLoadRoundAndTeam()
        {
            //Act
            var sut = new RoundEndViewModel(_navigationServiceMock.Object, _roundRepositoryMock.Object, _teamRepositoryMock.Object, _backendServiceMock.Object);

            FillInAnswers();

            //Assert
            Assert.That(sut.Round, Is.Not.Null);
            Assert.That(sut.Team, Is.Not.Null);
        }
Пример #3
0
        public async Task <IActionResult> Round(string id)
        {
            var game    = GetGame(id);
            var choices = await _choiceProvider.GetAll();

            var player = game.GetUnchocenPlayer();

            while (player != Player.None)
            {
                var playerId       = game.GetPlayerId(player);
                var playerInstance = await _playerProvider.GetPlayer(playerId);

                var viewablePlayerInstance = playerInstance as IViewablePlayer;
                if (viewablePlayerInstance != null)
                {
                    var view = await viewablePlayerInstance.View(game.GameState, choices, PlayerHelper.CreateRedirectUrl(this.Url, game.GameState, player), player);

                    return(view);
                }
                var choice = await playerInstance.GetChoice(player, game.GameState, choices);

                game.SetChoice(player, choice);
                _gameStateStorage.Save(game.GameState);
                player = game.GetUnchocenPlayer();
            }

            var winner = game.CalculateRoundWinner(choices);

            _gameStateStorage.Save(game.GameState);

            var round = game.GetCurrentRound();
            var model = new RoundEndViewModel()
            {
                Choices   = choices,
                GameState = game.GameState,
                Round     = round,
                RoundNo   = game.GameState.Rounds.Count,
                Winner    = winner
            };

            return(View("RoundEnd", model));
        }
        public void SetUp()
        {
            _round = GenerateRound();
            _team  = GenerateTeam();

            _crossConnectivityFake = new CrossConnectivityFake();
            _navigationServiceMock = new Mock <INavigationService>();
            _roundRepositoryMock   = new Mock <IRoundRepository>();
            _teamRepositoryMock    = new Mock <ITeamRepository>();
            _backendServiceMock    = new Mock <IBackendService>();
            _backendServiceMock.Setup(backend => backend.GetTeamByToken(It.IsAny <String>())).ReturnsAsync(_team);
            _backendServiceMock.Setup(backend => backend.GetRoundById(It.IsAny <Int32>(), It.IsAny <String>())).ReturnsAsync(_round);

            _receiver = new QuestionViewModel(_navigationServiceMock.Object);
            _sender   = new RoundStartViewModel(_navigationServiceMock.Object, _backendServiceMock.Object, 1);
            _sender.StartRoundCommand.Execute(null);
            _sut = new RoundEndViewModel(_navigationServiceMock.Object, _roundRepositoryMock.Object, _teamRepositoryMock.Object, _backendServiceMock.Object);

            FillInAnswers();
            Connectivity.Instance = _crossConnectivityFake;
        }