public async Task Setup()
        {
            context = await TestDatabase.GetDatabaseContext();

            MockDifficultiesRepository = new MockDifficultiesRepository(context);
            sut = new DifficultiesService(
                MockDifficultiesRepository.DifficultiesRepositorySuccessfulRequest.Object);
            sutCreateDifficulty = new DifficultiesService(
                MockDifficultiesRepository.DifficultiesRepositoryCreateDifficultyRequest.Object);
            license   = TestObjects.GetLicense();
            paginator = TestObjects.GetPaginator();
        }
Exemplo n.º 2
0
        public async Task Setup()
        {
            context = await TestDatabase.GetDatabaseContext();

            mockGamesRepository = new MockGamesRepository(context);
            mockAppsRepository  = new MockAppsRepository(context);
            mockUsersRepository = new MockUsersRepository(context);
            mockDifficultiesRepositorySuccessful = new MockDifficultiesRepository(context);
            mockDifficultiesRepositoryFailed     = new MockDifficultiesRepository(context);
            mockSolutionsRepository = new MockSolutionsRepository(context);

            sut = new GamesService(
                mockGamesRepository.GamesRepositorySuccessfulRequest.Object,
                mockAppsRepository.AppsRepositorySuccessfulRequest.Object,
                mockUsersRepository.UsersRepositorySuccessfulRequest.Object,
                mockDifficultiesRepositorySuccessful.DifficultiesRepositorySuccessfulRequest.Object,
                mockSolutionsRepository.SolutionsRepositorySuccessfulRequest.Object);

            sutFailure = new GamesService(
                mockGamesRepository.GamesRepositoryFailedRequest.Object,
                mockAppsRepository.AppsRepositorySuccessfulRequest.Object,
                mockUsersRepository.UsersRepositorySuccessfulRequest.Object,
                mockDifficultiesRepositorySuccessful.DifficultiesRepositorySuccessfulRequest.Object,
                mockSolutionsRepository.SolutionsRepositorySuccessfulRequest.Object);

            sutAnonFailure = new GamesService(
                mockGamesRepository.GamesRepositorySuccessfulRequest.Object,
                mockAppsRepository.AppsRepositorySuccessfulRequest.Object,
                mockUsersRepository.UsersRepositorySuccessfulRequest.Object,
                mockDifficultiesRepositoryFailed.DifficultiesRepositoryFailedRequest.Object,
                mockSolutionsRepository.SolutionsRepositorySuccessfulRequest.Object);

            sutUpdateFailure = new GamesService(
                mockGamesRepository.GamesRepositoryUpdateFailedRequest.Object,
                mockAppsRepository.AppsRepositorySuccessfulRequest.Object,
                mockUsersRepository.UsersRepositorySuccessfulRequest.Object,
                mockDifficultiesRepositorySuccessful.DifficultiesRepositorySuccessfulRequest.Object,
                mockSolutionsRepository.SolutionsRepositorySuccessfulRequest.Object);

            getGamesRequest = TestObjects.GetGamesRequest();
        }
Exemplo n.º 3
0
        public MockDifficultiesService(DatabaseContext context)
        {
            MockDifficultiesRepository = new MockDifficultiesRepository(context);

            DifficultiesServiceSuccessfulRequest = new Mock <IDifficultiesService>();
            DifficultiesServiceFailedRequest     = new Mock <IDifficultiesService>();

            DifficultiesServiceSuccessfulRequest.Setup(difficultiesService =>
                                                       difficultiesService.GetDifficulty(It.IsAny <int>(), It.IsAny <bool>()))
            .Returns(Task.FromResult(new DifficultyResult()
            {
                Success = MockDifficultiesRepository
                          .DifficultiesRepositorySuccessfulRequest
                          .Object
                          .GetById(It.IsAny <int>(), It.IsAny <bool>())
                          .Result
                          .Success,
                Message    = DifficultiesMessages.DifficultyFoundMessage,
                Difficulty = (Difficulty)MockDifficultiesRepository
                             .DifficultiesRepositorySuccessfulRequest
                             .Object
                             .GetById(It.IsAny <int>(), It.IsAny <bool>())
                             .Result
                             .Object
            } as IDifficultyResult));

            DifficultiesServiceSuccessfulRequest.Setup(difficultiesService =>
                                                       difficultiesService.GetDifficulties(It.IsAny <bool>()))
            .Returns(Task.FromResult(new DifficultiesResult()
            {
                Success = MockDifficultiesRepository
                          .DifficultiesRepositorySuccessfulRequest
                          .Object
                          .GetAll(It.IsAny <bool>())
                          .Result
                          .Success,
                Message      = DifficultiesMessages.DifficultiesFoundMessage,
                Difficulties = MockDifficultiesRepository
                               .DifficultiesRepositorySuccessfulRequest
                               .Object
                               .GetAll(It.IsAny <bool>())
                               .Result
                               .Objects
                               .ConvertAll(d => (IDifficulty)d)
            } as IDifficultiesResult));

            DifficultiesServiceSuccessfulRequest.Setup(difficultiesService =>
                                                       difficultiesService.CreateDifficulty(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <DifficultyLevel>()))
            .Returns(Task.FromResult(new DifficultyResult()
            {
                Success = MockDifficultiesRepository
                          .DifficultiesRepositorySuccessfulRequest
                          .Object
                          .Add(It.IsAny <Difficulty>())
                          .Result
                          .Success,
                Message    = DifficultiesMessages.DifficultyCreatedMessage,
                Difficulty = (Difficulty)MockDifficultiesRepository
                             .DifficultiesRepositorySuccessfulRequest
                             .Object
                             .Add(It.IsAny <Difficulty>())
                             .Result
                             .Object
            } as IDifficultyResult));

            DifficultiesServiceSuccessfulRequest.Setup(difficultiesService =>
                                                       difficultiesService.UpdateDifficulty(It.IsAny <int>(), It.IsAny <UpdateDifficultyRequest>()))
            .Returns(Task.FromResult(new BaseResult()
            {
                Success = MockDifficultiesRepository
                          .DifficultiesRepositorySuccessfulRequest
                          .Object
                          .Update(It.IsAny <Difficulty>())
                          .Result
                          .Success,
                Message = DifficultiesMessages.DifficultyUpdatedMessage
            } as IBaseResult));

            DifficultiesServiceSuccessfulRequest.Setup(difficultiesService =>
                                                       difficultiesService.DeleteDifficulty(It.IsAny <int>()))
            .Returns(Task.FromResult(new BaseResult()
            {
                Success = MockDifficultiesRepository
                          .DifficultiesRepositorySuccessfulRequest
                          .Object
                          .Delete(It.IsAny <Difficulty>())
                          .Result
                          .Success,
                Message = DifficultiesMessages.DifficultyDeletedMessage
            } as IBaseResult));

            DifficultiesServiceFailedRequest.Setup(difficultiesService =>
                                                   difficultiesService.GetDifficulty(It.IsAny <int>(), It.IsAny <bool>()))
            .Returns(Task.FromResult(new DifficultyResult()
            {
                Success = MockDifficultiesRepository
                          .DifficultiesRepositoryFailedRequest
                          .Object
                          .Add(It.IsAny <Difficulty>())
                          .Result
                          .Success,
                Message    = DifficultiesMessages.DifficultyNotFoundMessage,
                Difficulty = (Difficulty)MockDifficultiesRepository
                             .DifficultiesRepositoryFailedRequest
                             .Object
                             .Add(It.IsAny <Difficulty>())
                             .Result
                             .Object
            } as IDifficultyResult));

            DifficultiesServiceFailedRequest.Setup(difficultiesService =>
                                                   difficultiesService.GetDifficulties(It.IsAny <bool>()))
            .Returns(Task.FromResult(new DifficultiesResult()
            {
                Success = MockDifficultiesRepository
                          .DifficultiesRepositoryFailedRequest
                          .Object
                          .GetAll(It.IsAny <bool>())
                          .Result
                          .Success,
                Message      = DifficultiesMessages.DifficultiesNotFoundMessage,
                Difficulties = null
            } as IDifficultiesResult));

            DifficultiesServiceFailedRequest.Setup(difficultiesService =>
                                                   difficultiesService.CreateDifficulty(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <DifficultyLevel>()))
            .Returns(Task.FromResult(new DifficultyResult()
            {
                Success = MockDifficultiesRepository
                          .DifficultiesRepositoryFailedRequest
                          .Object
                          .Add(It.IsAny <Difficulty>())
                          .Result
                          .Success,
                Message    = DifficultiesMessages.DifficultyNotCreatedMessage,
                Difficulty = (Difficulty)MockDifficultiesRepository
                             .DifficultiesRepositoryFailedRequest
                             .Object
                             .Add(It.IsAny <Difficulty>())
                             .Result
                             .Object
            } as IDifficultyResult));

            DifficultiesServiceFailedRequest.Setup(difficultiesService =>
                                                   difficultiesService.UpdateDifficulty(It.IsAny <int>(), It.IsAny <UpdateDifficultyRequest>()))
            .Returns(Task.FromResult(new BaseResult()
            {
                Success = MockDifficultiesRepository
                          .DifficultiesRepositoryFailedRequest
                          .Object
                          .Update(It.IsAny <Difficulty>())
                          .Result
                          .Success,
                Message = DifficultiesMessages.DifficultyNotUpdatedMessage
            } as IBaseResult));

            DifficultiesServiceFailedRequest.Setup(difficultiesService =>
                                                   difficultiesService.DeleteDifficulty(It.IsAny <int>()))
            .Returns(Task.FromResult(new BaseResult()
            {
                Success = MockDifficultiesRepository
                          .DifficultiesRepositoryFailedRequest
                          .Object
                          .Delete(It.IsAny <Difficulty>())
                          .Result
                          .Success,
                Message = DifficultiesMessages.DifficultyNotDeletedMessage
            } as IBaseResult));
        }