From e922f48980836cfbbc97f348c9c521162f8b7d12 Mon Sep 17 00:00:00 2001 From: "louis.dufour" Date: Sat, 10 Feb 2024 18:15:53 +0100 Subject: [PATCH] Add(Master): Test unitaire --- Model/Tests/ModelTests/ModelTests.swift | 8 +- Model/Tests/ModelTests/PlayerTests.swift | 100 ++++---------- .../ModelTests/VerySimpleRulesTests.swift | 129 +++++++++++------- 3 files changed, 115 insertions(+), 122 deletions(-) diff --git a/Model/Tests/ModelTests/ModelTests.swift b/Model/Tests/ModelTests/ModelTests.swift index 2a9ce36..5405c43 100644 --- a/Model/Tests/ModelTests/ModelTests.swift +++ b/Model/Tests/ModelTests/ModelTests.swift @@ -43,20 +43,20 @@ class BoardTests: XCTestCase { // Testez removePiece(atRow:andColumn:) func testRemovePiece() { - let initialCell = testBoard.getCell(atRow: 0, column: 0) + let initialCell = testBoard.getCell(atRow: 0, atColumn: 0) XCTAssertNotNil(initialCell?.piece) let result = testBoard.removePiece(atRow: 0, andColumn: 0) XCTAssertEqual(result, .ok) // Vérifiez que la pièce a été supprimée correctement - let removedCell = testBoard.getCell(atRow: 0, column: 0) + let removedCell = testBoard.getCell(atRow: 0, atColumn: 0) XCTAssertNil(removedCell?.piece) } // Testez insert(piece:atRow:andColumn:) func testInsertPiece() { // Supprimez toute pièce existante dans la case cible (si elle existe) - let initialCell = testBoard.getCell(atRow: 0, column: 0) + let initialCell = testBoard.getCell(atRow: 0, atColumn: 0) if initialCell?.piece != nil { let removeResult = testBoard.removePiece(atRow: 0, andColumn: 0) XCTAssertEqual(removeResult, .ok) @@ -67,7 +67,7 @@ class BoardTests: XCTestCase { XCTAssertEqual(insertResult, .ok) // Vérifiez que la pièce a été insérée correctement - let cell = testBoard.getCell(atRow: 0, column: 0) + let cell = testBoard.getCell(atRow: 0, atColumn: 0) XCTAssertNotNil(cell?.piece) XCTAssertEqual(cell?.piece?.owner, .player1) XCTAssertEqual(cell?.piece?.animal, .lion) diff --git a/Model/Tests/ModelTests/PlayerTests.swift b/Model/Tests/ModelTests/PlayerTests.swift index 53b2a9b..70812f3 100644 --- a/Model/Tests/ModelTests/PlayerTests.swift +++ b/Model/Tests/ModelTests/PlayerTests.swift @@ -5,88 +5,44 @@ // Created by Louis DUFOUR on 31/01/2024. // -import Foundation -import Model import XCTest +@testable import Model // Remplacez 'YourModuleName' par le nom réel de votre module -/* -// Mocks et Stubs -class MockBoard: Board { - // Implémentez les méthodes nécessaires -} - -class MockRules: VerySimpleRules { - var mockMoves: [Move] = [] - - func getMoves(board: Board, owner: Owner) -> [Move] { - return mockMoves - } -} - -class MockMove: Move { - // Implémentez les détails nécessaires -} - -// Tests class PlayerTests: XCTestCase { - func testPlayerInitialization() { - let player = Player(name: "TestPlayer", id: .player1) - XCTAssertNotNil(player) - XCTAssertEqual(player.name, "TestPlayer") - // Plus d'assertions pour id - } -} - -class HumanPlayerTests: XCTestCase { - var mockBoard: MockBoard! - var mockRules: MockRules! - var mockMove: MockMove! + + var rules: VerySimpleRules! + var board: Board! override func setUp() { super.setUp() - mockBoard = MockBoard() - mockRules = MockRules() - mockMove = MockMove() + rules = VerySimpleRules() + board = VerySimpleRules.createBoard() } - func testHumanPlayerInitialization() { - let humanPlayer = HumanPlayer(name: "Human", id: .player1, inputMethod: { _, _ in return self.mockMove }) - XCTAssertNotNil(humanPlayer) - XCTAssertEqual(humanPlayer.name, "Human") + override func tearDown() { + rules = nil + board = nil + super.tearDown() + } + + func testRandomPlayerChooseMove() { + // Assurez-vous que l'initialisation de RandomPlayer correspond à votre implémentation + let randomPlayer = RandomPlayer(withName: "Random Player", andId: .player1) + XCTAssertNotNil(randomPlayer, "RandomPlayer n'a pas été correctement initialisé") + + // Testez chooseMove avec le board et les règles réels + let move = randomPlayer?.chooseMove(board: board, rules: rules) + XCTAssertNotNil(move, "RandomPlayer n'a pas choisi de mouvement") } func testHumanPlayerChooseMove() { - let humanPlayer = HumanPlayer(name: "Human", id: .player1, inputMethod: { _, _ in return self.mockMove }) - let move = humanPlayer.chooseMove(board: mockBoard, rules: mockRules) - XCTAssertEqual(move, mockMove) + // Assurez-vous que l'initialisation de HumanPlayer correspond à votre implémentation + let inputMethod: ([Move]) -> Move? = { moves in moves.first } + let humanPlayer = HumanPlayer(name: "Human Player", id: .player1, inputMethod: inputMethod) + XCTAssertNotNil(humanPlayer, "HumanPlayer n'a pas été correctement initialisé") + + // Testez chooseMove avec le board et les règles réels + let move = humanPlayer?.chooseMove(board: board, rules: rules) + XCTAssertNotNil(move, "HumanPlayer n'a pas choisi de mouvement") } } - -class RandomPlayerTests: XCTestCase { - var mockBoard: MockBoard! - var mockRules: MockRules! - var mockMove: MockMove! - - override func setUp() { - super.setUp() - mockBoard = MockBoard() - mockRules = MockRules() - mockMove = MockMove() - mockRules.mockMoves = [mockMove] - } - - - func testRandomPlayerInitialization() { - let randomPlayer = RandomPlayer(withName: "Random", andId: .player2) - XCTAssertNotNil(randomPlayer) - XCTAssertEqual(randomPlayer.name, "Random") - } - - func testRandomPlayerChooseMove() { - let randomPlayer = RandomPlayer(withName: "Random", andId: .player2) - let move = randomPlayer.chooseMove(board: mockBoard, rules: mockRules) - XCTAssertNotNil(move) - } -}*/ - - diff --git a/Model/Tests/ModelTests/VerySimpleRulesTests.swift b/Model/Tests/ModelTests/VerySimpleRulesTests.swift index 980acc5..511d579 100644 --- a/Model/Tests/ModelTests/VerySimpleRulesTests.swift +++ b/Model/Tests/ModelTests/VerySimpleRulesTests.swift @@ -56,63 +56,100 @@ class VerySimpleRulesTests: XCTestCase { let invalidBoard = Board(withGrid: invalidCells)! XCTAssertThrowsError(try VerySimpleRules.checkBoard(b: invalidBoard)) } + + func testMoveValidation() { + // Testez un mouvement valide + let validMove = Move(owner: .player1, rowOrigin: 0, columnOrigin: 1, rowDestination: 1, columnDestination: 1) + XCTAssertTrue(rules.isMoveValid(board: board, move: validMove), "Le mouvement valide n'a pas été reconnu comme tel") + + // Testez un mouvement invalide + let invalidMove = Move(owner: .player1, rowOrigin: 0, columnOrigin: 1, rowDestination: 3, columnDestination: 3) + XCTAssertFalse(rules.isMoveValid(board: board, move: invalidMove), "Le mouvement invalide a été reconnu comme valide") + } - func testGetMoves() { - // Supposons que pour une configuration de plateau spécifique, vous attendiez 3 mouvements possibles pour le joueur 1 - let expectedMoveCountForPlayer1 = 3 // Remplacez 3 par le nombre correct basé sur votre jeu + func testGameProgression() { + // Effectuer un mouvement valide + let move = Move(owner: .player1, rowOrigin: 0, columnOrigin: 1, rowDestination: 1, columnDestination: 1) + do { + try rules.playedMove(move: move, to: &board) + } catch { + XCTFail("Le mouvement n'a pas été appliqué comme prévu: \(error)") + } - // Test pour vérifier si getMoves retourne les bons mouvements pour le joueur 1 - let movesForPlayer1 = rules.getMoves(board: board, owner: .player1) + // Vérifier que l'historique des mouvements a été mis à jour + XCTAssertEqual(rules.historic.count, 1, "L'historique des mouvements n'a pas été correctement mis à jour") - // XCTAssertEqual(movesForPlayer1.count, expectedMoveCountForPlayer1) + // Vérifier le changement de joueur + let nextPlayer = rules.getNextPlayer() + XCTAssertEqual(nextPlayer, .player2, "Le joueur suivant n'a pas été correctement mis à jour") } - func testIsMoveValid() { - // Test pour un mouvement valide - let validMove = Move(owner: .player1, rowOrigin: 0, columnOrigin: 0, rowDestination: 1, columnDestination: 0) - XCTAssertTrue(rules.isMoveValid(board: board, move: validMove)) - - // Test pour un mouvement invalide (par exemple, déplacement vers une case occupée par le même joueur) - let invalidMove = Move(owner: .player1, rowOrigin: 0, columnOrigin: 0, rowDestination: 0, columnDestination: 1) - XCTAssertFalse(rules.isMoveValid(board: board, move: invalidMove)) + func testGameProgressionWithInvalidMove() { + // Essayer d'effectuer un mouvement invalide + let invalidMove = Move(owner: .player1, rowOrigin: 0, columnOrigin: 1, rowDestination: 3, columnDestination: 3) + XCTAssertThrowsError(try rules.playedMove(move: invalidMove, to: &board), "Un mouvement invalide a été accepté") { error in + guard let gameError = error as? GameError else { + XCTFail("Type d'erreur inattendu") + return + } + switch gameError { + case .invalidMove: + // Succès attendu, le mouvement est invalide + break + default: + XCTFail("Erreur inattendue pour un mouvement invalide") + } + } } - - func testIsGameOver() { - // Assurez-vous que `board` est bien initialisé - guard let currentBoard = board else { - XCTFail("Board is not initialized") - return + + func testGameOverConditions() { + // Utiliser `isGameOver` pour vérifier l'état de fin de jeu + let (isOver, result) = rules.isGameOver(board: board, lastMove: Move(owner: .player1, rowOrigin: 0, columnOrigin: 2, rowDestination: 4, columnDestination: 2)) + XCTAssertTrue(isOver, "Le jeu ne s'est pas terminé comme prévu") + + // Vérifier le résultat du jeu + switch result { + case .winner(let owner, let reason): + XCTAssertEqual(owner, .player1, "Le mauvais joueur a été déclaré gagnant") + // Ajouter des assertions spécifiques pour la raison de la victoire si nécessaire + default: + XCTFail("Résultat de fin de jeu inattendu") } + } - // Créez un mouvement qui simule une fin de partie - let winningMove = Move(owner: .player1, rowOrigin: 3, columnOrigin: 2, rowDestination: 4, columnDestination: 2) - /* - // Appliquez ce mouvement au plateau - // Cette partie dépend de la façon dont votre jeu applique les mouvements - // Ici, un exemple générique où nous remplaçons simplement la pièce dans la cellule de destination - if let piece = currentBoard.grid[winningMove.rowOrigin][winningMove.columnOrigin].piece { - currentBoard.grid[winningMove.rowDestination][winningMove.columnDestination].piece = piece - currentBoard.grid[winningMove.rowOrigin][winningMove.columnOrigin].piece = nil - } - */ + // Test pour obtenir une cellule spécifique du plateau + func testGetCell() { + let cell = board.getCell(atRow: 0, atColumn: 0) + XCTAssertNotNil(cell, "La cellule n'a pas été correctement récupérée") + } - // Testez si `isGameOver` détecte correctement la fin de partie - let (isGameOver, result) = rules.isGameOver(board: currentBoard, lastMove: winningMove) + // Test pour obtenir les mouvements possibles pour un joueur + func testGetMoves() { + // Supposons que le joueur 1 ait des mouvements valides depuis sa position initiale + let moves = rules.getMoves(board: board, owner: .player1) + XCTAssertFalse(moves.isEmpty, "Aucun mouvement possible trouvé pour le joueur 1") + } - XCTAssertTrue(isGameOver) - // Vérifiez le résultat spécifique de la fin de partie - switch result { - case .winner(let winner, let winCondition): - XCTAssertEqual(winner, .player1) - XCTAssertEqual(winCondition, .denReached) - default: - XCTFail("Unexpected game over result") - } + // Test pour vérifier le comportement de la fonction de mouvement + func testPlayedMove() { + // Assumer un mouvement valide + let move = Move(owner: .player1, rowOrigin: 0, columnOrigin: 1, rowDestination: 1, columnDestination: 1) + XCTAssertNoThrow(try rules.playedMove(move: move, to: &board), "Le mouvement valide a provoqué une erreur") + + // Vérifier l'état du plateau après le mouvement + let destinationCell = board.getCell(atRow: 1, atColumn: 1) + XCTAssertNotNil(destinationCell?.piece, "La pièce n'a pas été déplacée vers la nouvelle cellule") + XCTAssertEqual(destinationCell?.piece?.owner, .player1, "La pièce déplacée n'appartient pas au joueur 1") + } + + // Test pour valider un mouvement spécifique en utilisant des coordonnées + func testIsMoveValidWithCoordinates() { + // Valider un mouvement en utilisant des coordonnées directes + XCTAssertTrue(rules.isMoveValid(board: board, row: 0, column: 1, rowArrived: 1, columnArrived: 1), "Le mouvement valide n'a pas été reconnu") + + // Tester un mouvement invalide (par exemple, trop loin) + XCTAssertFalse(rules.isMoveValid(board: board, row: 0, column: 0, rowArrived: 3, columnArrived: 3), "Un mouvement invalide a été reconnu comme valide") } - static var allTests = [ - ("testCreateBoard", testCreateBoard), - ("testGetNextPlayer", testGetNextPlayer), - ] }