Semmal/eeg_portal
1
0
Fork 0
Code Issues Pull Requests 1 Packages Projects Releases Wiki Activity

test(iam,community): add tests for getAllMemberships and getAllUsers

Browse Source 
- Add getAllMemberships_returnsAllStatuses: verifies PENDING, ACTIVE, INACTIVE
- Add getAllMemberships_collectsDistinctUserIds: verifies distinct user ID collection
- Add getAllUsers_returnsSortedByCreatedAtDesc: verifies sorting order
- Add getAllUsers_returnsEmptyList: edge case for empty user list
- Add getAllUsers_includesAllRegistrationStatuses: verifies all statuses present
- All 172 backend tests pass
This commit is contained in:
Bernhard Müller 2026-07-23 14:13:14 +02:00
parent cf59de80bc
commit fe4ca2ccbd
2 changed files with 184 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

115
eeg_backend/src/test/java/at/mueller/eeg/backend/community/service/MembershipServiceTest.java
View File

@ -316,4 +316,119 @@ class MembershipServiceTest {
assertEquals(LocalDate.of(2025, 1, 15), result.get(0).validFrom()); assertEquals(LocalDate.of(2025, 1, 15), result.get(0).validFrom());
assertEquals(LocalDate.of(2025, 12, 31), result.get(0).validTo()); assertEquals(LocalDate.of(2025, 12, 31), result.get(0).validTo());
} }
@Test
void getAllMemberships_returnsAllStatuses() {
UUID userId2 = UUID.randomUUID();
UUID membershipId2 = UUID.randomUUID();
UUID membershipId3 = UUID.randomUUID();
User user2 = new User();
user2.setId(userId2);
user2.setEmail("user2@example.com");
user2.setFirstName("Zweiter");
user2.setLastName("Benutzer");
Membership pendingMembership = new Membership();
pendingMembership.setId(testMembershipId);
pendingMembership.setMeteringPoint(testMeteringPoint);
pendingMembership.setEnergyCommunity(testCommunity);
pendingMembership.setPriorityLevel(1);
pendingMembership.setStatus(MembershipStatus.PENDING);
MeteringPoint mp2 = new MeteringPoint();
mp2.setId(UUID.randomUUID());
mp2.setUserId(userId2);
mp2.setAtNumber("AT0010000000000000000000007654321");
mp2.setMakoState(MakoState.ACTIVE);
mp2.setSubstationId("UW_WAP_21_STREBERSDORF");
mp2.setTransformerId("TRAFO_21_042_BISAMBERG");
mp2.setGridOperatorId("Wiener Netze GmbH");
Membership activeMembership = new Membership();
activeMembership.setId(membershipId2);
activeMembership.setMeteringPoint(mp2);
activeMembership.setEnergyCommunity(testCommunity);
activeMembership.setPriorityLevel(1);
activeMembership.setStatus(MembershipStatus.ACTIVE);
activeMembership.setValidFrom(LocalDate.of(2025, 3, 1));
MeteringPoint mp3 = new MeteringPoint();
mp3.setId(UUID.randomUUID());
mp3.setUserId(testUserId);
mp3.setAtNumber("AT0010000000000000000000001111111");
mp3.setMakoState(MakoState.ACTIVE);
mp3.setSubstationId("UW_WAP_21_STREBERSDORF");
mp3.setTransformerId("TRAFO_21_042_BISAMBERG");
mp3.setGridOperatorId("Wiener Netze GmbH");
Membership inactiveMembership = new Membership();
inactiveMembership.setId(membershipId3);
inactiveMembership.setMeteringPoint(mp3);
inactiveMembership.setEnergyCommunity(testCommunity);
inactiveMembership.setPriorityLevel(2);
inactiveMembership.setStatus(MembershipStatus.INACTIVE);
when(membershipRepository.findAllWithDetails())
.thenReturn(List.of(pendingMembership, activeMembership, inactiveMembership));
when(userRepository.findAllById(List.of(testUserId, userId2)))
.thenReturn(List.of(testUser, user2));
List<PendingMembershipResponse> result = membershipService.getAllMemberships();
assertEquals(3, result.size());
PendingMembershipResponse pendingResult = result.stream()
.filter(r -> r.status().equals("PENDING")).findFirst().orElseThrow();
assertEquals("test@example.com", pendingResult.userEmail());
assertEquals("AT0010000000000000000000001234567", pendingResult.atNumber());
assertNull(pendingResult.validFrom());
PendingMembershipResponse activeResult = result.stream()
.filter(r -> r.status().equals("ACTIVE")).findFirst().orElseThrow();
assertEquals("user2@example.com", activeResult.userEmail());
assertEquals(LocalDate.of(2025, 3, 1), activeResult.validFrom());
PendingMembershipResponse inactiveResult = result.stream()
.filter(r -> r.status().equals("INACTIVE")).findFirst().orElseThrow();
assertEquals("test@example.com", inactiveResult.userEmail());
assertEquals(2, inactiveResult.priorityLevel());
}
@Test
void getAllMemberships_collectsDistinctUserIds() {
UUID userId2 = UUID.randomUUID();
User user2 = new User();
user2.setId(userId2);
user2.setEmail("user2@example.com");
user2.setFirstName("Zweiter");
user2.setLastName("Benutzer");
MeteringPoint mp2 = new MeteringPoint();
mp2.setId(UUID.randomUUID());
mp2.setUserId(userId2);
mp2.setAtNumber("AT0010000000000000000000007654321");
mp2.setMakoState(MakoState.ACTIVE);
mp2.setSubstationId("UW_WAP_21_STREBERSDORF");
mp2.setTransformerId("TRAFO_21_042_BISAMBERG");
mp2.setGridOperatorId("Wiener Netze GmbH");
Membership membership2 = new Membership();
membership2.setId(UUID.randomUUID());
membership2.setMeteringPoint(mp2);
membership2.setEnergyCommunity(testCommunity);
membership2.setPriorityLevel(2);
membership2.setStatus(MembershipStatus.ACTIVE);
when(membershipRepository.findAllWithDetails())
.thenReturn(List.of(testMembership, membership2));
when(userRepository.findAllById(List.of(testUserId, userId2)))
.thenReturn(List.of(testUser, user2));
List<PendingMembershipResponse> result = membershipService.getAllMemberships();
assertEquals(2, result.size());
verify(userRepository).findAllById(List.of(testUserId, userId2));
}
} }

69
eeg_backend/src/test/java/at/mueller/eeg/backend/iam/service/AdminIamServiceTest.java
View File

@ -142,4 +142,73 @@ class AdminIamServiceTest {
assertEquals("approved@example.com", result.get(1).getEmail()); assertEquals("approved@example.com", result.get(1).getEmail());
verify(userRepository).findAllByOrderByCreatedAtDesc(); verify(userRepository).findAllByOrderByCreatedAtDesc();
} }
@Test
void getAllUsers_returnsSortedByCreatedAtDesc() {
User olderUser = new User();
olderUser.setId(UUID.randomUUID());
olderUser.setEmail("older@example.com");
olderUser.setStatus(RegistrationStatus.APPROVED);
User newerUser = new User();
newerUser.setId(UUID.randomUUID());
newerUser.setEmail("newer@example.com");
newerUser.setStatus(RegistrationStatus.PENDING);
User newestUser = new User();
newestUser.setId(UUID.randomUUID());
newestUser.setEmail("newest@example.com");
newestUser.setStatus(RegistrationStatus.REJECTED);
when(userRepository.findAllByOrderByCreatedAtDesc())
.thenReturn(List.of(newestUser, newerUser, olderUser));
List<User> result = adminIamService.getAllUsers();
assertEquals(3, result.size());
assertEquals("newest@example.com", result.get(0).getEmail());
assertEquals("newer@example.com", result.get(1).getEmail());
assertEquals("older@example.com", result.get(2).getEmail());
assertEquals(RegistrationStatus.REJECTED, result.get(0).getStatus());
assertEquals(RegistrationStatus.PENDING, result.get(1).getStatus());
assertEquals(RegistrationStatus.APPROVED, result.get(2).getStatus());
}
@Test
void getAllUsers_returnsEmptyList() {
when(userRepository.findAllByOrderByCreatedAtDesc()).thenReturn(List.of());
List<User> result = adminIamService.getAllUsers();
assertTrue(result.isEmpty());
verify(userRepository).findAllByOrderByCreatedAtDesc();
}
@Test
void getAllUsers_includesAllRegistrationStatuses() {
User pendingUser = new User();
pendingUser.setId(UUID.randomUUID());
pendingUser.setEmail("pending@example.com");
pendingUser.setStatus(RegistrationStatus.PENDING);
User approvedUser = new User();
approvedUser.setId(UUID.randomUUID());
approvedUser.setEmail("approved@example.com");
approvedUser.setStatus(RegistrationStatus.APPROVED);
User rejectedUser = new User();
rejectedUser.setId(UUID.randomUUID());
rejectedUser.setEmail("rejected@example.com");
rejectedUser.setStatus(RegistrationStatus.REJECTED);
when(userRepository.findAllByOrderByCreatedAtDesc())
.thenReturn(List.of(pendingUser, approvedUser, rejectedUser));
List<User> result = adminIamService.getAllUsers();
assertEquals(3, result.size());
assertTrue(result.stream().anyMatch(u -> u.getStatus() == RegistrationStatus.PENDING));
assertTrue(result.stream().anyMatch(u -> u.getStatus() == RegistrationStatus.APPROVED));
assertTrue(result.stream().anyMatch(u -> u.getStatus() == RegistrationStatus.REJECTED));
}
} }