From 1071873be38515f09cc1b864563985a2d5a2e12e Mon Sep 17 00:00:00 2001 From: Maverick Studer Date: Wed, 13 Nov 2024 12:15:14 +0100 Subject: [PATCH] RED-10439: Migration Issue: After migration, global smtp settings does not apply --- ...alSMTPConfigurationPersistenceService.java | 26 +-- .../service/SMTPService.java | 178 +++++++++++------- .../tests/SMTPServiceTest.java | 139 ++++++++++++-- 3 files changed, 241 insertions(+), 102 deletions(-) diff --git a/src/main/java/com/knecon/fforesight/tenantusermanagement/service/GlobalSMTPConfigurationPersistenceService.java b/src/main/java/com/knecon/fforesight/tenantusermanagement/service/GlobalSMTPConfigurationPersistenceService.java index 006b694..75c63fd 100644 --- a/src/main/java/com/knecon/fforesight/tenantusermanagement/service/GlobalSMTPConfigurationPersistenceService.java +++ b/src/main/java/com/knecon/fforesight/tenantusermanagement/service/GlobalSMTPConfigurationPersistenceService.java @@ -1,14 +1,13 @@ package com.knecon.fforesight.tenantusermanagement.service; +import java.util.Optional; + import org.springframework.stereotype.Service; import org.springframework.transaction.annotation.Transactional; -import com.knecon.fforesight.tenantcommons.EncryptionDecryptionService; import com.knecon.fforesight.tenantusermanagement.entity.GlobalSMTPConfigurationEntity; import com.knecon.fforesight.tenantusermanagement.repository.GlobalSMTPConfigurationRepository; -import com.knecon.fforesight.tenantusermanagement.utils.SMTPConfigurationMapper; -import jakarta.annotation.PostConstruct; import lombok.AccessLevel; import lombok.RequiredArgsConstructor; import lombok.experimental.FieldDefaults; @@ -19,32 +18,17 @@ import lombok.experimental.FieldDefaults; public class GlobalSMTPConfigurationPersistenceService { GlobalSMTPConfigurationRepository smtpConfigurationRepository; - EnvironmentSMTPConfigurationProvider environmentSMTPConfigurationProvider; - EncryptionDecryptionService encryptionDecryptionService; - - - @PostConstruct - public void init() { - - smtpConfigurationRepository.findSingleton() - .orElseGet(() -> { - GlobalSMTPConfigurationEntity defaultConfig = SMTPConfigurationMapper.toEntity(environmentSMTPConfigurationProvider.get()); - defaultConfig.setPassword(encryptionDecryptionService.encrypt(defaultConfig.getPassword())); - return smtpConfigurationRepository.save(defaultConfig); - }); - } @Transactional(readOnly = true) - public GlobalSMTPConfigurationEntity getConfiguration() { + public Optional get() { - return smtpConfigurationRepository.findSingleton() - .orElseThrow(() -> new IllegalStateException("Global SMTP Configuration not found.")); + return smtpConfigurationRepository.findSingleton(); } @Transactional - public GlobalSMTPConfigurationEntity updateConfiguration(GlobalSMTPConfigurationEntity smtpConfiguration) { + public GlobalSMTPConfigurationEntity createUpdate(GlobalSMTPConfigurationEntity smtpConfiguration) { smtpConfiguration.setId("singleton"); return smtpConfigurationRepository.save(smtpConfiguration); diff --git a/src/main/java/com/knecon/fforesight/tenantusermanagement/service/SMTPService.java b/src/main/java/com/knecon/fforesight/tenantusermanagement/service/SMTPService.java index fbf65dc..16182a8 100644 --- a/src/main/java/com/knecon/fforesight/tenantusermanagement/service/SMTPService.java +++ b/src/main/java/com/knecon/fforesight/tenantusermanagement/service/SMTPService.java @@ -5,12 +5,14 @@ import java.util.List; import java.util.Map; import java.util.Optional; +import org.apache.commons.lang3.StringUtils; +import org.springframework.boot.context.event.ApplicationReadyEvent; +import org.springframework.context.event.EventListener; import org.springframework.stereotype.Service; import com.fasterxml.jackson.core.type.TypeReference; import com.fasterxml.jackson.databind.ObjectMapper; import com.iqser.red.service.persistence.service.v1.api.shared.model.license.Feature; -import com.iqser.red.service.persistence.service.v1.api.shared.model.license.License; import com.iqser.red.service.persistence.service.v1.api.shared.model.license.RedactionLicenseModel; import com.knecon.fforesight.tenantcommons.EncryptionDecryptionService; import com.knecon.fforesight.tenantcommons.TenantContext; @@ -21,13 +23,12 @@ import com.knecon.fforesight.tenantusermanagement.model.SMTPConfiguration; import com.knecon.fforesight.tenantusermanagement.repository.TenantRepository; import com.knecon.fforesight.tenantusermanagement.utils.SMTPConfigurationMapper; -import jakarta.annotation.PostConstruct; import lombok.RequiredArgsConstructor; import lombok.extern.slf4j.Slf4j; @Service -@RequiredArgsConstructor @Slf4j +@RequiredArgsConstructor public class SMTPService { private final GlobalSMTPConfigurationPersistenceService smtpConfigurationPersistenceService; @@ -44,64 +45,24 @@ public class SMTPService { private final static String DEFAULT_PASSWORD = "**********"; public static final String CONFIGURABLE_SMTP_SERVER_FEATURE = "configurableSMTPServer"; - - @PostConstruct + @EventListener(ApplicationReadyEvent.class) public void synchronizeSMTPConfigurations() { log.info("Starting SMTP configuration synchronization..."); try { - // Step 1: Retrieve all tenants List tenants = tenantRepository.findAll(); log.info("Retrieved {} tenants for SMTP synchronization.", tenants.size()); - // Step 2: Retrieve the global SMTP configuration - GlobalSMTPConfigurationEntity latestGlobalConfigEntity = smtpConfigurationPersistenceService.getConfiguration(); - SMTPConfiguration latestGlobalConfig = SMTPConfigurationMapper.toModel(latestGlobalConfigEntity); - latestGlobalConfig.setPassword(encryptionDecryptionService.decrypt(latestGlobalConfig.getPassword())); - log.info("Loaded existing global SMTP configuration."); + Optional optionalLatestGlobalConfigEntity = smtpConfigurationPersistenceService.get(); - // Step 3: Generate the latest SMTP config from environment variables and compare it to the saved global config - SMTPConfiguration currentGlobalConfig = environmentSMTPConfigurationProvider.get(); - if (!currentGlobalConfig.equals(latestGlobalConfig)) { - log.info("Environment SMTP configuration has changed. Updating global SMTP configuration."); + if (optionalLatestGlobalConfigEntity.isEmpty()) { + log.info("Global SMTP configuration was newly added. Initializing all tenant SMTP configurations."); + initializeGlobalSmtpConfig(tenants); - // Step 4: Iterate through each tenant to synchronize SMTP configurations - tenants - .forEach(tenant -> { - String tenantId = tenant.getTenantId(); - log.info("Processing SMTP configuration for tenant: {}", tenantId); - - try { - TenantContext.setTenantId(tenantId); - SMTPConfiguration tenantSMTPConfig = getSMTPConfiguration(); - tenantSMTPConfig.setId("singleton"); - updatePassword(tenantSMTPConfig); - if(!tenantSMTPConfig.getPassword().isBlank()) { - tenantSMTPConfig.setPassword(encryptionDecryptionService.decrypt(tenantSMTPConfig.getPassword())); - } - if (tenantSMTPConfig.equals(latestGlobalConfig)) { - log.info("Tenant '{}' SMTP configuration matches global. Updating to latest environment configuration.", tenantId); - updateSMTPConfiguration(currentGlobalConfig); - log.info("Tenant '{}' SMTP configuration updated successfully.", tenantId); - } else { - log.info("Tenant '{}' SMTP configuration differs from global. No action taken.", tenantId); - } - - } catch (Exception e) { - log.error("Error processing SMTP configuration for tenant '{}': {}", tenant.getTenantId(), e.getMessage()); - } finally { - TenantContext.clear(); - } - }); - - currentGlobalConfig.setPassword(encryptionDecryptionService.encrypt(currentGlobalConfig.getPassword())); - GlobalSMTPConfigurationEntity updatedGlobalConfig = SMTPConfigurationMapper.toEntity(currentGlobalConfig); - smtpConfigurationPersistenceService.updateConfiguration(updatedGlobalConfig); } else { - log.info("No changes detected in environment SMTP configuration."); + updateGlobalSmtpConfig(optionalLatestGlobalConfigEntity.get(), tenants); } - log.info("SMTP configuration synchronization completed successfully."); } catch (Exception e) { @@ -110,6 +71,95 @@ public class SMTPService { } + private void initializeGlobalSmtpConfig(List tenants) { + + SMTPConfiguration currentGlobalConfig = environmentSMTPConfigurationProvider.get(); + + initializeTenantsSmtpConfig(tenants, currentGlobalConfig); + + currentGlobalConfig.setPassword(encryptionDecryptionService.encrypt(currentGlobalConfig.getPassword())); + GlobalSMTPConfigurationEntity updatedGlobalConfig = SMTPConfigurationMapper.toEntity(currentGlobalConfig); + smtpConfigurationPersistenceService.createUpdate(updatedGlobalConfig); + + } + + + private void updateGlobalSmtpConfig(GlobalSMTPConfigurationEntity latestGlobalConfigEntity, List tenants) { + + SMTPConfiguration latestGlobalConfig = SMTPConfigurationMapper.toModel(latestGlobalConfigEntity); + latestGlobalConfig.setPassword(encryptionDecryptionService.decrypt(latestGlobalConfig.getPassword())); + log.info("Existing global SMTP configuration was loaded."); + + // Generate the latest SMTP config from environment variables and compare it to the last/saved global config + SMTPConfiguration currentGlobalConfig = environmentSMTPConfigurationProvider.get(); + if (!currentGlobalConfig.equals(latestGlobalConfig)) { + + log.info("Environment SMTP configuration has changed. Updating global SMTP configuration."); + updateTenantsSmtpConfig(tenants, latestGlobalConfig, currentGlobalConfig); + + currentGlobalConfig.setPassword(encryptionDecryptionService.encrypt(currentGlobalConfig.getPassword())); + GlobalSMTPConfigurationEntity updatedGlobalConfig = SMTPConfigurationMapper.toEntity(currentGlobalConfig); + smtpConfigurationPersistenceService.createUpdate(updatedGlobalConfig); + + } else { + log.info("No changes detected in environment SMTP configuration."); + } + } + + + private void initializeTenantsSmtpConfig(List tenants, SMTPConfiguration currentGlobalConfig) { + + tenants.forEach(tenant -> processTenantSmtpConfig(tenant, currentGlobalConfig, null, true)); + } + + + private void updateTenantsSmtpConfig(List tenants, SMTPConfiguration latestGlobalConfig, SMTPConfiguration currentGlobalConfig) { + + tenants.forEach(tenant -> processTenantSmtpConfig(tenant, currentGlobalConfig, latestGlobalConfig, false)); + } + + + private void processTenantSmtpConfig(TenantEntity tenant, SMTPConfiguration currentGlobalConfig, SMTPConfiguration latestGlobalConfig, boolean isInitialization) { + + String tenantId = tenant.getTenantId(); + log.info("Processing SMTP configuration for tenant: {}", tenantId); + + try { + TenantContext.setTenantId(tenantId); + SMTPConfiguration tenantSMTPConfig = getSMTPConfiguration(); + tenantSMTPConfig.setId("singleton"); + updatePassword(tenantSMTPConfig); + + if (!StringUtils.isBlank(tenantSMTPConfig.getPassword())) { + tenantSMTPConfig.setPassword(encryptionDecryptionService.decrypt(tenantSMTPConfig.getPassword())); + } + + if (isInitialization) { + if (StringUtils.isBlank(tenantSMTPConfig.getHost())) { + log.info("Tenant '{}' SMTP configuration has not been set yet.", tenantId); + updateSMTPConfiguration(currentGlobalConfig); + log.info("Tenant '{}' SMTP configuration set successfully.", tenantId); + } else { + log.info("Tenant '{}' SMTP configuration was already set. No action taken.", tenantId); + } + } else { + if (tenantSMTPConfig.equals(latestGlobalConfig)) { + log.info("Tenant '{}' SMTP configuration matches global. Updating to latest environment configuration.", tenantId); + updateSMTPConfiguration(currentGlobalConfig); + log.info("Tenant '{}' SMTP configuration updated successfully.", tenantId); + } else { + log.info("Tenant '{}' SMTP configuration differs from global. No action taken.", tenantId); + } + } + + } catch (Exception e) { + log.error("Error processing SMTP configuration for tenant '{}': {}", tenantId, e.getMessage()); + } finally { + TenantContext.clear(); + } + } + + public SMTPConfiguration getSMTPConfiguration() { var realm = realmService.realm(TenantContext.getTenantId()).toRepresentation(); @@ -129,23 +179,18 @@ public class SMTPService { RedactionLicenseModel licenseModel = licenseClient.getLicense(); String activeLicenseId = licenseModel.getActiveLicense(); - Optional license = licenseModel.getLicenses() + + return licenseModel.getLicenses() .stream() - .filter(l -> l.getId().equals(activeLicenseId)) - .findFirst(); - if (license.isPresent()) { - License activeLicense = license.get(); - Optional optionalConfigurableSMTPFeature = activeLicense.getFeatures() - .stream() - .filter(feature -> feature.getName().equals(CONFIGURABLE_SMTP_SERVER_FEATURE)) - .findFirst(); - if (optionalConfigurableSMTPFeature.isPresent()) { - return (Boolean) optionalConfigurableSMTPFeature.get().getValue(); - } else { - return false; - } - } - return false; + .filter(license -> license.getId().equals(activeLicenseId)) + .flatMap(license -> license.getFeatures() + .stream()) + .filter(feature -> CONFIGURABLE_SMTP_SERVER_FEATURE.equals(feature.getName())) + .map(Feature::getValue) + .filter(Boolean.class::isInstance) + .map(Boolean.class::cast) + .findFirst() + .orElse(false); } @@ -200,8 +245,7 @@ public class SMTPService { if (DEFAULT_PASSWORD.equals(smtpConfiguration.getPassword())) { try { - var password = realmService.realm(TenantContext.getTenantId()).toRepresentation().getAttributesOrEmpty() - .getOrDefault(SMTP_PASSWORD_KEY, ""); + var password = realmService.realm(TenantContext.getTenantId()).toRepresentation().getAttributesOrEmpty().getOrDefault(SMTP_PASSWORD_KEY, ""); smtpConfiguration.setPassword(password); } catch (Exception e) { log.info("No current SMTP Config exists", e); diff --git a/src/test/java/com/knecon/fforesight/tenantusermanagement/tests/SMTPServiceTest.java b/src/test/java/com/knecon/fforesight/tenantusermanagement/tests/SMTPServiceTest.java index 334bed9..dca6b5d 100644 --- a/src/test/java/com/knecon/fforesight/tenantusermanagement/tests/SMTPServiceTest.java +++ b/src/test/java/com/knecon/fforesight/tenantusermanagement/tests/SMTPServiceTest.java @@ -8,11 +8,13 @@ import static org.mockito.Mockito.never; import static org.mockito.Mockito.times; import static org.mockito.Mockito.verify; import static org.mockito.Mockito.when; +import static org.mockito.quality.Strictness.LENIENT; import java.util.Arrays; import java.util.HashMap; import java.util.List; import java.util.Map; +import java.util.Optional; import org.jetbrains.annotations.NotNull; import org.junit.jupiter.api.BeforeEach; @@ -21,8 +23,10 @@ import org.junit.jupiter.api.extension.ExtendWith; import org.keycloak.admin.client.resource.RealmResource; import org.keycloak.representations.idm.RealmRepresentation; import org.mockito.ArgumentCaptor; +import org.mockito.ArgumentMatchers; import org.mockito.InjectMocks; import org.mockito.Mock; +import org.mockito.junit.jupiter.MockitoSettings; import com.fasterxml.jackson.databind.ObjectMapper; import com.knecon.fforesight.tenantcommons.EncryptionDecryptionService; @@ -35,6 +39,7 @@ import com.knecon.fforesight.tenantusermanagement.service.GlobalSMTPConfiguratio import com.knecon.fforesight.tenantusermanagement.service.RealmService; import com.knecon.fforesight.tenantusermanagement.service.SMTPService; +@MockitoSettings(strictness = LENIENT) @ExtendWith(org.mockito.junit.jupiter.MockitoExtension.class) public class SMTPServiceTest { @@ -46,6 +51,8 @@ public class SMTPServiceTest { public static final int OLD_SMTP_PORT = 587; public static final String OLD_SMTP_USER = "globalUser"; public static final String OLD_SMTP_PASSWORD = "oldPassword"; + public static final String FFORESIGHT_SMTP_PASSWORD = "FFORESIGHT_SMTP_PASSWORD"; + @Mock private GlobalSMTPConfigurationPersistenceService smtpConfigurationPersistenceService; @@ -74,12 +81,12 @@ public class SMTPServiceTest { public void setUp() { smtpService = new SMTPService(smtpConfigurationPersistenceService, - environmentSMTPConfigurationProvider, - null, - realmService, - tenantRepository, - encryptionDecryptionService, - new ObjectMapper()); + environmentSMTPConfigurationProvider, + null, + realmService, + tenantRepository, + encryptionDecryptionService, + new ObjectMapper()); oldGlobalConfig = new SMTPConfiguration(); oldGlobalConfig.setId("singleton"); @@ -111,13 +118,18 @@ public class SMTPServiceTest { globalEntity.setPort(oldGlobalConfig.getPort()); globalEntity.setUserName(oldGlobalConfig.getUser()); globalEntity.setPassword(oldGlobalConfig.getPassword()); - when(smtpConfigurationPersistenceService.getConfiguration()).thenReturn(globalEntity); + when(smtpConfigurationPersistenceService.get()).thenReturn(Optional.of(globalEntity)); for (TenantEntity tenant : tenantEntities) { RealmResource tenantRealmResource = mock(RealmResource.class); when(realmService.realm(tenant.getTenantId())).thenReturn(tenantRealmResource); } + when(encryptionDecryptionService.encrypt(ArgumentMatchers.any())).thenAnswer(invocation -> { + String argument = invocation.getArgument(0); + return argument != null ? "encrypted_" + argument : null; + }); + when(encryptionDecryptionService.decrypt(anyString())).thenAnswer(invocation -> { String encrypted = invocation.getArgument(0); if (encrypted.startsWith("encrypted_")) { @@ -139,8 +151,6 @@ public class SMTPServiceTest { when(tenantRealmResource.toRepresentation()).thenReturn(realm); } - when(encryptionDecryptionService.encrypt(anyString())).thenAnswer(invocation -> "encrypted_" + invocation.getArgument(0)); - SMTPConfiguration newEnvConfig = new SMTPConfiguration(); newEnvConfig.setId("singleton"); newEnvConfig.setHost(NEW_SMTP_HOST); @@ -152,7 +162,7 @@ public class SMTPServiceTest { smtpService.synchronizeSMTPConfigurations(); ArgumentCaptor globalConfigCaptor = ArgumentCaptor.forClass(GlobalSMTPConfigurationEntity.class); - verify(smtpConfigurationPersistenceService).updateConfiguration(globalConfigCaptor.capture()); + verify(smtpConfigurationPersistenceService).createUpdate(globalConfigCaptor.capture()); GlobalSMTPConfigurationEntity updatedGlobalConfig = globalConfigCaptor.getValue(); assertEquals(NEW_SMTP_HOST, updatedGlobalConfig.getHost()); @@ -177,7 +187,8 @@ public class SMTPServiceTest { assertEquals(NEW_SMTP_HOST, smtpServer.get("host")); assertEquals(String.valueOf(NEW_SMTP_PORT), smtpServer.get("port")); assertEquals(NEW_SMTP_USER, smtpServer.get("user")); - assertEquals("encrypted_" + NEW_SMTP_PASSWORD, smtpServer.get("FFORESIGHT_SMTP_PASSWORD")); + assertEquals("encrypted_" + NEW_SMTP_PASSWORD, smtpServer.get(FFORESIGHT_SMTP_PASSWORD)); + assertEquals(NEW_SMTP_PASSWORD, smtpServer.get("password")); } else if ("tenant2".equals(tenant.getTenantId())) { // Verify that update() was never called for tenant2 verify(tenantRealmResource, never()).update(any(RealmRepresentation.class)); @@ -199,7 +210,7 @@ public class SMTPServiceTest { smtpService.synchronizeSMTPConfigurations(); - verify(smtpConfigurationPersistenceService, never()).updateConfiguration(any(GlobalSMTPConfigurationEntity.class)); + verify(smtpConfigurationPersistenceService, never()).createUpdate(any(GlobalSMTPConfigurationEntity.class)); // Verify that all tenants are unchanged for (TenantEntity tenant : tenantEntities) { @@ -210,6 +221,106 @@ public class SMTPServiceTest { } + @Test + public void testInitializeGlobalSMTPConfiguration() { + + + TenantEntity tenant1 = new TenantEntity(); + tenant1.setTenantId("tenant1"); + + TenantEntity tenant2 = new TenantEntity(); + tenant2.setTenantId("tenant2"); + + List tenantEntities = Arrays.asList(tenant1, tenant2); + + when(tenantRepository.findAll()).thenReturn(tenantEntities); + + when(smtpConfigurationPersistenceService.get()).thenReturn(Optional.empty()); + + String host = "global.smtp.host"; + int port = 25; + String globalUser = "globalUser"; + String globalPassword = "globalPassword"; + + SMTPConfiguration currentGlobalConfig = new SMTPConfiguration(); + currentGlobalConfig.setId("singleton"); + currentGlobalConfig.setHost(host); + currentGlobalConfig.setPort(port); + currentGlobalConfig.setUser(globalUser); + currentGlobalConfig.setPassword(globalPassword); + + when(environmentSMTPConfigurationProvider.get()).thenReturn(currentGlobalConfig); + + // Tenant1: Predefined SMTP configuration + RealmResource tenantRealmResource1 = mock(RealmResource.class); + when(realmService.realm("tenant1")).thenReturn(tenantRealmResource1); + RealmRepresentation realmRepresentation1 = getRealmRepresentationPredefined(); + + when(tenantRealmResource1.toRepresentation()).thenReturn(realmRepresentation1); + + // Tenant2: No SMTP configuration + RealmResource tenantRealmResource2 = mock(RealmResource.class); + when(realmService.realm("tenant2")).thenReturn(tenantRealmResource2); + RealmRepresentation realmRepresentation2 = new RealmRepresentation(); + + Map smtpServer2 = new HashMap<>(); + smtpServer2.put("host", ""); + realmRepresentation2.setSmtpServer(smtpServer2); + realmRepresentation2.setAttributes(new HashMap<>()); + + when(tenantRealmResource2.toRepresentation()).thenReturn(realmRepresentation2); + + smtpService.synchronizeSMTPConfigurations(); + + ArgumentCaptor globalConfigCaptor = ArgumentCaptor.forClass(GlobalSMTPConfigurationEntity.class); + verify(smtpConfigurationPersistenceService).createUpdate(globalConfigCaptor.capture()); + + GlobalSMTPConfigurationEntity updatedGlobalConfig = globalConfigCaptor.getValue(); + assertEquals(host, updatedGlobalConfig.getHost()); + assertEquals(port, updatedGlobalConfig.getPort()); + assertEquals(globalUser, updatedGlobalConfig.getUserName()); + String encryptedGlobalPassword = "encrypted_" + globalPassword; + assertEquals(encryptedGlobalPassword, updatedGlobalConfig.getPassword()); + + // Verify that tenant1's SMTP configuration remains unchanged + verify(tenantRealmResource1, never()).update(any(RealmRepresentation.class)); + + // Verify that tenant2's SMTP configuration is updated + ArgumentCaptor realmCaptor2 = ArgumentCaptor.forClass(RealmRepresentation.class); + verify(tenantRealmResource2, times(1)).update(realmCaptor2.capture()); + + RealmRepresentation updatedRealm2 = realmCaptor2.getValue(); + Map updatedSmtpServer2 = updatedRealm2.getSmtpServer(); + + assertEquals(host, updatedSmtpServer2.get("host")); + assertEquals(String.valueOf(port), updatedSmtpServer2.get("port")); + assertEquals(globalUser, updatedSmtpServer2.get("user")); + assertEquals(globalPassword, updatedSmtpServer2.get("password")); + + Map updatedAttributes2 = updatedRealm2.getAttributes(); + assertEquals(encryptedGlobalPassword, updatedAttributes2.get(FFORESIGHT_SMTP_PASSWORD)); + } + + + @NotNull + private static RealmRepresentation getRealmRepresentationPredefined() { + + RealmRepresentation realmRepresentation1 = new RealmRepresentation(); + + Map smtpServer1 = new HashMap<>(); + smtpServer1.put("host", "predefined.smtp.host"); + smtpServer1.put("port", "587"); + smtpServer1.put("user", "user1"); + smtpServer1.put("password", DEFAULT_PASSWORD); + Map attributes = new HashMap<>(); + attributes.put(FFORESIGHT_SMTP_PASSWORD, "encrypted_predefined_pass"); + + realmRepresentation1.setSmtpServer(smtpServer1); + realmRepresentation1.setAttributes(attributes); + return realmRepresentation1; + } + + @NotNull private static RealmRepresentation getRealmRepresentation(TenantEntity tenant, SMTPConfiguration overriddenConfig, SMTPConfiguration oldGlobalConfig) { @@ -223,14 +334,14 @@ public class SMTPServiceTest { smtpMap.put("host", overriddenConfig.getHost()); smtpMap.put("port", String.valueOf(overriddenConfig.getPort())); smtpMap.put("user", overriddenConfig.getUser()); - attributes.put("FFORESIGHT_SMTP_PASSWORD", overriddenConfig.getPassword()); + attributes.put(FFORESIGHT_SMTP_PASSWORD, overriddenConfig.getPassword()); } else { // tenant1 and tenant3 have SMTP config matching global smtpMap.put("host", oldGlobalConfig.getHost()); smtpMap.put("port", String.valueOf(oldGlobalConfig.getPort())); smtpMap.put("user", oldGlobalConfig.getUser()); - attributes.put("FFORESIGHT_SMTP_PASSWORD", oldGlobalConfig.getPassword()); + attributes.put(FFORESIGHT_SMTP_PASSWORD, oldGlobalConfig.getPassword()); } realm.setSmtpServer(smtpMap);