From 01de2848d1fc68ef9b23dd6095257ca10f6a6f93 Mon Sep 17 00:00:00 2001
From: andriluccahannes <lb214@hdm-stuttgart.de>
Date: Thu, 22 Feb 2024 17:17:01 +0100
Subject: [PATCH] 22.02.2024 - Implement Tournament Factory to ensure
expandability of project #32
---
.../controller/TournamentController.java | 184 +++++++++++++-----
.../mi/sthbackend/enums/TournamentType.java | 6 +
.../factory/TournamentServiceFactory.java | 47 +++++
.../service/ITournamentService.java | 70 +++++++
...> SingleEliminationTournamentService.java} | 51 ++---
... SingleEliminationTournamentTypeTest.java} | 26 +--
.../endpointTest/EndpointTests.java | 1 -
.../serviceTests/AddPlayerToTeamTest.java | 4 +-
.../serviceTests/CreateBracketTest.java | 22 +--
.../serviceTests/DetermineWinnerTest.java | 4 +-
.../serviceTests/FillBracketRandomTest.java | 12 +-
.../RemovePlayerFromTeamTest.java | 4 +-
.../serviceTests/UpdateScoreTest.java | 20 +-
13 files changed, 328 insertions(+), 123 deletions(-)
create mode 100644 sth-backend/src/main/java/hdm/mi/sthbackend/enums/TournamentType.java
create mode 100644 sth-backend/src/main/java/hdm/mi/sthbackend/factory/TournamentServiceFactory.java
create mode 100644 sth-backend/src/main/java/hdm/mi/sthbackend/service/ITournamentService.java
rename sth-backend/src/main/java/hdm/mi/sthbackend/service/{TournamentService.java => SingleEliminationTournamentService.java} (89%)
rename sth-backend/src/test/java/hdm/mi/sthbackend/{TournamentServiceTest.java => SingleEliminationTournamentTypeTest.java} (89%)
diff --git a/sth-backend/src/main/java/hdm/mi/sthbackend/controller/TournamentController.java b/sth-backend/src/main/java/hdm/mi/sthbackend/controller/TournamentController.java
index 506cf29..597036c 100644
--- a/sth-backend/src/main/java/hdm/mi/sthbackend/controller/TournamentController.java
+++ b/sth-backend/src/main/java/hdm/mi/sthbackend/controller/TournamentController.java
@@ -1,8 +1,9 @@
package hdm.mi.sthbackend.controller;
+import hdm.mi.sthbackend.enums.TournamentType;
import hdm.mi.sthbackend.exeptions.*;
+import hdm.mi.sthbackend.factory.TournamentServiceFactory;
import hdm.mi.sthbackend.model.Tournament;
-import hdm.mi.sthbackend.service.TournamentService;
import hdm.mi.sthbackend.service.UserService;
import hdm.mi.sthbackend.types.CreateTournament;
import hdm.mi.sthbackend.types.TeamMatchScore;
@@ -12,67 +13,107 @@ import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.*;
-import java.util.Arrays;
import java.util.List;
import java.util.UUID;
+import static hdm.mi.sthbackend.enums.TournamentType.SINGLE_ELIMINATION;
+
@RestController
-@RequestMapping("/api/v1")
+@RequestMapping( "/api/v1" )
@AllArgsConstructor
-@CrossOrigin(origins = "*",allowedHeaders = "*")
+@CrossOrigin( origins = "*", allowedHeaders = "*" )
public class TournamentController {
- private final TournamentService tournamentService;
+ private final TournamentServiceFactory tournamentServiceFactory;
private final UserService userService;
/**
* Player Endpoints
**/
- @PatchMapping("/tournaments/{tournamentId}/teams/{teamId}/players/{playerId}/updatePlayerName")
+ @PatchMapping( "/tournaments/{tournamentId}/teams/{teamId}/players/{playerId}/updatePlayerName" )
public UUID updatePlayerName(@PathVariable UUID tournamentId,
@PathVariable UUID teamId,
@PathVariable UUID playerId,
- @RequestBody String newPlayerName) throws PlayerIdNotFoundException, TeamIdNotFoundException, TournamentIdNotFoundException {
- return tournamentService.updatePlayerName(tournamentId, teamId, playerId, newPlayerName);
+ @RequestParam( name = "tournamentType", defaultValue = "SINGLE_ELIMINATION" ) TournamentType type,
+ @RequestBody String newPlayerName) throws
+ PlayerIdNotFoundException,
+ TeamIdNotFoundException,
+ TournamentIdNotFoundException {
+
+ return tournamentServiceFactory
+ .createTournamentService( type )
+ .updatePlayerName( tournamentId, teamId, playerId, newPlayerName );
}
/**
* Team Endpoints
**/
- @PostMapping("/tournaments/{tournamentId}/teams")
+ @PostMapping( "/tournaments/{tournamentId}/teams" )
public UUID createTeam(@PathVariable UUID tournamentId,
- @RequestBody TeamName teamName) throws TournamentIdNotFoundException {
- return tournamentService.createAndAddTeamToTournament(tournamentId, teamName.getName());
+ @RequestBody TeamName teamName,
+ @RequestParam( name = "type", defaultValue = "SINGLE_ELIMINATION" ) TournamentType type) throws
+ TournamentIdNotFoundException {
+
+ return tournamentServiceFactory
+ .createTournamentService( type )
+ .createAndAddTeamToTournament( tournamentId, teamName.getName() );
}
- @DeleteMapping("/tournaments/{tournamentId}/teams/{teamId}")
+ @DeleteMapping( "/tournaments/{tournamentId}/teams/{teamId}" )
public UUID removeTeamFromTournament(@PathVariable UUID tournamentId,
- @PathVariable UUID teamId) throws TournamentIdNotFoundException, TeamIdNotFoundException {
- return tournamentService.deleteAndRemoveTeamFromTournament(tournamentId, teamId);
+ @PathVariable UUID teamId,
+ @RequestParam( name = "type", defaultValue = "SINGLE_ELIMINATION" ) TournamentType type) throws
+ TournamentIdNotFoundException,
+ TeamIdNotFoundException {
+
+ return tournamentServiceFactory
+ .createTournamentService( type )
+ .deleteAndRemoveTeamFromTournament( tournamentId, teamId );
}
- @PostMapping("/tournaments/{tournamentId}/teams/{teamId}/addPlayer")
- public UUID addPlayerToTeam(@PathVariable UUID tournamentId, @PathVariable UUID teamId,
- @RequestBody String playerName) throws TeamIdNotFoundException, TournamentIdNotFoundException {
- return tournamentService.addPlayerToTeam(tournamentId, teamId, playerName);
+ @PostMapping( "/tournaments/{tournamentId}/teams/{teamId}/addPlayer" )
+ public UUID addPlayerToTeam(@PathVariable UUID tournamentId,
+ @PathVariable UUID teamId,
+ @RequestBody String playerName,
+ @RequestParam( name = "type", defaultValue = "SINGLE_ELIMINATION" ) TournamentType type) throws
+ TeamIdNotFoundException,
+ TournamentIdNotFoundException {
+
+ return tournamentServiceFactory
+ .createTournamentService( type )
+ .addPlayerToTeam( tournamentId, teamId, playerName );
}
@ResponseStatus
- @DeleteMapping("/tournaments/{tournamendId}/teams/{teamId}/players/{playerId}")
- public ResponseEntity<String> removePlayerFromTeam(@PathVariable UUID tournamendId, @PathVariable UUID teamId,
- @PathVariable UUID playerId) throws PlayerIdNotFoundException, TeamIdNotFoundException, TournamentIdNotFoundException {
- tournamentService.removePlayerFromTeam(tournamendId, teamId, playerId);
- return new ResponseEntity<>("Successfully deleted Player ...", HttpStatus.OK);
+ @DeleteMapping( "/tournaments/{tournamendId}/teams/{teamId}/players/{playerId}" )
+ public ResponseEntity<String> removePlayerFromTeam(@PathVariable UUID tournamendId,
+ @PathVariable UUID teamId,
+ @PathVariable UUID playerId,
+ @RequestParam( name = "type", defaultValue = "SINGLE_ELIMINATION" ) TournamentType type) throws
+ PlayerIdNotFoundException,
+ TeamIdNotFoundException,
+ TournamentIdNotFoundException {
+
+ tournamentServiceFactory
+ .createTournamentService( type )
+ .removePlayerFromTeam( tournamendId, teamId, playerId );
+ return new ResponseEntity<>( "Successfully deleted Player ...", HttpStatus.OK );
}
- @PatchMapping("/tournaments/{tournamentId}/teams/{teamId}/updateTeamName")
+ @PatchMapping( "/tournaments/{tournamentId}/teams/{teamId}/updateTeamName" )
public UUID updateTeamName(@PathVariable UUID tournamentId,
- @PathVariable UUID teamId,
- @RequestBody TeamName newTeamName) throws TeamIdNotFoundException, TournamentIdNotFoundException {
- return tournamentService.updateTeamName(tournamentId,teamId, newTeamName.getName());
+ @PathVariable UUID teamId,
+ @RequestBody TeamName newTeamName,
+ @RequestParam( name = "type", defaultValue = "SINGLE_ELIMINATION" ) TournamentType type) throws
+ TeamIdNotFoundException,
+ TournamentIdNotFoundException {
+
+ return tournamentServiceFactory
+ .createTournamentService( type )
+ .updateTeamName( tournamentId, teamId, newTeamName.getName() );
}
@@ -80,59 +121,100 @@ public class TournamentController {
* Match Endpoints
*/
- @PatchMapping("/tournaments/{tournamentId}/bracketRounds/{bracketRound}/matches/{matchId}/teams/{teamId}/updateScore")
+ @PatchMapping( "/tournaments/{tournamentId}/bracketRounds/{bracketRound}/matches/{matchId}/teams/{teamId}/updateScore" )
public ResponseEntity<String> updateScore(@PathVariable UUID tournamentId,
@PathVariable UUID matchId,
@PathVariable int bracketRound,
@PathVariable UUID teamId,
- @RequestBody TeamMatchScore newScore) throws MatchIdNotFoundException, TeamIdNotFoundException,
- BracketRoundNotFoundException, TournamentIdNotFoundException {
- tournamentService.updateScore(tournamentId, bracketRound, matchId, teamId, newScore.getScore());
- return new ResponseEntity<>("Successfully updated Score for match " + matchId + " ...", HttpStatus.OK);
+ @RequestBody TeamMatchScore newScore,
+ @RequestParam( name = "type", defaultValue = "SINGLE_ELIMINATION" ) TournamentType type) throws
+ MatchIdNotFoundException,
+ TeamIdNotFoundException,
+ BracketRoundNotFoundException,
+ TournamentIdNotFoundException {
+
+ tournamentServiceFactory
+ .createTournamentService( type )
+ .updateScore( tournamentId, bracketRound, matchId, teamId, newScore.getScore() );
+ return new ResponseEntity<>( "Successfully updated Score for match " + matchId + " ...", HttpStatus.OK );
}
- @PatchMapping("/tournaments/{tournamentId}/bracketRounds/{bracketRound}/matches/{matchId}/handleWinner")
- public UUID handleWinner(@PathVariable UUID tournamentId, @PathVariable int bracketRound, @PathVariable UUID matchId) throws MatchIdNotFoundException, WinnerNotDeterminedException, TournamentIdNotFoundException {
- return tournamentService.handleWinner(tournamentId, bracketRound, matchId);
+ @PatchMapping( "/tournaments/{tournamentId}/bracketRounds/{bracketRound}/matches/{matchId}/handleWinner" )
+ public UUID handleWinner(@PathVariable UUID tournamentId,
+ @PathVariable int bracketRound,
+ @PathVariable UUID matchId,
+ @RequestParam( name = "type", defaultValue = "SINGLE_ELIMINATION" ) TournamentType type) throws
+ MatchIdNotFoundException,
+ WinnerNotDeterminedException,
+ TournamentIdNotFoundException {
+
+ return tournamentServiceFactory
+ .createTournamentService( type )
+ .handleWinner( tournamentId, bracketRound, matchId );
}
/**
* Tournament Endpoints
*/
- @GetMapping("/tournaments/{tournamentId}")
- public Tournament findTournamentById(@PathVariable UUID tournamentId) throws TournamentIdNotFoundException {
- return tournamentService.getTournament(tournamentId);
+ @GetMapping( "/tournaments/{tournamentId}" )
+ public Tournament findTournamentById(@PathVariable UUID tournamentId,
+ @RequestParam( name = "type", defaultValue = "SINGLE_ELIMINATION" ) TournamentType type) throws
+ TournamentIdNotFoundException {
+
+ return tournamentServiceFactory
+ .createTournamentService( type )
+ .getTournament( tournamentId );
}
- @PostMapping("/tournaments")
- public Tournament createTournament(@RequestBody CreateTournament tournament) {
+ @PostMapping( "/tournaments" )
+ public Tournament createTournament(@RequestBody CreateTournament tournament,
+ @RequestParam( name = "type", defaultValue = "SINGLE_ELIMINATION" ) TournamentType type) {
String tournamentName = tournament.getTournamentName();
List<String> teamNames = tournament.getTeamNames();
UUID userId = tournament.getUserId();
- Tournament createdTournament = tournamentService.createTournament(new Tournament(tournamentName, teamNames));
- userService.addTournamentToUser(userId, createdTournament.getTournamentId());
+ Tournament createdTournament = tournamentServiceFactory
+ .createTournamentService( type )
+ .createTournament( new Tournament( tournamentName, teamNames ) );
+ userService.addTournamentToUser( userId, createdTournament.getTournamentId() );
return createdTournament;
}
- @DeleteMapping("/tournaments/{tournamentId}")
- public Tournament deleteTournament(@PathVariable UUID tournamentId) throws TournamentIdNotFoundException {
- return tournamentService.deleteTournament(tournamentId);
+ @DeleteMapping( "/tournaments/{tournamentId}" )
+ public Tournament deleteTournament(@PathVariable UUID tournamentId,
+ @RequestParam( name = "type", defaultValue = "SINGLE_ELIMINATION" ) TournamentType type) throws
+ TournamentIdNotFoundException {
+
+ return tournamentServiceFactory
+ .createTournamentService( type )
+ .deleteTournament( tournamentId );
}
- @PatchMapping("/tournaments/{tournamentId}/updateName")
+ @PatchMapping( "/tournaments/{tournamentId}/updateName" )
public UUID updateTournamentName(@PathVariable UUID tournamentId,
- @RequestBody String newTournamentName) throws TournamentIdNotFoundException {
- return tournamentService.updateTournamentName(tournamentId, newTournamentName);
+ @RequestBody String newTournamentName,
+ @RequestParam( name = "type", defaultValue = "SINGLE_ELIMINATION" ) TournamentType type) throws
+ TournamentIdNotFoundException {
+
+ return tournamentServiceFactory
+ .createTournamentService( type )
+ .updateTournamentName( tournamentId, newTournamentName );
}
- @PatchMapping("/tournaments/{tournamentId}/initialize")
- public Tournament initializeTournament(@PathVariable UUID tournamentId) throws TournamentIdNotFoundException, InsufficientTeamsException, BracketAlreadyInitializedException {
- return tournamentService.initializeTournament(tournamentId);
+ @PatchMapping( "/tournaments/{tournamentId}/initialize" )
+ public Tournament initializeTournament(@PathVariable UUID tournamentId,
+ @RequestParam( name = "type", defaultValue = "SINGLE_ELIMINATION" ) TournamentType type) throws
+ TournamentIdNotFoundException,
+ InsufficientTeamsException,
+ BracketAlreadyInitializedException {
+
+ return tournamentServiceFactory
+ .createTournamentService( type )
+ .initializeTournament( tournamentId );
}
}
diff --git a/sth-backend/src/main/java/hdm/mi/sthbackend/enums/TournamentType.java b/sth-backend/src/main/java/hdm/mi/sthbackend/enums/TournamentType.java
new file mode 100644
index 0000000..433ccd3
--- /dev/null
+++ b/sth-backend/src/main/java/hdm/mi/sthbackend/enums/TournamentType.java
@@ -0,0 +1,6 @@
+package hdm.mi.sthbackend.enums;
+
+public enum TournamentType {
+
+ SINGLE_ELIMINATION,
+}
diff --git a/sth-backend/src/main/java/hdm/mi/sthbackend/factory/TournamentServiceFactory.java b/sth-backend/src/main/java/hdm/mi/sthbackend/factory/TournamentServiceFactory.java
new file mode 100644
index 0000000..e809b19
--- /dev/null
+++ b/sth-backend/src/main/java/hdm/mi/sthbackend/factory/TournamentServiceFactory.java
@@ -0,0 +1,47 @@
+package hdm.mi.sthbackend.factory;
+
+import hdm.mi.sthbackend.enums.TournamentType;
+import hdm.mi.sthbackend.service.ITournamentService;
+import hdm.mi.sthbackend.service.SingleEliminationTournamentService;
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import org.springframework.stereotype.Component;
+
+import java.util.List;
+
+@Component
+public class TournamentServiceFactory {
+
+ public static final Logger logger = LogManager.getLogger( TournamentServiceFactory.class );
+
+ private final List<ITournamentService> tournamentServices;
+
+ public TournamentServiceFactory(List<ITournamentService> tournamentServices) {
+
+ this.tournamentServices = tournamentServices;
+ }
+
+ public ITournamentService createTournamentService(TournamentType tournamentType) {
+
+ switch ( tournamentType ) {
+ case SINGLE_ELIMINATION -> {
+ return getTournamentService( SingleEliminationTournamentService.class );
+ }
+ default -> {
+ return getTournamentService( SingleEliminationTournamentService.class );
+ }
+ }
+
+ }
+
+ private ITournamentService getTournamentService(Class tournamentServiceType) {
+
+ return tournamentServices
+ .stream()
+ .filter( tournamentServiceType::isInstance )
+ .findFirst()
+ .orElseThrow( () -> new IllegalArgumentException( "Tournament service not found" ) );
+ }
+
+
+}
diff --git a/sth-backend/src/main/java/hdm/mi/sthbackend/service/ITournamentService.java b/sth-backend/src/main/java/hdm/mi/sthbackend/service/ITournamentService.java
new file mode 100644
index 0000000..009e2eb
--- /dev/null
+++ b/sth-backend/src/main/java/hdm/mi/sthbackend/service/ITournamentService.java
@@ -0,0 +1,70 @@
+package hdm.mi.sthbackend.service;
+
+import hdm.mi.sthbackend.exeptions.*;
+import hdm.mi.sthbackend.model.Tournament;
+
+import java.util.UUID;
+
+public interface ITournamentService {
+ UUID addPlayerToTeam(UUID tournamentId, UUID teamId, String playerName) throws
+ TournamentIdNotFoundException,
+ TeamIdNotFoundException;
+
+ void removePlayerFromTeam(UUID tournamentId, UUID teamId, UUID playerId) throws
+ PlayerIdNotFoundException,
+ TeamIdNotFoundException,
+ TournamentIdNotFoundException;
+
+ UUID updatePlayerName(UUID tournamentId, UUID teamId, UUID playerId, String newPlayerName) throws
+ PlayerIdNotFoundException,
+ TournamentIdNotFoundException,
+ TeamIdNotFoundException;
+
+ UUID createAndAddTeamToTournament(UUID tournamentId, String teamName) throws TournamentIdNotFoundException;
+
+ UUID deleteAndRemoveTeamFromTournament(UUID tournamentId, UUID teamId) throws
+ TournamentIdNotFoundException,
+ TeamIdNotFoundException;
+
+ UUID updateTeamName(UUID tournamentId, UUID teamId, String newTeamName) throws
+ TeamIdNotFoundException,
+ TournamentIdNotFoundException;
+
+ UUID handleWinner(UUID tournamentId, int bracketRound, UUID matchId) throws
+ MatchIdNotFoundException,
+ WinnerNotDeterminedException,
+ TournamentIdNotFoundException;
+
+ Tournament assignTeamToMatch(Tournament tournament, int bracketRound, UUID matchId, UUID teamId) throws
+ MatchIdNotFoundException;
+
+ void updateScore(UUID tournamentId, int bracketRound, UUID matchId, UUID teamId, int newScore) throws
+ MatchIdNotFoundException,
+ TeamIdNotFoundException,
+ TournamentIdNotFoundException,
+ BracketRoundNotFoundException;
+
+ /*
+ * BracketRound service methods
+ */
+ Tournament createBracket(Tournament tournament) throws
+ InsufficientTeamsException,
+ BracketAlreadyInitializedException;
+
+ Tournament linkMatchesInNextRound(Tournament tournament);
+
+ Tournament fillBracketRandom(Tournament tournament);
+
+ Tournament createTournament(Tournament tournament);
+
+ Tournament initializeTournament(UUID tournamentId) throws
+ TournamentIdNotFoundException,
+ InsufficientTeamsException,
+ BracketAlreadyInitializedException;
+
+ UUID updateTournamentName(UUID tournamentId, String newTournamentName) throws TournamentIdNotFoundException;
+
+ Tournament getTournament(UUID tournamentId) throws TournamentIdNotFoundException;
+
+ Tournament deleteTournament(UUID tournamentId) throws TournamentIdNotFoundException;
+}
diff --git a/sth-backend/src/main/java/hdm/mi/sthbackend/service/TournamentService.java b/sth-backend/src/main/java/hdm/mi/sthbackend/service/SingleEliminationTournamentService.java
similarity index 89%
rename from sth-backend/src/main/java/hdm/mi/sthbackend/service/TournamentService.java
rename to sth-backend/src/main/java/hdm/mi/sthbackend/service/SingleEliminationTournamentService.java
index fdb7f46..38460bb 100644
--- a/sth-backend/src/main/java/hdm/mi/sthbackend/service/TournamentService.java
+++ b/sth-backend/src/main/java/hdm/mi/sthbackend/service/SingleEliminationTournamentService.java
@@ -15,9 +15,9 @@ import java.util.*;
@Service
@AllArgsConstructor
-public class TournamentService {
+public class SingleEliminationTournamentService implements ITournamentService {
- private final Logger log = LogManager.getLogger(TournamentService.class);
+ private final Logger log = LogManager.getLogger( SingleEliminationTournamentService.class);
ITournamentRepository tournamentRepository;
@@ -28,8 +28,8 @@ public class TournamentService {
* Player service methods
*/
- public UUID addPlayerToTeam(UUID tournamentId, UUID teamId,
- String playerName) throws TournamentIdNotFoundException, TeamIdNotFoundException {
+ @Override
+ public UUID addPlayerToTeam(UUID tournamentId, UUID teamId, String playerName) throws TournamentIdNotFoundException, TeamIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
@@ -46,8 +46,8 @@ public class TournamentService {
return newPlayer.getPlayerId();
}
- public void removePlayerFromTeam(UUID tournamentId, UUID teamId,
- UUID playerId) throws PlayerIdNotFoundException, TeamIdNotFoundException, TournamentIdNotFoundException {
+ @Override
+ public void removePlayerFromTeam(UUID tournamentId, UUID teamId, UUID playerId) throws PlayerIdNotFoundException, TeamIdNotFoundException, TournamentIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
@@ -65,8 +65,8 @@ public class TournamentService {
log.debug("Player " + removedPlayer.getPlayerId() + " removed from Team " + teamId);
}
- public UUID updatePlayerName(UUID tournamentId, UUID teamId, UUID playerId,
- String newPlayerName) throws PlayerIdNotFoundException, TournamentIdNotFoundException, TeamIdNotFoundException {
+ @Override
+ public UUID updatePlayerName(UUID tournamentId, UUID teamId, UUID playerId, String newPlayerName) throws PlayerIdNotFoundException, TournamentIdNotFoundException, TeamIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
@@ -87,6 +87,7 @@ public class TournamentService {
* Team service methods
*/
+ @Override
public UUID createAndAddTeamToTournament(UUID tournamentId, String teamName) throws TournamentIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
@@ -100,8 +101,8 @@ public class TournamentService {
return newTeam.getTeamId();
}
- public UUID deleteAndRemoveTeamFromTournament(UUID tournamentId,
- UUID teamId) throws TournamentIdNotFoundException, TeamIdNotFoundException {
+ @Override
+ public UUID deleteAndRemoveTeamFromTournament(UUID tournamentId, UUID teamId) throws TournamentIdNotFoundException, TeamIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
@@ -116,9 +117,8 @@ public class TournamentService {
return teamId;
}
- public UUID updateTeamName(UUID tournamentId,
- UUID teamId,
- String newTeamName) throws TeamIdNotFoundException, TournamentIdNotFoundException {
+ @Override
+ public UUID updateTeamName(UUID tournamentId, UUID teamId, String newTeamName) throws TeamIdNotFoundException, TournamentIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
@@ -136,10 +136,8 @@ public class TournamentService {
* Match service methods
*/
- public UUID handleWinner(UUID tournamentId,
- int bracketRound,
- UUID matchId
- ) throws MatchIdNotFoundException, WinnerNotDeterminedException, TournamentIdNotFoundException {
+ @Override
+ public UUID handleWinner(UUID tournamentId, int bracketRound, UUID matchId) throws MatchIdNotFoundException, WinnerNotDeterminedException, TournamentIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
@@ -177,10 +175,8 @@ public class TournamentService {
return winnerTeamId;
}
- public Tournament assignTeamToMatch(Tournament tournament,
- int bracketRound,
- UUID matchId,
- UUID teamId) throws MatchIdNotFoundException {
+ @Override
+ public Tournament assignTeamToMatch(Tournament tournament, int bracketRound, UUID matchId, UUID teamId) throws MatchIdNotFoundException {
try {
tournament
@@ -199,9 +195,8 @@ public class TournamentService {
}
- public void updateScore(UUID tournamentId, int bracketRound, UUID matchId,
- UUID teamId,
- int newScore) throws MatchIdNotFoundException, TeamIdNotFoundException, TournamentIdNotFoundException, BracketRoundNotFoundException {
+ @Override
+ public void updateScore(UUID tournamentId, int bracketRound, UUID matchId, UUID teamId, int newScore) throws MatchIdNotFoundException, TeamIdNotFoundException, TournamentIdNotFoundException, BracketRoundNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
@@ -230,6 +225,7 @@ public class TournamentService {
/*
* BracketRound service methods
*/
+ @Override
public Tournament createBracket(Tournament tournament) throws InsufficientTeamsException, BracketAlreadyInitializedException {
Map<UUID, Team> teams = tournament.getTeams();
@@ -267,6 +263,7 @@ public class TournamentService {
return tournament;
}
+ @Override
public Tournament linkMatchesInNextRound(Tournament tournament) {
int timesUsed = 0;
Map<UUID, Match> nextRoundMatches;
@@ -301,6 +298,7 @@ public class TournamentService {
}
+ @Override
public Tournament fillBracketRandom(Tournament tournament) {
Map<UUID, Team> teams = new HashMap<>(Map.copyOf(tournament.getTeams()));
@@ -332,6 +330,7 @@ public class TournamentService {
* Tournament service methods
*/
+ @Override
public Tournament createTournament(Tournament tournament) {
tournamentRepository.insert(tournament);
@@ -339,6 +338,7 @@ public class TournamentService {
return tournament;
}
+ @Override
public Tournament initializeTournament(UUID tournamentId) throws TournamentIdNotFoundException, InsufficientTeamsException, BracketAlreadyInitializedException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
@@ -351,6 +351,7 @@ public class TournamentService {
return tournamentWithFilledBrackets;
}
+ @Override
public UUID updateTournamentName(UUID tournamentId, String newTournamentName) throws TournamentIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
@@ -361,6 +362,7 @@ public class TournamentService {
return tournamentId;
}
+ @Override
public Tournament getTournament(UUID tournamentId) throws TournamentIdNotFoundException {
Tournament tournament = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
@@ -369,6 +371,7 @@ public class TournamentService {
return tournament;
}
+ @Override
public Tournament deleteTournament(UUID tournamentId) throws TournamentIdNotFoundException {
Tournament tournamentToDelete = tournamentRepository.findById(tournamentId)
.orElseThrow(() -> new TournamentIdNotFoundException(tournamentId));
diff --git a/sth-backend/src/test/java/hdm/mi/sthbackend/TournamentServiceTest.java b/sth-backend/src/test/java/hdm/mi/sthbackend/SingleEliminationTournamentTypeTest.java
similarity index 89%
rename from sth-backend/src/test/java/hdm/mi/sthbackend/TournamentServiceTest.java
rename to sth-backend/src/test/java/hdm/mi/sthbackend/SingleEliminationTournamentTypeTest.java
index d7259eb..30f2593 100644
--- a/sth-backend/src/test/java/hdm/mi/sthbackend/TournamentServiceTest.java
+++ b/sth-backend/src/test/java/hdm/mi/sthbackend/SingleEliminationTournamentTypeTest.java
@@ -5,7 +5,7 @@ import hdm.mi.sthbackend.exeptions.PlayerIdNotFoundException;
import hdm.mi.sthbackend.exeptions.TournamentIdNotFoundException;
import hdm.mi.sthbackend.model.*;
import hdm.mi.sthbackend.repository.ITournamentRepository;
-import hdm.mi.sthbackend.service.TournamentService;
+import hdm.mi.sthbackend.service.SingleEliminationTournamentService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.jupiter.api.Test;
@@ -25,11 +25,11 @@ import static org.mockito.Mockito.*;
@SpringBootTest
@ExtendWith(MockitoExtension.class)
-public class TournamentServiceTest {
+public class SingleEliminationTournamentTypeTest {
private final Logger log = LogManager.getLogger("TournamentControllerTest");
@InjectMocks
- private TournamentService tournamentService;
+ private SingleEliminationTournamentService singleEliminationTournamentService;
@Mock
ITournamentRepository tournamentRepository;
@@ -51,7 +51,7 @@ public class TournamentServiceTest {
when(tournamentRepository.findById(tournamentId)).thenReturn(Optional.of(tournament));
- UUID result = tournamentService.addPlayerToTeam(tournamentId, teamId, testString);
+ UUID result = singleEliminationTournamentService.addPlayerToTeam(tournamentId, teamId, testString);
assertNotNull(result);
verify(tournamentRepository, times(1)).findById(tournamentId);
@@ -79,7 +79,7 @@ public class TournamentServiceTest {
when(tournamentRepository.findById(tournamentId)).thenReturn(Optional.of(tournament));
- tournamentService.removePlayerFromTeam(tournamentId, teamId, playerId);
+ singleEliminationTournamentService.removePlayerFromTeam(tournamentId, teamId, playerId);
verify(tournamentRepository, times(1)).findById(tournamentId);
verify(tournamentRepository, times(1)).save(tournament);
@@ -110,7 +110,7 @@ public class TournamentServiceTest {
assertFalse(tournament.getBracket().get(0).getMatches().get(matchId).getTeamScores().containsKey(teamId));
- Tournament result = tournamentService.assignTeamToMatch(tournament,0,matchId,teamId);
+ Tournament result = singleEliminationTournamentService.assignTeamToMatch(tournament,0,matchId,teamId);
assertNotNull(result);
assertTrue(result.getBracket().get(0).getMatches().get(matchId).getTeamScores().containsKey(teamId));
@@ -137,7 +137,7 @@ public class TournamentServiceTest {
tournament.getBracket().get(0).getMatches().put(matchId,match);
assertThrows(MatchIdNotFoundException.class, () -> {
- tournamentService.assignTeamToMatch(tournament,0,notCreatedMatchId,teamId);
+ singleEliminationTournamentService.assignTeamToMatch(tournament,0,notCreatedMatchId,teamId);
});
}
@@ -147,7 +147,7 @@ public class TournamentServiceTest {
teamNames.add("machine");
Tournament tournament = new Tournament("testtunier",teamNames);
- Tournament result = tournamentService.createTournament(tournament);
+ Tournament result = singleEliminationTournamentService.createTournament(tournament);
assertNotNull(result);
assertEquals(tournament,result);
@@ -174,7 +174,7 @@ public class TournamentServiceTest {
when(tournamentRepository.findById(tournamentId)).thenReturn(Optional.of(tournament));
- UUID result = tournamentService.updatePlayerName(tournamentId,teamId,playerId,testString);
+ UUID result = singleEliminationTournamentService.updatePlayerName(tournamentId,teamId,playerId,testString);
assertNotNull(result);
assertEquals(testString, player.getName());
@@ -201,7 +201,7 @@ public class TournamentServiceTest {
when(tournamentRepository.findById(tournamentId)).thenReturn(Optional.of(tournament));
assertThrows(PlayerIdNotFoundException.class, () -> {
- tournamentService.updatePlayerName(tournamentId, teamId, playerId, testString);
+ singleEliminationTournamentService.updatePlayerName(tournamentId, teamId, playerId, testString);
});
verify(tournamentRepository, times(1)).findById(tournamentId);
@@ -225,7 +225,7 @@ public class TournamentServiceTest {
when(tournamentRepository.findById(tournamentId)).thenReturn(Optional.empty());
assertThrows(TournamentIdNotFoundException.class, () -> {
- tournamentService.updatePlayerName(tournamentId, teamId, playerId, testString);
+ singleEliminationTournamentService.updatePlayerName(tournamentId, teamId, playerId, testString);
});
verify(tournamentRepository, times(1)).findById(tournamentId);
@@ -240,7 +240,7 @@ public class TournamentServiceTest {
when(tournamentRepository.findById(tournamentId)).thenReturn(Optional.of(tournament));
- UUID result = tournamentService.createAndAddTeamToTournament(tournamentId, teamName);
+ UUID result = singleEliminationTournamentService.createAndAddTeamToTournament(tournamentId, teamName);
verify(tournamentRepository, times(1)).findById(tournamentId);
verify(tournamentRepository, times(1)).save(tournament);
@@ -266,7 +266,7 @@ public class TournamentServiceTest {
when(tournamentRepository.findById(tournamentId)).thenReturn(Optional.of(tournament));
- UUID result = tournamentService.deleteAndRemoveTeamFromTournament(tournamentId, teamId);
+ UUID result = singleEliminationTournamentService.deleteAndRemoveTeamFromTournament(tournamentId, teamId);
verify(tournamentRepository, times(1)).findById(tournamentId);
verify(tournamentRepository, times(1)).save(tournament);
diff --git a/sth-backend/src/test/java/hdm/mi/sthbackend/endpointTest/EndpointTests.java b/sth-backend/src/test/java/hdm/mi/sthbackend/endpointTest/EndpointTests.java
index 647344f..e219b3b 100644
--- a/sth-backend/src/test/java/hdm/mi/sthbackend/endpointTest/EndpointTests.java
+++ b/sth-backend/src/test/java/hdm/mi/sthbackend/endpointTest/EndpointTests.java
@@ -5,7 +5,6 @@ import com.jayway.jsonpath.JsonPath;
import hdm.mi.sthbackend.exeptions.TournamentIdNotFoundException;
import hdm.mi.sthbackend.model.Tournament;
import hdm.mi.sthbackend.repository.ITournamentRepository;
-import hdm.mi.sthbackend.service.TournamentService;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.autoconfigure.web.servlet.AutoConfigureMockMvc;
diff --git a/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/AddPlayerToTeamTest.java b/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/AddPlayerToTeamTest.java
index f38b921..58080d2 100644
--- a/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/AddPlayerToTeamTest.java
+++ b/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/AddPlayerToTeamTest.java
@@ -5,7 +5,7 @@ import hdm.mi.sthbackend.exeptions.TournamentIdNotFoundException;
import hdm.mi.sthbackend.model.Team;
import hdm.mi.sthbackend.model.Tournament;
import hdm.mi.sthbackend.repository.ITournamentRepository;
-import hdm.mi.sthbackend.service.TournamentService;
+import hdm.mi.sthbackend.service.SingleEliminationTournamentService;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
@@ -28,7 +28,7 @@ public class AddPlayerToTeamTest {
ITournamentRepository repository;
@InjectMocks
- TournamentService service;
+ SingleEliminationTournamentService service;
@Test
void shouldAddPlayerToTeam() throws TeamIdNotFoundException, TournamentIdNotFoundException {
diff --git a/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/CreateBracketTest.java b/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/CreateBracketTest.java
index e1a6f4e..7a6262b 100644
--- a/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/CreateBracketTest.java
+++ b/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/CreateBracketTest.java
@@ -4,25 +4,23 @@ import hdm.mi.sthbackend.dummyObjects.DummyTournaments;
import hdm.mi.sthbackend.exeptions.BracketAlreadyInitializedException;
import hdm.mi.sthbackend.exeptions.InsufficientTeamsException;
import hdm.mi.sthbackend.model.Tournament;
-import hdm.mi.sthbackend.service.TournamentService;
+import hdm.mi.sthbackend.service.SingleEliminationTournamentService;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
-import static hdm.mi.sthbackend.dummyObjects.DummyTournaments.*;
-
@SpringBootTest()
class CreateBracketTest {
@Autowired
- TournamentService tournamentService;
+ SingleEliminationTournamentService singleEliminationTournamentService;
DummyTournaments tournaments = new DummyTournaments();
@Test
void create2TeamBracketTest() throws InsufficientTeamsException, BracketAlreadyInitializedException {
- Tournament resultTournament = tournamentService.createBracket(tournaments.getDummyTournament("dummyName",2 ));
+ Tournament resultTournament = singleEliminationTournamentService.createBracket(tournaments.getDummyTournament("dummyName",2 ));
Assertions.assertEquals(1, resultTournament.getBracket()
.size());
@@ -34,7 +32,7 @@ class CreateBracketTest {
@Test
void create4TeamBracketTest() throws InsufficientTeamsException, BracketAlreadyInitializedException {
- Tournament resultTournament = tournamentService.createBracket(tournaments.getDummyTournament("dummyName", 4));
+ Tournament resultTournament = singleEliminationTournamentService.createBracket(tournaments.getDummyTournament("dummyName", 4));
Assertions.assertEquals(2, resultTournament.getBracket()
.size());
@@ -50,7 +48,7 @@ class CreateBracketTest {
@Test
void create8TeamBracketTest() throws InsufficientTeamsException, BracketAlreadyInitializedException {
- Tournament resultTournament = tournamentService.createBracket(tournaments.getDummyTournament("dummyName", 8));
+ Tournament resultTournament = singleEliminationTournamentService.createBracket(tournaments.getDummyTournament("dummyName", 8));
Assertions.assertEquals(3, resultTournament.getBracket()
.size());
@@ -70,7 +68,7 @@ class CreateBracketTest {
@Test
void create16TeamBracketTest() throws InsufficientTeamsException, BracketAlreadyInitializedException {
- Tournament resultTournament = tournamentService.createBracket(tournaments.getDummyTournament("dummyName", 16));
+ Tournament resultTournament = singleEliminationTournamentService.createBracket(tournaments.getDummyTournament("dummyName", 16));
Assertions.assertEquals(4, resultTournament.getBracket()
.size());
@@ -94,12 +92,12 @@ class CreateBracketTest {
@Test
void create1TeamBracketTest() {
- Assertions.assertThrows(InsufficientTeamsException.class, () -> tournamentService.createBracket(tournaments.getDummyTournament("dummyName", 1)));
+ Assertions.assertThrows(InsufficientTeamsException.class, () -> singleEliminationTournamentService.createBracket(tournaments.getDummyTournament("dummyName", 1)));
}
@Test
void create3TeamBracketTest() throws InsufficientTeamsException, BracketAlreadyInitializedException {
- Tournament resultTournament = tournamentService.createBracket(tournaments.getDummyTournament("dummyName", 3));
+ Tournament resultTournament = singleEliminationTournamentService.createBracket(tournaments.getDummyTournament("dummyName", 3));
Assertions.assertEquals(2, resultTournament.getBracket()
.size());
@@ -115,7 +113,7 @@ class CreateBracketTest {
@Test
void create5TeamBracketTest() throws InsufficientTeamsException, BracketAlreadyInitializedException {
- Tournament resultTournament = tournamentService.createBracket(tournaments.getDummyTournament("dummyName", 5));
+ Tournament resultTournament = singleEliminationTournamentService.createBracket(tournaments.getDummyTournament("dummyName", 5));
Assertions.assertEquals(3, resultTournament.getBracket()
.size());
@@ -135,7 +133,7 @@ class CreateBracketTest {
@Test
void create15TeamBracketTest() throws InsufficientTeamsException, BracketAlreadyInitializedException {
- Tournament resultTournament = tournamentService.createBracket(tournaments.getDummyTournament("dummyName", 15));
+ Tournament resultTournament = singleEliminationTournamentService.createBracket(tournaments.getDummyTournament("dummyName", 15));
Assertions.assertEquals(4, resultTournament.getBracket()
.size(), 4);
diff --git a/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/DetermineWinnerTest.java b/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/DetermineWinnerTest.java
index 5ac6457..2062520 100644
--- a/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/DetermineWinnerTest.java
+++ b/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/DetermineWinnerTest.java
@@ -5,7 +5,7 @@ import hdm.mi.sthbackend.exeptions.*;
import hdm.mi.sthbackend.model.Match;
import hdm.mi.sthbackend.model.Tournament;
import hdm.mi.sthbackend.repository.ITournamentRepository;
-import hdm.mi.sthbackend.service.TournamentService;
+import hdm.mi.sthbackend.service.SingleEliminationTournamentService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.jupiter.api.Assertions;
@@ -30,7 +30,7 @@ class DetermineWinnerTest {
ITournamentRepository tournamentRepository;
@InjectMocks
- TournamentService service;
+ SingleEliminationTournamentService service;
@Test
void determineWinnerShouldFindWinner() throws Exception {
diff --git a/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/FillBracketRandomTest.java b/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/FillBracketRandomTest.java
index 88b9ba9..c956517 100644
--- a/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/FillBracketRandomTest.java
+++ b/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/FillBracketRandomTest.java
@@ -4,7 +4,7 @@ import hdm.mi.sthbackend.dummyObjects.DummyTournaments;
import hdm.mi.sthbackend.model.BracketRound;
import hdm.mi.sthbackend.model.Match;
import hdm.mi.sthbackend.model.Tournament;
-import hdm.mi.sthbackend.service.TournamentService;
+import hdm.mi.sthbackend.service.SingleEliminationTournamentService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.jupiter.api.Test;
@@ -21,7 +21,7 @@ class FillBracketRandomTest {
private final Logger log = LogManager.getLogger("FillBracketTest");
@Autowired
- TournamentService tournamentService;
+ SingleEliminationTournamentService singleEliminationTournamentService;
DummyTournaments tournaments = new DummyTournaments();
@@ -50,7 +50,7 @@ class FillBracketRandomTest {
@Test
void fill2TeamBracketRandomTest() {
Tournament t1withMatches = createDummyBracketAndMatches(1, tournaments.getDummyTournament("dummyName", 2));
- Tournament t1Filled = tournamentService.fillBracketRandom(t1withMatches);
+ Tournament t1Filled = singleEliminationTournamentService.fillBracketRandom(t1withMatches);
int teamSum = calculateTeamSum(t1Filled);
assertEquals(2,teamSum);
@@ -59,7 +59,7 @@ class FillBracketRandomTest {
@Test
void fill4TeamBracketRandomTest() {
Tournament t2withMatches = createDummyBracketAndMatches(2, tournaments.getDummyTournament("dummyName", 4));
- Tournament t2Filled = tournamentService.fillBracketRandom(t2withMatches);
+ Tournament t2Filled = singleEliminationTournamentService.fillBracketRandom(t2withMatches);
int teamSum = calculateTeamSum(t2Filled);
assertEquals(4,teamSum);
@@ -68,7 +68,7 @@ class FillBracketRandomTest {
@Test
void fill8TeamBracketRandomTest() {
Tournament t3withMatches = createDummyBracketAndMatches(3, tournaments.getDummyTournament("dummyName", 8));
- Tournament t3Filled = tournamentService.fillBracketRandom(t3withMatches);
+ Tournament t3Filled = singleEliminationTournamentService.fillBracketRandom(t3withMatches);
int teamSum = calculateTeamSum(t3Filled);
assertEquals(8,teamSum);
@@ -78,7 +78,7 @@ class FillBracketRandomTest {
@Test
void fill16TeamBracketRandomTest() {
Tournament t4withMatches = createDummyBracketAndMatches(4, tournaments.getDummyTournament("dummyName", 16));
- Tournament t4Filled = tournamentService.fillBracketRandom(t4withMatches);
+ Tournament t4Filled = singleEliminationTournamentService.fillBracketRandom(t4withMatches);
int teamSum = calculateTeamSum(t4Filled);
assertEquals(16,teamSum);
diff --git a/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/RemovePlayerFromTeamTest.java b/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/RemovePlayerFromTeamTest.java
index ad92216..856577a 100644
--- a/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/RemovePlayerFromTeamTest.java
+++ b/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/RemovePlayerFromTeamTest.java
@@ -6,7 +6,7 @@ import hdm.mi.sthbackend.exeptions.TournamentIdNotFoundException;
import hdm.mi.sthbackend.model.Team;
import hdm.mi.sthbackend.model.Tournament;
import hdm.mi.sthbackend.repository.ITournamentRepository;
-import hdm.mi.sthbackend.service.TournamentService;
+import hdm.mi.sthbackend.service.SingleEliminationTournamentService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.jupiter.api.Assertions;
@@ -31,7 +31,7 @@ class RemovePlayerFromTeamTest {
ITournamentRepository tournamentRepository;
@InjectMocks
- TournamentService service;
+ SingleEliminationTournamentService service;
@Test
void shouldRemovePlayerFromTeamTest() throws TeamIdNotFoundException, TournamentIdNotFoundException, PlayerIdNotFoundException {
diff --git a/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/UpdateScoreTest.java b/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/UpdateScoreTest.java
index d47991f..aa0cd23 100644
--- a/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/UpdateScoreTest.java
+++ b/sth-backend/src/test/java/hdm/mi/sthbackend/serviceTests/UpdateScoreTest.java
@@ -5,7 +5,7 @@ import hdm.mi.sthbackend.exeptions.*;
import hdm.mi.sthbackend.model.Match;
import hdm.mi.sthbackend.model.Tournament;
import hdm.mi.sthbackend.repository.ITournamentRepository;
-import hdm.mi.sthbackend.service.TournamentService;
+import hdm.mi.sthbackend.service.SingleEliminationTournamentService;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.junit.jupiter.api.Assertions;
@@ -31,7 +31,7 @@ class UpdateScoreTest {
ITournamentRepository tournamentRepository;
@InjectMocks
- TournamentService tournamentService;
+ SingleEliminationTournamentService singleEliminationTournamentService;
DummyTournaments tournaments = new DummyTournaments();
@@ -41,7 +41,7 @@ class UpdateScoreTest {
Tournament tournament = tournaments.getDummyTournament("dummyName", 8);
when(tournamentRepository.findById(tournament.getTournamentId())).thenReturn(Optional.of(tournament));
try {
- tournamentService.initializeTournament(tournament.getTournamentId());
+ singleEliminationTournamentService.initializeTournament(tournament.getTournamentId());
} catch (InsufficientTeamsException | BracketAlreadyInitializedException e) {
log.error("Failed to initialize tournament");
}
@@ -61,7 +61,7 @@ class UpdateScoreTest {
.getTeamScores()
.get(teamId));
- tournamentService.updateScore(tournament.getTournamentId(), bracketRound, match.getMatchId(), teamId, 2);
+ singleEliminationTournamentService.updateScore(tournament.getTournamentId(), bracketRound, match.getMatchId(), teamId, 2);
Assertions.assertEquals(2, tournament.getBracket()
.get(bracketRound)
@@ -78,13 +78,13 @@ class UpdateScoreTest {
when(tournamentRepository.findById(tournament.getTournamentId())).thenReturn(Optional.of(tournament));
try {
- tournamentService.initializeTournament(tournament.getTournamentId());
+ singleEliminationTournamentService.initializeTournament(tournament.getTournamentId());
} catch (InsufficientTeamsException | BracketAlreadyInitializedException | TournamentIdNotFoundException e) {
log.error("Failed to initialize tournament");
}
BracketRoundNotFoundException thrown = Assertions.assertThrows(BracketRoundNotFoundException.class, () -> {
- tournamentService.updateScore(tournament.getTournamentId(), bracketRound, UUID.randomUUID(), UUID.randomUUID(), 3);
+ singleEliminationTournamentService.updateScore(tournament.getTournamentId(), bracketRound, UUID.randomUUID(), UUID.randomUUID(), 3);
});
Assertions.assertEquals("Bracket round " + bracketRound + " not found", thrown.getMessage());
}
@@ -96,14 +96,14 @@ class UpdateScoreTest {
when(tournamentRepository.findById(tournament.getTournamentId())).thenReturn(Optional.of(tournament));
try {
- tournamentService.initializeTournament(tournament.getTournamentId());
+ singleEliminationTournamentService.initializeTournament(tournament.getTournamentId());
} catch (InsufficientTeamsException | BracketAlreadyInitializedException | TournamentIdNotFoundException e) {
log.error("Failed to initialize tournament");
}
UUID wrongMatchId = UUID.randomUUID();
MatchIdNotFoundException thrown = Assertions.assertThrows(MatchIdNotFoundException.class, () -> {
- tournamentService.updateScore(tournament.getTournamentId(), bracketRound, wrongMatchId, UUID.randomUUID(), 3);
+ singleEliminationTournamentService.updateScore(tournament.getTournamentId(), bracketRound, wrongMatchId, UUID.randomUUID(), 3);
});
Assertions.assertEquals(String.format("MatchID %s not found", wrongMatchId), thrown.getMessage());
}
@@ -115,7 +115,7 @@ class UpdateScoreTest {
Tournament tournament = tournaments.getDummyTournament("dummyName", 8);
when(tournamentRepository.findById(tournament.getTournamentId())).thenReturn(Optional.of(tournament));
try {
- tournamentService.initializeTournament(tournament.getTournamentId());
+ singleEliminationTournamentService.initializeTournament(tournament.getTournamentId());
} catch (InsufficientTeamsException | BracketAlreadyInitializedException e) {
log.error("Failed to initialize tournament");
}
@@ -127,7 +127,7 @@ class UpdateScoreTest {
UUID wrongTeamId = UUID.randomUUID();
TeamIdNotFoundException thrown = Assertions.assertThrows(TeamIdNotFoundException.class, () -> {
- tournamentService.updateScore(tournament.getTournamentId(), bracketRound, match.getMatchId(), wrongTeamId, 2);
+ singleEliminationTournamentService.updateScore(tournament.getTournamentId(), bracketRound, match.getMatchId(), wrongTeamId, 2);
});
Assertions.assertEquals(String.format("TeamId %s not found", wrongTeamId), thrown.getMessage());
}
--
GitLab