Examples with SysSyncLogDto eu.bcvsolutions.idm.acc.dto.SysSyncLogDto used on opensource projects

Example 76 with SysSyncLogDto

use of eu.bcvsolutions.idm.acc.dto.SysSyncLogDto in project CzechIdMng by bcvsolutions.

the class DefaultRoleSynchronizationExecutorTest method testSyncRoles.

@Test
public void testSyncRoles() {
    AbstractSysSyncConfigDto syncConfigCustom = createSyncConfig();
    Assert.assertFalse(syncConfigService.isRunning(syncConfigCustom));
    Assert.assertTrue(syncConfigCustom instanceof SysSyncRoleConfigDto);
    // 
    helper.startSynchronization(syncConfigCustom);
    // 
    SysSyncLogFilter logFilter = new SysSyncLogFilter();
    logFilter.setSynchronizationConfigId(syncConfigCustom.getId());
    List<SysSyncLogDto> logs = syncLogService.find(logFilter, null).getContent();
    Assert.assertEquals(1, logs.size());
    SysSyncLogDto log = logs.get(0);
    Assert.assertFalse(log.isRunning());
    Assert.assertFalse(log.isContainsError());
    SysSystemMappingDto systemMappingDto = DtoUtils.getEmbedded(syncConfigCustom, SysSyncConfig_.systemMapping, SysSystemMappingDto.class);
    SysSchemaObjectClassDto schemaObjectClassDto = DtoUtils.getEmbedded(systemMappingDto, SysSystemMapping_.objectClass, SysSchemaObjectClassDto.class);
    UUID systemId = schemaObjectClassDto.getSystem();
    Assert.assertNotNull(systemId);
    helper.checkSyncLog(syncConfigCustom, SynchronizationActionType.CREATE_ENTITY, 5, OperationResultType.SUCCESS);
    AccRoleAccountFilter roleAccountFilter = new AccRoleAccountFilter();
    roleAccountFilter.setSystemId(systemId);
    List<AccRoleAccountDto> roleAccountDtos = roleAccountService.find(roleAccountFilter, null).getContent();
    Assert.assertEquals(5, roleAccountDtos.size());
    roleAccountDtos.forEach(roleAccountDto -> {
        SysRoleSystemFilter roleSystemFilter = new SysRoleSystemFilter();
        roleSystemFilter.setRoleId(roleAccountDto.getRole());
        List<SysRoleSystemDto> roleSystemDtos = roleSystemService.find(roleSystemFilter, null).getContent();
        Assert.assertTrue(roleSystemDtos.isEmpty());
    });
    // Delete a log.
    syncLogService.delete(log);
    // Delete roles.
    roleAccountDtos.forEach(roleAccountDto -> {
        roleService.delete(roleService.get(roleAccountDto.getRole()));
    });
    // Delete sync.
    syncConfigService.delete(syncConfigCustom);
    // Delete system.
    systemService.delete(systemService.get(systemId));
}

Example 77 with SysSyncLogDto

use of eu.bcvsolutions.idm.acc.dto.SysSyncLogDto in project CzechIdMng by bcvsolutions.

the class DefaultRoleSynchronizationExecutorTest method testSyncRolesSkipValueIfExcluded.

@Test
public void testSyncRolesSkipValueIfExcluded() {
    AbstractSysSyncConfigDto syncConfigCustom = createSyncConfig();
    SysSystemDto userSystem = helper.createTestResourceSystem(true);
    List<SysSystemMappingDto> userSystemMappings = systemMappingService.findBySystem(userSystem, SystemOperationType.PROVISIONING, SystemEntityType.IDENTITY);
    Assert.assertNotNull(userSystemMappings);
    Assert.assertEquals(1, userSystemMappings.size());
    SysSystemMappingDto userMappingDto = userSystemMappings.get(0);
    // Switch to the sync.
    userMappingDto.setOperationType(SystemOperationType.SYNCHRONIZATION);
    userMappingDto = systemMappingService.save(userMappingDto);
    List<SysSystemAttributeMappingDto> attributeMappingDtos = schemaAttributeMappingService.findBySystemMapping(userMappingDto);
    SysSystemAttributeMappingDto userEmailAttribute = attributeMappingDtos.stream().filter(attribute -> attribute.getName().equalsIgnoreCase(TestHelper.ATTRIBUTE_MAPPING_EMAIL)).findFirst().orElse(null);
    Assert.assertNotNull(userEmailAttribute);
    Assert.assertFalse(syncConfigService.isRunning(syncConfigCustom));
    Assert.assertTrue(syncConfigCustom instanceof SysSyncRoleConfigDto);
    SysSyncRoleConfigDto roleConfigDto = (SysSyncRoleConfigDto) syncConfigCustom;
    SysSystemMappingDto systemMappingDto = DtoUtils.getEmbedded(syncConfigCustom, SysSyncConfig_.systemMapping, SysSystemMappingDto.class);
    SysSchemaObjectClassDto schemaObjectClassDto = DtoUtils.getEmbedded(systemMappingDto, SysSystemMapping_.objectClass, SysSchemaObjectClassDto.class);
    UUID systemId = schemaObjectClassDto.getSystem();
    Assert.assertNotNull(systemId);
    SysSchemaAttributeFilter schemaAttributeFilter = new SysSchemaAttributeFilter();
    schemaAttributeFilter.setSystemId(systemId);
    schemaAttributeFilter.setObjectClassId(schemaObjectClassDto.getId());
    SysSchemaAttributeDto schemaAttributeDto = schemaAttributeService.find(schemaAttributeFilter, null).getContent().stream().filter(attribute -> attribute.getName().equalsIgnoreCase("name")).findFirst().orElse(null);
    Assert.assertNotNull(schemaAttributeDto);
    SysSystemDto roleSystemDto = new SysSystemDto();
    roleSystemDto.setId(systemId);
    List<SysSystemMappingDto> roleSystemMappings = systemMappingService.findBySystem(roleSystemDto, SystemOperationType.SYNCHRONIZATION, SystemEntityType.ROLE);
    Assert.assertNotNull(roleSystemMappings);
    Assert.assertEquals(1, roleSystemMappings.size());
    SysSystemMappingDto roleMappingDto = roleSystemMappings.get(0);
    // Create mapping attribute for get ID of role.
    SysSystemAttributeMappingDto roleIdAttribute = new SysSystemAttributeMappingDto();
    roleIdAttribute.setEntityAttribute(true);
    roleIdAttribute.setUid(false);
    roleIdAttribute.setSystemMapping(roleMappingDto.getId());
    roleIdAttribute.setExtendedAttribute(false);
    roleIdAttribute.setIdmPropertyName(RoleSynchronizationExecutor.ROLE_MEMBERSHIP_ID_FIELD);
    roleIdAttribute.setSchemaAttribute(schemaAttributeDto.getId());
    roleIdAttribute.setName(helper.createName());
    attributeMappingService.save(roleIdAttribute);
    // Create mapping attribute for get ID of role.
    SysSystemAttributeMappingDto frorwardAcmAttribute = new SysSystemAttributeMappingDto();
    frorwardAcmAttribute.setEntityAttribute(true);
    frorwardAcmAttribute.setUid(false);
    frorwardAcmAttribute.setSystemMapping(roleMappingDto.getId());
    frorwardAcmAttribute.setExtendedAttribute(false);
    frorwardAcmAttribute.setIdmPropertyName(RoleSynchronizationExecutor.ROLE_SKIP_VALUE_IF_EXCLUDED_FIELD);
    frorwardAcmAttribute.setSchemaAttribute(schemaAttributeDto.getId());
    frorwardAcmAttribute.setName(helper.createName());
    frorwardAcmAttribute.setTransformFromResourceScript("return true");
    attributeMappingService.save(frorwardAcmAttribute);
    // Enable membership and use the user system.
    roleConfigDto.setMembershipSwitch(true);
    roleConfigDto.setMemberSystemMapping(userMappingDto.getId());
    roleConfigDto.setMemberOfAttribute(userEmailAttribute.getId());
    roleConfigDto.setSkipValueIfExcludedSwitch(false);
    roleConfigDto = (SysSyncRoleConfigDto) syncConfigService.save(roleConfigDto);
    Assert.assertNotNull(roleConfigDto.getSkipValueIfExcludedMappingAttribute());
    // Start sync of roles.
    helper.startSynchronization(roleConfigDto);
    SysSyncLogFilter logFilter = new SysSyncLogFilter();
    logFilter.setSynchronizationConfigId(roleConfigDto.getId());
    List<SysSyncLogDto> logs = syncLogService.find(logFilter, null).getContent();
    Assert.assertEquals(1, logs.size());
    SysSyncLogDto log = logs.get(0);
    Assert.assertFalse(log.isRunning());
    Assert.assertFalse(log.isContainsError());
    helper.checkSyncLog(roleConfigDto, SynchronizationActionType.CREATE_ENTITY, 5, OperationResultType.SUCCESS);
    AccRoleAccountFilter roleAccountFilter = new AccRoleAccountFilter();
    roleAccountFilter.setSystemId(systemId);
    List<AccRoleAccountDto> roleAccountDtos = roleAccountService.find(roleAccountFilter, null).getContent();
    Assert.assertEquals(5, roleAccountDtos.size());
    roleAccountDtos.forEach(roleAccountDto -> {
        SysRoleSystemFilter roleSystemFilter = new SysRoleSystemFilter();
        roleSystemFilter.setRoleId(roleAccountDto.getRole());
        List<SysRoleSystemDto> roleSystemDtos = roleSystemService.find(roleSystemFilter, null).getContent();
        Assert.assertEquals(1, roleSystemDtos.size());
        SysRoleSystemDto roleSystem = roleSystemDtos.get(0);
        // Skip value if contract excluded feature is disabled now -> value should be "false".
        SysRoleSystemAttributeFilter roleSystemAttributeFilter = new SysRoleSystemAttributeFilter();
        roleSystemAttributeFilter.setRoleSystemId(roleSystem.getId());
        List<SysRoleSystemAttributeDto> roleSystemAttributeDtos = roleSystemAttributeService.find(roleSystemAttributeFilter, null).getContent();
        Assert.assertEquals(1, roleSystemAttributeDtos.size());
        Assert.assertFalse(roleSystemAttributeDtos.get(0).isSkipValueIfExcluded());
    });
    // Activate 'Skip value if excluded' in sync.
    roleConfigDto.setSkipValueIfExcludedSwitch(true);
    roleConfigDto = (SysSyncRoleConfigDto) syncConfigService.save(roleConfigDto);
    // Start sync of roles.
    helper.startSynchronization(roleConfigDto);
    helper.checkSyncLog(roleConfigDto, SynchronizationActionType.UPDATE_ENTITY, 5, OperationResultType.SUCCESS);
    roleAccountFilter.setSystemId(systemId);
    roleAccountDtos = roleAccountService.find(roleAccountFilter, null).getContent();
    Assert.assertEquals(5, roleAccountDtos.size());
    roleAccountDtos.forEach(roleAccountDto -> {
        SysRoleSystemFilter roleSystemFilter = new SysRoleSystemFilter();
        roleSystemFilter.setRoleId(roleAccountDto.getRole());
        List<SysRoleSystemDto> roleSystemDtos = roleSystemService.find(roleSystemFilter, null).getContent();
        Assert.assertEquals(1, roleSystemDtos.size());
        SysRoleSystemDto roleSystem = roleSystemDtos.get(0);
        // Skip value if contract excluded feature is enabled now -> value should be "true".
        SysRoleSystemAttributeFilter roleSystemAttributeFilter = new SysRoleSystemAttributeFilter();
        roleSystemAttributeFilter.setRoleSystemId(roleSystem.getId());
        List<SysRoleSystemAttributeDto> roleSystemAttributeDtos = roleSystemAttributeService.find(roleSystemAttributeFilter, null).getContent();
        Assert.assertEquals(1, roleSystemAttributeDtos.size());
        Assert.assertTrue(roleSystemAttributeDtos.get(0).isSkipValueIfExcluded());
    });
    cleanAfterTest(syncConfigCustom, systemId, log, roleAccountDtos);
}

Example 78 with SysSyncLogDto

use of eu.bcvsolutions.idm.acc.dto.SysSyncLogDto in project CzechIdMng by bcvsolutions.

the class DefaultRoleSynchronizationExecutorTest method testSyncRolesDeleteAssignedFromUsers.

@Test
public void testSyncRolesDeleteAssignedFromUsers() {
    AbstractSysSyncConfigDto syncConfigCustom = createSyncConfig();
    SysSystemDto userSystem = helper.createTestResourceSystem(true);
    List<SysSystemMappingDto> userSystemMappings = systemMappingService.findBySystem(userSystem, SystemOperationType.PROVISIONING, SystemEntityType.IDENTITY);
    Assert.assertNotNull(userSystemMappings);
    Assert.assertEquals(1, userSystemMappings.size());
    SysSystemMappingDto userMappingDto = userSystemMappings.get(0);
    // Switch to the sync.
    userMappingDto.setOperationType(SystemOperationType.SYNCHRONIZATION);
    userMappingDto = systemMappingService.save(userMappingDto);
    SysSyncIdentityConfigDto userSyncConfig = createUserSyncConfig(userSystem);
    List<SysSystemAttributeMappingDto> attributeMappingDtos = schemaAttributeMappingService.findBySystemMapping(userMappingDto);
    SysSystemAttributeMappingDto userEmailAttribute = attributeMappingDtos.stream().filter(attribute -> attribute.getName().equalsIgnoreCase(TestHelper.ATTRIBUTE_MAPPING_EMAIL)).findFirst().orElse(null);
    Assert.assertNotNull(userEmailAttribute);
    SysSystemAttributeMappingDto enableAttribute = attributeMappingDtos.stream().filter(attribute -> attribute.getName().equalsIgnoreCase(TestHelper.ATTRIBUTE_MAPPING_ENABLE)).findFirst().orElse(null);
    Assert.assertNotNull(enableAttribute);
    enableAttribute.setDisabledAttribute(true);
    attributeMappingService.save(enableAttribute);
    Assert.assertFalse(syncConfigService.isRunning(syncConfigCustom));
    Assert.assertTrue(syncConfigCustom instanceof SysSyncRoleConfigDto);
    SysSyncRoleConfigDto roleConfigDto = (SysSyncRoleConfigDto) syncConfigCustom;
    SysSystemMappingDto systemMappingDto = DtoUtils.getEmbedded(syncConfigCustom, SysSyncConfig_.systemMapping, SysSystemMappingDto.class);
    SysSchemaObjectClassDto schemaObjectClassDto = DtoUtils.getEmbedded(systemMappingDto, SysSystemMapping_.objectClass, SysSchemaObjectClassDto.class);
    UUID roleSystemId = schemaObjectClassDto.getSystem();
    Assert.assertNotNull(roleSystemId);
    SysSchemaAttributeFilter schemaAttributeFilter = new SysSchemaAttributeFilter();
    schemaAttributeFilter.setSystemId(roleSystemId);
    schemaAttributeFilter.setObjectClassId(schemaObjectClassDto.getId());
    SysSchemaAttributeDto schemaAttributeDto = schemaAttributeService.find(schemaAttributeFilter, null).getContent().stream().filter(attribute -> attribute.getName().equalsIgnoreCase("name")).findFirst().orElse(null);
    Assert.assertNotNull(schemaAttributeDto);
    SysSystemDto roleSystemDto = new SysSystemDto();
    roleSystemDto.setId(roleSystemId);
    List<SysSystemMappingDto> roleSystemMappings = systemMappingService.findBySystem(roleSystemDto, SystemOperationType.SYNCHRONIZATION, SystemEntityType.ROLE);
    Assert.assertNotNull(roleSystemMappings);
    Assert.assertEquals(1, roleSystemMappings.size());
    SysSystemMappingDto roleMappingDto = roleSystemMappings.get(0);
    // Create mapping attribute for get ID of role.
    SysSystemAttributeMappingDto roleIdAttribute = new SysSystemAttributeMappingDto();
    roleIdAttribute.setEntityAttribute(true);
    roleIdAttribute.setUid(false);
    roleIdAttribute.setSystemMapping(roleMappingDto.getId());
    roleIdAttribute.setExtendedAttribute(false);
    roleIdAttribute.setIdmPropertyName(RoleSynchronizationExecutor.ROLE_MEMBERSHIP_ID_FIELD);
    roleIdAttribute.setSchemaAttribute(schemaAttributeDto.getId());
    roleIdAttribute.setName(helper.createName());
    attributeMappingService.save(roleIdAttribute);
    String usernameOne = getHelper().createName();
    String usernameTwo = getHelper().createName();
    String usernameThree = getHelper().createName();
    // Create mapping attribute for get ID of role.
    SysSystemAttributeMappingDto membersRoleAttribute = new SysSystemAttributeMappingDto();
    membersRoleAttribute.setEntityAttribute(true);
    membersRoleAttribute.setUid(false);
    membersRoleAttribute.setSystemMapping(roleMappingDto.getId());
    membersRoleAttribute.setExtendedAttribute(false);
    membersRoleAttribute.setIdmPropertyName(RoleSynchronizationExecutor.ROLE_MEMBERS_FIELD);
    membersRoleAttribute.setSchemaAttribute(schemaAttributeDto.getId());
    membersRoleAttribute.setName(helper.createName());
    membersRoleAttribute.setTransformFromResourceScript("return ['" + usernameOne + "', '" + usernameTwo + "'];");
    membersRoleAttribute = attributeMappingService.save(membersRoleAttribute);
    SysSchemaAttributeFilter schemaUserAttributeFilter = new SysSchemaAttributeFilter();
    schemaUserAttributeFilter.setSystemId(userSystem.getId());
    SysSchemaAttributeDto nameUserSchemaAttribute = schemaAttributeService.find(schemaUserAttributeFilter, null).getContent().stream().filter(attribute -> "name".equalsIgnoreCase(attribute.getName())).findFirst().orElse(null);
    Assert.assertNotNull(nameUserSchemaAttribute);
    // Enable membership, assign role to users,  and use the user system.
    roleConfigDto.setMembershipSwitch(true);
    roleConfigDto.setMemberSystemMapping(userMappingDto.getId());
    roleConfigDto.setMemberOfAttribute(enableAttribute.getId());
    roleConfigDto.setAssignRoleSwitch(true);
    roleConfigDto.setRoleMembersMappingAttribute(membersRoleAttribute.getId());
    roleConfigDto.setMemberIdentifierAttribute(nameUserSchemaAttribute.getId());
    roleConfigDto = (SysSyncRoleConfigDto) syncConfigService.save(roleConfigDto);
    Assert.assertNotNull(roleConfigDto.getMemberOfAttribute());
    Assert.assertNotNull(roleConfigDto.getRoleIdentifiersMappingAttribute());
    Assert.assertNotNull(roleConfigDto.getRoleMembersMappingAttribute());
    Assert.assertNotNull(roleConfigDto.getMemberIdentifierAttribute());
    // Init users on system.
    helper.deleteAllResourceData();
    TestResource resource = new TestResource();
    resource.setName(usernameOne);
    resource.setFirstname(usernameOne);
    resource.setLastname(usernameOne);
    helper.saveResource(resource);
    resource.setName(usernameTwo);
    resource.setFirstname(usernameTwo);
    resource.setLastname(usernameTwo);
    helper.saveResource(resource);
    resource.setName(usernameThree);
    resource.setFirstname(usernameThree);
    resource.setLastname(usernameThree);
    helper.saveResource(resource);
    // Start sync of users
    helper.startSynchronization(userSyncConfig);
    helper.checkSyncLog(userSyncConfig, SynchronizationActionType.CREATE_ENTITY, 3, OperationResultType.SUCCESS);
    IdmIdentityDto identityOne = identityService.getByUsername(usernameOne);
    Assert.assertNotNull(identityOne);
    IdmIdentityDto identityTwo = identityService.getByUsername(usernameTwo);
    Assert.assertNotNull(identityTwo);
    IdmIdentityDto identityThree = identityService.getByUsername(usernameThree);
    Assert.assertNotNull(identityThree);
    // Start sync of roles
    helper.startSynchronization(syncConfigCustom);
    // 
    SysSyncLogFilter logFilter = new SysSyncLogFilter();
    logFilter.setSynchronizationConfigId(syncConfigCustom.getId());
    List<SysSyncLogDto> logs = syncLogService.find(logFilter, null).getContent();
    Assert.assertEquals(1, logs.size());
    SysSyncLogDto log = logs.get(0);
    Assert.assertFalse(log.isRunning());
    Assert.assertFalse(log.isContainsError());
    helper.checkSyncLog(syncConfigCustom, SynchronizationActionType.CREATE_ENTITY, 5, OperationResultType.SUCCESS);
    AccRoleAccountFilter roleAccountFilter = new AccRoleAccountFilter();
    roleAccountFilter.setSystemId(roleSystemId);
    List<AccRoleAccountDto> roleAccountDtos = roleAccountService.find(roleAccountFilter, null).getContent();
    Assert.assertEquals(5, roleAccountDtos.size());
    // Every role should be assigned to userOne and userTwo.
    roleAccountDtos.forEach(roleAccountDto -> {
        IdmIdentityRoleFilter identityRoleFilter = new IdmIdentityRoleFilter();
        identityRoleFilter.setRoleId(roleAccountDto.getRole());
        identityRoleFilter.setIdentityId(identityOne.getId());
        Assert.assertEquals(1, identityRoleService.find(identityRoleFilter, null).getContent().size());
        identityRoleFilter.setIdentityId(identityTwo.getId());
        Assert.assertEquals(1, identityRoleService.find(identityRoleFilter, null).getContent().size());
        identityRoleFilter.setIdentityId(identityThree.getId());
        Assert.assertEquals(0, identityRoleService.find(identityRoleFilter, null).getContent().size());
        // Assign role to identityThree.
        IdmIdentityContractDto primeContract = getHelper().getPrimeContract(identityThree);
        getHelper().assignRoles(primeContract, roleService.get(roleAccountDto.getRole()));
    });
    // Start sync of roles again. Identity three has redundantly assigned roles, but sync has not activated removing now.
    helper.startSynchronization(syncConfigCustom);
    helper.checkSyncLog(syncConfigCustom, SynchronizationActionType.UPDATE_ENTITY, 5, OperationResultType.SUCCESS);
    roleAccountDtos = roleAccountService.find(roleAccountFilter, null).getContent();
    Assert.assertEquals(5, roleAccountDtos.size());
    // Every role should be assigned to userOne and userTwo.
    roleAccountDtos.forEach(roleAccountDto -> {
        IdmIdentityRoleFilter identityRoleFilter = new IdmIdentityRoleFilter();
        identityRoleFilter.setRoleId(roleAccountDto.getRole());
        identityRoleFilter.setIdentityId(identityOne.getId());
        Assert.assertEquals(1, identityRoleService.find(identityRoleFilter, null).getContent().size());
        identityRoleFilter.setIdentityId(identityTwo.getId());
        Assert.assertEquals(1, identityRoleService.find(identityRoleFilter, null).getContent().size());
        // Identity three has redundantly assigned roles, but sync has not activated removing now.
        identityRoleFilter.setIdentityId(identityThree.getId());
        Assert.assertEquals(1, identityRoleService.find(identityRoleFilter, null).getContent().size());
    });
    // Start sync of roles again. Identity three has redundantly assigned roles and sync has activated removing. Role should be removed.
    roleConfigDto.setAssignRoleRemoveSwitch(true);
    roleConfigDto = (SysSyncRoleConfigDto) syncConfigService.save(roleConfigDto);
    helper.startSynchronization(roleConfigDto);
    helper.checkSyncLog(roleConfigDto, SynchronizationActionType.UPDATE_ENTITY, 5, OperationResultType.SUCCESS);
    roleAccountDtos = roleAccountService.find(roleAccountFilter, null).getContent();
    Assert.assertEquals(5, roleAccountDtos.size());
    // Every role should be assigned to userOne and userTwo.
    roleAccountDtos.forEach(roleAccountDto -> {
        IdmIdentityRoleFilter identityRoleFilter = new IdmIdentityRoleFilter();
        identityRoleFilter.setRoleId(roleAccountDto.getRole());
        identityRoleFilter.setIdentityId(identityOne.getId());
        Assert.assertEquals(1, identityRoleService.find(identityRoleFilter, null).getContent().size());
        identityRoleFilter.setIdentityId(identityTwo.getId());
        Assert.assertEquals(1, identityRoleService.find(identityRoleFilter, null).getContent().size());
        // Identity three has redundantly assigned roles and sync has activated removing. Role should be removed.
        identityRoleFilter.setIdentityId(identityThree.getId());
        Assert.assertEquals(0, identityRoleService.find(identityRoleFilter, null).getContent().size());
    });
    // Clean after test.
    cleanAfterTest(syncConfigCustom, roleSystemId, log, roleAccountDtos);
}

Example 79 with SysSyncLogDto

use of eu.bcvsolutions.idm.acc.dto.SysSyncLogDto in project CzechIdMng by bcvsolutions.

the class DefaultRoleSynchronizationExecutorTest method testSyncDeleteRolesMembership.

@Test
public void testSyncDeleteRolesMembership() {
    AbstractSysSyncConfigDto syncConfigCustom = createSyncConfig();
    SysSystemDto userSystem = helper.createTestResourceSystem(true);
    List<SysSystemMappingDto> userSystemMappings = systemMappingService.findBySystem(userSystem, SystemOperationType.PROVISIONING, SystemEntityType.IDENTITY);
    Assert.assertNotNull(userSystemMappings);
    Assert.assertEquals(1, userSystemMappings.size());
    SysSystemMappingDto userMappingDto = userSystemMappings.get(0);
    // Switch to the sync.
    userMappingDto.setOperationType(SystemOperationType.SYNCHRONIZATION);
    userMappingDto = systemMappingService.save(userMappingDto);
    List<SysSystemAttributeMappingDto> attributeMappingDtos = schemaAttributeMappingService.findBySystemMapping(userMappingDto);
    SysSystemAttributeMappingDto userEmailAttribute = attributeMappingDtos.stream().filter(attribute -> attribute.getName().equalsIgnoreCase(TestHelper.ATTRIBUTE_MAPPING_EMAIL)).findFirst().orElse(null);
    Assert.assertNotNull(userEmailAttribute);
    Assert.assertFalse(syncConfigService.isRunning(syncConfigCustom));
    Assert.assertTrue(syncConfigCustom instanceof SysSyncRoleConfigDto);
    SysSyncRoleConfigDto roleConfigDto = (SysSyncRoleConfigDto) syncConfigCustom;
    SysSystemMappingDto systemMappingDto = DtoUtils.getEmbedded(syncConfigCustom, SysSyncConfig_.systemMapping, SysSystemMappingDto.class);
    SysSchemaObjectClassDto schemaObjectClassDto = DtoUtils.getEmbedded(systemMappingDto, SysSystemMapping_.objectClass, SysSchemaObjectClassDto.class);
    UUID roleSystemId = schemaObjectClassDto.getSystem();
    Assert.assertNotNull(roleSystemId);
    SysSchemaAttributeFilter schemaAttributeFilter = new SysSchemaAttributeFilter();
    schemaAttributeFilter.setSystemId(roleSystemId);
    schemaAttributeFilter.setObjectClassId(schemaObjectClassDto.getId());
    SysSchemaAttributeDto schemaAttributeDto = schemaAttributeService.find(schemaAttributeFilter, null).getContent().stream().filter(attribute -> attribute.getName().equalsIgnoreCase("name")).findFirst().orElse(null);
    Assert.assertNotNull(schemaAttributeDto);
    SysSystemDto roleSystemDto = new SysSystemDto();
    roleSystemDto.setId(roleSystemId);
    List<SysSystemMappingDto> roleSystemMappings = systemMappingService.findBySystem(roleSystemDto, SystemOperationType.SYNCHRONIZATION, SystemEntityType.ROLE);
    Assert.assertNotNull(roleSystemMappings);
    Assert.assertEquals(1, roleSystemMappings.size());
    SysSystemMappingDto roleMappingDto = roleSystemMappings.get(0);
    // Create mapping attribute for get ID of role.
    SysSystemAttributeMappingDto roleIdAttribute = new SysSystemAttributeMappingDto();
    roleIdAttribute.setEntityAttribute(true);
    roleIdAttribute.setUid(false);
    roleIdAttribute.setSystemMapping(roleMappingDto.getId());
    roleIdAttribute.setExtendedAttribute(false);
    roleIdAttribute.setIdmPropertyName(RoleSynchronizationExecutor.ROLE_MEMBERSHIP_ID_FIELD);
    roleIdAttribute.setSchemaAttribute(schemaAttributeDto.getId());
    roleIdAttribute.setName(helper.createName());
    roleIdAttribute = attributeMappingService.save(roleIdAttribute);
    // Enable membership and use the user system.
    roleConfigDto.setMembershipSwitch(true);
    roleConfigDto.setMemberSystemMapping(userMappingDto.getId());
    roleConfigDto.setMemberOfAttribute(userEmailAttribute.getId());
    syncConfigCustom = syncConfigService.save(roleConfigDto);
    // 
    helper.startSynchronization(syncConfigCustom);
    // 
    SysSyncLogFilter logFilter = new SysSyncLogFilter();
    logFilter.setSynchronizationConfigId(syncConfigCustom.getId());
    List<SysSyncLogDto> logs = syncLogService.find(logFilter, null).getContent();
    Assert.assertEquals(1, logs.size());
    SysSyncLogDto log = logs.get(0);
    Assert.assertFalse(log.isRunning());
    Assert.assertFalse(log.isContainsError());
    helper.checkSyncLog(syncConfigCustom, SynchronizationActionType.CREATE_ENTITY, 5, OperationResultType.SUCCESS);
    AccRoleAccountFilter roleAccountFilter = new AccRoleAccountFilter();
    roleAccountFilter.setSystemId(roleSystemId);
    List<AccRoleAccountDto> roleAccountDtos = roleAccountService.find(roleAccountFilter, null).getContent();
    Assert.assertEquals(5, roleAccountDtos.size());
    // Delete a log.
    syncLogService.delete(log);
    // Transformation will return the null -> memberships should be deleted.
    roleIdAttribute.setTransformFromResourceScript("return null;");
    attributeMappingService.save(roleIdAttribute);
    // Start sync again - for update.
    helper.startSynchronization(syncConfigCustom);
    // 
    logFilter = new SysSyncLogFilter();
    logFilter.setSynchronizationConfigId(syncConfigCustom.getId());
    logs = syncLogService.find(logFilter, null).getContent();
    Assert.assertEquals(1, logs.size());
    log = logs.get(0);
    Assert.assertFalse(log.isRunning());
    Assert.assertFalse(log.isContainsError());
    helper.checkSyncLog(syncConfigCustom, SynchronizationActionType.UPDATE_ENTITY, 5, OperationResultType.SUCCESS);
    roleAccountFilter = new AccRoleAccountFilter();
    roleAccountFilter.setSystemId(roleSystemId);
    roleAccountDtos = roleAccountService.find(roleAccountFilter, null).getContent();
    Assert.assertEquals(5, roleAccountDtos.size());
    roleAccountDtos.forEach(roleAccountDto -> {
        SysRoleSystemFilter roleSystemFilter = new SysRoleSystemFilter();
        roleSystemFilter.setRoleId(roleAccountDto.getRole());
        List<SysRoleSystemDto> roleSystemDtos = roleSystemService.find(roleSystemFilter, null).getContent();
        Assert.assertEquals(0, roleSystemDtos.size());
    });
    cleanAfterTest(syncConfigCustom, roleSystemId, log, roleAccountDtos);
}

Example 80 with SysSyncLogDto

use of eu.bcvsolutions.idm.acc.dto.SysSyncLogDto in project CzechIdMng by bcvsolutions.

the class DefaultRoleSynchronizationServiceTest method doStartSyncB_Linked_doEntityUpdate.

@Test
public void doStartSyncB_Linked_doEntityUpdate() {
    SysSyncConfigFilter configFilter = new SysSyncConfigFilter();
    configFilter.setName(SYNC_CONFIG_NAME);
    List<AbstractSysSyncConfigDto> syncConfigs = syncConfigService.find(configFilter, null).getContent();
    // Change node code to changed
    this.getBean().changeOne();
    Assert.assertEquals(1, syncConfigs.size());
    AbstractSysSyncConfigDto syncConfigCustom = syncConfigs.get(0);
    Assert.assertFalse(syncConfigService.isRunning(syncConfigCustom));
    // Set sync config
    syncConfigCustom.setLinkedAction(SynchronizationLinkedActionType.UPDATE_ENTITY);
    syncConfigCustom.setUnlinkedAction(SynchronizationUnlinkedActionType.IGNORE);
    syncConfigCustom.setMissingEntityAction(SynchronizationMissingEntityActionType.IGNORE);
    syncConfigCustom.setMissingAccountAction(ReconciliationMissingAccountActionType.IGNORE);
    syncConfigService.save(syncConfigCustom);
    // Check state before sync
    IdmRoleFilter roleFilter = new IdmRoleFilter();
    roleFilter.setProperty(IdmRole_.code.getName());
    roleFilter.setValue("1");
    Assert.assertEquals("1", roleService.find(roleFilter, null).getContent().get(0).getDescription());
    helper.startSynchronization(syncConfigCustom);
    // 
    SysSyncLogFilter logFilter = new SysSyncLogFilter();
    logFilter.setSynchronizationConfigId(syncConfigCustom.getId());
    List<SysSyncLogDto> logs = syncLogService.find(logFilter, null).getContent();
    Assert.assertEquals(1, logs.size());
    SysSyncLogDto log = logs.get(0);
    Assert.assertFalse(log.isRunning());
    Assert.assertFalse(log.isContainsError());
    SysSyncActionLogFilter actionLogFilter = new SysSyncActionLogFilter();
    actionLogFilter.setSynchronizationLogId(log.getId());
    List<SysSyncActionLogDto> actions = syncActionLogService.find(actionLogFilter, null).getContent();
    Assert.assertEquals(1, actions.size());
    SysSyncActionLogDto actionLog = actions.stream().filter(action -> {
        return SynchronizationActionType.UPDATE_ENTITY == action.getSyncAction();
    }).findFirst().get();
    SysSyncItemLogFilter itemLogFilter = new SysSyncItemLogFilter();
    itemLogFilter.setSyncActionLogId(actionLog.getId());
    List<SysSyncItemLogDto> items = syncItemLogService.find(itemLogFilter, null).getContent();
    Assert.assertEquals(5, items.size());
    // Check state after sync
    Assert.assertEquals(CHANGED, roleService.find(roleFilter, null).getContent().get(0).getDescription());
    // Delete log
    syncLogService.delete(log);
}