// // 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" let password: String = "MyPass1234--" override func setUpWithError() throws { StoreCenter.main.synchronizationApiURL = "http://127.0.0.1:8000/roads/" Task { do { try await self.login() } catch { assertionFailure(error.localizedDescription) } } } override func tearDownWithError() throws { // Put teardown code here. This method is called after the invocation of each test method in the class. } func login() async throws { // print("LOGIN!") let _: User = try await StoreCenter.main.service().login(username: self.username, password: self.password) } 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" club.courtCount = 3 let inserted_club: Club = try await StoreCenter.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) assert(inserted_club.courtCount == club.courtCount) assert(inserted_club.broadcastCode != nil) assert(inserted_club.timezone != club.timezone) inserted_club.phone = "123456" let updated_club: Club = try await StoreCenter.main.service().put(inserted_club) assert(updated_club.phone == inserted_club.phone) } func testLogin() async throws { let user: User = try await StoreCenter.main.service().login(username: self.username, password: self.password) assert(user.username == "test") } func testEvent() async throws { guard let userId = StoreCenter.main.userId else { assertionFailure("missing user UUID") return } let clubs: [Club] = try await StoreCenter.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 StoreCenter.main.service().post(event) assert(e.name == event.name) assert(e.tenupId == event.tenupId) } func testTournament() async throws { let event: [Event] = try await StoreCenter.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, closedRegistrationDate: Date(), groupStageAdditionalQualified: 4, courtCount: 9, prioritizeClubMembers: true, qualifiedPerGroupStage: 1, teamsPerGroupStage: 2, entryFee: 30.0, additionalEstimationDuration: 5, isDeleted: true, publishTeams: true, publishSummons: true, publishGroupStages: true, publishBrackets: true, shouldVerifyBracket: true, shouldVerifyGroupStage: true, hideTeamsWeight: true, publishTournament: true, hidePointsEarned: true, publishRankings: true, loserBracketMode: .manual, initialSeedRound: 8, initialSeedCount: 4) let t = try await StoreCenter.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.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) assert(t.publishTeams == tournament.publishTeams) assert(t.publishSummons == tournament.publishSummons) assert(t.publishGroupStages == tournament.publishGroupStages) assert(t.publishBrackets == tournament.publishBrackets) assert(t.shouldVerifyBracket == tournament.shouldVerifyBracket) assert(t.shouldVerifyGroupStage == tournament.shouldVerifyGroupStage) assert(t.hideTeamsWeight == tournament.hideTeamsWeight) assert(t.publishTournament == tournament.publishTournament) assert(t.hidePointsEarned == tournament.hidePointsEarned) assert(t.publishRankings == tournament.publishRankings) assert(t.loserBracketMode == tournament.loserBracketMode) assert(t.initialSeedCount == tournament.initialSeedCount) assert(t.initialSeedRound == tournament.initialSeedRound) } func testGroupStage() async throws { let tournament: [Tournament] = try await StoreCenter.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!", step: 1) let gs: GroupStage = try await StoreCenter.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) assert(gs.step == groupStage.step) } func testRound() async throws { let tournament: [Tournament] = try await StoreCenter.main.service().get() guard let tournamentId = tournament.first?.id else { assertionFailure("missing tournament in database") return } let rounds: [Round] = try await StoreCenter.main.service().get() let parentRoundId = rounds.first?.id let round = Round(tournament: tournamentId, index: 1, parent: parentRoundId, matchFormat: MatchFormat.nineGames, startDate: Date(), groupStageLoserBracket: false, loserBracketMode: .manual) let r: Round = try await StoreCenter.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) assert(r.groupStageLoserBracket == round.groupStageLoserBracket) assert(r.loserBracketMode == round.loserBracketMode) } func testTeamRegistration() async throws { let tournament: [Tournament] = try await StoreCenter.main.service().get() guard let tournamentId = tournament.first?.id else { assertionFailure("missing tournament in database") return } let groupStages: [GroupStage] = try await StoreCenter.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, lockedWeight: 11, confirmationDate: Date(), qualified: true) let tr: TeamRegistration = try await StoreCenter.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.lockedWeight == teamRegistration.lockedWeight) assert(tr.confirmationDate?.formatted() == teamRegistration.confirmationDate?.formatted()) assert(tr.qualified == teamRegistration.qualified) } func testPlayerRegistration() async throws { let teamRegistrations: [TeamRegistration] = try await StoreCenter.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 StoreCenter.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 { let teamRegistrations: [TeamRegistration] = try await StoreCenter.main.service().get() guard let teamRegistrationId = teamRegistrations.first?.id else { assertionFailure("missing teamRegistrations in database") return } let rounds: [Round] = try await StoreCenter.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, confirmed: true) let m: Match = try await StoreCenter.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) assert(m.confirmed == match.confirmed) } func testTeamScore() async throws { let matches: [Match] = try await StoreCenter.main.service().get() guard let matchId = matches.first?.id else { assertionFailure("missing match in database") return } let teamRegistrations: [TeamRegistration] = try await StoreCenter.main.service().get() guard let teamRegistrationId = teamRegistrations.first?.id else { assertionFailure("missing teamRegistrations in database") return } let teamScore = TeamScore(match: matchId, teamRegistration: teamRegistrationId, score: "6/6", walkOut: 1, luckyLoser: 1) let ts: TeamScore = try await StoreCenter.main.service().post(teamScore) assert(ts.match == teamScore.match) assert(ts.teamRegistration == teamScore.teamRegistration) assert(ts.score == teamScore.score) assert(ts.walkOut == teamScore.walkOut) assert(ts.luckyLoser == teamScore.luckyLoser) } func testCourt() async throws { let clubs: [Club] = try await StoreCenter.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 StoreCenter.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 { let event: [Event] = try await StoreCenter.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 StoreCenter.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()) } func testPurchase() async throws { guard let userId = StoreCenter.main.userId else { assertionFailure("missing user UUID") return } let transactionId = UInt64.random(in: 0...100000) let quantity = Int.random(in: 0...10) let purchase: Purchase = Purchase(user: userId, transactionId: transactionId, purchaseDate: Date(), productId: "app.padelclub.productId", quantity: quantity, revocationDate: Date(), expirationDate: Date()) let p: Purchase = try await StoreCenter.main.service().post(purchase) assert(p.id == purchase.id) assert(p.user == purchase.user) assert(p.productId == purchase.productId) assert(p.purchaseDate.formatted() == purchase.purchaseDate.formatted()) assert(p.quantity == purchase.quantity) assert(p.revocationDate?.formatted() == purchase.revocationDate?.formatted()) assert(p.expirationDate?.formatted() == purchase.expirationDate?.formatted()) } func testDrawLog() async throws { let tournament: [Tournament] = try await StoreCenter.main.service().get() guard let tournamentId = tournament.first?.id else { assertionFailure("missing tournament in database") return } let drawLog = DrawLog(tournament: tournamentId, drawSeed: 1, drawMatchIndex: 1, drawTeamPosition: .two) let d: DrawLog = try await StoreCenter.main.service().post(drawLog) assert(d.tournament == drawLog.tournament) assert(d.drawDate.formatted() == drawLog.drawDate.formatted()) assert(d.drawSeed == drawLog.drawSeed) assert(d.drawTeamPosition == drawLog.drawTeamPosition) assert(d.drawMatchIndex == drawLog.drawMatchIndex) } }