Exemple #1
0
        public void Empty_string_route_throws_ArgumentException()
        {
            var filterFactory = new StatisticsFilterFactory(Mock.Of <IStoolballEntityRouteParser>(), _playerDataSource.Object, _clubDataSource.Object, _teamDataSource.Object, _matchLocationDataSource.Object,
                                                            _competitionDataSource.Object, _seasonDataSource.Object, _routeNormaliser.Object);

            Assert.ThrowsAsync <ArgumentException>(async() => await filterFactory.FromRoute(string.Empty).ConfigureAwait(false));
        }
Exemple #2
0
        public async Task Season_route_is_normalised(string seasonRoute)
        {
            var routeParser = new Mock <IStoolballEntityRouteParser>();

            routeParser.Setup(x => x.ParseRoute(seasonRoute)).Returns(StoolballEntityType.Season);
            var filterFactory = new StatisticsFilterFactory(routeParser.Object, _playerDataSource.Object, _clubDataSource.Object, _teamDataSource.Object, _matchLocationDataSource.Object,
                                                            _competitionDataSource.Object, _seasonDataSource.Object, _routeNormaliser.Object);

            var result = await filterFactory.FromRoute(seasonRoute).ConfigureAwait(false);

            _routeNormaliser.Verify(x => x.NormaliseRouteToEntity(seasonRoute, "competitions", Constants.Pages.SeasonUrlRegEx), Times.Once);
        }
Exemple #3
0
        public async Task Club_route_is_normalised()
        {
            var route       = "/clubs/example";
            var routeParser = new Mock <IStoolballEntityRouteParser>();

            routeParser.Setup(x => x.ParseRoute(route)).Returns(StoolballEntityType.Club);
            var filterFactory = new StatisticsFilterFactory(routeParser.Object, _playerDataSource.Object, _clubDataSource.Object, _teamDataSource.Object, _matchLocationDataSource.Object,
                                                            _competitionDataSource.Object, _seasonDataSource.Object, _routeNormaliser.Object);

            var result = await filterFactory.FromRoute(route).ConfigureAwait(false);

            _routeNormaliser.Verify(x => x.NormaliseRouteToEntity(route, "clubs"), Times.Once);
        }
Exemple #4
0
        public async Task Player_route_populates_player_from_playerDataSource()
        {
            var player = new Player {
                PlayerId = Guid.NewGuid(), PlayerRoute = "/players/example"
            };
            var routeParser = new Mock <IStoolballEntityRouteParser>();

            routeParser.Setup(x => x.ParseRoute(player.PlayerRoute)).Returns(StoolballEntityType.Player);
            _routeNormaliser.Setup(x => x.NormaliseRouteToEntity(player.PlayerRoute, "players")).Returns(player.PlayerRoute);
            _playerDataSource.Setup(x => x.ReadPlayerByRoute(player.PlayerRoute)).Returns(Task.FromResult(player));

            var filterFactory = new StatisticsFilterFactory(routeParser.Object, _playerDataSource.Object, _clubDataSource.Object, _teamDataSource.Object, _matchLocationDataSource.Object,
                                                            _competitionDataSource.Object, _seasonDataSource.Object, _routeNormaliser.Object);

            var result = await filterFactory.FromRoute(player.PlayerRoute).ConfigureAwait(false);

            _playerDataSource.Verify(x => x.ReadPlayerByRoute(player.PlayerRoute), Times.Once);
            Assert.Equal(player, result.Player);
        }
Exemple #5
0
        public async Task Season_route_populates_season_from_seasonDataSource(string seasonRoute)
        {
            var season = new Season {
                SeasonId = Guid.NewGuid(), SeasonRoute = seasonRoute
            };
            var routeParser = new Mock <IStoolballEntityRouteParser>();

            routeParser.Setup(x => x.ParseRoute(seasonRoute)).Returns(StoolballEntityType.Season);
            _routeNormaliser.Setup(x => x.NormaliseRouteToEntity(season.SeasonRoute, "competitions", Constants.Pages.SeasonUrlRegEx)).Returns(season.SeasonRoute);
            _seasonDataSource.Setup(x => x.ReadSeasonByRoute(season.SeasonRoute, false)).Returns(Task.FromResult(season));

            var filterFactory = new StatisticsFilterFactory(routeParser.Object, _playerDataSource.Object, _clubDataSource.Object, _teamDataSource.Object, _matchLocationDataSource.Object,
                                                            _competitionDataSource.Object, _seasonDataSource.Object, _routeNormaliser.Object);

            var result = await filterFactory.FromRoute(season.SeasonRoute).ConfigureAwait(false);

            _seasonDataSource.Verify(x => x.ReadSeasonByRoute(season.SeasonRoute, false), Times.Once);
            Assert.Equal(season, result.Season);
        }
Exemple #6
0
        public async Task Competition_route_populates_competition_from_competitionDataSource()
        {
            var competition = new Competition {
                CompetitionId = Guid.NewGuid(), CompetitionRoute = "/competitions/example"
            };
            var routeParser = new Mock <IStoolballEntityRouteParser>();

            routeParser.Setup(x => x.ParseRoute(competition.CompetitionRoute)).Returns(StoolballEntityType.Competition);
            _routeNormaliser.Setup(x => x.NormaliseRouteToEntity(competition.CompetitionRoute, "competitions")).Returns(competition.CompetitionRoute);
            _competitionDataSource.Setup(x => x.ReadCompetitionByRoute(competition.CompetitionRoute)).Returns(Task.FromResult(competition));

            var filterFactory = new StatisticsFilterFactory(routeParser.Object, _playerDataSource.Object, _clubDataSource.Object, _teamDataSource.Object, _matchLocationDataSource.Object,
                                                            _competitionDataSource.Object, _seasonDataSource.Object, _routeNormaliser.Object);

            var result = await filterFactory.FromRoute(competition.CompetitionRoute).ConfigureAwait(false);

            _competitionDataSource.Verify(x => x.ReadCompetitionByRoute(competition.CompetitionRoute), Times.Once);
            Assert.Equal(competition, result.Competition);
        }
Exemple #7
0
        public async Task Team_route_populates_team_from_teamDataSource()
        {
            var team = new Team {
                TeamId = Guid.NewGuid(), TeamRoute = "/teams/example"
            };
            var routeParser = new Mock <IStoolballEntityRouteParser>();

            routeParser.Setup(x => x.ParseRoute(team.TeamRoute)).Returns(StoolballEntityType.Team);
            _routeNormaliser.Setup(x => x.NormaliseRouteToEntity(team.TeamRoute, "teams")).Returns(team.TeamRoute);
            _teamDataSource.Setup(x => x.ReadTeamByRoute(team.TeamRoute, true)).Returns(Task.FromResult(team));

            var filterFactory = new StatisticsFilterFactory(routeParser.Object, _playerDataSource.Object, _clubDataSource.Object, _teamDataSource.Object, _matchLocationDataSource.Object,
                                                            _competitionDataSource.Object, _seasonDataSource.Object, _routeNormaliser.Object);

            var result = await filterFactory.FromRoute(team.TeamRoute).ConfigureAwait(false);

            _teamDataSource.Verify(x => x.ReadTeamByRoute(team.TeamRoute, true), Times.Once);
            Assert.Equal(team, result.Team);
        }