public RatingUpdater(IUserRepository _userRepository, IPuzzleRepository _puzzleRepository, IRatingRepository _ratingRepository, IAttemptRepository _attemptRepository)
{
userRepository = _userRepository;
puzzleRepository = _puzzleRepository;
ratingRepository = _ratingRepository;
attemptRepository = _attemptRepository;
}
public PuzzleController(IPuzzleRepository puzzleRepository, IUserProfileRepository userProfileRepository, IHistoryRepository historyRepository, IRequestRepository requestRepository)
{
_puzzleRepository = puzzleRepository;
_userProfileRepository = userProfileRepository;
_historyRepository = historyRepository;
_requestRepository = requestRepository;
}
public PuzzlesViewModel(INavigationService navigationService, IPuzzleRepository puzzleRepository, IUserService userService)
{
navigation = navigationService;
_puzzleRepository = puzzleRepository;
_userService = userService;
RegisterForMessage();
StartPuzzleCommand = new RelayCommand<PuzzleViewModel>(StartPuzzle);
}
public void CreatePuzzle_ShouldReturnPuzzleResponseObject()
{
mockLogger = new Mock <ILogger <SudokuController> >();
logger = mockLogger.Object;
mockService = new Mock <IPuzzleService>();
service = mockService.Object;
mockRepository = new Mock <IPuzzleRepository>();
repository = mockRepository.Object;
sut = new SudokuController(logger, service, repository);
var actualResult = sut.CreatePuzzle(0);
Assert.IsInstanceOfType(actualResult, typeof(ActionResult <PuzzleResponse>));
}
public CommentController(ICommentRepository _commentRepository,
ICommentVoteRepository _commentVoteRepository,
IUserRepository _userRepository,
ICounterRepository _counterRepository,
IPersistentLoginHandler _loginHandler,
INotificationRepository _notificationRepository,
IPuzzleRepository _puzzleRepository) : base(_userRepository, _loginHandler)
{
commentRepository = _commentRepository;
commentVoteRepository = _commentVoteRepository;
counterRepository = _counterRepository;
notificationRepository = _notificationRepository;
puzzleRepository = _puzzleRepository;
}
public void Solution_ShouldReturnPuzzleResponseObject()
{
mockLogger = new Mock <ILogger <SudokuController> >();
logger = mockLogger.Object;
mockService = new Mock <IPuzzleService>();
mockService.Setup(x => x.GetSolvedSudoku6x6(testData.GetValidPuzzle1()))
.Returns(testData.GetValidPuzzle1Solution());
service = mockService.Object;
mockRepository = new Mock <IPuzzleRepository>();
repository = mockRepository.Object;
sut = new SudokuController(logger, service, repository);
var actualResult = sut.Solution(new Puzzle(testData.GetValidPuzzle1()));
Assert.IsInstanceOfType(actualResult, typeof(ActionResult <PuzzleResponse>));
}
public void CreatePuzzle_ShouldReturnNotNullObject()
{
mockLogger = new Mock <ILogger <SudokuController> >();
logger = mockLogger.Object;
mockService = new Mock <IPuzzleService>();
service = mockService.Object;
mockRepository = new Mock <IPuzzleRepository>();
mockRepository.Setup(x => x.GetPuzzleById(0))
.Returns(new Puzzle(testData.GetValidPuzzle0()
));
repository = mockRepository.Object;
sut = new SudokuController(logger, service, repository);
var actualResult = sut.CreatePuzzle(0);
Assert.IsNotNull(actualResult);
}
public void CreatePuzzle_ShouldReturnPuzzleForId0()
{
mockLogger = new Mock <ILogger <SudokuController> >();
logger = mockLogger.Object;
mockService = new Mock <IPuzzleService>();
service = mockService.Object;
mockRepository = new Mock <IPuzzleRepository>();
mockRepository.Setup(x => x.GetPuzzleById(0))
.Returns(new Puzzle(testData.GetValidPuzzle0()
));
repository = mockRepository.Object;
sut = new SudokuController(logger, service, repository);
var actualResult = sut.CreatePuzzle(0);
var expectedResult = new PuzzleResponse(Constants.Code.OK, Constants.Message.Success, testData.GetValidPuzzle0());
Assert.AreEqual(expectedResult.Equals(actualResult.Value), true);
}
public PuzzleController(IPuzzlesBeingEditedRepository _puzzlesBeingEdited,
IPuzzleRepository _puzzleRepository,
IUserRepository _userRepository,
IRatingUpdater _ratingUpdater,
IMoveCollectionTransformer _movecollectionTransformer,
IPuzzleTrainingSessionRepository _puzzleTrainingSessionRepository,
ICounterRepository _counterRepository,
IPersistentLoginHandler _loginHandler,
IGameConstructor _gameConstructor) : base(_userRepository, _loginHandler)
{
puzzlesBeingEdited = _puzzlesBeingEdited;
puzzleRepository = _puzzleRepository;
ratingUpdater = _ratingUpdater;
moveCollectionTransformer = _movecollectionTransformer;
puzzleTrainingSessionRepository = _puzzleTrainingSessionRepository;
counterRepository = _counterRepository;
gameConstructor = _gameConstructor;
}
public void Solution_ShouldReturnNoSolutionForInvalidPuzzle()
{
mockLogger = new Mock <ILogger <SudokuController> >();
logger = mockLogger.Object;
var puzzle = testData.GetInvalidPuzzle();
mockService = new Mock <IPuzzleService>();
mockService.Setup(x => x.GetSolvedSudoku6x6(puzzle))
.Returns((int[][])null);
service = mockService.Object;
mockRepository = new Mock <IPuzzleRepository>();
repository = mockRepository.Object;
sut = new SudokuController(logger, service, repository);
var actualResult = sut.Solution(new Puzzle(puzzle));
var expectedResult = new PuzzleResponse(Constants.Code.OK, Constants.Message.SolutionNotFound, null);
Assert.AreEqual(expectedResult.Equals(actualResult.Value), true);
}
//Using Constructor Dependency Injection: http://aspnetboilerplate.com/Pages/Documents/Dependency-Injection
public PuzzleAppService(IPuzzleRepository puzzleRepository,
GridManager gridManager)
{
_puzzleRepository = puzzleRepository;
_gridManager = gridManager;
}
public PuzzlesService(IPuzzleRepository puzzlesRepository, IUserService userService)
{
this.puzzlesRepository = puzzlesRepository;
_userService = userService;
}
public PuzzleController(IPuzzleRepository puzzleRepository, IShopRepository shopRepository, IHostingEnvironment environment)
{
_puzzleRepository = puzzleRepository;
_shopRepository = shopRepository;
_environment = environment;
}
public PuzzleController(IPuzzleRepository puzzleRepository, IShopRepository shopRepository, IHostingEnvironment environment)
{
_puzzleRepository = puzzleRepository;
_shopRepository = shopRepository;
_environment = environment;
}
public SudokuController(ILogger <SudokuController> logger, IPuzzleService service, IPuzzleRepository repository)
{
_logger = logger;
_sudokuService = service;
_puzzlerepository = repository;
}
public HistoryController(IHistoryRepository historyRepository, IPuzzleRepository puzzleRepository, IUserProfileRepository userProfileRepository)
{
_puzzleRepository = puzzleRepository;
_userProfileRepository = userProfileRepository;
_historyRepository = historyRepository;
}
public PuzzlesService(IBlobCache blobCache = null)
{
puzzlesRepository = Locator.Current.GetService <IPuzzleRepository>();
_userService = Locator.Current.GetService <IUserService>();
_blobCache = blobCache ?? Locator.Current.GetService <IBlobCache>();
}
public ReviewController(IPuzzleRepository _puzzleRepository, IUserRepository _userRepository, IPersistentLoginHandler _loginHandler, INotificationRepository _notificationRepository)
: base(_userRepository, _loginHandler)
{
puzzleRepository = _puzzleRepository;
notificationRepository = _notificationRepository;
}
public ReviewController(IPuzzleRepository _puzzleRepository, IUserRepository _userRepository, IPersistentLoginHandler _loginHandler) : base(_userRepository, _loginHandler)
{
puzzleRepository = _puzzleRepository;
}
