src_fm_fc_ms_ff
stringlengths 43
86.8k
| target
stringlengths 20
276k
|
|---|---|
DefaultSettingsKeyAccessor implements SettingsKeyAccessor { @Override public List<SettingsKeyModel> getSettingsKeys() { return settingsKeyRepository.findAll() .stream() .map(this::convertToSettingsKeyModel) .collect(Collectors.toList()); } DefaultSettingsKeyAccessor(SettingsKeyRepository settingsKeyRepository); @Override List<SettingsKeyModel> getSettingsKeys(); @Override Optional<SettingsKeyModel> getSettingsKeyByKey(String key); @Override SettingsKeyModel saveSettingsKey(String key, String value); @Override void deleteSettingsKeyByKey(String key); @Override void deleteSettingsKeyById(Long id); }
|
@Test public void getSettingsKeysTest() { final String key = "key1"; final String key2 = "key2"; final String value1 = "value1"; final String value2 = "value2"; SettingsKeyEntity settingsKeyEntity1 = new SettingsKeyEntity(key, value1); SettingsKeyEntity settingsKeyEntity2 = new SettingsKeyEntity(key2, value2); settingsKeyEntity1.setId(1L); settingsKeyEntity2.setId(2L); SettingsKeyRepository settingsKeyRepository = new MockSettingsKeyRepository(); settingsKeyRepository.save(settingsKeyEntity1); settingsKeyRepository.save(settingsKeyEntity2); DefaultSettingsKeyAccessor settingsKeyAccessor = new DefaultSettingsKeyAccessor(settingsKeyRepository); List<SettingsKeyModel> settingsKeyModelList = settingsKeyAccessor.getSettingsKeys(); assertEquals(2, settingsKeyModelList.size()); SettingsKeyModel settingsKeyModel1 = settingsKeyModelList.get(0); SettingsKeyModel settingsKeyModel2 = settingsKeyModelList.get(1); assertEquals(key, settingsKeyModel1.getKey()); assertEquals(value1, settingsKeyModel1.getValue()); assertEquals(key2, settingsKeyModel2.getKey()); assertEquals(value2, settingsKeyModel2.getValue()); }
|
JiraCloudRequestDelegator { public IssueTrackerResponse sendRequests(List<IssueTrackerRequest> requests) throws IntegrationException { if (null == context) { throw new IssueTrackerException("Context missing. Cannot determine Jira Cloud instance."); } if (null == requests || requests.isEmpty()) { throw new IssueTrackerException("Requests missing. Requires at least one request."); } JiraCloudProperties jiraProperties = (JiraCloudProperties) context.getIssueTrackerConfig(); JiraCloudServiceFactory jiraCloudServiceFactory = jiraProperties.createJiraServicesCloudFactory(logger, gson); if (!jiraProperties.isPluginCheckDisabled()) { checkIfAlertPluginIsInstalled(jiraCloudServiceFactory.createPluginManagerService()); } ProjectService projectService = jiraCloudServiceFactory.createProjectService(); UserSearchService userSearchService = jiraCloudServiceFactory.createUserSearchService(); IssueTypeService issueTypeService = jiraCloudServiceFactory.createIssueTypeService(); IssueMetaDataService issueMetaDataService = jiraCloudServiceFactory.createIssueMetadataService(); JiraCloudIssueConfigValidator jiraIssueConfigValidator = new JiraCloudIssueConfigValidator(projectService, userSearchService, issueTypeService, issueMetaDataService); IssueConfig validIssueConfig = jiraIssueConfigValidator.createValidIssueConfig(context); IssueService issueService = jiraCloudServiceFactory.createIssueService(); IssuePropertyService issuePropertyService = jiraCloudServiceFactory.createIssuePropertyService(); IssueSearchService issueSearchService = jiraCloudServiceFactory.createIssueSearchService(); JiraContentValidator contentValidator = new JiraContentValidator(); JiraCloudTransitionHandler jiraTransitionHandler = new JiraCloudTransitionHandler(issueService); JiraCloudIssuePropertyHandler jiraIssuePropertyHandler = new JiraCloudIssuePropertyHandler(issueSearchService, issuePropertyService); JiraCloudIssueHandler jiraIssueHandler = new JiraCloudIssueHandler(issueService, jiraProperties, gson, jiraTransitionHandler, jiraIssuePropertyHandler, contentValidator); return jiraIssueHandler.createOrUpdateIssues(validIssueConfig, requests); } JiraCloudRequestDelegator(Gson gson, IssueTrackerContext context); IssueTrackerResponse sendRequests(List<IssueTrackerRequest> requests); }
|
@Test public void testContextNull() throws Exception { JiraCloudRequestDelegator service = new JiraCloudRequestDelegator(gson, null); List<IssueTrackerRequest> requests = new ArrayList<>(); try { service.sendRequests(requests); fail(); } catch (IssueTrackerException ex) { assertTrue(ex.getMessage().contains("Context missing.")); } }
@Test public void testRequestsNull() throws Exception { JiraCloudRequestDelegator service = new JiraCloudRequestDelegator(gson, createContext()); List<IssueTrackerRequest> requests = null; try { service.sendRequests(requests); fail(); } catch (IssueTrackerException ex) { assertTrue(ex.getMessage().contains("Requests missing.")); } }
@Test public void testRequestsEmpty() throws Exception { JiraCloudRequestDelegator service = new JiraCloudRequestDelegator(gson, createContext()); List<IssueTrackerRequest> requests = new ArrayList<>(); try { service.sendRequests(requests); fail(); } catch (IssueTrackerException ex) { assertTrue(ex.getMessage().contains("Requests missing.")); } }
@Test public void testAppMissing() throws Exception { JiraCloudRequestDelegator service = new JiraCloudRequestDelegator(gson, createContext()); List<IssueTrackerRequest> requests = new ArrayList<>(); IssueContentModel content = createContentModel(); IssueSearchProperties searchProperties = createSearchProperties(); AlertIssueOrigin alertIssueOrigin = new AlertIssueOrigin(null, null); requests.add(IssueCreationRequest.of(searchProperties, content, alertIssueOrigin)); requests.add(IssueCommentRequest.of(searchProperties, content, alertIssueOrigin)); requests.add(IssueResolutionRequest.of(searchProperties, content, alertIssueOrigin)); Mockito.when(jiraAppService.isAppInstalled(Mockito.eq(JiraConstants.JIRA_APP_KEY))).thenReturn(false); try { service.sendRequests(requests); fail(); } catch (IssueTrackerException ex) { assertTrue(ex.getMessage().contains("Please configure the Jira Cloud plugin")); } }
@Test public void testCreateIssue() throws Exception { Mockito.when(jiraAppService.isAppInstalled(Mockito.eq(JiraConstants.JIRA_APP_KEY))).thenReturn(true); List<ProjectComponent> pageComponents = new ArrayList<>(); pageComponents.add(new ProjectComponent(null, "1", "project", "project", null, null, null, null)); PageOfProjectsResponseModel pageOfProjects = new PageOfProjectsResponseModel(pageComponents); Mockito.when(projectService.getProjectsByName(Mockito.anyString())).thenReturn(pageOfProjects); List<IssueTypeResponseModel> issueTypes = new ArrayList<>(); issueTypes.add(new TestIssueTypeResponseModel()); Mockito.when(issueTypeService.getAllIssueTypes()).thenReturn(issueTypes); List<UserDetailsResponseModel> userDetails = new ArrayList<>(); userDetails.add(new TestIssueCreator()); Mockito.when(userSearchService.findUser(Mockito.anyString())).thenReturn(userDetails); Mockito.when(issueMetaDataService.doesProjectContainIssueType(Mockito.anyString(), Mockito.anyString())).thenReturn(Boolean.TRUE); IssueSearchResponseModel searchResponseModel = new IssueSearchResponseModel(); List<IssueResponseModel> issues = new ArrayList<>(); searchResponseModel.setIssues(issues); Mockito.when(issueSearchService.queryForIssues(Mockito.anyString())).thenReturn(searchResponseModel); IssueResponseModel issue = createIssueResponse(); Mockito.when(issueService.createIssue(Mockito.any(IssueCreationRequestModel.class))).thenReturn(issue); JiraCloudRequestDelegator service = new JiraCloudRequestDelegator(gson, createContext()); List<IssueTrackerRequest> requests = new ArrayList<>(); IssueContentModel content = createContentModel(); IssueSearchProperties searchProperties = Mockito.mock(JiraIssueSearchProperties.class); AlertIssueOrigin alertIssueOrigin = new AlertIssueOrigin(null, null); requests.add(IssueCreationRequest.of(searchProperties, content, alertIssueOrigin)); IssueTrackerResponse response = service.sendRequests(requests); assertNotNull(response); assertNotNull(response.getStatusMessage()); boolean anyIssuesMatchKey = response.getUpdatedIssues() .stream() .map(IssueTrackerIssueResponseModel::getIssueKey) .anyMatch("project-1"::equals); assertTrue(anyIssuesMatchKey, "No issues matched the expected key"); }
@Test public void testResolveIssue() throws Exception { Mockito.when(jiraAppService.isAppInstalled(Mockito.eq(JiraConstants.JIRA_APP_KEY))).thenReturn(true); List<ProjectComponent> pageComponents = new ArrayList<>(); pageComponents.add(new ProjectComponent(null, "1", "project", "project", null, null, null, null)); PageOfProjectsResponseModel pageOfProjects = new PageOfProjectsResponseModel(pageComponents); Mockito.when(projectService.getProjectsByName(Mockito.anyString())).thenReturn(pageOfProjects); List<IssueTypeResponseModel> issueTypes = new ArrayList<>(); issueTypes.add(new TestIssueTypeResponseModel()); Mockito.when(issueTypeService.getAllIssueTypes()).thenReturn(issueTypes); List<UserDetailsResponseModel> userDetails = new ArrayList<>(); userDetails.add(new TestIssueCreator()); Mockito.when(userSearchService.findUser(Mockito.anyString())).thenReturn(userDetails); Mockito.when(issueMetaDataService.doesProjectContainIssueType(Mockito.anyString(), Mockito.anyString())).thenReturn(Boolean.TRUE); IssueSearchResponseModel searchResponseModel = new IssueSearchResponseModel(); List<IssueResponseModel> issues = new ArrayList<>(); issues.add(createIssueResponse()); searchResponseModel.setIssues(issues); Mockito.when(issueSearchService.queryForIssues(Mockito.anyString())).thenReturn(searchResponseModel); StatusDetailsComponent statusDetailsComponent = new TestNewStatusDetailsComponent(); Mockito.when(issueService.getStatus(Mockito.anyString())).thenReturn(statusDetailsComponent); TransitionsResponseModel transitionsResponseModel = new TestTransitionResponsesModel(); Mockito.when(issueService.getTransitions(Mockito.anyString())).thenReturn(transitionsResponseModel); JiraCloudRequestDelegator service = new JiraCloudRequestDelegator(gson, createContext()); List<IssueTrackerRequest> requests = new ArrayList<>(); IssueContentModel content = createContentModel(); IssueSearchProperties searchProperties = Mockito.mock(JiraIssueSearchProperties.class); AlertIssueOrigin alertIssueOrigin = new AlertIssueOrigin(null, null); requests.add(IssueCommentRequest.of(searchProperties, content, alertIssueOrigin)); requests.add(IssueResolutionRequest.of(searchProperties, content, alertIssueOrigin)); IssueTrackerResponse response = service.sendRequests(requests); assertNotNull(response); assertNotNull(response.getStatusMessage()); boolean anyIssuesMatchKey = response.getUpdatedIssues() .stream() .map(IssueTrackerIssueResponseModel::getIssueKey) .anyMatch("project-1"::equals); assertTrue(anyIssuesMatchKey, "No issues matched the expected key"); }
|
DefaultSettingsKeyAccessor implements SettingsKeyAccessor { @Override public Optional<SettingsKeyModel> getSettingsKeyByKey(String key) { return settingsKeyRepository.findByKey(key).map(this::convertToSettingsKeyModel); } DefaultSettingsKeyAccessor(SettingsKeyRepository settingsKeyRepository); @Override List<SettingsKeyModel> getSettingsKeys(); @Override Optional<SettingsKeyModel> getSettingsKeyByKey(String key); @Override SettingsKeyModel saveSettingsKey(String key, String value); @Override void deleteSettingsKeyByKey(String key); @Override void deleteSettingsKeyById(Long id); }
|
@Test public void getSettingsByKeyTest() { final String key = "key1"; final String value1 = "value1"; SettingsKeyEntity settingsKeyEntity = new SettingsKeyEntity(key, value1); settingsKeyEntity.setId(1L); SettingsKeyRepository settingsKeyRepository = new MockSettingsKeyRepository(); settingsKeyRepository.save(settingsKeyEntity); DefaultSettingsKeyAccessor settingsKeyAccessor = new DefaultSettingsKeyAccessor(settingsKeyRepository); Optional<SettingsKeyModel> settingsKeyModelOptional = settingsKeyAccessor.getSettingsKeyByKey("key1"); Optional<SettingsKeyModel> settingsKeyModelOptionalNull = settingsKeyAccessor.getSettingsKeyByKey("-1"); assertTrue(settingsKeyModelOptional.isPresent()); assertFalse(settingsKeyModelOptionalNull.isPresent()); SettingsKeyModel settingsKeyModel = settingsKeyModelOptional.get(); assertEquals(key, settingsKeyModel.getKey()); assertEquals(value1, settingsKeyModel.getValue()); }
|
JiraCloudIssueConfigValidator extends JiraIssueConfigValidator { @Override public Collection<ProjectComponent> getProjectsByName(String jiraProjectName) throws IntegrationException { PageOfProjectsResponseModel projectsResponseModel = projectService.getProjectsByName(jiraProjectName); return projectsResponseModel.getProjects(); } JiraCloudIssueConfigValidator(ProjectService projectService, UserSearchService userSearchService, IssueTypeService issueTypeService, IssueMetaDataService issueMetaDataService); @Override String getProjectFieldKey(); @Override String getIssueTypeFieldKey(); @Override String getIssueCreatorFieldKey(); @Override String getAddCommentsFieldKey(); @Override String getResolveTransitionFieldKey(); @Override String getOpenTransitionFieldKey(); @Override Collection<ProjectComponent> getProjectsByName(String jiraProjectName); @Override boolean isUserValid(String issueCreator); }
|
@Test public void validateSuccessTest() throws IntegrationException { ProjectService projectService = Mockito.mock(ProjectService.class); UserSearchService userSearchService = Mockito.mock(UserSearchService.class); IssueTypeService issueTypeService = Mockito.mock(IssueTypeService.class); IssueMetaDataService issueMetaDataService = Mockito.mock(IssueMetaDataService.class); Mockito.when(issueMetaDataService.doesProjectContainIssueType(Mockito.anyString(), Mockito.anyString())).thenReturn(Boolean.TRUE); JiraCloudIssueConfigValidator jiraIssueConfigValidator = new JiraCloudIssueConfigValidator(projectService, userSearchService, issueTypeService, issueMetaDataService); String resolveTransitionString = "Resolve"; String projectName = "ProjectName"; String issueTypeString = "IssueType"; String issueCreatorString = "IssueCreator"; IssueConfig issueConfig = new IssueConfig(); issueConfig.setCommentOnIssues(true); issueConfig.setResolveTransition(resolveTransitionString); issueConfig.setProjectName(projectName); issueConfig.setIssueType(issueTypeString); issueConfig.setIssueCreator(issueCreatorString); IssueTypeResponseModel issue = Mockito.mock(IssueTypeResponseModel.class); Mockito.when(issue.getName()).thenReturn(issueTypeString); List<IssueTypeResponseModel> issueResponses = new ArrayList<>(1); issueResponses.add(issue); Mockito.when(issueTypeService.getAllIssueTypes()).thenReturn(issueResponses); UserDetailsResponseModel user = Mockito.mock(UserDetailsResponseModel.class); Mockito.when(user.getEmailAddress()).thenReturn(issueCreatorString); List<UserDetailsResponseModel> userResponses = new ArrayList<>(1); userResponses.add(user); Mockito.when(userSearchService.findUser(Mockito.anyString())).thenReturn(userResponses); ProjectComponent projectComponent = Mockito.mock(ProjectComponent.class); Mockito.when(projectComponent.getName()).thenReturn(projectName); PageOfProjectsResponseModel projectResponse = Mockito.mock(PageOfProjectsResponseModel.class); List<ProjectComponent> projectComponents = new ArrayList<>(1); projectComponents.add(projectComponent); Mockito.when(projectResponse.getProjects()).thenReturn(projectComponents); Mockito.when(projectService.getProjectsByName(Mockito.anyString())).thenReturn(projectResponse); try { IssueTrackerContext context = new IssueTrackerContext(null, issueConfig); jiraIssueConfigValidator.createValidIssueConfig(context); Assertions.assertEquals(resolveTransitionString, issueConfig.getResolveTransition().orElse("")); Assertions.assertEquals(projectName, issueConfig.getProjectName()); Assertions.assertEquals(issueCreatorString, issueConfig.getIssueCreator()); Assertions.assertEquals(issueTypeString, issueConfig.getIssueType()); } catch (AlertFieldException e) { fail(); } }
|
JiraCloudProperties implements IssueTrackerServiceConfig { public JiraCloudServiceFactory createJiraServicesCloudFactory(Logger logger, Gson gson) throws IssueTrackerException { JiraCloudRestConfig jiraServerConfig = createJiraServerConfig(); Slf4jIntLogger intLogger = new Slf4jIntLogger(logger); JiraHttpClient jiraHttpClient = jiraServerConfig.createJiraHttpClient(intLogger); return new JiraCloudServiceFactory(intLogger, jiraHttpClient, gson); } JiraCloudProperties(String url, String accessToken, String username, boolean pluginCheckDisabled); JiraCloudRestConfig createJiraServerConfig(); JiraCloudServiceFactory createJiraServicesCloudFactory(Logger logger, Gson gson); String getUrl(); String getAccessToken(); String getUsername(); boolean isPluginCheckDisabled(); }
|
@Test public void testServerServiceFactory() { try { JiraCloudProperties properties = new JiraCloudProperties("http: JiraCloudServiceFactory serviceFactory = properties.createJiraServicesCloudFactory(LoggerFactory.getLogger(getClass()), new Gson()); assertNotNull(serviceFactory); } catch (IssueTrackerException ex) { ex.printStackTrace(); fail(); } }
|
ResponseBodyBuilder { public ResponseBodyBuilder() { map = new JsonObject(); } ResponseBodyBuilder(); ResponseBodyBuilder(String id, String message); ResponseBodyBuilder(String message); ResponseBodyBuilder put(String key, Boolean value); ResponseBodyBuilder put(String key, Number value); ResponseBodyBuilder put(String key, String value); ResponseBodyBuilder putErrors(List<AlertFieldStatus> errors); String build(); @Override String toString(); }
|
@Test public void testResponseBodyBuilder() { ResponseBodyBuilder responseBodyBuilder = new ResponseBodyBuilder("55L", "Message"); responseBodyBuilder.put("Key1", "Value"); responseBodyBuilder.put("Key2", 22); responseBodyBuilder.put("Key3", false); assertEquals("{\"id\":\"55L\",\"message\":\"Message\",\"Key1\":\"Value\",\"Key2\":22,\"Key3\":false}", responseBodyBuilder.build()); }
|
FieldValueModel extends AlertSerializableModel { public Collection<String> getValues() { if (null != values) { return values; } return Set.of(); } private FieldValueModel(); FieldValueModel(Collection<String> values, boolean isSet); Collection<String> getValues(); void setValues(Collection<String> values); @JsonIgnore Optional<String> getValue(); @JsonIgnore void setValue(String value); boolean getIsSet(); void setIsSet(boolean isSet); boolean hasValues(); boolean containsNoData(); }
|
@Test public void getValuesTest() { String duplicateTestValue = testValue; List<String> values = new ArrayList(); values.add(testValue); values.add(duplicateTestValue); FieldValueModel testFieldValueModel = new FieldValueModel(values, Boolean.TRUE); assertTrue(testFieldValueModel.getValues().containsAll(values)); assertEquals(1, testFieldValueModel.getValues().size(), "getValues is expected to return a Set of 1."); }
@Test public void getNullValuesTest() { FieldValueModel testFieldValueModel = createEmptyFieldValueModel(); assertTrue(testFieldValueModel.getValues().isEmpty()); }
|
FieldValueModel extends AlertSerializableModel { @JsonIgnore public Optional<String> getValue() { return getValues().stream().findFirst(); } private FieldValueModel(); FieldValueModel(Collection<String> values, boolean isSet); Collection<String> getValues(); void setValues(Collection<String> values); @JsonIgnore Optional<String> getValue(); @JsonIgnore void setValue(String value); boolean getIsSet(); void setIsSet(boolean isSet); boolean hasValues(); boolean containsNoData(); }
|
@Test public void getValueTest() { List<String> values = new ArrayList(); values.add(testValue); FieldValueModel testFieldValueModel = new FieldValueModel(values, Boolean.TRUE); assertTrue(testFieldValueModel.getValue().isPresent()); assertEquals(testValue, testFieldValueModel.getValue().get()); }
|
FieldValueModel extends AlertSerializableModel { @JsonIgnore public void setValue(String value) { if (null == value) { setValues(Set.of()); } else { setValues(Set.of(value)); } } private FieldValueModel(); FieldValueModel(Collection<String> values, boolean isSet); Collection<String> getValues(); void setValues(Collection<String> values); @JsonIgnore Optional<String> getValue(); @JsonIgnore void setValue(String value); boolean getIsSet(); void setIsSet(boolean isSet); boolean hasValues(); boolean containsNoData(); }
|
@Test public void setValueTest() { String overwrittenTestValue = "new-value-overwriting-testValue"; FieldValueModel testFieldValueModel = createEmptyFieldValueModel(); testFieldValueModel.setValue(testValue); testFieldValueModel.setValue(overwrittenTestValue); assertTrue(testFieldValueModel.getValues().contains(overwrittenTestValue)); assertEquals(1, testFieldValueModel.getValues().size(), "getValues is expected to return a Set of 1."); }
|
FieldValueModel extends AlertSerializableModel { public void setIsSet(boolean isSet) { this.isSet = isSet; } private FieldValueModel(); FieldValueModel(Collection<String> values, boolean isSet); Collection<String> getValues(); void setValues(Collection<String> values); @JsonIgnore Optional<String> getValue(); @JsonIgnore void setValue(String value); boolean getIsSet(); void setIsSet(boolean isSet); boolean hasValues(); boolean containsNoData(); }
|
@Test public void setIsSetTest() { FieldValueModel testFieldValueModel = createEmptyFieldValueModel(); testFieldValueModel.setIsSet(Boolean.FALSE); assertFalse(testFieldValueModel.getIsSet()); }
|
FieldValueModel extends AlertSerializableModel { public boolean hasValues() { return !getValues().isEmpty(); } private FieldValueModel(); FieldValueModel(Collection<String> values, boolean isSet); Collection<String> getValues(); void setValues(Collection<String> values); @JsonIgnore Optional<String> getValue(); @JsonIgnore void setValue(String value); boolean getIsSet(); void setIsSet(boolean isSet); boolean hasValues(); boolean containsNoData(); }
|
@Test public void hasValuesTest() { FieldValueModel testFieldValueModel = createEmptyFieldValueModel(); FieldValueModel testFieldValueModelNoValues = createEmptyFieldValueModel(); List<String> values = new ArrayList(); values.add(testValue); testFieldValueModel.setValues(values); assertTrue(testFieldValueModel.hasValues()); assertFalse(testFieldValueModelNoValues.hasValues()); }
|
DefaultSettingsKeyAccessor implements SettingsKeyAccessor { @Override public SettingsKeyModel saveSettingsKey(String key, String value) { Optional<SettingsKeyEntity> settingsKeyOptional = settingsKeyRepository.findByKey(key); if (settingsKeyOptional.isPresent()) { Long id = settingsKeyOptional.get().getId(); SettingsKeyEntity settingsKeyEntity = new SettingsKeyEntity(key, value); settingsKeyEntity.setId(id); SettingsKeyEntity updatedSettingsKeyEntity = settingsKeyRepository.save(settingsKeyEntity); return convertToSettingsKeyModel(updatedSettingsKeyEntity); } SettingsKeyEntity newSettingsKeyEntity = settingsKeyRepository.save(new SettingsKeyEntity(key, value)); return convertToSettingsKeyModel(newSettingsKeyEntity); } DefaultSettingsKeyAccessor(SettingsKeyRepository settingsKeyRepository); @Override List<SettingsKeyModel> getSettingsKeys(); @Override Optional<SettingsKeyModel> getSettingsKeyByKey(String key); @Override SettingsKeyModel saveSettingsKey(String key, String value); @Override void deleteSettingsKeyByKey(String key); @Override void deleteSettingsKeyById(Long id); }
|
@Test public void saveSettingsKeyTest() { final String key = "key1"; final String key2 = "key2"; final String originalValue = "originalValue"; final String newValue = "newValue"; final String newValue2 = "newValue-2"; SettingsKeyEntity settingsKeyEntity = new SettingsKeyEntity(key, originalValue); settingsKeyEntity.setId(1L); SettingsKeyRepository settingsKeyRepository = new MockSettingsKeyRepository(); settingsKeyRepository.save(settingsKeyEntity); DefaultSettingsKeyAccessor settingsKeyAccessor = new DefaultSettingsKeyAccessor(settingsKeyRepository); SettingsKeyModel settingsKeyModel = settingsKeyAccessor.saveSettingsKey(key, newValue); SettingsKeyModel settingsKeyModelKeyNotPresent = settingsKeyAccessor.saveSettingsKey(key2, newValue2); assertEquals(key, settingsKeyModel.getKey()); assertEquals(newValue, settingsKeyModel.getValue()); assertEquals(key2, settingsKeyModelKeyNotPresent.getKey()); assertEquals(newValue2, settingsKeyModelKeyNotPresent.getValue()); }
|
FieldValueModel extends AlertSerializableModel { public boolean containsNoData() { return !hasValues() && !getIsSet(); } private FieldValueModel(); FieldValueModel(Collection<String> values, boolean isSet); Collection<String> getValues(); void setValues(Collection<String> values); @JsonIgnore Optional<String> getValue(); @JsonIgnore void setValue(String value); boolean getIsSet(); void setIsSet(boolean isSet); boolean hasValues(); boolean containsNoData(); }
|
@Test public void containsNoDataTest() { FieldValueModel testFieldValueModelNoValueIsNotSet = createEmptyFieldValueModel(); testFieldValueModelNoValueIsNotSet.setIsSet((Boolean.FALSE)); FieldValueModel testFieldValueModelNoValue = createEmptyFieldValueModel(); FieldValueModel testFieldValueModelIsNotSet = createEmptyFieldValueModel(); testFieldValueModelIsNotSet.setValue(testValue); testFieldValueModelIsNotSet.setIsSet(Boolean.FALSE); FieldValueModel testFieldValueModel = createEmptyFieldValueModel(); testFieldValueModel.setValue(testValue); assertTrue(testFieldValueModelNoValueIsNotSet.containsNoData()); assertFalse(testFieldValueModelNoValue.containsNoData()); assertFalse(testFieldValueModelIsNotSet.containsNoData()); assertFalse(testFieldValueModel.containsNoData()); }
|
Configuration extends AlertSerializableModel { public FieldUtility getFieldUtility() { return fieldUtility; } Configuration(@NotNull Map<String, ConfigurationFieldModel> keyToFieldMap); FieldUtility getFieldUtility(); }
|
@Test public void getFieldAccessorTest() { String fieldKey = "Key1"; ConfigurationFieldModel testConfigurationFieldModel = Mockito.mock(ConfigurationFieldModel.class); Map<String, ConfigurationFieldModel> keyToFieldMapTest = new HashMap<>(); keyToFieldMapTest.put(fieldKey, testConfigurationFieldModel); Configuration testConfig = new Configuration(keyToFieldMapTest); FieldUtility testFieldUtility = testConfig.getFieldUtility(); Optional<ConfigurationFieldModel> newConfigurationFieldModel = testFieldUtility.getField(fieldKey); assertTrue(newConfigurationFieldModel.isPresent()); assertEquals(testConfigurationFieldModel, newConfigurationFieldModel.get()); }
|
JobAuditModel extends Config { public String getConfigId() { return configId; } JobAuditModel(); JobAuditModel(final String id, final String configId, final String name, final String eventType, final AuditJobStatusModel auditJobStatusModel, final String errorMessage, final String errorStackTrace); String getConfigId(); String getName(); String getEventType(); AuditJobStatusModel getAuditJobStatusModel(); String getErrorMessage(); String getErrorStackTrace(); }
|
@Test public void getConfigIdTest() { assertEquals(testConfigId, testJobAuditModel.getConfigId()); }
|
JobAuditModel extends Config { public String getName() { return name; } JobAuditModel(); JobAuditModel(final String id, final String configId, final String name, final String eventType, final AuditJobStatusModel auditJobStatusModel, final String errorMessage, final String errorStackTrace); String getConfigId(); String getName(); String getEventType(); AuditJobStatusModel getAuditJobStatusModel(); String getErrorMessage(); String getErrorStackTrace(); }
|
@Test public void getNameTest() { assertEquals(testName, testJobAuditModel.getName()); }
|
JobAuditModel extends Config { public String getEventType() { return eventType; } JobAuditModel(); JobAuditModel(final String id, final String configId, final String name, final String eventType, final AuditJobStatusModel auditJobStatusModel, final String errorMessage, final String errorStackTrace); String getConfigId(); String getName(); String getEventType(); AuditJobStatusModel getAuditJobStatusModel(); String getErrorMessage(); String getErrorStackTrace(); }
|
@Test public void getEventTypeTest() { assertEquals(testEventType, testJobAuditModel.getEventType()); }
|
JobAuditModel extends Config { public AuditJobStatusModel getAuditJobStatusModel() { return auditJobStatusModel; } JobAuditModel(); JobAuditModel(final String id, final String configId, final String name, final String eventType, final AuditJobStatusModel auditJobStatusModel, final String errorMessage, final String errorStackTrace); String getConfigId(); String getName(); String getEventType(); AuditJobStatusModel getAuditJobStatusModel(); String getErrorMessage(); String getErrorStackTrace(); }
|
@Test public void getAuditJobStatusModelTest() { assertEquals(testAuditJobStatusModel, testJobAuditModel.getAuditJobStatusModel()); }
|
JobAuditModel extends Config { public String getErrorMessage() { return errorMessage; } JobAuditModel(); JobAuditModel(final String id, final String configId, final String name, final String eventType, final AuditJobStatusModel auditJobStatusModel, final String errorMessage, final String errorStackTrace); String getConfigId(); String getName(); String getEventType(); AuditJobStatusModel getAuditJobStatusModel(); String getErrorMessage(); String getErrorStackTrace(); }
|
@Test public void getErrorMessageTest() { assertEquals(testErrorMessage, testJobAuditModel.getErrorMessage()); }
|
JobAuditModel extends Config { public String getErrorStackTrace() { return errorStackTrace; } JobAuditModel(); JobAuditModel(final String id, final String configId, final String name, final String eventType, final AuditJobStatusModel auditJobStatusModel, final String errorMessage, final String errorStackTrace); String getConfigId(); String getName(); String getEventType(); AuditJobStatusModel getAuditJobStatusModel(); String getErrorMessage(); String getErrorStackTrace(); }
|
@Test public void getErrorStackTraceTest() { assertEquals(testErrorStackTrace, testJobAuditModel.getErrorStackTrace()); }
|
AlertPagedModel extends AlertSerializableModel { public int getTotalPages() { return totalPages; } AlertPagedModel(int totalPages, int currentPage, int pageSize, List<M> content); int getTotalPages(); int getCurrentPage(); int getPageSize(); List<M> getContent(); }
|
@Test public void getTotalPagesTest() { assertEquals(testTotalPages, testAlertPagedModel.getTotalPages()); }
|
AlertPagedModel extends AlertSerializableModel { public int getCurrentPage() { return currentPage; } AlertPagedModel(int totalPages, int currentPage, int pageSize, List<M> content); int getTotalPages(); int getCurrentPage(); int getPageSize(); List<M> getContent(); }
|
@Test public void getCurrentPageTest() { assertEquals(testCurrentPage, testAlertPagedModel.getCurrentPage()); }
|
DefaultSettingsKeyAccessor implements SettingsKeyAccessor { @Override public void deleteSettingsKeyByKey(String key) { getSettingsKeyByKey(key).ifPresent(settingsKeyModel -> deleteSettingsKeyById(settingsKeyModel.getId())); } DefaultSettingsKeyAccessor(SettingsKeyRepository settingsKeyRepository); @Override List<SettingsKeyModel> getSettingsKeys(); @Override Optional<SettingsKeyModel> getSettingsKeyByKey(String key); @Override SettingsKeyModel saveSettingsKey(String key, String value); @Override void deleteSettingsKeyByKey(String key); @Override void deleteSettingsKeyById(Long id); }
|
@Test public void deleteSettingsKeyByKeyTest() { final String key = "key1"; final String originalValue = "originalValue"; SettingsKeyEntity settingsKeyEntity = new SettingsKeyEntity(key, originalValue); settingsKeyEntity.setId(1L); SettingsKeyRepository settingsKeyRepository = new MockSettingsKeyRepository(); settingsKeyRepository.save(settingsKeyEntity); DefaultSettingsKeyAccessor settingsKeyAccessor = new DefaultSettingsKeyAccessor(settingsKeyRepository); assertTrue(settingsKeyRepository.findByKey(key).isPresent()); settingsKeyAccessor.deleteSettingsKeyByKey(key); assertFalse(settingsKeyRepository.findByKey(key).isPresent()); }
|
AlertPagedModel extends AlertSerializableModel { public int getPageSize() { return pageSize; } AlertPagedModel(int totalPages, int currentPage, int pageSize, List<M> content); int getTotalPages(); int getCurrentPage(); int getPageSize(); List<M> getContent(); }
|
@Test public void getPageSizeTest() { assertEquals(testPageSize, testAlertPagedModel.getPageSize()); }
|
AlertPagedModel extends AlertSerializableModel { public List<M> getContent() { return content; } AlertPagedModel(int totalPages, int currentPage, int pageSize, List<M> content); int getTotalPages(); int getCurrentPage(); int getPageSize(); List<M> getContent(); }
|
@Test public void getContentTest() { assertEquals(testContent, testAlertPagedModel.getContent()); }
|
FieldModel extends Config { private FieldModel() { this(null, null, null, null, null); } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }
|
@Test public void fieldModelTest() { String descriptor = "description1"; String context = "context1"; String key = "Key1"; String configId = "Id1"; String createdAt = "2020-01-22-14-11-20-124"; String lastUpdated = "2020-01-1"; FieldValueModel testFieldValueModel = Mockito.mock(FieldValueModel.class); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(key, testFieldValueModel); FieldModel testFieldModel = new FieldModel(configId, descriptor, context, createdAt, lastUpdated, keyToValues); assertEquals(descriptor, testFieldModel.getDescriptorName()); assertEquals(context, testFieldModel.getContext()); assertTrue(testFieldModel.getKeyToValues().containsKey(key)); assertEquals(configId, testFieldModel.getId()); assertEquals(createdAt, testFieldModel.getCreatedAt()); assertEquals(lastUpdated, testFieldModel.getLastUpdated()); }
|
FieldModel extends Config { public void setKeyToValues(final Map<String, FieldValueModel> keyToValues) { this.keyToValues = keyToValues; } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }
|
@Test public void setKeyToValuesTest() { String descriptor = "description1"; String context = "context1"; String key1 = "original key"; String key2 = "key to be added into keyToValues"; FieldValueModel testFieldValueModel = Mockito.mock(FieldValueModel.class); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(key1, testFieldValueModel); FieldModel testFieldModel = new FieldModel(descriptor, context, keyToValues); assertTrue(testFieldModel.getKeyToValues().containsKey(key1)); assertFalse(testFieldModel.getKeyToValues().containsKey(key2)); keyToValues.put(key2, testFieldValueModel); testFieldModel.setKeyToValues(keyToValues); assertTrue(testFieldModel.getKeyToValues().containsKey(key1)); assertTrue(testFieldModel.getKeyToValues().containsKey(key2)); }
|
FieldModel extends Config { public Optional<FieldValueModel> getFieldValueModel(final String key) { return Optional.ofNullable(keyToValues.get(key)); } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }
|
@Test public void getFieldValueModelTest() { String descriptor = "description1"; String context = "context1"; String keyValid = "Key1"; String keyBad = "This key is not in the Field Model"; FieldValueModel testFieldValueModel = Mockito.mock(FieldValueModel.class); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(keyValid, testFieldValueModel); FieldModel testFieldModel = new FieldModel(descriptor, context, keyToValues); Optional<FieldValueModel> verifyFieldValueModel = testFieldModel.getFieldValueModel(keyValid); assertTrue(verifyFieldValueModel.isPresent()); assertEquals(testFieldValueModel, verifyFieldValueModel.get()); verifyFieldValueModel = testFieldModel.getFieldValueModel(keyBad); assertFalse(verifyFieldValueModel.isPresent()); }
|
FieldModel extends Config { public Optional<String> getFieldValue(final String key) { return getFieldValueModel(key).flatMap(FieldValueModel::getValue); } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }
|
@Test public void getFieldValueTest() { String descriptor = "description1"; String context = "context1"; String key = "Key1"; String badKey = "This key doesn't exist"; String testFieldValue = "FieldValue1"; List<String> values = new ArrayList(); values.add(testFieldValue); FieldValueModel newFieldValueModel = new FieldValueModel(values, Boolean.TRUE); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(key, newFieldValueModel); FieldModel testFieldModel = new FieldModel(descriptor, context, keyToValues); Optional<String> value = testFieldModel.getFieldValue(key); assertEquals(testFieldValue, value.get()); assertTrue(value.isPresent()); value = testFieldModel.getFieldValue(badKey); assertFalse(value.isPresent()); }
|
FieldModel extends Config { public void putField(final String key, final FieldValueModel field) { keyToValues.put(key, field); } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }
|
@Test public void putFieldTest() { String descriptor = "description1"; String context = "context1"; String key = "Key1"; String newKey = "Key2"; FieldValueModel testFieldValueModel = Mockito.mock(FieldValueModel.class); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(key, testFieldValueModel); FieldModel testFieldModel = new FieldModel(descriptor, context, keyToValues); assertTrue(testFieldModel.getKeyToValues().containsKey(key)); assertFalse(testFieldModel.getKeyToValues().containsKey(newKey)); testFieldModel.putField(newKey, testFieldValueModel); assertTrue(testFieldModel.getKeyToValues().containsKey(key)); assertTrue(testFieldModel.getKeyToValues().containsKey(newKey), "The newKey was not successfully added into the testFieldModel."); }
|
FieldModel extends Config { public void removeField(final String key) { keyToValues.remove(key); } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }
|
@Test public void removeFieldTest() { String descriptor = "description1"; String context = "context1"; String keyValid = "Key1"; String keyToDelete = "Key2"; FieldValueModel testFieldValueModel = Mockito.mock(FieldValueModel.class); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(keyValid, testFieldValueModel); keyToValues.put(keyToDelete, testFieldValueModel); FieldModel testFieldModel = new FieldModel(descriptor, context, keyToValues); Map<String, FieldValueModel> testKeyToValues = testFieldModel.getKeyToValues(); assertTrue(testKeyToValues.containsKey(keyValid)); assertTrue(testKeyToValues.containsKey(keyToDelete)); testFieldModel.removeField(keyToDelete); testKeyToValues = testFieldModel.getKeyToValues(); assertTrue(testKeyToValues.containsKey(keyValid)); assertFalse(testKeyToValues.containsKey(keyToDelete), "The keyToDelete was not successfully removed."); }
|
FieldModel extends Config { public FieldModel fill(final FieldModel fieldModel) { final Map<String, FieldValueModel> fieldValueModelMap = new HashMap<>(); fieldValueModelMap.putAll(getKeyToValues()); final Map<String, FieldValueModel> fieldsToAdd = fieldModel.getKeyToValues(); for (final Map.Entry<String, FieldValueModel> entry : fieldsToAdd.entrySet()) { final String key = entry.getKey(); if (!fieldValueModelMap.containsKey(key) || fieldValueModelMap.get(key).getValue().isEmpty()) { fieldValueModelMap.put(key, entry.getValue()); } } final String modelDescriptorName = StringUtils.isNotBlank(getDescriptorName()) ? getDescriptorName() : fieldModel.getDescriptorName(); final String modelContext = StringUtils.isNotBlank(getContext()) ? getContext() : fieldModel.getContext(); final String modelCreatedAt = StringUtils.isNotBlank(getCreatedAt()) ? getCreatedAt() : fieldModel.getCreatedAt(); final String modelLastUpdated = StringUtils.isNotBlank(getLastUpdated()) ? getLastUpdated() : fieldModel.getLastUpdated(); final FieldModel newFieldModel = new FieldModel(modelDescriptorName, modelContext, modelCreatedAt, modelLastUpdated, fieldValueModelMap); final String id = StringUtils.isNotBlank(getId()) ? getId() : fieldModel.getId(); newFieldModel.setId(id); return newFieldModel; } private FieldModel(); FieldModel(String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, Map<String, FieldValueModel> keyToValues); FieldModel(String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); FieldModel(String configId, String descriptorName, String context, String createdAt, String lastUpdated, Map<String, FieldValueModel> keyToValues); String getDescriptorName(); String getContext(); String getCreatedAt(); String getLastUpdated(); Map<String, FieldValueModel> getKeyToValues(); void setKeyToValues(final Map<String, FieldValueModel> keyToValues); Optional<FieldValueModel> getFieldValueModel(final String key); Optional<String> getFieldValue(final String key); void putField(final String key, final FieldValueModel field); void removeField(final String key); FieldModel fill(final FieldModel fieldModel); }
|
@Test public void fillTest() { String descriptor = "description1"; String context = "context1"; String key = "Key1"; String configId = "Id1"; String createdAt = "2020-01-22-14-11-20-124"; String lastUpdated = "2020-01-1"; FieldValueModel testFieldValueModel = Mockito.mock(FieldValueModel.class); Map<String, FieldValueModel> keyToValues = new HashMap<>(); keyToValues.put(key, testFieldValueModel); FieldModel testFieldModel = new FieldModel(configId, descriptor, context, createdAt, lastUpdated, keyToValues); FieldModel newTestFieldModel = testFieldModel.fill(testFieldModel); assertEquals(testFieldModel, newTestFieldModel); assertFalse(testFieldModel == newTestFieldModel); assertEquals(descriptor, newTestFieldModel.getDescriptorName()); assertEquals(context, newTestFieldModel.getContext()); assertTrue(newTestFieldModel.getKeyToValues().containsKey(key)); assertEquals(configId, newTestFieldModel.getId()); assertEquals(createdAt, newTestFieldModel.getCreatedAt()); assertEquals(lastUpdated, newTestFieldModel.getLastUpdated()); }
|
JobFieldModel extends AlertSerializableModel { public JobFieldModel() { this(null, null); } JobFieldModel(); JobFieldModel(final String jobId, final Set<FieldModel> fieldModels); String getJobId(); void setJobId(final String jobId); Set<FieldModel> getFieldModels(); void setFieldModels(final Set<FieldModel> fieldModels); }
|
@Test public void jobFieldModelTest() { JobFieldModel testJobFieldModel = new JobFieldModel(); assertNull(testJobFieldModel.getJobId()); assertNull(testJobFieldModel.getFieldModels()); }
|
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public List<ConfigurationJobModel> getAllJobs() { List<ConfigGroupEntity> jobEntities = configGroupRepository.findAll(); SetMap<UUID, ConfigGroupEntity> jobMap = SetMap.createDefault(); for (ConfigGroupEntity entity : jobEntities) { UUID entityJobId = entity.getJobId(); jobMap.add(entityJobId, entity); } return jobMap.entrySet() .stream() .map(entry -> createJobModelFromExistingConfigs(entry.getKey(), entry.getValue())) .collect(Collectors.toList()); } @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; }
|
@Test public void getAllJobsTest() { UUID uuid = UUID.randomUUID(); ConfigGroupEntity configGroupEntity = new ConfigGroupEntity(1L, uuid); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(2L, 2L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(3L); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); FieldValueEntity fieldValueEntity = new FieldValueEntity(3L, 4L, fieldValue); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(4L); Mockito.when(configGroupRepository.findAll()).thenReturn(List.of(configGroupEntity)); setupGetJobMocks(descriptorConfigEntity, configContextEntity, fieldValueEntity, definedFieldEntity); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, definedFieldRepository, descriptorConfigRepository, configGroupRepository, configContextRepository, fieldValueRepository, encryptionUtility); List<ConfigurationJobModel> configurationJobModelList = configurationAccessor.getAllJobs(); assertEquals(1, configurationJobModelList.size()); ConfigurationJobModel configurationJobModel = configurationJobModelList.get(0); assertEquals(uuid, configurationJobModel.getJobId()); assertEquals(fieldValue, configurationJobModel.getName()); }
|
MessageContentGroupCsvCreator { public String createCsvString(MessageContentGroup messageContentGroup) { LinkableItem commonProvider = messageContentGroup.getCommonProvider(); LinkableItem commonTopic = messageContentGroup.getCommonTopic(); List<ProviderMessageContent> contents = messageContentGroup.getSubContent(); StringBuilder csvBuilder = new StringBuilder(); List<String> columnNames = createColumnNames(commonTopic, contents); appendLine(csvBuilder, columnNames); List<List<String>> rowValues = createRowValues(commonProvider, commonTopic, contents); for (List<String> row : rowValues) { appendLine(csvBuilder, row); } return csvBuilder.toString(); } String createCsvString(MessageContentGroup messageContentGroup); }
|
@Test public void createCsvStringTest() throws AlertException { MessageContentGroup messageContentGroup = new MessageContentGroup(); ProviderMessageContent.Builder providerMessageBuilder = new ProviderMessageContent.Builder(); providerMessageBuilder.applyProvider("Example Provider", 1L, "Example Config"); providerMessageBuilder.applyTopic("Example Topic Name", "Example Topic Value"); ComponentItem.Builder componentItemBuilder = new ComponentItem.Builder(); componentItemBuilder.applyNotificationId(1L); componentItemBuilder.applyOperation(ItemOperation.INFO); componentItemBuilder.applyCategory("Example Category"); componentItemBuilder.applyComponentData("Example Component Name", "Example Component Value", "https: componentItemBuilder.applySubComponent("Example SubComponent Name", "Example SubComponent Value", "https: componentItemBuilder.applyCategoryItem("Example Category Item Name", "Example Category Item Value"); componentItemBuilder.applyCategoryGroupingAttribute("Example Category Grouping Attribute Name", "Example Category Grouping Attribute Value"); providerMessageBuilder.applyComponentItem(componentItemBuilder.build()); messageContentGroup.add(providerMessageBuilder.build()); MessageContentGroupCsvCreator messageContentGroupCsvCreator = new MessageContentGroupCsvCreator(); String csvString = messageContentGroupCsvCreator.createCsvString(messageContentGroup); assertNotNull(csvString); }
|
DateUtils { public static OffsetDateTime createCurrentDateTimestamp() { return OffsetDateTime.now(ZoneOffset.UTC); } private DateUtils(); static OffsetDateTime createCurrentDateTimestamp(); static String createCurrentDateString(String format); static String formatDate(OffsetDateTime date, String format); static OffsetDateTime fromDateUTC(Date date); static OffsetDateTime parseDate(String dateTime, String format); static final String DOCKER_DATE_FORMAT; static final String AUDIT_DATE_FORMAT; static final String UTC_DATE_FORMAT_TO_MINUTE; }
|
@Test public void createCurrentDateTimestampOffsetTest() { OffsetDateTime alertDateTime = DateUtils.createCurrentDateTimestamp(); assertEquals(ZoneOffset.UTC, alertDateTime.getOffset()); }
@Test public void createCurrentDateTimestampZonedDateTimeTest() { OffsetDateTime alertDateTime = DateUtils.createCurrentDateTimestamp(); ZonedDateTime localZonedDateTime = ZonedDateTime.now(); ZonedDateTime reZonedLocalTime = localZonedDateTime.withZoneSameInstant(alertDateTime.getOffset()); assertEquals(alertDateTime.getHour(), reZonedLocalTime.getHour()); assertEquals(alertDateTime.getMinute(), reZonedLocalTime.getMinute()); }
@Test public void checkCurrentTime() throws InterruptedException { OffsetDateTime firstTimeStamp = DateUtils.createCurrentDateTimestamp(); TimeUnit.SECONDS.sleep(1); OffsetDateTime currentDateTimestamp = DateUtils.createCurrentDateTimestamp(); assertTrue(currentDateTimestamp.isAfter(firstTimeStamp)); assertTrue(firstTimeStamp.isBefore(currentDateTimestamp)); }
|
DataStructureUtils { public static <K, V> Map<K, V> mapToValues(Collection<V> valueCollection, Function<V, K> keyExtractor) { return mapToMap(valueCollection, keyExtractor, Function.identity()); } private DataStructureUtils(); static Map<K, V> mapToValues(Collection<V> valueCollection, Function<V, K> keyExtractor); static Map<K, V> mapToKeys(Collection<K> valueCollection, Function<K, V> valueExtractor); static Map<K, V> mapToMap(Collection<C> valueCollection, Function<C, K> keyExtractor, Function<C, V> valueExtractor); }
|
@Test public void convertListWithNameKey() { String key1 = "key1"; String key2 = "key2"; TestObject testObject1 = new TestObject(key1, "something"); TestObject testObject2 = new TestObject(key2, "something"); Map<String, TestObject> mapWithNameKey = DataStructureUtils.mapToValues(List.of(testObject1, testObject2), TestObject::getName); assertTrue(mapWithNameKey.containsKey(key1)); assertTrue(mapWithNameKey.containsKey(key2)); assertEquals(testObject1, mapWithNameKey.get(key1)); assertFalse(mapWithNameKey.containsKey(testObject1)); assertFalse(mapWithNameKey.containsKey(testObject1.getDesc())); }
|
DataStructureUtils { public static <K, V> Map<K, V> mapToKeys(Collection<K> valueCollection, Function<K, V> valueExtractor) { return mapToMap(valueCollection, Function.identity(), valueExtractor); } private DataStructureUtils(); static Map<K, V> mapToValues(Collection<V> valueCollection, Function<V, K> keyExtractor); static Map<K, V> mapToKeys(Collection<K> valueCollection, Function<K, V> valueExtractor); static Map<K, V> mapToMap(Collection<C> valueCollection, Function<C, K> keyExtractor, Function<C, V> valueExtractor); }
|
@Test public void convertListWithObjectKey() { String key1 = "key1"; String key2 = "key2"; TestObject testObject1 = new TestObject(key1, "something"); TestObject testObject2 = new TestObject(key2, "something"); Map<TestObject, String> mapWithObjectKey = DataStructureUtils.mapToKeys(List.of(testObject1, testObject2), TestObject::getName); assertTrue(mapWithObjectKey.containsKey(testObject1)); assertTrue(mapWithObjectKey.containsKey(testObject2)); assertEquals(key1, mapWithObjectKey.get(testObject1)); assertFalse(mapWithObjectKey.containsKey(key1)); }
|
DataStructureUtils { public static <K, V, C> Map<K, V> mapToMap(Collection<C> valueCollection, Function<C, K> keyExtractor, Function<C, V> valueExtractor) { return valueCollection.stream().collect(Collectors.toMap(keyExtractor::apply, valueExtractor::apply)); } private DataStructureUtils(); static Map<K, V> mapToValues(Collection<V> valueCollection, Function<V, K> keyExtractor); static Map<K, V> mapToKeys(Collection<K> valueCollection, Function<K, V> valueExtractor); static Map<K, V> mapToMap(Collection<C> valueCollection, Function<C, K> keyExtractor, Function<C, V> valueExtractor); }
|
@Test public void convertListWithNameAndObject() { String key1 = "key1"; String key2 = "key2"; TestObject testObject1 = new TestObject(key1, "something"); TestObject testObject2 = new TestObject(key2, "something"); Map<String, String> mapWithNameAndObjectKey = DataStructureUtils.mapToMap(List.of(testObject1, testObject2), TestObject::getName, TestObject::getDesc); assertEquals(2, mapWithNameAndObjectKey.size()); assertTrue(mapWithNameAndObjectKey.containsKey(key1)); assertTrue(mapWithNameAndObjectKey.containsKey(key2)); assertEquals(testObject1.getDesc(), mapWithNameAndObjectKey.get(key1)); assertEquals(testObject2.getDesc(), mapWithNameAndObjectKey.get(key2)); }
|
MessageContentKey extends AlertSerializableModel { public static MessageContentKey from(final String topicName, final String topicValue) { final String partialKey = String.format("%s%s%s", topicName, SEPARATOR, topicValue); return new MessageContentKey(partialKey); } private MessageContentKey(final String key); static MessageContentKey from(final String topicName, final String topicValue); static MessageContentKey from(final String topicName, final String topicValue, final String subTopicName, final String subTopicValue); static MessageContentKey from(final String topicName, final String topicValue, final Set<LinkableItem> subTopics); String getKey(); }
|
@Test public void equalsTest() { final String topicName = "Topic"; final String topicValue = "My Topic"; final String subTopicName = "Sub Topic"; final String subTopicValue = "A Sub Topic"; final MessageContentKey contentKey1 = MessageContentKey.from(topicName, topicValue); final MessageContentKey contentKey2 = MessageContentKey.from(topicName, topicValue); final MessageContentKey contentKey3 = MessageContentKey.from(topicName, topicValue, subTopicName, subTopicValue); final MessageContentKey contentKey4 = MessageContentKey.from(topicName, topicValue, subTopicName, subTopicValue); assertEquals(contentKey1, contentKey2); assertNotEquals(contentKey1, contentKey3); assertEquals(contentKey3, contentKey4); }
|
ProviderConfigMissingValidator extends BaseSystemValidator { public void validate() { removeSystemMessagesByType(SystemMessageType.BLACKDUCK_PROVIDER_CONFIGURATION_MISSING); for (Provider provider : providers) { try { List<ConfigurationModel> configurations = configurationAccessor.getConfigurationsByDescriptorKeyAndContext(provider.getKey(), ConfigContextEnum.GLOBAL); boolean emptyConfiguration = isConfigurationsEmpty(configurations); if (emptyConfiguration) { addSystemMessageForError(MISSING_BLACKDUCK_CONFIG_ERROR_FORMAT, SystemMessageSeverity.WARNING, SystemMessageType.BLACKDUCK_PROVIDER_CONFIGURATION_MISSING, true); } } catch (AlertDatabaseConstraintException ex) { logger.debug("Error getting provider configurations", ex); addSystemMessageForError(MISSING_BLACKDUCK_CONFIG_ERROR_FORMAT, SystemMessageSeverity.WARNING, SystemMessageType.BLACKDUCK_PROVIDER_CONFIGURATION_MISSING, true); } } } @Autowired ProviderConfigMissingValidator(SystemMessageAccessor systemMessageAccessor, List<Provider> providers,
ConfigurationAccessor configurationAccessor); void validate(); static final String MISSING_BLACKDUCK_CONFIG_ERROR_FORMAT; }
|
@Test public void testMissingProviders() { SystemMessageAccessor systemMessageAccessor = Mockito.mock(SystemMessageAccessor.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); List<Provider> providers = List.of(); ProviderConfigMissingValidator validator = new ProviderConfigMissingValidator(systemMessageAccessor, providers, configurationAccessor); validator.validate(); Mockito.verify(systemMessageAccessor, Mockito.never()) .addSystemMessage(Mockito.anyString(), Mockito.any(SystemMessageSeverity.class), Mockito.any(SystemMessageType.class)); }
@Test public void testEmptyConfigurationsList() throws Exception { SystemMessageAccessor systemMessageAccessor = Mockito.mock(SystemMessageAccessor.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); List<Provider> providers = List.of(Mockito.mock(Provider.class)); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(ProviderKey.class), Mockito.any(ConfigContextEnum.class))) .thenReturn(List.of()); ProviderConfigMissingValidator validator = new ProviderConfigMissingValidator(systemMessageAccessor, providers, configurationAccessor); validator.validate(); Mockito.verify(systemMessageAccessor) .addSystemMessage(Mockito.anyString(), Mockito.any(SystemMessageSeverity.class), Mockito.anyString()); }
@Test public void testConfigurationsThrowException() throws Exception { SystemMessageAccessor systemMessageAccessor = Mockito.mock(SystemMessageAccessor.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); List<Provider> providers = List.of(Mockito.mock(Provider.class)); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(ProviderKey.class), Mockito.any(ConfigContextEnum.class))) .thenThrow(AlertDatabaseConstraintException.class); ProviderConfigMissingValidator validator = new ProviderConfigMissingValidator(systemMessageAccessor, providers, configurationAccessor); validator.validate(); Mockito.verify(systemMessageAccessor) .addSystemMessage(Mockito.anyString(), Mockito.any(SystemMessageSeverity.class), Mockito.anyString()); }
@Test public void testEmptyConfigurations() throws Exception { SystemMessageAccessor systemMessageAccessor = Mockito.mock(SystemMessageAccessor.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); List<Provider> providers = List.of(Mockito.mock(Provider.class)); ConfigurationModel model = Mockito.mock(ConfigurationModel.class); Mockito.when(model.getCopyOfFieldList()).thenReturn(List.of()); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(ProviderKey.class), Mockito.any(ConfigContextEnum.class))) .thenReturn(List.of(model)); ProviderConfigMissingValidator validator = new ProviderConfigMissingValidator(systemMessageAccessor, providers, configurationAccessor); validator.validate(); Mockito.verify(systemMessageAccessor) .addSystemMessage(Mockito.anyString(), Mockito.any(SystemMessageSeverity.class), Mockito.anyString()); }
@Test public void testValidConfigurations() throws Exception { SystemMessageAccessor systemMessageAccessor = Mockito.mock(SystemMessageAccessor.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); List<Provider> providers = List.of(Mockito.mock(Provider.class)); ConfigurationModel model = Mockito.mock(ConfigurationModel.class); Mockito.when(model.getCopyOfFieldList()).thenReturn(List.of(Mockito.mock(ConfigurationFieldModel.class))); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(), Mockito.any())) .thenReturn(List.of(model)); ProviderConfigMissingValidator validator = new ProviderConfigMissingValidator(systemMessageAccessor, providers, configurationAccessor); validator.validate(); Mockito.verify(systemMessageAccessor, Mockito.never()) .addSystemMessage(Mockito.anyString(), Mockito.any(SystemMessageSeverity.class), Mockito.anyString()); }
|
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public Optional<ConfigurationJobModel> getJobById(UUID jobId) throws AlertDatabaseConstraintException { if (jobId == null) { throw new AlertDatabaseConstraintException(NULL_JOB_ID); } List<ConfigGroupEntity> jobConfigEntities = configGroupRepository.findByJobId(jobId); return jobConfigEntities .stream() .findAny() .map(configGroupEntity -> createJobModelFromExistingConfigs(configGroupEntity.getJobId(), jobConfigEntities)); } @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; }
|
@Test public void getJobByIdTest() throws Exception { UUID jobId = UUID.randomUUID(); ConfigGroupEntity configGroupEntity = new ConfigGroupEntity(1L, jobId); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(2L, 2L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(3L); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); FieldValueEntity fieldValueEntity = new FieldValueEntity(3L, 4L, fieldValue); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(4L); Mockito.when(configGroupRepository.findByJobId(Mockito.any())).thenReturn(List.of(configGroupEntity)); setupGetJobMocks(descriptorConfigEntity, configContextEntity, fieldValueEntity, definedFieldEntity); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, definedFieldRepository, descriptorConfigRepository, configGroupRepository, configContextRepository, fieldValueRepository, encryptionUtility); Optional<ConfigurationJobModel> configurationJobModelOptional = configurationAccessor.getJobById(jobId); assertTrue(configurationJobModelOptional.isPresent()); ConfigurationJobModel configurationJobModel = configurationJobModelOptional.get(); assertEquals(jobId, configurationJobModel.getJobId()); assertEquals(fieldValue, configurationJobModel.getName()); }
@Test public void getJobByIdNullTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.getJobById(null); fail("Null jobId did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
|
DefaultDescriptorGlobalConfigUtility { public DescriptorKey getKey() { return key; } DefaultDescriptorGlobalConfigUtility(DescriptorKey descriptorKey, ConfigurationAccessor configurationAccessor, ApiAction apiAction,
ConfigurationFieldModelConverter configurationFieldModelConverter); DescriptorKey getKey(); boolean doesConfigurationExist(); Optional<ConfigurationModel> getConfiguration(); Optional<FieldModel> getFieldModel(); FieldModel save(FieldModel fieldModel); FieldModel update(Long id, FieldModel fieldModel); }
|
@Test public void testGetKey() { DescriptorKey descriptorKey = createDescriptorKey(); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, null, null, null); assertEquals(descriptorKey, configUtility.getKey()); }
|
DefaultDescriptorGlobalConfigUtility { public boolean doesConfigurationExist() { try { return !configurationAccessor.getConfigurationsByDescriptorKeyAndContext(key, context).isEmpty(); } catch (AlertException ex) { logger.debug("Error reading configuration from database.", ex); return false; } } DefaultDescriptorGlobalConfigUtility(DescriptorKey descriptorKey, ConfigurationAccessor configurationAccessor, ApiAction apiAction,
ConfigurationFieldModelConverter configurationFieldModelConverter); DescriptorKey getKey(); boolean doesConfigurationExist(); Optional<ConfigurationModel> getConfiguration(); Optional<FieldModel> getFieldModel(); FieldModel save(FieldModel fieldModel); FieldModel update(Long id, FieldModel fieldModel); }
|
@Test public void testConfigurationExists() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, null, null); assertFalse(configUtility.doesConfigurationExist()); ConfigurationModel configurationModel = Mockito.mock(ConfigurationModel.class); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(DescriptorKey.class), Mockito.any(ConfigContextEnum.class))).thenReturn(List.of(configurationModel)); assertTrue(configUtility.doesConfigurationExist()); }
@Test public void testConfigurationExistsWithException() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(DescriptorKey.class), Mockito.any(ConfigContextEnum.class))).thenThrow(new AlertDatabaseConstraintException("Test exception")); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, null, null); assertFalse(configUtility.doesConfigurationExist()); }
|
DefaultDescriptorGlobalConfigUtility { public Optional<ConfigurationModel> getConfiguration() throws AlertException { return configurationAccessor.getConfigurationsByDescriptorKeyAndContext(key, context) .stream() .findFirst(); } DefaultDescriptorGlobalConfigUtility(DescriptorKey descriptorKey, ConfigurationAccessor configurationAccessor, ApiAction apiAction,
ConfigurationFieldModelConverter configurationFieldModelConverter); DescriptorKey getKey(); boolean doesConfigurationExist(); Optional<ConfigurationModel> getConfiguration(); Optional<FieldModel> getFieldModel(); FieldModel save(FieldModel fieldModel); FieldModel update(Long id, FieldModel fieldModel); }
|
@Test public void testGetConfiguration() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, null, null); assertFalse(configUtility.getConfiguration().isPresent()); ConfigurationModel configurationModel = Mockito.mock(ConfigurationModel.class); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(DescriptorKey.class), Mockito.any(ConfigContextEnum.class))).thenReturn(List.of(configurationModel)); assertTrue(configUtility.getConfiguration().isPresent()); }
|
DefaultDescriptorGlobalConfigUtility { public Optional<FieldModel> getFieldModel() throws AlertException { Optional<ConfigurationModel> configurationModelOptional = getConfiguration(); if (configurationModelOptional.isPresent()) { ConfigurationModel configurationModel = configurationModelOptional.get(); FieldModel fieldModel = configurationFieldModelConverter.convertToFieldModel(configurationModel); return Optional.ofNullable(apiAction.afterGetAction(fieldModel)); } return Optional.empty(); } DefaultDescriptorGlobalConfigUtility(DescriptorKey descriptorKey, ConfigurationAccessor configurationAccessor, ApiAction apiAction,
ConfigurationFieldModelConverter configurationFieldModelConverter); DescriptorKey getKey(); boolean doesConfigurationExist(); Optional<ConfigurationModel> getConfiguration(); Optional<FieldModel> getFieldModel(); FieldModel save(FieldModel fieldModel); FieldModel update(Long id, FieldModel fieldModel); }
|
@Test public void testGetFieldModelEmptyConfiguration() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ConfigurationFieldModelConverter converter = Mockito.mock(ConfigurationFieldModelConverter.class); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, null, converter); assertFalse(configUtility.getFieldModel().isPresent()); }
@Test public void testGetFieldModel() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); FieldModel fieldModel = new FieldModel(descriptorKey.getUniversalKey(), ConfigContextEnum.GLOBAL.name(), Map.of()); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ConfigurationFieldModelConverter converter = Mockito.mock(ConfigurationFieldModelConverter.class); ConfigurationModel configurationModel = Mockito.mock(ConfigurationModel.class); ApiAction apiAction = Mockito.mock(ApiAction.class); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(DescriptorKey.class), Mockito.any(ConfigContextEnum.class))).thenReturn(List.of(configurationModel)); Mockito.when(converter.convertToFieldModel(Mockito.any())).thenReturn(fieldModel); Mockito.when(apiAction.afterGetAction(Mockito.eq(fieldModel))).thenReturn(fieldModel); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, apiAction, converter); FieldModel actualFieldModel = configUtility.getFieldModel().orElse(null); assertEquals(fieldModel, actualFieldModel); }
@Test public void testGetFieldModelActionNull() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); FieldModel fieldModel = new FieldModel(descriptorKey.getUniversalKey(), ConfigContextEnum.GLOBAL.name(), Map.of()); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ConfigurationFieldModelConverter converter = Mockito.mock(ConfigurationFieldModelConverter.class); ConfigurationModel configurationModel = Mockito.mock(ConfigurationModel.class); ApiAction apiAction = Mockito.mock(ApiAction.class); Mockito.when(configurationAccessor.getConfigurationsByDescriptorKeyAndContext(Mockito.any(DescriptorKey.class), Mockito.any(ConfigContextEnum.class))).thenReturn(List.of(configurationModel)); Mockito.when(converter.convertToFieldModel(Mockito.any())).thenReturn(fieldModel); Mockito.when(apiAction.afterGetAction(Mockito.eq(fieldModel))).thenReturn(null); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, apiAction, converter); Optional<FieldModel> actualFieldModel = configUtility.getFieldModel(); assertFalse(actualFieldModel.isPresent()); }
|
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public List<ConfigurationJobModel> getJobsByFrequency(FrequencyType frequency) { return getAllJobs() .stream() .filter(job -> frequency == job.getFrequencyType()) .collect(Collectors.toList()); } @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; }
|
@Test public void getJobsByFrequency() { FrequencyType frequencyType = FrequencyType.DAILY; final Long jobId = 1L; UUID uuid = UUID.randomUUID(); String fieldValueFrequency = frequencyType.name(); final String fieldKeyFrequency = "channel.common.frequency"; ConfigGroupEntity configGroupEntity = new ConfigGroupEntity(jobId, uuid); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(2L, 2L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(3L); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); FieldValueEntity fieldValueEntity = new FieldValueEntity(3L, 4L, fieldValueFrequency); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKeyFrequency, false); definedFieldEntity.setId(4L); Mockito.when(configGroupRepository.findAll()).thenReturn(List.of(configGroupEntity)); setupGetJobMocks(descriptorConfigEntity, configContextEntity, fieldValueEntity, definedFieldEntity); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, definedFieldRepository, descriptorConfigRepository, configGroupRepository, configContextRepository, fieldValueRepository, encryptionUtility); List<ConfigurationJobModel> configurationJobModelList = configurationAccessor.getJobsByFrequency(frequencyType); assertEquals(1, configurationJobModelList.size()); ConfigurationJobModel configurationJobModel = configurationJobModelList.get(0); assertEquals(uuid, configurationJobModel.getJobId()); assertEquals(fieldValueFrequency, configurationJobModel.getFrequencyType().name()); }
|
DefaultDescriptorGlobalConfigUtility { public FieldModel save(FieldModel fieldModel) throws AlertException { FieldModel beforeAction = apiAction.beforeSaveAction(fieldModel); Collection<ConfigurationFieldModel> values = configurationFieldModelConverter.convertToConfigurationFieldModelMap(beforeAction).values(); ConfigurationModel configuration = configurationAccessor.createConfiguration(key, context, values); FieldModel convertedFieldModel = configurationFieldModelConverter.convertToFieldModel(configuration); return apiAction.afterSaveAction(convertedFieldModel); } DefaultDescriptorGlobalConfigUtility(DescriptorKey descriptorKey, ConfigurationAccessor configurationAccessor, ApiAction apiAction,
ConfigurationFieldModelConverter configurationFieldModelConverter); DescriptorKey getKey(); boolean doesConfigurationExist(); Optional<ConfigurationModel> getConfiguration(); Optional<FieldModel> getFieldModel(); FieldModel save(FieldModel fieldModel); FieldModel update(Long id, FieldModel fieldModel); }
|
@Test public void testSave() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); FieldModel fieldModel = new FieldModel(descriptorKey.getUniversalKey(), ConfigContextEnum.GLOBAL.name(), Map.of()); Map<String, ConfigurationFieldModel> configurationFieldModelCollection = Map.of(); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ConfigurationFieldModelConverter converter = Mockito.mock(ConfigurationFieldModelConverter.class); ConfigurationModel configurationModel = Mockito.mock(ConfigurationModel.class); ApiAction apiAction = Mockito.mock(ApiAction.class); Mockito.when(configurationAccessor.createConfiguration(Mockito.eq(descriptorKey), Mockito.any(ConfigContextEnum.class), Mockito.anyCollection())).thenReturn(configurationModel); Mockito.when(converter.convertToConfigurationFieldModelMap(Mockito.eq(fieldModel))).thenReturn(configurationFieldModelCollection); Mockito.when(converter.convertToFieldModel(Mockito.any())).thenReturn(fieldModel); Mockito.when(apiAction.beforeSaveAction(Mockito.eq(fieldModel))).thenReturn(fieldModel); Mockito.when(apiAction.afterSaveAction(Mockito.eq(fieldModel))).thenReturn(fieldModel); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, apiAction, converter); FieldModel savedModel = configUtility.save(fieldModel); assertEquals(fieldModel, savedModel); Mockito.verify(configurationAccessor).createConfiguration(Mockito.eq(descriptorKey), Mockito.eq(ConfigContextEnum.GLOBAL), Mockito.anyCollection()); }
|
DefaultDescriptorGlobalConfigUtility { public FieldModel update(Long id, FieldModel fieldModel) throws AlertException { FieldModel beforeUpdateActionFieldModel = apiAction.beforeUpdateAction(fieldModel); Map<String, ConfigurationFieldModel> valueMap = configurationFieldModelConverter.convertToConfigurationFieldModelMap(beforeUpdateActionFieldModel); Optional<ConfigurationModel> existingConfig = configurationAccessor.getConfigurationById(id); ConfigurationModel configurationModel; if (existingConfig.isPresent()) { Map<String, ConfigurationFieldModel> updatedValues = updateSensitiveFields(valueMap, existingConfig.get()); configurationModel = configurationAccessor.updateConfiguration(id, updatedValues.values()); } else { configurationModel = configurationAccessor.createConfiguration(key, context, valueMap.values()); } FieldModel convertedFieldModel = configurationFieldModelConverter.convertToFieldModel(configurationModel); return apiAction.afterUpdateAction(beforeUpdateActionFieldModel, convertedFieldModel); } DefaultDescriptorGlobalConfigUtility(DescriptorKey descriptorKey, ConfigurationAccessor configurationAccessor, ApiAction apiAction,
ConfigurationFieldModelConverter configurationFieldModelConverter); DescriptorKey getKey(); boolean doesConfigurationExist(); Optional<ConfigurationModel> getConfiguration(); Optional<FieldModel> getFieldModel(); FieldModel save(FieldModel fieldModel); FieldModel update(Long id, FieldModel fieldModel); }
|
@Test public void testUpdateNoExistingConfig() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); FieldModel fieldModel = new FieldModel(descriptorKey.getUniversalKey(), ConfigContextEnum.GLOBAL.name(), Map.of()); Map<String, ConfigurationFieldModel> configurationFieldModelCollection = Map.of(); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ConfigurationFieldModelConverter converter = Mockito.mock(ConfigurationFieldModelConverter.class); ConfigurationModel configurationModel = Mockito.mock(ConfigurationModel.class); ApiAction apiAction = Mockito.mock(ApiAction.class); Mockito.when(configurationAccessor.createConfiguration(Mockito.eq(descriptorKey), Mockito.any(ConfigContextEnum.class), Mockito.anyCollection())).thenReturn(configurationModel); Mockito.when(converter.convertToConfigurationFieldModelMap(Mockito.eq(fieldModel))).thenReturn(configurationFieldModelCollection); Mockito.when(converter.convertToFieldModel(Mockito.any())).thenReturn(fieldModel); Mockito.when(apiAction.beforeUpdateAction(Mockito.eq(fieldModel))).thenReturn(fieldModel); Mockito.when(apiAction.afterUpdateAction(Mockito.eq(fieldModel), Mockito.eq(fieldModel))).thenReturn(fieldModel); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, apiAction, converter); FieldModel savedModel = configUtility.update(1L, fieldModel); assertEquals(fieldModel, savedModel); }
@Test public void testUpdate() throws Exception { DescriptorKey descriptorKey = createDescriptorKey(); FieldModel fieldModel = new FieldModel(descriptorKey.getUniversalKey(), ConfigContextEnum.GLOBAL.name(), Map.of()); Map<String, ConfigurationFieldModel> configurationFieldModelCollection = Map.of(); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ConfigurationFieldModelConverter converter = Mockito.mock(ConfigurationFieldModelConverter.class); ConfigurationModel configurationModel = Mockito.mock(ConfigurationModel.class); ApiAction apiAction = Mockito.mock(ApiAction.class); Mockito.when(configurationAccessor.getConfigurationById(Mockito.anyLong())).thenReturn(Optional.of(configurationModel)); Mockito.when(configurationAccessor.createConfiguration(Mockito.eq(descriptorKey), Mockito.any(ConfigContextEnum.class), Mockito.anyCollection())).thenReturn(configurationModel); Mockito.when(converter.convertToConfigurationFieldModelMap(Mockito.eq(fieldModel))).thenReturn(configurationFieldModelCollection); Mockito.when(converter.convertToFieldModel(Mockito.any())).thenReturn(fieldModel); Mockito.when(apiAction.beforeUpdateAction(Mockito.eq(fieldModel))).thenReturn(fieldModel); Mockito.when(apiAction.afterUpdateAction(Mockito.eq(fieldModel), Mockito.eq(fieldModel))).thenReturn(fieldModel); DefaultDescriptorGlobalConfigUtility configUtility = new DefaultDescriptorGlobalConfigUtility(descriptorKey, configurationAccessor, apiAction, converter); FieldModel savedModel = configUtility.update(1L, fieldModel); assertEquals(fieldModel, savedModel); Mockito.verify(configurationAccessor).updateConfiguration(Mockito.anyLong(), Mockito.anyCollection()); }
|
ValidationResult { public Collection<String> getErrors() { return errors; } private ValidationResult(); private ValidationResult(Collection<String> errors, Collection<String> warnings); static ValidationResult success(); static ValidationResult errors(Collection<String> errors); static ValidationResult errors(String... errors); static ValidationResult warnings(Collection<String> warnings); static ValidationResult warnings(String... warnings); static ValidationResult of(ValidationResult... validationResults); Collection<String> getErrors(); Collection<String> getWarnings(); boolean hasErrors(); boolean hasWarnings(); String combineErrorMessages(); String combineWarningMessages(); }
|
@Test public void getErrorsTest() { ValidationResult errors = ValidationResult.errors(ERROR_MESSAGE_1); ArrayList<String> errorList = new ArrayList<>(errors.getErrors()); assertEquals(1, errorList.size()); assertEquals(ERROR_MESSAGE_1, errorList.get(0)); }
|
ValidationResult { public Collection<String> getWarnings() { return warnings; } private ValidationResult(); private ValidationResult(Collection<String> errors, Collection<String> warnings); static ValidationResult success(); static ValidationResult errors(Collection<String> errors); static ValidationResult errors(String... errors); static ValidationResult warnings(Collection<String> warnings); static ValidationResult warnings(String... warnings); static ValidationResult of(ValidationResult... validationResults); Collection<String> getErrors(); Collection<String> getWarnings(); boolean hasErrors(); boolean hasWarnings(); String combineErrorMessages(); String combineWarningMessages(); }
|
@Test public void getWarningsTest() { ValidationResult warnings = ValidationResult.warnings(WARNING_MESSAGE_1); ArrayList<String> warningList = new ArrayList<>(warnings.getWarnings()); assertEquals(1, warningList.size()); assertEquals(WARNING_MESSAGE_1, warningList.get(0)); }
|
ValidationResult { public boolean hasErrors() { return !errors.isEmpty(); } private ValidationResult(); private ValidationResult(Collection<String> errors, Collection<String> warnings); static ValidationResult success(); static ValidationResult errors(Collection<String> errors); static ValidationResult errors(String... errors); static ValidationResult warnings(Collection<String> warnings); static ValidationResult warnings(String... warnings); static ValidationResult of(ValidationResult... validationResults); Collection<String> getErrors(); Collection<String> getWarnings(); boolean hasErrors(); boolean hasWarnings(); String combineErrorMessages(); String combineWarningMessages(); }
|
@Test public void hasErrorsTest() { ValidationResult errors = ValidationResult.errors(ERROR_MESSAGE_1); ValidationResult emptyErrors = ValidationResult.success(); assertTrue(errors.hasErrors()); assertFalse(emptyErrors.hasErrors()); }
|
ValidationResult { public boolean hasWarnings() { return !warnings.isEmpty(); } private ValidationResult(); private ValidationResult(Collection<String> errors, Collection<String> warnings); static ValidationResult success(); static ValidationResult errors(Collection<String> errors); static ValidationResult errors(String... errors); static ValidationResult warnings(Collection<String> warnings); static ValidationResult warnings(String... warnings); static ValidationResult of(ValidationResult... validationResults); Collection<String> getErrors(); Collection<String> getWarnings(); boolean hasErrors(); boolean hasWarnings(); String combineErrorMessages(); String combineWarningMessages(); }
|
@Test public void hasWarningsTest() { ValidationResult warnings = ValidationResult.warnings(WARNING_MESSAGE_1); ValidationResult emptyWarnings = ValidationResult.success(); assertTrue(warnings.hasWarnings()); assertFalse(emptyWarnings.hasErrors()); }
|
ValidationResult { public String combineErrorMessages() { return combineMessages(errors); } private ValidationResult(); private ValidationResult(Collection<String> errors, Collection<String> warnings); static ValidationResult success(); static ValidationResult errors(Collection<String> errors); static ValidationResult errors(String... errors); static ValidationResult warnings(Collection<String> warnings); static ValidationResult warnings(String... warnings); static ValidationResult of(ValidationResult... validationResults); Collection<String> getErrors(); Collection<String> getWarnings(); boolean hasErrors(); boolean hasWarnings(); String combineErrorMessages(); String combineWarningMessages(); }
|
@Test public void combineErrorMessages() { List<String> listOfErrorStrings = List.of(ERROR_MESSAGE_1, ERROR_MESSAGE_2); ValidationResult errors = ValidationResult.errors(listOfErrorStrings); String expectedString = StringUtils.join(listOfErrorStrings, ", "); assertEquals(2, errors.getErrors().size()); assertEquals(expectedString, errors.combineErrorMessages()); }
|
ValidationResult { public String combineWarningMessages() { return combineMessages(warnings); } private ValidationResult(); private ValidationResult(Collection<String> errors, Collection<String> warnings); static ValidationResult success(); static ValidationResult errors(Collection<String> errors); static ValidationResult errors(String... errors); static ValidationResult warnings(Collection<String> warnings); static ValidationResult warnings(String... warnings); static ValidationResult of(ValidationResult... validationResults); Collection<String> getErrors(); Collection<String> getWarnings(); boolean hasErrors(); boolean hasWarnings(); String combineErrorMessages(); String combineWarningMessages(); }
|
@Test public void combineWarningMessages() { List<String> listOfWarningsStrings = List.of(WARNING_MESSAGE_1, WARNING_MESSAGE_2); ValidationResult warnings = ValidationResult.warnings(listOfWarningsStrings); String expectedString = StringUtils.join(listOfWarningsStrings, ", "); assertEquals(2, warnings.getWarnings().size()); assertEquals(expectedString, warnings.combineWarningMessages()); }
|
ChannelEventManager extends EventManager { @Override @Transactional public void sendEvent(AlertEvent alertEvent) { if (alertEvent instanceof DistributionEvent) { String destination = alertEvent.getDestination(); DistributionEvent distributionEvent = (DistributionEvent) alertEvent; UUID jobId = UUID.fromString(distributionEvent.getConfigId()); Map<Long, Long> notificationIdToAuditId = auditAccessor.createAuditEntry(distributionEvent.getNotificationIdToAuditId(), jobId, distributionEvent.getContent()); distributionEvent.setNotificationIdToAuditId(notificationIdToAuditId); String jsonMessage = getContentConverter().getJsonString(distributionEvent); getJmsTemplate().convertAndSend(destination, jsonMessage); } } @Autowired ChannelEventManager(ContentConverter contentConverter, JmsTemplate jmsTemplate, AuditAccessor auditAccessor); @Override @Transactional void sendEvent(AlertEvent alertEvent); }
|
@Test public void testNotAbstractChannelEvent() throws Exception { AuditAccessor auditAccessor = Mockito.mock(AuditAccessor.class); JmsTemplate jmsTemplate = Mockito.mock(JmsTemplate.class); ContentConverter contentConverter = Mockito.mock(ContentConverter.class); Mockito.doNothing().when(jmsTemplate).convertAndSend(Mockito.anyString(), Mockito.any(Object.class)); ChannelEventManager eventManager = new ChannelEventManager(contentConverter, jmsTemplate, auditAccessor); LinkableItem subTopic = new LinkableItem("subTopic", "sub topic", null); ProviderMessageContent content = new ProviderMessageContent.Builder() .applyProvider("testProvider", 1L, "testProviderConfig") .applyTopic("testTopic", "topic") .applySubTopic(subTopic.getName(), subTopic.getValue()) .build(); AlertEvent dbStoreEvent = new ContentEvent("", RestConstants.formatDate(new Date()), 1L, "FORMAT", MessageContentGroup.singleton(content)); eventManager.sendEvent(dbStoreEvent); }
|
ConfigurationModel extends AlertSerializableModel { public Long getDescriptorId() { return descriptorId; } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }
|
@Test public void getDescriptorIdTest() { ConfigurationModel configurationModel = createConfigurationModel(); assertEquals(descriptorId, configurationModel.getDescriptorId()); }
|
ConfigurationModel extends AlertSerializableModel { public Long getConfigurationId() { return configurationId; } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }
|
@Test public void getConfigurationIdTest() { ConfigurationModel configurationModel = createConfigurationModel(); assertEquals(configurationId, configurationModel.getConfigurationId()); }
|
ConfigurationModel extends AlertSerializableModel { public String getCreatedAt() { return createdAt; } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }
|
@Test public void getCreatedAtTest() { ConfigurationModel configurationModel = createConfigurationModel(); assertEquals(createdAt, configurationModel.getCreatedAt()); }
|
ConfigurationModel extends AlertSerializableModel { public String getLastUpdated() { return lastUpdated; } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }
|
@Test public void getLastUpdatedTest() { ConfigurationModel configurationModel = createConfigurationModel(); assertEquals(lastUpdated, configurationModel.getLastUpdated()); }
|
ConfigurationModel extends AlertSerializableModel { public ConfigContextEnum getDescriptorContext() { return context; } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }
|
@Test public void getDescriptorContextTest() { ConfigurationModel configurationModel = createConfigurationModel(); assertEquals(configContextEnum, configurationModel.getDescriptorContext()); }
|
ConfigurationModel extends AlertSerializableModel { public Optional<ConfigurationFieldModel> getField(String fieldKey) { Objects.requireNonNull(fieldKey); return Optional.ofNullable(configuredFields.get(fieldKey)); } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }
|
@Test public void getFieldTest() { ConfigurationModel configurationModel = createConfigurationModel(); assertTrue(configurationModel.getField(fieldKey).isPresent()); assertFalse(configurationModel.getField("badFieldKey").isPresent()); }
|
ConfigurationModel extends AlertSerializableModel { public List<ConfigurationFieldModel> getCopyOfFieldList() { return new ArrayList<>(configuredFields.values()); } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }
|
@Test public void getCopyOfFieldListTest() { ConfigurationModel configurationModel = createConfigurationModel(); List<ConfigurationFieldModel> fieldList = configurationModel.getCopyOfFieldList(); assertEquals(1, fieldList.size()); assertEquals(configurationFieldModel, fieldList.get(0)); }
|
ConfigurationModel extends AlertSerializableModel { public Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap() { return new HashMap<>(configuredFields); } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }
|
@Test public void getCopyOfKeyToFieldMapTest() { ConfigurationModel configurationModel = createConfigurationModel(); Map<String, ConfigurationFieldModel> keyToFieldMap = configurationModel.getCopyOfKeyToFieldMap(); assertFalse(keyToFieldMap.isEmpty()); assertTrue(keyToFieldMap.containsValue(configurationFieldModel)); }
|
ConfigurationModel extends AlertSerializableModel { public ConfigurationModelMutable createMutableCopy() { ConfigurationModelMutable mutableCopy = new ConfigurationModelMutable(descriptorId, configurationId, createdAt, lastUpdated, context); mutableCopy.getConfiguredFields().putAll(configuredFields); return mutableCopy; } ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); ConfigurationModel(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context, Map<String, ConfigurationFieldModel> configuredFields); Long getDescriptorId(); Long getConfigurationId(); String getCreatedAt(); String getLastUpdated(); ConfigContextEnum getDescriptorContext(); Optional<ConfigurationFieldModel> getField(String fieldKey); List<ConfigurationFieldModel> getCopyOfFieldList(); Map<String, ConfigurationFieldModel> getCopyOfKeyToFieldMap(); ConfigurationModelMutable createMutableCopy(); }
|
@Test public void createMutableCopyTest() { ConfigurationModel configurationModel = createConfigurationModel(); ConfigurationModelMutable configurationModelMutable = configurationModel.createMutableCopy(); assertEquals(configurationModel, configurationModelMutable); assertTrue(configurationModel != configurationModelMutable); }
|
ConfigurationModelMutable extends ConfigurationModel { public void put(ConfigurationFieldModel configFieldModel) { Objects.requireNonNull(configFieldModel); String fieldKey = configFieldModel.getFieldKey(); Objects.requireNonNull(fieldKey); if (getConfiguredFields().containsKey(fieldKey)) { ConfigurationFieldModel oldConfigField = getConfiguredFields().get(fieldKey); List<String> values = combine(oldConfigField, configFieldModel); oldConfigField.setFieldValues(values); } else { getConfiguredFields().put(fieldKey, configFieldModel); } } ConfigurationModelMutable(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, String context); ConfigurationModelMutable(Long registeredDescriptorId, Long descriptorConfigId, String createdAt, String lastUpdated, ConfigContextEnum context); void put(ConfigurationFieldModel configFieldModel); }
|
@Test public void putTest() { final String fieldValue2 = "fieldValue-2"; ConfigurationFieldModel configurationFieldModel2 = ConfigurationFieldModel.create(fieldKey); configurationFieldModel2.setFieldValue(fieldValue2); ConfigurationModelMutable configurationModelMutable = createConfigurationModelMutable(); configurationModelMutable.put(configurationFieldModel); configurationModelMutable.put(configurationFieldModel2); Optional<ConfigurationFieldModel> testConfigurationFieldModelOptional = configurationModelMutable.getField(fieldKey); assertTrue(testConfigurationFieldModelOptional.isPresent()); ArrayList<String> fieldValues = new ArrayList<>(testConfigurationFieldModelOptional.get().getFieldValues()); assertEquals(2, fieldValues.size()); assertTrue(fieldValues.contains(fieldValue)); assertTrue(fieldValues.contains(fieldValue2)); }
@Test public void getFieldTest() { ConfigurationModelMutable configurationModelMutable = new ConfigurationModelMutable(descriptorId, configurationId, createdAt, lastUpdated, configContextEnum.name()); configurationModelMutable.put(configurationFieldModel); Optional<ConfigurationFieldModel> testConfigurationFieldModel = configurationModelMutable.getField(fieldKey); Optional<ConfigurationFieldModel> testConfigurationFieldModelEmpty = configurationModelMutable.getField("badKey"); assertTrue(testConfigurationFieldModel.isPresent()); assertFalse(testConfigurationFieldModelEmpty.isPresent()); assertEquals(configurationFieldModel, testConfigurationFieldModel.get()); }
@Test public void getCopyOfFieldListTest() { ConfigurationModelMutable configurationModelMutable = createConfigurationModelMutable(); configurationModelMutable.put(configurationFieldModel); List<ConfigurationFieldModel> testConfigurationFieldModelList = configurationModelMutable.getCopyOfFieldList(); assertEquals(1, testConfigurationFieldModelList.size()); assertEquals(configurationFieldModel, testConfigurationFieldModelList.get(0)); }
@Test public void getCopyOfKeyToFieldMapTest() { ConfigurationModelMutable configurationModelMutable = createConfigurationModelMutable(); configurationModelMutable.put(configurationFieldModel); Map<String, ConfigurationFieldModel> configurationFieldModelMap = configurationModelMutable.getCopyOfKeyToFieldMap(); assertEquals(1, configurationFieldModelMap.size()); assertEquals(configurationFieldModel, configurationFieldModelMap.get(fieldKey)); }
|
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public ConfigurationJobModel createJob(Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields) throws AlertDatabaseConstraintException { return createJob(null, descriptorNames, configuredFields); } @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; }
|
@Test public void createJobTest() throws Exception { List<String> descriptorNames = List.of("descriptor-name-test"); ConfigurationFieldModel configurationFieldModel = ConfigurationFieldModel.create("channel.common.name"); configurationFieldModel.setFieldValue(fieldValue); List<ConfigurationFieldModel> configuredFields = List.of(configurationFieldModel); RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity("name", 1L); registeredDescriptorEntity.setId(2L); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); configContextEntity.setId(3L); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(4L); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(5L, 6L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(5L); setupCreateJobMocks(registeredDescriptorEntity, configContextEntity, definedFieldEntity, descriptorConfigEntity); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(registeredDescriptorRepository, null, definedFieldRepository, descriptorConfigRepository, configGroupRepository, configContextRepository, fieldValueRepository, null); ConfigurationJobModel configurationJobModel = configurationAccessor.createJob(descriptorNames, configuredFields); assertEquals(fieldValue, configurationJobModel.getName()); }
|
TopLevelActionCombiner implements MessageCombiner { @Override public List<ProviderMessageContent> combine(List<ProviderMessageContent> messages) { Map<String, List<ProviderMessageContent>> providerMessagesCache = new LinkedHashMap<>(); for (ProviderMessageContent message : messages) { String cacheKey = flattenProviderAndTopic(message); if (isTopLevelDelete(message)) { List<ProviderMessageContent> cachedMessages = providerMessagesCache.get(cacheKey); if (null != cachedMessages) { boolean didUpdate = updateCache(message, cachedMessages); if (didUpdate) { continue; } } } providerMessagesCache.computeIfAbsent(cacheKey, ignored -> new LinkedList<>()).add(message); } return Stream .of(providerMessagesCache.values()) .flatMap(Collection::stream) .flatMap(List::stream) .collect(Collectors.toList()); } @Override List<ProviderMessageContent> combine(List<ProviderMessageContent> messages); }
|
@Test public void combineWithSubTopicTest() throws AlertException { TopLevelActionCombiner topLevelActionCombiner = new TopLevelActionCombiner(); String commonProviderValue = "common_provider"; Long commonProviderId = 1L; String commonProviderConfig = "common_provider_config"; String commonTopicName = "common topic name"; String commonTopicValue = "common topic value"; String commonSubTopicName = "common_sub_topic_name"; String commonSubTopicValue = "common.sub.topic.value"; ProviderMessageContent addAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.ADD) .build(); ProviderMessageContent updateAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.UPDATE) .build(); ProviderMessageContent infoAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.INFO) .build(); ProviderMessageContent unrelatedTopicAdd = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic("uncommon topic name 123", "random value") .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.ADD) .build(); ProviderMessageContent deleteAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.DELETE) .build(); List<ProviderMessageContent> orderedActionMessages = List.of(addAction, updateAction, infoAction, unrelatedTopicAdd, deleteAction); List<ProviderMessageContent> combinedMessages = topLevelActionCombiner.combine(orderedActionMessages); assertEquals(1, combinedMessages.size()); }
@Test public void combineWithoutSubTopicTest() throws AlertException { TopLevelActionCombiner topLevelActionCombiner = new TopLevelActionCombiner(); String commonProviderValue = "common_provider"; Long commonProviderId = 1L; String commonProviderConfig = "common_provider_config"; String commonTopicName = "common topic name"; String commonTopicValue = "common topic value"; String commonSubTopicName = "common_sub_topic_name"; String commonSubTopicValue = "common.sub.topic.value"; ProviderMessageContent addAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.ADD) .build(); ProviderMessageContent updateAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.UPDATE) .build(); ProviderMessageContent infoAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.INFO) .build(); ProviderMessageContent unrelatedTopicAdd = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic("uncommon topic name 123", "random value") .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.ADD) .build(); ProviderMessageContent deleteAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applyAction(ItemOperation.DELETE) .build(); List<ProviderMessageContent> orderedActionMessages = List.of(addAction, updateAction, infoAction, unrelatedTopicAdd, deleteAction); List<ProviderMessageContent> combinedMessages = topLevelActionCombiner.combine(orderedActionMessages); assertEquals(1, combinedMessages.size()); }
@Test public void combineWithoutSubTopicOnSomeTest() throws AlertException { TopLevelActionCombiner topLevelActionCombiner = new TopLevelActionCombiner(); String commonProviderValue = "common_provider"; Long commonProviderId = 1L; String commonProviderConfig = "common_provider_config"; String commonTopicName = "common topic name"; String commonTopicValue = "common topic value"; String commonSubTopicName = "common_sub_topic_name"; String commonSubTopicValue = "common.sub.topic.value"; ProviderMessageContent addAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.ADD) .build(); ProviderMessageContent updateAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applyAction(ItemOperation.UPDATE) .build(); ProviderMessageContent infoAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applyAction(ItemOperation.INFO) .build(); ProviderMessageContent unrelatedTopicAdd = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic("uncommon topic name 123", "random value") .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.ADD) .build(); ProviderMessageContent deleteAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.DELETE) .build(); List<ProviderMessageContent> orderedActionMessages = List.of(addAction, updateAction, infoAction, unrelatedTopicAdd, deleteAction); List<ProviderMessageContent> combinedMessages = topLevelActionCombiner.combine(orderedActionMessages); assertEquals(3, combinedMessages.size()); }
@Test public void combineWithComponentItemsTest() throws AlertException { TopLevelActionCombiner topLevelActionCombiner = new TopLevelActionCombiner(); String commonProviderValue = "common_provider"; Long commonProviderId = 1L; String commonProviderConfig = "common_provider_config"; String commonTopicName = "common topic name"; String commonTopicValue = "common topic value"; String commonSubTopicName = "common_sub_topic_name"; String commonSubTopicValue = "common.sub.topic.value"; ComponentItem componentItem = new ComponentItem.Builder() .applyCategory("example") .applyOperation(ItemOperation.INFO) .applyComponentData("exmaple", "example") .applyCategoryItem("examle", "example") .applyNotificationId(1L) .build(); ProviderMessageContent addAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.ADD) .build(); ProviderMessageContent updateAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyComponentItem(componentItem) .applyAction(ItemOperation.UPDATE) .build(); ProviderMessageContent infoAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyComponentItem(componentItem) .applyAction(ItemOperation.INFO) .build(); ProviderMessageContent unrelatedTopicAdd = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic("uncommon topic name 123", "random value") .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.ADD) .build(); ProviderMessageContent deleteAction = new ProviderMessageContent.Builder() .applyNotificationId(1L) .applyProvider(commonProviderValue, commonProviderId, commonProviderConfig) .applyTopic(commonTopicName, commonTopicValue) .applySubTopic(commonSubTopicName, commonSubTopicValue) .applyAction(ItemOperation.DELETE) .build(); List<ProviderMessageContent> orderedActionMessages = List.of(addAction, updateAction, infoAction, unrelatedTopicAdd, deleteAction); List<ProviderMessageContent> combinedMessages = topLevelActionCombiner.combine(orderedActionMessages); assertEquals(3, combinedMessages.size()); }
|
EventManager { @Transactional public void sendEvents(List<? extends AlertEvent> eventList) { if (!eventList.isEmpty()) { eventList.forEach(this::sendEvent); } } @Autowired EventManager(ContentConverter contentConverter, JmsTemplate jmsTemplate); @Transactional void sendEvents(List<? extends AlertEvent> eventList); @Transactional void sendEvent(AlertEvent event); JmsTemplate getJmsTemplate(); ContentConverter getContentConverter(); }
|
@Test public void testSendEvents() throws Exception { JmsTemplate jmsTemplate = Mockito.mock(JmsTemplate.class); ContentConverter contentConverter = Mockito.mock(ContentConverter.class); Mockito.doNothing().when(jmsTemplate).convertAndSend(Mockito.anyString(), Mockito.any(Object.class)); EventManager eventManager = new EventManager(contentConverter, jmsTemplate); LinkableItem subTopic = new LinkableItem("subTopic", "sub topic", null); ProviderMessageContent content = new ProviderMessageContent.Builder() .applyProvider("1", 1L, "providerConfig") .applyTopic("testTopic", "topic") .applySubTopic(subTopic.getName(), subTopic.getValue()) .build(); FieldUtility fieldUtility = new FieldUtility(Map.of()); DistributionEvent event = new DistributionEvent(UUID.randomUUID().toString(), "destination", RestConstants.formatDate(new Date()), 1L, "FORMAT", MessageContentGroup.singleton(content), fieldUtility); eventManager.sendEvents(List.of(event)); }
|
EventManager { @Transactional public void sendEvent(AlertEvent event) { String destination = event.getDestination(); String jsonMessage = contentConverter.getJsonString(event); jmsTemplate.convertAndSend(destination, jsonMessage); } @Autowired EventManager(ContentConverter contentConverter, JmsTemplate jmsTemplate); @Transactional void sendEvents(List<? extends AlertEvent> eventList); @Transactional void sendEvent(AlertEvent event); JmsTemplate getJmsTemplate(); ContentConverter getContentConverter(); }
|
@Test public void testNotAbstractChannelEvent() throws Exception { JmsTemplate jmsTemplate = Mockito.mock(JmsTemplate.class); ContentConverter contentConverter = Mockito.mock(ContentConverter.class); Mockito.doNothing().when(jmsTemplate).convertAndSend(Mockito.anyString(), Mockito.any(Object.class)); EventManager eventManager = new EventManager(contentConverter, jmsTemplate); LinkableItem subTopic = new LinkableItem("subTopic", "sub topic", null); ProviderMessageContent content = new ProviderMessageContent.Builder() .applyProvider("1", 1L, "providerConfig") .applyTopic("testTopic", "topic") .applySubTopic(subTopic.getName(), subTopic.getValue()) .build(); AlertEvent dbStoreEvent = new ContentEvent("", RestConstants.formatDate(new Date()), 1L, "FORMAT", MessageContentGroup.singleton(content)); eventManager.sendEvent(dbStoreEvent); }
|
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public ConfigurationJobModel updateJob(UUID jobId, Collection<String> descriptorNames, Collection<ConfigurationFieldModel> configuredFields) throws AlertDatabaseConstraintException { if (jobId == null) { throw new AlertDatabaseConstraintException(NULL_JOB_ID); } deleteJob(jobId); return createJob(jobId, descriptorNames, configuredFields); } @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; }
|
@Test public void updateJobTest() throws Exception { UUID uuid = UUID.randomUUID(); List<String> descriptorNames = List.of("descriptor-name-test"); ConfigurationFieldModel configurationFieldModel = ConfigurationFieldModel.create("channel.common.name"); configurationFieldModel.setFieldValue(fieldValue); List<ConfigurationFieldModel> configuredFields = List.of(configurationFieldModel); RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity("name", 1L); registeredDescriptorEntity.setId(2L); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); configContextEntity.setId(3L); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(4L); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(5L, 6L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(5L); ConfigGroupEntity configGroupEntity = new ConfigGroupEntity(6L, uuid); Mockito.when(configGroupRepository.findByJobId(Mockito.any())).thenReturn(List.of(configGroupEntity)); setupCreateJobMocks(registeredDescriptorEntity, configContextEntity, definedFieldEntity, descriptorConfigEntity); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(registeredDescriptorRepository, null, definedFieldRepository, descriptorConfigRepository, configGroupRepository, configContextRepository, fieldValueRepository, null); ConfigurationJobModel configurationJobModel = configurationAccessor.updateJob(uuid, descriptorNames, configuredFields); Mockito.verify(descriptorConfigRepository).deleteById(Mockito.any()); assertEquals(uuid, configurationJobModel.getJobId()); assertEquals(fieldValue, configurationJobModel.getName()); }
@Test public void updateJobNullIdTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.updateJob(null, null, null); fail("Null jobId did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
|
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; }
|
@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); } }
|
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public Optional<ConfigurationModel> getProviderConfigurationByName(String providerConfigName) throws AlertDatabaseConstraintException { if (StringUtils.isBlank(providerConfigName)) { throw new AlertDatabaseConstraintException("The provider configuration name cannot be null"); } Long fieldId = definedFieldRepository.findFirstByKey(ProviderDescriptor.KEY_PROVIDER_CONFIG_NAME) .map(DefinedFieldEntity::getId) .orElseThrow(() -> new AlertDatabaseConstraintException(String.format("The key '%s' is not registered in the database", ProviderDescriptor.KEY_PROVIDER_CONFIG_NAME))); List<Long> providerConfigIds = fieldValueRepository.findAllByFieldIdAndValue(fieldId, providerConfigName) .stream() .map(FieldValueEntity::getConfigId) .collect(Collectors.toList()); if (!providerConfigIds.isEmpty()) { for (Long configId : providerConfigIds) { Optional<ConfigurationModel> globalModel = getConfigurationById(configId) .filter(model -> model.getDescriptorContext() == ConfigContextEnum.GLOBAL); if (globalModel.isPresent()) { return globalModel; } } } 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; }
|
@Test public void getProviderConfigurationByNameTest() throws Exception { 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, false); 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()); 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); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, definedFieldRepository, descriptorConfigRepository, null, configContextRepository, fieldValueRepository, encryptionUtility); Optional<ConfigurationModel> configurationModelOptional = configurationAccessor.getProviderConfigurationByName(providerConfigName); Optional<ConfigurationModel> configurationModelProviderConfigsEmpty = configurationAccessor.getProviderConfigurationByName(emptyProviderConfigName); assertTrue(configurationModelOptional.isPresent()); assertFalse(configurationModelProviderConfigsEmpty.isPresent()); ConfigurationModel configurationModel = configurationModelOptional.get(); testConfigurationModel(configurationId, descriptorId, configurationModel); }
@Test public void getProviderConfigurationByNameBlankTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.getProviderConfigurationByName(""); fail("Blank providerConfigName did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
|
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; }
|
@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); } }
|
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public List<ConfigurationModel> getConfigurationsByDescriptorKey(DescriptorKey descriptorKey) throws AlertDatabaseConstraintException { if (null == descriptorKey || StringUtils.isBlank(descriptorKey.getUniversalKey())) { throw new AlertDatabaseConstraintException(String.format(EXCEPTION_FORMAT_DESCRIPTOR_KEY_IS_NOT_VALID, descriptorKey)); } Optional<RegisteredDescriptorEntity> registeredDescriptorEntity = registeredDescriptorRepository.findFirstByName(descriptorKey.getUniversalKey()); if (registeredDescriptorEntity.isPresent()) { return createConfigModels(Collections.singleton(registeredDescriptorEntity.get())); } return createConfigModels(Collections.emptyList()); } @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; }
|
@Test public void getConfigurationsByDescriptorKeyTest() throws Exception { final Long descriptorId = 3L; final Long configurationId = 5L; DescriptorKey descriptorKey = createDescriptorKey("descriptorKeyName"); DescriptorKey badDescriptorKey = createDescriptorKey("bad-descriptorKey"); RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity("name-test", 1L); registeredDescriptorEntity.setId(2L); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(descriptorId, 4L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(configurationId); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); FieldValueEntity fieldValueEntity = new FieldValueEntity(6L, 7L, fieldValue); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(8L); Mockito.when(registeredDescriptorRepository.findFirstByName(descriptorKey.getUniversalKey())).thenReturn(Optional.of(registeredDescriptorEntity)); Mockito.when(registeredDescriptorRepository.findFirstByName(badDescriptorKey.getUniversalKey())).thenReturn(Optional.empty()); setupCreatConfigMocks(descriptorConfigEntity, configContextEntity, fieldValueEntity, definedFieldEntity); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(registeredDescriptorRepository, null, definedFieldRepository, descriptorConfigRepository, null, configContextRepository, fieldValueRepository, encryptionUtility); List<ConfigurationModel> configurationModelList = configurationAccessor.getConfigurationsByDescriptorKey(descriptorKey); List<ConfigurationModel> configurationModelListEmpty = configurationAccessor.getConfigurationsByDescriptorKey(badDescriptorKey); assertEquals(1, configurationModelList.size()); assertTrue(configurationModelListEmpty.isEmpty()); ConfigurationModel configurationModel = configurationModelList.get(0); testConfigurationModel(configurationId, descriptorId, configurationModel); }
@Test public void getConfigurationsByDescriptorKeyNullTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.getConfigurationsByDescriptorKey(null); fail("Null descriptorKey did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
|
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; }
|
@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); }
|
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public List<ConfigurationModel> getConfigurationsByDescriptorType(DescriptorType descriptorType) throws AlertDatabaseConstraintException { if (null == descriptorType) { throw new AlertDatabaseConstraintException("Descriptor type cannot be null"); } Long typeId = descriptorTypeRepository .findFirstByType(descriptorType.name()) .map(DatabaseEntity::getId) .orElseThrow(() -> new AlertDatabaseConstraintException("Descriptor type has not been registered")); List<RegisteredDescriptorEntity> registeredDescriptorEntities = registeredDescriptorRepository.findByTypeId(typeId); return createConfigModels(registeredDescriptorEntities); } @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; }
|
@Test public void getConfigurationsByDescriptorTypeTest() throws Exception { final Long descriptorId = 3L; final Long configurationId = 5L; DescriptorType descriptorType = DescriptorType.CHANNEL; DescriptorTypeEntity descriptorTypeEntity = new DescriptorTypeEntity("CHANNEL"); descriptorTypeEntity.setId(1L); RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity("name-test", 1L); registeredDescriptorEntity.setId(2L); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(descriptorId, 4L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(configurationId); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); FieldValueEntity fieldValueEntity = new FieldValueEntity(6L, 7L, fieldValue); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(8L); Mockito.when(descriptorTypeRepository.findFirstByType(Mockito.any())).thenReturn(Optional.of(descriptorTypeEntity)); Mockito.when(registeredDescriptorRepository.findByTypeId(Mockito.any())).thenReturn(List.of(registeredDescriptorEntity)); setupCreatConfigMocks(descriptorConfigEntity, configContextEntity, fieldValueEntity, definedFieldEntity); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(registeredDescriptorRepository, descriptorTypeRepository, definedFieldRepository, descriptorConfigRepository, null, configContextRepository, fieldValueRepository, encryptionUtility); List<ConfigurationModel> configurationModelList = configurationAccessor.getConfigurationsByDescriptorType(descriptorType); assertEquals(1, configurationModelList.size()); ConfigurationModel configurationModel = configurationModelList.get(0); testConfigurationModel(configurationId, descriptorId, configurationModel); }
@Test public void getConfigurationsByDescriptorTypeNullTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.getConfigurationsByDescriptorType(null); fail("Null descriptorType did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
|
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public List<ConfigurationModel> getChannelConfigurationsByFrequency(FrequencyType frequencyType) throws AlertDatabaseConstraintException { if (null == frequencyType) { throw new AlertDatabaseConstraintException("Frequency type cannot be null"); } Long typeId = descriptorTypeRepository .findFirstByType(DescriptorType.CHANNEL.name()) .map(DatabaseEntity::getId) .orElseThrow(() -> new AlertDatabaseConstraintException("Descriptor type has not been registered")); List<RegisteredDescriptorEntity> registeredDescriptorEntities = registeredDescriptorRepository.findByTypeIdAndFrequency(typeId, frequencyType.name()); return createConfigModels(registeredDescriptorEntities); } @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; }
|
@Test public void getChannelConfigurationsByFrequencyTest() throws Exception { final Long descriptorId = 3L; final Long configurationId = 5L; FrequencyType frequencyType = FrequencyType.DAILY; DescriptorTypeEntity descriptorTypeEntity = new DescriptorTypeEntity("CHANNEL"); descriptorTypeEntity.setId(1L); RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity("name-test", 1L); registeredDescriptorEntity.setId(2L); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(descriptorId, 4L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(configurationId); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); FieldValueEntity fieldValueEntity = new FieldValueEntity(6L, 7L, fieldValue); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(8L); Mockito.when(descriptorTypeRepository.findFirstByType(Mockito.any())).thenReturn(Optional.of(descriptorTypeEntity)); Mockito.when(registeredDescriptorRepository.findByTypeIdAndFrequency(Mockito.any(), Mockito.any())).thenReturn(List.of(registeredDescriptorEntity)); setupCreatConfigMocks(descriptorConfigEntity, configContextEntity, fieldValueEntity, definedFieldEntity); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(registeredDescriptorRepository, descriptorTypeRepository, definedFieldRepository, descriptorConfigRepository, null, configContextRepository, fieldValueRepository, encryptionUtility); List<ConfigurationModel> configurationModelList = configurationAccessor.getChannelConfigurationsByFrequency(frequencyType); assertEquals(1, configurationModelList.size()); ConfigurationModel configurationModel = configurationModelList.get(0); testConfigurationModel(configurationId, descriptorId, configurationModel); }
@Test public void getChannelConfigurationsByFrequencyNullTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.getChannelConfigurationsByFrequency(null); fail("Null frequencyType did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
|
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public List<ConfigurationModel> getConfigurationsByDescriptorKeyAndContext(DescriptorKey descriptorKey, ConfigContextEnum context) throws AlertDatabaseConstraintException { if (null == descriptorKey || StringUtils.isBlank(descriptorKey.getUniversalKey())) { throw new AlertDatabaseConstraintException(String.format(EXCEPTION_FORMAT_DESCRIPTOR_KEY_IS_NOT_VALID, descriptorKey)); } return getConfigurationsByDescriptorNameAndContext(descriptorKey.getUniversalKey(), context); } @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; }
|
@Test public void getConfigurationsByDescriptorKeyAndContextTest() throws Exception { final Long descriptorId = 3L; final Long configurationId = 5L; DescriptorKey descriptorKey = createDescriptorKey("descriptorKeyName"); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(descriptorId, 4L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(configurationId); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); configContextEntity.setId(3L); RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity("name", 1L); registeredDescriptorEntity.setId(2L); FieldValueEntity fieldValueEntity = new FieldValueEntity(6L, 7L, fieldValue); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(8L); Mockito.when(descriptorConfigRepository.findByDescriptorIdAndContextId(Mockito.any(), Mockito.any())).thenReturn(List.of(descriptorConfigEntity)); Mockito.when(configContextRepository.findFirstByContext(Mockito.any())).thenReturn(Optional.of(configContextEntity)); Mockito.when(configContextRepository.findById(Mockito.any())).thenReturn(Optional.of(configContextEntity)); Mockito.when(registeredDescriptorRepository.findFirstByName(Mockito.any())).thenReturn(Optional.of(registeredDescriptorEntity)); Mockito.when(fieldValueRepository.findByConfigId(Mockito.any())).thenReturn(List.of(fieldValueEntity)); Mockito.when(definedFieldRepository.findById(Mockito.any())).thenReturn(Optional.of(definedFieldEntity)); EncryptionUtility encryptionUtility = createEncryptionUtility(); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(registeredDescriptorRepository, null, definedFieldRepository, descriptorConfigRepository, null, configContextRepository, fieldValueRepository, encryptionUtility); List<ConfigurationModel> configurationModelList = configurationAccessor.getConfigurationsByDescriptorKeyAndContext(descriptorKey, configContextEnum); assertEquals(1, configurationModelList.size()); ConfigurationModel configurationModel = configurationModelList.get(0); testConfigurationModel(configurationId, descriptorId, configurationModel); }
@Test public void getConfigurationsByDescriptorKeyAndContextNullTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.getConfigurationsByDescriptorKeyAndContext(null, null); fail("Null descriptorKey and context did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
|
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public ConfigurationModel createConfiguration(DescriptorKey descriptorKey, ConfigContextEnum context, Collection<ConfigurationFieldModel> configuredFields) throws AlertDatabaseConstraintException { if (null == descriptorKey || StringUtils.isBlank(descriptorKey.getUniversalKey())) { throw new AlertDatabaseConstraintException(String.format(EXCEPTION_FORMAT_DESCRIPTOR_KEY_IS_NOT_VALID, descriptorKey)); } return createConfiguration(descriptorKey.getUniversalKey(), context, configuredFields); } @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; }
|
@Test public void createConfigurationTest() throws Exception { final Long descriptorId = 3L; final Long configurationId = 5L; DescriptorKey descriptorKey = createDescriptorKey("descriptorKeyName"); ConfigurationFieldModel configurationFieldModel = ConfigurationFieldModel.create("channel.common.name"); configurationFieldModel.setFieldValue(fieldValue); List<ConfigurationFieldModel> configuredFields = List.of(configurationFieldModel); RegisteredDescriptorEntity registeredDescriptorEntity = new RegisteredDescriptorEntity("name", 1L); registeredDescriptorEntity.setId(descriptorId); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); configContextEntity.setId(3L); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(4L); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(5L, 6L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(configurationId); Mockito.when(registeredDescriptorRepository.findFirstByName(Mockito.any())).thenReturn(Optional.of(registeredDescriptorEntity)); Mockito.when(configContextRepository.findFirstByContext(Mockito.any())).thenReturn(Optional.of(configContextEntity)); Mockito.when(definedFieldRepository.findByDescriptorIdAndContext(Mockito.any(), Mockito.any())).thenReturn(List.of(definedFieldEntity)); Mockito.when(descriptorConfigRepository.save(Mockito.any())).thenReturn(descriptorConfigEntity); Mockito.when(definedFieldRepository.findFirstByKey(Mockito.any())).thenReturn(Optional.of(definedFieldEntity)); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(registeredDescriptorRepository, null, definedFieldRepository, descriptorConfigRepository, configGroupRepository, configContextRepository, fieldValueRepository, null); ConfigurationModel configurationModel = configurationAccessor.createConfiguration(descriptorKey, configContextEnum, configuredFields); testConfigurationModel(configurationId, descriptorId, configurationModel); }
@Test public void createConfigurationNullTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.createConfiguration(null, null, null); fail("Null descriptorKey, context, and configuredFields did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
|
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; }
|
@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); } }
|
DefaultConfigurationAccessor implements ConfigurationAccessor { @Override public ConfigurationModel updateConfiguration(Long descriptorConfigId, Collection<ConfigurationFieldModel> configuredFields) throws AlertDatabaseConstraintException { if (descriptorConfigId == null) { throw new AlertDatabaseConstraintException(NULL_CONFIG_ID); } DescriptorConfigEntity descriptorConfigEntity = descriptorConfigsRepository .findById(descriptorConfigId) .orElseThrow(() -> new AlertDatabaseConstraintException("A config with that id did not exist")); List<FieldValueEntity> oldValues = fieldValueRepository.findByConfigId(descriptorConfigId); fieldValueRepository.deleteAll(oldValues); fieldValueRepository.flush(); ConfigurationModelMutable updatedConfig = createEmptyConfigModel(descriptorConfigEntity.getDescriptorId(), descriptorConfigEntity.getId(), descriptorConfigEntity.getCreatedAt(), descriptorConfigEntity.getLastUpdated(), descriptorConfigEntity.getContextId()); if (configuredFields != null && !configuredFields.isEmpty()) { List<FieldValueEntity> fieldValuesToSave = new ArrayList<>(configuredFields.size()); for (ConfigurationFieldModel configFieldModel : configuredFields) { String fieldKey = configFieldModel.getFieldKey(); Long fieldId = getFieldIdOrThrowException(fieldKey); boolean isSensitive = isFieldSensitive(fieldKey); for (String value : configFieldModel.getFieldValues()) { FieldValueEntity newFieldValue = new FieldValueEntity(descriptorConfigId, fieldId, encrypt(value, isSensitive)); fieldValuesToSave.add(newFieldValue); } updatedConfig.put(configFieldModel); } fieldValueRepository.saveAll(fieldValuesToSave); fieldValueRepository.flush(); } descriptorConfigEntity.setLastUpdated(DateUtils.createCurrentDateTimestamp()); descriptorConfigsRepository.save(descriptorConfigEntity); return updatedConfig; } @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; }
|
@Test public void updateConfigurationTest() throws Exception { Long configurationId = 2L; Long descriptorId = 3L; ConfigurationFieldModel configurationFieldModel = ConfigurationFieldModel.create("channel.common.name"); configurationFieldModel.setFieldValue(fieldValue); List<ConfigurationFieldModel> configuredFields = List.of(configurationFieldModel); DescriptorConfigEntity descriptorConfigEntity = new DescriptorConfigEntity(descriptorId, 4L, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); descriptorConfigEntity.setId(configurationId); FieldValueEntity fieldValueEntity = new FieldValueEntity(5L, 6L, fieldValue); ConfigContextEntity configContextEntity = new ConfigContextEntity(configContextEnum.name()); DefinedFieldEntity definedFieldEntity = new DefinedFieldEntity(fieldKey, false); definedFieldEntity.setId(7L); Mockito.when(descriptorConfigRepository.findById(Mockito.any())).thenReturn(Optional.of(descriptorConfigEntity)); Mockito.when(fieldValueRepository.findByConfigId(Mockito.any())).thenReturn(List.of(fieldValueEntity)); Mockito.when(configContextRepository.findById(Mockito.any())).thenReturn(Optional.of(configContextEntity)); Mockito.when(definedFieldRepository.findFirstByKey(Mockito.any())).thenReturn(Optional.of(definedFieldEntity)); DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, definedFieldRepository, descriptorConfigRepository, null, configContextRepository, fieldValueRepository, null); ConfigurationModel configurationModel = configurationAccessor.updateConfiguration(1L, configuredFields); Mockito.verify(fieldValueRepository).deleteAll(Mockito.any()); Mockito.verify(descriptorConfigRepository).save(Mockito.any()); testConfigurationModel(configurationId, descriptorId, configurationModel); }
@Test public void updateConfigurationNullTest() throws Exception { DefaultConfigurationAccessor configurationAccessor = new DefaultConfigurationAccessor(null, null, null, null, null, null, null, null); try { configurationAccessor.updateConfiguration(null, null); fail("Null descriptorConfigId and configuredFields did not throw expected AlertDatabaseConstraintException."); } catch (AlertDatabaseConstraintException e) { assertNotNull(e); } }
|
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; }
|
@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()); }
|
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; }
|
@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); } }
|
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; }
|
@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()); }
|
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); }
|
@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()); }
|
DefaultAuditAccessor implements AuditAccessor { @Override @Transactional public Optional<AuditJobStatusModel> findFirstByJobId(UUID jobId) { Optional<AuditEntryEntity> auditEntryEntity = auditEntryRepository.findFirstByCommonConfigIdOrderByTimeLastSentDesc(jobId); return auditEntryEntity.map(this::convertToJobStatusModel); } @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); }
|
@Test public void findFirstByJobIdEmptyTest() { AuditEntryRepository auditEntryRepository = Mockito.mock(AuditEntryRepository.class); ContentConverter contentConverter = Mockito.mock(ContentConverter.class); Mockito.when(auditEntryRepository.findFirstByCommonConfigIdOrderByTimeLastSentDesc(Mockito.any(UUID.class))).thenReturn(Optional.empty()); DefaultAuditAccessor auditUtility = new DefaultAuditAccessor(auditEntryRepository, null, null, null, contentConverter); assertFalse(auditUtility.findFirstByJobId(UUID.randomUUID()).isPresent()); }
@Test public void findFirstByJobIdNullTest() { AuditEntryRepository auditEntryRepository = Mockito.mock(AuditEntryRepository.class); ContentConverter contentConverter = Mockito.mock(ContentConverter.class); AuditEntryEntity auditEntryEntity = new AuditEntryEntity(null, null, null, null, null, null); Mockito.when(auditEntryRepository.findFirstByCommonConfigIdOrderByTimeLastSentDesc(Mockito.any(UUID.class))).thenReturn(Optional.of(auditEntryEntity)); DefaultAuditAccessor auditUtility = new DefaultAuditAccessor(auditEntryRepository, null, null, null, contentConverter); UUID testUUID = UUID.randomUUID(); AuditJobStatusModel auditJobStatusModel = auditUtility.findFirstByJobId(testUUID).get(); String timeAuditCreated = auditJobStatusModel.getTimeAuditCreated(); String timeLastSent = auditJobStatusModel.getTimeLastSent(); String status = auditJobStatusModel.getStatus(); assertTrue(auditUtility.findFirstByJobId(testUUID).isPresent()); assertNull(timeAuditCreated); assertNull(timeLastSent); assertNull(status); }
@Test public void findFirstByJobIdNotNullTest() { OffsetDateTime timeLastSent = DateUtils.createCurrentDateTimestamp(); OffsetDateTime timeCreated = timeLastSent.minusMinutes(10L); AuditEntryStatus status = AuditEntryStatus.PENDING; UUID testUUID = UUID.randomUUID(); AuditEntryRepository auditEntryRepository = Mockito.mock(AuditEntryRepository.class); AuditEntryEntity auditEntryEntity = new AuditEntryEntity(testUUID, timeCreated, timeLastSent, status.name(), null, null); Mockito.when(auditEntryRepository.findFirstByCommonConfigIdOrderByTimeLastSentDesc(Mockito.any(UUID.class))).thenReturn(Optional.of(auditEntryEntity)); DefaultAuditAccessor auditUtility = new DefaultAuditAccessor(auditEntryRepository, null, null, null, null); AuditJobStatusModel auditJobStatusModel = auditUtility.findFirstByJobId(testUUID).get(); String testTimeAuditCreated = auditJobStatusModel.getTimeAuditCreated(); String testTimeLastSent = auditJobStatusModel.getTimeLastSent(); String testStatus = auditJobStatusModel.getStatus(); assertTrue(auditUtility.findFirstByJobId(testUUID).isPresent()); assertEquals(DateUtils.formatDate(timeCreated, DateUtils.AUDIT_DATE_FORMAT), testTimeAuditCreated); assertEquals(DateUtils.formatDate(timeLastSent, DateUtils.AUDIT_DATE_FORMAT), testTimeLastSent); assertEquals(status.getDisplayName(), testStatus); }
|
DefaultAuditAccessor implements AuditAccessor { @Override @Transactional public AuditEntryPageModel getPageOfAuditEntries(Integer pageNumber, Integer pageSize, String searchTerm, String sortField, String sortOrder, boolean onlyShowSentNotifications, Function<AlertNotificationModel, AuditEntryModel> notificationToAuditEntryConverter) { Page<AlertNotificationModel> auditPage = getPageOfNotifications(sortField, sortOrder, searchTerm, pageNumber, pageSize, onlyShowSentNotifications); List<AuditEntryModel> auditEntries = convertToAuditEntryModelFromNotificationsSorted(auditPage.getContent(), notificationToAuditEntryConverter, sortField, sortOrder); return new AuditEntryPageModel(auditPage.getTotalPages(), auditPage.getNumber(), auditEntries.size(), auditEntries); } @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); }
|
@Test public void getPageOfAuditEntriesTest() { Integer pageNumber = 0; int pageSize = 2; String searchTerm = null; String sortField = "lastSent"; String sortOrder = "ASC"; Boolean onlyShowSentNotifications = Boolean.TRUE; String overallStatus = "overallStatusString"; String lastSent = DateUtils.createCurrentDateString(DateUtils.AUDIT_DATE_FORMAT); AuditEntryRepository auditEntryRepository = Mockito.mock(AuditEntryRepository.class); DefaultNotificationAccessor notificationManager = Mockito.mock(DefaultNotificationAccessor.class); AuditNotificationRepository auditNotificationRepository = Mockito.mock(AuditNotificationRepository.class); PageRequest pageRequest = PageRequest.of(0, 10); Mockito.when(auditEntryRepository.findMatchingAudit(Mockito.anyLong(), Mockito.any(UUID.class))).thenReturn(Optional.empty()); Mockito.when(notificationManager.getPageRequestForNotifications(pageNumber, pageSize, sortField, sortOrder)).thenReturn(pageRequest); AlertNotificationModel alertNotificationModel = new AlertNotificationModel(1L, 1L, "provider-test", "providerConfigName-test", "notificationType-test", "{content: \"content is here...\"}", DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); AlertNotificationModel alertNotificationModel2 = new AlertNotificationModel(2L, 2L, "provider-test2", "providerConfigName-test2", "notificationType-test2", "{content: \"content is here2..\"}", DateUtils.createCurrentDateTimestamp().minusSeconds(15), DateUtils.createCurrentDateTimestamp().minusSeconds(10)); Pageable auditPageable = Mockito.mock(Pageable.class); Mockito.when(auditPageable.getOffset()).thenReturn(pageNumber.longValue()); Mockito.when(auditPageable.getPageSize()).thenReturn(pageSize); Page<AlertNotificationModel> auditPage = new PageImpl<>(List.of(alertNotificationModel, alertNotificationModel2), auditPageable, 1); Mockito.when(notificationManager.findAll(pageRequest, onlyShowSentNotifications)).thenReturn(auditPage); NotificationConfig notificationConfig = new NotificationConfig("3", "createdAtString", "providerString", 2L, "providerConfigNameString", "providerCreationTimeString", "notificationTypeString", "content-test"); AuditEntryModel auditEntryModel = new AuditEntryModel("2", notificationConfig, List.of(), overallStatus, lastSent); Function<AlertNotificationModel, AuditEntryModel> notificationToAuditEntryConverter = (AlertNotificationModel notificationModel) -> auditEntryModel; DefaultAuditAccessor auditUtility = new DefaultAuditAccessor(auditEntryRepository, auditNotificationRepository, null, notificationManager, null); AlertPagedModel<AuditEntryModel> alertPagedModel = auditUtility.getPageOfAuditEntries(pageNumber, pageSize, searchTerm, sortField, sortOrder, onlyShowSentNotifications, notificationToAuditEntryConverter); assertEquals(1, alertPagedModel.getTotalPages()); assertEquals(pageNumber.intValue(), alertPagedModel.getCurrentPage()); assertEquals(pageSize, alertPagedModel.getPageSize()); assertEquals(2, alertPagedModel.getContent().size()); assertEquals(lastSent, alertPagedModel.getContent().get(0).getLastSent()); assertEquals(lastSent, alertPagedModel.getContent().get(1).getLastSent()); AuditEntryModel auditContentTest = alertPagedModel.getContent().stream().findFirst().orElse(null); assertEquals(auditEntryModel.getId(), auditContentTest.getId()); assertEquals(notificationConfig, auditContentTest.getNotification()); assertEquals(0, auditContentTest.getJobs().size()); assertEquals(overallStatus, auditContentTest.getOverallStatus()); assertEquals(lastSent, auditContentTest.getLastSent()); }
|
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; }
|
@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()); }
|
DefaultAuditAccessor implements AuditAccessor { @Override @Transactional public AuditEntryModel convertToAuditEntryModelFromNotification(AlertNotificationModel notificationContentEntry) { List<AuditNotificationRelation> relations = auditNotificationRepository.findByNotificationId(notificationContentEntry.getId()); List<Long> auditEntryIds = relations.stream().map(AuditNotificationRelation::getAuditEntryId).collect(Collectors.toList()); List<AuditEntryEntity> auditEntryEntities = auditEntryRepository.findAllById(auditEntryIds); AuditEntryStatus overallStatus = null; String timeLastSent = null; OffsetDateTime timeLastSentOffsetDateTime = null; List<JobAuditModel> jobAuditModels = new ArrayList<>(); for (AuditEntryEntity auditEntryEntity : auditEntryEntities) { UUID commonConfigId = auditEntryEntity.getCommonConfigId(); if (null != auditEntryEntity.getTimeLastSent() && (null == timeLastSentOffsetDateTime || timeLastSentOffsetDateTime.isBefore(auditEntryEntity.getTimeLastSent()))) { timeLastSentOffsetDateTime = auditEntryEntity.getTimeLastSent(); timeLastSent = formatAuditDate(timeLastSentOffsetDateTime); } String id = contentConverter.getStringValue(auditEntryEntity.getId()); String configId = contentConverter.getStringValue(commonConfigId); String timeCreated = formatAuditDate(auditEntryEntity.getTimeCreated()); AuditEntryStatus status = null; if (auditEntryEntity.getStatus() != null) { status = AuditEntryStatus.valueOf(auditEntryEntity.getStatus()); overallStatus = getWorstStatus(overallStatus, status); } String errorMessage = auditEntryEntity.getErrorMessage(); String errorStackTrace = auditEntryEntity.getErrorStackTrace(); Optional<ConfigurationJobModel> commonConfig = Optional.empty(); try { commonConfig = configurationAccessor.getJobById(commonConfigId); } catch (AlertDatabaseConstraintException e) { logger.error("There was an issue accessing the job."); } String distributionConfigName = null; String eventType = null; if (commonConfig.isPresent()) { distributionConfigName = commonConfig.get().getName(); eventType = commonConfig.get().getChannelName(); } String statusDisplayName = null; if (null != status) { statusDisplayName = status.getDisplayName(); } AuditJobStatusModel auditJobStatusModel = new AuditJobStatusModel(timeCreated, timeLastSent, statusDisplayName); jobAuditModels.add(new JobAuditModel(id, configId, distributionConfigName, eventType, auditJobStatusModel, errorMessage, errorStackTrace)); } String id = contentConverter.getStringValue(notificationContentEntry.getId()); NotificationConfig notificationConfig = populateConfigFromEntity(notificationContentEntry); String overallStatusDisplayName = null; if (null != overallStatus) { overallStatusDisplayName = overallStatus.getDisplayName(); } return new AuditEntryModel(id, notificationConfig, jobAuditModels, overallStatusDisplayName, timeLastSent); } @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); }
|
@Test public void convertToAuditEntryModelFromNotificationTest() throws Exception { Long id = 1L; Long providerConfigId = 2L; String provider = "provider-test"; String providerConfigName = "providerConfigName-test"; String notificationType = "notificationType-test"; String content = "content-test"; OffsetDateTime timeLastSent = DateUtils.createCurrentDateTimestamp(); OffsetDateTime timeCreated = timeLastSent.minusSeconds(10); Long auditEntryId = 3L; String channelName = "test-channel.common.name-value"; String eventType = "test-channel.common.channel.name-value"; AuditEntryRepository auditEntryRepository = Mockito.mock(AuditEntryRepository.class); AuditNotificationRepository auditNotificationRepository = Mockito.mock(AuditNotificationRepository.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); ContentConverter contentConverter = new ContentConverter(gson, new DefaultConversionService()); AlertNotificationModel alertNotificationModel = new AlertNotificationModel(id, providerConfigId, provider, providerConfigName, notificationType, content, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp()); AuditNotificationRelation auditNotificationRelation = new AuditNotificationRelation(auditEntryId, alertNotificationModel.getId()); AuditEntryEntity auditEntryEntity = new AuditEntryEntity(UUID.randomUUID(), timeCreated, timeLastSent, AuditEntryStatus.SUCCESS.name(), null, null); Mockito.when(auditNotificationRepository.findByNotificationId(Mockito.any())).thenReturn(List.of(auditNotificationRelation)); Mockito.when(auditEntryRepository.findAllById(Mockito.any())).thenReturn(List.of(auditEntryEntity)); ConfigurationModelMutable configurationModel = new ConfigurationModelMutable(10L, 11L, "createdAt-test", "lastUpdate-test", ConfigContextEnum.DISTRIBUTION); ConfigurationFieldModel configurationFieldModel = ConfigurationFieldModel.create("channel.common.name"); configurationFieldModel.setFieldValue("test-channel.common.name-value"); ConfigurationFieldModel configurationFieldModel2 = ConfigurationFieldModel.create("channel.common.channel.name"); configurationFieldModel2.setFieldValue("test-channel.common.channel.name-value"); configurationModel.put(configurationFieldModel); configurationModel.put(configurationFieldModel2); ConfigurationJobModel configurationJobModel = new ConfigurationJobModel(UUID.randomUUID(), Set.of(configurationModel)); Mockito.when(configurationAccessor.getJobById(Mockito.any())).thenReturn(Optional.of(configurationJobModel)); DefaultAuditAccessor auditUtility = new DefaultAuditAccessor(auditEntryRepository, auditNotificationRepository, configurationAccessor, null, contentConverter); AuditEntryModel testAuditEntryModel = auditUtility.convertToAuditEntryModelFromNotification(alertNotificationModel); assertEquals(id, Long.valueOf(testAuditEntryModel.getId())); assertNotNull(testAuditEntryModel.getNotification()); assertFalse(testAuditEntryModel.getJobs().isEmpty()); assertEquals(1, testAuditEntryModel.getJobs().size()); JobAuditModel testJob = testAuditEntryModel.getJobs().get(0); assertEquals(channelName, testJob.getName()); assertEquals(eventType, testJob.getEventType()); assertEquals(AuditEntryStatus.SUCCESS.getDisplayName(), testAuditEntryModel.getOverallStatus()); assertEquals(DateUtils.formatDate(timeLastSent, DateUtils.AUDIT_DATE_FORMAT), testAuditEntryModel.getLastSent()); }
|
DefaultAuditAccessor implements AuditAccessor { @Override @Transactional public Map<Long, Long> createAuditEntry(Map<Long, Long> existingNotificationIdToAuditId, UUID jobId, MessageContentGroup contentGroup) { Map<Long, Long> notificationIdToAuditId = new HashMap<>(); List<ProviderMessageContent> subContent = contentGroup.getSubContent(); Set<Long> componentNotificationIds = subContent .stream() .map(ProviderMessageContent::getComponentItems) .flatMap(Collection::stream) .map(ComponentItem::getNotificationIds) .flatMap(Set::stream) .collect(Collectors.toSet()); Set<Long> topLevelActionNotificationIds = subContent .stream() .filter(ProviderMessageContent::isTopLevelActionOnly) .map(ProviderMessageContent::getNotificationId) .flatMap(Optional::stream) .collect(Collectors.toSet()); Set<Long> allMessageNotificationIds = Stream .concat(componentNotificationIds.stream(), topLevelActionNotificationIds.stream()) .collect(Collectors.toSet()); for (Long notificationId : allMessageNotificationIds) { AuditEntryEntity auditEntryEntity = new AuditEntryEntity(jobId, DateUtils.createCurrentDateTimestamp(), null, null, null, null); boolean didAuditEntryExist = false; if (null != existingNotificationIdToAuditId && !existingNotificationIdToAuditId.isEmpty()) { Long auditEntryId = existingNotificationIdToAuditId.get(notificationId); didAuditEntryExist = null != auditEntryId; if (didAuditEntryExist) { auditEntryEntity = auditEntryRepository.findById(auditEntryId).orElse(auditEntryEntity); } } auditEntryEntity.setStatus(AuditEntryStatus.PENDING.toString()); AuditEntryEntity savedAuditEntryEntity = auditEntryRepository.save(auditEntryEntity); notificationIdToAuditId.put(notificationId, savedAuditEntryEntity.getId()); if (!didAuditEntryExist) { AuditNotificationRelation auditNotificationRelation = new AuditNotificationRelation(savedAuditEntryEntity.getId(), notificationId); auditNotificationRepository.save(auditNotificationRelation); } } return notificationIdToAuditId; } @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); }
|
@Test public void createAuditEntryTest() throws Exception { AuditEntryRepository auditEntryRepository = Mockito.mock(AuditEntryRepository.class); AuditNotificationRepository auditNotificationRepository = Mockito.mock(AuditNotificationRepository.class); DefaultAuditAccessor auditUtility = new DefaultAuditAccessor(auditEntryRepository, auditNotificationRepository, null, null, null); ProviderMessageContent content = createMessageContent(); UUID commonConfigUUID = UUID.randomUUID(); AuditEntryEntity savedAuditEntryEntity = new AuditEntryEntity(commonConfigUUID, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp(), AuditEntryStatus.SUCCESS.toString(), null, null); final Long auditID = 10L; savedAuditEntryEntity.setId(auditID); Mockito.when(auditEntryRepository.findById(Mockito.anyLong())).thenReturn(Optional.of(savedAuditEntryEntity)); mockAuditRepositorySave(auditEntryRepository, savedAuditEntryEntity); Map<Long, Long> existingNotificationIdToAuditId = new HashMap<>(); existingNotificationIdToAuditId.put(1L, auditID); Map<Long, Long> savedNotificationIdToAuditId = auditUtility.createAuditEntry(existingNotificationIdToAuditId, commonConfigUUID, MessageContentGroup.singleton(content)); assertFalse(savedNotificationIdToAuditId.isEmpty()); assertEquals(2, savedNotificationIdToAuditId.size()); assertEquals(savedAuditEntryEntity.getId(), savedNotificationIdToAuditId.get(1L)); assertEquals(AuditEntryStatus.PENDING.toString(), savedAuditEntryEntity.getStatus()); Mockito.verify(auditEntryRepository).findById(Mockito.anyLong()); Mockito.verify(auditNotificationRepository, Mockito.times(existingNotificationIdToAuditId.size())).save(Mockito.any(AuditNotificationRelation.class)); }
@Test public void createAuditEntryNullEntryIdTest() throws Exception { AuditEntryRepository auditEntryRepository = Mockito.mock(AuditEntryRepository.class); AuditNotificationRepository auditNotificationRepository = Mockito.mock(AuditNotificationRepository.class); DefaultAuditAccessor auditUtility = new DefaultAuditAccessor(auditEntryRepository, auditNotificationRepository, null, null, null); ProviderMessageContent content = createMessageContent(); UUID commonConfigUUID = UUID.randomUUID(); AuditEntryEntity savedAuditEntryEntity = new AuditEntryEntity(commonConfigUUID, DateUtils.createCurrentDateTimestamp(), DateUtils.createCurrentDateTimestamp(), AuditEntryStatus.SUCCESS.toString(), null, null); savedAuditEntryEntity.setId(10L); mockAuditRepositorySave(auditEntryRepository, savedAuditEntryEntity); Map<Long, Long> savedNotificationIdToAuditId = auditUtility.createAuditEntry(null, commonConfigUUID, MessageContentGroup.singleton(content)); assertFalse(savedNotificationIdToAuditId.isEmpty()); assertEquals(2, savedNotificationIdToAuditId.size()); assertEquals(savedAuditEntryEntity.getId(), savedNotificationIdToAuditId.values().iterator().next()); assertEquals(AuditEntryStatus.PENDING.toString(), savedAuditEntryEntity.getStatus()); Mockito.verify(auditEntryRepository, Mockito.times(0)).findById(Mockito.anyLong()); Mockito.verify(auditNotificationRepository, Mockito.times(2)).save(Mockito.any(AuditNotificationRelation.class)); }
|
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); }
|
@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()); }
|
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); }
|
@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()); }
|
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); }
|
@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()); }
|
DefaultNotificationAccessor implements NotificationAccessor { @Transactional(readOnly = true, isolation = Isolation.READ_COMMITTED) public Page<AlertNotificationModel> findAll(PageRequest pageRequest, boolean onlyShowSentNotifications) { if (onlyShowSentNotifications) { Page<NotificationEntity> allSentNotifications = notificationContentRepository.findAllSentNotifications(pageRequest); return allSentNotifications.map(this::toModel); } return notificationContentRepository.findAll(pageRequest).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); }
|
@Test public void finalAllTest() throws Exception { PageRequest pageRequest = PageRequest.of(0, 10); NotificationEntity notificationEntity = new NotificationEntity(id, DateUtils.createCurrentDateTimestamp(), provider, providerConfigId, DateUtils.createCurrentDateTimestamp(), notificationType, content); Page<NotificationEntity> allSentNotifications = new PageImpl<>(List.of(notificationEntity)); ConfigurationModel configurationModel = createConfigurationModel(); NotificationContentRepository notificationContentRepository = Mockito.mock(NotificationContentRepository.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); Mockito.when(notificationContentRepository.findAllSentNotifications(Mockito.any())).thenReturn(allSentNotifications); Mockito.when(configurationAccessor.getConfigurationById(Mockito.any())).thenReturn(Optional.of(configurationModel)); DefaultNotificationAccessor notificationManager = new DefaultNotificationAccessor(notificationContentRepository, null, null, configurationAccessor, null); Page<AlertNotificationModel> alertNotificationModelPage = notificationManager.findAll(pageRequest, Boolean.TRUE); assertEquals(1, alertNotificationModelPage.getTotalPages()); AlertNotificationModel testAlertNotificationModel = alertNotificationModelPage.getContent().get(0); testExpectedAlertNotificationModel(expectedAlertNotificationModel, testAlertNotificationModel); }
@Test public void finalAllShowNotificationsFalseTest() throws Exception { PageRequest pageRequest = PageRequest.of(0, 10); NotificationEntity notificationEntity = new NotificationEntity(id, DateUtils.createCurrentDateTimestamp(), provider, providerConfigId, DateUtils.createCurrentDateTimestamp(), notificationType, content); Page<NotificationEntity> allSentNotifications = new PageImpl<>(List.of(notificationEntity)); ConfigurationModel configurationModel = createConfigurationModel(); NotificationContentRepository notificationContentRepository = Mockito.mock(NotificationContentRepository.class); ConfigurationAccessor configurationAccessor = Mockito.mock(ConfigurationAccessor.class); Mockito.when(configurationAccessor.getConfigurationById(Mockito.any())).thenReturn(Optional.of(configurationModel)); Mockito.when(notificationContentRepository.findAll(pageRequest)).thenReturn(allSentNotifications); DefaultNotificationAccessor notificationManager = new DefaultNotificationAccessor(notificationContentRepository, null, null, configurationAccessor, null); Page<AlertNotificationModel> alertNotificationModelPage = notificationManager.findAll(pageRequest, Boolean.FALSE); assertEquals(1, alertNotificationModelPage.getTotalPages()); AlertNotificationModel testAlertNotificationModel = alertNotificationModelPage.getContent().get(0); testExpectedAlertNotificationModel(expectedAlertNotificationModel, testAlertNotificationModel); }
|
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); }
|
@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); }
|
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); }
|
@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); }
|
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); }
|
@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()); }
|
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); }
|
@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); }
|
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); }
|
@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); }
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.