public void ViewTeamScheduleCommand_WhenSelectedTeamIsNull_ShouldNotLoadTeamSeasonScheduleProfileTotalsAndAverages()
        {
            // Arrange
            var teamSeasonRepository         = A.Fake <ITeamSeasonRepository>();
            var teamSeasonScheduleRepository = A.Fake <ITeamSeasonScheduleRepository>();
            var testObject = new TeamSeasonsControlViewModel(teamSeasonRepository, teamSeasonScheduleRepository);

            var teamSeasonOpponentProfiles = new List <TeamSeasonOpponentProfile>();

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleProfile(A <string> .Ignored,
                                                                                     A <int> .Ignored)).Returns(teamSeasonOpponentProfiles);

            var teamSeasonScheduleTotals = new TeamSeasonScheduleTotals();

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleTotals(A <string> .Ignored,
                                                                                    A <int> .Ignored)).Returns(teamSeasonScheduleTotals);

            var teamSeasonScheduleAverages = new TeamSeasonScheduleAverages();

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleAverages(A <string> .Ignored,
                                                                                      A <int> .Ignored)).Returns(teamSeasonScheduleAverages);

            // Act
            testObject.ViewTeamScheduleCommand.Execute(null !);

            // Assert
            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleProfile(A <string> .Ignored,
                                                                                     A <int> .Ignored)).MustNotHaveHappened();
            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleTotals(A <string> .Ignored,
                                                                                    A <int> .Ignored)).MustNotHaveHappened();
            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleAverages(A <string> .Ignored,
                                                                                      A <int> .Ignored)).MustNotHaveHappened();
        }
        public async Task GetTeamSeasonScheduleAverages_WhenExceptionIsNotCaught_ShouldReturnTeamSeasonOpponentAveragesModel()
        {
            // Arrange
            var teamSeasonScheduleAveragesRepository = A.Fake <ITeamSeasonScheduleRepository>();
            TeamSeasonScheduleAverages?teamSeasonScheduleAverages = new TeamSeasonScheduleAverages();

            A.CallTo(() => teamSeasonScheduleAveragesRepository.GetTeamSeasonScheduleAveragesAsync(
                         A <string> .Ignored, A <int> .Ignored)).Returns(teamSeasonScheduleAverages);

            var mapper = A.Fake <IMapper>();
            var teamSeasonScheduleAveragesModel = new TeamSeasonScheduleAveragesModel();

            A.CallTo(() => mapper.Map <TeamSeasonScheduleAveragesModel>(A <TeamSeasonScheduleAverages> .Ignored))
            .Returns(teamSeasonScheduleAveragesModel);

            var testController = new TeamSeasonScheduleController(teamSeasonScheduleAveragesRepository, mapper);

            string teamName   = "Team";
            int    seasonYear = 1920;

            // Act
            var result = await testController.GetTeamSeasonScheduleAverages(teamName, seasonYear);

            // Assert
            A.CallTo(() => teamSeasonScheduleAveragesRepository.GetTeamSeasonScheduleAveragesAsync(teamName, seasonYear))
            .MustHaveHappenedOnceExactly();
            A.CallTo(() => mapper.Map <TeamSeasonScheduleAveragesModel>(teamSeasonScheduleAverages))
            .MustHaveHappenedOnceExactly();
            result.Value.ShouldBeOfType <TeamSeasonScheduleAveragesModel>();
        }
        public void SelectedTeamSetter_WhenValueDoesNotEqualSelectedTeam_ShouldAssignValueToSelectedTeam()
        {
            // Arrange
            var teamSeasonRepository = A.Fake <ITeamSeasonRepository>();

            var teamSeasonScheduleRepository = A.Fake <ITeamSeasonScheduleRepository>();
            var teamSeasonOpponentProfiles   = new List <TeamSeasonOpponentProfile>();

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleProfile(A <string> .Ignored,
                                                                                     A <int> .Ignored)).Returns(teamSeasonOpponentProfiles);

            var teamSeasonScheduleTotals = new TeamSeasonScheduleTotals();

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleTotals(A <string> .Ignored,
                                                                                    A <int> .Ignored)).Returns(teamSeasonScheduleTotals);

            var teamSeasonScheduleAverages = new TeamSeasonScheduleAverages();

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleAverages(A <string> .Ignored,
                                                                                      A <int> .Ignored)).Returns(teamSeasonScheduleAverages);

            var testObject = new TeamSeasonsControlViewModel(teamSeasonRepository, teamSeasonScheduleRepository)
            {
                SelectedTeam = null
            };

            var teamSeason = new TeamSeason();

            // Act
            testObject.SelectedTeam = teamSeason;

            // Assert
            testObject.SelectedTeam.ShouldBe(teamSeason);

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleProfile(A <string> .Ignored,
                                                                                     A <int> .Ignored)).MustHaveHappenedOnceExactly();
            testObject.TeamSeasonScheduleProfile.ShouldBeOfType <ReadOnlyCollection <TeamSeasonOpponentProfile> >();
            testObject.TeamSeasonScheduleProfile.ShouldBe(teamSeasonOpponentProfiles.ToList());

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleTotals(A <string> .Ignored,
                                                                                    A <int> .Ignored)).MustHaveHappenedOnceExactly();
            testObject.TeamSeasonScheduleTotals.ShouldBeOfType <ReadOnlyCollection <TeamSeasonScheduleTotals> >();

            var teamSeasonScheduleTotalsList = new List <TeamSeasonScheduleTotals> {
                teamSeasonScheduleTotals
            };

            testObject.TeamSeasonScheduleTotals.ShouldBe(teamSeasonScheduleTotalsList);

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleAverages(A <string> .Ignored,
                                                                                      A <int> .Ignored)).MustHaveHappenedOnceExactly();
            testObject.TeamSeasonScheduleAverages.ShouldBeOfType <ReadOnlyCollection <TeamSeasonScheduleAverages> >();

            var teamSeasonScheduleAveragesList = new List <TeamSeasonScheduleAverages> {
                teamSeasonScheduleAverages
            };

            testObject.TeamSeasonScheduleAverages.ShouldBe(teamSeasonScheduleAveragesList);
        }
        public void ViewTeamScheduleCommand_WhenSelectedTeamIsNotNull_ShouldLoadTeamSeasonScheduleProfileTotalsAndAverages()
        {
            // Arrange
            var teamSeasonRepository = A.Fake <ITeamSeasonRepository>();

            var teamSeasonScheduleRepository = A.Fake <ITeamSeasonScheduleRepository>();
            var teamSeasonOpponentProfiles   = new List <TeamSeasonOpponentProfile>();

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleProfile(A <string> .Ignored,
                                                                                     A <int> .Ignored)).Returns(teamSeasonOpponentProfiles);

            var teamSeasonScheduleTotals = new TeamSeasonScheduleTotals();

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleTotals(A <string> .Ignored,
                                                                                    A <int> .Ignored)).Returns(teamSeasonScheduleTotals);

            var teamSeasonScheduleAverages = new TeamSeasonScheduleAverages();

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleAverages(A <string> .Ignored,
                                                                                      A <int> .Ignored)).Returns(teamSeasonScheduleAverages);

            var testObject = new TeamSeasonsControlViewModel(teamSeasonRepository, teamSeasonScheduleRepository)
            {
                SelectedTeam = new TeamSeason()
            };

            // Act
            testObject.ViewTeamScheduleCommand.Execute(null !);

            // Assert
            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleProfile(A <string> .Ignored,
                                                                                     A <int> .Ignored)).MustHaveHappened();
            testObject.TeamSeasonScheduleProfile.ShouldBeOfType <ReadOnlyCollection <TeamSeasonOpponentProfile> >();
            testObject.TeamSeasonScheduleProfile.ShouldBe(teamSeasonOpponentProfiles.ToList());

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleTotals(A <string> .Ignored,
                                                                                    A <int> .Ignored)).MustHaveHappened();
            testObject.TeamSeasonScheduleTotals.ShouldBeOfType <ReadOnlyCollection <TeamSeasonScheduleTotals> >();

            var teamSeasonScheduleTotalsList = new List <TeamSeasonScheduleTotals> {
                teamSeasonScheduleTotals
            };

            testObject.TeamSeasonScheduleTotals.ShouldBe(teamSeasonScheduleTotalsList);

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleAverages(A <string> .Ignored,
                                                                                      A <int> .Ignored)).MustHaveHappened();
            testObject.TeamSeasonScheduleAverages.ShouldBeOfType <ReadOnlyCollection <TeamSeasonScheduleAverages> >();

            var teamSeasonScheduleAveragesList = new List <TeamSeasonScheduleAverages> {
                teamSeasonScheduleAverages
            };

            testObject.TeamSeasonScheduleAverages.ShouldBe(teamSeasonScheduleAveragesList);
        }
Exemple #5
0
        public async Task Details_WhenIdIsNotNullAndTeamSeasonIsFound_ShouldReturnNotFound()
        {
            // Arrange
            var teamSeasonsIndexViewModel   = A.Fake <ITeamSeasonsIndexViewModel>();
            var teamSeasonsDetailsViewModel = A.Fake <ITeamSeasonsDetailsViewModel>();
            var seasonRepository            = A.Fake <ISeasonRepository>();

            var        teamSeasonRepository = A.Fake <ITeamSeasonRepository>();
            string     teamName             = "Team";
            int        seasonYear           = 1920;
            TeamSeason?teamSeason           = new TeamSeason
            {
                TeamName   = teamName,
                SeasonYear = seasonYear
            };

            A.CallTo(() => teamSeasonRepository.GetTeamSeasonAsync(A <int> .Ignored)).Returns(teamSeason);

            var teamSeasonScheduleRepository = A.Fake <ITeamSeasonScheduleRepository>();

            var teamSeasonScheduleProfile = new List <TeamSeasonOpponentProfile>();

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleProfileAsync(A <string> .Ignored,
                                                                                          A <int> .Ignored)).Returns(teamSeasonScheduleProfile);

            var teamSeasonScheduleTotals = new TeamSeasonScheduleTotals();

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleTotalsAsync(A <string> .Ignored,
                                                                                         A <int> .Ignored)).Returns(teamSeasonScheduleTotals);

            var teamSeasonScheduleAverages = new TeamSeasonScheduleAverages();

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleAveragesAsync(A <string> .Ignored,
                                                                                           A <int> .Ignored)).Returns(teamSeasonScheduleAverages);

            var sharedRepository    = A.Fake <ISharedRepository>();
            var weeklyUpdateService = A.Fake <IWeeklyUpdateService>();

            var testController = new TeamSeasonsController(teamSeasonsIndexViewModel, teamSeasonsDetailsViewModel,
                                                           seasonRepository, teamSeasonRepository, teamSeasonScheduleRepository, sharedRepository,
                                                           weeklyUpdateService);

            int?id = 1;

            // Act
            var result = await testController.Details(id);

            // Assert
            teamSeasonsDetailsViewModel.TeamSeason = teamSeason;

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleProfileAsync(teamName, seasonYear))
            .MustHaveHappenedOnceExactly();
            teamSeasonsDetailsViewModel.TeamSeasonScheduleProfile.ShouldBe(teamSeasonScheduleProfile);

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleTotalsAsync(teamName, seasonYear))
            .MustHaveHappenedOnceExactly();
            teamSeasonsDetailsViewModel.TeamSeasonScheduleTotals.ShouldBe(teamSeasonScheduleTotals);

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleAveragesAsync(teamName,
                                                                                           seasonYear)).MustHaveHappenedOnceExactly();
            teamSeasonsDetailsViewModel.TeamSeasonScheduleAverages.ShouldBe(teamSeasonScheduleAverages);

            result.ShouldBeOfType <ViewResult>();
            ((ViewResult)result).Model.ShouldBe(teamSeasonsDetailsViewModel);
        }
        public async Task RunWeeklyUpdate_WhenTeamSeasonScheduleTotalsScheduleGamesIsNotNullAndWhenTeamSeasonScheduleAveragesPointsForAndPointsAgainstAreNotNullAndLeagueSeasonAveragePointsIsNotNull_ShouldUpdateRankingsForTeamSeason()
        {
            // Arrange
            var seasonRepository             = A.Fake <ISeasonRepository>();
            var gameRepository               = A.Fake <IGameRepository>();
            var leagueSeasonRepository       = A.Fake <ILeagueSeasonRepository>();
            var leagueSeasonTotalsRepository = A.Fake <ILeagueSeasonTotalsRepository>();
            var teamSeasonRepository         = A.Fake <ITeamSeasonRepository>();
            var teamSeasonScheduleRepository = A.Fake <ITeamSeasonScheduleRepository>();
            var sharedRepository             = A.Fake <ISharedRepository>();

            var service = new WeeklyUpdateService(seasonRepository, gameRepository, leagueSeasonRepository,
                                                  leagueSeasonTotalsRepository, teamSeasonRepository, teamSeasonScheduleRepository, sharedRepository);

            var leagueSeasonTotals = new LeagueSeasonTotals
            {
                TotalGames  = 1,
                TotalPoints = 0
            };

            A.CallTo(() => leagueSeasonTotalsRepository.GetLeagueSeasonTotals(A <string> .Ignored, A <int> .Ignored))
            .Returns(leagueSeasonTotals);

            var leagueSeason = new LeagueSeason
            {
                AveragePoints = 0
            };

            A.CallTo(() => leagueSeasonRepository.GetLeagueSeasonByLeagueAndSeasonAsync(A <string> .Ignored, A <int> .Ignored))
            .Returns(leagueSeason);

            var seasonYear = 1920;

            var games = new List <Game>
            {
                new Game
                {
                    SeasonYear = seasonYear,
                    Week       = 3
                }
            };

            A.CallTo(() => gameRepository.GetGamesAsync()).Returns(games);

            A.CallTo(() => seasonRepository.GetSeasonAsync(A <int> .Ignored)).Returns <Season?>(null);

            var teamName   = "Team";
            var leagueName = "APFA";

            var teamSeasons = new List <TeamSeason>
            {
                new TeamSeason
                {
                    TeamName   = teamName,
                    SeasonYear = seasonYear,
                    LeagueName = leagueName
                }
            };

            A.CallTo(() => teamSeasonRepository.GetTeamSeasonsBySeasonAsync(seasonYear)).Returns(teamSeasons);

            var teamSeasonScheduleTotals = new TeamSeasonScheduleTotals
            {
                ScheduleGames = 0
            };

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleTotalsAsync(A <string> .Ignored,
                                                                                         seasonYear)).Returns(teamSeasonScheduleTotals);

            var teamSeasonScheduleAverages = new TeamSeasonScheduleAverages
            {
                PointsFor     = 0,
                PointsAgainst = 0
            };

            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleAveragesAsync(A <string> .Ignored,
                                                                                           seasonYear)).Returns(teamSeasonScheduleAverages);

            // Act
            await service.RunWeeklyUpdate(seasonYear);

            // Assert
            A.CallTo(() => leagueSeasonTotalsRepository.GetLeagueSeasonTotals(leagueName, seasonYear))
            .MustHaveHappened();
            A.CallTo(() => leagueSeasonRepository.GetLeagueSeasonByLeagueAndSeasonAsync(leagueName, seasonYear))
            .MustHaveHappenedTwiceExactly();
            A.CallTo(() => gameRepository.GetGamesAsync()).MustHaveHappened();
            A.CallTo(() => seasonRepository.GetSeasonAsync(seasonYear)).MustHaveHappened();
            A.CallTo(() => teamSeasonRepository.GetTeamSeasonsBySeasonAsync(seasonYear)).MustHaveHappened();
            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleTotalsAsync(teamName, seasonYear))
            .MustHaveHappened();
            A.CallTo(() => teamSeasonScheduleRepository.GetTeamSeasonScheduleAveragesAsync(teamName, seasonYear))
            .MustHaveHappened();
            A.CallTo(() => sharedRepository.SaveChangesAsync()).MustHaveHappenedTwiceExactly();
        }