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.
327 lines
14 KiB
327 lines
14 KiB
//
|
|
// DataAccessSyncTests.swift
|
|
// PadelClubDataTests
|
|
//
|
|
// Created by Laurent Morvillier on 02/05/2025.
|
|
//
|
|
|
|
import Testing
|
|
@testable import PadelClubData
|
|
@testable import LeStorage
|
|
|
|
struct SyncDataAccessTests {
|
|
|
|
let username1: String = "UserDataTests"
|
|
let password1: String = "MyPass1234--"
|
|
|
|
let username2: String = "seconduser"
|
|
let password2: String = "MyPass1234--"
|
|
|
|
var secondStoreCenter: StoreCenter
|
|
|
|
init() async throws {
|
|
FileManager.default.deleteDirectoryInDocuments(directoryName: "storage")
|
|
FileManager.default.deleteDirectoryInDocuments(directoryName: "storage-2")
|
|
|
|
self.secondStoreCenter = StoreCenter(directoryName: "storage-2")
|
|
self.secondStoreCenter.configureURLs(secureScheme: false, domain: "127.0.0.1:8000", webSockets: false, useSynchronization: true)
|
|
self.secondStoreCenter.tokenKeychain = MockKeychainStore(fileName: "storage-2/token.json")
|
|
self.secondStoreCenter.deviceKeychain = MockKeychainStore(fileName: "storage-2/device.json")
|
|
try self.secondStoreCenter.deviceKeychain.add(value: UUID().uuidString)
|
|
|
|
self.secondStoreCenter.classProject = "PadelClubData"
|
|
|
|
let token2 = try? self.secondStoreCenter.rawTokenShouldNotBeUsed()
|
|
if token2 == nil {
|
|
try await self.login(storeCenter: self.secondStoreCenter, username: self.username2, password: self.password2)
|
|
}
|
|
|
|
StoreCenter.main.configureURLs(secureScheme: false, domain: "127.0.0.1:8000", webSockets: false, useSynchronization: true)
|
|
StoreCenter.main.tokenKeychain = MockKeychainStore(fileName: "storage/token.json")
|
|
StoreCenter.main.deviceKeychain = MockKeychainStore(fileName: "storage/device.json")
|
|
try StoreCenter.main.deviceKeychain.add(value: UUID().uuidString)
|
|
StoreCenter.main.classProject = "PadelClubData"
|
|
|
|
let token = try? StoreCenter.main.rawTokenShouldNotBeUsed()
|
|
if token == nil {
|
|
try await self.login(storeCenter: StoreCenter.main, username: self.username1, password: self.password1)
|
|
}
|
|
}
|
|
|
|
mutating func login(storeCenter: StoreCenter, username: String, password: String) async throws {
|
|
let _: CustomUser = try await storeCenter.service().login(username: username, password: password)
|
|
}
|
|
|
|
@Test func testSetup() async throws {
|
|
#expect(StoreCenter.main.isAuthenticated)
|
|
#expect(self.secondStoreCenter.isAuthenticated)
|
|
|
|
guard let userId1 = StoreCenter.main.userId else {
|
|
throw TestError.notAuthenticated
|
|
}
|
|
guard let userId2 = self.secondStoreCenter.userId else {
|
|
throw TestError.notAuthenticated
|
|
}
|
|
#expect(userId1 != userId2)
|
|
}
|
|
|
|
/// In this test, the first user:
|
|
/// - creates an event and a tournament
|
|
/// - shares the tournament with a second user
|
|
/// - remove the sharing with the second user
|
|
/// We test that the data is properly received and removed upon the sharing actions
|
|
@Test func testTournamentSharing() async throws {
|
|
|
|
guard let userId1 = StoreCenter.main.userId else {
|
|
throw TestError.notAuthenticated
|
|
}
|
|
guard let userId2 = self.secondStoreCenter.userId else {
|
|
throw TestError.notAuthenticated
|
|
}
|
|
|
|
// Setup
|
|
let eventColA: SyncedCollection<Event> = await StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
|
|
let tournamentColA: SyncedCollection<Tournament> = await StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
|
|
let eventColB: SyncedCollection<Event> = await self.secondStoreCenter.mainStore.asyncLoadingSynchronizedCollection()
|
|
let tournamentColB: SyncedCollection<Tournament> = await self.secondStoreCenter.mainStore.asyncLoadingSynchronizedCollection()
|
|
|
|
if let dataAccessCollection = StoreCenter.main.dataAccessCollection {
|
|
try await dataAccessCollection.deleteAsync(contentOfs: Array(dataAccessCollection))
|
|
}
|
|
|
|
try await eventColA.deleteAsync(contentOfs: Array(eventColA))
|
|
try await tournamentColA.deleteAsync(contentOfs: Array(tournamentColA))
|
|
|
|
let _ = try await self.secondStoreCenter.testSynchronizeOnceAsync()
|
|
|
|
#expect(eventColB.count == 0)
|
|
#expect(tournamentColB.count == 0)
|
|
|
|
// Create
|
|
let eventA = Event(creator: userId1)
|
|
try await eventColA.addOrUpdateAsync(instance: eventA)
|
|
let tournamentA = Tournament(event: eventA.id, name: "P100")
|
|
try await tournamentColA.addOrUpdateAsync(instance: tournamentA)
|
|
|
|
// Share with user2
|
|
try await StoreCenter.main.setAuthorizedUsersAsync(for: tournamentA, users: [userId2])
|
|
|
|
var dataB = try await self.secondStoreCenter.testSynchronizeOnceAsync()
|
|
var syncDataB = try SyncData(data: dataB, storeCenter: self.secondStoreCenter)
|
|
#expect(syncDataB.grants.count == 2)
|
|
|
|
#expect(eventColB.count == 1)
|
|
#expect(tournamentColB.count == 1)
|
|
|
|
// Remove sharing from user2
|
|
try await StoreCenter.main.setAuthorizedUsersAsync(for: tournamentA, users: [])
|
|
|
|
dataB = try await self.secondStoreCenter.testSynchronizeOnceAsync()
|
|
syncDataB = try SyncData(data: dataB, storeCenter: self.secondStoreCenter)
|
|
#expect(syncDataB.revocations.count == 1)
|
|
#expect(syncDataB.revocationParents.count == 1)
|
|
|
|
#expect(eventColB.count == 0)
|
|
#expect(tournamentColB.count == 0)
|
|
|
|
let dataAccesses: [DataAccess] = try await StoreCenter.main.service().get()
|
|
#expect(dataAccesses.count == 0)
|
|
}
|
|
|
|
/// In this test, the first user:
|
|
/// - creates a club and 2 events in that club
|
|
/// - shares both events with a second user
|
|
/// - removes the sharing of 1 event
|
|
/// Here we want to test that the Club instance remains even if one event is removed from the second user
|
|
@Test func testSharedRelationship() async throws {
|
|
|
|
guard let userId1 = StoreCenter.main.userId else {
|
|
throw TestError.notAuthenticated
|
|
}
|
|
guard let userId2 = self.secondStoreCenter.userId else {
|
|
throw TestError.notAuthenticated
|
|
}
|
|
|
|
// Setup
|
|
let eventColA: SyncedCollection<Event> = await StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
|
|
let clubColA: SyncedCollection<Club> = await StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
|
|
let eventColB: SyncedCollection<Event> = await self.secondStoreCenter.mainStore.asyncLoadingSynchronizedCollection()
|
|
let clubColB: SyncedCollection<Club> = await self.secondStoreCenter.mainStore.asyncLoadingSynchronizedCollection()
|
|
|
|
if let dataAccessCollection = StoreCenter.main.dataAccessCollection {
|
|
try await dataAccessCollection.deleteAsync(contentOfs: Array(dataAccessCollection))
|
|
}
|
|
|
|
try await eventColA.deleteAsync(contentOfs: Array(eventColA))
|
|
try await clubColA.deleteAsync(contentOfs: Array(clubColA))
|
|
|
|
let _ = try await self.secondStoreCenter.testSynchronizeOnceAsync()
|
|
|
|
#expect(eventColB.count == 0)
|
|
#expect(clubColB.count == 0)
|
|
|
|
// Create
|
|
let clubA = Club(creator: userId1, name: "Club A", acronym: "CA")
|
|
try await clubColA.addOrUpdateAsync(instance: clubA)
|
|
|
|
let event1A = Event(creator: userId1, club: clubA.id, name: "event 1")
|
|
let event2A = Event(creator: userId1, club: clubA.id, name: "event 2")
|
|
try await eventColA.addOrUpdateAsync(contentOfs: [event1A, event2A])
|
|
|
|
// Share with user2
|
|
try await StoreCenter.main.setAuthorizedUsersAsync(for: event1A, users: [userId2])
|
|
try await StoreCenter.main.setAuthorizedUsersAsync(for: event2A, users: [userId2])
|
|
|
|
var dataB = try await self.secondStoreCenter.testSynchronizeOnceAsync()
|
|
var syncDataB = try SyncData(data: dataB, storeCenter: self.secondStoreCenter)
|
|
|
|
#expect(syncDataB.grants.count == 2)
|
|
|
|
let clubGrants = syncDataB.grants.first { $0.type == Club.self }
|
|
let eventGrants = syncDataB.grants.first { $0.type == Event.self }
|
|
#expect(clubGrants?.items.count == 1)
|
|
#expect(eventGrants?.items.count == 2)
|
|
|
|
#expect(eventColB.count == 2)
|
|
#expect(clubColB.count == 1)
|
|
|
|
// Remove sharing from user2
|
|
try await StoreCenter.main.setAuthorizedUsersAsync(for: event1A, users: [])
|
|
|
|
dataB = try await self.secondStoreCenter.testSynchronizeOnceAsync()
|
|
syncDataB = try SyncData(data: dataB, storeCenter: self.secondStoreCenter)
|
|
#expect(syncDataB.revocations.count == 1)
|
|
#expect(syncDataB.revocationParents.count == 1)
|
|
|
|
#expect(eventColB.count == 1)
|
|
#expect(clubColB.count == 1) // club remains because used in event2A
|
|
}
|
|
|
|
/// In this test, the first user:
|
|
/// - creates one event and 2 clubs
|
|
/// - shares the event with a second user
|
|
/// - changes the club on the event
|
|
/// Here we want to test that the first Club is removed and the second one is received
|
|
@Test func testRelationshipChange() async throws {
|
|
|
|
guard let userId1 = StoreCenter.main.userId else {
|
|
throw TestError.notAuthenticated
|
|
}
|
|
guard let userId2 = self.secondStoreCenter.userId else {
|
|
throw TestError.notAuthenticated
|
|
}
|
|
|
|
// Setup
|
|
let eventColA: SyncedCollection<Event> = await StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
|
|
let clubColA: SyncedCollection<Club> = await StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
|
|
let eventColB: SyncedCollection<Event> = await self.secondStoreCenter.mainStore.asyncLoadingSynchronizedCollection()
|
|
let clubColB: SyncedCollection<Club> = await self.secondStoreCenter.mainStore.asyncLoadingSynchronizedCollection()
|
|
|
|
if let dataAccessCollection = StoreCenter.main.dataAccessCollection {
|
|
try await dataAccessCollection.deleteAsync(contentOfs: Array(dataAccessCollection))
|
|
}
|
|
|
|
try await eventColA.deleteAsync(contentOfs: Array(eventColA))
|
|
try await clubColA.deleteAsync(contentOfs: Array(clubColA))
|
|
|
|
let _ = try await self.secondStoreCenter.testSynchronizeOnceAsync()
|
|
|
|
#expect(eventColB.count == 0)
|
|
#expect(clubColB.count == 0)
|
|
|
|
// Create
|
|
let club1A = Club(creator: userId1, name: "Club 1", acronym: "C1")
|
|
try await clubColA.addOrUpdateAsync(instance: club1A)
|
|
let club2A = Club(creator: userId1, name: "Club 2", acronym: "C2")
|
|
try await clubColA.addOrUpdateAsync(instance: club2A)
|
|
|
|
let eventA = Event(creator: userId1, club: club1A.id, name: "event 1")
|
|
try await eventColA.addOrUpdateAsync(instance: eventA)
|
|
|
|
// Share with user2
|
|
try await StoreCenter.main.setAuthorizedUsersAsync(for: eventA, users: [userId2])
|
|
let _ = try await self.secondStoreCenter.testSynchronizeOnceAsync()
|
|
#expect(eventColB.count == 1)
|
|
#expect(clubColB.count == 1)
|
|
|
|
// Change the club
|
|
eventA.club = club2A.id
|
|
try await eventColA.addOrUpdateAsync(instance: eventA)
|
|
let dataB = try await self.secondStoreCenter.testSynchronizeOnceAsync()
|
|
|
|
let syncDataB = try SyncData(data: dataB, storeCenter: self.secondStoreCenter)
|
|
|
|
#expect(syncDataB.sharedRelationshipSets.count == 1)
|
|
#expect(syncDataB.sharedRelationshipRemovals.count == 1)
|
|
|
|
#expect(eventColB.first?.club == club2A.id)
|
|
}
|
|
|
|
/// In this test, the first user:
|
|
/// - creates one event
|
|
/// - shares the event with a second user
|
|
/// The second user:
|
|
/// - changes the club
|
|
/// Here we want to test that the first Club is removed and the second one is received
|
|
@Test func testRelationshipChangesByAgent() async throws {
|
|
|
|
guard let userId1 = StoreCenter.main.userId else {
|
|
throw TestError.notAuthenticated
|
|
}
|
|
guard let userId2 = self.secondStoreCenter.userId else {
|
|
throw TestError.notAuthenticated
|
|
}
|
|
|
|
// Setup
|
|
let eventColA: SyncedCollection<Event> = await StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
|
|
let clubColA: SyncedCollection<Club> = await StoreCenter.main.mainStore.asyncLoadingSynchronizedCollection()
|
|
let eventColB: SyncedCollection<Event> = await self.secondStoreCenter.mainStore.asyncLoadingSynchronizedCollection()
|
|
let clubColB: SyncedCollection<Club> = await self.secondStoreCenter.mainStore.asyncLoadingSynchronizedCollection()
|
|
|
|
if let dataAccessCollection = StoreCenter.main.dataAccessCollection {
|
|
try await dataAccessCollection.deleteAsync(contentOfs: Array(dataAccessCollection))
|
|
}
|
|
|
|
try await eventColA.deleteAsync(contentOfs: Array(eventColA))
|
|
try await clubColA.deleteAsync(contentOfs: Array(clubColA))
|
|
|
|
let _ = try await self.secondStoreCenter.testSynchronizeOnceAsync()
|
|
|
|
#expect(eventColB.count == 0)
|
|
#expect(clubColB.count == 0)
|
|
|
|
// Create
|
|
let clubA = Club(creator: userId1, name: "Club 1", acronym: "C1")
|
|
try await clubColA.addOrUpdateAsync(instance: clubA)
|
|
|
|
let eventA = Event(creator: userId1, club: clubA.id, name: "event 1")
|
|
try await eventColA.addOrUpdateAsync(instance: eventA)
|
|
|
|
// Share with user2
|
|
try await StoreCenter.main.setAuthorizedUsersAsync(for: eventA, users: [userId2])
|
|
let _ = try await self.secondStoreCenter.testSynchronizeOnceAsync()
|
|
|
|
guard let eventB = eventColB.first else {
|
|
throw TestError.missingEvent
|
|
}
|
|
#expect(eventA.id == eventB.id)
|
|
#expect(clubColB.count == 1)
|
|
|
|
// Second user changes the club
|
|
let club2B = Club(creator: userId2, name: "Club 2", acronym: "C2")
|
|
try await clubColB.addOrUpdateAsync(instance: club2B)
|
|
eventB.club = club2B.id
|
|
try await eventColB.addOrUpdateAsync(instance: eventB)
|
|
|
|
let dataA = try await StoreCenter.main.testSynchronizeOnceAsync()
|
|
let syncDataA = try SyncData(data: dataA, storeCenter: StoreCenter.main)
|
|
|
|
// #expect(syncDataA.sharedRelationshipSets.count == 1)
|
|
// #expect(syncDataA.sharedRelationshipRemovals.count == 1)
|
|
|
|
#expect(eventA.club == club2B.id)
|
|
#expect(clubColB.count == 1)
|
|
|
|
}
|
|
|
|
}
|
|
|