Beispiel #1
0
        public async Task CreateMatch_WhenCalled_CreateNewMatch()
        {
            const int id = 1;

            var matchCreateDto = new MatchCreateDto
            {
                Round = 1
            };

            var expectedMatch = new Match
            {
                Id    = id,
                Round = 1
            };

            _matchService.Setup(m => m.GetDetailByIdAsync(It.IsAny <int>())).ReturnsAsync(expectedMatch);

            var result = await _matchesController.CreateMatch(matchCreateDto);

            var okObjectResult      = result as OkObjectResult;
            var okObjectResultValue = okObjectResult.Value as MatchDetailDto;

            _matchService.Verify(m => m.CreateAsync(It.IsAny <Match>()), Times.Once);

            Assert.That(result, Is.TypeOf <OkObjectResult>());
            Assert.That(okObjectResultValue.Round, Is.EqualTo(1));
        }
Beispiel #2
0
        public async Task DeleteMatch_WhenCalled_DeleteMatchFromDb()
        {
            const int id            = 1;
            var       expectedMatch = new Match
            {
                Id = id
            };

            _matchService.Setup(m => m.GetByIdAsync(id)).ReturnsAsync(expectedMatch);

            var result = await _matchesController.DeleteMatch(id);

            var okObjectResult = result as OkObjectResult;

            _matchService.Verify(m => m.DeleteAsync(It.IsAny <Match>()), Times.Once);

            Assert.That(result, Is.TypeOf <OkObjectResult>());
            Assert.That(okObjectResult.Value, Is.EqualTo(id));
        }
Beispiel #3
0
        public async Task GetMatch_WhenCalled_ReturnMatchFromDb()
        {
            const int id            = 1;
            var       expectedMatch = new Match
            {
                Id = id,
            };

            _matchService.Setup(m => m.GetDetailByIdAsync(id)).ReturnsAsync(expectedMatch);

            var result = await _matchesController.GetMatch(id);

            var okObjectResult      = result as OkObjectResult;
            var okObjectResultValue = okObjectResult.Value as MatchDetailDto;

            Assert.That(result, Is.TypeOf <OkObjectResult>());

            Assert.That(okObjectResultValue, Is.Not.Null);
            Assert.That(okObjectResultValue.Id, Is.EqualTo(id));
        }
Beispiel #4
0
        public async Task UpdateaMatch_WhenCalled_UpdateExistingMatch()
        {
            const int id          = 1;
            const int updateRound = 2;

            var matchUpdateDto = new MatchUpdateDto
            {
                Round = updateRound
            };

            var match = new Match
            {
                Id    = id,
                Round = 1
            };

            var expectedMatch = new Match
            {
                Id    = id,
                Round = updateRound
            };

            _matchService.SetupSequence(m => m.GetDetailByIdAsync(id))
            .ReturnsAsync(match)
            .ReturnsAsync(expectedMatch);

            var result = await _matchesController.UpdateMatch(id, matchUpdateDto);

            var okObjectResult      = result as OkObjectResult;
            var okObjectResultValue = okObjectResult.Value as MatchDetailDto;

            _matchService.Verify(m => m.GetDetailByIdAsync(id), Times.Exactly(2));
            _matchService.Verify(m => m.UpdateAsync(It.IsAny <Match>()), Times.Once);

            Assert.That(result, Is.TypeOf <OkObjectResult>());
            Assert.That(okObjectResultValue.Round, Is.EqualTo(updateRound));
        }