public void Should_Add_Away_Win_Correctly()
        {
            var processor = new LeagueTableProcessor("DummyTournament");

            const string homeTeamTitle = "Home";
            const string awayTeamTitle = "Away";

            const string irrelevantTeamTitle = "Irrelevant";

            const int homeTeamGoals = 0;
            const int awayTeamGoals = 2;

            var winPoints  = _pointSystem.WinWeight;
            var losePoints = _pointSystem.LoseWeight;


            processor.HandleMatch(homeTeamTitle, homeTeamGoals, awayTeamTitle, awayTeamGoals);
            var table = processor.Table;

            var containsIrrelevant = table.ContainsKey(irrelevantTeamTitle);
            var homeStats          = table[homeTeamTitle];
            var awayStats          = table[awayTeamTitle];


            containsIrrelevant.ShouldBeFalse();

            homeStats.Games.ShouldBe(1);
            homeStats.Wins.ShouldBe(0);
            homeStats.Draws.ShouldBe(0);
            homeStats.Loses.ShouldBe(1);
            homeStats.ScoredGoals.ShouldBe(homeTeamGoals);
            homeStats.ConcededGoals.ShouldBe(awayTeamGoals);
            homeStats.Points.ShouldBe(losePoints);

            awayStats.Games.ShouldBe(1);
            awayStats.Wins.ShouldBe(1);
            awayStats.Draws.ShouldBe(0);
            awayStats.Loses.ShouldBe(0);
            awayStats.ScoredGoals.ShouldBe(awayTeamGoals);
            awayStats.ConcededGoals.ShouldBe(homeTeamGoals);
            awayStats.Points.ShouldBe(winPoints);
        }
        public async Task <HeadToHeadTableReadDto> Handle(GetHeadToHeadTable request,
                                                          CancellationToken cancellationToken = default(CancellationToken))
        {
            var tournamentId = request.HeadToHeadTournamentId;

            var headToHeadTournament = await _context
                                       .HeadToHeadTournaments
                                       .FetchWithScheduleInfo(FetchMode.ForRead)
                                       .WithIdAsync(tournamentId, cancellationToken);

            var parentTournament = headToHeadTournament.ParentTournament;
            var headToHeadTours  = headToHeadTournament.Tours.ToList();

            var tableProcessor = new LeagueTableProcessor(parentTournament.Title);

            foreach (var headToHeadTour in headToHeadTours)
            {
                if (!headToHeadTour.IsOver)
                {
                    break;
                }

                var headToHeadMatches = headToHeadTour.Matches;
                foreach (var headToHeadMatch in headToHeadMatches)
                {
                    var homeExpertNickname = headToHeadMatch.HomeExpert.Nickname;
                    var awayExpertNickname = headToHeadMatch.AwayExpert.Nickname;

                    var homeGoals = headToHeadMatch.HomeGoals;
                    var awayGoals = headToHeadMatch.AwayGoals;

                    tableProcessor.HandleMatch(homeExpertNickname, homeGoals, awayExpertNickname, awayGoals);
                }
            }

            var table      = tableProcessor.Table;
            var tableLines = table.Select(line => new HeadToHeadTableLineReadDto(line.Key, line.Value)).OrderBy(line => line.Points).ThenBy(lines => lines.ScoredGoals - lines.ConcededGoals).ThenBy(line => line.ScoredGoals).ToList();

            return(new HeadToHeadTableReadDto(tableProcessor.TournamentTitle, tableLines));
        }