method2testcases
stringlengths 118
6.63k
|
|---|
### Question:
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public void deleteJob(UUID jobId) throws AlertDatabaseConstraintException { if (jobId == null) { throw new AlertDatabaseConstraintException(NULL_JOB_ID); } List<Long> configIdsForJob = configGroupRepository .findByJobId(jobId) .stream() .map(ConfigGroupEntity::getConfigId) .collect(Collectors.toList()); for (Long configId : configIdsForJob) { deleteConfiguration(configId); } } @Autowired DefaultConfigurationAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DescriptorTypeRepository descriptorTypeRepository, DefinedFieldRepository definedFieldRepository,
DescriptorConfigRepository descriptorConfigsRepository, ConfigGroupRepository configGroupRepository, ConfigContextRepository configContextRepository, FieldValueRepository fieldValueRepository,
EncryptionUtility encryptionUtility); @Override List<ConfigurationJobModel> getAllJobs(); @Override Optional<ConfigurationJobModel> getJobById(UUID jobId); @Override List<ConfigurationJobModel> getJobsByFrequency(FrequencyType frequency); @Override ConfigurationJobModel createJob(Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override ConfigurationJobModel updateJob(UUID jobId, Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteJob(UUID jobId); @Override Optional<ConfigurationModel> getProviderConfigurationByName(String providerConfigName); @Override Optional<ConfigurationModel> getConfigurationById(Long id); @Override List<ConfigurationModel> getConfigurationsByDescriptorKey(DescriptorKey descriptorKey); @Override List<ConfigurationModel> getConfigurationsByDescriptorType(DescriptorType descriptorType); @Override List<ConfigurationModel> getChannelConfigurationsByFrequency(FrequencyType frequencyType); @Override List<ConfigurationModel> getConfigurationsByDescriptorKeyAndContext(DescriptorKey descriptorKey, ConfigContextEnum context); @Override ConfigurationModel createConfiguration(DescriptorKey descriptorKey, ConfigContextEnum context, Collection<ConfigurationFieldModel> configuredFields); @Override List<ConfigurationModel> getConfigurationsByDescriptorNameAndContext(String descriptorName, ConfigContextEnum context); @Override ConfigurationModel updateConfiguration(Long descriptorConfigId, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteConfiguration(ConfigurationModel configModel); @Override void deleteConfiguration(Long descriptorConfigId); static final String EXCEPTION_FORMAT_DESCRIPTOR_KEY_IS_NOT_VALID; }### Answer:
@Test public void deleteJobNullIdTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.deleteJob(null); fail("Null jobId did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } } |
### Question:
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public Optional<ConfigurationModel> getConfigurationById(Long id) throws AlertDatabaseConstraintException { if (id == null) { throw new AlertDatabaseConstraintException(NULL_CONFIG_ID); } Optional<DescriptorConfigEntity> optionalDescriptorConfigEntity = descriptorConfigsRepository.findById(id); if (optionalDescriptorConfigEntity.isPresent()) { DescriptorConfigEntity descriptorConfigEntity = optionalDescriptorConfigEntity.get(); return Optional .of(createConfigModel(descriptorConfigEntity.getDescriptorId(), descriptorConfigEntity.getId(), descriptorConfigEntity.getCreatedAt(), descriptorConfigEntity.getLastUpdated(), descriptorConfigEntity.getContextId())); } return Optional.empty(); } @Autowired DefaultConfigurationAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DescriptorTypeRepository descriptorTypeRepository, DefinedFieldRepository definedFieldRepository,
DescriptorConfigRepository descriptorConfigsRepository, ConfigGroupRepository configGroupRepository, ConfigContextRepository configContextRepository, FieldValueRepository fieldValueRepository,
EncryptionUtility encryptionUtility); @Override List<ConfigurationJobModel> getAllJobs(); @Override Optional<ConfigurationJobModel> getJobById(UUID jobId); @Override List<ConfigurationJobModel> getJobsByFrequency(FrequencyType frequency); @Override ConfigurationJobModel createJob(Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override ConfigurationJobModel updateJob(UUID jobId, Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteJob(UUID jobId); @Override Optional<ConfigurationModel> getProviderConfigurationByName(String providerConfigName); @Override Optional<ConfigurationModel> getConfigurationById(Long id); @Override List<ConfigurationModel> getConfigurationsByDescriptorKey(DescriptorKey descriptorKey); @Override List<ConfigurationModel> getConfigurationsByDescriptorType(DescriptorType descriptorType); @Override List<ConfigurationModel> getChannelConfigurationsByFrequency(FrequencyType frequencyType); @Override List<ConfigurationModel> getConfigurationsByDescriptorKeyAndContext(DescriptorKey descriptorKey, ConfigContextEnum context); @Override ConfigurationModel createConfiguration(DescriptorKey descriptorKey, ConfigContextEnum context, Collection<ConfigurationFieldModel> configuredFields); @Override List<ConfigurationModel> getConfigurationsByDescriptorNameAndContext(String descriptorName, ConfigContextEnum context); @Override ConfigurationModel updateConfiguration(Long descriptorConfigId, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteConfiguration(ConfigurationModel configModel); @Override void deleteConfiguration(Long descriptorConfigId); static final String EXCEPTION_FORMAT_DESCRIPTOR_KEY_IS_NOT_VALID; }### Answer:
@Test public void getConfigurationByIdEmptyTest() throws Exception { Mockito.when(descriptorConfigRepository.findById(Mockito.any())).thenReturn(Optional.empty()); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, descriptorConfigRepository, null, null, null, null); Optional<ConfigurationModel> configurationModelOptional = configurationAccessor.getConfigurationById(1L); assertFalse(configurationModelOptional.isPresent()); }
@Test public void getConfigurationByIdNullTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.getConfigurationById(null); fail("Null id did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } } |
### Question:
DefaultProviderDataAccessor implements ProviderDataAccessor { @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) public List<ProviderProject> getProjectsByProviderConfigId(Long providerConfigId) { return providerProjectRepository.findByProviderConfigId(providerConfigId) .stream() .map(this::convertToProjectModel) .collect(Collectors.toList()); } @Autowired DefaultProviderDataAccessor(ProviderProjectRepository providerProjectRepository, ProviderUserProjectRelationRepository providerUserProjectRelationRepository, ProviderUserRepository providerUserRepository,
ConfigurationAccessor configurationAccessor); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderProject> getProjectsByProviderConfigName(String providerConfigName); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderProject> getProjectsByProviderConfigId(Long providerConfigId); @Override void deleteProjects(Collection<ProviderProject> providerProjects); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Set<String> getEmailAddressesForProjectHref(String projectHref); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderUserModel> getUsersByProviderConfigId(Long providerConfigId); @Override List<ProviderUserModel> getUsersByProviderConfigName(String providerConfigName); @Override void updateProjectAndUserData(Long providerConfigId, Map<ProviderProject, Set<String>> projectToUserData, Set<String> additionalRelevantUsers); static final int MAX_DESCRIPTION_LENGTH; static final int MAX_PROJECT_NAME_LENGTH; }### Answer:
@Test public void getProjectsByProviderConfigIdTest() { ProviderProjectEntity providerProjectEntity = new ProviderProjectEntity(name, description, href, projectOwnerEmail, 1L); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ProviderProjectRepository providerProjectRepository = Mockito.mock(ProviderProjectRepository.class); Mockito.when(providerProjectRepository.findByProviderConfigId(Mockito.any())).thenReturn(List.of(providerProjectEntity)); DefaultProviderDataAccessor providerDataAccessor = new DefaultProviderDataAccessor(providerProjectRepository, null, null, configurationAccessor); List<ProviderProject> providerProjectList = providerDataAccessor.getProjectsByProviderConfigId(1L); assertEquals(1, providerProjectList.size()); ProviderProject providerProject = providerProjectList.get(0); testProviderProject(expectedProviderProject, providerProject); } |
### Question:
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public List<ConfigurationModel> getConfigurationsByDescriptorNameAndContext(String descriptorName, ConfigContextEnum context) throws AlertDatabaseConstraintException { if (StringUtils.isBlank(descriptorName)) { throw new AlertDatabaseConstraintException("Descriptor name cannot be null"); } if (null == context) { throw new AlertDatabaseConstraintException("Context cannot be null"); } Long contextId = getConfigContextIdOrThrowException(context); Long descriptorId = getDescriptorIdOrThrowException(descriptorName); List<DescriptorConfigEntity> descriptorConfigEntities = descriptorConfigsRepository.findByDescriptorIdAndContextId(descriptorId, contextId); List<ConfigurationModel> configurationModels = new ArrayList<>(); for (DescriptorConfigEntity descriptorConfigEntity : descriptorConfigEntities) { configurationModels.add(createConfigModel(descriptorConfigEntity.getDescriptorId(), descriptorConfigEntity.getId(), descriptorConfigEntity.getCreatedAt(), descriptorConfigEntity.getLastUpdated(), contextId)); } return configurationModels; } @Autowired DefaultConfigurationAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DescriptorTypeRepository descriptorTypeRepository, DefinedFieldRepository definedFieldRepository,
DescriptorConfigRepository descriptorConfigsRepository, ConfigGroupRepository configGroupRepository, ConfigContextRepository configContextRepository, FieldValueRepository fieldValueRepository,
EncryptionUtility encryptionUtility); @Override List<ConfigurationJobModel> getAllJobs(); @Override Optional<ConfigurationJobModel> getJobById(UUID jobId); @Override List<ConfigurationJobModel> getJobsByFrequency(FrequencyType frequency); @Override ConfigurationJobModel createJob(Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override ConfigurationJobModel updateJob(UUID jobId, Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteJob(UUID jobId); @Override Optional<ConfigurationModel> getProviderConfigurationByName(String providerConfigName); @Override Optional<ConfigurationModel> getConfigurationById(Long id); @Override List<ConfigurationModel> getConfigurationsByDescriptorKey(DescriptorKey descriptorKey); @Override List<ConfigurationModel> getConfigurationsByDescriptorType(DescriptorType descriptorType); @Override List<ConfigurationModel> getChannelConfigurationsByFrequency(FrequencyType frequencyType); @Override List<ConfigurationModel> getConfigurationsByDescriptorKeyAndContext(DescriptorKey descriptorKey, ConfigContextEnum context); @Override ConfigurationModel createConfiguration(DescriptorKey descriptorKey, ConfigContextEnum context, Collection<ConfigurationFieldModel> configuredFields); @Override List<ConfigurationModel> getConfigurationsByDescriptorNameAndContext(String descriptorName, ConfigContextEnum context); @Override ConfigurationModel updateConfiguration(Long descriptorConfigId, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteConfiguration(ConfigurationModel configModel); @Override void deleteConfiguration(Long descriptorConfigId); static final String EXCEPTION_FORMAT_DESCRIPTOR_KEY_IS_NOT_VALID; }### Answer:
@Test public void getConfigurationByDescriptorNameAndContextNullTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.getConfigurationsByDescriptorNameAndContext(null, configContextEnum); fail("Null descriptorName did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } try { configurationAccessor.getConfigurationsByDescriptorNameAndContext("descriptorName", null); fail("Null context did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } } |
### Question:
DefaultProviderDataAccessor implements ProviderDataAccessor { @Override public void deleteProjects(Collection<ProviderProject> providerProjects) { providerProjects.forEach(project -> providerProjectRepository.deleteByHref(project.getHref())); } @Autowired DefaultProviderDataAccessor(ProviderProjectRepository providerProjectRepository, ProviderUserProjectRelationRepository providerUserProjectRelationRepository, ProviderUserRepository providerUserRepository,
ConfigurationAccessor configurationAccessor); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderProject> getProjectsByProviderConfigName(String providerConfigName); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderProject> getProjectsByProviderConfigId(Long providerConfigId); @Override void deleteProjects(Collection<ProviderProject> providerProjects); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Set<String> getEmailAddressesForProjectHref(String projectHref); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderUserModel> getUsersByProviderConfigId(Long providerConfigId); @Override List<ProviderUserModel> getUsersByProviderConfigName(String providerConfigName); @Override void updateProjectAndUserData(Long providerConfigId, Map<ProviderProject, Set<String>> projectToUserData, Set<String> additionalRelevantUsers); static final int MAX_DESCRIPTION_LENGTH; static final int MAX_PROJECT_NAME_LENGTH; }### Answer:
@Test public void deleteProjectsTest() { ProviderProject providerProject = new ProviderProject(name, description, href, projectOwnerEmail); ProviderProjectRepository providerProjectRepository = Mockito.mock(ProviderProjectRepository.class); DefaultProviderDataAccessor providerDataAccessor = new DefaultProviderDataAccessor(providerProjectRepository, null, null, null); providerDataAccessor.deleteProjects(List.of(providerProject)); Mockito.verify(providerProjectRepository).deleteByHref(Mockito.any()); } |
### Question:
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public void deleteConfiguration(ConfigurationModel configModel) throws AlertDatabaseConstraintException { if (configModel == null) { throw new AlertDatabaseConstraintException("Cannot delete a null object from the database"); } deleteConfiguration(configModel.getConfigurationId()); } @Autowired DefaultConfigurationAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DescriptorTypeRepository descriptorTypeRepository, DefinedFieldRepository definedFieldRepository,
DescriptorConfigRepository descriptorConfigsRepository, ConfigGroupRepository configGroupRepository, ConfigContextRepository configContextRepository, FieldValueRepository fieldValueRepository,
EncryptionUtility encryptionUtility); @Override List<ConfigurationJobModel> getAllJobs(); @Override Optional<ConfigurationJobModel> getJobById(UUID jobId); @Override List<ConfigurationJobModel> getJobsByFrequency(FrequencyType frequency); @Override ConfigurationJobModel createJob(Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override ConfigurationJobModel updateJob(UUID jobId, Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteJob(UUID jobId); @Override Optional<ConfigurationModel> getProviderConfigurationByName(String providerConfigName); @Override Optional<ConfigurationModel> getConfigurationById(Long id); @Override List<ConfigurationModel> getConfigurationsByDescriptorKey(DescriptorKey descriptorKey); @Override List<ConfigurationModel> getConfigurationsByDescriptorType(DescriptorType descriptorType); @Override List<ConfigurationModel> getChannelConfigurationsByFrequency(FrequencyType frequencyType); @Override List<ConfigurationModel> getConfigurationsByDescriptorKeyAndContext(DescriptorKey descriptorKey, ConfigContextEnum context); @Override ConfigurationModel createConfiguration(DescriptorKey descriptorKey, ConfigContextEnum context, Collection<ConfigurationFieldModel> configuredFields); @Override List<ConfigurationModel> getConfigurationsByDescriptorNameAndContext(String descriptorName, ConfigContextEnum context); @Override ConfigurationModel updateConfiguration(Long descriptorConfigId, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteConfiguration(ConfigurationModel configModel); @Override void deleteConfiguration(Long descriptorConfigId); static final String EXCEPTION_FORMAT_DESCRIPTOR_KEY_IS_NOT_VALID; }### Answer:
@Test public void deleteConfigurationTest() throws Exception { ConfigurationModel configurationModel = new ConfigurationModel(1L, 2L, "dateCreated", "lastUpdated", configContextEnum); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, descriptorConfigRepository, null, null, null, null); configurationAccessor.deleteConfiguration(configurationModel); Mockito.verify(descriptorConfigRepository).deleteById(Mockito.any()); }
@Test public void deleteConfigurationNullConfigModelTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { ConfigurationModel configurationModel = null; configurationAccessor.deleteConfiguration(configurationModel); fail("Null configurationModel did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
@Test public void deleteConfigurationNullDescriptorConfigIdTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { Long descriptorConfigId = null; configurationAccessor.deleteConfiguration(descriptorConfigId); fail("Null descriptorConfigId did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } } |
### Question:
DefaultConfigurationAccessor implements ConfigurationAccessor { private String decrypt(String value, boolean shouldDecrypt) { if (shouldDecrypt && value != null) { return encryptionUtility.decrypt(value); } return value; } @Autowired DefaultConfigurationAccessor(RegisteredDescriptorRepository registeredDescriptorRepository, DescriptorTypeRepository descriptorTypeRepository, DefinedFieldRepository definedFieldRepository,
DescriptorConfigRepository descriptorConfigsRepository, ConfigGroupRepository configGroupRepository, ConfigContextRepository configContextRepository, FieldValueRepository fieldValueRepository,
EncryptionUtility encryptionUtility); @Override List<ConfigurationJobModel> getAllJobs(); @Override Optional<ConfigurationJobModel> getJobById(UUID jobId); @Override List<ConfigurationJobModel> getJobsByFrequency(FrequencyType frequency); @Override ConfigurationJobModel createJob(Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override ConfigurationJobModel updateJob(UUID jobId, Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteJob(UUID jobId); @Override Optional<ConfigurationModel> getProviderConfigurationByName(String providerConfigName); @Override Optional<ConfigurationModel> getConfigurationById(Long id); @Override List<ConfigurationModel> getConfigurationsByDescriptorKey(DescriptorKey descriptorKey); @Override List<ConfigurationModel> getConfigurationsByDescriptorType(DescriptorType descriptorType); @Override List<ConfigurationModel> getChannelConfigurationsByFrequency(FrequencyType frequencyType); @Override List<ConfigurationModel> getConfigurationsByDescriptorKeyAndContext(DescriptorKey descriptorKey, ConfigContextEnum context); @Override ConfigurationModel createConfiguration(DescriptorKey descriptorKey, ConfigContextEnum context, Collection<ConfigurationFieldModel> configuredFields); @Override List<ConfigurationModel> getConfigurationsByDescriptorNameAndContext(String descriptorName, ConfigContextEnum context); @Override ConfigurationModel updateConfiguration(Long descriptorConfigId, Collection<ConfigurationFieldModel> configuredFields); @Override void deleteConfiguration(ConfigurationModel configModel); @Override void deleteConfiguration(Long descriptorConfigId); static final String EXCEPTION_FORMAT_DESCRIPTOR_KEY_IS_NOT_VALID; }### Answer:
@Test public void decryptTest() throws Exception { final String decryptedString = "decryptedString"; final String providerConfigName = "provider-config-name-test"; final String emptyProviderConfigName = "bad-config-name"; final Long fieldId = 1L; final Long descriptorId = 4L; final Long configurationId = 6L; DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, true); definedFieldEntity.setId(fieldId); FieldValueEntity fieldValueEntity = new FieldValueEntity(2L, 3L, fieldValue); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(descriptorId, 5L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(configurationId); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); EncryptionUtility encryptionUtilityDecrypt = Mockito.mock(EncryptionUtility.class); Mockito.when(definedFieldRepository.findFirstByKey(Mockito.any())).thenReturn(Optional.of(definedFieldEntity)); Mockito.when(fieldValueRepository.findAllByFieldIdAndValue(fieldId, providerConfigName)).thenReturn(List.of(fieldValueEntity)); Mockito.when(fieldValueRepository.findAllByFieldIdAndValue(fieldId, emptyProviderConfigName)).thenReturn(List.of()); setupGetJobMocks(descriptorConfigEntity, configContextEntity, fieldValueEntity, definedFieldEntity); Mockito.when(encryptionUtilityDecrypt.decrypt(Mockito.any())).thenReturn(decryptedString); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, definedFieldRepository, descriptorConfigRepository, null, configContextRepository, fieldValueRepository, encryptionUtilityDecrypt); Optional<ConfigurationModel> configurationModelOptional = configurationAccessor.getProviderConfigurationByName(providerConfigName); assertTrue(configurationModelOptional.isPresent()); ConfigurationModel configurationModel = configurationModelOptional.get(); testConfigurationModel(configurationId, descriptorId, configurationModel); assertEquals(decryptedString, configurationModel.getField(fieldKey).get().getFieldValue().get()); } |
### Question:
DefaultAuditAccessor implements AuditAccessor { @Override public Optional<Long> findMatchingAuditId(Long notificationId, UUID commonDistributionId) { return auditEntryRepository.findMatchingAudit(notificationId, commonDistributionId).map(AuditEntryEntity::getId); } @Autowired DefaultAuditAccessor(AuditEntryRepository auditEntryRepository, AuditNotificationRepository auditNotificationRepository, ConfigurationAccessor configurationAccessor,
DefaultNotificationAccessor notificationAccessor, ContentConverter contentConverter); @Override Optional<Long> findMatchingAuditId(Long notificationId, UUID commonDistributionId); @Override @Transactional Optional<AuditJobStatusModel> findFirstByJobId(UUID jobId); @Override @Transactional AuditEntryPageModel getPageOfAuditEntries(Integer pageNumber, Integer pageSize, String searchTerm, String sortField, String sortOrder, boolean onlyShowSentNotifications,
Function<AlertNotificationModel, AuditEntryModel> notificationToAuditEntryConverter); @Override @Transactional Map<Long, Long> createAuditEntry(Map<Long, Long> existingNotificationIdToAuditId, UUID jobId, MessageContentGroup contentGroup); @Override @Transactional void setAuditEntrySuccess(Collection<Long> auditEntryIds); @Override @Transactional void setAuditEntryFailure(Collection<Long> auditEntryIds, String errorMessage, Throwable t); @Override @Transactional AuditEntryModel convertToAuditEntryModelFromNotification(AlertNotificationModel notificationContentEntry); }### Answer:
@Test public void findMatchingAuditIdTest() { AuditEntryRepository auditEntryRepository = Mockito.mock(AuditEntryRepository.class); Mockito.when(auditEntryRepository.findMatchingAudit(Mockito.anyLong(), Mockito.any(UUID.class))).thenReturn(Optional.empty()); DefaultAuditAccessor auditUtility = new DefaultAuditAccessor(auditEntryRepository, null, null, null, null); Optional<Long> nullValue = auditUtility.findMatchingAuditId(1L, UUID.randomUUID()); assertFalse(nullValue.isPresent()); AuditEntryEntity auditEntryEntity = new AuditEntryEntity(null, null, null, null, null, null); Long expectedLong = 2L; auditEntryEntity.setId(expectedLong); Mockito.when(auditEntryRepository.findMatchingAudit(Mockito.anyLong(), Mockito.any(UUID.class))).thenReturn(Optional.of(auditEntryEntity)); Optional<Long> actualValue = auditUtility.findMatchingAuditId(expectedLong, UUID.randomUUID()); assertTrue(actualValue.isPresent()); assertEquals(expectedLong, actualValue.get()); } |
### Question:
DefaultProviderDataAccessor implements ProviderDataAccessor { @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) public Set<String> getEmailAddressesForProjectHref(String projectHref) { Optional<Long> projectId = providerProjectRepository.findFirstByHref(projectHref).map(ProviderProjectEntity::getId); if (projectId.isPresent()) { Set<Long> userIds = providerUserProjectRelationRepository.findByProviderProjectId(projectId.get()) .stream() .map(ProviderUserProjectRelation::getProviderUserId) .collect(Collectors.toSet()); return providerUserRepository.findAllById(userIds) .stream() .map(ProviderUserEntity::getEmailAddress) .collect(Collectors.toSet()); } return Set.of(); } @Autowired DefaultProviderDataAccessor(ProviderProjectRepository providerProjectRepository, ProviderUserProjectRelationRepository providerUserProjectRelationRepository, ProviderUserRepository providerUserRepository,
ConfigurationAccessor configurationAccessor); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderProject> getProjectsByProviderConfigName(String providerConfigName); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderProject> getProjectsByProviderConfigId(Long providerConfigId); @Override void deleteProjects(Collection<ProviderProject> providerProjects); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Set<String> getEmailAddressesForProjectHref(String projectHref); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderUserModel> getUsersByProviderConfigId(Long providerConfigId); @Override List<ProviderUserModel> getUsersByProviderConfigName(String providerConfigName); @Override void updateProjectAndUserData(Long providerConfigId, Map<ProviderProject, Set<String>> projectToUserData, Set<String> additionalRelevantUsers); static final int MAX_DESCRIPTION_LENGTH; static final int MAX_PROJECT_NAME_LENGTH; }### Answer:
@Test public void getEmailAddressesForProjectHrefTest() throws Exception { ProviderProjectEntity providerProjectEntity = new ProviderProjectEntity(name, description, href, projectOwnerEmail, 1L); providerProjectEntity.setId(1L); ProviderUserProjectRelation providerUserProjectRelation = new ProviderUserProjectRelation(2L, 1L); ProviderUserEntity providerUserEntity = new ProviderUserEntity(projectOwnerEmail, true, 1L); ProviderProjectRepository providerProjectRepository = Mockito.mock(ProviderProjectRepository.class); ProviderUserProjectRelationRepository providerUserProjectRelationRepository = Mockito.mock(ProviderUserProjectRelationRepository.class); ProviderUserRepository providerUserRepository = Mockito.mock(ProviderUserRepository.class); Mockito.when(providerProjectRepository.findFirstByHref(Mockito.any())).thenReturn(Optional.of(providerProjectEntity)); Mockito.when(providerUserProjectRelationRepository.findByProviderProjectId(Mockito.any())).thenReturn(List.of(providerUserProjectRelation)); Mockito.when(providerUserRepository.findAllById(Mockito.any())).thenReturn(List.of(providerUserEntity)); DefaultProviderDataAccessor providerDataAccessor = new DefaultProviderDataAccessor(providerProjectRepository, providerUserProjectRelationRepository, providerUserRepository, null); Set<String> emailAddresses = providerDataAccessor.getEmailAddressesForProjectHref(href); assertEquals(1, emailAddresses.size()); assertTrue(emailAddresses.contains(projectOwnerEmail)); }
@Test public void getEmailAddressesForProjectHrefEmptyTest() { ProviderProjectRepository providerProjectRepository = Mockito.mock(ProviderProjectRepository.class); Mockito.when(providerProjectRepository.findFirstByHref(Mockito.any())).thenReturn(Optional.empty()); DefaultProviderDataAccessor providerDataAccessor = new DefaultProviderDataAccessor(providerProjectRepository, null, null, null); Set<String> emailAddresses = providerDataAccessor.getEmailAddressesForProjectHref("test-href"); assertTrue(emailAddresses.isEmpty()); } |
### Question:
DefaultAuditAccessor implements AuditAccessor { @Override @Transactional public void setAuditEntrySuccess(Collection<Long> auditEntryIds) { for (Long auditEntryId : auditEntryIds) { try { Optional<AuditEntryEntity> auditEntryEntityOptional = auditEntryRepository.findById(auditEntryId); if (auditEntryEntityOptional.isEmpty()) { logger.error("Could not find the audit entry {} to set the success status.", auditEntryId); } AuditEntryEntity auditEntryEntity = auditEntryEntityOptional.orElse(new AuditEntryEntity()); auditEntryEntity.setStatus(AuditEntryStatus.SUCCESS.toString()); auditEntryEntity.setErrorMessage(null); auditEntryEntity.setErrorStackTrace(null); auditEntryEntity.setTimeLastSent(DateUtils.createCurrentDateTimestamp()); auditEntryRepository.save(auditEntryEntity); } catch (Exception e) { logger.error(e.getMessage(), e); } } } @Autowired DefaultAuditAccessor(AuditEntryRepository auditEntryRepository, AuditNotificationRepository auditNotificationRepository, ConfigurationAccessor configurationAccessor,
DefaultNotificationAccessor notificationAccessor, ContentConverter contentConverter); @Override Optional<Long> findMatchingAuditId(Long notificationId, UUID commonDistributionId); @Override @Transactional Optional<AuditJobStatusModel> findFirstByJobId(UUID jobId); @Override @Transactional AuditEntryPageModel getPageOfAuditEntries(Integer pageNumber, Integer pageSize, String searchTerm, String sortField, String sortOrder, boolean onlyShowSentNotifications,
Function<AlertNotificationModel, AuditEntryModel> notificationToAuditEntryConverter); @Override @Transactional Map<Long, Long> createAuditEntry(Map<Long, Long> existingNotificationIdToAuditId, UUID jobId, MessageContentGroup contentGroup); @Override @Transactional void setAuditEntrySuccess(Collection<Long> auditEntryIds); @Override @Transactional void setAuditEntryFailure(Collection<Long> auditEntryIds, String errorMessage, Throwable t); @Override @Transactional AuditEntryModel convertToAuditEntryModelFromNotification(AlertNotificationModel notificationContentEntry); }### Answer:
@Test public void setAuditEntrySuccessCatchExceptionTest() { DefaultAuditAccessor auditUtility = new DefaultAuditAccessor(null, null, null, null, null); auditUtility.setAuditEntrySuccess(Collections.singletonList(1L)); }
@Test public void setAuditEntrySuccessTest() { AuditEntryRepository auditEntryRepository = Mockito.mock(AuditEntryRepository.class); DefaultAuditAccessor auditUtility = new DefaultAuditAccessor(auditEntryRepository, null, null, null, null); AuditEntryEntity entity = new AuditEntryEntity(UUID.randomUUID(), DateUtils.createCurrentDateTimestamp().minusSeconds(1), DateUtils.createCurrentDateTimestamp(), AuditEntryStatus.SUCCESS.toString(), null, null); entity.setId(1L); Mockito.when(auditEntryRepository.findById(Mockito.anyLong())).thenReturn(Optional.of(entity)); Mockito.when(auditEntryRepository.save(entity)).thenReturn(entity); auditUtility.setAuditEntrySuccess(Collections.emptyList()); auditUtility.setAuditEntrySuccess(Collections.singletonList(entity.getId())); assertEquals(AuditEntryStatus.SUCCESS.toString(), entity.getStatus()); } |
### Question:
DefaultAuditAccessor implements AuditAccessor { @Override @Transactional public void setAuditEntryFailure(Collection<Long> auditEntryIds, String errorMessage, Throwable t) { for (Long auditEntryId : auditEntryIds) { try { Optional<AuditEntryEntity> auditEntryEntityOptional = auditEntryRepository.findById(auditEntryId); if (auditEntryEntityOptional.isEmpty()) { logger.error("Could not find the audit entry {} to set the failure status. Error: {}", auditEntryId, errorMessage); } AuditEntryEntity auditEntryEntity = auditEntryEntityOptional.orElse(new AuditEntryEntity()); auditEntryEntity.setId(auditEntryId); auditEntryEntity.setStatus(AuditEntryStatus.FAILURE.toString()); auditEntryEntity.setErrorMessage(errorMessage); String[] rootCause = ExceptionUtils.getRootCauseStackTrace(t); String exceptionStackTrace = ""; for (String line : rootCause) { if (exceptionStackTrace.length() + line.length() < AuditEntryEntity.STACK_TRACE_CHAR_LIMIT) { exceptionStackTrace = String.format("%s%s%s", exceptionStackTrace, line, System.lineSeparator()); } else { break; } } auditEntryEntity.setErrorStackTrace(exceptionStackTrace); auditEntryEntity.setTimeLastSent(DateUtils.createCurrentDateTimestamp()); auditEntryRepository.save(auditEntryEntity); } catch (Exception e) { logger.error(e.getMessage(), e); } } } @Autowired DefaultAuditAccessor(AuditEntryRepository auditEntryRepository, AuditNotificationRepository auditNotificationRepository, ConfigurationAccessor configurationAccessor,
DefaultNotificationAccessor notificationAccessor, ContentConverter contentConverter); @Override Optional<Long> findMatchingAuditId(Long notificationId, UUID commonDistributionId); @Override @Transactional Optional<AuditJobStatusModel> findFirstByJobId(UUID jobId); @Override @Transactional AuditEntryPageModel getPageOfAuditEntries(Integer pageNumber, Integer pageSize, String searchTerm, String sortField, String sortOrder, boolean onlyShowSentNotifications,
Function<AlertNotificationModel, AuditEntryModel> notificationToAuditEntryConverter); @Override @Transactional Map<Long, Long> createAuditEntry(Map<Long, Long> existingNotificationIdToAuditId, UUID jobId, MessageContentGroup contentGroup); @Override @Transactional void setAuditEntrySuccess(Collection<Long> auditEntryIds); @Override @Transactional void setAuditEntryFailure(Collection<Long> auditEntryIds, String errorMessage, Throwable t); @Override @Transactional AuditEntryModel convertToAuditEntryModelFromNotification(AlertNotificationModel notificationContentEntry); }### Answer:
@Test public void setAuditEntryFailureCatchExceptionTest() { DefaultAuditAccessor auditUtility = new DefaultAuditAccessor(null, null, null, null, null); auditUtility.setAuditEntryFailure(Collections.singletonList(1L), null, null); }
@Test public void setAuditEntryFailureTest() { AuditEntryRepository auditEntryRepository = Mockito.mock(AuditEntryRepository.class); DefaultAuditAccessor auditUtility = new DefaultAuditAccessor(auditEntryRepository, null, null, null, null); AuditEntryEntity entity = new AuditEntryEntity(UUID.randomUUID(), DateUtils.createCurrentDateTimestamp().minusSeconds(1), DateUtils.createCurrentDateTimestamp(), AuditEntryStatus.FAILURE.toString(), null, null); entity.setId(1L); Mockito.when(auditEntryRepository.findById(Mockito.anyLong())).thenReturn(Optional.of(entity)); Mockito.when(auditEntryRepository.save(entity)).thenReturn(entity); auditUtility.setAuditEntryFailure(Collections.emptyList(), null, null); auditUtility.setAuditEntryFailure(Collections.singletonList(entity.getId()), "error", new Exception()); assertEquals(AuditEntryStatus.FAILURE.toString(), entity.getStatus()); assertEquals("error", entity.getErrorMessage()); } |
### Question:
DefaultNotificationAccessor implements NotificationAccessor { @Override public List<AlertNotificationModel> saveAllNotifications(Collection<AlertNotificationModel> notifications) { List<NotificationEntity> entitiesToSave = notifications .stream() .map(this::fromModel) .collect(Collectors.toList()); List<AlertNotificationModel> savedModels = notificationContentRepository.saveAll(entitiesToSave) .stream() .map(this::toModel) .collect(Collectors.toList()); notificationContentRepository.flush(); if (!savedModels.isEmpty()) { List<Long> notificationIds = savedModels.stream() .map(AlertNotificationModel::getId) .collect(Collectors.toList()); eventManager.sendEvent(new NotificationEvent(notificationIds)); } return savedModels; } @Autowired DefaultNotificationAccessor(NotificationContentRepository notificationContentRepository, AuditEntryRepository auditEntryRepository, AuditNotificationRepository auditNotificationRepository,
ConfigurationAccessor configurationAccessor, EventManager eventManager); @Override List<AlertNotificationModel> saveAllNotifications(Collection<AlertNotificationModel> notifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAll(PageRequest pageRequest, boolean onlyShowSentNotifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAllWithSearch(String searchTerm, PageRequest pageRequest, boolean onlyShowSentNotifications); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByIds(List<Long> notificationIds); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Optional<AlertNotificationModel> findById(Long notificationId); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBetween(OffsetDateTime startDate, OffsetDateTime endDate); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBefore(OffsetDateTime date); @Override List<AlertNotificationModel> findByCreatedAtBeforeDayOffset(int dayOffset); @Override void deleteNotificationList(List<AlertNotificationModel> notifications); @Override void deleteNotification(AlertNotificationModel notification); PageRequest getPageRequestForNotifications(Integer pageNumber, Integer pageSize, String sortField, String sortOrder); }### Answer:
@Test public void saveAllNotificationsTest() throws Exception { OffsetDateTime createdAt = DateUtils.createCurrentDateTimestamp(); OffsetDateTime providerCreationTime = createdAt.minusSeconds(10); AlertNotificationModel alertNotificationModel = new AlertNotificationModel(null, providerConfigId, provider, providerConfigName, notificationType, content, createdAt, providerCreationTime); NotificationEntity notificationEntity = new NotificationEntity(id, createdAt, provider, providerConfigId, providerCreationTime, notificationType, content); ConfigurationModel configurationModel = createConfigurationModel(); NotificationContentRepository notificationContentRepository = Mockito.mock(NotificationContentRepository.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); EventManager eventManager = Mockito.mock(EventManager.class); Mockito.when(notificationContentRepository.saveAll(Mockito.any())).thenReturn(List.of(notificationEntity)); Mockito.when(configurationAccessor.getConfigurationById(Mockito.any())).thenReturn(Optional.of(configurationModel)); DefaultNotificationAccessor notificationManager = new DefaultNotificationAccessor(notificationContentRepository, null, null, configurationAccessor, eventManager); List<AlertNotificationModel> alertNotificationModelList = notificationManager.saveAllNotifications(List.of(alertNotificationModel)); assertEquals(1, alertNotificationModelList.size()); AlertNotificationModel testAlertNotificationModel = alertNotificationModelList.get(0); testExpectedAlertNotificationModel(expectedAlertNotificationModel, testAlertNotificationModel); }
@Test public void saveAllNotificationsEmptyModelListTest() { NotificationContentRepository notificationContentRepository = Mockito.mock(NotificationContentRepository.class); Mockito.when(notificationContentRepository.saveAll(Mockito.any())).thenReturn(new ArrayList<>()); DefaultNotificationAccessor notificationManager = new DefaultNotificationAccessor(notificationContentRepository, null, null, null, null); List<AlertNotificationModel> alertNotificationModelList = notificationManager.saveAllNotifications(new ArrayList<>()); assertTrue(alertNotificationModelList.isEmpty()); } |
### Question:
DefaultNotificationAccessor implements NotificationAccessor { @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) public Page<AlertNotificationModel> findAllWithSearch(String searchTerm, PageRequest pageRequest, boolean onlyShowSentNotifications) { String lcSearchTerm = searchTerm.toLowerCase(Locale.ENGLISH); Page<NotificationEntity> matchingNotifications; if (onlyShowSentNotifications) { matchingNotifications = notificationContentRepository.findMatchingSentNotification(lcSearchTerm, pageRequest); } else { matchingNotifications = notificationContentRepository.findMatchingNotification(lcSearchTerm, pageRequest); } return matchingNotifications.map(this::toModel); } @Autowired DefaultNotificationAccessor(NotificationContentRepository notificationContentRepository, AuditEntryRepository auditEntryRepository, AuditNotificationRepository auditNotificationRepository,
ConfigurationAccessor configurationAccessor, EventManager eventManager); @Override List<AlertNotificationModel> saveAllNotifications(Collection<AlertNotificationModel> notifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAll(PageRequest pageRequest, boolean onlyShowSentNotifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAllWithSearch(String searchTerm, PageRequest pageRequest, boolean onlyShowSentNotifications); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByIds(List<Long> notificationIds); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Optional<AlertNotificationModel> findById(Long notificationId); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBetween(OffsetDateTime startDate, OffsetDateTime endDate); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBefore(OffsetDateTime date); @Override List<AlertNotificationModel> findByCreatedAtBeforeDayOffset(int dayOffset); @Override void deleteNotificationList(List<AlertNotificationModel> notifications); @Override void deleteNotification(AlertNotificationModel notification); PageRequest getPageRequestForNotifications(Integer pageNumber, Integer pageSize, String sortField, String sortOrder); }### Answer:
@Test public void findAllWithSearchTest() throws Exception { final String searchTerm = "searchTerm-test"; PageRequest pageRequest = PageRequest.of(0, 10); NotificationEntity notificationEntity = new NotificationEntity(id, DateUtils.createCurrentDateTimestamp(), provider, providerConfigId, DateUtils.createCurrentDateTimestamp(), notificationType, content); Page<NotificationEntity> notificationEntityPage = new PageImpl<>(List.of(notificationEntity)); ConfigurationModel configurationModel = createConfigurationModel(); NotificationContentRepository notificationContentRepository = Mockito.mock(NotificationContentRepository.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); Mockito.when(notificationContentRepository.findMatchingSentNotification(Mockito.any(), Mockito.any())).thenReturn(notificationEntityPage); Mockito.when(configurationAccessor.getConfigurationById(Mockito.any())).thenReturn(Optional.of(configurationModel)); Mockito.when(notificationContentRepository.findMatchingNotification(Mockito.any(), Mockito.any())).thenReturn(notificationEntityPage); DefaultNotificationAccessor notificationManager = new DefaultNotificationAccessor(notificationContentRepository, null, null, configurationAccessor, null); Page<AlertNotificationModel> alertNotificationModelPage = notificationManager.findAllWithSearch(searchTerm, pageRequest, Boolean.TRUE); Page<AlertNotificationModel> alertNotificationModelPageShowNotificationsFalse = notificationManager.findAllWithSearch(searchTerm, pageRequest, Boolean.FALSE); assertEquals(1, alertNotificationModelPage.getTotalPages()); AlertNotificationModel testAlertNotificationModel = alertNotificationModelPage.getContent().get(0); testExpectedAlertNotificationModel(expectedAlertNotificationModel, testAlertNotificationModel); assertEquals(1, alertNotificationModelPageShowNotificationsFalse.getTotalPages()); AlertNotificationModel testAlertNotificationModel2 = alertNotificationModelPageShowNotificationsFalse.getContent().get(0); testExpectedAlertNotificationModel(expectedAlertNotificationModel, testAlertNotificationModel2); } |
### Question:
DefaultNotificationAccessor implements NotificationAccessor { @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) public List<AlertNotificationModel> findByIds(List<Long> notificationIds) { return toModels(notificationContentRepository.findAllById(notificationIds)); } @Autowired DefaultNotificationAccessor(NotificationContentRepository notificationContentRepository, AuditEntryRepository auditEntryRepository, AuditNotificationRepository auditNotificationRepository,
ConfigurationAccessor configurationAccessor, EventManager eventManager); @Override List<AlertNotificationModel> saveAllNotifications(Collection<AlertNotificationModel> notifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAll(PageRequest pageRequest, boolean onlyShowSentNotifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAllWithSearch(String searchTerm, PageRequest pageRequest, boolean onlyShowSentNotifications); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByIds(List<Long> notificationIds); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Optional<AlertNotificationModel> findById(Long notificationId); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBetween(OffsetDateTime startDate, OffsetDateTime endDate); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBefore(OffsetDateTime date); @Override List<AlertNotificationModel> findByCreatedAtBeforeDayOffset(int dayOffset); @Override void deleteNotificationList(List<AlertNotificationModel> notifications); @Override void deleteNotification(AlertNotificationModel notification); PageRequest getPageRequestForNotifications(Integer pageNumber, Integer pageSize, String sortField, String sortOrder); }### Answer:
@Test public void findByIdsTest() throws Exception { NotificationEntity notificationEntity = new NotificationEntity(id, DateUtils.createCurrentDateTimestamp(), provider, providerConfigId, DateUtils.createCurrentDateTimestamp(), notificationType, content); ConfigurationModel configurationModel = createConfigurationModel(); NotificationContentRepository notificationContentRepository = Mockito.mock(NotificationContentRepository.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); Mockito.when(notificationContentRepository.findAllById(Mockito.any())).thenReturn(List.of(notificationEntity)); Mockito.when(configurationAccessor.getConfigurationById(Mockito.any())).thenReturn(Optional.of(configurationModel)); DefaultNotificationAccessor notificationManager = new DefaultNotificationAccessor(notificationContentRepository, null, null, configurationAccessor, null); List<AlertNotificationModel> alertNotificationModelList = notificationManager.findByIds(List.of(1L)); assertEquals(1, alertNotificationModelList.size()); AlertNotificationModel alertNotificationModel = alertNotificationModelList.get(0); testExpectedAlertNotificationModel(expectedAlertNotificationModel, alertNotificationModel); } |
### Question:
DefaultNotificationAccessor implements NotificationAccessor { @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) public Optional<AlertNotificationModel> findById(Long notificationId) { return notificationContentRepository.findById(notificationId).map(this::toModel); } @Autowired DefaultNotificationAccessor(NotificationContentRepository notificationContentRepository, AuditEntryRepository auditEntryRepository, AuditNotificationRepository auditNotificationRepository,
ConfigurationAccessor configurationAccessor, EventManager eventManager); @Override List<AlertNotificationModel> saveAllNotifications(Collection<AlertNotificationModel> notifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAll(PageRequest pageRequest, boolean onlyShowSentNotifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAllWithSearch(String searchTerm, PageRequest pageRequest, boolean onlyShowSentNotifications); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByIds(List<Long> notificationIds); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Optional<AlertNotificationModel> findById(Long notificationId); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBetween(OffsetDateTime startDate, OffsetDateTime endDate); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBefore(OffsetDateTime date); @Override List<AlertNotificationModel> findByCreatedAtBeforeDayOffset(int dayOffset); @Override void deleteNotificationList(List<AlertNotificationModel> notifications); @Override void deleteNotification(AlertNotificationModel notification); PageRequest getPageRequestForNotifications(Integer pageNumber, Integer pageSize, String sortField, String sortOrder); }### Answer:
@Test public void findByIdTest() throws Exception { NotificationEntity notificationEntity = new NotificationEntity(id, DateUtils.createCurrentDateTimestamp(), provider, providerConfigId, DateUtils.createCurrentDateTimestamp(), notificationType, content); ConfigurationModel configurationModel = createConfigurationModel(); NotificationContentRepository notificationContentRepository = Mockito.mock(NotificationContentRepository.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); Mockito.when(notificationContentRepository.findById(Mockito.any())).thenReturn(Optional.of(notificationEntity)); Mockito.when(configurationAccessor.getConfigurationById(Mockito.any())).thenReturn(Optional.of(configurationModel)); DefaultNotificationAccessor notificationManager = new DefaultNotificationAccessor(notificationContentRepository, null, null, configurationAccessor, null); Optional<AlertNotificationModel> alertNotificationModel = notificationManager.findById(1L); assertTrue(alertNotificationModel.isPresent()); testExpectedAlertNotificationModel(expectedAlertNotificationModel, alertNotificationModel.get()); } |
### Question:
DefaultNotificationAccessor implements NotificationAccessor { @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) public List<AlertNotificationModel> findByCreatedAtBetween(OffsetDateTime startDate, OffsetDateTime endDate) { List<NotificationEntity> byCreatedAtBetween = notificationContentRepository.findByCreatedAtBetween(startDate, endDate); return toModels(byCreatedAtBetween); } @Autowired DefaultNotificationAccessor(NotificationContentRepository notificationContentRepository, AuditEntryRepository auditEntryRepository, AuditNotificationRepository auditNotificationRepository,
ConfigurationAccessor configurationAccessor, EventManager eventManager); @Override List<AlertNotificationModel> saveAllNotifications(Collection<AlertNotificationModel> notifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAll(PageRequest pageRequest, boolean onlyShowSentNotifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAllWithSearch(String searchTerm, PageRequest pageRequest, boolean onlyShowSentNotifications); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByIds(List<Long> notificationIds); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Optional<AlertNotificationModel> findById(Long notificationId); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBetween(OffsetDateTime startDate, OffsetDateTime endDate); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBefore(OffsetDateTime date); @Override List<AlertNotificationModel> findByCreatedAtBeforeDayOffset(int dayOffset); @Override void deleteNotificationList(List<AlertNotificationModel> notifications); @Override void deleteNotification(AlertNotificationModel notification); PageRequest getPageRequestForNotifications(Integer pageNumber, Integer pageSize, String sortField, String sortOrder); }### Answer:
@Test public void findByCreatedAtBetweenTest() throws Exception { NotificationEntity notificationEntity = new NotificationEntity(id, DateUtils.createCurrentDateTimestamp(), provider, providerConfigId, DateUtils.createCurrentDateTimestamp(), notificationType, content); ConfigurationModel configurationModel = createConfigurationModel(); NotificationContentRepository notificationContentRepository = Mockito.mock(NotificationContentRepository.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); Mockito.when(notificationContentRepository.findByCreatedAtBetween(Mockito.any(), Mockito.any())).thenReturn(List.of(notificationEntity)); Mockito.when(configurationAccessor.getConfigurationById(Mockito.any())).thenReturn(Optional.of(configurationModel)); DefaultNotificationAccessor notificationManager = new DefaultNotificationAccessor(notificationContentRepository, null, null, configurationAccessor, null); List<AlertNotificationModel> alertNotificationModelList = notificationManager.findByCreatedAtBetween(DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); assertEquals(1, alertNotificationModelList.size()); AlertNotificationModel alertNotificationModel = alertNotificationModelList.get(0); testExpectedAlertNotificationModel(expectedAlertNotificationModel, alertNotificationModel); } |
### Question:
DefaultNotificationAccessor implements NotificationAccessor { @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) public List<AlertNotificationModel> findByCreatedAtBefore(OffsetDateTime date) { List<NotificationEntity> byCreatedAtBefore = notificationContentRepository.findByCreatedAtBefore(date); return toModels(byCreatedAtBefore); } @Autowired DefaultNotificationAccessor(NotificationContentRepository notificationContentRepository, AuditEntryRepository auditEntryRepository, AuditNotificationRepository auditNotificationRepository,
ConfigurationAccessor configurationAccessor, EventManager eventManager); @Override List<AlertNotificationModel> saveAllNotifications(Collection<AlertNotificationModel> notifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAll(PageRequest pageRequest, boolean onlyShowSentNotifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAllWithSearch(String searchTerm, PageRequest pageRequest, boolean onlyShowSentNotifications); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByIds(List<Long> notificationIds); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Optional<AlertNotificationModel> findById(Long notificationId); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBetween(OffsetDateTime startDate, OffsetDateTime endDate); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBefore(OffsetDateTime date); @Override List<AlertNotificationModel> findByCreatedAtBeforeDayOffset(int dayOffset); @Override void deleteNotificationList(List<AlertNotificationModel> notifications); @Override void deleteNotification(AlertNotificationModel notification); PageRequest getPageRequestForNotifications(Integer pageNumber, Integer pageSize, String sortField, String sortOrder); }### Answer:
@Test public void findByCreatedAtBeforeTest() throws Exception { NotificationEntity notificationEntity = new NotificationEntity(id, DateUtils.createCurrentDateTimestamp(), provider, providerConfigId, DateUtils.createCurrentDateTimestamp(), notificationType, content); ConfigurationModel configurationModel = createConfigurationModel(); NotificationContentRepository notificationContentRepository = Mockito.mock(NotificationContentRepository.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); Mockito.when(notificationContentRepository.findByCreatedAtBefore(Mockito.any())).thenReturn(List.of(notificationEntity)); Mockito.when(configurationAccessor.getConfigurationById(Mockito.any())).thenReturn(Optional.of(configurationModel)); DefaultNotificationAccessor notificationManager = new DefaultNotificationAccessor(notificationContentRepository, null, null, configurationAccessor, null); List<AlertNotificationModel> alertNotificationModelList = notificationManager.findByCreatedAtBefore(DateUtils.createCurrentDateTimestamp()); assertEquals(1, alertNotificationModelList.size()); AlertNotificationModel alertNotificationModel = alertNotificationModelList.get(0); testExpectedAlertNotificationModel(expectedAlertNotificationModel, alertNotificationModel); } |
### Question:
DefaultNotificationAccessor implements NotificationAccessor { @Override public List<AlertNotificationModel> findByCreatedAtBeforeDayOffset(int dayOffset) { OffsetDateTime searchTime = DateUtils.createCurrentDateTimestamp() .minusDays(dayOffset) .withHour(0).withMinute(0).withSecond(0).withNano(0); return findByCreatedAtBefore(searchTime); } @Autowired DefaultNotificationAccessor(NotificationContentRepository notificationContentRepository, AuditEntryRepository auditEntryRepository, AuditNotificationRepository auditNotificationRepository,
ConfigurationAccessor configurationAccessor, EventManager eventManager); @Override List<AlertNotificationModel> saveAllNotifications(Collection<AlertNotificationModel> notifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAll(PageRequest pageRequest, boolean onlyShowSentNotifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAllWithSearch(String searchTerm, PageRequest pageRequest, boolean onlyShowSentNotifications); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByIds(List<Long> notificationIds); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Optional<AlertNotificationModel> findById(Long notificationId); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBetween(OffsetDateTime startDate, OffsetDateTime endDate); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBefore(OffsetDateTime date); @Override List<AlertNotificationModel> findByCreatedAtBeforeDayOffset(int dayOffset); @Override void deleteNotificationList(List<AlertNotificationModel> notifications); @Override void deleteNotification(AlertNotificationModel notification); PageRequest getPageRequestForNotifications(Integer pageNumber, Integer pageSize, String sortField, String sortOrder); }### Answer:
@Test public void findByCreatedAtBeforeDayOffsetTest() throws Exception { NotificationEntity notificationEntity = new NotificationEntity(id, DateUtils.createCurrentDateTimestamp(), provider, providerConfigId, DateUtils.createCurrentDateTimestamp(), notificationType, content); ConfigurationModel configurationModel = createConfigurationModel(); NotificationContentRepository notificationContentRepository = Mockito.mock(NotificationContentRepository.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); Mockito.when(notificationContentRepository.findByCreatedAtBefore(Mockito.any())).thenReturn(List.of(notificationEntity)); Mockito.when(configurationAccessor.getConfigurationById(Mockito.any())).thenReturn(Optional.of(configurationModel)); DefaultNotificationAccessor notificationManager = new DefaultNotificationAccessor(notificationContentRepository, null, null, configurationAccessor, null); List<AlertNotificationModel> alertNotificationModelList = notificationManager.findByCreatedAtBeforeDayOffset(1); assertEquals(1, alertNotificationModelList.size()); AlertNotificationModel alertNotificationModel = alertNotificationModelList.get(0); testExpectedAlertNotificationModel(expectedAlertNotificationModel, alertNotificationModel); } |
### Question:
DefaultNotificationAccessor implements NotificationAccessor { @Override public void deleteNotificationList(List<AlertNotificationModel> notifications) { notifications.forEach(this::deleteNotification); } @Autowired DefaultNotificationAccessor(NotificationContentRepository notificationContentRepository, AuditEntryRepository auditEntryRepository, AuditNotificationRepository auditNotificationRepository,
ConfigurationAccessor configurationAccessor, EventManager eventManager); @Override List<AlertNotificationModel> saveAllNotifications(Collection<AlertNotificationModel> notifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAll(PageRequest pageRequest, boolean onlyShowSentNotifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAllWithSearch(String searchTerm, PageRequest pageRequest, boolean onlyShowSentNotifications); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByIds(List<Long> notificationIds); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Optional<AlertNotificationModel> findById(Long notificationId); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBetween(OffsetDateTime startDate, OffsetDateTime endDate); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBefore(OffsetDateTime date); @Override List<AlertNotificationModel> findByCreatedAtBeforeDayOffset(int dayOffset); @Override void deleteNotificationList(List<AlertNotificationModel> notifications); @Override void deleteNotification(AlertNotificationModel notification); PageRequest getPageRequestForNotifications(Integer pageNumber, Integer pageSize, String sortField, String sortOrder); }### Answer:
@Test public void deleteNotificationListTest() { AlertNotificationModel alertNotificationModel = new AlertNotificationModel(null, providerConfigId, provider, providerConfigName, notificationType, content, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); AuditNotificationRelation auditNotificationRelation = new AuditNotificationRelation(1L, 2L); AuditEntryEntity auditEntryEntity = new AuditEntryEntity(UUID.randomUUID(), DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp(), "test-status", "test-errorMessage", "test-errorStackTrace"); NotificationContentRepository notificationContentRepository = Mockito.mock(NotificationContentRepository.class); AuditEntryRepository auditEntryRepository = Mockito.mock(AuditEntryRepository.class); AuditNotificationRepository auditNotificationRepository = Mockito.mock(AuditNotificationRepository.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); Mockito.when(auditNotificationRepository.findByNotificationId(Mockito.anyLong())).thenReturn(List.of(auditNotificationRelation)); Mockito.when(auditEntryRepository.findAllById(Mockito.any())).thenReturn(List.of(auditEntryEntity)); DefaultNotificationAccessor notificationManager = new DefaultNotificationAccessor(notificationContentRepository, auditEntryRepository, auditNotificationRepository, configurationAccessor, null); notificationManager.deleteNotificationList(List.of(alertNotificationModel)); Mockito.verify(auditEntryRepository).deleteAll(Mockito.any()); Mockito.verify(notificationContentRepository).deleteById(Mockito.any()); } |
### Question:
DefaultNotificationAccessor implements NotificationAccessor { public PageRequest getPageRequestForNotifications(Integer pageNumber, Integer pageSize, String sortField, String sortOrder) { Integer page = ObjectUtils.defaultIfNull(pageNumber, 0); Integer size = ObjectUtils.defaultIfNull(pageSize, Integer.MAX_VALUE); boolean sortQuery = false; String sortingField = "createdAt"; if (StringUtils.isNotBlank(sortField) && "createdAt".equalsIgnoreCase(sortField) || "provider".equalsIgnoreCase(sortField) || "providerCreationTime".equalsIgnoreCase(sortField) || "notificationType".equalsIgnoreCase(sortField) || "content".equalsIgnoreCase(sortField)) { sortingField = sortField; sortQuery = true; } Sort.Order sortingOrder = Sort.Order.desc(sortingField); if (StringUtils.isNotBlank(sortOrder) && sortQuery && Sort.Direction.ASC.name().equalsIgnoreCase(sortOrder)) { sortingOrder = Sort.Order.asc(sortingField); } return PageRequest.of(page, size, Sort.by(sortingOrder)); } @Autowired DefaultNotificationAccessor(NotificationContentRepository notificationContentRepository, AuditEntryRepository auditEntryRepository, AuditNotificationRepository auditNotificationRepository,
ConfigurationAccessor configurationAccessor, EventManager eventManager); @Override List<AlertNotificationModel> saveAllNotifications(Collection<AlertNotificationModel> notifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAll(PageRequest pageRequest, boolean onlyShowSentNotifications); @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Page<AlertNotificationModel> findAllWithSearch(String searchTerm, PageRequest pageRequest, boolean onlyShowSentNotifications); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByIds(List<Long> notificationIds); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Optional<AlertNotificationModel> findById(Long notificationId); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBetween(OffsetDateTime startDate, OffsetDateTime endDate); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<AlertNotificationModel> findByCreatedAtBefore(OffsetDateTime date); @Override List<AlertNotificationModel> findByCreatedAtBeforeDayOffset(int dayOffset); @Override void deleteNotificationList(List<AlertNotificationModel> notifications); @Override void deleteNotification(AlertNotificationModel notification); PageRequest getPageRequestForNotifications(Integer pageNumber, Integer pageSize, String sortField, String sortOrder); }### Answer:
@Test public void getPageRequestForNotificationsTest() { final int pageNumber = 1; final int pageSize = 1; final String sortField = "content"; String sortOrder = Sort.Direction.ASC.name(); NotificationContentRepository notificationContentRepository = Mockito.mock(NotificationContentRepository.class); AuditEntryRepository auditEntryRepository = Mockito.mock(AuditEntryRepository.class); AuditNotificationRepository auditNotificationRepository = Mockito.mock(AuditNotificationRepository.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); DefaultNotificationAccessor notificationManager = new DefaultNotificationAccessor(notificationContentRepository, auditEntryRepository, auditNotificationRepository, configurationAccessor, null); PageRequest pageRequest = notificationManager.getPageRequestForNotifications(pageNumber, pageSize, sortField, sortOrder); assertEquals(pageNumber, pageRequest.getPageNumber()); assertEquals(pageSize, pageRequest.getPageSize()); } |
### Question:
DefaultCustomCertificateAccessor implements CustomCertificateAccessor { @Override public List<CustomCertificateModel> getCertificates() { return customCertificateRepository.findAll() .stream() .map(this::createModel) .collect(Collectors.toList()); } @Autowired DefaultCustomCertificateAccessor(CustomCertificateRepository customCertificateRepository); @Override List<CustomCertificateModel> getCertificates(); @Override Optional<CustomCertificateModel> getCertificate(Long id); @Override CustomCertificateModel storeCertificate(CustomCertificateModel certificateModel); @Override void deleteCertificate(String certificateAlias); @Override void deleteCertificate(Long certificateId); }### Answer:
@Test public void getCertificatesTest() { CustomCertificateRepository customCertificateRepository = new MockCustomCertificateRepository(alias, content, testDate); DefaultCustomCertificateAccessor customCertificateAccessor = new DefaultCustomCertificateAccessor(customCertificateRepository); List<CustomCertificateModel> customCertificateModelList = customCertificateAccessor.getCertificates(); assertEquals(1, customCertificateModelList.size()); CustomCertificateModel customCertificateModel = customCertificateModelList.get(0); testCustomCertificateModel(expectedCustomCertificateModel, customCertificateModel); } |
### Question:
DefaultProviderDataAccessor implements ProviderDataAccessor { @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) public List<ProviderUserModel> getUsersByProviderConfigId(Long providerConfigId) { if (null == providerConfigId) { return List.of(); } return providerUserRepository.findByProviderConfigId(providerConfigId) .stream() .map(this::convertToUserModel) .collect(Collectors.toList()); } @Autowired DefaultProviderDataAccessor(ProviderProjectRepository providerProjectRepository, ProviderUserProjectRelationRepository providerUserProjectRelationRepository, ProviderUserRepository providerUserRepository,
ConfigurationAccessor configurationAccessor); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderProject> getProjectsByProviderConfigName(String providerConfigName); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderProject> getProjectsByProviderConfigId(Long providerConfigId); @Override void deleteProjects(Collection<ProviderProject> providerProjects); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) Set<String> getEmailAddressesForProjectHref(String projectHref); @Override @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) List<ProviderUserModel> getUsersByProviderConfigId(Long providerConfigId); @Override List<ProviderUserModel> getUsersByProviderConfigName(String providerConfigName); @Override void updateProjectAndUserData(Long providerConfigId, Map<ProviderProject, Set<String>> projectToUserData, Set<String> additionalRelevantUsers); static final int MAX_DESCRIPTION_LENGTH; static final int MAX_PROJECT_NAME_LENGTH; }### Answer:
@Test public void getUsersByProviderConfigIdTest() { ProviderUserEntity providerUserEntity = new ProviderUserEntity(projectOwnerEmail, true, 1L); ProviderProjectRepository providerProjectRepository = Mockito.mock(ProviderProjectRepository.class); ProviderUserRepository providerUserRepository = Mockito.mock(ProviderUserRepository.class); Mockito.when(providerUserRepository.findByProviderConfigId(Mockito.any())).thenReturn(List.of(providerUserEntity)); DefaultProviderDataAccessor providerDataAccessor = new DefaultProviderDataAccessor(providerProjectRepository, null, providerUserRepository, null); List<ProviderUserModel> providerUserModelList = providerDataAccessor.getUsersByProviderConfigId(1L); assertEquals(1, providerUserModelList.size()); ProviderUserModel providerUserModel = providerUserModelList.get(0); assertEquals(projectOwnerEmail, providerUserModel.getEmailAddress()); assertTrue(providerUserModel.getOptOut()); }
@Test public void getUsersByProviderConfigIdNullTest() { DefaultProviderDataAccessor providerDataAccessor = new DefaultProviderDataAccessor(null, null, null, null); List<ProviderUserModel> providerUserModelList = providerDataAccessor.getUsersByProviderConfigId(null); assertTrue(providerUserModelList.isEmpty()); } |
### Question:
DefaultCustomCertificateAccessor implements CustomCertificateAccessor { @Override public Optional<CustomCertificateModel> getCertificate(Long id) { return customCertificateRepository.findById(id) .map(this::createModel); } @Autowired DefaultCustomCertificateAccessor(CustomCertificateRepository customCertificateRepository); @Override List<CustomCertificateModel> getCertificates(); @Override Optional<CustomCertificateModel> getCertificate(Long id); @Override CustomCertificateModel storeCertificate(CustomCertificateModel certificateModel); @Override void deleteCertificate(String certificateAlias); @Override void deleteCertificate(Long certificateId); }### Answer:
@Test public void getCertificateTest() { CustomCertificateRepository customCertificateRepository = new MockCustomCertificateRepository(alias, content, testDate); DefaultCustomCertificateAccessor customCertificateAccessor = new DefaultCustomCertificateAccessor(customCertificateRepository); Optional<CustomCertificateModel> customCertificateModelOptional = customCertificateAccessor.getCertificate(0L); Optional<CustomCertificateModel> customCertificateModelOptionalEmpty = customCertificateAccessor.getCertificate(9L); assertTrue(customCertificateModelOptional.isPresent()); assertFalse(customCertificateModelOptionalEmpty.isPresent()); CustomCertificateModel customCertificateModel = customCertificateModelOptional.get(); testCustomCertificateModel(expectedCustomCertificateModel, customCertificateModel); } |
### Question:
DefaultCustomCertificateAccessor implements CustomCertificateAccessor { @Override public CustomCertificateModel storeCertificate(CustomCertificateModel certificateModel) throws AlertDatabaseConstraintException { if (null == certificateModel) { throw new AlertDatabaseConstraintException("The certificate model cannot be null"); } String alias = certificateModel.getAlias(); if (StringUtils.isBlank(alias)) { throw new AlertDatabaseConstraintException("The field 'alias' cannot be blank"); } String certificateContent = certificateModel.getCertificateContent(); if (StringUtils.isBlank(certificateContent)) { throw new AlertDatabaseConstraintException("The field 'certificateContent' cannot be blank"); } CustomCertificateEntity entityToSave = new CustomCertificateEntity(alias, certificateContent, DateUtils.createCurrentDateTimestamp()); Long id = certificateModel.getNullableId(); if (null == id) { id = customCertificateRepository.findByAlias(alias).map(CustomCertificateEntity::getId).orElse(null); } else { if (!customCertificateRepository.existsById(id)) { throw new AlertDatabaseConstraintException("A custom certificate with that id did not exist"); } } entityToSave.setId(id); CustomCertificateEntity updatedEntity = customCertificateRepository.save(entityToSave); return createModel(updatedEntity); } @Autowired DefaultCustomCertificateAccessor(CustomCertificateRepository customCertificateRepository); @Override List<CustomCertificateModel> getCertificates(); @Override Optional<CustomCertificateModel> getCertificate(Long id); @Override CustomCertificateModel storeCertificate(CustomCertificateModel certificateModel); @Override void deleteCertificate(String certificateAlias); @Override void deleteCertificate(Long certificateId); }### Answer:
@Test public void storeCertificateTest() throws Exception { CustomCertificateModel certificateModel = new CustomCertificateModel(alias, content, testDate.toString()); CustomCertificateRepository customCertificateRepository = new MockCustomCertificateRepository(); DefaultCustomCertificateAccessor customCertificateAccessor = new DefaultCustomCertificateAccessor(customCertificateRepository); CustomCertificateModel customCertificateModel = customCertificateAccessor.storeCertificate(certificateModel); testCustomCertificateModel(expectedCustomCertificateModel, customCertificateModel); }
@Test public void storeCertificateNullTest() throws Exception { CustomCertificateRepository customCertificateRepository = new MockCustomCertificateRepository(); DefaultCustomCertificateAccessor customCertificateAccessor = new DefaultCustomCertificateAccessor(customCertificateRepository); try { customCertificateAccessor.storeCertificate(null); fail(); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
@Test public void storeCertificateBlankValuesTest() throws Exception { CustomCertificateRepository customCertificateRepository = new MockCustomCertificateRepository(); DefaultCustomCertificateAccessor customCertificateAccessor = new DefaultCustomCertificateAccessor(customCertificateRepository); try { CustomCertificateModel certificateModel = new CustomCertificateModel("", content, testDate.toString()); customCertificateAccessor.storeCertificate(certificateModel); fail(); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } try { CustomCertificateModel certificateModel = new CustomCertificateModel(alias, "", testDate.toString()); customCertificateAccessor.storeCertificate(certificateModel); fail(); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
@Test public void storeCertificateIdDoesNotExistTest() throws Exception { CustomCertificateRepository customCertificateRepository = new MockCustomCertificateRepository(); DefaultCustomCertificateAccessor customCertificateAccessor = new DefaultCustomCertificateAccessor(customCertificateRepository); try { CustomCertificateModel certificateModel = new CustomCertificateModel(9L, alias, content, testDate.toString()); customCertificateAccessor.storeCertificate(certificateModel); fail(); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } } |
### Question:
DefaultCustomCertificateAccessor implements CustomCertificateAccessor { @Override public void deleteCertificate(String certificateAlias) throws AlertDatabaseConstraintException { if (StringUtils.isBlank(certificateAlias)) { throw new AlertDatabaseConstraintException("The field 'certificateAlias' cannot be blank"); } CustomCertificateEntity customCertificateEntity = customCertificateRepository.findByAlias(certificateAlias) .orElseThrow(() -> new AlertDatabaseConstraintException("A custom certificate with the alias " + certificateAlias + " did not exist")); deleteCertificate(customCertificateEntity.getId()); } @Autowired DefaultCustomCertificateAccessor(CustomCertificateRepository customCertificateRepository); @Override List<CustomCertificateModel> getCertificates(); @Override Optional<CustomCertificateModel> getCertificate(Long id); @Override CustomCertificateModel storeCertificate(CustomCertificateModel certificateModel); @Override void deleteCertificate(String certificateAlias); @Override void deleteCertificate(Long certificateId); }### Answer:
@Test public void deleteCertificateByAliasBlankTest() throws Exception { CustomCertificateRepository customCertificateRepository = new MockCustomCertificateRepository(alias, content, testDate); DefaultCustomCertificateAccessor customCertificateAccessor = new DefaultCustomCertificateAccessor(customCertificateRepository); try { customCertificateAccessor.deleteCertificate(""); fail(); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
@Test public void deleteCertificateByIdNullTest() throws Exception { CustomCertificateRepository customCertificateRepository = new MockCustomCertificateRepository(alias, content, testDate); DefaultCustomCertificateAccessor customCertificateAccessor = new DefaultCustomCertificateAccessor(customCertificateRepository); try { Long certificateId = null; customCertificateAccessor.deleteCertificate(certificateId); fail(); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } try { customCertificateAccessor.deleteCertificate(-1L); fail(); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } } |
### Question:
DefaultSystemStatusAccessor implements SystemStatusAccessor { @Override @Transactional public boolean isSystemInitialized() { return getSystemStatus().isInitialConfigurationPerformed(); } @Autowired DefaultSystemStatusAccessor(SystemStatusRepository systemStatusRepository); @Override @Transactional boolean isSystemInitialized(); @Override @Transactional void setSystemInitialized(boolean systemInitialized); @Override @Transactional void startupOccurred(); @Override @Transactional OffsetDateTime getStartupTime(); static final Long SYSTEM_STATUS_ID; }### Answer:
@Test public void isSystemInitializedTest() { SystemStatusRepository systemStatusRepository = Mockito.mock(SystemStatusRepository.class); SystemStatusEntity systemStatus = new SystemStatusEntity(Boolean.TRUE, DateUtils.createCurrentDateTimestamp()); Mockito.when(systemStatusRepository.findById(Mockito.any())).thenReturn(Optional.of(systemStatus)); DefaultSystemStatusAccessor systemStatusUtility = new DefaultSystemStatusAccessor(systemStatusRepository); assertTrue(systemStatusUtility.isSystemInitialized()); } |
### Question:
DefaultSystemStatusAccessor implements SystemStatusAccessor { @Override @Transactional public void setSystemInitialized(boolean systemInitialized) { SystemStatusEntity systemStatus = getSystemStatus(); SystemStatusEntity newSystemStatus = new SystemStatusEntity(systemInitialized, systemStatus.getStartupTime()); updateSystemStatus(newSystemStatus); } @Autowired DefaultSystemStatusAccessor(SystemStatusRepository systemStatusRepository); @Override @Transactional boolean isSystemInitialized(); @Override @Transactional void setSystemInitialized(boolean systemInitialized); @Override @Transactional void startupOccurred(); @Override @Transactional OffsetDateTime getStartupTime(); static final Long SYSTEM_STATUS_ID; }### Answer:
@Test public void setSystemInitializedTest() { SystemStatusRepository systemStatusRepository = new MockSystemStatusRepository(Boolean.FALSE); DefaultSystemStatusAccessor systemStatusUtility = new DefaultSystemStatusAccessor(systemStatusRepository); systemStatusUtility.setSystemInitialized(Boolean.TRUE); SystemStatusEntity testSystemStatus = systemStatusRepository.findAll().get(0); assertTrue(testSystemStatus.isInitialConfigurationPerformed()); } |
### Question:
DefaultSystemStatusAccessor implements SystemStatusAccessor { @Override @Transactional public void startupOccurred() { SystemStatusEntity systemStatus = getSystemStatus(); SystemStatusEntity newSystemStatus = new SystemStatusEntity(systemStatus.isInitialConfigurationPerformed(), createCurrentDateTimestamp()); updateSystemStatus(newSystemStatus); } @Autowired DefaultSystemStatusAccessor(SystemStatusRepository systemStatusRepository); @Override @Transactional boolean isSystemInitialized(); @Override @Transactional void setSystemInitialized(boolean systemInitialized); @Override @Transactional void startupOccurred(); @Override @Transactional OffsetDateTime getStartupTime(); static final Long SYSTEM_STATUS_ID; }### Answer:
@Test public void startupOccurred() { SystemStatusRepository systemStatusRepository = new MockSystemStatusRepository(Boolean.FALSE); DefaultSystemStatusAccessor systemStatusUtility = new DefaultSystemStatusAccessor(systemStatusRepository); systemStatusUtility.startupOccurred(); LocalDateTime estimatedDate = LocalDateTime.now(); SystemStatusEntity testSystemStatus = systemStatusRepository.findAll().get(0); LocalDateTime systemStatusLocalDateTime = testSystemStatus.getStartupTime() .toInstant() .atZone(ZoneId.systemDefault()) .toLocalDateTime(); assertFalse(testSystemStatus.isInitialConfigurationPerformed()); assertNotNull(testSystemStatus.getStartupTime()); assertEquals(estimatedDate.getHour(), systemStatusLocalDateTime.getHour()); assertEquals(estimatedDate.getMinute(), systemStatusLocalDateTime.getMinute()); } |
### Question:
DefaultSystemStatusAccessor implements SystemStatusAccessor { @Override @Transactional public OffsetDateTime getStartupTime() { return getSystemStatus().getStartupTime(); } @Autowired DefaultSystemStatusAccessor(SystemStatusRepository systemStatusRepository); @Override @Transactional boolean isSystemInitialized(); @Override @Transactional void setSystemInitialized(boolean systemInitialized); @Override @Transactional void startupOccurred(); @Override @Transactional OffsetDateTime getStartupTime(); static final Long SYSTEM_STATUS_ID; }### Answer:
@Test public void getStartupTime() { SystemStatusRepository systemStatusRepository = Mockito.mock(SystemStatusRepository.class); OffsetDateTime date = DateUtils.createCurrentDateTimestamp(); SystemStatusEntity systemStatus = new SystemStatusEntity(Boolean.TRUE, date); Mockito.when(systemStatusRepository.findById(Mockito.any())).thenReturn(Optional.of(systemStatus)); DefaultSystemStatusAccessor systemStatusUtility = new DefaultSystemStatusAccessor(systemStatusRepository); assertEquals(date, systemStatusUtility.getStartupTime()); } |
### Question:
DefaultRoleAccessor implements RoleAccessor { @Override public Set<UserRoleModel> getRoles() { List<RoleEntity> roleList = roleRepository.findAll(); Set<UserRoleModel> userRoles = new LinkedHashSet<>(); for (RoleEntity entity : roleList) { userRoles.add(new UserRoleModel(entity.getId(), entity.getRoleName(), entity.getCustom(), readPermissionsForRole(entity.getId()))); } return userRoles; } @Autowired DefaultRoleAccessor(RoleRepository roleRepository, UserRoleRepository userRoleRepository, PermissionMatrixRepository permissionMatrixRepository,
RegisteredDescriptorRepository registeredDescriptorRepository, ConfigContextRepository configContextRepository); @Override Set<UserRoleModel> getRoles(); @Override Set<UserRoleModel> getRoles(Collection<Long> roleIds); @Override boolean doesRoleNameExist(String name); @Override UserRoleModel createRole(String roleName); @Override UserRoleModel createRoleWithPermissions(String roleName, PermissionMatrixModel permissionMatrix); @Override void updateRoleName(Long roleId, String roleName); @Override PermissionMatrixModel updatePermissionsForRole(String roleName, PermissionMatrixModel permissionMatrix); @Override void deleteRole(Long roleId); @Override void updateUserRoles(Long userId, Collection<UserRoleModel> roles); @Override PermissionMatrixModel mergePermissionsForRoles(Collection<String> roleNames); @Override PermissionMatrixModel readPermissionsForRole(Long roleId); }### Answer:
@Test public void getRolesTest() { RoleEntity roleEntity = new RoleEntity(DefaultUserRole.ALERT_USER.name(), true); roleEntity.setId(1L); Mockito.when(roleRepository.findAll()).thenReturn(List.of(roleEntity)); DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); Set<UserRoleModel> userRoleModelsSet = authorizationUtility.getRoles(); UserRoleModel expectedUserRoleModel = createUserRoleModel(1L, DefaultUserRole.ALERT_USER.name(), true); assertEquals(1, userRoleModelsSet.size()); assertTrue(userRoleModelsSet.contains(expectedUserRoleModel)); }
@Test public void getRolesByRoleIdsTest() { RoleEntity roleEntity = new RoleEntity(DefaultUserRole.ALERT_USER.name(), true); roleEntity.setId(1L); Mockito.when(roleRepository.findById(Mockito.any())).thenReturn(Optional.of(roleEntity)); DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); Set<UserRoleModel> userRoleModelsSet = authorizationUtility.getRoles(List.of(1L)); UserRoleModel expectedUserRoleModel = createUserRoleModel(1L, DefaultUserRole.ALERT_USER.name(), true); assertEquals(1, userRoleModelsSet.size()); assertTrue(userRoleModelsSet.contains(expectedUserRoleModel)); } |
### Question:
DefaultRoleAccessor implements RoleAccessor { @Override public boolean doesRoleNameExist(String name) { return roleRepository.existsRoleEntityByRoleName(name); } @Autowired DefaultRoleAccessor(RoleRepository roleRepository, UserRoleRepository userRoleRepository, PermissionMatrixRepository permissionMatrixRepository,
RegisteredDescriptorRepository registeredDescriptorRepository, ConfigContextRepository configContextRepository); @Override Set<UserRoleModel> getRoles(); @Override Set<UserRoleModel> getRoles(Collection<Long> roleIds); @Override boolean doesRoleNameExist(String name); @Override UserRoleModel createRole(String roleName); @Override UserRoleModel createRoleWithPermissions(String roleName, PermissionMatrixModel permissionMatrix); @Override void updateRoleName(Long roleId, String roleName); @Override PermissionMatrixModel updatePermissionsForRole(String roleName, PermissionMatrixModel permissionMatrix); @Override void deleteRole(Long roleId); @Override void updateUserRoles(Long userId, Collection<UserRoleModel> roles); @Override PermissionMatrixModel mergePermissionsForRoles(Collection<String> roleNames); @Override PermissionMatrixModel readPermissionsForRole(Long roleId); }### Answer:
@Test public void doesRoleNameExistTest() { Mockito.when(roleRepository.existsRoleEntityByRoleName(Mockito.any())).thenReturn(true); DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); assertTrue(authorizationUtility.doesRoleNameExist("name")); } |
### Question:
DefaultRoleAccessor implements RoleAccessor { @Override public UserRoleModel createRole(String roleName) throws AlertDatabaseConstraintException { RoleEntity dbRole = createRole(roleName, true); return UserRoleModel.of(dbRole.getRoleName(), dbRole.getCustom()); } @Autowired DefaultRoleAccessor(RoleRepository roleRepository, UserRoleRepository userRoleRepository, PermissionMatrixRepository permissionMatrixRepository,
RegisteredDescriptorRepository registeredDescriptorRepository, ConfigContextRepository configContextRepository); @Override Set<UserRoleModel> getRoles(); @Override Set<UserRoleModel> getRoles(Collection<Long> roleIds); @Override boolean doesRoleNameExist(String name); @Override UserRoleModel createRole(String roleName); @Override UserRoleModel createRoleWithPermissions(String roleName, PermissionMatrixModel permissionMatrix); @Override void updateRoleName(Long roleId, String roleName); @Override PermissionMatrixModel updatePermissionsForRole(String roleName, PermissionMatrixModel permissionMatrix); @Override void deleteRole(Long roleId); @Override void updateUserRoles(Long userId, Collection<UserRoleModel> roles); @Override PermissionMatrixModel mergePermissionsForRoles(Collection<String> roleNames); @Override PermissionMatrixModel readPermissionsForRole(Long roleId); }### Answer:
@Test public void createRoleTest() throws Exception { final String roleName = "roleName"; Mockito.when(roleRepository.save(Mockito.any())).thenReturn(new RoleEntity(roleName, true)); DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); UserRoleModel userRoleModel = authorizationUtility.createRole(roleName); UserRoleModel expectedUserRoleModel = createUserRoleModel(null, roleName, true); assertEquals(expectedUserRoleModel, userRoleModel); }
@Test public void createRoleNullTest() throws Exception { DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); try { authorizationUtility.createRole(""); fail("Blank roleName did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } } |
### Question:
DefaultRoleAccessor implements RoleAccessor { @Override public UserRoleModel createRoleWithPermissions(String roleName, PermissionMatrixModel permissionMatrix) throws AlertDatabaseConstraintException { RoleEntity roleEntity = createRole(roleName, true); List<PermissionMatrixRelation> permissions = updateRoleOperations(roleEntity, permissionMatrix); return new UserRoleModel(roleEntity.getId(), roleEntity.getRoleName(), roleEntity.getCustom(), createModelFromPermission(permissions)); } @Autowired DefaultRoleAccessor(RoleRepository roleRepository, UserRoleRepository userRoleRepository, PermissionMatrixRepository permissionMatrixRepository,
RegisteredDescriptorRepository registeredDescriptorRepository, ConfigContextRepository configContextRepository); @Override Set<UserRoleModel> getRoles(); @Override Set<UserRoleModel> getRoles(Collection<Long> roleIds); @Override boolean doesRoleNameExist(String name); @Override UserRoleModel createRole(String roleName); @Override UserRoleModel createRoleWithPermissions(String roleName, PermissionMatrixModel permissionMatrix); @Override void updateRoleName(Long roleId, String roleName); @Override PermissionMatrixModel updatePermissionsForRole(String roleName, PermissionMatrixModel permissionMatrix); @Override void deleteRole(Long roleId); @Override void updateUserRoles(Long userId, Collection<UserRoleModel> roles); @Override PermissionMatrixModel mergePermissionsForRoles(Collection<String> roleNames); @Override PermissionMatrixModel readPermissionsForRole(Long roleId); }### Answer:
@Test public void createRoleWithPermissions() throws Exception { final String roleName = "roleName"; final String contextString = "context-test"; final String descriptorName = "descriptorName"; RoleEntity roleEntity = new RoleEntity(roleName, true); roleEntity.setId(1L); ConfigContextEntity configContextEntity = new ConfigContextEntity(contextString); configContextEntity.setId(1L); RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity(descriptorName, 1L); registeredDescriptorEntity.setId(1L); PermissionKey permissionKey = new PermissionKey(contextString, descriptorName); PermissionMatrixModel permissionMatrixModel = new PermissionMatrixModel(Map.of(permissionKey, AccessOperation.READ.getBit() + AccessOperation.WRITE.getBit())); PermissionMatrixRelation permissionMatrixRelation = new PermissionMatrixRelation(roleEntity.getId(), configContextEntity.getId(), registeredDescriptorEntity.getId(), AccessOperation.READ.getBit() + AccessOperation.WRITE.getBit()); Mockito.when(roleRepository.save(Mockito.any())).thenReturn(new RoleEntity(roleName, true)); mockUpdateRoleOperations(permissionMatrixRelation, configContextEntity, registeredDescriptorEntity); mockCreateModelFromPermission(configContextEntity, registeredDescriptorEntity); DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); UserRoleModel userRoleModel = authorizationUtility.createRoleWithPermissions(roleName, permissionMatrixModel); Mockito.verify(permissionMatrixRepository).deleteAll(Mockito.any()); assertEquals(roleName, userRoleModel.getName()); assertTrue(userRoleModel.isCustom()); assertEquals(permissionMatrixModel, userRoleModel.getPermissions()); } |
### Question:
DefaultRoleAccessor implements RoleAccessor { @Override public void updateRoleName(Long roleId, String roleName) throws AlertDatabaseConstraintException { Optional<RoleEntity> foundRole = roleRepository.findById(roleId); if (foundRole.isPresent()) { RoleEntity roleEntity = foundRole.get(); if (BooleanUtils.isFalse(roleEntity.getCustom())) { throw new AlertDatabaseConstraintException("Cannot update the existing role '" + foundRole.get().getRoleName() + "' to '" + roleName + "' because it is not a custom role"); } RoleEntity updatedEntity = new RoleEntity(roleName, true); updatedEntity.setId(roleEntity.getId()); roleRepository.save(updatedEntity); } } @Autowired DefaultRoleAccessor(RoleRepository roleRepository, UserRoleRepository userRoleRepository, PermissionMatrixRepository permissionMatrixRepository,
RegisteredDescriptorRepository registeredDescriptorRepository, ConfigContextRepository configContextRepository); @Override Set<UserRoleModel> getRoles(); @Override Set<UserRoleModel> getRoles(Collection<Long> roleIds); @Override boolean doesRoleNameExist(String name); @Override UserRoleModel createRole(String roleName); @Override UserRoleModel createRoleWithPermissions(String roleName, PermissionMatrixModel permissionMatrix); @Override void updateRoleName(Long roleId, String roleName); @Override PermissionMatrixModel updatePermissionsForRole(String roleName, PermissionMatrixModel permissionMatrix); @Override void deleteRole(Long roleId); @Override void updateUserRoles(Long userId, Collection<UserRoleModel> roles); @Override PermissionMatrixModel mergePermissionsForRoles(Collection<String> roleNames); @Override PermissionMatrixModel readPermissionsForRole(Long roleId); }### Answer:
@Test public void updateRoleNameTest() throws Exception { final String roleName = "roleName"; final Long roleId = 1L; RoleEntity roleEntity = new RoleEntity(DefaultUserRole.ALERT_USER.name(), true); roleEntity.setId(1L); Mockito.when(roleRepository.findById(Mockito.any())).thenReturn(Optional.of(roleEntity)); DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); authorizationUtility.updateRoleName(roleId, roleName); Mockito.verify(roleRepository).save(Mockito.any()); }
@Test public void updateRoleNameCustomFalseTest() throws Exception { DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); RoleEntity roleEntity = new RoleEntity(DefaultUserRole.ALERT_USER.name(), false); roleEntity.setId(1L); Mockito.when(roleRepository.findById(Mockito.any())).thenReturn(Optional.of(roleEntity)); try { authorizationUtility.updateRoleName(1L, "roleName"); fail("Custom parameter of roleEntity set to 'false' did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } } |
### Question:
DefaultRoleAccessor implements RoleAccessor { @Override public PermissionMatrixModel updatePermissionsForRole(String roleName, PermissionMatrixModel permissionMatrix) throws AlertDatabaseConstraintException { RoleEntity roleEntity = roleRepository.findByRoleName(roleName) .orElseThrow(() -> new AlertDatabaseConstraintException("No role exists with name: " + roleName)); List<PermissionMatrixRelation> permissions = updateRoleOperations(roleEntity, permissionMatrix); return createModelFromPermission(permissions); } @Autowired DefaultRoleAccessor(RoleRepository roleRepository, UserRoleRepository userRoleRepository, PermissionMatrixRepository permissionMatrixRepository,
RegisteredDescriptorRepository registeredDescriptorRepository, ConfigContextRepository configContextRepository); @Override Set<UserRoleModel> getRoles(); @Override Set<UserRoleModel> getRoles(Collection<Long> roleIds); @Override boolean doesRoleNameExist(String name); @Override UserRoleModel createRole(String roleName); @Override UserRoleModel createRoleWithPermissions(String roleName, PermissionMatrixModel permissionMatrix); @Override void updateRoleName(Long roleId, String roleName); @Override PermissionMatrixModel updatePermissionsForRole(String roleName, PermissionMatrixModel permissionMatrix); @Override void deleteRole(Long roleId); @Override void updateUserRoles(Long userId, Collection<UserRoleModel> roles); @Override PermissionMatrixModel mergePermissionsForRoles(Collection<String> roleNames); @Override PermissionMatrixModel readPermissionsForRole(Long roleId); }### Answer:
@Test public void updatePermissionsForRole() throws Exception { final String roleName = "roleName"; final String contextString = "context-test"; final String descriptorName = "descriptorName"; RoleEntity roleEntity = new RoleEntity(roleName, true); roleEntity.setId(1L); ConfigContextEntity configContextEntity = new ConfigContextEntity(contextString); configContextEntity.setId(1L); RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity(descriptorName, 1L); registeredDescriptorEntity.setId(1L); PermissionKey permissionKey = new PermissionKey(contextString, descriptorName); PermissionMatrixModel permissionMatrix = new PermissionMatrixModel(Map.of(permissionKey, AccessOperation.READ.getBit() + AccessOperation.WRITE.getBit())); PermissionMatrixRelation permissionMatrixRelation = new PermissionMatrixRelation(roleEntity.getId(), configContextEntity.getId(), registeredDescriptorEntity.getId(), AccessOperation.READ.getBit() + AccessOperation.WRITE.getBit()); Mockito.when(roleRepository.findByRoleName(Mockito.any())).thenReturn(Optional.of(roleEntity)); mockUpdateRoleOperations(permissionMatrixRelation, configContextEntity, registeredDescriptorEntity); mockCreateModelFromPermission(configContextEntity, registeredDescriptorEntity); DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); PermissionMatrixModel permissionMatrixModel = authorizationUtility.updatePermissionsForRole(roleName, permissionMatrix); Mockito.verify(permissionMatrixRepository).saveAll(Mockito.any()); assertFalse(permissionMatrixModel.isEmpty()); assertEquals(permissionMatrix, permissionMatrixModel); } |
### Question:
DefaultRoleAccessor implements RoleAccessor { @Override public void deleteRole(Long roleId) throws AlertForbiddenOperationException { Optional<RoleEntity> foundRole = roleRepository.findById(roleId); if (foundRole.isPresent()) { RoleEntity roleEntity = foundRole.get(); if (BooleanUtils.isFalse(roleEntity.getCustom())) { throw new AlertForbiddenOperationException("Cannot delete the role '" + roleId + "' because it is not a custom role."); } roleRepository.deleteById(roleEntity.getId()); } } @Autowired DefaultRoleAccessor(RoleRepository roleRepository, UserRoleRepository userRoleRepository, PermissionMatrixRepository permissionMatrixRepository,
RegisteredDescriptorRepository registeredDescriptorRepository, ConfigContextRepository configContextRepository); @Override Set<UserRoleModel> getRoles(); @Override Set<UserRoleModel> getRoles(Collection<Long> roleIds); @Override boolean doesRoleNameExist(String name); @Override UserRoleModel createRole(String roleName); @Override UserRoleModel createRoleWithPermissions(String roleName, PermissionMatrixModel permissionMatrix); @Override void updateRoleName(Long roleId, String roleName); @Override PermissionMatrixModel updatePermissionsForRole(String roleName, PermissionMatrixModel permissionMatrix); @Override void deleteRole(Long roleId); @Override void updateUserRoles(Long userId, Collection<UserRoleModel> roles); @Override PermissionMatrixModel mergePermissionsForRoles(Collection<String> roleNames); @Override PermissionMatrixModel readPermissionsForRole(Long roleId); }### Answer:
@Test public void deleteRoleTest() throws Exception { final String roleName = "roleName"; final Long roleId = 1L; RoleEntity roleEntity = new RoleEntity(roleName, true); roleEntity.setId(1L); Mockito.when(roleRepository.findById(Mockito.any())).thenReturn(Optional.of(roleEntity)); DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); authorizationUtility.deleteRole(roleId); Mockito.verify(roleRepository).deleteById(Mockito.any()); }
@Test public void deleteRoleCustomFalseTest() throws Exception { DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); RoleEntity roleEntity = new RoleEntity("name", false); roleEntity.setId(1L); Mockito.when(roleRepository.findById(Mockito.any())).thenReturn(Optional.of(roleEntity)); try { authorizationUtility.deleteRole(1L); fail("Custom parameter of roleEntity set to 'false' did not throw expected AlertForbiddenOperationException."); } catch (AlertForbiddenOperationException e) { assertNotNull(e); } } |
### Question:
DefaultRoleAccessor implements RoleAccessor { @Override public void updateUserRoles(Long userId, Collection<UserRoleModel> roles) { if (null != userId) { userRoleRepository.deleteAllByUserId(userId); if (null != roles && !roles.isEmpty()) { Collection<String> roleNames = roles.stream().map(UserRoleModel::getName).collect(Collectors.toSet()); List<RoleEntity> roleEntities = roleRepository.findRoleEntitiesByRoleNames(roleNames); List<UserRoleRelation> roleRelations = new LinkedList<>(); for (RoleEntity role : roleEntities) { roleRelations.add(new UserRoleRelation(userId, role.getId())); } userRoleRepository.saveAll(roleRelations); } } } @Autowired DefaultRoleAccessor(RoleRepository roleRepository, UserRoleRepository userRoleRepository, PermissionMatrixRepository permissionMatrixRepository,
RegisteredDescriptorRepository registeredDescriptorRepository, ConfigContextRepository configContextRepository); @Override Set<UserRoleModel> getRoles(); @Override Set<UserRoleModel> getRoles(Collection<Long> roleIds); @Override boolean doesRoleNameExist(String name); @Override UserRoleModel createRole(String roleName); @Override UserRoleModel createRoleWithPermissions(String roleName, PermissionMatrixModel permissionMatrix); @Override void updateRoleName(Long roleId, String roleName); @Override PermissionMatrixModel updatePermissionsForRole(String roleName, PermissionMatrixModel permissionMatrix); @Override void deleteRole(Long roleId); @Override void updateUserRoles(Long userId, Collection<UserRoleModel> roles); @Override PermissionMatrixModel mergePermissionsForRoles(Collection<String> roleNames); @Override PermissionMatrixModel readPermissionsForRole(Long roleId); }### Answer:
@Test public void updateUserRolesTest() { final Long userId = 1L; final String roleName = "roleName"; final Long roleId = 1L; RoleEntity roleEntity = new RoleEntity(roleName, true); roleEntity.setId(1L); UserRoleModel userRoleModel = createUserRoleModel(roleId, roleName, true); Collection<UserRoleModel> userRoleModelCollection = List.of(userRoleModel); Mockito.when(roleRepository.findRoleEntitiesByRoleNames(Mockito.any())).thenReturn(List.of(roleEntity)); DefaultRoleAccessor authorizationUtility = new DefaultRoleAccessor(roleRepository, userRoleRepository, permissionMatrixRepository, registeredDescriptorRepository, configContextRepository); authorizationUtility.updateUserRoles(userId, userRoleModelCollection); Mockito.verify(userRoleRepository).deleteAllByUserId(Mockito.any()); Mockito.verify(userRoleRepository).saveAll(Mockito.any()); } |
### Question:
DefaultAuthenticationTypeAccessor implements AuthenticationTypeAccessor { @Override public Optional<AuthenticationTypeDetails> getAuthenticationTypeDetails(AuthenticationType authenticationType) { Optional<AuthenticationTypeEntity> authenticationTypeEntity = authenticationTypeRepository.findById(authenticationType.getId()); return authenticationTypeEntity.map(entity -> new AuthenticationTypeDetails(entity.getId(), entity.getName())); } @Autowired DefaultAuthenticationTypeAccessor(AuthenticationTypeRepository authenticationTypeRepository); @Override Optional<AuthenticationTypeDetails> getAuthenticationTypeDetails(AuthenticationType authenticationType); @Override Optional<AuthenticationType> getAuthenticationType(Long id); }### Answer:
@Test public void getAuthenticationTypeDetailsTest() { AuthenticationTypeRepository authenticationTypeRepository = Mockito.mock(AuthenticationTypeRepository.class); DefaultAuthenticationTypeAccessor authenticationTypeAccessor = new DefaultAuthenticationTypeAccessor(authenticationTypeRepository); AuthenticationTypeEntity authenticationTypeEntity = new AuthenticationTypeEntity("name-test"); Mockito.when(authenticationTypeRepository.findById(Mockito.any())).thenReturn(Optional.of(authenticationTypeEntity)); Optional<AuthenticationTypeDetails> testAuthenticationTypeDetails = authenticationTypeAccessor.getAuthenticationTypeDetails(AuthenticationType.DATABASE); assertTrue(testAuthenticationTypeDetails.isPresent()); AuthenticationTypeDetails authenticationTypeDetails = testAuthenticationTypeDetails.get(); assertEquals(authenticationTypeEntity.getName(), authenticationTypeDetails.getName()); assertEquals(authenticationTypeEntity.getId(), authenticationTypeDetails.getId()); }
@Test public void getAuthenticationTypeDetailsNullTest() { AuthenticationTypeRepository authenticationTypeRepository = Mockito.mock(AuthenticationTypeRepository.class); DefaultAuthenticationTypeAccessor authenticationTypeAccessor = new DefaultAuthenticationTypeAccessor(authenticationTypeRepository); Mockito.when(authenticationTypeRepository.findById(Mockito.any())).thenReturn(Optional.empty()); Optional<AuthenticationTypeDetails> testAuthenticationTypeDetails = authenticationTypeAccessor.getAuthenticationTypeDetails(AuthenticationType.DATABASE); assertFalse(testAuthenticationTypeDetails.isPresent()); } |
### Question:
DefaultAuthenticationTypeAccessor implements AuthenticationTypeAccessor { @Override public Optional<AuthenticationType> getAuthenticationType(Long id) { return AuthenticationType.getById(id); } @Autowired DefaultAuthenticationTypeAccessor(AuthenticationTypeRepository authenticationTypeRepository); @Override Optional<AuthenticationTypeDetails> getAuthenticationTypeDetails(AuthenticationType authenticationType); @Override Optional<AuthenticationType> getAuthenticationType(Long id); }### Answer:
@Test public void getAuthenticationTypeTest() { AuthenticationTypeRepository authenticationTypeRepository = Mockito.mock(AuthenticationTypeRepository.class); DefaultAuthenticationTypeAccessor authenticationTypeAccessor = new DefaultAuthenticationTypeAccessor(authenticationTypeRepository); assertEquals(AuthenticationType.DATABASE, authenticationTypeAccessor.getAuthenticationType(1L).get()); assertEquals(AuthenticationType.LDAP, authenticationTypeAccessor.getAuthenticationType(2L).get()); assertEquals(AuthenticationType.SAML, authenticationTypeAccessor.getAuthenticationType(3L).get()); assertFalse(authenticationTypeAccessor.getAuthenticationType(5L).isPresent()); } |
### Question:
DefaultProviderTaskPropertiesAccessor implements ProviderTaskPropertiesAccessor { @Override public Optional<String> getTaskProperty(String taskName, String propertyKey) { if (StringUtils.isBlank(taskName) || StringUtils.isBlank(propertyKey)) { return Optional.empty(); } return providerTaskPropertiesRepository.findByTaskNameAndPropertyName(taskName, propertyKey).map(ProviderTaskPropertiesEntity::getValue); } @Autowired DefaultProviderTaskPropertiesAccessor(ProviderTaskPropertiesRepository providerTaskPropertiesRepository); @Override Optional<String> getTaskProperty(String taskName, String propertyKey); @Override void setTaskProperty(Long configId, String taskName, String propertyKey, String propertyValue); }### Answer:
@Test public void getTaskPropertyTest() { DefaultProviderTaskPropertiesAccessor providerTaskPropertiesAccessor = new DefaultProviderTaskPropertiesAccessor(providerTaskPropertiesRepository); Optional<String> taskPropertyValue = providerTaskPropertiesAccessor.getTaskProperty(taskName, propertyName); assertTrue(taskPropertyValue.isPresent()); assertEquals(value, taskPropertyValue.get()); }
@Test public void getTaskPropertyEmptyTest() { DefaultProviderTaskPropertiesAccessor providerTaskPropertiesAccessor = new DefaultProviderTaskPropertiesAccessor(providerTaskPropertiesRepository); Optional<String> taskPropertyOptionalEmpty = providerTaskPropertiesAccessor.getTaskProperty("invalidTaskName", "invalidPropertyKey"); Optional<String> taskPropertyValueEmpty = providerTaskPropertiesAccessor.getTaskProperty("", ""); assertFalse(taskPropertyOptionalEmpty.isPresent()); assertFalse(taskPropertyValueEmpty.isPresent()); } |
### Question:
Author extends AbstractNode { @Override public int hashCode() { final int prime = 31; int result = 1; result += prime * result + ((this.firstInitial == null) ? 0 : this.firstInitial.hashCode()); result += prime * result + ((this.lastName == null) ? 0 : this.lastName.hashCode()); return result; } Author(String rawAuthorText, int origin); Author(String rawAuthorText, int origin, IncitesInstitutionLocationMap locationMap); void addInstitution(String institution); void addPublication(Publication publication); double getExpectedCitations(); @Override boolean equals(Object other); void format(); @Override CyNode getCyNode(); String getDepartment(); String getFirstInitial(); String getFirstName(); String getInstitution(); List<String> getInstitutions(); @Override String getLabel(); String getLastName(); String getLocation(); String getMainInstitution(); @Override Map<String, Object> getNodeAttrMap(); int getOrigin(); List<String> getPubList(); int getTimesCited(); boolean hasAlreadyBeenAdded(); @Override int hashCode(); boolean isIdentified(); void prioritizeInstitution(Author author, Author otherAuthor); void setAlreadyBeenAdded(boolean alreadyBeenAdded); @Override void setCyNode(CyNode cyNode); void setDepartment(String department); void setFirstInitial(String firstInitial); void setFirstName(String firstName); @Override void setLabel(String label); void setLastName(String lastName); void setLocation(String location); void setMainInstitution(String mainInstitution); void setMiddleInitial(String middleInitial); @Override void setNodeAttrMap(Map<String, Object> attrMap); void setOrigin(int origin); void setPubList(List<String> pubList); void setTimesCited(int timesCited); @Override String toString(); }### Answer:
@Test public void testUpperCaseHashCode() { Author author = new Author("somebody hm", Category.PUBMED); Author authorUpperCase = new Author("sOMeBODy H", Category.PUBMED); assertTrue(authorUpperCase.hashCode() == author.hashCode()); }
@Test public void testHashCode() { Author author1 = new Author("somebody h", Category.PUBMED); Author author2 = new Author("somebody hm", Category.PUBMED); assertTrue(author1.hashCode() == author2.hashCode()); } |
### Question:
Author extends AbstractNode { public String getFirstName() { return this.firstName; } Author(String rawAuthorText, int origin); Author(String rawAuthorText, int origin, IncitesInstitutionLocationMap locationMap); void addInstitution(String institution); void addPublication(Publication publication); double getExpectedCitations(); @Override boolean equals(Object other); void format(); @Override CyNode getCyNode(); String getDepartment(); String getFirstInitial(); String getFirstName(); String getInstitution(); List<String> getInstitutions(); @Override String getLabel(); String getLastName(); String getLocation(); String getMainInstitution(); @Override Map<String, Object> getNodeAttrMap(); int getOrigin(); List<String> getPubList(); int getTimesCited(); boolean hasAlreadyBeenAdded(); @Override int hashCode(); boolean isIdentified(); void prioritizeInstitution(Author author, Author otherAuthor); void setAlreadyBeenAdded(boolean alreadyBeenAdded); @Override void setCyNode(CyNode cyNode); void setDepartment(String department); void setFirstInitial(String firstInitial); void setFirstName(String firstName); @Override void setLabel(String label); void setLastName(String lastName); void setLocation(String location); void setMainInstitution(String mainInstitution); void setMiddleInitial(String middleInitial); @Override void setNodeAttrMap(Map<String, Object> attrMap); void setOrigin(int origin); void setPubList(List<String> pubList); void setTimesCited(int timesCited); @Override String toString(); }### Answer:
@Test public void testVerifyFirstNameA() { Author author1 = new Author("Kofia, Victro (UNIV TORONTO)", Category.INCITES); Author author2 = new Author("Kofia, Victor (UNIV TORONTO)", Category.INCITES); Author author3 = null; HashMap<Author, Author> authorMap = new HashMap<Author, Author>(); authorMap.put(author2, author2); boolean switched = true; author3 = authorMap.get(author1); if (author3 != null) { switched = !author3.getFirstName().equalsIgnoreCase(author2.getFirstName()); } assertTrue(!switched); }
@Test public void testVerifyFirstNameB() { Author author1 = new Author("Kofia, V (UNIV TORONTO)", Category.INCITES); Author author2 = new Author("Kofia, Victor (UNIV TORONTO)", Category.INCITES); Author author3 = null; HashMap<Author, Author> authorMap = new HashMap<Author, Author>(); authorMap.put(author2, author2); boolean switched = true; author3 = authorMap.get(author1); if (author3 != null) { switched = !author3.getFirstName().equalsIgnoreCase(author2.getFirstName()); } assertTrue(!switched); }
@Test public void testFixDefectiveFirstName() { Author author1 = new Author("Kofia, Victor (UNIV TORONTO)", Category.INCITES); Author author2 = new Author("Kofia, Vica (UNIV TORONTO)", Category.INCITES); Author check = null; HashMap<Author, Author> authorMap = new HashMap<Author, Author>(); authorMap.put(author2, author2); boolean fixed = false; check = authorMap.get(author1); if (check != null) { fixed = author2.getFirstName().equalsIgnoreCase(author1.getFirstName()); } assertTrue(fixed); }
@Test public void testFixFirstName() { Author author1 = new Author("Kofia, Victor (UNIV TORONTO)", Category.INCITES); Author author2 = new Author("Kofia, V (UNIV TORONTO)", Category.INCITES); Object check = null; HashMap<Author, Author> authorMap = new HashMap<Author, Author>(); authorMap.put(author2, author2); boolean switched = false; check = authorMap.get(author1); if (check != null) { switched = author2.getFirstName().equalsIgnoreCase(author1.getFirstName()); } assertTrue(switched); } |
### Question:
linkedList { public linkedList() { start = null; end = null; size = 0; } linkedList(); boolean isEmpty(); int getSize(); void insertAtStart(int val); void insertAtEnd(int val); void insertAtPos(int val , int pos); void deleteAtPos(int pos); void display(); public int size; }### Answer:
@Test public void testLinkedList(){ LinkedList<Integer> intList = new LinkedList<Integer>(); assertTrue(intList.add(1)); assertTrue(intList.add(2)); assertEquals(new Integer(1), intList.head()); assertEquals(new Integer(2), intList.tail()); assertTrue(intList.add(3)); assertEquals(new Integer(3), intList.tail()); assertEquals(3, intList.size()); assertFalse(intList.add(null)); assertTrue(intList.remove(new Integer(3))); assertFalse(intList.contains(new Integer(3))); assertEquals(2, intList.size()); assertTrue(intList.contains(new Integer(2))); assertFalse(intList.remove(new Integer(3))); } |
### Question:
DatabaseConnectionDialog { public void registerClass( String key, String className ) { extendedClasses.put( key, className ); } DatabaseConnectionDialog(); void registerClass( String key, String className ); XulDomContainer getSwtInstance( Shell shell ); XulDomContainer getSwtInstance( SwtXulLoader loader, Shell shell ); static final String DIALOG_DEFINITION_FILE; }### Answer:
@Test public void testRegisterClass() throws Exception { assertTrue( dialog.extendedClasses.isEmpty() ); dialog.registerClass( "MyClass", "org.pentaho.test.MyClass" ); assertFalse( dialog.extendedClasses.isEmpty() ); assertEquals( "org.pentaho.test.MyClass", dialog.extendedClasses.get( "MyClass" ) ); } |
### Question:
Utils { public static boolean isEmpty( CharSequence val ) { return val == null || val.length() == 0; } static int getDamerauLevenshteinDistance( String s, String t ); static boolean isEmpty( CharSequence val ); static boolean isEmpty( CharSequence[] strings ); static boolean isEmpty( Object[] array ); static boolean isEmpty( List<?> list ); static String resolvePassword( VariableSpace variables, String password ); static String[][] normalizeArrays( int normalizeToLength, String[]... arraysToNormalize ); static long[][] normalizeArrays( int normalizeToLength, long[]... arraysToNormalize ); static int[][] normalizeArrays( int normalizeToLength, int[]... arraysToNormalize ); static boolean[][] normalizeArrays( int normalizeToLength, boolean[]... arraysToNormalize ); static short[][] normalizeArrays( int normalizeToLength, short[]... arraysToNormalize ); }### Answer:
@Test public void testIsEmptyStringArray() { assertTrue( Utils.isEmpty( (String[]) null ) ); assertTrue( Utils.isEmpty( new String[] {} ) ); assertFalse( Utils.isEmpty( new String[] { "test" } ) ); }
@Test public void testIsEmptyObjectArray() { assertTrue( Utils.isEmpty( (Object[]) null ) ); assertTrue( Utils.isEmpty( new Object[] {} ) ); assertFalse( Utils.isEmpty( new Object[] { "test" } ) ); }
@Test public void testIsEmptyList() { assertTrue( Utils.isEmpty( (List<String>) null ) ); assertTrue( Utils.isEmpty( new ArrayList<String>() ) ); assertFalse( Utils.isEmpty( Arrays.asList( "test", 1 ) ) ); }
@Test public void testIsEmptyStringBuffer() { assertTrue( Utils.isEmpty( (StringBuffer) null ) ); assertTrue( Utils.isEmpty( new StringBuffer( "" ) ) ); assertFalse( Utils.isEmpty( new StringBuffer( "test" ) ) ); }
@Test public void testIsEmptyStringBuilder() { assertTrue( Utils.isEmpty( (StringBuilder) null ) ); assertTrue( Utils.isEmpty( new StringBuilder( "" ) ) ); assertFalse( Utils.isEmpty( new StringBuilder( "test" ) ) ); }
@Test public void testIsEmpty() { assertTrue( Utils.isEmpty( (String) null ) ); assertTrue( Utils.isEmpty( "" ) ); assertFalse( Utils.isEmpty( "test" ) ); } |
### Question:
Utils { public static String resolvePassword( VariableSpace variables, String password ) { String resolvedPassword = variables.environmentSubstitute( password ); if ( resolvedPassword != null ) { return Encr.decryptPasswordOptionallyEncrypted( resolvedPassword ); } else { return resolvedPassword; } } static int getDamerauLevenshteinDistance( String s, String t ); static boolean isEmpty( CharSequence val ); static boolean isEmpty( CharSequence[] strings ); static boolean isEmpty( Object[] array ); static boolean isEmpty( List<?> list ); static String resolvePassword( VariableSpace variables, String password ); static String[][] normalizeArrays( int normalizeToLength, String[]... arraysToNormalize ); static long[][] normalizeArrays( int normalizeToLength, long[]... arraysToNormalize ); static int[][] normalizeArrays( int normalizeToLength, int[]... arraysToNormalize ); static boolean[][] normalizeArrays( int normalizeToLength, boolean[]... arraysToNormalize ); static short[][] normalizeArrays( int normalizeToLength, short[]... arraysToNormalize ); }### Answer:
@Test public void testResolvePassword() { String password = "password"; assertSame( password, Utils.resolvePassword( Variables.getADefaultVariableSpace(), password ).intern() ); }
@Test public void testResolvePasswordEncrypted() { String decPassword = "password"; String encPassword = "Encrypted 2be98afc86aa7f2e4bb18bd63c99dbdde"; assertSame( decPassword, Utils.resolvePassword( Variables.getADefaultVariableSpace(), encPassword ).intern() ); }
@Test public void testResolvePasswordNull() { String password = null; assertSame( password, Utils.resolvePassword( Variables.getADefaultVariableSpace(), password ) ); }
@Test public void testResolvePasswordVariable() { String passwordKey = "PASS_VAR"; String passwordVar = "${" + passwordKey + "}"; String passwordValue = "password"; Variables vars = new Variables(); vars.setVariable( passwordKey, passwordValue ); assertSame( passwordValue, Utils.resolvePassword( vars, passwordVar ).intern() ); } |
### Question:
SessionConfigurator extends ClientEndpointConfig.Configurator { @Override public void beforeRequest( Map<String, List<String>> headers ) { if ( withAuth ) { Header authenticationHeader = getAuthenticationHeader( url ); if ( authenticationHeader != null ) { headers .put( authenticationHeader.getName(), Collections.singletonList( authenticationHeader.getValue() ) ); } } } SessionConfigurator( URI url, String keytab, String principal ); @Override void beforeRequest( Map<String, List<String>> headers ); @Override void afterResponse( HandshakeResponse hr ); }### Answer:
@Test public void testNoAuthentication() throws URISyntaxException { sessionConfigurator = new SessionConfigurator( new URI( "ws: sessionConfigurator.beforeRequest( headers ); verify( headers, times( 0 ) ).put( any(), any() ); }
@Test public void testPrincipal() throws URISyntaxException, RuntimeException { sessionConfigurator = new SessionConfigurator( new URI( "ws: expectedException.expect( RuntimeException.class ); sessionConfigurator.beforeRequest( headers ); }
@Test public void testPrincipalKeytab() throws URISyntaxException, RuntimeException { sessionConfigurator = new SessionConfigurator( new URI( "ws: expectedException.expect( RuntimeException.class ); sessionConfigurator.beforeRequest( headers ); } |
### Question:
DatabaseConnectionPoolParameter { public static final List<RowMetaAndData> getRowList( DatabaseConnectionPoolParameter[] poolParameters, String titleParameter, String titleDefaultValue, String titleDescription ) { RowMetaInterface rowMeta = new RowMeta(); rowMeta.addValueMeta( new ValueMetaString( titleParameter ) ); rowMeta.addValueMeta( new ValueMetaString( titleDefaultValue ) ); rowMeta.addValueMeta( new ValueMetaString( titleDescription ) ); List<RowMetaAndData> list = new ArrayList<RowMetaAndData>(); for ( int i = 0; i < poolParameters.length; i++ ) { DatabaseConnectionPoolParameter p = poolParameters[i]; Object[] row = new Object[rowMeta.size()]; row[0] = p.getParameter(); row[1] = p.getDefaultValue(); row[2] = p.getDescription(); list.add( new RowMetaAndData( rowMeta, row ) ); } return list; } DatabaseConnectionPoolParameter(); DatabaseConnectionPoolParameter( String parameter, String defaultValue, String description ); String getDefaultValue(); void setDefaultValue( String defaultValue ); String getDescription(); void setDescription( String description ); String getParameter(); void setParameter( String parameter ); static final String[] getParameterNames( DatabaseConnectionPoolParameter[] poolParameters ); static final DatabaseConnectionPoolParameter findParameter( String parameterName,
DatabaseConnectionPoolParameter[] poolParameters ); static final List<RowMetaAndData> getRowList( DatabaseConnectionPoolParameter[] poolParameters,
String titleParameter, String titleDefaultValue, String titleDescription ); }### Answer:
@Test public void testGetRowList() { List<RowMetaAndData> result = DatabaseConnectionPoolParameter.getRowList( BaseDatabaseMeta.poolingParameters, "myTitleParameter", "myTitleDefaultValue", "myTitleDescription" ); assertNotNull( result ); for ( RowMetaAndData rmd : result ) { assertEquals( 3, rmd.getRowMeta().size() ); assertEquals( "myTitleParameter", rmd.getRowMeta().getValueMeta( 0 ).getName() ); assertEquals( ValueMetaInterface.TYPE_STRING, rmd.getRowMeta().getValueMeta( 0 ).getType() ); assertEquals( "myTitleDefaultValue", rmd.getRowMeta().getValueMeta( 1 ).getName() ); assertEquals( ValueMetaInterface.TYPE_STRING, rmd.getRowMeta().getValueMeta( 1 ).getType() ); assertEquals( "myTitleDescription", rmd.getRowMeta().getValueMeta( 2 ).getName() ); assertEquals( ValueMetaInterface.TYPE_STRING, rmd.getRowMeta().getValueMeta( 2 ).getType() ); } } |
### Question:
DatabaseLogExceptionFactory { public static LogExceptionBehaviourInterface getExceptionStrategy( LogTableCoreInterface table ) { return getExceptionStrategy( table, null ); } static LogExceptionBehaviourInterface getExceptionStrategy( LogTableCoreInterface table ); static LogExceptionBehaviourInterface getExceptionStrategy( LogTableCoreInterface table, Exception e ); static final String KETTLE_GLOBAL_PROP_NAME; }### Answer:
@Test public void testGetExceptionStrategyWithoutException() { LogExceptionBehaviourInterface exceptionStrategy = DatabaseLogExceptionFactory.getExceptionStrategy( logTable ); String strategyName = exceptionStrategy.getClass().getName(); assertEquals( SUPPRESSABLE, strategyName ); }
@Test public void testGetExceptionStrategyWithoutExceptionPropSetY() { System.setProperty( DatabaseLogExceptionFactory.KETTLE_GLOBAL_PROP_NAME, PROPERTY_VALUE_TRUE ); LogExceptionBehaviourInterface exceptionStrategy = DatabaseLogExceptionFactory.getExceptionStrategy( logTable ); String strategyName = exceptionStrategy.getClass().getName(); assertEquals( THROWABLE, strategyName ); }
@Test public void testExceptionStrategyWithException() { LogExceptionBehaviourInterface exceptionStrategy = DatabaseLogExceptionFactory.getExceptionStrategy( logTable, new Exception() ); String strategyName = exceptionStrategy.getClass().getName(); assertEquals( SUPPRESSABLE, strategyName ); }
@Test public void testGetExceptionStrategyWithExceptionPropSetY() { System.setProperty( DatabaseLogExceptionFactory.KETTLE_GLOBAL_PROP_NAME, PROPERTY_VALUE_TRUE ); LogExceptionBehaviourInterface exceptionStrategy = DatabaseLogExceptionFactory.getExceptionStrategy( logTable, new Exception() ); String strategyName = exceptionStrategy.getClass().getName(); assertEquals( THROWABLE, strategyName ); }
@Test public void testExceptionStrategyWithPacketTooBigException() { DatabaseMeta databaseMeta = mock( DatabaseMeta.class ); DatabaseInterface databaseInterface = new MySQLDatabaseMeta(); PacketTooBigException e = new PacketTooBigException(); when( logTable.getDatabaseMeta() ).thenReturn( databaseMeta ); when( databaseMeta.getDatabaseInterface() ).thenReturn( databaseInterface ); LogExceptionBehaviourInterface exceptionStrategy = DatabaseLogExceptionFactory.getExceptionStrategy( logTable, new KettleDatabaseException( e ) ); String strategyName = exceptionStrategy.getClass().getName(); assertEquals( SUPPRESSABLE_WITH_SHORT_MESSAGE, strategyName ); }
@Test public void testExceptionStrategyWithMaxAllowedPacketException() { DatabaseMeta databaseMeta = mock( DatabaseMeta.class ); DatabaseInterface databaseInterface = new MariaDBDatabaseMeta(); MaxAllowedPacketException e = new MaxAllowedPacketException(); when( logTable.getDatabaseMeta() ).thenReturn( databaseMeta ); when( databaseMeta.getDatabaseInterface() ).thenReturn( databaseInterface ); LogExceptionBehaviourInterface exceptionStrategy = DatabaseLogExceptionFactory.getExceptionStrategy( logTable, new KettleDatabaseException( e ) ); String strategyName = exceptionStrategy.getClass().getName(); assertEquals( SUPPRESSABLE_WITH_SHORT_MESSAGE, strategyName ); }
@Test public void testExceptionStrategyWithMysqlDataTruncationException() { DatabaseMeta databaseMeta = mock( DatabaseMeta.class ); DatabaseInterface databaseInterface = new MySQLDatabaseMeta(); MysqlDataTruncation e = new MysqlDataTruncation(); when( logTable.getDatabaseMeta() ).thenReturn( databaseMeta ); when( databaseMeta.getDatabaseInterface() ).thenReturn( databaseInterface ); LogExceptionBehaviourInterface exceptionStrategy = DatabaseLogExceptionFactory.getExceptionStrategy( logTable, new KettleDatabaseException( e ) ); String strategyName = exceptionStrategy.getClass().getName(); assertEquals( SUPPRESSABLE_WITH_SHORT_MESSAGE, strategyName ); }
@Test public void testExceptionStrategyWithPacketTooBigExceptionPropSetY() { System.setProperty( DatabaseLogExceptionFactory.KETTLE_GLOBAL_PROP_NAME, PROPERTY_VALUE_TRUE ); DatabaseMeta databaseMeta = mock( DatabaseMeta.class ); DatabaseInterface databaseInterface = new MySQLDatabaseMeta(); PacketTooBigException e = new PacketTooBigException(); when( logTable.getDatabaseMeta() ).thenReturn( databaseMeta ); when( databaseMeta.getDatabaseInterface() ).thenReturn( databaseInterface ); LogExceptionBehaviourInterface exceptionStrategy = DatabaseLogExceptionFactory.getExceptionStrategy( logTable, new KettleDatabaseException( e ) ); String strategyName = exceptionStrategy.getClass().getName(); assertEquals( THROWABLE, strategyName ); } |
### Question:
DatabaseUtil implements DataSourceProviderInterface { @Override public DataSource getNamedDataSource( String datasourceName ) throws DataSourceNamingException { ClassLoader original = Thread.currentThread().getContextClassLoader(); try { Thread.currentThread().setContextClassLoader( getClass().getClassLoader() ); return DatabaseUtil.getDataSourceFromJndi( datasourceName, new InitialContext() ); } catch ( NamingException ex ) { throw new DataSourceNamingException( ex ); } finally { Thread.currentThread().setContextClassLoader( original ); } } static void closeSilently( Connection[] connections ); static void closeSilently( Connection conn ); static void closeSilently( Statement[] statements ); static void closeSilently( Statement st ); @Override DataSource getNamedDataSource( String datasourceName ); @Override DataSource getNamedDataSource( String datasourceName, DatasourceType type ); }### Answer:
@Test public void testCl() throws NamingException { DataSource dataSource = mock( DataSource.class ); when( context.lookup( testName ) ).thenReturn( dataSource ); DatabaseUtil util = new DatabaseUtil(); ClassLoader orig = Thread.currentThread().getContextClassLoader(); ClassLoader cl = mock( ClassLoader.class ); try { Thread.currentThread().setContextClassLoader( cl ); util.getNamedDataSource( testName ); } catch ( Exception ex ) { } finally { try { verify( cl, never() ).loadClass( anyString() ); verify( cl, never() ).getResource( anyString() ); verify( cl, never() ).getResourceAsStream( anyString() ); } catch ( Exception ex ) { } Thread.currentThread().setContextClassLoader( orig ); } } |
### Question:
RedshiftDatabaseMeta extends PostgreSQLDatabaseMeta { @Override public int getDefaultDatabasePort() { if ( getAccessType() == DatabaseMeta.TYPE_ACCESS_NATIVE ) { return 5439; } return -1; } RedshiftDatabaseMeta(); @Override int getDefaultDatabasePort(); @Override String getDriverClass(); @Override String getURL( String hostname, String port, String databaseName ); @Override String getExtraOptionsHelpText(); @Override boolean isFetchSizeSupported(); @Override boolean supportsSetMaxRows(); @Override String[] getUsedLibraries(); }### Answer:
@Test public void testGetDefaultDatabasePort() throws Exception { assertEquals( 5439, dbMeta.getDefaultDatabasePort() ); dbMeta.setAccessType( DatabaseMeta.TYPE_ACCESS_JNDI ); assertEquals( -1, dbMeta.getDefaultDatabasePort() ); } |
### Question:
RedshiftDatabaseMeta extends PostgreSQLDatabaseMeta { @Override public String getDriverClass() { if ( getAccessType() == DatabaseMeta.TYPE_ACCESS_ODBC ) { return "sun.jdbc.odbc.JdbcOdbcDriver"; } else { return "com.amazon.redshift.jdbc4.Driver"; } } RedshiftDatabaseMeta(); @Override int getDefaultDatabasePort(); @Override String getDriverClass(); @Override String getURL( String hostname, String port, String databaseName ); @Override String getExtraOptionsHelpText(); @Override boolean isFetchSizeSupported(); @Override boolean supportsSetMaxRows(); @Override String[] getUsedLibraries(); }### Answer:
@Test public void testGetDriverClass() throws Exception { assertEquals( "com.amazon.redshift.jdbc4.Driver", dbMeta.getDriverClass() ); dbMeta.setAccessType( DatabaseMeta.TYPE_ACCESS_ODBC ); assertEquals( "sun.jdbc.odbc.JdbcOdbcDriver", dbMeta.getDriverClass() ); } |
### Question:
MessageEventService { public final void addHandler( final Message eventType, final MessageEventHandler handler ) throws HandlerRegistrationException { if ( handler != null && eventType != null ) { addHandlerFor( eventType, handler ); } else { throw new HandlerRegistrationException( "One of the parameters is null : " + " eventType: " + eventType + " handler:" + handler ); } } MessageEventService(); void fireEvent( final Message event ); final void addHandler( final Message eventType, final MessageEventHandler handler ); final boolean hasHandlers( final Message eventType ); List<MessageEventHandler> getHandlersFor( final Message eventType ); }### Answer:
@Test( expected = HandlerRegistrationException.class ) public void testTranformationDuplicateAddHandler() throws KettleException { messageEventService.addHandler( transformationMessageEvent, messageEventHandler ); messageEventService.addHandler( transformationMessageEvent, messageEventHandler ); }
@Test( expected = HandlerRegistrationException.class ) public void testOperationDuplicateAddHandler() throws KettleException { messageEventService.addHandler( operationMessageEvent, messageEventHandler ); messageEventService.addHandler( operationMessageEvent, messageEventHandler ); }
@Test( expected = HandlerRegistrationException.class ) public void testMsgEventTypeNull() throws KettleException { messageEventService.addHandler( null, messageEventHandler ); }
@Test( expected = HandlerRegistrationException.class ) public void testMsgHandlerNull() throws KettleException { messageEventService.addHandler( operationMessageEvent, null ); }
@Test( expected = HandlerRegistrationException.class ) public void testbothNull() throws KettleException { messageEventService.addHandler( null, null ); } |
### Question:
RedshiftDatabaseMeta extends PostgreSQLDatabaseMeta { @Override public String getURL( String hostname, String port, String databaseName ) { if ( getAccessType() == DatabaseMeta.TYPE_ACCESS_ODBC ) { return "jdbc:odbc:" + databaseName; } else { return "jdbc:redshift: } } RedshiftDatabaseMeta(); @Override int getDefaultDatabasePort(); @Override String getDriverClass(); @Override String getURL( String hostname, String port, String databaseName ); @Override String getExtraOptionsHelpText(); @Override boolean isFetchSizeSupported(); @Override boolean supportsSetMaxRows(); @Override String[] getUsedLibraries(); }### Answer:
@Test public void testGetURL() throws Exception { assertEquals( "jdbc:redshift: assertEquals( "jdbc:redshift: dbMeta.getURL( "rs.pentaho.com", "4444", "myDB" ) ); dbMeta.setAccessType( DatabaseMeta.TYPE_ACCESS_ODBC ); assertEquals( "jdbc:odbc:myDB", dbMeta.getURL( null, "Not Null", "myDB" ) ); } |
### Question:
RedshiftDatabaseMeta extends PostgreSQLDatabaseMeta { @Override public String getExtraOptionsHelpText() { return "http: } RedshiftDatabaseMeta(); @Override int getDefaultDatabasePort(); @Override String getDriverClass(); @Override String getURL( String hostname, String port, String databaseName ); @Override String getExtraOptionsHelpText(); @Override boolean isFetchSizeSupported(); @Override boolean supportsSetMaxRows(); @Override String[] getUsedLibraries(); }### Answer:
@Test public void testGetExtraOptionsHelpText() throws Exception { assertEquals( "http: dbMeta.getExtraOptionsHelpText() ); } |
### Question:
RedshiftDatabaseMeta extends PostgreSQLDatabaseMeta { @Override public boolean isFetchSizeSupported() { return false; } RedshiftDatabaseMeta(); @Override int getDefaultDatabasePort(); @Override String getDriverClass(); @Override String getURL( String hostname, String port, String databaseName ); @Override String getExtraOptionsHelpText(); @Override boolean isFetchSizeSupported(); @Override boolean supportsSetMaxRows(); @Override String[] getUsedLibraries(); }### Answer:
@Test public void testIsFetchSizeSupported() throws Exception { assertFalse( dbMeta.isFetchSizeSupported() ); } |
### Question:
RedshiftDatabaseMeta extends PostgreSQLDatabaseMeta { @Override public boolean supportsSetMaxRows() { return false; } RedshiftDatabaseMeta(); @Override int getDefaultDatabasePort(); @Override String getDriverClass(); @Override String getURL( String hostname, String port, String databaseName ); @Override String getExtraOptionsHelpText(); @Override boolean isFetchSizeSupported(); @Override boolean supportsSetMaxRows(); @Override String[] getUsedLibraries(); }### Answer:
@Test public void testSupportsSetMaxRows() throws Exception { assertFalse( dbMeta.supportsSetMaxRows() ); } |
### Question:
RedshiftDatabaseMeta extends PostgreSQLDatabaseMeta { @Override public String[] getUsedLibraries() { return new String[] { "RedshiftJDBC4_1.0.10.1010.jar" }; } RedshiftDatabaseMeta(); @Override int getDefaultDatabasePort(); @Override String getDriverClass(); @Override String getURL( String hostname, String port, String databaseName ); @Override String getExtraOptionsHelpText(); @Override boolean isFetchSizeSupported(); @Override boolean supportsSetMaxRows(); @Override String[] getUsedLibraries(); }### Answer:
@Test public void testGetUsedLibraries() throws Exception { String[] libs = dbMeta.getUsedLibraries(); assertNotNull( libs ); assertEquals( 1, libs.length ); assertEquals( "RedshiftJDBC4_1.0.10.1010.jar", libs[0] ); } |
### Question:
MessageEventService { public final boolean hasHandlers( final Message eventType ) { return containsHandlerFor( eventType ); } MessageEventService(); void fireEvent( final Message event ); final void addHandler( final Message eventType, final MessageEventHandler handler ); final boolean hasHandlers( final Message eventType ); List<MessageEventHandler> getHandlersFor( final Message eventType ); }### Answer:
@Test public void testTransformationHasHandler() throws KettleException { addHandlers( transformationMessageEvent, messageEventHandler, messageEventHandler2 ); assertTrue( messageEventService.hasHandlers( transformationMessageEvent ) ); }
@Test public void testTransformationHasHandlerFalseTrans() throws KettleException { addHandlers( transformationMessageEvent, messageEventHandler, messageEventHandler2 ); assertFalse( messageEventService.hasHandlers( otherTransMessageEvent ) ); }
@Test public void testTransformationHasHandlerFalseOp() throws KettleException { addHandlers( transformationMessageEvent, messageEventHandler, messageEventHandler2 ); assertFalse( messageEventService.hasHandlers( otherOpMessageEvent ) ); }
@Test public void testOperationHasHandler() throws KettleException { addHandlers( operationMessageEvent, messageEventHandler, messageEventHandler2 ); assertTrue( messageEventService.hasHandlers( operationMessageEvent ) ); }
@Test public void testOperationHasHandlerFalseTrans() throws KettleException { addHandlers( operationMessageEvent, messageEventHandler, messageEventHandler2 ); assertFalse( messageEventService.hasHandlers( otherTransMessageEvent ) ); }
@Test public void testOperationHasHandlerFalseOp() throws KettleException { addHandlers( operationMessageEvent, messageEventHandler, messageEventHandler2 ); assertFalse( messageEventService.hasHandlers( otherOpMessageEvent ) ); } |
### Question:
ConnectionPoolUtil { public static Connection getConnection( LogChannelInterface log, DatabaseMeta dbMeta, String partitionId ) throws Exception { return getConnection( log, dbMeta, partitionId, dbMeta.getInitialPoolSize(), dbMeta.getMaximumPoolSize() ); } static Connection getConnection( LogChannelInterface log, DatabaseMeta dbMeta, String partitionId ); static Connection getConnection( LogChannelInterface log, DatabaseMeta dbMeta, String partitionId,
int initialSize, int maximumSize ); static final String DEFAULT_AUTO_COMMIT; static final String DEFAULT_READ_ONLY; static final String DEFAULT_TRANSACTION_ISOLATION; static final String DEFAULT_CATALOG; static final String INITIAL_SIZE; static final String MAX_ACTIVE; static final String MAX_IDLE; static final String MIN_IDLE; static final String MAX_WAIT; static final String VALIDATION_QUERY; static final String TEST_ON_BORROW; static final String TEST_ON_RETURN; static final String TEST_WHILE_IDLE; static final String TIME_BETWEEN_EVICTION_RUNS_MILLIS; static final String POOL_PREPARED_STATEMENTS; static final String MAX_OPEN_PREPARED_STATEMENTS; static final String ACCESS_TO_UNDERLYING_CONNECTION_ALLOWED; static final String REMOVE_ABANDONED; static final String REMOVE_ABANDONED_TIMEOUT; static final String LOG_ABANDONED; static final int defaultInitialNrOfConnections; static final int defaultMaximumNrOfConnections; }### Answer:
@Test public void testGetConnection() throws Exception { when( dbMeta.getName() ).thenReturn( "CP1" ); when( dbMeta.getPassword() ).thenReturn( PASSWORD ); Connection conn = ConnectionPoolUtil.getConnection( logChannelInterface, dbMeta, "", 1, 2 ); assertTrue( conn != null ); }
@Test public void testGetConnectionEncrypted() throws Exception { when( dbMeta.getName() ).thenReturn( "CP2" ); when( dbMeta.getPassword() ).thenReturn( ENCR_PASSWORD ); Connection conn = ConnectionPoolUtil.getConnection( logChannelInterface, dbMeta, "", 1, 2 ); assertTrue( conn != null ); } |
### Question:
ConnectionPoolUtil { protected static String buildPoolName( DatabaseMeta dbMeta, String partitionId ) { return dbMeta.getName() + Const.NVL( dbMeta.getDatabaseName(), "" ) + Const.NVL( dbMeta.getHostname(), "" ) + Const.NVL( dbMeta.getDatabasePortNumberString(), "" ) + Const.NVL( partitionId, "" ); } static Connection getConnection( LogChannelInterface log, DatabaseMeta dbMeta, String partitionId ); static Connection getConnection( LogChannelInterface log, DatabaseMeta dbMeta, String partitionId,
int initialSize, int maximumSize ); static final String DEFAULT_AUTO_COMMIT; static final String DEFAULT_READ_ONLY; static final String DEFAULT_TRANSACTION_ISOLATION; static final String DEFAULT_CATALOG; static final String INITIAL_SIZE; static final String MAX_ACTIVE; static final String MAX_IDLE; static final String MIN_IDLE; static final String MAX_WAIT; static final String VALIDATION_QUERY; static final String TEST_ON_BORROW; static final String TEST_ON_RETURN; static final String TEST_WHILE_IDLE; static final String TIME_BETWEEN_EVICTION_RUNS_MILLIS; static final String POOL_PREPARED_STATEMENTS; static final String MAX_OPEN_PREPARED_STATEMENTS; static final String ACCESS_TO_UNDERLYING_CONNECTION_ALLOWED; static final String REMOVE_ABANDONED; static final String REMOVE_ABANDONED_TIMEOUT; static final String LOG_ABANDONED; static final int defaultInitialNrOfConnections; static final int defaultMaximumNrOfConnections; }### Answer:
@Test public void testGetConnectionName() throws Exception { when( dbMeta.getName() ).thenReturn( "CP2" ); when( dbMeta.getPassword() ).thenReturn( ENCR_PASSWORD ); String connectionName = ConnectionPoolUtil.buildPoolName( dbMeta, "" ); assertTrue( connectionName.equals( "CP2" ) ); assertFalse( connectionName.equals( "CP2pentaho" ) ); when( dbMeta.getDatabaseName() ).thenReturn( "pentaho" ); connectionName = ConnectionPoolUtil.buildPoolName( dbMeta, "" ); assertTrue( connectionName.equals( "CP2pentaho" ) ); assertFalse( connectionName.equals( "CP2pentaholocal" ) ); when( dbMeta.getHostname() ).thenReturn( "local" ); connectionName = ConnectionPoolUtil.buildPoolName( dbMeta, "" ); assertTrue( connectionName.equals( "CP2pentaholocal" ) ); assertFalse( connectionName.equals( "CP2pentaholocal3306" ) ); when( dbMeta.getDatabasePortNumberString() ).thenReturn( "3306" ); connectionName = ConnectionPoolUtil.buildPoolName( dbMeta, "" ); assertTrue( connectionName.equals( "CP2pentaholocal3306" ) ); } |
### Question:
ConnectionPoolUtil { @VisibleForTesting static void configureDataSource( BasicDataSource ds, DatabaseMeta databaseMeta, String partitionId, int initialSize, int maximumSize ) throws KettleDatabaseException { Properties connectionPoolProperties = new Properties( databaseMeta.getConnectionPoolingProperties() ); connectionPoolProperties = environmentSubstitute( connectionPoolProperties, databaseMeta ); setPoolProperties( ds, connectionPoolProperties, initialSize, maximumSize ); setCredentials( ds, databaseMeta, partitionId ); String url = databaseMeta.environmentSubstitute( databaseMeta.getURL( partitionId ) ); ds.setUrl( url ); String clazz = databaseMeta.getDriverClass(); if ( databaseMeta.getDatabaseInterface() != null ) { ds.setDriverClassLoader( databaseMeta.getDatabaseInterface().getClass().getClassLoader() ); } ds.setDriverClassName( clazz ); } static Connection getConnection( LogChannelInterface log, DatabaseMeta dbMeta, String partitionId ); static Connection getConnection( LogChannelInterface log, DatabaseMeta dbMeta, String partitionId,
int initialSize, int maximumSize ); static final String DEFAULT_AUTO_COMMIT; static final String DEFAULT_READ_ONLY; static final String DEFAULT_TRANSACTION_ISOLATION; static final String DEFAULT_CATALOG; static final String INITIAL_SIZE; static final String MAX_ACTIVE; static final String MAX_IDLE; static final String MIN_IDLE; static final String MAX_WAIT; static final String VALIDATION_QUERY; static final String TEST_ON_BORROW; static final String TEST_ON_RETURN; static final String TEST_WHILE_IDLE; static final String TIME_BETWEEN_EVICTION_RUNS_MILLIS; static final String POOL_PREPARED_STATEMENTS; static final String MAX_OPEN_PREPARED_STATEMENTS; static final String ACCESS_TO_UNDERLYING_CONNECTION_ALLOWED; static final String REMOVE_ABANDONED; static final String REMOVE_ABANDONED_TIMEOUT; static final String LOG_ABANDONED; static final int defaultInitialNrOfConnections; static final int defaultMaximumNrOfConnections; }### Answer:
@Test public void testConfigureDataSource() throws KettleDatabaseException { when( dbMeta.getURL( "partId" ) ).thenReturn( "jdbc:foo: when( dbMeta.getUsername() ).thenReturn( "suzy" ); when( dbMeta.getPassword() ).thenReturn( "password" ); ConnectionPoolUtil.configureDataSource( dataSource, dbMeta, "partId", INITIAL_SIZE, MAX_SIZE ); verify( dataSource ).setDriverClassName( "org.pentaho.di.core.database.ConnectionPoolUtilTest" ); verify( dataSource ).setDriverClassLoader( any( ClassLoader.class ) ); verify( dataSource ).setUrl( "jdbc:foo: verify( dataSource ).addConnectionProperty( "user", "suzy" ); verify( dataSource ).addConnectionProperty( "password", "password" ); verify( dataSource ).setInitialSize( INITIAL_SIZE ); verify( dataSource ).setMaxActive( MAX_SIZE ); }
@Test public void testConfigureDataSourceWhenNoDatabaseInterface() throws KettleDatabaseException { when( dbMeta.getDatabaseInterface() ).thenReturn( null ); ConnectionPoolUtil.configureDataSource( dataSource, dbMeta, "partId", INITIAL_SIZE, MAX_SIZE ); verify( dataSource, never() ).setDriverClassLoader( any( ClassLoader.class ) ); } |
### Question:
HypersonicDatabaseMeta extends BaseDatabaseMeta implements DatabaseInterface { @Override public String getSQLSequenceExists( String sequenceName ) { return "SELECT * FROM INFORMATION_SCHEMA.SYSTEM_SEQUENCES WHERE SEQUENCE_NAME = '" + sequenceName + "'"; } @Override int[] getAccessTypeList(); @Override int getDefaultDatabasePort(); @Override String getDriverClass(); @Override String getURL( String hostname, String port, String databaseName ); @Override boolean supportsBitmapIndex(); @Override String getAddColumnStatement( String tablename, ValueMetaInterface v, String tk, boolean use_autoinc,
String pk, boolean semicolon ); @Override String getModifyColumnStatement( String tablename, ValueMetaInterface v, String tk, boolean use_autoinc,
String pk, boolean semicolon ); @Override String getFieldDefinition( ValueMetaInterface v, String tk, String pk, boolean use_autoinc,
boolean add_fieldname, boolean add_cr ); @Override String[] getUsedLibraries(); @Override String getExtraOptionsHelpText(); @Override String[] getReservedWords(); @Override boolean supportsSequences(); @Override String getSQLSequenceExists( String sequenceName ); @Override String getSQLListOfSequences(); @Override String getSQLCurrentSequenceValue( String sequenceName ); @Override String getSQLNextSequenceValue( String sequenceName ); }### Answer:
@Test public void testGetSQLSequenceExists() throws Exception { String sql = hypersonicDatabaseMeta.getSQLSequenceExists( sequenceName ); String expectedSql = "SELECT * FROM INFORMATION_SCHEMA.SYSTEM_SEQUENCES WHERE SEQUENCE_NAME = 'seQuence'"; assertEquals( expectedSql, sql ); sql = hypersonicDatabaseMetaQouting.getSQLSequenceExists( sequenceName ); assertEquals( expectedSql, sql ); sql = hypersonicDatabaseMetaUppercase.getSQLSequenceExists( sequenceName ); assertEquals( expectedSql, sql ); } |
### Question:
HypersonicDatabaseMeta extends BaseDatabaseMeta implements DatabaseInterface { @Override public String getSQLCurrentSequenceValue( String sequenceName ) { return "SELECT " + sequenceName + ".currval FROM INFORMATION_SCHEMA.SYSTEM_SEQUENCES WHERE SEQUENCE_NAME = '" + sequenceName + "'"; } @Override int[] getAccessTypeList(); @Override int getDefaultDatabasePort(); @Override String getDriverClass(); @Override String getURL( String hostname, String port, String databaseName ); @Override boolean supportsBitmapIndex(); @Override String getAddColumnStatement( String tablename, ValueMetaInterface v, String tk, boolean use_autoinc,
String pk, boolean semicolon ); @Override String getModifyColumnStatement( String tablename, ValueMetaInterface v, String tk, boolean use_autoinc,
String pk, boolean semicolon ); @Override String getFieldDefinition( ValueMetaInterface v, String tk, String pk, boolean use_autoinc,
boolean add_fieldname, boolean add_cr ); @Override String[] getUsedLibraries(); @Override String getExtraOptionsHelpText(); @Override String[] getReservedWords(); @Override boolean supportsSequences(); @Override String getSQLSequenceExists( String sequenceName ); @Override String getSQLListOfSequences(); @Override String getSQLCurrentSequenceValue( String sequenceName ); @Override String getSQLNextSequenceValue( String sequenceName ); }### Answer:
@Test public void testGetSQLCurrentSequenceValue() throws Exception { String sql = hypersonicDatabaseMeta.getSQLCurrentSequenceValue( sequenceName ); String expectedSql = "SELECT seQuence.currval FROM INFORMATION_SCHEMA.SYSTEM_SEQUENCES WHERE SEQUENCE_NAME = 'seQuence'"; assertEquals( expectedSql, sql ); sql = hypersonicDatabaseMetaQouting.getSQLCurrentSequenceValue( sequenceName ); assertEquals( expectedSql, sql ); sql = hypersonicDatabaseMetaUppercase.getSQLCurrentSequenceValue( sequenceName ); assertEquals( expectedSql, sql ); } |
### Question:
HypersonicDatabaseMeta extends BaseDatabaseMeta implements DatabaseInterface { @Override public String getSQLNextSequenceValue( String sequenceName ) { return "SELECT NEXT VALUE FOR " + sequenceName + " FROM INFORMATION_SCHEMA.SYSTEM_SEQUENCES WHERE SEQUENCE_NAME = '" + sequenceName + "'"; } @Override int[] getAccessTypeList(); @Override int getDefaultDatabasePort(); @Override String getDriverClass(); @Override String getURL( String hostname, String port, String databaseName ); @Override boolean supportsBitmapIndex(); @Override String getAddColumnStatement( String tablename, ValueMetaInterface v, String tk, boolean use_autoinc,
String pk, boolean semicolon ); @Override String getModifyColumnStatement( String tablename, ValueMetaInterface v, String tk, boolean use_autoinc,
String pk, boolean semicolon ); @Override String getFieldDefinition( ValueMetaInterface v, String tk, String pk, boolean use_autoinc,
boolean add_fieldname, boolean add_cr ); @Override String[] getUsedLibraries(); @Override String getExtraOptionsHelpText(); @Override String[] getReservedWords(); @Override boolean supportsSequences(); @Override String getSQLSequenceExists( String sequenceName ); @Override String getSQLListOfSequences(); @Override String getSQLCurrentSequenceValue( String sequenceName ); @Override String getSQLNextSequenceValue( String sequenceName ); }### Answer:
@Test public void testGetSQLNextSequenceValue() throws Exception { String sql = hypersonicDatabaseMeta.getSQLNextSequenceValue( sequenceName ); String expectedSql = "SELECT NEXT VALUE FOR seQuence FROM INFORMATION_SCHEMA.SYSTEM_SEQUENCES WHERE SEQUENCE_NAME = 'seQuence'"; assertEquals( expectedSql, sql ); sql = hypersonicDatabaseMetaQouting.getSQLNextSequenceValue( sequenceName ); assertEquals( expectedSql, sql ); sql = hypersonicDatabaseMetaUppercase.getSQLNextSequenceValue( sequenceName ); assertEquals( expectedSql, sql ); } |
### Question:
SqlCommentScrubber { public static String removeComments( String text ) { if ( text == null ) { return null; } StringBuilder queryWithoutComments = new StringBuilder(); boolean blkComment = false; boolean lineComment = false; boolean inString = false; StringReader buffer = new StringReader( text ); int ch; char currentStringChar = (char) QUOTE_CHARS[0]; boolean done = false; try { while ( !done ) { switch ( ch = buffer.read() ) { case EOF: { done = true; break; } case '\'': case '"': { if ( !lineComment && !blkComment ) { char cch = (char) ch; if ( inString ) { if ( currentStringChar == cch ) { inString = false; } } else { inString = true; currentStringChar = cch; } queryWithoutComments.append( cch ); } break; } case '/': { if ( !lineComment ) { ch = buffer.read(); if ( ( ch == '*' ) && ( !blkComment ) && ( !inString ) ) { ch = buffer.read(); if ( ch == '+' ) { queryWithoutComments.append( '/' ); queryWithoutComments.append( '*' ); queryWithoutComments.append( '+' ); } else { blkComment = true; } } else { if ( !blkComment ) { queryWithoutComments.append( '/' ); queryWithoutComments.append( (char) ch ); if ( inString && ( currentStringChar == (char) ch ) ) { inString = false; } } } } break; } case '*': { if ( blkComment ) { ch = buffer.read(); if ( ch == '/' ) { blkComment = false; } } else { if ( !lineComment ) { queryWithoutComments.append( '*' ); } } break; } case '-': { if ( !blkComment && !lineComment ) { ch = buffer.read(); if ( ch == '-' && !inString ) { lineComment = true; } else { queryWithoutComments.append( '-' ); queryWithoutComments.append( (char) ch ); if ( isQuoteChar( ch ) ) { char cch = (char) ch; if ( inString ) { if ( currentStringChar == cch ) { inString = false; } } else { inString = true; currentStringChar = cch; } } } } break; } case EOL: { if ( !blkComment && !lineComment ) { queryWithoutComments.append( (char) ch ); } lineComment = false; break; } default: { if ( !blkComment && !lineComment ) { queryWithoutComments.append( (char) ch ); } break; } } } } catch ( IOException e ) { } return queryWithoutComments.toString(); } private SqlCommentScrubber(); static String removeComments( String text ); static final int EOF; static final int EOL; }### Answer:
@Test public void testRemoveComments() throws Exception { Assert.assertEquals( expected, SqlCommentScrubber.removeComments( input ) ); } |
### Question:
InfobrightDatabaseMeta extends MySQLDatabaseMeta implements DatabaseInterface { @Override public int getDefaultDatabasePort() { if ( getAccessType() == DatabaseMeta.TYPE_ACCESS_NATIVE ) { return 5029; } return -1; } @Override int getDefaultDatabasePort(); @Override void addDefaultOptions(); }### Answer:
@Test public void mysqlTestOverrides() throws Exception { InfobrightDatabaseMeta idm = new InfobrightDatabaseMeta(); idm.setAccessType( DatabaseMeta.TYPE_ACCESS_NATIVE ); assertEquals( 5029, idm.getDefaultDatabasePort() ); idm.setAccessType( DatabaseMeta.TYPE_ACCESS_ODBC ); assertEquals( -1, idm.getDefaultDatabasePort() ); } |
### Question:
SvgSupport { public static boolean isSvgEnabled() { return true; } static boolean isSvgEnabled(); static SvgImage loadSvgImage( InputStream in ); static boolean isSvgName( String name ); static String toPngName( String name ); static boolean isPngName( String name ); static String toSvgName( String name ); }### Answer:
@Test public void testIsSvgEnabled() throws Exception { assertTrue( SvgSupport.isSvgEnabled() ); } |
### Question:
SvgSupport { public static SvgImage loadSvgImage( InputStream in ) throws Exception { Document document = getSvgFactory().createDocument( null, in ); return new SvgImage( document ); } static boolean isSvgEnabled(); static SvgImage loadSvgImage( InputStream in ); static boolean isSvgName( String name ); static String toPngName( String name ); static boolean isPngName( String name ); static String toSvgName( String name ); }### Answer:
@Test public void testLoadSvgImage() throws Exception { SvgImage image = SvgSupport.loadSvgImage( new ByteArrayInputStream( svgImage.getBytes() ) ); assertNotNull( image ); } |
### Question:
DataHandler extends AbstractXulEventHandler { public void getOptionHelp() { String message = null; DatabaseMeta database = new DatabaseMeta(); getInfo( database ); String url = database.getExtraOptionsHelpText(); if ( ( url == null ) || ( url.trim().length() == 0 ) ) { message = Messages.getString( "DataHandler.USER_NO_HELP_AVAILABLE" ); showMessage( message, false ); return; } Status status = Launch.openURL( url ); if ( status.equals( Status.Failed ) ) { message = Messages.getString( "DataHandler.USER_UNABLE_TO_LAUNCH_BROWSER", url ); showMessage( message, false ); } } DataHandler(); void loadConnectionData(); void loadAccessData(); void editOptions( int index ); void clearOptionsData(); void getOptionHelp(); void setDeckChildIndex(); void onPoolingCheck(); void onClusterCheck(); Object getData(); void setData( Object data ); void pushCache(); void popCache(); void onCancel(); void onOK(); void testDatabaseConnection(); void restoreDefaults(); void poolingRowChange( int idx ); void disablePortIfInstancePopulated(); void handleUseSecurityCheckbox(); static final SortedMap<String, DatabaseInterface> connectionMap; static final Map<String, String> connectionNametoID; }### Answer:
@Test public void testGetOptionHelp() throws Exception { when( accessBox.getSelectedItem() ).thenReturn( "JNDI" ); when( connectionBox.getSelectedItem() ).thenReturn( "PostgreSQL" ); dataHandler.getOptionHelp(); }
@Test( expected = RuntimeException.class ) public void testGetOptionHelpNoDatabase() throws Exception { when( accessBox.getSelectedItem() ).thenReturn( "JNDI" ); when( connectionBox.getSelectedItem() ).thenReturn( "MyDB" ); dataHandler.getOptionHelp(); } |
### Question:
SvgSupport { public static String toPngName( String name ) { if ( isSvgName( name ) ) { name = name.substring( 0, name.length() - 4 ) + PNG_EXTENSION; } return name; } static boolean isSvgEnabled(); static SvgImage loadSvgImage( InputStream in ); static boolean isSvgName( String name ); static String toPngName( String name ); static boolean isPngName( String name ); static String toSvgName( String name ); }### Answer:
@Test public void testToPngName() throws Exception { assertTrue( SvgSupport.isPngName( "my_file.png" ) ); assertTrue( SvgSupport.isPngName( "my_file.PNG" ) ); assertTrue( SvgSupport.isPngName( ".png" ) ); assertFalse( SvgSupport.isPngName( "png" ) ); assertFalse( SvgSupport.isPngName( "myFile.svg" ) ); assertEquals( "myFile.png", SvgSupport.toPngName( "myFile.svg" ) ); } |
### Question:
SvgSupport { public static String toSvgName( String name ) { if ( isPngName( name ) ) { name = name.substring( 0, name.length() - 4 ) + SVG_EXTENSION; } return name; } static boolean isSvgEnabled(); static SvgImage loadSvgImage( InputStream in ); static boolean isSvgName( String name ); static String toPngName( String name ); static boolean isPngName( String name ); static String toSvgName( String name ); }### Answer:
@Test public void testToSvgName() throws Exception { assertTrue( SvgSupport.isSvgName( "my_file.svg" ) ); assertTrue( SvgSupport.isSvgName( "my_file.SVG" ) ); assertTrue( SvgSupport.isSvgName( ".svg" ) ); assertFalse( SvgSupport.isSvgName( "svg" ) ); assertFalse( SvgSupport.isSvgName( "myFile.png" ) ); assertEquals( "myFile.svg", SvgSupport.toSvgName( "myFile.png" ) ); } |
### Question:
SvgImage { public Document getDocument() { return document; } protected SvgImage( Document doc ); Document getDocument(); }### Answer:
@Test public void testGetDocument() throws Exception { assertEquals( document, image.getDocument() ); } |
### Question:
LogMessage implements LogMessageInterface { @Override @Deprecated public String toString() { if ( message == null ) { return subject; } if ( arguments != null && arguments.length > 0 ) { return subject + " - " + MessageFormat.format( message, arguments ); } else { return subject + " - " + message; } } LogMessage( String subject, LogLevel level ); LogMessage( String message, String logChannelId, LogLevel level ); LogMessage( String message, String logChannelId, Object[] arguments, LogLevel level ); @Override @Deprecated String toString(); @Override LogLevel getLevel(); @Deprecated void setLevel( LogLevel level ); @Override String getMessage(); @Deprecated void setMessage( String message ); @Override String getSubject(); @Deprecated void setSubject( String subject ); @Override String getLogChannelId(); @Deprecated void setLogChannelId( String logChannelId ); @Override Object[] getArguments(); @Deprecated void setArguments( Object[] arguments ); boolean isError(); @Override String getCopy(); void setCopy( String copy ); }### Answer:
@Test public void testToString() throws Exception { LogMessage msg = new LogMessage( "Log message", "Channel 01", LogLevel.DEBUG ); msg.setSubject( "Simple" ); assertEquals( "Simple - Log message", msg.toString( ) ); } |
### Question:
KettleLogLayout { public String format( KettleLoggingEvent event ) { StringBuilder line = new StringBuilder(); String dateTimeString = ""; if ( timeAdded ) { dateTimeString = LOCAL_SIMPLE_DATE_PARSER.get().format( new Date( event.timeStamp ) ) + " - "; } Object object = event.getMessage(); if ( object instanceof LogMessage ) { LogMessage message = (LogMessage) object; String[] parts = message.getMessage() == null ? new String[] {} : message.getMessage().split( Const.CR ); for ( int i = 0; i < parts.length; i++ ) { line.append( dateTimeString ); if ( message.getSubject() != null ) { line.append( message.getSubject() ); if ( message.getCopy() != null ) { line.append( "." ).append( message.getCopy() ); } line.append( " - " ); } if ( i == 0 && message.isError() ) { BuildVersion buildVersion = BuildVersion.getInstance(); line.append( ERROR_STRING ); line.append( " (version " ); line.append( buildVersion.getVersion() ); if ( !Utils.isEmpty( buildVersion.getRevision() ) ) { line.append( ", build " ); line.append( buildVersion.getRevision() ); } if ( !Utils.isEmpty( buildVersion.getBuildDate() ) ) { line.append( " from " ); line.append( buildVersion.getBuildDate() ); } if ( !Utils.isEmpty( buildVersion.getBuildUser() ) ) { line.append( " by " ); line.append( buildVersion.getBuildUser() ); } line.append( ") : " ); } line.append( parts[i] ); if ( i < parts.length - 1 ) { line.append( Const.CR ); } } } else { line.append( dateTimeString ); line.append( ( object != null ? object.toString() : "<null>" ) ); } return line.toString(); } KettleLogLayout(); KettleLogLayout( boolean addTime ); String format( KettleLoggingEvent event ); boolean ignoresThrowable(); void activateOptions(); boolean isTimeAdded(); void setTimeAdded( boolean addTime ); static final String ERROR_STRING; }### Answer:
@Test public void testFormat() throws Exception { LogMessage mcg = new LogMessage( "Log message for {0}", "Channel 01", new String[]{ "Test" }, LogLevel.DEBUG ); mcg.setSubject( "Subject" ); KettleLoggingEvent event = new KettleLoggingEvent( mcg, 0, LogLevel.BASIC ); KettleLogLayout layout = new KettleLogLayout(); final String formattedMsg = layout.format( event ); Assert.assertEquals( "The log message must be formatted and not contain placeholders.", "Subject - Log message for Test", formattedMsg.substring( formattedMsg.indexOf( '-' ) + 2 ) ); } |
### Question:
LoggingObject implements LoggingObjectInterface { @Override public boolean equals( Object obj ) { if ( !( obj instanceof LoggingObject ) ) { return false; } if ( obj == this ) { return true; } try { LoggingObject loggingObject = (LoggingObject) obj; boolean sameCarteFamily = ( getContainerObjectId() == null && loggingObject.getContainerObjectId() == null ) || ( getContainerObjectId() != null && loggingObject.getContainerObjectId() != null && getContainerObjectId() .equals( loggingObject.getContainerObjectId() ) ); if ( sameCarteFamily && loggingObject.getObjectId() != null && loggingObject.getObjectId().equals( getObjectId() ) ) { return true; } boolean sameParents = loggingObject.getParent() == null && this.getParent() == null || loggingObject.getParent() != null && this.getParent() != null && loggingObject.getParent().equals( this.getParent() ); if ( sameCarteFamily && !Utils.isEmpty( loggingObject.getFilename() ) && loggingObject.getFilename().equals( getFilename() ) && sameParents && StringUtils.equals( loggingObject.getObjectName(), getObjectName() ) ) { return true; } if ( !sameCarteFamily || ( loggingObject.getObjectName() == null && getObjectName() != null ) || ( loggingObject.getObjectName() != null && getObjectName() == null ) ) { return false; } if ( sameCarteFamily && ( ( loggingObject.getObjectName() == null && getObjectName() == null ) || ( loggingObject .getObjectName().equals( getObjectName() ) ) ) && loggingObject.getObjectType().equals( getObjectType() ) ) { if ( !Utils.isEmpty( getObjectCopy() ) && !getObjectCopy().equals( loggingObject.getObjectCopy() ) ) { return false; } LoggingObjectInterface parent1 = loggingObject.getParent(); LoggingObjectInterface parent2 = getParent(); if ( ( parent1 != null && parent2 == null ) || ( parent1 == null && parent2 != null ) ) { return false; } if ( parent1 == null && parent2 == null ) { return true; } if ( parent1.equals( parent2 ) ) { return true; } } } catch ( Exception e ) { e.printStackTrace(); } return false; } LoggingObject( Object object ); @Override boolean equals( Object obj ); @Override String getObjectName(); void setObjectName( String name ); @Override RepositoryDirectoryInterface getRepositoryDirectory(); void setRepositoryDirectory( RepositoryDirectory repositoryDirectory ); @Override String getFilename(); void setFilename( String filename ); @Override ObjectId getObjectId(); void setObjectId( ObjectId objectId ); @Override ObjectRevision getObjectRevision(); void setObjectRevision( ObjectRevision objectRevision ); @Override String getLogChannelId(); void setLogChannelId( String logChannelId ); @Override LoggingObjectInterface getParent(); void setParent( LoggingObjectInterface parent ); @Override LoggingObjectType getObjectType(); void setObjectType( LoggingObjectType objectType ); @Override String getObjectCopy(); void setObjectCopy( String objectCopy ); @Override LogLevel getLogLevel(); void setLogLevel( LogLevel logLevel ); @Override String getContainerObjectId(); void setCarteObjectId( String carteObjectId ); @Override Date getRegistrationDate(); void setRegistrationDate( Date registrationDate ); @Override boolean isGatheringMetrics(); @Override void setGatheringMetrics( boolean gatheringMetrics ); @Override boolean isForcingSeparateLogging(); @Override void setForcingSeparateLogging( boolean forcingSeparateLogging ); }### Answer:
@Test public void testEquals() throws Exception { LoggingObjectInterface parent = new LoggingObject( new SimpleLoggingObject( "parent", LoggingObjectType.JOB, null ) ); LoggingObject loggingObject1 = new LoggingObject( "test" ); loggingObject1.setFilename( "fileName" ); loggingObject1.setParent( parent ); loggingObject1.setObjectName( "job1" ); LoggingObject loggingObject2 = new LoggingObject( "test" ); loggingObject2.setFilename( "fileName" ); loggingObject2.setParent( parent ); loggingObject2.setObjectName( "job2" ); Assert.assertFalse( loggingObject1.equals( loggingObject2 ) ); } |
### Question:
MetricsRegistry { public Map<String, Queue<MetricsSnapshotInterface>> getSnapshotLists() { return snapshotLists; } private MetricsRegistry(); static MetricsRegistry getInstance(); void addSnapshot( LogChannelInterface logChannel, MetricsSnapshotInterface snapshot ); Map<String, Queue<MetricsSnapshotInterface>> getSnapshotLists(); Map<String, Map<String, MetricsSnapshotInterface>> getSnapshotMaps(); Queue<MetricsSnapshotInterface> getSnapshotList( String logChannelId ); Map<String, MetricsSnapshotInterface> getSnapshotMap( String logChannelId ); }### Answer:
@Test( timeout = 2000 ) public void testConcurrencySnap() throws Exception { ExecutorService service = Executors.newFixedThreadPool( threadCount ); for ( int i = 0; i < threadCount; i++ ) { service.submit( new ConcurrentPutIfAbsent( logIds.get( i % 20 ) ) ); } countDownLatch.countDown(); service.shutdown(); while ( !service.isTerminated() ) { Thread.currentThread().sleep( 1 ); } int expectedQueueCount = logChannelIdCount > threadCount ? threadCount : logChannelIdCount; assertTrue( expectedQueueCount == metricsRegistry.getSnapshotLists().size() ); } |
### Question:
JndiUtil { public static void initJNDI() throws KettleException { String path = Const.JNDI_DIRECTORY; if ( path == null || path.equals( "" ) ) { try { File file = new File( "simple-jndi" ); path = file.getCanonicalPath(); } catch ( Exception e ) { throw new KettleException( "Error initializing JNDI", e ); } Const.JNDI_DIRECTORY = path; } System.setProperty( "java.naming.factory.initial", "org.osjava.sj.SimpleContextFactory" ); System.setProperty( "org.osjava.sj.root", path ); System.setProperty( "org.osjava.sj.delimiter", "/" ); } static void initJNDI(); }### Answer:
@Test public void testInitJNDI() throws Exception { final String factoryInitialKey = "java.naming.factory.initial"; final String factoryInitialBak = System.getProperty( factoryInitialKey ); final String sjRootKey = "org.osjava.sj.root"; final String sjRootBak = System.getProperty( sjRootKey ); final String sjDelimiterKey = "org.osjava.sj.root"; final String sjDelimiterBak = System.getProperty( sjDelimiterKey ); System.clearProperty( factoryInitialKey ); System.clearProperty( sjRootKey ); System.clearProperty( sjDelimiterKey ); JndiUtil.initJNDI(); try { assertFalse( System.getProperty( factoryInitialKey ).isEmpty() ); assertFalse( System.getProperty( sjRootKey ).isEmpty() ); assertFalse( System.getProperty( sjDelimiterKey ).isEmpty() ); assertEquals( System.getProperty( sjRootKey ), Const.JNDI_DIRECTORY ); } finally { if ( factoryInitialBak != null ) { System.setProperty( factoryInitialKey, factoryInitialBak ); } if ( sjRootBak != null ) { System.setProperty( sjRootKey, sjRootBak ); } if ( sjDelimiterBak != null ) { System.setProperty( sjDelimiterKey, sjDelimiterBak ); } } } |
### Question:
ExtensionPointMap { public void addExtensionPoint( PluginInterface extensionPointPlugin ) { lock.writeLock().lock(); try { for ( String id : extensionPointPlugin.getIds() ) { extensionPointPluginMap.put( extensionPointPlugin.getName(), id, createLazyLoader( extensionPointPlugin ) ); } } finally { lock.writeLock().unlock(); } } private ExtensionPointMap( PluginRegistry pluginRegistry ); static ExtensionPointMap getInstance(); void addExtensionPoint( PluginInterface extensionPointPlugin ); void removeExtensionPoint( PluginInterface extensionPointPlugin ); void reInitialize(); void callExtensionPoint( LogChannelInterface log, String id, Object object ); static LogChannelInterface getLog(); }### Answer:
@Test public void addExtensionPointTest() throws KettlePluginException { ExtensionPointMap.getInstance().addExtensionPoint( pluginInterface ); assertEquals( ExtensionPointMap.getInstance().getTableValue( TEST_NAME, "testID" ), extensionPoint ); assertEquals( ExtensionPointMap.getInstance().getTableValue( TEST_NAME, "testID" ), extensionPoint ); verify( pluginInterface, times( 1 ) ).loadClass( any( Class.class ) ); } |
### Question:
ExtensionPointHandler { public static void callExtensionPoint( final LogChannelInterface log, final String id, final Object object ) throws KettleException { ExtensionPointMap.getInstance().callExtensionPoint( log, id, object ); } static void callExtensionPoint( final LogChannelInterface log, final String id, final Object object ); }### Answer:
@Test public void callExtensionPointTest() throws Exception { PluginMockInterface pluginInterface = mock( PluginMockInterface.class ); when( pluginInterface.getName() ).thenReturn( TEST_NAME ); when( pluginInterface.getMainType() ).thenReturn( (Class) ExtensionPointInterface.class ); when( pluginInterface.getIds() ).thenReturn( new String[] {"testID"} ); ExtensionPointInterface extensionPoint = mock( ExtensionPointInterface.class ); when( pluginInterface.loadClass( ExtensionPointInterface.class ) ).thenReturn( extensionPoint ); PluginRegistry.addPluginType( ExtensionPointPluginType.getInstance() ); PluginRegistry.getInstance().registerPlugin( ExtensionPointPluginType.class, pluginInterface ); final LogChannelInterface log = mock( LogChannelInterface.class ); ExtensionPointHandler.callExtensionPoint( log, "noPoint", null ); verify( extensionPoint, never() ).callExtensionPoint( any( LogChannelInterface.class ), any() ); ExtensionPointHandler.callExtensionPoint( log, TEST_NAME, null ); verify( extensionPoint, times( 1 ) ).callExtensionPoint( eq( log ), isNull() ); } |
### Question:
Encr { public static final String encryptPassword( String password ) { return encoder.encode( password, false ); } Encr(); @Deprecated boolean init(); static void init( String encoderPluginId ); @Deprecated static final boolean checkSignatureShort( String signature, String verify ); @Deprecated static final String getSignatureShort( String signature ); static final String encryptPassword( String password ); static final String decryptPassword( String encrypted ); static final String encryptPasswordIfNotUsingVariables( String password ); static final String decryptPasswordOptionallyEncrypted( String password ); static void main( String[] args ); static final String PASSWORD_ENCRYPTED_PREFIX; }### Answer:
@Test public void testEncryptPassword() throws KettleValueException { String encryption; encryption = Encr.encryptPassword( null ); assertTrue( "".equals( encryption ) ); encryption = Encr.encryptPassword( "" ); assertTrue( "".equals( encryption ) ); encryption = Encr.encryptPassword( " " ); assertTrue( "2be98afc86aa7f2e4cb79ce309ed2ef9a".equals( encryption ) ); encryption = Encr.encryptPassword( "Test of different encryptions!!@#$%" ); assertTrue( "54657374206f6620646966666572656e742067d0fbddb11ad39b8ba50aef31fed1eb9f".equals( encryption ) ); encryption = Encr.encryptPassword( " Spaces left" ); assertTrue( "2be98afe84af48285a81cbd30d297a9ce".equals( encryption ) ); encryption = Encr.encryptPassword( "Spaces right" ); assertTrue( "2be98afc839d79387ae0aee62d795a7ce".equals( encryption ) ); encryption = Encr.encryptPassword( " Spaces " ); assertTrue( "2be98afe84a87d2c49809af73db81ef9a".equals( encryption ) ); encryption = Encr.encryptPassword( "1234567890" ); assertTrue( "2be98afc86aa7c3d6f84dfb2689caf68a".equals( encryption ) ); }
@Test public void testEncryptPassword() throws HopValueException { String encryption; encryption = Encr.encryptPassword( null ); assertTrue( "".equals( encryption ) ); encryption = Encr.encryptPassword( "" ); assertTrue( "".equals( encryption ) ); encryption = Encr.encryptPassword( " " ); assertTrue( "2be98afc86aa7f2e4cb79ce309ed2ef9a".equals( encryption ) ); encryption = Encr.encryptPassword( "Test of different encryptions!!@#$%" ); assertTrue( "54657374206f6620646966666572656e742067d0fbddb11ad39b8ba50aef31fed1eb9f".equals( encryption ) ); encryption = Encr.encryptPassword( " Spaces left" ); assertTrue( "2be98afe84af48285a81cbd30d297a9ce".equals( encryption ) ); encryption = Encr.encryptPassword( "Spaces right" ); assertTrue( "2be98afc839d79387ae0aee62d795a7ce".equals( encryption ) ); encryption = Encr.encryptPassword( " Spaces " ); assertTrue( "2be98afe84a87d2c49809af73db81ef9a".equals( encryption ) ); encryption = Encr.encryptPassword( "1234567890" ); assertTrue( "2be98afc86aa7c3d6f84dfb2689caf68a".equals( encryption ) ); } |
### Question:
Encr { public static final String decryptPassword( String encrypted ) { return encoder.decode( encrypted ); } Encr(); @Deprecated boolean init(); static void init( String encoderPluginId ); @Deprecated static final boolean checkSignatureShort( String signature, String verify ); @Deprecated static final String getSignatureShort( String signature ); static final String encryptPassword( String password ); static final String decryptPassword( String encrypted ); static final String encryptPasswordIfNotUsingVariables( String password ); static final String decryptPasswordOptionallyEncrypted( String password ); static void main( String[] args ); static final String PASSWORD_ENCRYPTED_PREFIX; }### Answer:
@Test public void testDecryptPassword() throws KettleValueException { String encryption; String decryption; encryption = Encr.encryptPassword( null ); decryption = Encr.decryptPassword( encryption ); assertTrue( "".equals( decryption ) ); encryption = Encr.encryptPassword( "" ); decryption = Encr.decryptPassword( encryption ); assertTrue( "".equals( decryption ) ); encryption = Encr.encryptPassword( " " ); decryption = Encr.decryptPassword( encryption ); assertTrue( " ".equals( decryption ) ); encryption = Encr.encryptPassword( "Test of different encryptions!!@#$%" ); decryption = Encr.decryptPassword( encryption ); assertTrue( "Test of different encryptions!!@#$%".equals( decryption ) ); encryption = Encr.encryptPassword( " Spaces left" ); decryption = Encr.decryptPassword( encryption ); assertTrue( " Spaces left".equals( decryption ) ); encryption = Encr.encryptPassword( "Spaces right" ); decryption = Encr.decryptPassword( encryption ); assertTrue( "Spaces right".equals( decryption ) ); encryption = Encr.encryptPassword( " Spaces " ); decryption = Encr.decryptPassword( encryption ); assertTrue( " Spaces ".equals( decryption ) ); encryption = Encr.encryptPassword( "1234567890" ); decryption = Encr.decryptPassword( encryption ); assertTrue( "1234567890".equals( decryption ) ); }
@Test public void testDecryptPassword() throws HopValueException { String encryption; String decryption; encryption = Encr.encryptPassword( null ); decryption = Encr.decryptPassword( encryption ); assertTrue( "".equals( decryption ) ); encryption = Encr.encryptPassword( "" ); decryption = Encr.decryptPassword( encryption ); assertTrue( "".equals( decryption ) ); encryption = Encr.encryptPassword( " " ); decryption = Encr.decryptPassword( encryption ); assertTrue( " ".equals( decryption ) ); encryption = Encr.encryptPassword( "Test of different encryptions!!@#$%" ); decryption = Encr.decryptPassword( encryption ); assertTrue( "Test of different encryptions!!@#$%".equals( decryption ) ); encryption = Encr.encryptPassword( " Spaces left" ); decryption = Encr.decryptPassword( encryption ); assertTrue( " Spaces left".equals( decryption ) ); encryption = Encr.encryptPassword( "Spaces right" ); decryption = Encr.decryptPassword( encryption ); assertTrue( "Spaces right".equals( decryption ) ); encryption = Encr.encryptPassword( " Spaces " ); decryption = Encr.decryptPassword( encryption ); assertTrue( " Spaces ".equals( decryption ) ); encryption = Encr.encryptPassword( "1234567890" ); decryption = Encr.decryptPassword( encryption ); assertTrue( "1234567890".equals( decryption ) ); } |
### Question:
Encr { public static final String encryptPasswordIfNotUsingVariables( String password ) { return encoder.encode( password, true ); } Encr(); @Deprecated boolean init(); static void init( String encoderPluginId ); @Deprecated static final boolean checkSignatureShort( String signature, String verify ); @Deprecated static final String getSignatureShort( String signature ); static final String encryptPassword( String password ); static final String decryptPassword( String encrypted ); static final String encryptPasswordIfNotUsingVariables( String password ); static final String decryptPasswordOptionallyEncrypted( String password ); static void main( String[] args ); static final String PASSWORD_ENCRYPTED_PREFIX; }### Answer:
@Test public void testEncryptPasswordIfNotUsingVariables() throws KettleValueException { String encryption; encryption = Encr.encryptPasswordIfNotUsingVariables( null ); assertTrue( "Encrypted ".equals( encryption ) ); encryption = Encr.encryptPasswordIfNotUsingVariables( "" ); assertTrue( "Encrypted ".equals( encryption ) ); encryption = Encr.encryptPasswordIfNotUsingVariables( "String" ); assertTrue( "Encrypted 2be98afc86aa7f2e4cb799d64cc9ba1dd".equals( encryption ) ); encryption = Encr.encryptPasswordIfNotUsingVariables( " ${VAR} String" ); assertTrue( " ${VAR} String".equals( encryption ) ); encryption = Encr.encryptPasswordIfNotUsingVariables( " %%VAR%% String" ); assertTrue( " %%VAR%% String".equals( encryption ) ); encryption = Encr.encryptPasswordIfNotUsingVariables( " %% VAR String" ); assertTrue( "Encrypted 2be988fed4f87a4a599599d64cc9ba1dd".equals( encryption ) ); encryption = Encr.encryptPasswordIfNotUsingVariables( "${%%$$$$" ); assertTrue( "Encrypted 2be98afc86aa7f2e4ef02eb359ad6eb9e".equals( encryption ) ); }
@Test public void testEncryptPasswordIfNotUsingVariables() throws HopValueException { String encryption; encryption = Encr.encryptPasswordIfNotUsingVariables( null ); assertTrue( "Encrypted ".equals( encryption ) ); encryption = Encr.encryptPasswordIfNotUsingVariables( "" ); assertTrue( "Encrypted ".equals( encryption ) ); encryption = Encr.encryptPasswordIfNotUsingVariables( "String" ); assertTrue( "Encrypted 2be98afc86aa7f2e4cb799d64cc9ba1dd".equals( encryption ) ); encryption = Encr.encryptPasswordIfNotUsingVariables( " ${VAR} String" ); assertTrue( " ${VAR} String".equals( encryption ) ); encryption = Encr.encryptPasswordIfNotUsingVariables( " %%VAR%% String" ); assertTrue( " %%VAR%% String".equals( encryption ) ); encryption = Encr.encryptPasswordIfNotUsingVariables( " %% VAR String" ); assertTrue( "Encrypted 2be988fed4f87a4a599599d64cc9ba1dd".equals( encryption ) ); encryption = Encr.encryptPasswordIfNotUsingVariables( "${%%$$$$" ); assertTrue( "Encrypted 2be98afc86aa7f2e4ef02eb359ad6eb9e".equals( encryption ) ); } |
### Question:
CertificateGenEncryptUtil { public static Key generateSingleKey() throws NoSuchAlgorithmException { Key key = KeyGenerator.getInstance( SINGLE_KEY_ALGORITHM ).generateKey(); return key; } static KeyPair generateKeyPair(); static Key generateSingleKey(); static byte[] encodeKeyForTransmission( Key encodingKey, Key keyToEncode ); static Key decodeTransmittedKey( byte[] sessionKey, byte[] transmittedKey, boolean privateKey ); static Cipher initDecryptionCipher( Key unwrappedKey, byte[] unencryptedKey ); static byte[] encryptUsingKey( byte[] data, Key key ); static byte[] decryptUsingKey( byte[] data, Key key ); static final int KEY_SIZE; static final String PUBLIC_KEY_ALGORITHM; static final String SINGLE_KEY_ALGORITHM; static final String TRANSMISSION_CIPHER_PARAMS; }### Answer:
@Test public void testRandomSessionKeyGeneration() throws Exception { Key key = CertificateGenEncryptUtil.generateSingleKey(); Key key1 = CertificateGenEncryptUtil.generateSingleKey(); assertFalse( key.equals( key1 ) ); assertFalse( Arrays.equals( key.getEncoded(), key1.getEncoded() ) ); } |
### Question:
KettleTwoWayPasswordEncoder implements TwoWayPasswordEncoderInterface { @Override public String encode( String rawPassword ) { return encode( rawPassword, true ); } KettleTwoWayPasswordEncoder(); @Override void init(); @Override String encode( String rawPassword ); @Override String encode( String rawPassword, boolean includePrefix ); @Override String decode( String encodedPassword ); @Override String decode( String encodedPassword, boolean optionallyEncrypted ); @Override String[] getPrefixes(); static final String encryptPasswordIfNotUsingVariables( String password ); static final String decryptPasswordOptionallyEncrypted( String password ); static final String encryptPassword( String password ); static final String decryptPassword( String encrypted ); static final String PASSWORD_ENCRYPTED_PREFIX; }### Answer:
@Test public void testEncode1() throws KettleValueException { KettleTwoWayPasswordEncoder encoder = new KettleTwoWayPasswordEncoder(); String encryption; encryption = encoder.encode( null, false ); assertTrue( "".equals( encryption ) ); encryption = encoder.encode( "", false ); assertTrue( "".equals( encryption ) ); encryption = encoder.encode( " ", false ); assertTrue( "2be98afc86aa7f2e4cb79ce309ed2ef9a".equals( encryption ) ); encryption = encoder.encode( "Test of different encryptions!!@#$%", false ); assertTrue( "54657374206f6620646966666572656e742067d0fbddb11ad39b8ba50aef31fed1eb9f".equals( encryption ) ); encryption = encoder.encode( " Spaces left", false ); assertTrue( "2be98afe84af48285a81cbd30d297a9ce".equals( encryption ) ); encryption = encoder.encode( "Spaces right", false ); assertTrue( "2be98afc839d79387ae0aee62d795a7ce".equals( encryption ) ); encryption = encoder.encode( " Spaces ", false ); assertTrue( "2be98afe84a87d2c49809af73db81ef9a".equals( encryption ) ); encryption = encoder.encode( "1234567890", false ); assertTrue( "2be98afc86aa7c3d6f84dfb2689caf68a".equals( encryption ) ); }
@Test public void testEncode2() throws KettleValueException { KettleTwoWayPasswordEncoder encoder = new KettleTwoWayPasswordEncoder(); String encryption; encryption = encoder.encode( null ); assertTrue( "Encrypted ".equals( encryption ) ); encryption = encoder.encode( "" ); assertTrue( "Encrypted ".equals( encryption ) ); encryption = encoder.encode( "String" ); assertTrue( "Encrypted 2be98afc86aa7f2e4cb799d64cc9ba1dd".equals( encryption ) ); encryption = encoder.encode( " ${VAR} String" ); assertTrue( " ${VAR} String".equals( encryption ) ); encryption = encoder.encode( " %%VAR%% String" ); assertTrue( " %%VAR%% String".equals( encryption ) ); encryption = encoder.encode( " %% VAR String" ); assertTrue( "Encrypted 2be988fed4f87a4a599599d64cc9ba1dd".equals( encryption ) ); encryption = encoder.encode( "${%%$$$$" ); assertTrue( "Encrypted 2be98afc86aa7f2e4ef02eb359ad6eb9e".equals( encryption ) ); } |
### Question:
QueueRowSet extends BaseRowSet implements Comparable<RowSet>, RowSet { @Override public boolean putRow( RowMetaInterface rowMeta, Object[] rowData ) { this.rowMeta = rowMeta; buffer.add( rowData ); return true; } QueueRowSet(); @Override Object[] getRow(); @Override Object[] getRowImmediate(); @Override Object[] getRowWait( long timeout, TimeUnit tu ); @Override boolean putRow( RowMetaInterface rowMeta, Object[] rowData ); @Override boolean putRowWait( RowMetaInterface rowMeta, Object[] rowData, long time, TimeUnit tu ); @Override int size(); @Override void clear(); }### Answer:
@Test public void testPutRow() throws Exception { rowSet.putRow( new RowMeta(), row ); assertSame( row, rowSet.getRow() ); } |
### Question:
QueueRowSet extends BaseRowSet implements Comparable<RowSet>, RowSet { @Override public boolean putRowWait( RowMetaInterface rowMeta, Object[] rowData, long time, TimeUnit tu ) { return putRow( rowMeta, rowData ); } QueueRowSet(); @Override Object[] getRow(); @Override Object[] getRowImmediate(); @Override Object[] getRowWait( long timeout, TimeUnit tu ); @Override boolean putRow( RowMetaInterface rowMeta, Object[] rowData ); @Override boolean putRowWait( RowMetaInterface rowMeta, Object[] rowData, long time, TimeUnit tu ); @Override int size(); @Override void clear(); }### Answer:
@Test public void testPutRowWait() throws Exception { rowSet.putRowWait( new RowMeta(), row, 1, TimeUnit.SECONDS ); assertSame( row, rowSet.getRowWait( 1, TimeUnit.SECONDS ) ); } |
### Question:
QueueRowSet extends BaseRowSet implements Comparable<RowSet>, RowSet { @Override public Object[] getRowImmediate() { return getRow(); } QueueRowSet(); @Override Object[] getRow(); @Override Object[] getRowImmediate(); @Override Object[] getRowWait( long timeout, TimeUnit tu ); @Override boolean putRow( RowMetaInterface rowMeta, Object[] rowData ); @Override boolean putRowWait( RowMetaInterface rowMeta, Object[] rowData, long time, TimeUnit tu ); @Override int size(); @Override void clear(); }### Answer:
@Test public void testGetRowImmediate() throws Exception { rowSet.putRow( new RowMeta(), row ); assertSame( row, rowSet.getRowImmediate() ); } |
### Question:
QueueRowSet extends BaseRowSet implements Comparable<RowSet>, RowSet { @Override public int size() { return buffer.size(); } QueueRowSet(); @Override Object[] getRow(); @Override Object[] getRowImmediate(); @Override Object[] getRowWait( long timeout, TimeUnit tu ); @Override boolean putRow( RowMetaInterface rowMeta, Object[] rowData ); @Override boolean putRowWait( RowMetaInterface rowMeta, Object[] rowData, long time, TimeUnit tu ); @Override int size(); @Override void clear(); }### Answer:
@Test public void testSize() throws Exception { assertEquals( 0, rowSet.size() ); rowSet.putRow( new RowMeta(), row ); assertEquals( 1, rowSet.size() ); rowSet.putRow( new RowMeta(), row ); assertEquals( 2, rowSet.size() ); rowSet.clear(); assertEquals( 0, rowSet.size() ); } |
### Question:
RowMeta implements RowMetaInterface { @Override public List<ValueMetaInterface> getValueMetaList() { List<ValueMetaInterface> copy; lock.readLock().lock(); try { copy = new ArrayList<ValueMetaInterface>( valueMetaList ); } finally { lock.readLock().unlock(); } return Collections.unmodifiableList( copy ); } RowMeta(); private RowMeta( RowMeta rowMeta, Integer targetType ); private RowMeta( List<ValueMetaInterface> valueMetaList, RowMetaCache rowMetaCache ); RowMeta( DataInputStream inputStream ); RowMeta( Node node ); @Override RowMeta clone(); @Override RowMetaInterface cloneToType( int targetType ); @Override String toString(); @Override List<ValueMetaInterface> getValueMetaList(); @Override void setValueMetaList( List<ValueMetaInterface> valueMetaList ); @Override int size(); @Override boolean isEmpty(); @Override boolean exists( ValueMetaInterface meta ); @Override void addValueMeta( ValueMetaInterface meta ); @Override void addValueMeta( int index, ValueMetaInterface meta ); @Override ValueMetaInterface getValueMeta( int index ); @Override void setValueMeta( int index, ValueMetaInterface valueMeta ); @Override String getString( Object[] dataRow, int index ); @Override Long getInteger( Object[] dataRow, int index ); @Override Double getNumber( Object[] dataRow, int index ); @Override Date getDate( Object[] dataRow, int index ); @Override BigDecimal getBigNumber( Object[] dataRow, int index ); @Override Boolean getBoolean( Object[] dataRow, int index ); @Override byte[] getBinary( Object[] dataRow, int index ); @Override boolean isNull( Object[] dataRow, int index ); @Override Object[] cloneRow( Object[] objects ); @Override Object[] cloneRow( Object[] objects, Object[] newObjects ); @Override String getString( Object[] dataRow, String valueName, String defaultValue ); @Override Long getInteger( Object[] dataRow, String valueName, Long defaultValue ); @Override Date getDate( Object[] dataRow, String valueName, Date defaultValue ); @Override int indexOfValue( String valueName ); @Override ValueMetaInterface searchValueMeta( String valueName ); @Override void addRowMeta( RowMetaInterface rowMeta ); @Override void mergeRowMeta( RowMetaInterface r ); @Override void mergeRowMeta( RowMetaInterface r, String originStepName ); @Override String[] getFieldNames(); @Override void writeData( DataOutputStream outputStream, Object[] data ); @Override void writeMeta( DataOutputStream outputStream ); @Override Object[] readData( DataInputStream inputStream ); @Override void clear(); @Override void removeValueMeta( String valueName ); @Override void removeValueMeta( int index ); @Override String toStringMeta(); @Override String getString( Object[] row ); @Override String[] getFieldNamesAndTypes( int maxlen ); @Override int compare( Object[] rowData1, Object[] rowData2, int[] fieldnrs ); @Override boolean equals( Object[] rowData1, Object[] rowData2, int[] fieldnrs ); @Override int compare( Object[] rowData1, Object[] rowData2, int[] fieldnrs1, int[] fieldnrs2 ); @Override int compare( Object[] rowData1, RowMetaInterface rowMeta2, Object[] rowData2, int[] fieldnrs1,
int[] fieldnrs2 ); @Override int compare( Object[] rowData1, Object[] rowData2 ); @Override @Deprecated int oldXORHashCode( Object[] rowData ); @Override int hashCode( Object[] rowData ); @Override int convertedValuesHashCode( Object[] rowData ); static byte[] extractData( RowMetaInterface metadata, Object[] row ); static Object[] getRow( RowMetaInterface metadata, byte[] data ); static Row createOriginalRow( RowMetaInterface rowMeta, Object[] rowData ); @Override String getMetaXML(); @Override String getDataXML( Object[] rowData ); @Override Object[] getRow( Node node ); static final String XML_META_TAG; static final String XML_DATA_TAG; }### Answer:
@Test public void testGetValueMetaList() { List<ValueMetaInterface> list = rowMeta.getValueMetaList(); assertTrue( list.contains( string ) ); assertTrue( list.contains( integer ) ); assertTrue( list.contains( date ) ); } |
### Question:
RowMeta implements RowMetaInterface { @Override public boolean exists( ValueMetaInterface meta ) { return ( meta != null ) && searchValueMeta( meta.getName() ) != null; } RowMeta(); private RowMeta( RowMeta rowMeta, Integer targetType ); private RowMeta( List<ValueMetaInterface> valueMetaList, RowMetaCache rowMetaCache ); RowMeta( DataInputStream inputStream ); RowMeta( Node node ); @Override RowMeta clone(); @Override RowMetaInterface cloneToType( int targetType ); @Override String toString(); @Override List<ValueMetaInterface> getValueMetaList(); @Override void setValueMetaList( List<ValueMetaInterface> valueMetaList ); @Override int size(); @Override boolean isEmpty(); @Override boolean exists( ValueMetaInterface meta ); @Override void addValueMeta( ValueMetaInterface meta ); @Override void addValueMeta( int index, ValueMetaInterface meta ); @Override ValueMetaInterface getValueMeta( int index ); @Override void setValueMeta( int index, ValueMetaInterface valueMeta ); @Override String getString( Object[] dataRow, int index ); @Override Long getInteger( Object[] dataRow, int index ); @Override Double getNumber( Object[] dataRow, int index ); @Override Date getDate( Object[] dataRow, int index ); @Override BigDecimal getBigNumber( Object[] dataRow, int index ); @Override Boolean getBoolean( Object[] dataRow, int index ); @Override byte[] getBinary( Object[] dataRow, int index ); @Override boolean isNull( Object[] dataRow, int index ); @Override Object[] cloneRow( Object[] objects ); @Override Object[] cloneRow( Object[] objects, Object[] newObjects ); @Override String getString( Object[] dataRow, String valueName, String defaultValue ); @Override Long getInteger( Object[] dataRow, String valueName, Long defaultValue ); @Override Date getDate( Object[] dataRow, String valueName, Date defaultValue ); @Override int indexOfValue( String valueName ); @Override ValueMetaInterface searchValueMeta( String valueName ); @Override void addRowMeta( RowMetaInterface rowMeta ); @Override void mergeRowMeta( RowMetaInterface r ); @Override void mergeRowMeta( RowMetaInterface r, String originStepName ); @Override String[] getFieldNames(); @Override void writeData( DataOutputStream outputStream, Object[] data ); @Override void writeMeta( DataOutputStream outputStream ); @Override Object[] readData( DataInputStream inputStream ); @Override void clear(); @Override void removeValueMeta( String valueName ); @Override void removeValueMeta( int index ); @Override String toStringMeta(); @Override String getString( Object[] row ); @Override String[] getFieldNamesAndTypes( int maxlen ); @Override int compare( Object[] rowData1, Object[] rowData2, int[] fieldnrs ); @Override boolean equals( Object[] rowData1, Object[] rowData2, int[] fieldnrs ); @Override int compare( Object[] rowData1, Object[] rowData2, int[] fieldnrs1, int[] fieldnrs2 ); @Override int compare( Object[] rowData1, RowMetaInterface rowMeta2, Object[] rowData2, int[] fieldnrs1,
int[] fieldnrs2 ); @Override int compare( Object[] rowData1, Object[] rowData2 ); @Override @Deprecated int oldXORHashCode( Object[] rowData ); @Override int hashCode( Object[] rowData ); @Override int convertedValuesHashCode( Object[] rowData ); static byte[] extractData( RowMetaInterface metadata, Object[] row ); static Object[] getRow( RowMetaInterface metadata, byte[] data ); static Row createOriginalRow( RowMetaInterface rowMeta, Object[] rowData ); @Override String getMetaXML(); @Override String getDataXML( Object[] rowData ); @Override Object[] getRow( Node node ); static final String XML_META_TAG; static final String XML_DATA_TAG; }### Answer:
@Test public void testExists() { assertTrue( rowMeta.exists( string ) ); assertTrue( rowMeta.exists( date ) ); assertTrue( rowMeta.exists( integer ) ); } |
### Question:
RowMeta implements RowMetaInterface { @Override public ValueMetaInterface getValueMeta( int index ) { lock.readLock().lock(); try { if ( ( index >= 0 ) && ( index < valueMetaList.size() ) ) { return valueMetaList.get( index ); } else { return null; } } finally { lock.readLock().unlock(); } } RowMeta(); private RowMeta( RowMeta rowMeta, Integer targetType ); private RowMeta( List<ValueMetaInterface> valueMetaList, RowMetaCache rowMetaCache ); RowMeta( DataInputStream inputStream ); RowMeta( Node node ); @Override RowMeta clone(); @Override RowMetaInterface cloneToType( int targetType ); @Override String toString(); @Override List<ValueMetaInterface> getValueMetaList(); @Override void setValueMetaList( List<ValueMetaInterface> valueMetaList ); @Override int size(); @Override boolean isEmpty(); @Override boolean exists( ValueMetaInterface meta ); @Override void addValueMeta( ValueMetaInterface meta ); @Override void addValueMeta( int index, ValueMetaInterface meta ); @Override ValueMetaInterface getValueMeta( int index ); @Override void setValueMeta( int index, ValueMetaInterface valueMeta ); @Override String getString( Object[] dataRow, int index ); @Override Long getInteger( Object[] dataRow, int index ); @Override Double getNumber( Object[] dataRow, int index ); @Override Date getDate( Object[] dataRow, int index ); @Override BigDecimal getBigNumber( Object[] dataRow, int index ); @Override Boolean getBoolean( Object[] dataRow, int index ); @Override byte[] getBinary( Object[] dataRow, int index ); @Override boolean isNull( Object[] dataRow, int index ); @Override Object[] cloneRow( Object[] objects ); @Override Object[] cloneRow( Object[] objects, Object[] newObjects ); @Override String getString( Object[] dataRow, String valueName, String defaultValue ); @Override Long getInteger( Object[] dataRow, String valueName, Long defaultValue ); @Override Date getDate( Object[] dataRow, String valueName, Date defaultValue ); @Override int indexOfValue( String valueName ); @Override ValueMetaInterface searchValueMeta( String valueName ); @Override void addRowMeta( RowMetaInterface rowMeta ); @Override void mergeRowMeta( RowMetaInterface r ); @Override void mergeRowMeta( RowMetaInterface r, String originStepName ); @Override String[] getFieldNames(); @Override void writeData( DataOutputStream outputStream, Object[] data ); @Override void writeMeta( DataOutputStream outputStream ); @Override Object[] readData( DataInputStream inputStream ); @Override void clear(); @Override void removeValueMeta( String valueName ); @Override void removeValueMeta( int index ); @Override String toStringMeta(); @Override String getString( Object[] row ); @Override String[] getFieldNamesAndTypes( int maxlen ); @Override int compare( Object[] rowData1, Object[] rowData2, int[] fieldnrs ); @Override boolean equals( Object[] rowData1, Object[] rowData2, int[] fieldnrs ); @Override int compare( Object[] rowData1, Object[] rowData2, int[] fieldnrs1, int[] fieldnrs2 ); @Override int compare( Object[] rowData1, RowMetaInterface rowMeta2, Object[] rowData2, int[] fieldnrs1,
int[] fieldnrs2 ); @Override int compare( Object[] rowData1, Object[] rowData2 ); @Override @Deprecated int oldXORHashCode( Object[] rowData ); @Override int hashCode( Object[] rowData ); @Override int convertedValuesHashCode( Object[] rowData ); static byte[] extractData( RowMetaInterface metadata, Object[] row ); static Object[] getRow( RowMetaInterface metadata, byte[] data ); static Row createOriginalRow( RowMetaInterface rowMeta, Object[] rowData ); @Override String getMetaXML(); @Override String getDataXML( Object[] rowData ); @Override Object[] getRow( Node node ); static final String XML_META_TAG; static final String XML_DATA_TAG; }### Answer:
@Test public void testGetValueMeta() { assertTrue( rowMeta.getValueMeta( 1 ).equals( integer ) ); } |
### Question:
RowMeta implements RowMetaInterface { @Override public void addRowMeta( RowMetaInterface rowMeta ) { for ( int i = 0; i < rowMeta.size(); i++ ) { addValueMeta( rowMeta.getValueMeta( i ) ); } } RowMeta(); private RowMeta( RowMeta rowMeta, Integer targetType ); private RowMeta( List<ValueMetaInterface> valueMetaList, RowMetaCache rowMetaCache ); RowMeta( DataInputStream inputStream ); RowMeta( Node node ); @Override RowMeta clone(); @Override RowMetaInterface cloneToType( int targetType ); @Override String toString(); @Override List<ValueMetaInterface> getValueMetaList(); @Override void setValueMetaList( List<ValueMetaInterface> valueMetaList ); @Override int size(); @Override boolean isEmpty(); @Override boolean exists( ValueMetaInterface meta ); @Override void addValueMeta( ValueMetaInterface meta ); @Override void addValueMeta( int index, ValueMetaInterface meta ); @Override ValueMetaInterface getValueMeta( int index ); @Override void setValueMeta( int index, ValueMetaInterface valueMeta ); @Override String getString( Object[] dataRow, int index ); @Override Long getInteger( Object[] dataRow, int index ); @Override Double getNumber( Object[] dataRow, int index ); @Override Date getDate( Object[] dataRow, int index ); @Override BigDecimal getBigNumber( Object[] dataRow, int index ); @Override Boolean getBoolean( Object[] dataRow, int index ); @Override byte[] getBinary( Object[] dataRow, int index ); @Override boolean isNull( Object[] dataRow, int index ); @Override Object[] cloneRow( Object[] objects ); @Override Object[] cloneRow( Object[] objects, Object[] newObjects ); @Override String getString( Object[] dataRow, String valueName, String defaultValue ); @Override Long getInteger( Object[] dataRow, String valueName, Long defaultValue ); @Override Date getDate( Object[] dataRow, String valueName, Date defaultValue ); @Override int indexOfValue( String valueName ); @Override ValueMetaInterface searchValueMeta( String valueName ); @Override void addRowMeta( RowMetaInterface rowMeta ); @Override void mergeRowMeta( RowMetaInterface r ); @Override void mergeRowMeta( RowMetaInterface r, String originStepName ); @Override String[] getFieldNames(); @Override void writeData( DataOutputStream outputStream, Object[] data ); @Override void writeMeta( DataOutputStream outputStream ); @Override Object[] readData( DataInputStream inputStream ); @Override void clear(); @Override void removeValueMeta( String valueName ); @Override void removeValueMeta( int index ); @Override String toStringMeta(); @Override String getString( Object[] row ); @Override String[] getFieldNamesAndTypes( int maxlen ); @Override int compare( Object[] rowData1, Object[] rowData2, int[] fieldnrs ); @Override boolean equals( Object[] rowData1, Object[] rowData2, int[] fieldnrs ); @Override int compare( Object[] rowData1, Object[] rowData2, int[] fieldnrs1, int[] fieldnrs2 ); @Override int compare( Object[] rowData1, RowMetaInterface rowMeta2, Object[] rowData2, int[] fieldnrs1,
int[] fieldnrs2 ); @Override int compare( Object[] rowData1, Object[] rowData2 ); @Override @Deprecated int oldXORHashCode( Object[] rowData ); @Override int hashCode( Object[] rowData ); @Override int convertedValuesHashCode( Object[] rowData ); static byte[] extractData( RowMetaInterface metadata, Object[] row ); static Object[] getRow( RowMetaInterface metadata, byte[] data ); static Row createOriginalRow( RowMetaInterface rowMeta, Object[] rowData ); @Override String getMetaXML(); @Override String getDataXML( Object[] rowData ); @Override Object[] getRow( Node node ); static final String XML_META_TAG; static final String XML_DATA_TAG; }### Answer:
@Test public void testAddRowMeta() throws KettlePluginException { List<ValueMetaInterface> list = this.generateVList( new String[]{ "alfa", "bravo", "charly", "delta" }, new int[]{ 2, 2, 3, 4 } ); RowMeta added = new RowMeta(); added.setValueMetaList( list ); rowMeta.addRowMeta( added ); assertEquals( 7, rowMeta.getValueMetaList().size() ); assertEquals( 5, rowMeta.indexOfValue( "charly" ) ); } |
### Question:
RowMeta implements RowMetaInterface { @Override public String[] getFieldNames() { lock.readLock().lock(); try { String[] retval = new String[ size() ]; for ( int i = 0; i < size(); i++ ) { String valueName = getValueMeta( i ).getName(); retval[i] = valueName == null ? "" : valueName; } return retval; } finally { lock.readLock().unlock(); } } RowMeta(); private RowMeta( RowMeta rowMeta, Integer targetType ); private RowMeta( List<ValueMetaInterface> valueMetaList, RowMetaCache rowMetaCache ); RowMeta( DataInputStream inputStream ); RowMeta( Node node ); @Override RowMeta clone(); @Override RowMetaInterface cloneToType( int targetType ); @Override String toString(); @Override List<ValueMetaInterface> getValueMetaList(); @Override void setValueMetaList( List<ValueMetaInterface> valueMetaList ); @Override int size(); @Override boolean isEmpty(); @Override boolean exists( ValueMetaInterface meta ); @Override void addValueMeta( ValueMetaInterface meta ); @Override void addValueMeta( int index, ValueMetaInterface meta ); @Override ValueMetaInterface getValueMeta( int index ); @Override void setValueMeta( int index, ValueMetaInterface valueMeta ); @Override String getString( Object[] dataRow, int index ); @Override Long getInteger( Object[] dataRow, int index ); @Override Double getNumber( Object[] dataRow, int index ); @Override Date getDate( Object[] dataRow, int index ); @Override BigDecimal getBigNumber( Object[] dataRow, int index ); @Override Boolean getBoolean( Object[] dataRow, int index ); @Override byte[] getBinary( Object[] dataRow, int index ); @Override boolean isNull( Object[] dataRow, int index ); @Override Object[] cloneRow( Object[] objects ); @Override Object[] cloneRow( Object[] objects, Object[] newObjects ); @Override String getString( Object[] dataRow, String valueName, String defaultValue ); @Override Long getInteger( Object[] dataRow, String valueName, Long defaultValue ); @Override Date getDate( Object[] dataRow, String valueName, Date defaultValue ); @Override int indexOfValue( String valueName ); @Override ValueMetaInterface searchValueMeta( String valueName ); @Override void addRowMeta( RowMetaInterface rowMeta ); @Override void mergeRowMeta( RowMetaInterface r ); @Override void mergeRowMeta( RowMetaInterface r, String originStepName ); @Override String[] getFieldNames(); @Override void writeData( DataOutputStream outputStream, Object[] data ); @Override void writeMeta( DataOutputStream outputStream ); @Override Object[] readData( DataInputStream inputStream ); @Override void clear(); @Override void removeValueMeta( String valueName ); @Override void removeValueMeta( int index ); @Override String toStringMeta(); @Override String getString( Object[] row ); @Override String[] getFieldNamesAndTypes( int maxlen ); @Override int compare( Object[] rowData1, Object[] rowData2, int[] fieldnrs ); @Override boolean equals( Object[] rowData1, Object[] rowData2, int[] fieldnrs ); @Override int compare( Object[] rowData1, Object[] rowData2, int[] fieldnrs1, int[] fieldnrs2 ); @Override int compare( Object[] rowData1, RowMetaInterface rowMeta2, Object[] rowData2, int[] fieldnrs1,
int[] fieldnrs2 ); @Override int compare( Object[] rowData1, Object[] rowData2 ); @Override @Deprecated int oldXORHashCode( Object[] rowData ); @Override int hashCode( Object[] rowData ); @Override int convertedValuesHashCode( Object[] rowData ); static byte[] extractData( RowMetaInterface metadata, Object[] row ); static Object[] getRow( RowMetaInterface metadata, byte[] data ); static Row createOriginalRow( RowMetaInterface rowMeta, Object[] rowData ); @Override String getMetaXML(); @Override String getDataXML( Object[] rowData ); @Override Object[] getRow( Node node ); static final String XML_META_TAG; static final String XML_DATA_TAG; }### Answer:
@Test public void testGetFieldNames() { rowMeta.clear(); fillRowMeta(); String[] names = rowMeta.getFieldNames(); assertEquals( 10, names.length ); assertEquals( "sample", names[0] ); for ( int i = 1; i < names.length; i++ ) { assertEquals( "", names[i] ); } } |
### Question:
ValueMetaTimestamp extends ValueMetaDate { @Override public void setPreparedStatementValue( DatabaseMeta databaseMeta, PreparedStatement preparedStatement, int index, Object data ) throws KettleDatabaseException { try { if ( data != null ) { preparedStatement.setTimestamp( index, getTimestamp( data ) ); } else { preparedStatement.setNull( index, java.sql.Types.TIMESTAMP ); } } catch ( Exception e ) { throw new KettleDatabaseException( toStringMeta() + " : Unable to set value on prepared statement on index " + index, e ); } } ValueMetaTimestamp(); ValueMetaTimestamp( String name ); @Override boolean isDate(); @Override Date getDate( Object object ); @Override Long getInteger( Object object ); @Override Double getNumber( Object object ); @Override BigDecimal getBigNumber( Object object ); @Override Boolean getBoolean( Object object ); @Override String getString( Object object ); Timestamp getTimestamp( Object object ); int compare( Object data1, Object data2 ); @Override Object convertDataFromString( String pol, ValueMetaInterface convertMeta, String nullIf, String ifNull,
int trim_type ); Timestamp convertDateToTimestamp( Date date ); @Override Object convertData( ValueMetaInterface meta2, Object data2 ); @Override Object cloneValueData( Object object ); @Override ValueMetaInterface getValueFromSQLType( DatabaseMeta databaseMeta, String name, ResultSetMetaData rm,
int index, boolean ignoreLength, boolean lazyConversion ); @Override Object getValueFromResultSet( DatabaseInterface databaseInterface, ResultSet resultSet, int index ); @Override void setPreparedStatementValue( DatabaseMeta databaseMeta, PreparedStatement preparedStatement, int index,
Object data ); @Override Object convertDataUsingConversionMetaData( Object data2 ); @Override byte[] getBinaryString( Object object ); @Override void writeData( DataOutputStream outputStream, Object object ); @Override Object readData( DataInputStream inputStream ); @Override synchronized SimpleDateFormat getDateFormat(); @Override String getFormatMask(); @Override Class<?> getNativeDataTypeClass(); }### Answer:
@Test public void testSetPreparedStatementValue() throws Exception { ValueMetaTimestamp vm = new ValueMetaTimestamp(); PreparedStatement ps = mock( PreparedStatement.class ); doAnswer( new Answer<Object>() { @Override public Object answer( InvocationOnMock invocationOnMock ) throws Throwable { Object ts = invocationOnMock.getArguments()[1]; return ts.toString(); } } ).when( ps ).setTimestamp( anyInt(), (Timestamp) anyObject() ); try { vm.setPreparedStatementValue( mock( DatabaseMeta.class ), ps, 0, null ); } catch ( KettleDatabaseException ex ) { fail( "Check PDI-11547" ); } } |
### Question:
ValueMetaTimestamp extends ValueMetaDate { public int compare( Object data1, Object data2 ) throws KettleValueException { Timestamp timestamp1 = getTimestamp( data1 ); Timestamp timestamp2 = getTimestamp( data2 ); int cmp = 0; if ( timestamp1 == null ) { if ( timestamp2 == null ) { cmp = 0; } else { cmp = -1; } } else if ( timestamp2 == null ) { cmp = 1; } else { cmp = timestamp1.compareTo( timestamp2 ); } if ( isSortedDescending() ) { return -cmp; } else { return cmp; } } ValueMetaTimestamp(); ValueMetaTimestamp( String name ); @Override boolean isDate(); @Override Date getDate( Object object ); @Override Long getInteger( Object object ); @Override Double getNumber( Object object ); @Override BigDecimal getBigNumber( Object object ); @Override Boolean getBoolean( Object object ); @Override String getString( Object object ); Timestamp getTimestamp( Object object ); int compare( Object data1, Object data2 ); @Override Object convertDataFromString( String pol, ValueMetaInterface convertMeta, String nullIf, String ifNull,
int trim_type ); Timestamp convertDateToTimestamp( Date date ); @Override Object convertData( ValueMetaInterface meta2, Object data2 ); @Override Object cloneValueData( Object object ); @Override ValueMetaInterface getValueFromSQLType( DatabaseMeta databaseMeta, String name, ResultSetMetaData rm,
int index, boolean ignoreLength, boolean lazyConversion ); @Override Object getValueFromResultSet( DatabaseInterface databaseInterface, ResultSet resultSet, int index ); @Override void setPreparedStatementValue( DatabaseMeta databaseMeta, PreparedStatement preparedStatement, int index,
Object data ); @Override Object convertDataUsingConversionMetaData( Object data2 ); @Override byte[] getBinaryString( Object object ); @Override void writeData( DataOutputStream outputStream, Object object ); @Override Object readData( DataInputStream inputStream ); @Override synchronized SimpleDateFormat getDateFormat(); @Override String getFormatMask(); @Override Class<?> getNativeDataTypeClass(); }### Answer:
@Test public void testCompare() throws Exception { ValueMetaTimestamp vm = new ValueMetaTimestamp(); Timestamp earlier = Timestamp.valueOf( "2012-12-12 12:12:12.121212" ); Timestamp later = Timestamp.valueOf( "2013-12-12 12:12:12.121212" ); assertTrue( vm.isSortedAscending() ); assertFalse( vm.isSortedDescending() ); assertEquals( vm.compare( null, null ), 0 ); assertEquals( vm.compare( null, earlier ), -1 ); assertEquals( vm.compare( earlier, null ), 1 ); assertEquals( vm.compare( earlier, earlier ), 0 ); assertEquals( vm.compare( earlier, later ), -1 ); assertEquals( vm.compare( later, earlier ), 1 ); vm.setSortedDescending( true ); assertFalse( vm.isSortedAscending() ); assertTrue( vm.isSortedDescending() ); assertEquals( vm.compare( null, null ), 0 ); assertEquals( vm.compare( null, earlier ), 1 ); assertEquals( vm.compare( earlier, null ), -1 ); assertEquals( vm.compare( earlier, earlier ), 0 ); assertEquals( vm.compare( earlier, later ), 1 ); assertEquals( vm.compare( later, earlier ), -1 ); } |
### Question:
ValueMetaTimestamp extends ValueMetaDate { protected synchronized Timestamp convertStringToTimestamp( String string ) throws KettleValueException { string = Const.trimToType( string, getTrimType() ); if ( Utils.isEmpty( string ) ) { return null; } Timestamp returnValue; try { returnValue = Timestamp.valueOf( string ); } catch ( IllegalArgumentException e ) { try { returnValue = (Timestamp) getDateFormat().parse( string ); } catch ( ParseException ex ) { throw new KettleValueException( toString() + " : couldn't convert string [" + string + "] to a timestamp, expecting format [yyyy-mm-dd hh:mm:ss.ffffff]", e ); } } return returnValue; } ValueMetaTimestamp(); ValueMetaTimestamp( String name ); @Override boolean isDate(); @Override Date getDate( Object object ); @Override Long getInteger( Object object ); @Override Double getNumber( Object object ); @Override BigDecimal getBigNumber( Object object ); @Override Boolean getBoolean( Object object ); @Override String getString( Object object ); Timestamp getTimestamp( Object object ); int compare( Object data1, Object data2 ); @Override Object convertDataFromString( String pol, ValueMetaInterface convertMeta, String nullIf, String ifNull,
int trim_type ); Timestamp convertDateToTimestamp( Date date ); @Override Object convertData( ValueMetaInterface meta2, Object data2 ); @Override Object cloneValueData( Object object ); @Override ValueMetaInterface getValueFromSQLType( DatabaseMeta databaseMeta, String name, ResultSetMetaData rm,
int index, boolean ignoreLength, boolean lazyConversion ); @Override Object getValueFromResultSet( DatabaseInterface databaseInterface, ResultSet resultSet, int index ); @Override void setPreparedStatementValue( DatabaseMeta databaseMeta, PreparedStatement preparedStatement, int index,
Object data ); @Override Object convertDataUsingConversionMetaData( Object data2 ); @Override byte[] getBinaryString( Object object ); @Override void writeData( DataOutputStream outputStream, Object object ); @Override Object readData( DataInputStream inputStream ); @Override synchronized SimpleDateFormat getDateFormat(); @Override String getFormatMask(); @Override Class<?> getNativeDataTypeClass(); }### Answer:
@Test public void testConvertStringToTimestamp() throws Exception { ValueMetaTimestamp valueMetaTimestamp = new ValueMetaTimestamp(); assertEquals( Timestamp.valueOf( "2012-04-05 04:03:02.123456" ), valueMetaTimestamp .convertStringToTimestamp( "2012/4/5 04:03:02.123456" ) ); assertEquals( Timestamp.valueOf( "2012-04-05 04:03:02.123" ), valueMetaTimestamp .convertStringToTimestamp( "2012/4/5 04:03:02.123" ) ); assertEquals( Timestamp.valueOf( "2012-04-05 04:03:02.123456789" ), valueMetaTimestamp .convertStringToTimestamp( "2012/4/5 04:03:02.123456789" ) ); } |
### Question:
ValueMetaTimestamp extends ValueMetaDate { protected synchronized String convertTimestampToString( Timestamp timestamp ) throws KettleValueException { if ( timestamp == null ) { return null; } return getDateFormat().format( timestamp ); } ValueMetaTimestamp(); ValueMetaTimestamp( String name ); @Override boolean isDate(); @Override Date getDate( Object object ); @Override Long getInteger( Object object ); @Override Double getNumber( Object object ); @Override BigDecimal getBigNumber( Object object ); @Override Boolean getBoolean( Object object ); @Override String getString( Object object ); Timestamp getTimestamp( Object object ); int compare( Object data1, Object data2 ); @Override Object convertDataFromString( String pol, ValueMetaInterface convertMeta, String nullIf, String ifNull,
int trim_type ); Timestamp convertDateToTimestamp( Date date ); @Override Object convertData( ValueMetaInterface meta2, Object data2 ); @Override Object cloneValueData( Object object ); @Override ValueMetaInterface getValueFromSQLType( DatabaseMeta databaseMeta, String name, ResultSetMetaData rm,
int index, boolean ignoreLength, boolean lazyConversion ); @Override Object getValueFromResultSet( DatabaseInterface databaseInterface, ResultSet resultSet, int index ); @Override void setPreparedStatementValue( DatabaseMeta databaseMeta, PreparedStatement preparedStatement, int index,
Object data ); @Override Object convertDataUsingConversionMetaData( Object data2 ); @Override byte[] getBinaryString( Object object ); @Override void writeData( DataOutputStream outputStream, Object object ); @Override Object readData( DataInputStream inputStream ); @Override synchronized SimpleDateFormat getDateFormat(); @Override String getFormatMask(); @Override Class<?> getNativeDataTypeClass(); }### Answer:
@Test public void testConvertTimestampToString() throws Exception { ValueMetaTimestamp valueMetaTimestamp = new ValueMetaTimestamp(); assertEquals( "2012/04/05 04:03:02.123456000", valueMetaTimestamp.convertTimestampToString( Timestamp .valueOf( "2012-04-05 04:03:02.123456" ) ) ); assertEquals( "2012/04/05 04:03:02.123000000", valueMetaTimestamp.convertTimestampToString( Timestamp .valueOf( "2012-04-05 04:03:02.123" ) ) ); assertEquals( "2012/04/05 04:03:02.123456789", valueMetaTimestamp.convertTimestampToString( Timestamp .valueOf( "2012-04-05 04:03:02.123456789" ) ) ); } |
### Question:
ValueMetaTimestamp extends ValueMetaDate { public Timestamp convertDateToTimestamp( Date date ) throws KettleValueException { if ( date == null ) { return null; } Timestamp result = null; if ( date instanceof Timestamp ) { result = (Timestamp) date; } else { result = new Timestamp( date.getTime() ); } return result; } ValueMetaTimestamp(); ValueMetaTimestamp( String name ); @Override boolean isDate(); @Override Date getDate( Object object ); @Override Long getInteger( Object object ); @Override Double getNumber( Object object ); @Override BigDecimal getBigNumber( Object object ); @Override Boolean getBoolean( Object object ); @Override String getString( Object object ); Timestamp getTimestamp( Object object ); int compare( Object data1, Object data2 ); @Override Object convertDataFromString( String pol, ValueMetaInterface convertMeta, String nullIf, String ifNull,
int trim_type ); Timestamp convertDateToTimestamp( Date date ); @Override Object convertData( ValueMetaInterface meta2, Object data2 ); @Override Object cloneValueData( Object object ); @Override ValueMetaInterface getValueFromSQLType( DatabaseMeta databaseMeta, String name, ResultSetMetaData rm,
int index, boolean ignoreLength, boolean lazyConversion ); @Override Object getValueFromResultSet( DatabaseInterface databaseInterface, ResultSet resultSet, int index ); @Override void setPreparedStatementValue( DatabaseMeta databaseMeta, PreparedStatement preparedStatement, int index,
Object data ); @Override Object convertDataUsingConversionMetaData( Object data2 ); @Override byte[] getBinaryString( Object object ); @Override void writeData( DataOutputStream outputStream, Object object ); @Override Object readData( DataInputStream inputStream ); @Override synchronized SimpleDateFormat getDateFormat(); @Override String getFormatMask(); @Override Class<?> getNativeDataTypeClass(); }### Answer:
@Test public void testConvertDateToTimestamp() throws Exception { ValueMetaTimestamp valueMetaTimestamp = new ValueMetaTimestamp(); Date date = new Date(); assertEquals( valueMetaTimestamp.convertDateToTimestamp( date ).getTime(), date.getTime() ); Timestamp timestamp = Timestamp.valueOf( "2014-04-05 04:03:02.123456789" ); Timestamp convertedTimestamp = valueMetaTimestamp.convertDateToTimestamp( timestamp ); assertEquals( convertedTimestamp.getTime(), timestamp.getTime() ); assertEquals( convertedTimestamp.getNanos(), timestamp.getNanos() ); } |
### Question:
ValueMetaInternetAddress extends ValueMetaDate { @Override public int compare( Object data1, Object data2 ) throws KettleValueException { InetAddress inet1 = getInternetAddress( data1 ); InetAddress inet2 = getInternetAddress( data2 ); int cmp = 0; if ( inet1 == null ) { if ( inet2 == null ) { cmp = 0; } else { cmp = -1; } } else if ( inet2 == null ) { cmp = 1; } else { BigInteger bigint1 = new BigInteger( inet1.getAddress() ); BigInteger bigint2 = new BigInteger( inet2.getAddress() ); cmp = bigint1.compareTo( bigint2 ); } if ( isSortedDescending() ) { return -cmp; } else { return cmp; } } ValueMetaInternetAddress(); ValueMetaInternetAddress( String name ); @Override int compare( Object data1, Object data2 ); InetAddress getInternetAddress( Object object ); @Override Date getDate( Object object ); @Override Long getInteger( Object object ); @Override Double getNumber( Object object ); @Override BigDecimal getBigNumber( Object object ); @Override Boolean getBoolean( Object object ); @Override String getString( Object object ); @Override byte[] getBinaryString( Object object ); @Override Object convertDataFromString( String pol, ValueMetaInterface convertMeta, String nullIf, String ifNull,
int trim_type ); @Override Object convertData( ValueMetaInterface meta2, Object data2 ); @Override Object cloneValueData( Object object ); @Override ValueMetaInterface getValueFromSQLType( DatabaseMeta databaseMeta, String name, ResultSetMetaData rm,
int index, boolean ignoreLength, boolean lazyConversion ); @Override Object getValueFromResultSet( DatabaseInterface databaseInterface, ResultSet resultSet, int index ); @Override void setPreparedStatementValue( DatabaseMeta databaseMeta, PreparedStatement preparedStatement,
int index, Object data ); @Override String getDatabaseColumnTypeDefinition( DatabaseInterface databaseInterface, String tk, String pk,
boolean use_autoinc, boolean add_fieldname, boolean add_cr ); @Override Class<?> getNativeDataTypeClass(); }### Answer:
@Test public void testCompare() throws UnknownHostException, KettleValueException { ValueMetaInternetAddress vm = new ValueMetaInternetAddress(); InetAddress smaller = InetAddress.getByName( "127.0.0.1" ); InetAddress larger = InetAddress.getByName( "127.0.1.1" ); assertTrue( vm.isSortedAscending() ); assertFalse( vm.isSortedDescending() ); assertEquals( 0, vm.compare( null, null ) ); assertEquals( -1, vm.compare( null, smaller ) ); assertEquals( 1, vm.compare( smaller, null ) ); assertEquals( 0, vm.compare( smaller, smaller ) ); assertEquals( -1, vm.compare( smaller, larger ) ); assertEquals( 1, vm.compare( larger, smaller ) ); vm.setSortedDescending( true ); assertFalse( vm.isSortedAscending() ); assertTrue( vm.isSortedDescending() ); assertEquals( 0, vm.compare( null, null ) ); assertEquals( 1, vm.compare( null, smaller ) ); assertEquals( -1, vm.compare( smaller, null ) ); assertEquals( 0, vm.compare( smaller, smaller ) ); assertEquals( 1, vm.compare( smaller, larger ) ); assertEquals( -1, vm.compare( larger, smaller ) ); } |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.