You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
417 lines
18 KiB
417 lines
18 KiB
//
|
|
// ServerDataTests.swift
|
|
// PadelClubTests
|
|
//
|
|
// Created by Laurent Morvillier on 08/05/2024.
|
|
//
|
|
|
|
import XCTest
|
|
import LeStorage
|
|
@testable import PadelClub
|
|
|
|
final class ServerDataTests: XCTestCase {
|
|
|
|
let username: String = "test"
|
|
|
|
|
|
override func setUpWithError() throws {
|
|
Store.main.synchronizationApiURL = "http://127.0.0.1:8000/api/"
|
|
}
|
|
|
|
override func tearDownWithError() throws {
|
|
// Put teardown code here. This method is called after the invocation of each test method in the class.
|
|
}
|
|
|
|
func testClub() async throws {
|
|
|
|
let club = Club(name: "Aix Universite Club")
|
|
club.acronym = "AUC"
|
|
club.city = "Aix en provence"
|
|
club.zipCode = "13100"
|
|
club.code = "abc"
|
|
club.address = "2 avenue de la vie"
|
|
club.latitude = 13
|
|
club.longitude = 10
|
|
club.phone = "061234567890"
|
|
|
|
let inserted_club: Club = try await Store.main.service().post(club)
|
|
assert(inserted_club.name == club.name)
|
|
assert(inserted_club.acronym == club.acronym)
|
|
assert(inserted_club.zipCode == club.zipCode)
|
|
assert(inserted_club.address == club.address)
|
|
assert(inserted_club.latitude == club.latitude)
|
|
assert(inserted_club.longitude == club.longitude)
|
|
assert(inserted_club.phone == club.phone)
|
|
|
|
inserted_club.phone = "123456"
|
|
|
|
let updated_club: Club = try await Store.main.service().put(inserted_club)
|
|
assert(updated_club.phone == inserted_club.phone)
|
|
|
|
}
|
|
|
|
func testUserCreation() async throws {
|
|
|
|
let userCreationForm = UserCreationForm(username: self.username, password: "MyPass1234--", firstName: "jean", lastName: "coco", email: "laurent@staxriver.com", phone: "0123", country: "France")
|
|
let user: User = try await Store.main.service().createAccount(user: userCreationForm)
|
|
|
|
assert(user.username == userCreationForm.username)
|
|
assert(user.firstName == userCreationForm.firstName)
|
|
assert(user.lastName == userCreationForm.lastName)
|
|
assert(user.email == userCreationForm.email)
|
|
assert(user.phone == userCreationForm.phone)
|
|
assert(user.country == userCreationForm.country)
|
|
|
|
}
|
|
|
|
func createUser() async throws -> User {
|
|
let userCreationForm = UserCreationForm(username: "test", password: "MyPass1234--", firstName: "jean", lastName: "coco", email: "laurent@staxriver.com", phone: "0123", country: "France")
|
|
return try await Store.main.service().createAccount(user: userCreationForm)
|
|
}
|
|
|
|
func testLogin() async throws {
|
|
|
|
let user: User = try await Store.main.service().login(username: "test", password: "MyPass1234--")
|
|
assert(user.username == "test")
|
|
|
|
}
|
|
|
|
func login() async throws {
|
|
let _: User = try await Store.main.service().login(username: "test", password: "MyPass1234--")
|
|
}
|
|
|
|
func testEvent() async throws {
|
|
|
|
do {
|
|
try await self.login()
|
|
} catch {
|
|
let _ = try await self.createUser()
|
|
try await self.login()
|
|
}
|
|
|
|
guard let userId = Store.main.currentUserUUID?.uuidString else {
|
|
assertionFailure("missing user UUID")
|
|
return
|
|
}
|
|
|
|
let clubs: [Club] = try await Store.main.service().get()
|
|
guard let clubId = clubs.first?.id else {
|
|
assertionFailure("missing club in database")
|
|
return
|
|
}
|
|
|
|
let event = Event(creator: userId, club: clubId, name: "Roland Garros", tenupId: "abc")
|
|
let e = try await Store.main.service().post(event)
|
|
|
|
assert(e.name == event.name)
|
|
assert(e.tenupId == event.tenupId)
|
|
|
|
}
|
|
|
|
func testTournament() async throws {
|
|
|
|
do {
|
|
try await self.login()
|
|
} catch {
|
|
let _ = try await self.createUser()
|
|
try await self.login()
|
|
}
|
|
|
|
let event: [Event] = try await Store.main.service().get()
|
|
guard let eventId = event.first?.id else {
|
|
assertionFailure("missing event in database")
|
|
return
|
|
}
|
|
|
|
let tournament = Tournament(event: eventId, name: "RG Homme", startDate: Date(), endDate: nil, creationDate: Date(), isPrivate: false, groupStageFormat: MatchFormat.megaTie, roundFormat: MatchFormat.nineGames, loserRoundFormat: MatchFormat.nineGamesDecisivePoint, groupStageSortMode: GroupStageOrderingMode.snake, groupStageCount: 2, rankSourceDate: Date(), dayDuration: 5, teamCount: 3, teamSorting: TeamSortingType.rank, federalCategory: TournamentCategory.mix, federalLevelCategory: TournamentLevel.p1000, federalAgeCategory: FederalTournamentAge.a45, groupStageCourtCount: 6, closedRegistrationDate: Date(), groupStageAdditionalQualified: 4, courtCount: 9, prioritizeClubMembers: true, qualifiedPerGroupStage: 1, teamsPerGroupStage: 2, entryFee: 30.0, additionalEstimationDuration: 5, isDeleted: true)
|
|
let t = try await Store.main.service().post(tournament)
|
|
|
|
assert(t.event == tournament.event)
|
|
assert(t.name == tournament.name)
|
|
assert(t.startDate.formatted() == tournament.startDate.formatted())
|
|
assert(t.endDate?.formatted() == tournament.endDate?.formatted())
|
|
assert(t.creationDate.formatted() == tournament.creationDate.formatted())
|
|
assert(t.isPrivate == tournament.isPrivate)
|
|
assert(t.groupStageFormat == tournament.groupStageFormat)
|
|
assert(t.roundFormat == tournament.roundFormat)
|
|
assert(t.loserRoundFormat == tournament.loserRoundFormat)
|
|
assert(t.groupStageSortMode == tournament.groupStageSortMode)
|
|
assert(t.groupStageCount == tournament.groupStageCount)
|
|
assert(t.rankSourceDate?.formatted() == tournament.rankSourceDate?.formatted())
|
|
assert(t.dayDuration == tournament.dayDuration)
|
|
assert(t.teamCount == tournament.teamCount)
|
|
assert(t.teamSorting == tournament.teamSorting)
|
|
assert(t.federalCategory == tournament.federalCategory)
|
|
assert(t.federalLevelCategory == tournament.federalLevelCategory)
|
|
assert(t.federalAgeCategory == tournament.federalAgeCategory)
|
|
assert(t.groupStageCourtCount == tournament.groupStageCourtCount)
|
|
assert(t.closedRegistrationDate?.formatted() == tournament.closedRegistrationDate?.formatted())
|
|
assert(t.groupStageAdditionalQualified == tournament.groupStageAdditionalQualified)
|
|
assert(t.courtCount == tournament.courtCount)
|
|
assert(t.prioritizeClubMembers == tournament.prioritizeClubMembers)
|
|
assert(t.qualifiedPerGroupStage == tournament.qualifiedPerGroupStage)
|
|
assert(t.teamsPerGroupStage == tournament.teamsPerGroupStage)
|
|
assert(t.entryFee == tournament.entryFee)
|
|
assert(t.additionalEstimationDuration == tournament.additionalEstimationDuration)
|
|
assert(t.isDeleted == tournament.isDeleted)
|
|
|
|
}
|
|
|
|
func testGroupStage() async throws {
|
|
|
|
do {
|
|
try await self.login()
|
|
} catch {
|
|
let _ = try await self.createUser()
|
|
try await self.login()
|
|
}
|
|
|
|
let tournament: [Tournament] = try await Store.main.service().get()
|
|
guard let tournamentId = tournament.first?.id else {
|
|
assertionFailure("missing tournament in database")
|
|
return
|
|
}
|
|
|
|
let groupStage = GroupStage(tournament: tournamentId, index: 2, size: 3, matchFormat: MatchFormat.nineGames, startDate: Date(), name: "Yeah!")
|
|
let gs: GroupStage = try await Store.main.service().post(groupStage)
|
|
|
|
assert(gs.tournament == groupStage.tournament)
|
|
assert(gs.name == groupStage.name)
|
|
assert(gs.index == groupStage.index)
|
|
assert(gs.size == groupStage.size)
|
|
assert(gs.matchFormat == groupStage.matchFormat)
|
|
assert(gs.startDate != nil)
|
|
|
|
}
|
|
|
|
func testRound() async throws {
|
|
|
|
do {
|
|
try await self.login()
|
|
} catch {
|
|
let _ = try await self.createUser()
|
|
try await self.login()
|
|
}
|
|
|
|
let tournament: [Tournament] = try await Store.main.service().get()
|
|
guard let tournamentId = tournament.first?.id else {
|
|
assertionFailure("missing tournament in database")
|
|
return
|
|
}
|
|
let rounds: [Round] = try await Store.main.service().get()
|
|
let parentRoundId = rounds.first?.id
|
|
|
|
let round = Round(tournament: tournamentId, index: 1, parent: parentRoundId, matchFormat: MatchFormat.nineGames, startDate: Date())
|
|
let r: Round = try await Store.main.service().post(round)
|
|
|
|
assert(r.tournament == round.tournament)
|
|
assert(r.index == round.index)
|
|
assert(r.parent == round.parent)
|
|
assert(r.matchFormat == round.matchFormat)
|
|
assert(r.startDate != nil)
|
|
|
|
}
|
|
|
|
func testTeamRegistration() async throws {
|
|
|
|
do {
|
|
try await self.login()
|
|
} catch {
|
|
let _ = try await self.createUser()
|
|
try await self.login()
|
|
}
|
|
|
|
let tournament: [Tournament] = try await Store.main.service().get()
|
|
guard let tournamentId = tournament.first?.id else {
|
|
assertionFailure("missing tournament in database")
|
|
return
|
|
}
|
|
let groupStages: [GroupStage] = try await Store.main.service().get()
|
|
guard let groupStageId = groupStages.first?.id else {
|
|
assertionFailure("missing groupStage in database")
|
|
return
|
|
}
|
|
|
|
let teamRegistration = TeamRegistration(tournament: tournamentId, groupStage: groupStageId, registrationDate: Date(), callDate: Date(), bracketPosition: 1, groupStagePosition: 2, comment: "comment", source: "source", sourceValue: "source V", logo: "logo", name: "Stax", walkOut: true, wildCardBracket: true, wildCardGroupStage: true, weight: 1, lockWeight: 11, confirmationDate: Date(), qualified: true)
|
|
|
|
let tr: TeamRegistration = try await Store.main.service().post(teamRegistration)
|
|
|
|
assert(tr.tournament == teamRegistration.tournament)
|
|
assert(tr.groupStage == teamRegistration.groupStage)
|
|
assert(tr.registrationDate != nil)
|
|
assert(tr.callDate != nil)
|
|
assert(tr.bracketPosition == teamRegistration.bracketPosition)
|
|
assert(tr.groupStagePosition == teamRegistration.groupStagePosition)
|
|
assert(tr.comment == teamRegistration.comment)
|
|
assert(tr.source == teamRegistration.source)
|
|
assert(tr.sourceValue == teamRegistration.sourceValue)
|
|
assert(tr.logo == teamRegistration.logo)
|
|
assert(tr.name == teamRegistration.name)
|
|
assert(tr.walkOut == teamRegistration.walkOut)
|
|
assert(tr.wildCardBracket == teamRegistration.wildCardBracket)
|
|
assert(tr.wildCardGroupStage == teamRegistration.wildCardGroupStage)
|
|
assert(tr.weight == teamRegistration.weight)
|
|
assert(tr.lockWeight == teamRegistration.lockWeight)
|
|
// assert(tr.confirmationDate != nil)
|
|
assert(tr.qualified == teamRegistration.qualified)
|
|
|
|
}
|
|
|
|
func testPlayerRegistration() async throws {
|
|
|
|
do {
|
|
try await self.login()
|
|
} catch {
|
|
let _ = try await self.createUser()
|
|
try await self.login()
|
|
}
|
|
|
|
let teamRegistrations: [TeamRegistration] = try await Store.main.service().get()
|
|
guard let teamRegistrationId = teamRegistrations.first?.id else {
|
|
assertionFailure("missing teamRegistrations in database")
|
|
return
|
|
}
|
|
|
|
let playerRegistration = PlayerRegistration(teamRegistration: teamRegistrationId, firstName: "juan", lastName: "lebron", licenceId: "123", rank: 11, paymentType: PlayerRegistration.PlayerPaymentType.cash, sex: PlayerRegistration.PlayerSexType.male, tournamentPlayed: 2, points: 33, clubName: "le club", ligueName: "la league", assimilation: "ass", phoneNumber: "123123", email: "email@email.com", birthdate: nil, computedRank: 222, source: PlayerRegistration.PlayerDataSource.frenchFederation, hasArrived: true)
|
|
let pr: PlayerRegistration = try await Store.main.service().post(playerRegistration)
|
|
|
|
assert(pr.teamRegistration == playerRegistration.teamRegistration)
|
|
assert(pr.firstName == playerRegistration.firstName)
|
|
assert(pr.lastName == playerRegistration.lastName)
|
|
assert(pr.licenceId == playerRegistration.licenceId)
|
|
assert(pr.rank == playerRegistration.rank)
|
|
assert(pr.paymentType == playerRegistration.paymentType)
|
|
assert(pr.sex == playerRegistration.sex)
|
|
assert(pr.tournamentPlayed == playerRegistration.tournamentPlayed)
|
|
assert(pr.points == playerRegistration.points)
|
|
assert(pr.clubName == playerRegistration.clubName)
|
|
assert(pr.ligueName == playerRegistration.ligueName)
|
|
assert(pr.assimilation == playerRegistration.assimilation)
|
|
assert(pr.phoneNumber == playerRegistration.phoneNumber)
|
|
assert(pr.birthdate == playerRegistration.birthdate)
|
|
assert(pr.computedRank == playerRegistration.computedRank)
|
|
assert(pr.source == playerRegistration.source)
|
|
assert(pr.hasArrived == playerRegistration.hasArrived)
|
|
|
|
}
|
|
|
|
func testMatch() async throws {
|
|
|
|
do {
|
|
try await self.login()
|
|
} catch {
|
|
let _ = try await self.createUser()
|
|
try await self.login()
|
|
}
|
|
|
|
let teamRegistrations: [TeamRegistration] = try await Store.main.service().get()
|
|
guard let teamRegistrationId = teamRegistrations.first?.id else {
|
|
assertionFailure("missing teamRegistrations in database")
|
|
return
|
|
}
|
|
let rounds: [Round] = try await Store.main.service().get()
|
|
let parentRoundId = rounds.first?.id
|
|
|
|
let match: Match = Match(round: parentRoundId, groupStage: nil, startDate: Date(), endDate: Date(), index: 2, matchFormat: MatchFormat.twoSets, servingTeamId: teamRegistrationId, winningTeamId: teamRegistrationId, losingTeamId: teamRegistrationId, disabled: true, courtIndex: 1)
|
|
let m: Match = try await Store.main.service().post(match)
|
|
|
|
assert(m.round == match.round)
|
|
assert(m.groupStage == match.groupStage)
|
|
assert(m.startDate != nil)
|
|
assert(m.endDate != nil)
|
|
assert(m.index == match.index)
|
|
assert(m.matchFormat == match.matchFormat)
|
|
assert(m.servingTeamId == match.servingTeamId)
|
|
assert(m.winningTeamId == match.winningTeamId)
|
|
assert(m.losingTeamId == match.losingTeamId)
|
|
assert(m.disabled == match.disabled)
|
|
assert(m.courtIndex == match.courtIndex)
|
|
|
|
}
|
|
|
|
func testTeamScore() async throws {
|
|
|
|
do {
|
|
try await self.login()
|
|
} catch {
|
|
let _ = try await self.createUser()
|
|
try await self.login()
|
|
}
|
|
|
|
let matches: [Match] = try await Store.main.service().get()
|
|
guard let matchId = matches.first?.id else {
|
|
assertionFailure("missing match in database")
|
|
return
|
|
}
|
|
let teamRegistrations: [TeamRegistration] = try await Store.main.service().get()
|
|
guard let teamRegistrationId = teamRegistrations.first?.id else {
|
|
assertionFailure("missing teamRegistrations in database")
|
|
return
|
|
}
|
|
let playerRegistrations: [PlayerRegistration] = try await Store.main.service().get()
|
|
let regs = playerRegistrations.prefix(upTo: 2).map { $0.id }
|
|
|
|
let teamScore = TeamScore(match: matchId, teamRegistration: teamRegistrationId, playerRegistrations: regs, score: "6/6", walkOut: 1, luckyLoser: 1)
|
|
let ts: TeamScore = try await Store.main.service().post(teamScore)
|
|
|
|
assert(ts.match == teamScore.match)
|
|
assert(ts.teamRegistration == teamScore.teamRegistration)
|
|
assert(ts.playerRegistrations == teamScore.playerRegistrations)
|
|
assert(ts.score == teamScore.score)
|
|
assert(ts.walkOut == teamScore.walkOut)
|
|
assert(ts.luckyLoser == teamScore.luckyLoser)
|
|
|
|
}
|
|
|
|
func testCourt() async throws {
|
|
|
|
do {
|
|
try await self.login()
|
|
} catch {
|
|
let _ = try await self.createUser()
|
|
try await self.login()
|
|
}
|
|
|
|
|
|
let clubs: [Club] = try await Store.main.service().get()
|
|
guard let clubId = clubs.first?.id else {
|
|
assertionFailure("missing club in database")
|
|
return
|
|
}
|
|
|
|
let court = Court(index: 1, club: clubId, name: "Philippe Chatrier", exitAllowed: true, indoor: true)
|
|
let c: Court = try await Store.main.service().post(court)
|
|
|
|
assert(c.club == court.club)
|
|
assert(c.name == court.name)
|
|
assert(c.index == court.index)
|
|
assert(c.exitAllowed == court.exitAllowed)
|
|
assert(c.indoor == court.indoor)
|
|
|
|
}
|
|
|
|
func testDateInterval() async throws {
|
|
|
|
do {
|
|
try await self.login()
|
|
} catch {
|
|
let _ = try await self.createUser()
|
|
try await self.login()
|
|
}
|
|
|
|
let event: [Event] = try await Store.main.service().get()
|
|
guard let eventId = event.first?.id else {
|
|
assertionFailure("missing event in database")
|
|
return
|
|
}
|
|
|
|
let dateInterval = DateInterval(event: eventId, courtIndex: 1, startDate: Date(), endDate: Date())
|
|
let di: PadelClub.DateInterval = try await Store.main.service().post(dateInterval)
|
|
|
|
assert(di.event == dateInterval.event)
|
|
assert(di.courtIndex == dateInterval.courtIndex)
|
|
assert(di.startDate.formatted() == dateInterval.startDate.formatted())
|
|
assert(di.endDate.formatted() == dateInterval.endDate.formatted())
|
|
|
|
}
|
|
}
|
|
|