diff options
Diffstat (limited to 'src/test/java/org')
43 files changed, 6444 insertions, 0 deletions
diff --git a/src/test/java/org/onap/aai/validation/auth/MicroServiceAuthTest.java b/src/test/java/org/onap/aai/validation/auth/MicroServiceAuthTest.java new file mode 100644 index 0000000..f9bd177 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/auth/MicroServiceAuthTest.java @@ -0,0 +1,227 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.auth; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; + +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.nio.file.Paths; +import java.security.cert.X509Certificate; +import javax.security.auth.x500.X500Principal; +import javax.ws.rs.core.Cookie; +import org.json.JSONArray; +import org.json.JSONException; +import org.json.JSONObject; +import org.junit.Test; +import org.mockito.Mockito; +import org.onap.aai.auth.AAIAuthException; +import org.onap.aai.auth.AAIMicroServiceAuth; +import org.onap.aai.auth.AAIMicroServiceAuthCore; +import org.onap.aai.validation.config.ValidationServiceAuthConfig; +import org.springframework.mock.web.MockHttpServletRequest; + +/** + * Tests @{link AAIMicroServiceAuth} + */ + +public class MicroServiceAuthTest { + + static { + System.setProperty("APP_HOME", "."); + System.setProperty("CONFIG_HOME", Paths.get(System.getProperty("user.dir"), "src/test/resources").toString()); + } + + private static final String VALID_ADMIN_USER = "cn=common-name, ou=org-unit, o=org, l=location, st=state, c=us"; + private static final String authPolicyFile = "auth_policy.json"; + + /** + * Temporarily invalidate the default policy file and then try to initialise the authorisation class using the name + * of a policy file that does not exist. + * + * @throws AAIAuthException + * @throws IOException + */ + @Test(expected = AAIAuthException.class) + public void missingPolicyFile() throws AAIAuthException, IOException { + String defaultFile = AAIMicroServiceAuthCore.getDefaultAuthFileName(); + try { + AAIMicroServiceAuthCore.setDefaultAuthFileName("invalid.default.file"); + ValidationServiceAuthConfig authConfig = new ValidationServiceAuthConfig(); + authConfig.setAuthPolicyFile("invalid.file.name"); + new AAIMicroServiceAuth(authConfig); + } finally { + AAIMicroServiceAuthCore.setDefaultAuthFileName(defaultFile); + } + } + + /** + * Test loading of a temporary file created with the specified roles + * + * @throws AAIAuthException + * @throws IOException + * @throws JSONException + */ + @Test + public void createLocalAuthFile() throws AAIAuthException, IOException, JSONException { + JSONObject roles = createRoleObject("role", createUserObject("user"), createFunctionObject("func")); + AAIMicroServiceAuth auth = createAuthService(roles); + assertThat(auth.authUser("nosuchuser", "method:func"), is(equalTo("AAI_9101"))); + assertThat(auth.authUser("user", "method:func"), is(equalTo("OK"))); + } + + /** + * Test loading of the policy file relative to CONFIG_HOME + * + * @throws AAIAuthException + */ + @Test + public void createAuth() throws AAIAuthException { + AAIMicroServiceAuth auth = createStandardAuth(); + assertAdminUserAuthorisation(auth, VALID_ADMIN_USER); + } + + @Test + public void testAuthUser() throws AAIAuthException { + AAIMicroServiceAuth auth = createStandardAuth(); + assertThat(auth.authUser(VALID_ADMIN_USER, "GET:actions"), is(equalTo("OK"))); + assertThat(auth.authUser(VALID_ADMIN_USER, "WRONG:action"), is(equalTo("AAI_9101"))); + } + + @Test + public void testAuthCookie() throws AAIAuthException { + AAIMicroServiceAuth auth = createStandardAuth(); + Cookie mockCookie = new Cookie("name", null); + StringBuilder user = new StringBuilder(VALID_ADMIN_USER); + + assertThat(auth.authCookie(null, "GET:actions", user), is(false)); + assertThat(auth.authCookie(null, "WRONG:action", user), is(false)); + + assertThat(auth.authCookie(mockCookie, "GET:actions", user), is(true)); + assertThat(auth.authCookie(mockCookie, "WRONG:action", user), is(false)); + } + + @Test + public void testValidateRequests() throws AAIAuthException { + AAIMicroServiceAuth auth = createStandardAuth(); + assertThat(auth.validateRequest(new MockHttpServletRequest(), null, "app/v1/service"), is(false)); + assertThat(auth.validateRequest(createMockRequest(), "POST", "getAndPublish"), is(false)); + assertThat(auth.validateRequest(createMockRequest(), "POST", "validate"), is(true)); + } + + private MockHttpServletRequest createMockRequest() { + MockHttpServletRequest servletRequest = new MockHttpServletRequest(); + servletRequest.setSecure(true); + servletRequest.setScheme("https"); + servletRequest.setServerPort(9501); + servletRequest.setServerName("localhost"); + servletRequest.setRequestURI("/services/validation-service/v1/app/validate"); + + X509Certificate mockCertificate = Mockito.mock(X509Certificate.class); + Mockito.when(mockCertificate.getSubjectX500Principal()) + .thenReturn(new X500Principal("CN=test, OU=qa, O=Test Ltd, L=London, ST=London, C=GB")); + + servletRequest.setAttribute("javax.servlet.request.X509Certificate", new X509Certificate[] {mockCertificate}); + servletRequest.setAttribute("javax.servlet.request.cipher_suite", ""); + return servletRequest; + } + + private AAIMicroServiceAuth createStandardAuth() throws AAIAuthException { + ValidationServiceAuthConfig authConfig = new ValidationServiceAuthConfig(); + authConfig.setAuthPolicyFile(authPolicyFile); + return new AAIMicroServiceAuth(authConfig); + } + + /** + * @param rolesJson + * @return + * @throws IOException + * @throws AAIAuthException + */ + private AAIMicroServiceAuth createAuthService(JSONObject roles) throws IOException, AAIAuthException { + ValidationServiceAuthConfig authConfig = new ValidationServiceAuthConfig(); + File file = File.createTempFile("auth-policy", "json"); + file.deleteOnExit(); + FileWriter fileWriter = new FileWriter(file); + fileWriter.write(roles.toString()); + fileWriter.flush(); + fileWriter.close(); + + authConfig.setAuthPolicyFile(file.getAbsolutePath()); + return new AAIMicroServiceAuth(authConfig); + } + + /** + * Assert authorisation results for an admin user based on the test policy file + * + * @param auth + * @param adminUser + * @throws AAIAuthException + */ + private void assertAdminUserAuthorisation(AAIMicroServiceAuth auth, String adminUser) throws AAIAuthException { + assertThat(auth.authUser(adminUser, "GET:actions"), is(equalTo("OK"))); + assertThat(auth.authUser(adminUser, "POST:actions"), is(equalTo("OK"))); + assertThat(auth.authUser(adminUser, "PUT:actions"), is(equalTo("OK"))); + assertThat(auth.authUser(adminUser, "DELETE:actions"), is(equalTo("OK"))); + } + + private JSONArray createFunctionObject(String functionName) throws JSONException { + JSONArray functionsArray = new JSONArray(); + JSONObject func = new JSONObject(); + func.put("name", functionName); + func.put("methods", createMethodObject("method")); + functionsArray.put(func); + return functionsArray; + } + + private JSONArray createMethodObject(String methodName) throws JSONException { + JSONArray methodsArray = new JSONArray(); + JSONObject method = new JSONObject(); + method.put("name", methodName); + methodsArray.put(method); + return methodsArray; + } + + private JSONArray createUserObject(String username) throws JSONException { + JSONArray usersArray = new JSONArray(); + JSONObject user = new JSONObject(); + user.put("username", username); + usersArray.put(user); + return usersArray; + } + + private JSONObject createRoleObject(String roleName, JSONArray usersArray, JSONArray functionsArray) + throws JSONException { + JSONObject roles = new JSONObject(); + + JSONObject role = new JSONObject(); + role.put("name", roleName); + role.put("functions", functionsArray); + role.put("users", usersArray); + + JSONArray rolesArray = new JSONArray(); + rolesArray.put(role); + roles.put("roles", rolesArray); + + return roles; + } + +} diff --git a/src/test/java/org/onap/aai/validation/config/TestRestConfig.java b/src/test/java/org/onap/aai/validation/config/TestRestConfig.java new file mode 100644 index 0000000..313c847 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/config/TestRestConfig.java @@ -0,0 +1,79 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.config; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +import javax.inject.Inject; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.aai.validation.config.RestConfig; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(locations = {"classpath:/rest-config/test-validation-service-beans.xml"}) +public class TestRestConfig { + + static { + System.setProperty("APP_HOME", "."); + } + + @Inject + private RestConfig restConfig; + + @Test + public void testRestConfigPopulation() throws Exception { + RestConfig expectedRestConfig = new RestConfig(); + + expectedRestConfig.setHost("localhost"); + expectedRestConfig.setPort(8080); + expectedRestConfig.setProtocol("https"); + expectedRestConfig.setBaseModelURI("${baseModelURI}"); + expectedRestConfig.setTrustStorePath("/dir1/dir2/trustStorePath"); + expectedRestConfig.setTrustStorePassword("70c87528c88dcd9f9c2558d30e817868"); + expectedRestConfig.setKeyStorePath("/dir1/dir2/keyStorePath"); + expectedRestConfig.setKeyStorePassword("70c87528c88dcd9f9c2558d30e817868"); + expectedRestConfig.setKeyManagerFactoryAlgorithm("AES"); + expectedRestConfig.setKeyStoreType("jks"); + expectedRestConfig.setSecurityProtocol("TLS"); + expectedRestConfig.setConnectionTimeout(100); + expectedRestConfig.setReadTimeout(200); + + assertThat(expectedRestConfig, is(restConfig)); + assertThat(expectedRestConfig.getBaseModelURI(), is(restConfig.getBaseModelURI())); + assertThat(expectedRestConfig.getConnectionTimeout(), is(restConfig.getConnectionTimeout())); + assertThat(expectedRestConfig.getHost(), is(restConfig.getHost())); + assertThat(expectedRestConfig.getKeyManagerFactoryAlgorithm(), is(restConfig.getKeyManagerFactoryAlgorithm())); + assertThat(expectedRestConfig.getKeyStorePassword(), is(restConfig.getKeyStorePassword())); + assertThat(expectedRestConfig.getKeyStorePath(), is(restConfig.getKeyStorePath())); + assertThat(expectedRestConfig.getKeyStoreType(), is(restConfig.getKeyStoreType())); + assertThat(expectedRestConfig.getPort(), is(restConfig.getPort())); + assertThat(expectedRestConfig.getProtocol(), is(restConfig.getProtocol())); + assertThat(expectedRestConfig.getReadTimeout(), is(restConfig.getReadTimeout())); + assertThat(expectedRestConfig.getSecurityProtocol(), is(restConfig.getSecurityProtocol())); + assertThat(expectedRestConfig.getTrustStorePassword(), is(restConfig.getTrustStorePassword())); + assertThat(expectedRestConfig.getTrustStorePath(), is(restConfig.getTrustStorePath())); + assertThat(expectedRestConfig.hashCode(), is(restConfig.hashCode())); + assertThat(expectedRestConfig.toString(), is(restConfig.toString())); + assertTrue(expectedRestConfig.equals(restConfig)); + + } +} diff --git a/src/test/java/org/onap/aai/validation/config/TestTopicAdminConfig.java b/src/test/java/org/onap/aai/validation/config/TestTopicAdminConfig.java new file mode 100644 index 0000000..f6a6195 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/config/TestTopicAdminConfig.java @@ -0,0 +1,60 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.config; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +import javax.inject.Inject; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.aai.validation.config.TopicAdminConfig; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(locations = {"classpath:/topic-admin-config/test-validation-service-beans.xml"}) +public class TestTopicAdminConfig { + + static { + System.setProperty("APP_HOME", "."); + } + + @Inject + private TopicAdminConfig topicAdminConfig; + + @Test + public void testTopicAdminConfigPopulation() throws Exception { + TopicAdminConfig expectedTopicAdminConfig = new TopicAdminConfig(); + + expectedTopicAdminConfig.setPublishEnable(true); + expectedTopicAdminConfig.setPublishRetries(3l); + expectedTopicAdminConfig.setConsumeEnable(true); + expectedTopicAdminConfig.setConsumePollingIntervalSeconds(3l); + + assertThat(expectedTopicAdminConfig, is(topicAdminConfig)); + assertThat(expectedTopicAdminConfig.hashCode(), is(topicAdminConfig.hashCode())); + assertThat(expectedTopicAdminConfig.toString(), is(topicAdminConfig.toString())); + assertThat(expectedTopicAdminConfig.getConsumePollingIntervalSeconds(), + is(topicAdminConfig.getConsumePollingIntervalSeconds())); + assertThat(expectedTopicAdminConfig.getPublishRetries(), is(topicAdminConfig.getPublishRetries())); + assertTrue(expectedTopicAdminConfig.equals(topicAdminConfig)); + } + +} diff --git a/src/test/java/org/onap/aai/validation/config/TestTopicConfig.java b/src/test/java/org/onap/aai/validation/config/TestTopicConfig.java new file mode 100644 index 0000000..efe82b8 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/config/TestTopicConfig.java @@ -0,0 +1,107 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.config; + +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; + +import java.util.List; +import java.util.Properties; +import javax.annotation.Resource; +import javax.inject.Inject; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.aai.validation.config.TopicConfig; +import org.onap.aai.validation.ValidationServiceApplication; +import org.onap.aai.validation.config.TopicConfig.Topic; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(locations = {"classpath:/topic-config/test-validation-service-beans.xml"}) +public class TestTopicConfig { + + static { + System.setProperty("APP_HOME", "."); + } + + @Inject + private TopicConfig topicConfigurations; + + @Resource(name = "topicProperties") + private Properties topicProperties; + + + @Test + public void testGetTopicProperties() throws Exception { + assertThat(topicProperties.getProperty("aai-event.name"), is("aai-event")); + assertThat(topicProperties.getProperty("aai-data-export.name"), is("aai-data-export")); + } + + + + @Test + public void testGetConsumerTopicsFromTopicConfig() throws Exception { + assertThat(topicConfigurations.getConsumerTopicNames(), containsInAnyOrder("aai-event", "aai-data-export")); + } + + + @Test + public void testGetConsumerTopicConfigurationObjects() throws Exception { + Topic eventTopic = new TopicConfig("aai-event","aai-data-integrity").new Topic(); + eventTopic.setName("aai-event"); + eventTopic.setHost("event-dummy-host"); + eventTopic.setUsername("event-dummy-username"); + eventTopic.setPassword("event-dummy-password"); + eventTopic.setConsumerGroup("event-dummy-consumer-group"); + eventTopic.setConsumerId("event-dummy-consumer-id"); + eventTopic.setTransportType("event-dummy-transport-type"); + + Topic exportTopic = new TopicConfig("aai-data-export","aai-data-integrity").new Topic(); + exportTopic.setName("aai-data-export"); + exportTopic.setHost("export-dummy-host"); + exportTopic.setUsername("export-dummy-username"); + exportTopic.setPassword("export-dummy-password"); + exportTopic.setConsumerGroup("export-dummy-consumer-group"); + exportTopic.setConsumerId("export-dummy-consumer-id"); + exportTopic.setTransportType("export-dummy-transport-type"); + + List<Topic> consumerTopics = topicConfigurations.getConsumerTopics(); + + assertThat(consumerTopics, containsInAnyOrder(eventTopic, exportTopic)); + } + + @Test + public void testGetPublisherTopicConfigurationObjects() throws Exception { + Topic integrityTopic = new TopicConfig("aai-data-export","aai-data-integrity").new Topic(); + integrityTopic.setName("aai-data-integrity"); + integrityTopic.setHost("integrity-dummy-host"); + integrityTopic.setPartition("integrity-dummy-partition"); + integrityTopic.setUsername("integrity-dummy-username"); + integrityTopic.setPassword("integrity-dummy-password"); + integrityTopic.setTransportType("integrity-dummy-transport-type"); + + List<Topic> publisherTopics = topicConfigurations.getPublisherTopics(); + + assertThat(publisherTopics, containsInAnyOrder(integrityTopic)); + } + + +} diff --git a/src/test/java/org/onap/aai/validation/config/TestValidationControllerConfig.java b/src/test/java/org/onap/aai/validation/config/TestValidationControllerConfig.java new file mode 100644 index 0000000..a8e03eb --- /dev/null +++ b/src/test/java/org/onap/aai/validation/config/TestValidationControllerConfig.java @@ -0,0 +1,69 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.config; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; + +import java.util.ArrayList; +import java.util.List; +import javax.inject.Inject; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.aai.validation.config.ValidationControllerConfig; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(locations = {"classpath:/validation-controller-config/test-validation-service-beans.xml"}) +public class TestValidationControllerConfig { + + static { + System.setProperty("APP_HOME", "."); + } + + @Inject + private ValidationControllerConfig validationControllerConfig; + + @Test + public void testValidationControllerConfig() { + ValidationControllerConfig expected = new ValidationControllerConfig(); + List<String> excludedEventActionList = new ArrayList<String>(); + excludedEventActionList.add("DELETE"); + + List<String> eventTypeRuleList = new ArrayList<String>(2); + eventTypeRuleList.add("AAI-EVENT"); + eventTypeRuleList.add("AAI-DATA-EXPORT-API"); + + List<String> eventTypeModelList = new ArrayList<String>(); + eventTypeModelList.add("AAI-DATA-EXPORT-NQ"); + + expected.setEventDomain("devINT1"); + expected.setExcludedEventActions(excludedEventActionList); + expected.setEventTypeRule(eventTypeRuleList); + expected.setEventTypeModel(eventTypeModelList); + expected.setEventTypeEnd("END-EVENT"); + + assertThat(expected.getEventDomain(), is(validationControllerConfig.getEventDomain())); + assertThat(expected.getExcludedEventActions(), is(validationControllerConfig.getExcludedEventActions())); + assertThat(expected.getEventTypeRule(), is(validationControllerConfig.getEventTypeRule())); + assertThat(expected.getEventTypeModel(), is(validationControllerConfig.getEventTypeModel())); + assertThat(expected.getEventTypeEnd(), is(validationControllerConfig.getEventTypeEnd())); + } + +} diff --git a/src/test/java/org/onap/aai/validation/controller/TestValidationController.java b/src/test/java/org/onap/aai/validation/controller/TestValidationController.java new file mode 100644 index 0000000..ff67181 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/controller/TestValidationController.java @@ -0,0 +1,391 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.controller; + +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import java.util.ArrayList; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Optional; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; +import org.onap.aai.validation.Validator; +import org.onap.aai.validation.config.EventReaderConfig; +import org.onap.aai.validation.config.ValidationControllerConfig; +import org.onap.aai.validation.controller.ValidationController; +import org.onap.aai.validation.exception.ValidationServiceError; +import org.onap.aai.validation.exception.ValidationServiceException; +import org.onap.aai.validation.publisher.MessagePublisher; +import org.onap.aai.validation.reader.EventReader; +import org.onap.aai.validation.reader.data.Entity; +import org.onap.aai.validation.reader.data.EntityId; +import org.onap.aai.validation.result.ValidationResult; +import org.onap.aai.validation.result.Violation; + +@RunWith(MockitoJUnitRunner.class) +public class TestValidationController { + + private static final String AAI_EVENT = "AAI-EVENT"; + private static final String CREATE = "CREATE"; + private static final String DELETE = "DELETE"; + private static final String DEV_INT_1 = "devINT1"; + private static final String ENTITY_LINK = "entityLink"; + private static final String MODEL = "model"; + private static final String RULE = "rule"; + private static final String TEST = "test"; + private static final String TESTDATA_EVENTTYPE_NAMEDQUERY = "aai named query eventtype"; + private static final String TESTDATA_EVENTTYPE_API = "aai api eventtype"; + private static final String TESTDATA_EVENTTYPE_AAI = "aai event eventype"; + private static final String TESTDATA_EVENTTYPE_UNKNOWN = "unknown eventtype"; + private static final String TESTDATA_EVENTTYPE_NULL = "event with null eventtype"; + private static final String TESTDATA_EVENTTYPE_END_EVENT = "END-EVENT"; + private static final String TESTDATA_DOMAIN_INVALID = "event with invalid domain"; + private static final String TESTDATA_DOMAIN_NULL = "event with null domain"; + private static final String TESTDATA_EVENTACTION_DELETE = "event with delete event action"; + private static final String TESTDATA_EVENTACTION_NULL = "event with null event action"; + private static final String TESTDATA_EXCEPTION_EVENT = "event causing exception"; + private static final String TESTDATA_HANDLE_EXCEPTION_EXCEPTION_EVENT = + "event causing exception during handling of the original exception"; + private static final String TESTDATA_VALIDATION_RESULT_PUBLISH_ERROR = + "event causing exception during publishing of validation result"; + private static final String VSERVER = "vserver"; + + @Mock + private ValidationControllerConfig validationControllerConfig; + + @Mock + private EventReader eventReader; + + @Mock + private Validator ruleDrivenValidator; + + @Mock + private Validator modelDrivenValidator; + + @Mock + private MessagePublisher messagePublisher; + + @InjectMocks + private ValidationController validationController = new ValidationController(validationControllerConfig, + eventReader, ruleDrivenValidator, modelDrivenValidator, messagePublisher); + + @Mock + private Entity entity; + + static { + System.setProperty("APP_HOME", "."); + } + + @Before + public void setupMocks() throws ValidationServiceException { + + Map<String, List<ValidationResult>> validationResultsMap = setupTestData(); + + when(ruleDrivenValidator.validate(TESTDATA_EVENTTYPE_AAI)) + .thenReturn(validationResultsMap.get(TESTDATA_EVENTTYPE_AAI)); + when(ruleDrivenValidator.validate(TESTDATA_EVENTTYPE_API)) + .thenReturn(validationResultsMap.get(TESTDATA_EVENTTYPE_API)); + when(modelDrivenValidator.validate(TESTDATA_EVENTTYPE_NAMEDQUERY)) + .thenReturn(validationResultsMap.get(TESTDATA_EVENTTYPE_NAMEDQUERY)); + when(ruleDrivenValidator.validate(TESTDATA_EXCEPTION_EVENT)) + .thenThrow(new RuntimeException("Failed to validate")); + when(ruleDrivenValidator.validate(TESTDATA_HANDLE_EXCEPTION_EXCEPTION_EVENT)) + .thenThrow(new RuntimeException("Failed to validate")); + when(ruleDrivenValidator.validate(TESTDATA_VALIDATION_RESULT_PUBLISH_ERROR)) + .thenReturn(validationResultsMap.get(TESTDATA_VALIDATION_RESULT_PUBLISH_ERROR)); + when(ruleDrivenValidator.validate(TESTDATA_EVENTACTION_NULL)) + .thenReturn(validationResultsMap.get(TESTDATA_EVENTTYPE_AAI)); + + Map<String, List<String>> eventTypeDataMap = setupEventTypeData(); + when(validationControllerConfig.getEventTypeRule()).thenReturn(eventTypeDataMap.get(RULE)); + when(validationControllerConfig.getEventTypeModel()).thenReturn(eventTypeDataMap.get(MODEL)); + when(validationControllerConfig.getEventTypeEnd()).thenReturn("END-EVENT"); + + when(eventReader.getEventType(TESTDATA_EVENTTYPE_AAI)).thenReturn(Optional.of(AAI_EVENT)); + when(eventReader.getEventType(TESTDATA_EVENTTYPE_API)).thenReturn(Optional.of("AAI-DATA-EXPORT-API")); + when(eventReader.getEventType(TESTDATA_EVENTTYPE_NAMEDQUERY)).thenReturn(Optional.of("AAI-DATA-EXPORT-NQ")); + when(eventReader.getEventType(TESTDATA_EVENTTYPE_UNKNOWN)).thenReturn(Optional.of("EVENTTYPE-UNKNOWN")); + when(eventReader.getEventType(TESTDATA_EVENTTYPE_NULL)).thenReturn(Optional.empty()); + when(eventReader.getEventType(TESTDATA_EXCEPTION_EVENT)).thenReturn(Optional.of(AAI_EVENT)); + when(eventReader.getEventType(TESTDATA_HANDLE_EXCEPTION_EXCEPTION_EVENT)).thenReturn(Optional.of(AAI_EVENT)); + when(eventReader.getEventType(TESTDATA_VALIDATION_RESULT_PUBLISH_ERROR)).thenReturn(Optional.of(AAI_EVENT)); + when(eventReader.getEventType(TESTDATA_EVENTACTION_NULL)).thenReturn(Optional.of(AAI_EVENT)); + + when(validationControllerConfig.getEventDomain()).thenReturn(DEV_INT_1); + when(eventReader.getEventDomain(TESTDATA_EVENTTYPE_AAI)).thenReturn(Optional.of(DEV_INT_1)); + when(eventReader.getEventDomain(TESTDATA_EVENTTYPE_API)).thenReturn(Optional.of(DEV_INT_1)); + when(eventReader.getEventDomain(TESTDATA_EVENTTYPE_NAMEDQUERY)).thenReturn(Optional.of(DEV_INT_1)); + when(eventReader.getEventDomain(TESTDATA_EVENTTYPE_UNKNOWN)).thenReturn(Optional.of(DEV_INT_1)); + when(eventReader.getEventDomain(TESTDATA_EVENTTYPE_NULL)).thenReturn(Optional.of(DEV_INT_1)); + when(eventReader.getEventDomain(TESTDATA_DOMAIN_INVALID)).thenReturn(Optional.of("invalidDomain")); + when(eventReader.getEventDomain(TESTDATA_DOMAIN_NULL)).thenReturn(Optional.empty()); + when(eventReader.getEventDomain(TESTDATA_EXCEPTION_EVENT)).thenReturn(Optional.of(DEV_INT_1)); + when(eventReader.getEventDomain(TESTDATA_HANDLE_EXCEPTION_EXCEPTION_EVENT)).thenReturn(Optional.of(DEV_INT_1)); + when(eventReader.getEventDomain(TESTDATA_VALIDATION_RESULT_PUBLISH_ERROR)).thenReturn(Optional.of(DEV_INT_1)); + when(eventReader.getEventDomain(TESTDATA_EVENTACTION_DELETE)).thenReturn(Optional.of(DEV_INT_1)); + when(eventReader.getEventDomain(TESTDATA_EVENTACTION_NULL)).thenReturn(Optional.of(DEV_INT_1)); + + List<String> excludedActions = new ArrayList<>(); + excludedActions.add(DELETE); + when(validationControllerConfig.getExcludedEventActions()).thenReturn(excludedActions); + when(eventReader.getEventAction(TESTDATA_EVENTTYPE_AAI)).thenReturn(Optional.of(CREATE)); + when(eventReader.getEventAction(TESTDATA_EVENTTYPE_API)).thenReturn(Optional.of(CREATE)); + when(eventReader.getEventAction(TESTDATA_EVENTTYPE_NAMEDQUERY)).thenReturn(Optional.of(CREATE)); + when(eventReader.getEventAction(TESTDATA_EVENTTYPE_UNKNOWN)).thenReturn(Optional.of(CREATE)); + when(eventReader.getEventAction(TESTDATA_EVENTTYPE_NULL)).thenReturn(Optional.of(CREATE)); + when(eventReader.getEventAction(TESTDATA_EXCEPTION_EVENT)).thenReturn(Optional.of(CREATE)); + when(eventReader.getEventAction(TESTDATA_HANDLE_EXCEPTION_EXCEPTION_EVENT)).thenReturn(Optional.of(CREATE)); + when(eventReader.getEventAction(TESTDATA_VALIDATION_RESULT_PUBLISH_ERROR)).thenReturn(Optional.of(CREATE)); + when(eventReader.getEventAction(TESTDATA_EVENTACTION_DELETE)).thenReturn(Optional.of(DELETE)); + when(eventReader.getEventAction(TESTDATA_EVENTACTION_NULL)).thenReturn(Optional.empty()); + + when(eventReader.getEntityType(TESTDATA_EXCEPTION_EVENT)).thenReturn(Optional.of(VSERVER)); + when(eventReader.getEntity(TESTDATA_EXCEPTION_EVENT)).thenReturn(entity); + when(eventReader.getEntityType(TESTDATA_HANDLE_EXCEPTION_EXCEPTION_EVENT)).thenThrow( + new RuntimeException("Error during handling the exception for an event that couldn't be validated")); + //@formatter:off + Mockito.doThrow(new ValidationServiceException(ValidationServiceError.EVENT_CLIENT_PUBLISHER_INIT_ERROR)) + .when(messagePublisher) + .publishMessage( + Mockito.contains("\"entityId\":\"[vserver-id=instanceid1]\",\"entityType\":\"entitytype1\",\"resourceVersion\":\"resourceVersion1\"")); + //@formatter:on + } + + private Map<String, List<String>> setupEventTypeData() { + Map<String, List<String>> eventTypeDataMap = new HashMap<>(); + List<String> eventTypeRule = new ArrayList<>(); + + eventTypeRule.add(AAI_EVENT); + eventTypeRule.add("AAI-DATA-EXPORT-API"); + eventTypeDataMap.put(RULE, eventTypeRule); + + List<String> eventTypeModel = new ArrayList<>(); + eventTypeModel.add("AAI-DATA-EXPORT-NQ"); + eventTypeDataMap.put(MODEL, eventTypeModel); + + return eventTypeDataMap; + } + + private Map<String, List<ValidationResult>> setupTestData() throws ValidationServiceException { + + Map<String, List<ValidationResult>> validationResultsMap = new HashMap<>(); + + List<ValidationResult> aaiEventValidationResults = new ArrayList<>(); + + setUpEntityMock("20160525162737-61c49d41-5338-4755-af54-06cee9fe4aca", VSERVER, "1464193654"); + + aaiEventValidationResults.add(new ValidationResult(entity)); + aaiEventValidationResults.add(new ValidationResult(entity)); + validationResultsMap.put(TESTDATA_EVENTTYPE_AAI, aaiEventValidationResults); + + List<ValidationResult> apiEventValidationResults = new ArrayList<>(); + + setUpEntityMock("20160525162737-61c49d41-5338-4755-af54-06cee9fe4acb", VSERVER, "1464193655"); + + apiEventValidationResults.add(new ValidationResult(entity)); + validationResultsMap.put(TESTDATA_EVENTTYPE_API, apiEventValidationResults); + + List<ValidationResult> namedQueryEventValidationResults = new ArrayList<>(); + + setUpEntityMock("20160525162737-61c49d41-5338-4755-af54-06cee9fe4acc", VSERVER, "1464193656"); + + namedQueryEventValidationResults.add(new ValidationResult(entity)); + validationResultsMap.put(TESTDATA_EVENTTYPE_NAMEDQUERY, namedQueryEventValidationResults); + + List<ValidationResult> messagePublishExceptionValidationResults = new ArrayList<>(); + + setUpEntityMock("instanceid1", "entitytype1", "resourceVersion1"); + + messagePublishExceptionValidationResults.add(new ValidationResult(entity)); + validationResultsMap.put(TESTDATA_VALIDATION_RESULT_PUBLISH_ERROR, messagePublishExceptionValidationResults); + + return validationResultsMap; + } + + @Test + public void testExecuteForAAIEvent() throws Exception { + // Test for AAI-EVENT + validationController.execute(TESTDATA_EVENTTYPE_AAI, TEST); + verify(ruleDrivenValidator, times(1)).validate(TESTDATA_EVENTTYPE_AAI); + verify(messagePublisher, times(2)).publishMessage(Mockito.contains( + "\"entityId\":{\"vserver-id\":\"20160525162737-61c49d41-5338-4755-af54-06cee9fe4aca\"},\"entityType\":\"vserver\",\"entityLink\":\"entityLink\",\"resourceVersion\":\"1464193654\",\"entity\":{},\"violations\":[]}")); + } + + @Test + public void testExecuteForAPIEvent() throws Exception { + // Test for AAI-DATA-EXPORT-API + validationController.execute(TESTDATA_EVENTTYPE_API, TEST); + verify(ruleDrivenValidator, times(1)).validate(TESTDATA_EVENTTYPE_API); + verify(messagePublisher, times(1)).publishMessage(Mockito.contains( + "\"entityId\":{\"vserver-id\":\"20160525162737-61c49d41-5338-4755-af54-06cee9fe4acb\"},\"entityType\":\"vserver\",\"entityLink\":\"entityLink\",\"resourceVersion\":\"1464193655\",\"entity\":{},\"violations\":[]}")); + } + + @Test + public void testExecuteForNQEvent() throws Exception { + // Test for AAI-DATA-EXPORT-NQ + validationController.execute(TESTDATA_EVENTTYPE_NAMEDQUERY, TEST); + verify(modelDrivenValidator, times(1)).validate(TESTDATA_EVENTTYPE_NAMEDQUERY); + verify(messagePublisher, times(1)).publishMessage(Mockito.contains( + "\"entityId\":{\"vserver-id\":\"20160525162737-61c49d41-5338-4755-af54-06cee9fe4acc\"},\"entityType\":\"vserver\",\"entityLink\":\"entityLink\",\"resourceVersion\":\"1464193656\",\"entity\":{},\"violations\":[]}")); + } + + @Test + public void testExecuteForNullDomain() throws Exception { + doVerifyMockInteractionsTest(TESTDATA_DOMAIN_NULL, TEST); + } + + private void doVerifyMockInteractionsTest(String event, String eventSource) throws Exception { + validationController.execute(event, eventSource); + verify(eventReader, times(1)).getEventType(Mockito.anyString()); + verify(ruleDrivenValidator, times(0)).validate(Mockito.anyString()); + verify(modelDrivenValidator, times(0)).validate(Mockito.anyString()); + verify(messagePublisher, times(0)).publishMessage(Mockito.anyString()); + + } + + @Test + public void testExecuteForInvalidDomain() throws Exception { + doVerifyMockInteractionsTest(TESTDATA_DOMAIN_INVALID, TEST); + } + + @Test + public void testExecuteForExcludedAction() throws Exception { + doVerifyMockInteractionsTest(TESTDATA_EVENTACTION_DELETE, TEST); + } + + @Test + public void testExecuteForNullAction() throws Exception { + validationController.execute(TESTDATA_EVENTACTION_NULL, TEST); + verify(eventReader, times(2)).getEventType(Mockito.anyString()); + verify(ruleDrivenValidator, times(1)).validate(Mockito.anyString()); + verify(modelDrivenValidator, times(0)).validate(Mockito.anyString()); + verify(messagePublisher, times(2)).publishMessage(Mockito.anyString()); + } + + + + private void doEventTypeTest(String event, String eventSource, int numEventReaderInvocations) throws Exception { + validationController.execute(event, eventSource); + verify(eventReader, times(numEventReaderInvocations)).getEventType(event); + verify(ruleDrivenValidator, times(0)).validate(Mockito.anyString()); + verify(modelDrivenValidator, times(0)).validate(Mockito.anyString()); + verify(messagePublisher, times(0)).publishMessage(Mockito.anyString()); + } + + @Test + public void testExecuteForNullEventType() throws Exception { + // The implementation checks whether this is an end event + // Given that it is not, the event is then examined to see if it is a validation candidate + doEventTypeTest(TESTDATA_EVENTTYPE_NULL, TEST, 2); + } + + @Test + public void testExecuteForUnknownEventType() throws Exception { + doEventTypeTest(TESTDATA_EVENTTYPE_UNKNOWN, TEST, 2); + } + + @Test + public void testExecuteForEndEventType() throws Exception { + doVerifyMockInteractionsTest(TESTDATA_EVENTTYPE_END_EVENT, TEST); + } + + @Test + public void testExceptionDuringValidation() throws Exception { + String primaryKey = "vserver-id"; + String value = "example-vserver-id-val-34666"; + String resourceVersion = "123456789"; + + EntityId entityId = new EntityId(primaryKey, value); + + when(entity.getResourceVersion()).thenReturn(Optional.of(resourceVersion)); + when(entity.getIds()).thenReturn(Collections.singletonList(entityId)); + validationController.execute(TESTDATA_EXCEPTION_EVENT, TEST); + verify(ruleDrivenValidator, times(1)).validate(TESTDATA_EXCEPTION_EVENT); + + // @formatter:off + Violation violation = new Violation.Builder(entity) + .category("CANNOT_VALIDATE") + .severity("CRITICAL") + .violationType("NONE") + .errorMessage("Failed to validate") + .build(); + // @formatter:on + + JsonObject violationObject = new JsonParser().parse(violation.toString()).getAsJsonObject(); + violationObject.remove("validationRule"); // Not set + + JsonObject validationResult = new JsonObject(); + JsonObject entityIdObject = new JsonObject(); + JsonElement entity = new JsonObject(); + entityIdObject.addProperty(primaryKey, value); + validationResult.add(Violation.ENTITY_ID_PROPERTY, entityIdObject); + validationResult.addProperty(Violation.ENTITY_TYPE_PROPERTY, "entitytype1"); + validationResult.addProperty(ENTITY_LINK, ENTITY_LINK); + validationResult.addProperty("resourceVersion", resourceVersion); + validationResult.add("entity", entity); + JsonArray violations = new JsonArray(); + violations.add(violationObject); + validationResult.add("violations", violations); + + String json = validationResult.toString(); + String messageContent = json.substring(1, json.length() - 1); // Remove the { } from the JSON string + verify(messagePublisher).publishMessage(Mockito.contains(messageContent)); + } + + @Test + public void testExceptionDuringHandlingValidationException() throws Exception { + // Test for exception during handling of an exception scenario + validationController.execute(TESTDATA_HANDLE_EXCEPTION_EXCEPTION_EVENT, TEST); + verify(ruleDrivenValidator, times(1)).validate(TESTDATA_HANDLE_EXCEPTION_EXCEPTION_EVENT); + verify(messagePublisher, times(0)).publishMessage(Mockito.anyString()); + } + + @Test + public void testExceptionDuringMessagePublish() throws Exception { + // Test for exception during publishing message. + // Cant verify if the static application logger has been called. + // This test is here for code coverage. + validationController.execute(TESTDATA_VALIDATION_RESULT_PUBLISH_ERROR, TEST); + verify(ruleDrivenValidator, times(1)).validate(TESTDATA_VALIDATION_RESULT_PUBLISH_ERROR); + verify(messagePublisher, times(1)).publishMessage(Mockito.contains( + "\"entityId\":{\"vserver-id\":\"instanceid1\"},\"entityType\":\"entitytype1\",\"entityLink\":\"entityLink\",\"resourceVersion\":\"resourceVersion1\",\"entity\":{},\"violations\":[]}")); + } + + private void setUpEntityMock(String id, String type, String resourceVersion) throws ValidationServiceException { + when(eventReader.getEventReaderConfig()).thenReturn(new EventReaderConfig()); + when(entity.getType()).thenReturn(type); + EntityId entityId = new EntityId("vserver-id", id); + when(entity.getIds()).thenReturn(Collections.singletonList(entityId)); + when(entity.getEntityLink()).thenReturn(ENTITY_LINK); + when(entity.getResourceVersion()).thenReturn(Optional.of(resourceVersion)); + } +} diff --git a/src/test/java/org/onap/aai/validation/data/client/TestRestClient.java b/src/test/java/org/onap/aai/validation/data/client/TestRestClient.java new file mode 100644 index 0000000..9f2807b --- /dev/null +++ b/src/test/java/org/onap/aai/validation/data/client/TestRestClient.java @@ -0,0 +1,74 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.data.client; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.CoreMatchers.notNullValue; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertThat; + +import javax.ws.rs.core.MediaType; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; +import org.onap.aai.validation.config.RestConfig; +import org.onap.aai.validation.data.client.RestClient; +import org.onap.aai.validation.exception.ValidationServiceException; + +/** + * Simple tests for GET and POST failures so as to increase code coverage. + * + * Note that the REST client is not properly initialised. + * + */ +public class TestRestClient { + + static { + System.setProperty("APP_HOME", "."); + } + + private static final String TEST_URL = "/aai/v11"; + private RestConfig mockRestConfig; + + @Before + public void setUp() { + mockRestConfig = Mockito.mock(RestConfig.class); + Mockito.when(mockRestConfig.getProtocol()).thenReturn("http"); + Mockito.when(mockRestConfig.getHost()).thenReturn("localhost"); + Mockito.when(mockRestConfig.getPort()).thenReturn(8080); + } + + @Test + public void validateConstructor() { + RestClient restClient = new RestClient(mockRestConfig); + assertNotNull(restClient); + assertThat(restClient.toString(), is(notNullValue())); + } + + @Test(expected = ValidationServiceException.class) + public void getOperationFailure() throws ValidationServiceException { + RestClient restClient = new RestClient(mockRestConfig); + restClient.get(TEST_URL, MediaType.TEXT_PLAIN); + } + + @Test(expected = ValidationServiceException.class) + public void postOperationFailure() throws ValidationServiceException { + RestClient restClient = new RestClient(mockRestConfig); + restClient.post(TEST_URL, MediaType.TEXT_PLAIN); + } +} diff --git a/src/test/java/org/onap/aai/validation/logging/LogReader.java b/src/test/java/org/onap/aai/validation/logging/LogReader.java new file mode 100644 index 0000000..096221d --- /dev/null +++ b/src/test/java/org/onap/aai/validation/logging/LogReader.java @@ -0,0 +1,101 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.logging; + +import java.io.BufferedReader; +import java.io.File; +import java.io.FileReader; +import java.io.IOException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.Comparator; +import java.util.HashMap; +import java.util.Map; +import java.util.Optional; +import java.util.concurrent.TimeUnit; +import org.apache.commons.lang.time.StopWatch; +import org.junit.Assert; + +public class LogReader { + + private Map<String, Path> cachedLogMap = new HashMap<>(); + private Map<String, BufferedReader> readersMap = new HashMap<>(); + private BufferedReader cachedReader; + + public LogReader(String logDirectory, String logFilePrefix) throws IOException { + cachedReader = getReader(logDirectory, logFilePrefix); + } + + private BufferedReader getReader(String logDirectory, String logFilePrefix) throws IOException { + BufferedReader reader = readersMap.get(logFilePrefix); + if (reader == null) { + reader = new BufferedReader(new FileReader(getLogFile(logDirectory, logFilePrefix))); + while (reader.readLine() != null) { + // Consume all lines + } + readersMap.put(logFilePrefix, reader); + } + return reader; + } + + /** + * @param logDirectory + * @return the most recently created log file. + * @throws IOException + */ + public File getLogFile(String logDirectory, String filenamePrefix) throws IOException { + Path cachedLog = cachedLogMap.get(filenamePrefix); + + if (cachedLog == null) { + Optional<Path> latestFilePath = Files.list(Paths.get(logDirectory)) + .filter(f -> Files.isDirectory(f) == false && f.getFileName().toString().startsWith(filenamePrefix)) + .max(Comparator.comparingLong(f -> f.toFile().lastModified())); + if (latestFilePath.isPresent()) { + cachedLog = latestFilePath.get(); + } else { + throw new IOException("No validation log files were found!"); + } + } + + return cachedLog.toFile(); + } + + /** + * @return new lines appended to the log file + * @throws IOException + */ + public String getNewLines() throws IOException { + StopWatch stopwatch = new StopWatch(); + stopwatch.start(); + + while (!cachedReader.ready()) { + if (stopwatch.getTime() > TimeUnit.SECONDS.toMillis(30)) { + Assert.fail("Test took too long"); + } + // else keep waiting + } + + StringBuilder lines = new StringBuilder(); + String line; + while ((line = cachedReader.readLine()) != null) { + lines.append(line).append(System.lineSeparator()); + } + return lines.toString(); + } +} diff --git a/src/test/java/org/onap/aai/validation/logging/TestApplicationLogger.java b/src/test/java/org/onap/aai/validation/logging/TestApplicationLogger.java new file mode 100644 index 0000000..d19d43d --- /dev/null +++ b/src/test/java/org/onap/aai/validation/logging/TestApplicationLogger.java @@ -0,0 +1,245 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.logging; + +import static org.hamcrest.CoreMatchers.containsString; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.CoreMatchers.notNullValue; +import static org.hamcrest.CoreMatchers.startsWith; +import static org.hamcrest.MatcherAssert.assertThat; + +import java.io.IOException; +import java.nio.file.Paths; +import java.util.Arrays; +import org.apache.commons.lang.time.StopWatch; +import org.junit.BeforeClass; +import org.junit.Test; +import org.mockito.Mockito; +import org.onap.aai.cl.api.LogFields; +import org.onap.aai.cl.api.Logger; +import org.onap.aai.cl.mdc.MdcOverride; +import org.onap.aai.validation.logging.ApplicationMsgs; +import org.onap.aai.validation.logging.LogHelper; +import org.onap.aai.validation.logging.LogHelper.TriConsumer; +import org.springframework.http.HttpHeaders; + +/** + * Simple test to log each of the validation messages in turn. + * + * This version tests only the error logger at INFO level. + * + */ +public class TestApplicationLogger { + + @BeforeClass + public static void setupClass() { + System.setProperty("APP_HOME", "."); + } + + /** + * Check that each message can be logged and that (by implication of successful logging) there is a corresponding + * resource (message format). + * + * @throws IOException + */ + @Test + public void logAllMessages() throws IOException { + Logger logger = LogHelper.INSTANCE; + String logDirectory = getLogDirectory(); + LogReader errorReader = new LogReader(logDirectory, "error"); + LogReader debugReader = new LogReader(logDirectory, "debug"); + String[] args = {"1", "2", "3", "4"}; + for (ApplicationMsgs msg : Arrays.asList(ApplicationMsgs.values())) { + if (msg.name().endsWith("ERROR")) { + logger.error(msg, args); + validateLoggedMessage(msg, errorReader, "ERROR"); + + logger.error(msg, new RuntimeException("fred"), args); + validateLoggedMessage(msg, errorReader, "fred"); + } else { + logger.info(msg, args); + validateLoggedMessage(msg, errorReader, "INFO"); + + logger.warn(msg, args); + validateLoggedMessage(msg, errorReader, "WARN"); + } + + logger.debug(msg, args); + validateLoggedMessage(msg, debugReader, "DEBUG"); + + // The trace level is not enabled + logger.trace(msg, args); + } + } + + /** + * Check that each message can be logged and that (by implication of successful logging) there is a corresponding + * resource (message format). + * + * @throws IOException + */ + @Test + public void logDebugMessages() throws IOException { + LogReader reader = new LogReader(getLogDirectory(), "debug"); + LogHelper.INSTANCE.debug("a message"); + String s = reader.getNewLines(); + assertThat(s, is(notNullValue())); + } + + + /** + * Check logAudit with HTTP headers + * + * @throws IOException + */ + @Test + public void logAuditMessage() throws IOException { + LogHelper logger = LogHelper.INSTANCE; + LogReader reader = new LogReader(getLogDirectory(), "audit"); + + HttpHeaders headers = Mockito.mock(HttpHeaders.class); + Mockito.when(headers.getFirst("X-ECOMP-RequestID")).thenReturn("ecomp-request-id"); + Mockito.when(headers.getFirst("X-FromAppId")).thenReturn("app-id"); + + // Call logAudit without first calling startAudit + logger.logAuditSuccess("first call: bob"); + String s = reader.getNewLines(); + assertThat(s, is(notNullValue())); + assertThat("audit message log level", s, containsString("INFO")); + assertThat("audit message content", s, containsString("bob")); + + // This time call the start method + logger.startAudit(headers, null); + logger.logAuditSuccess("second call: foo"); + s = reader.getNewLines(); + assertThat(s, is(notNullValue())); + assertThat("audit message log level", s, containsString("INFO")); + assertThat("audit message content", s, containsString("foo")); + assertThat("audit message content", s, containsString("ecomp-request-id")); + assertThat("audit message content", s, containsString("app-id")); + } + + /** + * Check logAudit with no HTTP headers + * + * @throws IOException + */ + @Test + public void logAuditMessageWithoutHeaders() throws IOException { + LogHelper logger = LogHelper.INSTANCE; + LogReader reader = new LogReader(getLogDirectory(), "audit"); + logger.startAudit(null, null); + logger.logAuditSuccess("foo"); + String s = reader.getNewLines(); + assertThat(s, is(notNullValue())); + assertThat("audit message log level", s, containsString("INFO")); + assertThat("audit message content", s, containsString("foo")); + } + + /** + * Check logMetrics + * + * @throws IOException + */ + @Test + public void logMetricsMessage() throws IOException { + LogReader reader = new LogReader(getLogDirectory(), "metrics"); + LogHelper logger = LogHelper.INSTANCE; + logger.logMetrics("metrics: fred"); + String s = reader.getNewLines(); + assertThat(s, is(notNullValue())); + assertThat("metrics message log level", s, containsString("INFO")); + assertThat("metrics message content", s, containsString("fred")); + } + + @Test + public void logMetricsMessageWithStopwatch() throws IOException { + LogReader reader = new LogReader(getLogDirectory(), "metrics"); + LogHelper logger = LogHelper.INSTANCE; + StopWatch stopWatch = new StopWatch(); + stopWatch.start(); + logger.logMetrics(stopWatch, "joe", "bloggs"); + String logLine = reader.getNewLines(); + assertThat(logLine, is(notNullValue())); + assertThat("metrics message log level", logLine, containsString("INFO")); + assertThat("metrics message content", logLine, containsString("joe")); + } + + @Test + public void callUnsupportedMethods() throws IOException { + LogHelper logger = LogHelper.INSTANCE; + ApplicationMsgs dummyMsg = ApplicationMsgs.LOAD_PROPERTIES; + callUnsupportedOperationMethod(logger::error, dummyMsg); + callUnsupportedOperationMethod(logger::info, dummyMsg); + callUnsupportedOperationMethod(logger::warn, dummyMsg); + callUnsupportedOperationMethod(logger::debug, dummyMsg); + callUnsupportedOperationMethod(logger::trace, dummyMsg); + try { + logger.error(dummyMsg, new LogFields(), new RuntimeException("test"), ""); + } catch (UnsupportedOperationException e) { + // Expected to reach here + } + try { + logger.info(dummyMsg, new LogFields(), new MdcOverride(), ""); + } catch (UnsupportedOperationException e) { + // Expected to reach here + } + try { + logger.formatMsg(dummyMsg, ""); + } catch (UnsupportedOperationException e) { + // Expected to reach here + } + } + + private String getLogDirectory() { + String logDirectory = LogHelper.getLogDirectory(); + assertThat(Paths.get(logDirectory).toAbsolutePath().toString(), + startsWith(Paths.get(System.getProperty("APP_HOME")).toAbsolutePath().toString())); + return logDirectory; + } + + /** + * Call a logger method which is expected to throw an UnsupportedOperationException + * + * @param logMethod + * @param dummyMsg + */ + private void callUnsupportedOperationMethod(TriConsumer<Enum<?>, LogFields, String[]> logMethod, + ApplicationMsgs dummyMsg) { + try { + logMethod.accept(dummyMsg, new LogFields(), new String[] {""}); + org.junit.Assert.fail("method should have thrown execption"); // NOSONAR as code not reached + } catch (UnsupportedOperationException e) { + // Expected to reach here + } + } + + /** + * Assert that a log message was logged to the expected log file at the expected severity + * + * @param msg + * @param reader + * @param severity + * @throws IOException + */ + private void validateLoggedMessage(ApplicationMsgs msg, LogReader reader, String severity) throws IOException { + String s = reader.getNewLines(); + assertThat(s, is(notNullValue())); + assertThat(msg.toString() + " log level", s, containsString(severity)); + } +} diff --git a/src/test/java/org/onap/aai/validation/modeldriven/TestModelId.java b/src/test/java/org/onap/aai/validation/modeldriven/TestModelId.java new file mode 100644 index 0000000..7cefede --- /dev/null +++ b/src/test/java/org/onap/aai/validation/modeldriven/TestModelId.java @@ -0,0 +1,95 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.modeldriven; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.CoreMatchers.not; +import static org.junit.Assert.assertThat; + +import org.junit.Test; +import org.onap.aai.validation.modeldriven.ModelId; + +public class TestModelId { + + static { + System.setProperty("APP_HOME", "."); + } + + @Test + public void testGettersAndSetters() { + String attr = null; + String id = null; + ModelId modelId = new ModelId(attr, id); + assertThat(modelId.getModelIdAttribute(), is(equalTo(attr))); + assertThat(modelId.getModelId(), is(equalTo(id))); + assertThat(modelId.isEmpty(), is(true)); + + attr = ""; + modelId.setModelIdAttribute(attr); + assertThat(modelId.getModelIdAttribute(), is(equalTo(attr))); + assertThat(modelId.getModelId(), is(equalTo(id))); + assertThat(modelId.isEmpty(), is(true)); + + attr = "new_attr_value"; + modelId.setModelIdAttribute(attr); + assertThat(modelId.getModelIdAttribute(), is(equalTo(attr))); + assertThat(modelId.getModelId(), is(equalTo(id))); + assertThat(modelId.isEmpty(), is(true)); + + id = "new_id"; + modelId.setModelId(id); + assertThat(modelId.getModelIdAttribute(), is(equalTo(attr))); + assertThat(modelId.getModelId(), is(equalTo(id))); + assertThat(modelId.isEmpty(), is(false)); + + id = ""; + modelId.setModelId(id); + assertThat(modelId.getModelIdAttribute(), is(equalTo(attr))); + assertThat(modelId.getModelId(), is(equalTo(id))); + assertThat(modelId.isEmpty(), is(true)); + + attr = null; + modelId.setModelIdAttribute(attr); + assertThat(modelId.getModelIdAttribute(), is(equalTo(attr))); + assertThat(modelId.getModelId(), is(equalTo(id))); + assertThat(modelId.isEmpty(), is(true)); + } + + @Test + public void testIsEmpty() { + assertThat(new ModelId(null, null).isEmpty(), is(true)); + assertThat(new ModelId("", null).isEmpty(), is(true)); + assertThat(new ModelId(null, "").isEmpty(), is(true)); + assertThat(new ModelId("", "").isEmpty(), is(true)); + assertThat(new ModelId("A", null).isEmpty(), is(true)); + assertThat(new ModelId(null, "B").isEmpty(), is(true)); + assertThat(new ModelId("A", "B").isEmpty(), is(false)); + } + + @Test + public void testEqualsMethod() { + ModelId id1 = new ModelId("a", "b"); + ModelId id2 = new ModelId("a", "b"); + assertThat(id1, is(equalTo(id1))); + assertThat(id1, is(equalTo(id2))); + assertThat(id1, is(not(equalTo(null)))); + assertThat(id1.hashCode(), is(equalTo(id2.hashCode()))); + } + +} diff --git a/src/test/java/org/onap/aai/validation/modeldriven/configuration/mapping/TestFilter.java b/src/test/java/org/onap/aai/validation/modeldriven/configuration/mapping/TestFilter.java new file mode 100644 index 0000000..c9d2688 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/modeldriven/configuration/mapping/TestFilter.java @@ -0,0 +1,55 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.modeldriven.configuration.mapping; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import org.junit.Test; +import org.onap.aai.validation.modeldriven.configuration.mapping.Filter; + +public class TestFilter { + + static { + System.setProperty("APP_HOME", "."); + } + + @Test + public void testAllMethodsInFilterClassToImproveCodeCoverage() { + Filter filter1 = new Filter(); + List<String> valid = new ArrayList<>(); + valid.add("String 1"); + filter1.setPath("path"); + filter1.setValid(valid); + + Filter filter2 = new Filter(); + filter2.setPath("path"); + filter2.setValid(valid); + + assertThat(filter1, is(filter2)); + assertThat(filter1.hashCode(), is(filter2.hashCode())); + assertThat(filter1.getPath(), is(filter2.getPath())); + assertThat(filter1.getValid(), is(filter2.getValid())); + assertThat(filter1.toString(), is(filter2.toString())); + assertTrue(filter1.equals(filter2)); + } + +} diff --git a/src/test/java/org/onap/aai/validation/modeldriven/configuration/mapping/TestModelInstanceMapper.java b/src/test/java/org/onap/aai/validation/modeldriven/configuration/mapping/TestModelInstanceMapper.java new file mode 100644 index 0000000..7c820bb --- /dev/null +++ b/src/test/java/org/onap/aai/validation/modeldriven/configuration/mapping/TestModelInstanceMapper.java @@ -0,0 +1,71 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.modeldriven.configuration.mapping; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import org.junit.Test; +import org.onap.aai.validation.modeldriven.configuration.mapping.Filter; +import org.onap.aai.validation.modeldriven.configuration.mapping.ModelInstanceMapper; +import org.onap.aai.validation.modeldriven.configuration.mapping.ValueConfiguration; +import org.onap.aai.validation.modeldriven.configuration.mapping.ModelInstanceMapper.MappingType; + +public class TestModelInstanceMapper { + + static { + System.setProperty("APP_HOME", "."); + } + + @Test + public void testAllMethodsToImproveCodeCoverage() { + List<String> valid = new ArrayList<>(); + valid.add("string1"); + Filter filter = new Filter(); + filter.setPath("testPath"); + filter.setValid(valid); + + ValueConfiguration valueConf1 = new ValueConfiguration(); + valueConf1.setFilter(filter); + valueConf1.setId("id"); + valueConf1.setOrigin("testOrigin"); + valueConf1.setRoot("testRoot"); + valueConf1.setValue("testValue"); + + ModelInstanceMapper mapper1 = new ModelInstanceMapper(); + mapper1.setInstance(valueConf1); + mapper1.setMappingType(MappingType.ATTRIBUTE.toString()); + mapper1.setModel(valueConf1); + + ModelInstanceMapper mapper2 = new ModelInstanceMapper(); + mapper2.setInstance(valueConf1); + mapper2.setMappingType(MappingType.ATTRIBUTE.toString()); + mapper2.setModel(valueConf1); + + assertThat(mapper1.hashCode(), is(mapper2.hashCode())); + assertThat(mapper1.getInstance(), is(mapper2.getInstance())); + assertThat(mapper1.getMappingType(), is(mapper2.getMappingType())); + assertThat(mapper1.getModel(), is(mapper2.getModel())); + assertThat(mapper1.toString(), is(mapper2.toString())); + assertTrue(mapper1.equals(mapper2)); + } + +} diff --git a/src/test/java/org/onap/aai/validation/modeldriven/configuration/mapping/TestValueConfiguration.java b/src/test/java/org/onap/aai/validation/modeldriven/configuration/mapping/TestValueConfiguration.java new file mode 100644 index 0000000..80c1ab8 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/modeldriven/configuration/mapping/TestValueConfiguration.java @@ -0,0 +1,70 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.modeldriven.configuration.mapping; + +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +import java.util.ArrayList; +import java.util.List; +import org.junit.Test; +import org.onap.aai.validation.modeldriven.configuration.mapping.Filter; +import org.onap.aai.validation.modeldriven.configuration.mapping.ValueConfiguration; + +public class TestValueConfiguration { + + static { + System.setProperty("APP_HOME", "."); + } + + @Test + public void testAllMethodsToImproveCodeCoverage() { + + List<String> valid = new ArrayList<>(); + valid.add("string1"); + Filter filter = new Filter(); + filter.setPath("testPath"); + filter.setValid(valid); + + ValueConfiguration valueConf1 = new ValueConfiguration(); + valueConf1.setFilter(filter); + valueConf1.setId("id"); + valueConf1.setOrigin("testOrigin"); + valueConf1.setRoot("testRoot"); + valueConf1.setValue("testValue"); + + ValueConfiguration valueConf2 = new ValueConfiguration(); + valueConf2.setFilter(filter); + valueConf2.setId("id"); + valueConf2.setOrigin("testOrigin"); + valueConf2.setRoot("testRoot"); + valueConf2.setValue("testValue"); + + assertThat(valueConf1, is(valueConf2)); + assertThat(valueConf1.hashCode(), is(valueConf2.hashCode())); + assertThat(valueConf1.getFilter(), is(valueConf2.getFilter())); + assertThat(valueConf1.getId(), is(valueConf2.getId())); + assertThat(valueConf1.getOrigin(), is(valueConf2.getOrigin())); + assertThat(valueConf1.getRoot(), is(valueConf2.getRoot())); + assertThat(valueConf1.getValue(), is(valueConf2.getValue())); + assertThat(valueConf1.toString(), is(valueConf2.toString())); + assertTrue(valueConf1.equals(valueConf2)); + } + +} diff --git a/src/test/java/org/onap/aai/validation/modeldriven/parser/TestXMLModelParser.java b/src/test/java/org/onap/aai/validation/modeldriven/parser/TestXMLModelParser.java new file mode 100644 index 0000000..3344193 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/modeldriven/parser/TestXMLModelParser.java @@ -0,0 +1,96 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.modeldriven.parser; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNull; +import static org.junit.Assert.assertTrue; + +import java.io.File; +import java.util.ArrayList; +import java.util.List; +import org.dom4j.Element; +import org.dom4j.Node; +import org.junit.Before; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.onap.aai.validation.modeldriven.parser.XMLModelParser; + +public class TestXMLModelParser { + + static { + System.setProperty("APP_HOME", "."); + } + + private static final String CONNECTOR_MODEL_ID = "460c6de2-a92b-4e3b-9ba3-538ce782b2fa"; + private static final String MODEL_ID_ATTRIBUTE = "model-name-version-id"; + + private Element modelElement; + + @Rule + public ExpectedException exception = ExpectedException.none(); + + @Before + public void setUp() throws Exception { + File modelFile = new File("src/test/resources/model-validation/model-parser/all-models.xml"); + Element modelsElement = XMLModelParser.parse(modelFile, false); + modelElement = XMLModelParser.getModelElementWithId(modelsElement, MODEL_ID_ATTRIBUTE, CONNECTOR_MODEL_ID); + } + + @Test + public void testParseXMLModelFile() throws Exception { + assertEquals("Invalid model element name.", "model", modelElement.getName()); + } + + @Test + public void testGetAttributes() throws Exception { + String attrsXPath = "metadata/metadatum/metaname"; + List<Node> attrNodes = XMLModelParser.getObjectsFromXPath(modelElement, attrsXPath); + assertEquals("Unexpected number of attributes.", 2, attrNodes.size()); + + List<String> validAttrs = new ArrayList<>(); + validAttrs.add("a"); + validAttrs.add("b"); + + List<String> actualAttrs = new ArrayList<>(); + for (Node node : attrNodes) { + actualAttrs.add(node.getText()); + } + + assertTrue("Unexpected attribute names.", validAttrs.containsAll(actualAttrs)); + } + + @Test + public void testGetRelatedObjects() throws Exception { + String relObjsXPath = "model-elements/model-element"; + List<Node> relatedNodes = XMLModelParser.getObjectsFromXPath(modelElement, relObjsXPath); + assertEquals("Unexpected number of related objects.", 1, relatedNodes.size()); + + Node relatedObjUUIDNode = relatedNodes.get(0).selectSingleNode("model-element-uuid"); + assertEquals("Unexpected related object UUID.", "71b825be-febf-45f7-b86a-ca0e3de19c90", + relatedObjUUIDNode.getText()); + } + + @Test + public void testModelValidationFailure() throws Exception { + File modelFile = new File("src/test/resources/model-validation/model-parser/all-models.xml"); + + assertNull("Validation failure should result in null being returned.", XMLModelParser.parse(modelFile, true)); + } +} diff --git a/src/test/java/org/onap/aai/validation/modeldriven/validator/TestInstanceReader.java b/src/test/java/org/onap/aai/validation/modeldriven/validator/TestInstanceReader.java new file mode 100644 index 0000000..60588bb --- /dev/null +++ b/src/test/java/org/onap/aai/validation/modeldriven/validator/TestInstanceReader.java @@ -0,0 +1,236 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.modeldriven.validator; + +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertThat; + +import com.google.common.collect.Multimap; +import com.google.gson.JsonElement; +import com.google.gson.JsonParser; +import javax.inject.Inject; +import org.json.JSONArray; +import org.json.JSONObject; +import org.junit.BeforeClass; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.junit.runner.RunWith; +import org.onap.aai.validation.exception.ValidationServiceException; +import org.onap.aai.validation.modeldriven.configuration.mapping.ModelInstanceMapper; +import org.onap.aai.validation.modeldriven.validator.InstanceReader; +import org.onap.aai.validation.test.util.TestUtil; +import org.onap.aai.validation.util.JsonUtil; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.TestPropertySource; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@TestPropertySource(properties = {"schemaIngestPropLoc = src/test/resources/oxm-reader/schemaIngest.properties"}) +@ContextConfiguration(locations = {"classpath:model-validation/instance-reader/test-validation-service-beans.xml"}) +public class TestInstanceReader { + + static { + System.setProperty("APP_HOME", "."); + } + + private static ModelInstanceMapper mapping; + private static ModelInstanceMapper mappingRootUnknown; + private static ModelInstanceMapper mappingRootMissing; + private static String connector; + private static String connectorSibling; + private static String expectedVirtualDataCenter; + private static String expectedVirtualDataCenterModelName; + private static String connectorModelName; + private static String expectedLogicalLink; + private static String expectedGenericVnf; + private static String expectedPserver; + + @Inject + private InstanceReader instanceReader; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + mapping = TestInstanceReader.getMapping(TestData.MAPPING.getFilename()); + mappingRootUnknown = TestInstanceReader.getMapping(TestData.MAPPING_ROOT_UNKNOWN.getFilename()); + mappingRootMissing = TestInstanceReader.getMapping(TestData.MAPPING_ROOT_MISSING.getFilename()); + connector = TestUtil.getFileAsString(TestData.CONNECTOR.getFilename()); + connectorModelName = TestUtil.getFileAsString(TestData.CONNECTOR_MODEL_NAME.getFilename()); + connectorSibling = TestUtil.getFileAsString(TestData.CONNECTOR_SIBLING.getFilename()); + expectedVirtualDataCenter = TestUtil.getFileAsString(TestData.EXPECTED_VDC.getFilename()); + expectedVirtualDataCenterModelName = TestUtil.getFileAsString(TestData.EXPECTED_VDC_MODEL_NAME.getFilename()); + expectedLogicalLink = TestUtil.getFileAsString(TestData.EXPECTED_LOGICAL_LINK.getFilename()); + expectedGenericVnf = TestUtil.getFileAsString(TestData.EXPECTED_GENERIC_VNF.getFilename()); + expectedPserver = TestUtil.getFileAsString(TestData.EXPECTED_PSERVER.getFilename()); + + } + + enum TestData { + // @formatter:off + MAPPING ("model-validation/instance-reader/model-instance-mapping.json_conf"), + MAPPING_ROOT_UNKNOWN ("model-validation/instance-reader/model-instance-mapping-root-unknown.json_conf"), + MAPPING_ROOT_MISSING ("model-validation/instance-reader/model-instance-mapping-root-missing.json_conf"), + CONNECTOR ("model-validation/instance-reader/connector.json"), + CONNECTOR_MODEL_NAME ("model-validation/instance-reader/connector-model-name.json"), + CONNECTOR_SIBLING ("model-validation/instance-reader/connector-sibling-inventory-items.json"), + EXPECTED_VDC ("model-validation/instance-reader/expected-virtual-data-center.json"), + EXPECTED_VDC_MODEL_NAME ("model-validation/instance-reader/expected-virtual-data-center-model-name.json"), + EXPECTED_LOGICAL_LINK ("model-validation/instance-reader/expected-logical-link.json"), + EXPECTED_GENERIC_VNF ("model-validation/instance-reader/expected-generic-vnf.json"), + EXPECTED_PSERVER ("model-validation/instance-reader/expected-pserver.json"); + + private String filename; + TestData(String filename) {this.filename = filename;} + public String getFilename() {return this.filename;} + // @formatter:on + } + + @Rule + public ExpectedException thrown = ExpectedException.none(); + + @Test + public void testGetValuesNoModelName() throws Exception { + // Set expectation + JsonParser jsonParser = new JsonParser(); + JsonElement jsonElement = jsonParser.parse(expectedVirtualDataCenter); + String expectedValue = jsonElement.toString(); + + // Method under test + Multimap<String, String> values = instanceReader.getValues(connector, mapping); + + assertFalse(values.isEmpty()); + assertThat(values.keys().iterator().next(), is(equalTo("virtual-data-center"))); + assertThat(values.get("virtual-data-center").iterator().next(), is(equalTo(expectedValue))); + } + + @Test + public void testGetValuesWithModelName() throws Exception { + // Set expectation + JsonParser jsonParser = new JsonParser(); + JsonElement jsonElement = jsonParser.parse(expectedVirtualDataCenterModelName); + String expectedValue = jsonElement.toString(); + + // Method under test + Multimap<String, String> values = instanceReader.getValues(connectorModelName, mapping); + + assertFalse(values.isEmpty()); + assertThat(values.keys().iterator().next(), is(equalTo("Test VC Model Name"))); + assertThat(values.get("Test VC Model Name").iterator().next(), is(equalTo(expectedValue))); + } + + @Test + public void testNavigateInstance() throws Exception { + // Set expectation + JsonParser jsonParser = new JsonParser(); + JsonElement jsonElement = jsonParser.parse(expectedLogicalLink); + String expectedValue = jsonElement.toString(); + + // Method under test + Multimap<String, String> values = instanceReader.getValues(connector, mapping); + + String virtualDataCenterInstance = values.get("virtual-data-center").iterator().next(); + + // Method under test + values = instanceReader.getValues(virtualDataCenterInstance, mapping); + + assertThat(values.keys().iterator().next(), is(equalTo("Test LL Model Name"))); + assertThat(values.get("Test LL Model Name").iterator().next(), is(equalTo(expectedValue))); + } + + @Test + public void testNavigateInstanceWithSiblingInventoryItems() throws Exception { + // Set expectations + JsonParser jsonParser = new JsonParser(); + JsonElement genericVnfJsonElement = jsonParser.parse(expectedGenericVnf); + String expectedGenericVnf = genericVnfJsonElement.toString(); + + JsonElement pserverJsonElement = jsonParser.parse(expectedPserver); + String expectedPserver = pserverJsonElement.toString(); + + // Method under test + Multimap<String, String> values = instanceReader.getValues(connectorSibling, mapping); + + String virtualDataCenterInstance = values.get("virtual-data-center").iterator().next(); + + // Method under test + values = instanceReader.getValues(virtualDataCenterInstance, mapping); + + String logicalLinkInstance = values.get("Test LL Model Name").iterator().next(); + + // Method under test + values = instanceReader.getValues(logicalLinkInstance, mapping); + + assertThat(values.get("generic-vnf").iterator().next(), is(equalTo(expectedGenericVnf))); + assertThat(values.get("pserver").iterator().next(), is(equalTo(expectedPserver))); + } + + @Test + public void testGetValuesRootUnknown() throws Exception { + Multimap<String, String> values = instanceReader.getValues(connector, mappingRootUnknown); + + assertThat(values.isEmpty(), is(true)); + } + + @Test + public void testGetValuesRootMissing() throws Exception { + thrown.expect(ValidationServiceException.class); + thrown.expectMessage("VS-604"); + + instanceReader.getValues(connector, mappingRootMissing); + } + + @Test + public void testGetInstanceTypeNoModelName() throws Exception { + String instanceType = instanceReader.getInstanceType(connector); + assertThat(instanceType, is("connector")); + } + + @Test + public void testGetModelName() throws Exception { + String instanceType = instanceReader.getModelName(connectorModelName); + assertThat(instanceType, is("Test Connector Model Name")); + } + + @Test + public void testGetInstanceIdNoModelName() throws Exception { + String instanceId = instanceReader.getInstanceId(connector); + assertThat(instanceId, is("c7611ebe-c324-48f1-8085-94aef0c12fd")); + } + + @Test + public void testGetInstanceIdModelName() throws Exception { + String instanceId = instanceReader.getInstanceId(connectorModelName); + assertThat(instanceId, is("c7611ebe-c324-48f1-8085-94aef0c12fd")); + } + + @Test + public void testGetResourceVersion() throws Exception { + String resourceVersion = instanceReader.getResourceVersion(connector); + + assertThat(resourceVersion, is("1467975776")); + } + + private static ModelInstanceMapper getMapping(String mappingFileName) throws Exception { + JSONArray jsonArray = new JSONArray(TestUtil.getFileAsString(mappingFileName)); + JSONObject jsonObject = jsonArray.getJSONObject(0); + + return JsonUtil.fromJson(jsonObject.toString(), ModelInstanceMapper.class); + } +} diff --git a/src/test/java/org/onap/aai/validation/modeldriven/validator/TestModelDrivenValidator.java b/src/test/java/org/onap/aai/validation/modeldriven/validator/TestModelDrivenValidator.java new file mode 100644 index 0000000..cb9de43 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/modeldriven/validator/TestModelDrivenValidator.java @@ -0,0 +1,291 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.modeldriven.validator; + +import static org.hamcrest.CoreMatchers.containsString; +import static org.hamcrest.Matchers.empty; +import static org.hamcrest.Matchers.equalTo; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder; +import static org.junit.Assert.assertThat; + +import java.util.ArrayList; +import java.util.Arrays; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import javax.inject.Inject; +import org.dom4j.Element; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.InjectMocks; +import org.mockito.Mock; +import org.mockito.Mockito; +import org.mockito.MockitoAnnotations; +import org.onap.aai.validation.controller.ValidationController; +import org.onap.aai.validation.modeldriven.ModelCacheManager; +import org.onap.aai.validation.modeldriven.ModelId; +import org.onap.aai.validation.modeldriven.parser.XMLModelParser; +import org.onap.aai.validation.modeldriven.validator.ModelDrivenValidator; +import org.onap.aai.validation.result.ValidationResult; +import org.onap.aai.validation.result.Violation; +import org.onap.aai.validation.test.util.TestUtil; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.TestPropertySource; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@TestPropertySource(properties = {"schemaIngestPropLoc = src/test/resources/oxm-reader/schemaIngest.properties"}) +@ContextConfiguration(locations = {"classpath:model-validation/instance-validator/test-validation-service-beans.xml"}) +public class TestModelDrivenValidator { + + static { + System.setProperty("APP_HOME", "."); + } + + private static final String RESOURCE_VERSION = "1467975776"; + private static final String MODEL_ID_ATTRIBUTE_MNV = "model-name-version-id"; + private static final String MODEL_ID_ATTRIBUTE_MID = "model-id"; + + @Mock + private ModelCacheManager mockModelCacheManager; + + @InjectMocks + @Inject + private ModelDrivenValidator modelDrivenValidator; + + private String objectInstance; + private String connectorModel; + + enum INSTANCE_VALIDATION_FILE { + // @formatter:off + CONNECTOR_MODEL ("model-validation/instance-validator/connector-widget-id.xml"), + NO_MODEL_ID ("model-validation/instance-validator/connector-instance-no-model-id.json"), + UNKNOWN_MODEL_ID ("model-validation/instance-validator/connector-instance-unknown-model-id.json"), + ERRORS ("model-validation/instance-validator/connector-instance-errors.json"), + MULTIPLE_MISSING_ATTRS ("model-validation/instance-validator/connector-instance-multiple-missing-attrs.json"), + MULTIPLE_UNEXPECTED_ATTRS ("model-validation/instance-validator/connector-instance-multiple-unexpected-attrs.json"), + SUCCESS ("model-validation/instance-validator/connector-instance-success.json"); + // @formatter:on + + private String filename; + + INSTANCE_VALIDATION_FILE(String filename) { + this.filename = filename; + } + + public String getFilename() { + return this.filename; + } + } + + @Before + public void initMocks() { + MockitoAnnotations.initMocks(this); + } + + @Before + public void setUp() throws Exception { + connectorModel = TestUtil.getFileAsString(INSTANCE_VALIDATION_FILE.CONNECTOR_MODEL.getFilename()); + } + + @Test + public void testValidateInstanceWithoutModelId() throws Exception { + objectInstance = TestUtil.getFileAsString(INSTANCE_VALIDATION_FILE.NO_MODEL_ID.getFilename()); + + ValidationResult validationResult = modelDrivenValidator.validate(objectInstance).get(0); + assertThatValidationResultIsValid(validationResult, "c7611ebe-c324-48f1-8085-94aef0c12fd", "connector", + "1467975776"); + + Violation violation = validationResult.getViolations().get(0); + Map<String, Object> details = new HashMap<>(); + details.put("No model ID", null); + assertThatViolationIsValid(violation, ValidationController.VALIDATION_ERROR_SEVERITY, details, + "The model [null] could not be found", RESOURCE_VERSION); + } + + @Test + public void testValidateInstanceWithUnknownModelId() throws Exception { + objectInstance = TestUtil.getFileAsString(INSTANCE_VALIDATION_FILE.UNKNOWN_MODEL_ID.getFilename()); + + Mockito.when(mockModelCacheManager.get(new ModelId(MODEL_ID_ATTRIBUTE_MID, "UNKNOWN-MODEL"))).thenReturn(null); + + ValidationResult validationResult = modelDrivenValidator.validate(objectInstance).get(0); + assertThatValidationResultIsValid(validationResult, "c7611ebe-c324-48f1-8085-94aef0c12fd", "connector", + "1467975776"); + + Violation violation = validationResult.getViolations().get(0); + Map<String, Object> details = new HashMap<>(); + details.put("No model ID", "UNKNOWN-MODEL"); + assertThatViolationIsValid(violation, ValidationController.VALIDATION_ERROR_SEVERITY, details, + "The model [UNKNOWN-MODEL] could not be found", RESOURCE_VERSION); + } + + @Test + public void testValidate() throws Exception { + objectInstance = TestUtil.getFileAsString(INSTANCE_VALIDATION_FILE.ERRORS.getFilename()); + + Element modelElement = XMLModelParser.parse(connectorModel, true); + + Mockito.when(mockModelCacheManager.get(new ModelId(MODEL_ID_ATTRIBUTE_MID, "connector-widget-id"))) + .thenReturn(modelElement); + Mockito.when(mockModelCacheManager + .get(new ModelId(MODEL_ID_ATTRIBUTE_MNV, "l2-bridge-for-wan-connector-resource-id"))).thenReturn(null); + + ValidationResult validationResult = modelDrivenValidator.validate(objectInstance).get(0); + assertThatValidationResultIsValid(validationResult, "c7611ebe-c324-48f1-8085-94aef0c12fd", "connector", + "1467975776"); + + List<Violation> violations = validationResult.getViolations(); + + assertThat(violations, hasSize(3)); + assertThat(getCategories(violations), + containsInAnyOrder(Arrays.asList("MISSING_ATTR", "UNEXPECTED_ATTR", "UNEXPECTED_REL").toArray())); + + Violation violation = getValidationByCategory(violations, "MISSING_ATTR").get(0); + Map<String, Object> details = new HashMap<>(); + details.put("MISSING ATTR", "product"); + assertThatViolationIsValid(violation, ValidationController.VALIDATION_ERROR_SEVERITY, details, + "Attribute [product] is missing in the object instance", RESOURCE_VERSION); + + violation = getValidationByCategory(violations, "UNEXPECTED_ATTR").get(0); + details = new HashMap<>(); + details.put("UNEXPECTED ATTR", "unexpected"); + assertThatViolationIsValid(violation, ValidationController.VALIDATION_ERROR_SEVERITY, details, + "Attribute [unexpected] should not be present in the object instance", RESOURCE_VERSION); + + violation = getValidationByCategory(violations, "UNEXPECTED_REL").get(0); + details = new HashMap<>(); + Map<String, Object> entityIdmap = new HashMap<>(); + entityIdmap.put("vdc-id", "vdc-01"); + details.put("entityId", entityIdmap); + details.put("modelName", null); + details.put("entityType", "virtual-data-center"); + details.put("UNEXPECTED REL", "logical-link"); + assertThatViolationIsValid(violation, ValidationController.VALIDATION_ERROR_SEVERITY, details, + "Entity [vdc-id=vdc-01] of type [virtual-data-center] must not be related to [logical-link]", + RESOURCE_VERSION); + } + + @Test + public void testValidateMultipleMissingAttrs() throws Exception { + objectInstance = TestUtil.getFileAsString(INSTANCE_VALIDATION_FILE.MULTIPLE_MISSING_ATTRS.getFilename()); + + Element modelElement = XMLModelParser.parse(connectorModel, true); + + Mockito.when(mockModelCacheManager.get(new ModelId(MODEL_ID_ATTRIBUTE_MID, "connector-widget-id"))) + .thenReturn(modelElement); + Mockito.when(mockModelCacheManager + .get(new ModelId(MODEL_ID_ATTRIBUTE_MNV, "l2-bridge-for-wan-connector-resource-id"))).thenReturn(null); + + List<Violation> violations = modelDrivenValidator.validate(objectInstance).get(0).getViolations(); + + assertThat(violations, hasSize(2)); + assertThat(getCategories(violations), + containsInAnyOrder(Arrays.asList("MISSING_ATTR", "MISSING_ATTR").toArray())); + + List<Violation> missingAttrValidations = getValidationByCategory(violations, "MISSING_ATTR"); + String detailsAsString = getDetails(missingAttrValidations).toString(); + assertThat(detailsAsString, containsString("{MISSING ATTR=product}")); + assertThat(detailsAsString, containsString("{MISSING ATTR=vpn-id}")); + } + + @Test + public void testValidateMultipleUnexpectedAttrs() throws Exception { + objectInstance = TestUtil.getFileAsString(INSTANCE_VALIDATION_FILE.MULTIPLE_UNEXPECTED_ATTRS.getFilename()); + + Element modelElement = XMLModelParser.parse(connectorModel, true); + + Mockito.when(mockModelCacheManager.get(new ModelId(MODEL_ID_ATTRIBUTE_MID, "connector-widget-id"))) + .thenReturn(modelElement); + Mockito.when(mockModelCacheManager + .get(new ModelId(MODEL_ID_ATTRIBUTE_MNV, "l2-bridge-for-wan-connector-resource-id"))).thenReturn(null); + + List<Violation> violations = modelDrivenValidator.validate(objectInstance).get(0).getViolations(); + + assertThat(violations, hasSize(2)); + assertThat(getCategories(violations), + containsInAnyOrder(Arrays.asList("UNEXPECTED_ATTR", "UNEXPECTED_ATTR").toArray())); + + List<Violation> missingAttrViolations = getValidationByCategory(violations, "UNEXPECTED_ATTR"); + String detailsAsString = getDetails(missingAttrViolations).toString(); + assertThat(detailsAsString, containsString("{UNEXPECTED ATTR=city}")); + assertThat(detailsAsString, containsString("{UNEXPECTED ATTR=state}")); + } + + @Test + public void testValidateSuccess() throws Exception { + objectInstance = TestUtil.getFileAsString(INSTANCE_VALIDATION_FILE.SUCCESS.getFilename()); + + Element modelElement = XMLModelParser.parse(connectorModel, true); + + Mockito.when(mockModelCacheManager.get(new ModelId(MODEL_ID_ATTRIBUTE_MID, "connector-widget-id"))) + .thenReturn(modelElement); + Mockito.when(mockModelCacheManager + .get(new ModelId(MODEL_ID_ATTRIBUTE_MNV, "l2-bridge-for-wan-connector-resource-id"))).thenReturn(null); + + List<Violation> violations = modelDrivenValidator.validate(objectInstance).get(0).getViolations(); + + assertThat(violations, is(empty())); + } + + private void assertThatValidationResultIsValid(ValidationResult validationResult, String entityInstanceId, + String entityType, String resourceVersion) { + assertThat( + validationResult.getEntityId().getAsJsonObject().entrySet().iterator().next().getValue().getAsString(), + is(equalTo(entityInstanceId))); + assertThat(validationResult.getEntityType(), is(equalTo(entityType))); + assertThat(validationResult.getResourceVersion(), is(equalTo(resourceVersion))); + } + + private void assertThatViolationIsValid(Violation violation, String severity, Map<String, Object> violationDetails, + String errorMessage, String resourceVersion) { + assertThat(violation.getSeverity(), is(equalTo(severity))); + assertThat(violation.getViolationType(), is(equalTo("Model"))); + assertThat(violation.getViolationDetails(), is(equalTo(violationDetails))); + assertThat(violation.getErrorMessage(), is(equalTo(errorMessage))); + } + + private List<String> getCategories(List<Violation> validations) { + List<String> categories = new ArrayList<>(); + for (Violation validation : validations) { + categories.add(validation.getCategory()); + } + return categories; + } + + private List<Map<String, Object>> getDetails(List<Violation> validations) { + List<Map<String, Object>> details = new ArrayList<>(); + for (Violation validation : validations) { + details.add(validation.getViolationDetails()); + } + return details; + } + + private List<Violation> getValidationByCategory(List<Violation> validations, String category) { + List<Violation> validationsByCategory = new ArrayList<>(); + for (Violation validation : validations) { + if (category.equals(validation.getCategory())) { + validationsByCategory.add(validation); + } + } + return validationsByCategory; + } +} diff --git a/src/test/java/org/onap/aai/validation/modeldriven/validator/TestModelReader.java b/src/test/java/org/onap/aai/validation/modeldriven/validator/TestModelReader.java new file mode 100644 index 0000000..d974ca2 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/modeldriven/validator/TestModelReader.java @@ -0,0 +1,261 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.modeldriven.validator; + +import static org.hamcrest.Matchers.arrayContainingInAnyOrder; +import static org.hamcrest.Matchers.empty; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; + +import com.google.common.collect.Multimap; +import java.io.File; +import java.util.Collection; +import java.util.List; +import java.util.Map.Entry; +import javax.inject.Inject; +import org.dom4j.Element; +import org.dom4j.Node; +import org.json.JSONArray; +import org.json.JSONObject; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.aai.validation.exception.ValidationServiceException; +import org.onap.aai.validation.modeldriven.ModelCacheManager; +import org.onap.aai.validation.modeldriven.configuration.mapping.ModelInstanceMapper; +import org.onap.aai.validation.modeldriven.parser.XMLModelParser; +import org.onap.aai.validation.modeldriven.validator.ModelReader; +import org.onap.aai.validation.test.util.TestUtil; +import org.onap.aai.validation.util.JsonUtil; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@ContextConfiguration(locations = {"classpath:model-validation/model-reader/test-validation-service-beans.xml"}) +public class TestModelReader { + + static { + System.setProperty("APP_HOME", "."); + } + + private Element modelElement; + private ModelInstanceMapper mapping; + + @Inject + private ModelCacheManager cache; + + @Test + public void testGetValues() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-attributes-1.json"); + modelElement = XMLModelParser + .parse(new File("src/test/resources/model-validation/model-reader/connector-widget-id.xml"), false); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + + assertThat(values.entries().size(), is(2)); + assertThat(values.containsEntry("product", null), is(true)); + assertThat(values.containsEntry("vpn-id", null), is(true)); + } + + /** + * @throws Exception + */ + @Test(expected = ValidationServiceException.class) + public void testGetValuesWithUnknownPath() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-attributes-2.json"); + modelElement = XMLModelParser + .parse(new File("src/test/resources/model-validation/model-reader/connector-widget-id.xml"), false); + + ModelReader.getValues(modelElement, mapping, cache); + } + + @Test + public void testGetValuesSingleModel() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships.json"); + modelElement = XMLModelParser + .parse(new File("src/test/resources/model-validation/model-reader/connector-widget-id.xml"), false); + + List<Node> expectedModels = XMLModelParser.getObjectsFromXPath(modelElement, mapping.getModel().getRoot()); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + + Collection<Entry<String, Node>> entries = values.entries(); + assertThat(entries.size(), is(1)); + assertThat(values.containsEntry("virtual-data-center", expectedModels.get(0)), is(true)); + } + + @Test + public void testGetValuesMultipleModels() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships.json"); + modelElement = XMLModelParser + .parse(new File("src/test/resources/model-validation/model-reader/logical-link-widget-id.xml"), false); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + + assertThat(values.keys().toArray(new String[] {}), arrayContainingInAnyOrder(new String[] {"logical-link",})); + + values = ModelReader.getValues(values.values().iterator().next(), mapping, cache); + + assertThat(values.keys().toArray(new String[] {}), + arrayContainingInAnyOrder(new String[] {"pBgf", "vDbe", "ipe", "vSbg",})); + } + + @Test + public void testGetValuesCurrentModelNoChildrenNoValues() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships.json"); + modelElement = XMLModelParser.parse( + new File("src/test/resources/model-validation/model-reader/connector-widget-id-no-children-1.xml"), + false); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + + assertThat(values.isEmpty(), is(true)); + } + + @Test + public void testGetValuesCurrentModelNoChildrenWithValues() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships.json"); + modelElement = XMLModelParser.parse( + new File("src/test/resources/model-validation/model-reader/connector-widget-id-no-children-2.xml"), + false); + + Multimap<String, Node> parentValues = ModelReader.getValues(modelElement, mapping, cache); + + Multimap<String, Node> childValues = + ModelReader.getValues(parentValues.entries().iterator().next().getValue(), mapping, cache); + + assertThat(childValues.isEmpty(), is(true)); + } + + @Test + public void testResourceModelType() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships.json"); + modelElement = XMLModelParser.parse( + new File("src/test/resources/model-validation/model-reader/virtual-data-center-widget-id.xml"), false); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + + assertThat(values.keys().toArray(new String[] {}), + arrayContainingInAnyOrder(new String[] {"l2-bridge-for-wan-connector",})); + } + + @Test + public void testRootWithInvalidPath() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships-root-1.json"); + modelElement = XMLModelParser.parse( + new File("src/test/resources/model-validation/model-reader/virtual-data-center-widget-id.xml"), false); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + + assertThat(values.entries(), is(empty())); + } + + @Test + public void testRootMissing() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships-root-2.json"); + modelElement = XMLModelParser.parse( + new File("src/test/resources/model-validation/model-reader/virtual-data-center-widget-id.xml"), false); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + assertThat(values.entries(), is(empty())); + } + + @Test + public void testFilterWithInvalidType() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships-filter-1.json"); + modelElement = XMLModelParser + .parse(new File("src/test/resources/model-validation/model-reader/connector-widget-id.xml"), false); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + + assertThat(values.entries(), is(empty())); + } + + @Test + public void testFilterWithEmptyArray() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships-filter-2.json"); + modelElement = XMLModelParser.parse( + new File("src/test/resources/model-validation/model-reader/virtual-data-center-widget-id.xml"), false); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + + assertThat(values.entries(), is(empty())); + } + + @Test + public void testFilterWithMissingValidProperty() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships-filter-3.json"); + modelElement = XMLModelParser.parse( + new File("src/test/resources/model-validation/model-reader/virtual-data-center-widget-id.xml"), false); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + + assertThat(values.entries(), is(empty())); + } + + @Test + public void testFilterWithInvalidPath() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships-filter-4.json"); + modelElement = XMLModelParser.parse( + new File("src/test/resources/model-validation/model-reader/virtual-data-center-widget-id.xml"), false); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + + assertThat(values.entries(), is(empty())); + } + + @Test + public void testFilterWithMissingPath() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships-filter-5.json"); + modelElement = XMLModelParser.parse( + new File("src/test/resources/model-validation/model-reader/virtual-data-center-widget-id.xml"), false); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + + assertThat(values.entries(), is(empty())); + } + + @Test + public void testFilterMissing() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships-filter-6.json"); + modelElement = XMLModelParser.parse( + new File("src/test/resources/model-validation/model-reader/virtual-data-center-widget-id.xml"), false); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + + assertThat(values.keys().toArray(new String[] {}), + arrayContainingInAnyOrder(new String[] {"l2-bridge-for-wan-connector"})); + } + + @Test + public void testGetValuesWithMultipleModelFetch() throws Exception { + mapping = getMapping("model-validation/model-reader/model-instance-mapping-relationships-with-id.json"); + modelElement = XMLModelParser + .parse(new File("src/test/resources/model-validation/model-reader/connector-widget-id.xml"), false); + + Multimap<String, Node> values = ModelReader.getValues(modelElement, mapping, cache); + + assertThat(values.entries(), is(empty())); + } + + private ModelInstanceMapper getMapping(String mappingFileName) throws Exception { + JSONArray jsonArray = new JSONArray(TestUtil.getFileAsString(mappingFileName)); + JSONObject jsonObject = jsonArray.getJSONObject(0); + + return JsonUtil.fromJson(jsonObject.toString(), ModelInstanceMapper.class); + } +} diff --git a/src/test/java/org/onap/aai/validation/publisher/MockEventPublisher.java b/src/test/java/org/onap/aai/validation/publisher/MockEventPublisher.java new file mode 100644 index 0000000..d1cfae0 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/publisher/MockEventPublisher.java @@ -0,0 +1,72 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.publisher; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.MatcherAssert.assertThat; + +import java.io.IOException; +import java.net.URISyntaxException; +import java.util.Collection; +import org.onap.aai.validation.exception.ValidationServiceException; +import org.onap.aai.validation.publisher.MessagePublisher; +import org.onap.aai.validation.result.ValidationResult; +import org.onap.aai.validation.test.util.TestEntity; +import org.onap.aai.validation.test.util.ValidationResultIsEqual; + +/** + * Will be injected by Spring + * + */ +public class MockEventPublisher implements MessagePublisher { + + private ValidationResult expectedValidationResult; + private String testDescription; + private boolean publishedMessage; + + public MockEventPublisher() { + // Deliberately empty - no configuration needed + } + + public void setTestEntity(TestEntity entity) throws URISyntaxException, IOException { + this.expectedValidationResult = entity.getExpectedValidationResult(); + this.publishedMessage = false; + } + + public void setTestDescription(String testDescription) { + this.testDescription = testDescription; + } + + @Override + public void publishMessage(String message) throws ValidationServiceException { + ValidationResult validationResult = ValidationResult.fromJson(message); + assertThat(testDescription, validationResult, is(ValidationResultIsEqual.equalTo(expectedValidationResult))); + publishedMessage = true; + } + + @Override + public void publishMessages(Collection<String> messages) throws ValidationServiceException { + for (String message : messages) { + publishMessage(message); + } + } + + public boolean processedSuccessfully() { + return publishedMessage || expectedValidationResult == null; + } +} diff --git a/src/test/java/org/onap/aai/validation/publisher/TestValidationEventPublisher.java b/src/test/java/org/onap/aai/validation/publisher/TestValidationEventPublisher.java new file mode 100644 index 0000000..8950e63 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/publisher/TestValidationEventPublisher.java @@ -0,0 +1,102 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.publisher; + +import static org.mockito.Matchers.any; +import static org.mockito.Mockito.times; +import static org.mockito.Mockito.verify; +import static org.mockito.Mockito.when; + +import org.onap.aai.event.client.DMaaPEventPublisher; +import org.onap.aai.validation.config.TopicAdminConfig; +import org.onap.aai.validation.config.TopicConfig; +import org.onap.aai.validation.config.TopicConfig.Topic; +import org.onap.aai.validation.factory.DMaaPEventPublisherFactory; +import org.onap.aai.validation.publisher.ValidationEventPublisher; +import java.util.ArrayList; +import java.util.Collection; +import java.util.List; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mockito; +import org.mockito.runners.MockitoJUnitRunner; + +@RunWith(MockitoJUnitRunner.class) +public class TestValidationEventPublisher { + + static { + System.setProperty("APP_HOME", "."); + System.setProperty("consumer.topic.names", "poa-rule-validation"); + System.setProperty("publisher.topic.names", "poa-audit-result"); + } + + private DMaaPEventPublisher mockEventPublisher; + private ValidationEventPublisher validationEventPublisher; + private List<Topic> topicList = new ArrayList<>(); + + @Before + public void setUp() throws Exception { + TopicConfig mockTopicConfig = Mockito.mock(TopicConfig.class); + TopicAdminConfig mockTopicAdminConfig = Mockito.mock(TopicAdminConfig.class); + when(mockTopicAdminConfig.isPublishEnable()).thenReturn(true); + + Topic topic1 = new TopicConfig("poa-rule-validation","poa-audit-result").new Topic(); + topic1.setName("aai-data-integrity"); + topic1.setHost("integrity-dummy-host"); + topic1.setPartition("integrity-dummy-partition"); + topic1.setUsername("integrity-dummy-username"); + topic1.setPassword("integrity-dummy-password"); + topic1.setTransportType("integrity-dummy-transport-type"); + topicList.add(topic1); + + when(mockTopicConfig.getPublisherTopics()).thenReturn(topicList); + validationEventPublisher = new ValidationEventPublisher(mockTopicConfig, mockTopicAdminConfig); + + mockEventPublisher = Mockito.mock(DMaaPEventPublisher.class); + when(mockEventPublisher.closeWithUnsent()).thenReturn(new ArrayList<>()); + + DMaaPEventPublisherFactory mockEventPublisherFactory = Mockito.mock(DMaaPEventPublisherFactory.class); + when(mockEventPublisherFactory.createEventPublisher(any(), any(), any(), any(), any())) + .thenReturn(mockEventPublisher); + + validationEventPublisher.setEventPublisherFactory(mockEventPublisherFactory); + } + + @Test + public void testPublishMessages() throws Exception { + Collection<String> messages = new ArrayList<>(); + messages.add("first test message"); + messages.add("second test message"); + when(mockEventPublisher.sendSync(any(String.class), Mockito.<Collection<String>>any())).thenReturn(2); + + validationEventPublisher.publishMessages(messages); + verify(mockEventPublisher, times(1)).sendSync(topicList.get(0).getPartition(), messages); + } + + @Test + public void testPublishMessage() throws Exception { + Collection<String> messages = new ArrayList<>(); + messages.add("first test message"); + when(mockEventPublisher.sendSync(any(String.class), Mockito.<Collection<String>>any())).thenReturn(1); + + validationEventPublisher.publishMessage(messages.iterator().next()); + verify(mockEventPublisher, times(1)).sendSync(topicList.get(0).getPartition(), messages); + } + +} diff --git a/src/test/java/org/onap/aai/validation/reader/TestEventReader.java b/src/test/java/org/onap/aai/validation/reader/TestEventReader.java new file mode 100644 index 0000000..a41eb76 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/reader/TestEventReader.java @@ -0,0 +1,270 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.reader; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.not; +import static org.hamcrest.Matchers.empty; +import static org.hamcrest.Matchers.hasSize; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; + +import com.google.gson.JsonElement; +import com.google.gson.JsonParser; +import java.util.Arrays; +import java.util.List; +import java.util.Optional; +import javax.inject.Inject; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.aai.validation.exception.ValidationServiceException; +import org.onap.aai.validation.reader.EventReader; +import org.onap.aai.validation.reader.data.Entity; +import org.onap.aai.validation.reader.data.EntityId; +import org.onap.aai.validation.test.util.TestUtil; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.TestPropertySource; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@TestPropertySource(properties = {"schemaIngestPropLoc = src/test/resources/oxm-reader/schemaIngest.properties"}) +@ContextConfiguration(locations = {"classpath:event-reader/test-validation-service-beans.xml"}) +public class TestEventReader { + + static { + System.setProperty("APP_HOME", "."); + } + + @Inject + private EventReader eventReader; + + private static String vserverEvent; + private static String genericVnfEvent; + private static String invalidEvent1; + private static String invalidEvent2; + private static String invalidEvent3; + private static String invalidEvent4; + private static String invalidEvent5; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + vserverEvent = TestUtil.getFileAsString(TestData.VSERVER.getFilename()); + genericVnfEvent = TestUtil.getFileAsString(TestData.GENERIC_VNF.getFilename()); + invalidEvent1 = TestUtil.getFileAsString(TestData.INVALID_1.getFilename()); + invalidEvent2 = TestUtil.getFileAsString(TestData.INVALID_2.getFilename()); + invalidEvent3 = TestUtil.getFileAsString(TestData.INVALID_3.getFilename()); + invalidEvent4 = TestUtil.getFileAsString(TestData.INVALID_4.getFilename()); + invalidEvent5 = TestUtil.getFileAsString(TestData.INVALID_5.getFilename()); + } + + enum TestData { + // @formatter:off + VSERVER ("event-reader/vserver-create-event.json"), + GENERIC_VNF ("event-reader/generic-vnf-create-event.json"), + INVALID_1 ("event-reader/invalid-event-1.json"), + INVALID_2 ("event-reader/invalid-event-2.json"), + INVALID_3 ("event-reader/invalid-event-3.json"), + INVALID_4 ("event-reader/invalid-event-4.json"), + INVALID_5 ("event-reader/invalid-event-5.json"); + + private String filename; + TestData(String filename) {this.filename = filename;} + public String getFilename() {return this.filename;} + // @formatter:on + } + + @Test + public void testGetEventDomain() throws Exception { + Optional<String> eventType = eventReader.getEventDomain(vserverEvent); + + assertThat(eventType.get(), is("devINT1")); + } + + @Test + public void testGetEventAction() throws Exception { + Optional<String> action = eventReader.getEventAction(vserverEvent); + + assertThat(action.get(), is("CREATE")); + } + + @Test + public void testGetEventType() throws Exception { + Optional<String> eventType = eventReader.getEventType(vserverEvent); + + assertThat(eventType.isPresent(), is(true)); + assertThat(eventType.get(), is("AAI-EVENT")); + } + + @Test(expected = ValidationServiceException.class) + public void testGetEventTypeMalformedJson() throws Exception { + eventReader.getEventType("this is malformed"); + } + + @Test + public void testGetEventTypeFromUnrecognisableEvent() throws Exception { + Optional<String> eventType = eventReader.getEventType("this-is-not-an-event-but-is-valid-json"); + + assertThat(eventType.isPresent(), is(false)); + } + + @Test + public void testGetEventTypeThatIsMissing() throws Exception { + Optional<String> eventType = eventReader.getEventType(invalidEvent1); + + assertThat(eventType.isPresent(), is(false)); + } + + @Test + public void testGetEntityType() throws Exception { + Optional<String> entityType = eventReader.getEntityType(vserverEvent); + + assertThat(entityType.get(), is("vserver")); + } + + @Test + public void testGetEntity() throws Exception { + Entity entity = eventReader.getEntity(genericVnfEvent); + + assertThat(entity.getType(), is("generic-vnf")); + + // Dig deeper to check we have the object we want + JsonParser parser = new JsonParser(); + JsonElement jsonElement = parser.parse(entity.getJson()); + String id = jsonElement.getAsJsonObject().get("vnf-id").getAsString(); + + assertThat(id, is("VAPP-1581")); + } + + @Test + public void testEntityLink() throws Exception { + Entity entity = eventReader.getEntity(vserverEvent); + + assertThat(entity.getEntityLink(), is( + "cloud-infrastructure/cloud-regions/cloud-region/region1/AAIregion1/tenants/tenant/example-tenant-id-val-88551/vservers/vserver/example-vserver-id-val-34666")); + } + + @Test(expected = ValidationServiceException.class) + public void testGetEntityWithMissingEntityType() throws Exception { + eventReader.getEntity(invalidEvent1); + } + + @Test(expected = ValidationServiceException.class) + public void testGetEntityWithUnknownEntityType() throws Exception { + eventReader.getEntity(invalidEvent2); + } + + @Test + public void testGetNestedEntity() throws Exception { + Entity entity = eventReader.getEntity(vserverEvent); + + assertThat(entity.getType(), is("vserver")); + + // Dig deeper to check we have the object we want + JsonParser parser = new JsonParser(); + JsonElement jsonElement = parser.parse(entity.getJson()); + String id = jsonElement.getAsJsonObject().get("vserver-id").getAsString(); + + assertThat(id, is("example-vserver-id-val-34666")); + } + + @Test(expected = ValidationServiceException.class) + public void testTooManyNestedEntitiesThrowsException() throws Exception { + eventReader.getEntity(invalidEvent4); + } + + @Test + public void testGetEntityIds() throws Exception { + Entity entity = eventReader.getEntity(vserverEvent); + + List<EntityId> ids = entity.getIds(); + + assertThat(ids, hasSize(1)); + EntityId entityId = ids.get(0); + + assertThat(entityId.getPrimaryKey(), is("vserver-id")); + assertThat(entityId.getValue(), is("example-vserver-id-val-34666")); + } + + @Test + public void testCompareEntityIds() throws Exception { + EntityId entityId = new EntityId(); + assertThat(entityId, is(not(equalTo(null)))); + + entityId.setPrimaryKey("key"); + assertThat(entityId, is(not(equalTo(null)))); + entityId.setValue("value"); + assertThat(entityId, is(not(equalTo(null)))); + + EntityId other = new EntityId(); + assertThat(entityId, is(not(equalTo(other)))); + + other.setPrimaryKey("key"); + assertThat(entityId, is(not(equalTo(other)))); + + other.setValue("value"); + assertThat(entityId, is(equalTo(other))); + + // Force call to hashCode() + assertThat(entityId.hashCode(), is(equalTo(other.hashCode()))); + } + + @Test + public void testGetEntityIdsForUnknownEntityType() throws Exception { + Entity entity = eventReader.getEntity(invalidEvent3); + + List<EntityId> ids = entity.getIds(); + + assertThat(ids, is(empty())); + } + + @Test + public void testGetResourceVersion() throws Exception { + Entity entity = eventReader.getEntity(vserverEvent); + + Optional<String> resourceVersion = entity.getResourceVersion(); + + assertThat(resourceVersion.isPresent(), is(true)); + assertThat(resourceVersion.get(), is("1464193654")); + } + + @Test + public void testGetResourceVersionMissing() throws Exception { + Entity entity = eventReader.getEntity(invalidEvent5); + + Optional<String> resourceVersion = entity.getResourceVersion(); + assertThat(resourceVersion.isPresent(), is(false)); + } + + @Test + public void testGetProperty() throws Exception { + Entity entity = eventReader.getEntity(vserverEvent); + + String resourceVersion = (String) entity.getAttributeValues(Arrays.asList("prov-status")).get("prov-status"); + + assertThat(resourceVersion, is("PREPROV")); + } + + @Test + public void testEntityLinkIsStripped() throws Exception { + Entity entity = eventReader.getEntity(vserverEvent); + String entityLink = entity.getEntityLink(); + assertThat(entityLink, is( + "cloud-infrastructure/cloud-regions/cloud-region/region1/AAIregion1/tenants/tenant/example-tenant-id-val-88551/vservers/vserver/example-vserver-id-val-34666")); + } +} diff --git a/src/test/java/org/onap/aai/validation/reader/TestJsonReader.java b/src/test/java/org/onap/aai/validation/reader/TestJsonReader.java new file mode 100644 index 0000000..e7a906a --- /dev/null +++ b/src/test/java/org/onap/aai/validation/reader/TestJsonReader.java @@ -0,0 +1,95 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.reader; + +import static org.hamcrest.Matchers.empty; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; + +import java.util.Arrays; +import java.util.List; +import org.junit.Test; +import org.onap.aai.validation.reader.JsonReader; +import org.onap.aai.validation.test.util.TestUtil; + +public class TestJsonReader { + + static { + System.setProperty("APP_HOME", "."); + } + + enum TestData { + // @formatter:off + SAMPLE_JSON ("json-reader/sample.json"); + + private String filename; + TestData(String filename) {this.filename = filename;} + public String getFilename() {return this.filename;} + // @formatter:on + } + + @Test + public void testGetString() throws Exception { + String json = TestUtil.getFileAsString(TestData.SAMPLE_JSON.getFilename()); + JsonReader jsonReader = new JsonReader(); + List<String> result = jsonReader.get(json, "$.event-header.entity-type"); + assertThat(result.get(0), is("vserver")); + } + + @Test + public void testGetInteger() throws Exception { + String json = TestUtil.getFileAsString(TestData.SAMPLE_JSON.getFilename()); + JsonReader jsonReader = new JsonReader(); + List<String> result = jsonReader.get(json, "$.event-header.sample-integer"); + assertThat(result.get(0), is("1")); + } + + @Test + public void testGetBoolean() throws Exception { + String json = TestUtil.getFileAsString(TestData.SAMPLE_JSON.getFilename()); + JsonReader jsonReader = new JsonReader(); + List<String> result = jsonReader.get(json, "$.event-header.sample-boolean"); + assertThat(result.get(0), is("true")); + } + + @Test + public void testGetObjectAsString() throws Exception { + String json = TestUtil.getFileAsString(TestData.SAMPLE_JSON.getFilename()); + JsonReader jsonReader = new JsonReader(); + List<String> result = jsonReader.get(json, "$.event-header.sample-object"); + + assertThat(result.get(0), is("{\"property\":\"value\"}")); + } + + @Test + public void testGetArrayAsString() throws Exception { + String json = TestUtil.getFileAsString(TestData.SAMPLE_JSON.getFilename()); + JsonReader jsonReader = new JsonReader(); + List<String> result = jsonReader.get(json, "$.event-header.sample-array"); + + assertThat(result, is(Arrays.asList("one"))); + } + + @Test + public void testGetWithInvalidPath() throws Exception { + String json = TestUtil.getFileAsString(TestData.SAMPLE_JSON.getFilename()); + JsonReader jsonReader = new JsonReader(); + List<String> result = jsonReader.get(json, "$.unknown"); + assertThat(result, empty()); + } +} diff --git a/src/test/java/org/onap/aai/validation/reader/TestOxmConfigTranslator.java b/src/test/java/org/onap/aai/validation/reader/TestOxmConfigTranslator.java new file mode 100644 index 0000000..73e76db --- /dev/null +++ b/src/test/java/org/onap/aai/validation/reader/TestOxmConfigTranslator.java @@ -0,0 +1,111 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.reader; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.Matchers.isEmptyString; +import static org.hamcrest.Matchers.not; +import static org.junit.Assert.assertThat; + +import java.nio.file.InvalidPathException; +import java.util.List; +import java.util.Map; +import java.util.ServiceConfigurationError; +import org.junit.Test; +import org.onap.aai.setup.SchemaLocationsBean; +import org.onap.aai.setup.Version; +import org.onap.aai.validation.reader.OxmConfigTranslator; +import org.springframework.test.util.ReflectionTestUtils; + +public class TestOxmConfigTranslator { + + static { + System.setProperty("APP_HOME", "."); + } + + @Test + public void testOxmFiles() { + OxmConfigTranslator translator = buildConfigTranslator("src/test/resources/oxm-reader/single/"); + Map<Version, List<String>> latestVersion = translator.getNodeFiles(); + assertThat(latestVersion.size(), is(3)); + assertThat(latestVersion.values().iterator().next().size(), is(1)); + assertThat(latestVersion.values().iterator().next().get(0), not(isEmptyString())); + Map<Version, List<String>> latestVersion1 = translator.getEdgeFiles(); + assertThat(latestVersion1.size(), is(1)); + assertThat(latestVersion1.values().iterator().next().size(), is(1)); + assertThat(latestVersion1.values().iterator().next().get(0), not(isEmptyString())); + } + + @Test + public void testMultipleOxmFilesPerVersion() { + OxmConfigTranslator translator = buildConfigTranslator("src/test/resources/oxm-reader/multiple"); + Map<Version, List<String>> latestVersion = translator.getNodeFiles(); + assertThat(latestVersion.size(), is(2)); + assertThat(latestVersion.values().iterator().next().size(), is(2)); + assertThat(latestVersion.values().iterator().next().get(0), not(isEmptyString())); + Map<Version, List<String>> latestVersion1 = translator.getEdgeFiles(); + assertThat(latestVersion1.size(), is(0)); + } + + @Test + public void testZeroMatchingFiles() { + OxmConfigTranslator translator = buildConfigTranslator("src/test/resources/oxm-reader/"); + Map<Version, List<String>> versionsMap = translator.getNodeFiles(); + assertThat(versionsMap.size(), is(0)); + } + + @Test(expected = ServiceConfigurationError.class) + public void testNullNodesPath() { + buildConfigTranslator(null).getNodeFiles(); + } + + @Test(expected = ServiceConfigurationError.class) + public void testNullEdgesPath() { + buildConfigTranslator(null).getEdgeFiles(); + } + + @Test(expected = ServiceConfigurationError.class) + public void testNonExistentNodesPath() { + buildConfigTranslator("no-such-folder-exists/").getNodeFiles(); + } + + @Test(expected = ServiceConfigurationError.class) + public void testNonExistentEdgesPath() { + SchemaLocationsBean bean = new SchemaLocationsBean(); + ReflectionTestUtils.setField(bean, "nodeDirectory", "src/test/resources/oxm-reader/"); + ReflectionTestUtils.setField(bean, "edgeDirectory", "no-such-folder-exists/"); + new OxmConfigTranslator(bean).getEdgeFiles(); + } + + @Test(expected = InvalidPathException.class) + public void testInvalidPath() { + buildConfigTranslator("\0").getEdgeFiles(); + } + + private OxmConfigTranslator buildConfigTranslator(String path) { + return new OxmConfigTranslator(createSchemaLocationsBean(path)); + } + + private SchemaLocationsBean createSchemaLocationsBean(String path) { + SchemaLocationsBean bean = new SchemaLocationsBean(); + ReflectionTestUtils.setField(bean, "nodeDirectory", path); + ReflectionTestUtils.setField(bean, "edgeDirectory", path); + return bean; + } + +} diff --git a/src/test/java/org/onap/aai/validation/reader/TestOxmReader.java b/src/test/java/org/onap/aai/validation/reader/TestOxmReader.java new file mode 100644 index 0000000..f7f2643 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/reader/TestOxmReader.java @@ -0,0 +1,63 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.reader; + +import static org.hamcrest.Matchers.contains; +import static org.hamcrest.Matchers.empty; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; + +import java.util.List; +import javax.inject.Inject; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.aai.validation.reader.OxmReader; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.TestPropertySource; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@TestPropertySource(properties = {"schemaIngestPropLoc = src/test/resources/oxm-reader/schemaIngest.properties"}) +@ContextConfiguration(locations = {"classpath:oxm-reader/oxm-reader-beans.xml"}) +public class TestOxmReader { + + static { + System.setProperty("APP_HOME", "."); + } + + @Inject + private OxmReader oxmReader; + + @Test + public void testGetPrimaryKeysSingleKey() throws Exception { + List<String> primaryKeys = oxmReader.getPrimaryKeys("connector"); + assertThat(primaryKeys.get(0), is("resource-instance-id")); + } + + @Test + public void testGetPrimaryKeysMultipleKeys() throws Exception { + List<String> primaryKeys = oxmReader.getPrimaryKeys("cloud-region"); + assertThat(primaryKeys, contains("cloud-owner", "cloud-region-id")); + } + + @Test + public void testGetPrimaryKeysUnknownObject() throws Exception { + List<String> primaryKeys = oxmReader.getPrimaryKeys("most-surely-does-not-exist"); + assertThat(primaryKeys, empty()); + } +} diff --git a/src/test/java/org/onap/aai/validation/request/TestRequestHeaders.java b/src/test/java/org/onap/aai/validation/request/TestRequestHeaders.java new file mode 100644 index 0000000..b9ff07c --- /dev/null +++ b/src/test/java/org/onap/aai/validation/request/TestRequestHeaders.java @@ -0,0 +1,143 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.request; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.CoreMatchers.nullValue; +import static org.junit.Assert.assertThat; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Map.Entry; +import javax.ws.rs.core.MultivaluedHashMap; +import org.junit.Test; +import org.mockito.Mockito; +import org.onap.aai.validation.services.RequestHeaders; +import org.springframework.http.HttpHeaders; + +/** + * Test the RequestHeaders class. + * + */ +public class TestRequestHeaders { + + static { + System.setProperty("APP_HOME", "."); + } + + @Test + public void testONAPHeaders() { + String transactionId = "transaction-id"; + String serviceInstanceId = "service-instance-id"; + + MultivaluedHashMap<String, String> headersMap = new MultivaluedHashMap<>(); + headersMap.put(RequestHeaders.HEADER_REQUEST_ID, createSingletonList(transactionId)); + headersMap.put(RequestHeaders.HEADER_SERVICE_INSTANCE_ID, createSingletonList(serviceInstanceId)); + headersMap.put("X-FromAppId", createSingletonList("app-id")); + headersMap.put("Host", createSingletonList("hostname")); + + HttpHeaders headers = createMockedHeaders(headersMap); + RequestHeaders requestHeaders = new RequestHeaders(headers); + assertThat(requestHeaders.getRequestId(), is(equalTo(transactionId))); + assertThat(requestHeaders.getInstanceId(), is(equalTo(serviceInstanceId))); + } + + @Test + public void testMultipleHeaderValues() { + String transactionId = "transaction-id"; + String serviceInstanceId = "service-instance-id"; + + MultivaluedHashMap<String, String> headersMap = new MultivaluedHashMap<>(); + headersMap.put(RequestHeaders.HEADER_REQUEST_ID, Arrays.asList(transactionId, "fred")); + headersMap.put(RequestHeaders.HEADER_SERVICE_INSTANCE_ID, Arrays.asList(serviceInstanceId, "bob")); + + HttpHeaders headers = createMockedHeaders(headersMap); + RequestHeaders requestHeaders = new RequestHeaders(headers); + assertThat(requestHeaders.getRequestId(), is(equalTo(transactionId))); + assertThat(requestHeaders.getInstanceId(), is(equalTo(serviceInstanceId))); + } + + @Test + public void testStandardHeaders() { + MultivaluedHashMap<String, String> headersMap = new MultivaluedHashMap<>(); + headersMap.put("X-TransactionId", createSingletonList("transaction-id")); + headersMap.put("X-FromAppId", createSingletonList("app-id")); + headersMap.put("Host", createSingletonList("hostname")); + + HttpHeaders headers = createMockedHeaders(headersMap); + RequestHeaders requestHeaders = new RequestHeaders(headers); + assertThat(requestHeaders.getRequestId(), is(nullValue())); + assertThat(requestHeaders.getInstanceId(), is(nullValue())); + } + + @Test + public void testEmptyHeaders() { + MultivaluedHashMap<String, String> headersMap = new MultivaluedHashMap<>(); + headersMap.put(RequestHeaders.HEADER_REQUEST_ID, Collections.emptyList()); + headersMap.put(RequestHeaders.HEADER_SERVICE_INSTANCE_ID, Collections.emptyList()); + + HttpHeaders headers = createMockedHeaders(headersMap); + RequestHeaders requestHeaders = new RequestHeaders(headers); + assertThat(requestHeaders.getRequestId(), is(nullValue())); + assertThat(requestHeaders.getInstanceId(), is(nullValue())); + } + + @Test + public void testNullHeaders() { + MultivaluedHashMap<String, String> headersMap = new MultivaluedHashMap<>(); + headersMap.put(RequestHeaders.HEADER_REQUEST_ID, Collections.emptyList()); + + HttpHeaders headers = createMockedHeaders(headersMap); + Mockito.when(headers.getFirst(RequestHeaders.HEADER_SERVICE_INSTANCE_ID)).thenReturn(null); + + RequestHeaders requestHeaders = new RequestHeaders(headers); + assertThat(requestHeaders.getRequestId(), is(nullValue())); + assertThat(requestHeaders.getInstanceId(), is(nullValue())); + } + + @Test + public void testToString() { + String transactionId = "transaction-id"; + String serviceInstanceId = "service-instance-id"; + + MultivaluedHashMap<String, String> headersMap = new MultivaluedHashMap<>(); + headersMap.put(RequestHeaders.HEADER_REQUEST_ID, createSingletonList(transactionId)); + headersMap.put(RequestHeaders.HEADER_SERVICE_INSTANCE_ID, createSingletonList(serviceInstanceId)); + + HttpHeaders headers = createMockedHeaders(headersMap); + RequestHeaders requestHeaders = new RequestHeaders(headers); + assertThat(requestHeaders.toString(), + is(equalTo("RequestHeaders [requestId=transaction-id, instanceId=service-instance-id]"))); + } + + private HttpHeaders createMockedHeaders(MultivaluedHashMap<String, String> headersMap) { + HttpHeaders headers = Mockito.mock(HttpHeaders.class); + for (Entry<String, List<String>> entry : headersMap.entrySet()) { + List<String> valuesList = entry.getValue(); + String value = valuesList == null || valuesList.isEmpty() ? null : valuesList.get(0); + Mockito.when(headers.getFirst(entry.getKey())).thenReturn(value); + } + return headers; + } + + private List<String> createSingletonList(String listItem) { + return Collections.<String>singletonList(listItem); + } +} diff --git a/src/test/java/org/onap/aai/validation/result/TestValidationResult.java b/src/test/java/org/onap/aai/validation/result/TestValidationResult.java new file mode 100644 index 0000000..5d02101 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/result/TestValidationResult.java @@ -0,0 +1,444 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.result; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.not; +import static org.hamcrest.Matchers.is; +import static org.junit.Assert.assertThat; +import static org.junit.Assert.assertTrue; + +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import com.google.gson.JsonParser; +import java.time.Instant; +import java.time.ZoneOffset; +import java.time.format.DateTimeFormatter; +import java.util.Arrays; +import java.util.HashMap; +import java.util.Map; +import java.util.UUID; +import javax.inject.Inject; +import org.junit.Before; +import org.junit.BeforeClass; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.aai.validation.exception.ValidationServiceException; +import org.onap.aai.validation.reader.EventReader; +import org.onap.aai.validation.reader.data.Entity; +import org.onap.aai.validation.result.ValidationResult; +import org.onap.aai.validation.result.Violation; +import org.onap.aai.validation.result.Violation.Builder; +import org.onap.aai.validation.result.Violation.ViolationType; +import org.onap.aai.validation.test.util.TestUtil; +import org.onap.aai.validation.util.JsonUtil; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.TestPropertySource; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@TestPropertySource(properties = {"schemaIngestPropLoc = src/test/resources/oxm-reader/schemaIngest.properties"}) +@ContextConfiguration(locations = {"classpath:validation-result/test-validation-service-beans.xml"}) +public class TestValidationResult { + + static { + System.setProperty("APP_HOME", "."); + } + + @Inject + private EventReader eventReader; + + private static String vserverEvent; + private static Entity entity; + + @BeforeClass + public static void setUpBeforeClass() throws Exception { + vserverEvent = TestUtil.getFileAsString(TestData.VSERVER.getFilename()); + } + + @Before + public void setUp() throws Exception { + entity = eventReader.getEntity(vserverEvent); + } + + enum TestData { + // @formatter:off + VSERVER ("validation-result/vserver-create-event.json"); + + private String filename; + TestData(String filename) {this.filename = filename;} + public String getFilename() {return this.filename;} + // @formatter:on + } + + @Test + public void testValidationResultWithViolationDetailsAsString() throws Exception { + // Violation details + Map<String, Object> violationDetails = new HashMap<>(); + violationDetails.put("attr1", "val1"); + violationDetails.put("attr2", "val2"); + + ValidationResult validationResult = getValidationResult(violationDetails); + ValidationResult transformedVr = toAndFromJson(validationResult); + + assertThatValidationResultIsValid(transformedVr); + Violation v = assertThatViolationIsValid(transformedVr, validationResult.getViolations().get(0)); + assertThat(v.getViolationDetails(), is(violationDetails)); + } + + @Test + public void testValidationResultWithViolationDetailsIncludingNull() throws Exception { + // Violation details + Map<String, Object> violationDetails = new HashMap<>(); + violationDetails.put("attr1", "val1"); + violationDetails.put("attr2", null); + + ValidationResult validationResult = getValidationResult(violationDetails); + ValidationResult transformedVr = toAndFromJson(validationResult); + + // Check + assertThatValidationResultIsValid(transformedVr); + Violation v = assertThatViolationIsValid(transformedVr, validationResult.getViolations().get(0)); + assertThat(v.getViolationDetails(), is(violationDetails)); + } + + @Test + public void testValidationResultWithViolationDetailsAsList() throws Exception { + // Violation details + Map<String, Object> violationDetails = new HashMap<>(); + violationDetails.put("attr1", Arrays.asList("val1", "val2")); + violationDetails.put("attr2", Arrays.asList("val3", "val4")); + + ValidationResult validationResult = getValidationResult(violationDetails); + ValidationResult transformedVr = toAndFromJson(validationResult); + + // Check + assertThatValidationResultIsValid(transformedVr); + Violation v = assertThatViolationIsValid(transformedVr, validationResult.getViolations().get(0)); + assertThat(v.getViolationDetails(), is(violationDetails)); + } + + @Test + public void testValidationResultWithViolationDetailsAsInt() throws Exception { + // Violation details + Map<String, Object> violationDetails = new HashMap<>(); + violationDetails.put("attr1", 1); + violationDetails.put("attr2", 2); + + ValidationResult validationResult = getValidationResult(violationDetails); + ValidationResult vr = toAndFromJson(validationResult); + + // Check + assertThatValidationResultIsValid(vr); + Violation v = assertThatViolationIsValid(vr, validationResult.getViolations().get(0)); + assertThat(v.getViolationDetails().get("attr1"), is(1.0)); + assertThat(v.getViolationDetails().get("attr2"), is(2.0)); + } + + @Test + public void testValidationResultWithViolationDetailsAsObject() throws Exception { + // Violation details + JsonArray jsonArray = new JsonArray(); + jsonArray.add("v1"); + JsonObject jsonObject = new JsonObject(); + jsonObject.add("p1", jsonArray); + jsonObject.add("p2", jsonArray); + Map<String, Object> violationDetails = new HashMap<>(); + violationDetails.put("attr1", jsonObject); + + ValidationResult validationResult = getValidationResult(violationDetails); + ValidationResult transformedVr = toAndFromJson(validationResult); + + // Check + assertThatValidationResultIsValid(transformedVr); + Violation v = assertThatViolationIsValid(transformedVr, validationResult.getViolations().get(0)); + String jsonDetails = v.getViolationDetails().get("attr1").toString(); + JsonParser jsonParser = new JsonParser(); + JsonElement jsonElement = jsonParser.parse(jsonDetails); + assertThat(jsonObject, is(jsonElement)); + } + + @Test + public void testCompareObjects() throws Exception { + ValidationResult validationResult = new ValidationResult(entity); + assertThat(validationResult, is(not(equalTo(null)))); + + validationResult.setEntityId(new JsonObject()); + assertThat(validationResult, is(not(equalTo(null)))); + + ValidationResult other = new ValidationResult(entity); + assertThat(validationResult, is(not(equalTo(other)))); + + validationResult.setEntityType("type"); + assertThat(validationResult, is(not(equalTo(other)))); + + Map<String, Object> violationDetails = new HashMap<>(); + + //@formatter:off + Violation violation = new Violation.Builder(entity) + .category("category") + .severity("severity") + .violationType("violationType") + .violationDetails(violationDetails) + .errorMessage("errorMessage") + .build(); + //@formatter:on + + validationResult.addViolation(violation); + assertThat(validationResult, is(not(equalTo(other)))); + + // Force call to hashCode() + assertThat(validationResult.hashCode(), is(not(equalTo(other.hashCode())))); + + } + + /** + * Tests for comparing two Violation objects. The generated Violation ID must be deterministic. + * + * @throws Exception + */ + @Test + public void testCompareViolationObjects() throws Exception { + // Use the standard vserver event + Builder builder = new Violation.Builder(entity); + + // Force call to toString() for coverage only + assertThat(builder.toString(), is(equalTo(new Violation.Builder(entity).toString()))); + + // Build a blank violation + Violation violation = builder.build(); + + // Identity tests + assertThat(violation, is(not(equalTo(null)))); + assertThat(violation, is(not(equalTo(1)))); + assertThat(violation, is(equalTo(violation))); + + // Ensure that any violations we build are identical + testViolationIdsForEquality(builder, builder, true); + + // Create a copy of the vserver event and vary the resourceVersion + Entity entity2 = eventReader + .getEntity(vserverEvent.replaceFirst("resource-version\": \"1464193654", "resource-version\": \"123")); + + // The violationId produced for identically built violations is the same for each builder (although the vserver + // events differ). + testViolationIdsForEquality(new Violation.Builder(entity), new Violation.Builder(entity2), true); + + // The violationId produced must differ whenever the violation values differ. + testViolationIdsForInequality(new Violation.Builder(entity), new Violation.Builder(entity2)); + + // Make a new variant of the vserver event using a different entity Id + Entity entity3 = eventReader.getEntity( + vserverEvent.replaceFirst("vserver-id\": \"example-vserver-id-val-34666", "vserver-id\": \"123")); + + // The violationId produced for identically built violations is now different for each builder (because the + // entity Ids differ). + testViolationIdsForEquality(new Violation.Builder(entity), new Violation.Builder(entity3), false); + } + + /** + * Generate various violations using the supplied builders and assert the expected equality of the generated + * Violation IDs whenever the values supplied to the builders are the same. + * + * @param b1 a builder + * @param b2 another builder + * @param expectedResult whether or not the two builders should produce identical violations + * @throws ValidationServiceException + */ + private void testViolationIdsForEquality(Builder b1, Builder b2, Boolean expectedResult) + throws ValidationServiceException { + Violation v1 = b1.build(); + Violation v2 = b2.build(); + assertThatViolationsAreEqual(v1, v2, expectedResult); + + // Use the same category + String category = "INVALID OBJ"; + v1 = b1.category(category).build(); + v2 = b2.category(category).build(); + assertThatViolationsAreEqual(v1, v2, expectedResult); + + // Use the same severity + String severity = "CRITICAL"; + v1 = b1.severity(severity).build(); + v2 = b2.severity(severity).build(); + assertThatViolationsAreEqual(v1, v2, expectedResult); + + // Use the same violation type + v1 = b1.violationType(ViolationType.RULE).build(); + v2 = b2.violationType(ViolationType.RULE).build(); + assertThatViolationsAreEqual(v1, v2, expectedResult); + + // Use the same validation rule + String rule = "prov-status"; + v1 = b1.validationRule(rule).build(); + v2 = b2.validationRule(rule).build(); + assertThatViolationsAreEqual(v1, v2, expectedResult); + + // Use the same error message + String errorMessage = "Invalid prov-status value. Must have a value not equal to ACTIVE/active."; + v1 = b1.errorMessage(errorMessage).build(); + v2 = b2.errorMessage(errorMessage).build(); + assertThatViolationsAreEqual(v1, v2, expectedResult); + + // Use the same violation details + Map<String, Object> details = new HashMap<>(); + details.put(rule, "ACTIVE"); + v1 = b1.violationDetails(details).build(); + v2 = b2.violationDetails(details).build(); + assertThatViolationsAreEqual(v1, v2, expectedResult); + } + + /** + * Generate violations using the supplied builders and assert that the generated Violation IDs differ whenever the + * values supplied to the builders differ. + * + * @param builder + * @param builder2 + * @throws ValidationServiceException + */ + private void testViolationIdsForInequality(Builder builder, Builder builder2) throws ValidationServiceException { + Violation violation; + Violation other; + + // Vary the violation type + violation = builder.violationType("").build(); + other = builder2.violationType(ViolationType.RULE).build(); + assertThatViolationIdsDiffer(violation, other); + + violation = builder.violationType(ViolationType.NONE).build(); + other = builder2.violationType(ViolationType.RULE).build(); + assertThatViolationIdsDiffer(violation, other); + + // Vary the validation rule + violation = builder.validationRule(null).build(); + other = builder2.validationRule("rule").build(); + assertThatViolationIdsDiffer(violation, other); + + violation = builder.validationRule("rule1").build(); + other = builder2.validationRule(null).build(); + assertThatViolationIdsDiffer(violation, other); + + violation = builder.validationRule("rule1").build(); + other = builder2.validationRule("rule2").build(); + assertThatViolationIdsDiffer(violation, other); + + // Vary the category + violation = builder.category(null).build(); + other = builder2.category("category").build(); + assertThatViolationIdsDiffer(violation, other); + + violation = builder.category("category").build(); + other = builder2.category(null).build(); + assertThatViolationIdsDiffer(violation, other); + + violation = builder.category("category1").build(); + other = builder2.category("category2").build(); + assertThatViolationIdsDiffer(violation, other); + + // Vary the error message + violation = builder.validationRule("rule").build(); + other = builder2.validationRule("rule").errorMessage("message2").build(); + assertThatViolationIdsDiffer(violation, other); + + violation = builder.validationRule("rule").errorMessage("message1").build(); + other = builder2.validationRule("rule").errorMessage("message2").build(); + assertThatViolationIdsDiffer(violation, other); + + // Vary the severity + violation = builder.errorMessage("msg").build(); + other = builder2.errorMessage("msg").severity("sev2").build(); + assertThatViolationIdsDiffer(violation, other); + + violation = builder.errorMessage("msg").severity("sev1").build(); + other = builder2.errorMessage("msg").severity("sev2").build(); + assertThatViolationIdsDiffer(violation, other); + } + + private ValidationResult getValidationResult(Map<String, Object> violationDetails) + throws ValidationServiceException { + ValidationResult validationResult = new ValidationResult(entity); + + //@formatter:off + Violation violation = new Violation.Builder(entity) + .category("category") + .severity("severity") + .violationType("violationType") + .violationDetails(violationDetails) + .errorMessage("errorMessage") + .build(); + //@formatter:on + + validationResult.addViolation(violation); + + return validationResult; + } + + private ValidationResult toAndFromJson(ValidationResult validationResult) { + return JsonUtil.toAnnotatedClassfromJson(validationResult.toJson(), ValidationResult.class); + } + + private void assertThatValidationResultIsValid(ValidationResult vr) { + assertTrue("Expected valid UUID", isValidEventId(vr.getValidationId())); + assertIsValidTimestamp(vr.getValidationTimestamp()); + JsonObject expectedEntityId = new JsonObject(); + expectedEntityId.addProperty("vserver-id", "example-vserver-id-val-34666"); + assertThat(vr.getEntityId(), is(expectedEntityId)); + assertThat(vr.getEntityType(), is("vserver")); + assertThat(vr.getResourceVersion(), is("1464193654")); + assertThat(vr.getEntityLink(), is( + "cloud-infrastructure/cloud-regions/cloud-region/region1/AAIregion1/tenants/tenant/example-tenant-id-val-88551/vservers/vserver/example-vserver-id-val-34666")); + } + + private Violation assertThatViolationIsValid(ValidationResult vr, Violation expectedViolation) { + Violation v = vr.getViolations().get(0); + assertThat(v.getViolationId(), is(expectedViolation.getViolationId())); + assertThat(v.getCategory(), is("category")); + assertThat(v.getSeverity(), is("severity")); + assertThat(v.getViolationType(), is("violationType")); + assertThat(v.getErrorMessage(), is("errorMessage")); + return v; + } + + private void assertThatViolationsAreEqual(Violation v1, Violation v2, Boolean expectedResult) { + assertThat("Violation equality in error:\n" + v1 + " equals " + v2, v1.equals(v2), is(expectedResult)); + assertThat("Violation ID equality in error:\n" + v1.getViolationId() + " equals " + v2.getViolationId(), + v1.getViolationId().equals(v2.getViolationId()), is(expectedResult)); + // Force a call to toString() for code coverage only + assertThat(v1.toString().equals(v2.toString()), is(equalTo(expectedResult))); + } + + private void assertThatViolationIdsDiffer(Violation violation, Violation other) { + assertThat(violation.getViolationId(), is(not(equalTo(other.getViolationId())))); + assertThat(violation, is(not(equalTo(other)))); + } + + private boolean isValidEventId(String eventId) { + try { + UUID.fromString(eventId); + } catch (IllegalArgumentException exception) { + return false; + } + return true; + } + + private void assertIsValidTimestamp(String date) { + DateTimeFormatter f = DateTimeFormatter.ofPattern("yyyyMMdd'T'HHmmssX").withZone(ZoneOffset.UTC); + Instant.from(f.parse(date)); + } +} diff --git a/src/test/java/org/onap/aai/validation/ruledriven/configuration/ConfigFileBuilder.java b/src/test/java/org/onap/aai/validation/ruledriven/configuration/ConfigFileBuilder.java new file mode 100644 index 0000000..1f87ca0 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/ruledriven/configuration/ConfigFileBuilder.java @@ -0,0 +1,104 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.ruledriven.configuration; + +import java.io.BufferedWriter; +import java.io.File; +import java.io.FileWriter; +import java.io.IOException; +import java.util.List; +import java.util.Properties; +import org.junit.rules.TemporaryFolder; +import org.onap.aai.cl.api.Logger; +import org.onap.aai.validation.logging.LogHelper; +import org.onap.aai.validation.ruledriven.configuration.EntitySection; +import org.onap.aai.validation.ruledriven.configuration.RulesConfigurationLoader; +import org.onap.aai.validation.ruledriven.configuration.build.ContentBuilder; +import org.onap.aai.validation.ruledriven.configuration.build.EntityBuilder; +import org.onap.aai.validation.ruledriven.configuration.build.RuleBuilder; + +public class ConfigFileBuilder extends ContentBuilder { + + private static final Logger logger = LogHelper.INSTANCE; + + private static final String TMP_CONFIG_FILE = "config.txt"; + private TemporaryFolder testFolder; + private File tempFile; + + public ConfigFileBuilder(TemporaryFolder testFolder) { + super(); + this.testFolder = testFolder; + } + + @Override + public String toString() { + StringBuilder sb = new StringBuilder(); + sb.append("ConfigBuilder [").append(testFolder.getRoot().getAbsolutePath()).append(System.lineSeparator()); + for (ContentBuilder item : items) { + sb.append(item).append(System.lineSeparator()); + } + sb.append(System.lineSeparator()).append("]"); + return sb.toString(); + } + + public EntityBuilder entity() { + EntityBuilder item = new EntityBuilder(); + addContent(item); + return item; + } + + public RuleBuilder rule() { + RuleBuilder item = new RuleBuilder(); + addContent(item); + return item; + } + + public void entity(Properties props) { + EntityBuilder entity = entity(); + entity.appendProperties(props); + } + + public RuleBuilder rule(String name) { + RuleBuilder rule = rule(); + rule.appendValue("name", name); + return rule; + } + + public List<EntitySection> loadConfiguration() throws IOException { + logger.debug("Configuration file: " + build()); + return buildConfiguration(build()); + } + + private List<EntitySection> buildConfiguration(String text) throws IOException { + tempFile = createConfigFile(text); + return RulesConfigurationLoader.loadConfiguration(tempFile).getEntities(); + } + + private File createConfigFile(String configText) throws IOException { + tempFile = testFolder.newFile(TMP_CONFIG_FILE); + BufferedWriter bw = new BufferedWriter(new FileWriter(tempFile)); + bw.write(configText); + bw.close(); + return tempFile; + } + + public void freeResources() { + tempFile.delete(); + } + +} diff --git a/src/test/java/org/onap/aai/validation/ruledriven/configuration/ConfigurationExceptionMatcher.java b/src/test/java/org/onap/aai/validation/ruledriven/configuration/ConfigurationExceptionMatcher.java new file mode 100644 index 0000000..f32c5d3 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/ruledriven/configuration/ConfigurationExceptionMatcher.java @@ -0,0 +1,73 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.ruledriven.configuration; + +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.hamcrest.TypeSafeMatcher; +import org.onap.aai.validation.ruledriven.configuration.GroovyConfigurationException; + +public class ConfigurationExceptionMatcher { + public static Matcher<GroovyConfigurationException> hasInvalidToken(final String expectedToken) { + return new TypeSafeMatcher<GroovyConfigurationException>() { + private String foundToken; + + @Override + public void describeTo(Description description) { + description.appendText("result from getInvalidToken() equals \"").appendText(expectedToken) + .appendText("\""); + } + + @Override + public void describeMismatchSafely(final GroovyConfigurationException exception, + final Description mismatchDescription) { + mismatchDescription.appendText("was ").appendValue(foundToken); + } + + @Override + protected boolean matchesSafely(GroovyConfigurationException exception) { + foundToken = exception.getInvalidToken(); + return foundToken != null && foundToken.equalsIgnoreCase(expectedToken); + } + }; + } + + public static Matcher<GroovyConfigurationException> configTextContains(final String expectedConfigText) { + return new TypeSafeMatcher<GroovyConfigurationException>() { + private String foundConfigText; + + @Override + public void describeTo(Description description) { + description.appendText("result from getConfigText() containing \"").appendText(expectedConfigText) + .appendText("\""); + } + + @Override + public void describeMismatchSafely(final GroovyConfigurationException exception, + final Description mismatchDescription) { + mismatchDescription.appendText("was ").appendValue(foundConfigText); + } + + @Override + protected boolean matchesSafely(GroovyConfigurationException exception) { + foundConfigText = exception.getConfigText(); + return foundConfigText != null && foundConfigText.contains(expectedConfigText); + } + }; + } +} diff --git a/src/test/java/org/onap/aai/validation/ruledriven/configuration/TestConfigFileBuilder.java b/src/test/java/org/onap/aai/validation/ruledriven/configuration/TestConfigFileBuilder.java new file mode 100644 index 0000000..6d56fa8 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/ruledriven/configuration/TestConfigFileBuilder.java @@ -0,0 +1,59 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.ruledriven.configuration; + +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.TemporaryFolder; +import org.onap.aai.validation.ruledriven.configuration.build.EntityBuilder; + +/** + * These tests are required to ensure code coverage by unit testing + * + */ +public class TestConfigFileBuilder { + + static { + System.setProperty("APP_HOME", "."); + } + + @Rule + public TemporaryFolder testFolder = new TemporaryFolder(); + + /** + * Validate that a content builder accepts a numeric value + * + * @throws Exception + */ + @Test + public void testNumberItem() throws Exception { + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + EntityBuilder ab = new EntityBuilder(); + ab.appendValue("dummy", 3); + ab.appendValue("dummy2", 5L); + builder.addContent(ab); + builder.toString(); + } + + @Test + public void testToString() throws Exception { + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + builder.addContent(new EntityBuilder()); + builder.toString(); + } +} diff --git a/src/test/java/org/onap/aai/validation/ruledriven/configuration/TestRulesConfigurationReader.java b/src/test/java/org/onap/aai/validation/ruledriven/configuration/TestRulesConfigurationReader.java new file mode 100644 index 0000000..c0f9f48 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/ruledriven/configuration/TestRulesConfigurationReader.java @@ -0,0 +1,448 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.ruledriven.configuration; + +import static org.hamcrest.CoreMatchers.containsString; +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.Iterator; +import java.util.List; +import java.util.Properties; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.junit.rules.TemporaryFolder; +import org.onap.aai.validation.ruledriven.configuration.EntitySection; +import org.onap.aai.validation.ruledriven.configuration.GroovyConfigurationException; +import org.onap.aai.validation.ruledriven.configuration.RuleSection; +import org.onap.aai.validation.ruledriven.configuration.SettingsSection; +import org.onap.aai.validation.ruledriven.configuration.build.EntityBuilder; +import org.onap.aai.validation.ruledriven.configuration.build.RuleBuilder; +import org.onap.aai.validation.ruledriven.configuration.build.ValidationBuilder; +import org.onap.aai.validation.test.util.RandomString; + +/** + * Tests for the Groovy classes that read and parse the rules configuration + * + */ +public class TestRulesConfigurationReader { + + static { + System.setProperty("APP_HOME", "."); + } + + @Rule + public TemporaryFolder testFolder = new TemporaryFolder(); + + /** + * Exception expected by Junit. This is modified per test. + */ + @Rule + public final ExpectedException exception = ExpectedException.none(); + + private static final String INVALID_TOKEN = "audif"; + + @Test + public void testEmptyConfiguration() throws Exception { + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + Collection<EntitySection> entitys = builder.loadConfiguration(); + assertThat(entitys.size(), is(0)); + } + + /** + * Test for reporting of an unknown token with various syntax formatting + * + * @throws Exception + */ + @Test + public void testInvalidTopLevelItem() throws Exception { + testInvalidToken(INVALID_TOKEN); + testInvalidToken(INVALID_TOKEN + " { }"); + testInvalidToken("{ " + INVALID_TOKEN + " }"); + testInvalidToken(INVALID_TOKEN + " { "); + testInvalidToken(INVALID_TOKEN + " } "); + testInvalidToken("{} " + INVALID_TOKEN); + testInvalidToken("\"" + INVALID_TOKEN); + } + + @Test + public void testInvalidentityItem1() throws Exception { + testInvalidToken("entity { invalid }", "invalid"); + } + + @Test + public void testInvalidentityItem2() throws Exception { + testInvalidToken("entity { invalid item }", "item"); + } + + @Test + public void testInvalidentityItem3() throws Exception { + testInvalidToken("entity { name name\n fred fred}", "name"); + } + + @Test + public void testInvalidQuery() throws Exception { + testInvalidToken("entity { name 'name'\n joe}", "joe"); + } + + @Test + public void testGenericRuleWithZeroAttributes() throws Exception { + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + EntityBuilder entity = builder.entity(); + entity.appendValue("name", "entity"); + ValidationBuilder validation = entity.validation(buildProperties("type")); + validation.useRule("ruleZ"); + builder.rule("ruleZ"); + + exception.expect(GroovyConfigurationException.class); + exception.expectMessage(containsString("attributes")); + builder.loadConfiguration(); + } + + @Test + public void testInvalidUseRule() throws Exception { + testInvalidToken("entity { validation { useRule { foo } } }", "foo"); + } + + @Test + public void testMissingRule() throws Exception { + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + builder.entity().validation().useRule("missingRule"); + exception.expect(GroovyConfigurationException.class); + exception.expectMessage(containsString("missingRule")); + builder.loadConfiguration(); + } + + @Test + public void testDuplicateRule() throws Exception { + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + builder.rule("duplicateRule"); + builder.rule("duplicateRule"); + exception.expect(GroovyConfigurationException.class); + exception.expectMessage(containsString("duplicateRule")); + builder.loadConfiguration(); + } + + @Test + public void testSimpleentity() throws Exception { + String name = RandomString.generate(); + + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + Properties entity = new Properties(); + entity.put("name", name); + builder.entity(entity); + + List<EntitySection> entities = builder.loadConfiguration(); + + assertThat(entities.size(), is(1)); + EntitySection entityConf = entities.get(0); + assertThat(entityConf.getName(), is(equalTo(name))); + } + + /** + * The Settings section is not tested elsewhere + * + * @throws Exception + */ + @Test + public void testGlobalSettings() throws Exception { + SettingsSection settings = new SettingsSection(); + settings.toString(); + } + + @Test + public void testentityWithRuleUsingStrings() throws Exception { + String name = RandomString.generate(); + String description = RandomString.generate(); + String severity = RandomString.generate(); + List<String> attributes = Arrays.asList(RandomString.generate()); + String validate = randomValidationExpression(); + + Properties rule = new Properties(); + rule.put("name", name); + rule.put("description", description); + rule.put("severity", severity); + rule.put("attributes", attributes); + rule.put("validate", validate); + + String type = RandomString.generate(); + + Properties validation = new Properties(); + validation.put("type", type); + validation.put("rule", rule); + + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + Properties entity = new Properties(); + entity.put("validation", validation); + builder.entity(entity); + + List<EntitySection> entities = builder.loadConfiguration(); + + assertThat(entities.size(), is(1)); + EntitySection entityConf = entities.get(0); + Collection<RuleSection> rules = entityConf.getRules(); + assertThat(rules.size(), is(1)); + + RuleSection ruleConfig = rules.iterator().next(); + assertThat(ruleConfig.getName(), is(equalTo(name))); + assertThat(ruleConfig.getDescription(), is(equalTo(description))); + assertThat(ruleConfig.getSeverity(), is(equalTo(severity))); + assertThat(ruleConfig.getAttributes(), is(equalTo(attributes))); + assertThat(ruleConfig.getExpression(), is(equalTo(validate))); + assertThat(ruleConfig.getType(), is(equalTo(type))); + } + + @Test + public void testentityWithRuleUsingBuilder() throws Exception { + String name = RandomString.generate(); + String description = RandomString.generate(); + String severity = RandomString.generate(); + List<String> attributes = Arrays.asList(RandomString.generate()); + String validate = randomValidationExpression(); + String type = RandomString.generate(); + + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + ValidationBuilder validation = builder.entity().validation(); + validation.appendValue("type", type); + + RuleBuilder rule = validation.rule(name); + rule.appendValue("description", description); + rule.appendValue("severity", severity); + rule.appendValue("attributes", attributes); + rule.appendValue("validate", validate); + + List<EntitySection> entitys = builder.loadConfiguration(); + + assertThat(entitys.size(), is(1)); + EntitySection entityConf = entitys.get(0); + Collection<RuleSection> rules = entityConf.getRules(); + assertThat(rules.size(), is(1)); + + RuleSection ruleConfig = rules.iterator().next(); + assertThat(ruleConfig.getName(), is(equalTo(name))); + assertThat(ruleConfig.getDescription(), is(equalTo(description))); + assertThat(ruleConfig.getSeverity(), is(equalTo(severity))); + assertThat(ruleConfig.getAttributes(), is(equalTo(attributes))); + assertThat(ruleConfig.getExpression(), is(equalTo(validate))); + assertThat(ruleConfig.getType(), is(equalTo(type))); + } + + @Test + public void testentityWithEmbeddedRule() throws Exception { + Properties rule = buildProperties("name", "description", "severity", "validate"); + rule.put("attributes", Arrays.asList(RandomString.generate())); + + Properties validation = buildProperties("type"); + validation.put("rule", rule); + + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + Properties entity = new Properties(); + entity.put("validation", validation); + builder.entity(entity); + + List<EntitySection> entitys = builder.loadConfiguration(); + + assertThat(entitys.size(), is(1)); + EntitySection entityConf = entitys.get(0); + Collection<RuleSection> rules = entityConf.getRules(); + assertThat(rules.size(), is(1)); + + RuleSection ruleConfig = rules.iterator().next(); + assertThatConfigMatchesProperties(ruleConfig, rule, validation); + } + + @Test + public void testEmbeddedRuleUsingString() throws Exception { + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + builder.appendLine("entity {"); + builder.appendLine(" type 'newvce'"); + builder.appendLine(" validation {"); + builder.appendLine(" rule {"); + builder.appendLine(" name 'vnfName'"); + builder.appendLine( + " description 'Validate that the vnf-name attribute matches the expected string format'"); + builder.appendLine(" severity 'MAJOR'"); + builder.appendLine(" attributes 'vnf-name'"); + builder.appendLine(" validate 'vnf-name.matchesPattern(xxxxnnnvbc)'"); + builder.appendLine(" }"); + builder.appendLine(" }"); + builder.appendLine("}"); + List<EntitySection> entitys = builder.loadConfiguration(); + + assertThat(entitys.size(), is(1)); + EntitySection entityConf = entitys.get(0); + assertThat(entityConf.getName(), is(equalTo("newvce"))); + + Collection<RuleSection> rules = entityConf.getRules(); + assertThat(rules.size(), is(1)); + RuleSection ruleConfig = rules.iterator().next(); + + assertThat(ruleConfig.getType(), is(equalTo("newvce"))); + assertThat(ruleConfig.getName(), is(equalTo("vnfName"))); + assertThat(ruleConfig.getDescription(), + is(equalTo("Validate that the vnf-name attribute matches the expected string format"))); + assertThat(ruleConfig.getSeverity(), is(equalTo("MAJOR"))); + List<String> expectedList = new ArrayList<String>(); + expectedList.add("vnf-name"); + assertThat(ruleConfig.getAttributes(), is(equalTo(expectedList))); + assertThat(ruleConfig.getExpression(), is(equalTo("vnf-name.matchesPattern(xxxxnnnvbc)"))); + } + + @Test + public void testGenericRuleUsingStrings() throws Exception { + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + builder.appendLine("entity {"); + builder.appendLine(" type 'newvce'"); + builder.appendLine(" validation {"); + builder.appendLine(" useRule {"); + builder.appendLine(" name 'genericRule'"); + builder.appendLine(" attributes 'clli'"); + builder.appendLine(" }"); + builder.appendLine(" }"); + builder.appendLine("}"); + builder.appendLine("rule {"); + builder.appendLine(" name 'genericRule'"); + builder.appendLine(" description 'The field (attribute) must be less than 50 characters in length'"); + builder.appendLine(" severity 'MINOR'"); + builder.appendLine(" validate 'attribute.size() < 50'"); + builder.appendLine("}"); + + List<EntitySection> entitys = builder.loadConfiguration(); + assertThat(entitys.size(), is(1)); + EntitySection entityConf = entitys.get(0); + assertThat(entityConf.getName(), is(equalTo("newvce"))); + + Collection<RuleSection> rules = entityConf.getRules(); + assertThat("Number of rules", rules.size(), is(1)); + RuleSection ruleConfig = rules.iterator().next(); + + assertThat(ruleConfig.getType(), is(equalTo("newvce"))); + assertThat(ruleConfig.getName(), is(equalTo("genericRule"))); + assertThat(ruleConfig.getDescription(), + is(equalTo("The field (attribute) must be less than 50 characters in length"))); + assertThat(ruleConfig.getSeverity(), is(equalTo("MINOR"))); + List<String> expectedList = new ArrayList<String>(); + expectedList.add("clli"); + assertThat(ruleConfig.getAttributes(), is(equalTo(expectedList))); + assertThat(ruleConfig.getExpression(), is(equalTo("attribute.size() < 50"))); + } + + @Test + public void testMultipleGenericRules() throws Exception { + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + EntityBuilder entity = builder.entity(); + ValidationBuilder validation = entity.validation(buildProperties("type")); + validation.useRule("rule1"); + validation.useRule("rule2").appendValue("attributes", "attr"); + builder.rule("rule1").appendValue("attributes", "field").appendValue("validate", "true"); + builder.rule("rule2").appendValue("validate", "true"); + + List<EntitySection> entitys = builder.loadConfiguration(); + + assertThat(entitys.size(), is(1)); + EntitySection entityConf = entitys.get(0); + Collection<RuleSection> rules = entityConf.getRules(); + assertThat(rules.size(), is(2)); + + Iterator<RuleSection> iterator = rules.iterator(); + RuleSection ruleConfig = iterator.next(); + assertThat(ruleConfig.getName(), is(equalTo("rule1"))); + assertThat(ruleConfig.getAttributes(), is(Collections.singletonList("field"))); + + ruleConfig = iterator.next(); + assertThat(ruleConfig.getName(), is(equalTo("rule2"))); + assertThat(ruleConfig.getAttributes(), is(Collections.singletonList("attr"))); + } + + @Test + public void testGenericRuleWithMultipleAttributes() throws Exception { + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + EntityBuilder entity = builder.entity(); + ValidationBuilder validation = entity.validation(buildProperties("type")); + validation.useRule("rule").appendValue("attributes", Arrays.asList("attr1", "attr2")); + builder.rule("rule").appendValue("attributes", Arrays.asList("field1", "field2")).appendValue("validate", + "true"); + + List<EntitySection> entities = builder.loadConfiguration(); + + assertThat(entities.size(), is(1)); + EntitySection entityConf = entities.get(0); + Collection<RuleSection> rules = entityConf.getRules(); + assertThat(rules.size(), is(1)); + + Iterator<RuleSection> iterator = rules.iterator(); + RuleSection ruleConfig = iterator.next(); + assertThat(ruleConfig.getName(), is(equalTo("rule"))); + assertThat(ruleConfig.getAttributes(), is(Arrays.asList("attr1", "attr2"))); + } + + private String randomValidationExpression() { + String validate = RandomString.generate(); + while (validate.matches("^\\d+[a-fA-F]+\\D+.*") || validate.matches("0x\\D+.*")) { + validate = RandomString.generate(); + } + return validate; + } + + private void testInvalidToken(String configText) throws IOException { + testInvalidToken(configText, INVALID_TOKEN); + } + + private void testInvalidToken(String configText, String invalidToken) throws IOException { + ConfigFileBuilder builder = new ConfigFileBuilder(testFolder); + builder.addContent(configText); + assertConfigurationException(invalidToken); + builder.loadConfiguration(); + } + + private void assertConfigurationException(String invalidToken) { + exception.expect(GroovyConfigurationException.class); + exception.expectMessage(containsString(invalidToken)); + exception.expect(ConfigurationExceptionMatcher.hasInvalidToken(invalidToken)); + exception.expect(ConfigurationExceptionMatcher.configTextContains(invalidToken)); + } + + private Properties buildProperties(String... strings) { + Properties props = new Properties(); + for (String str : strings) { + props.put(str, randomValidationExpression()); + } + return props; + } + + private void assertThatConfigMatchesProperties(RuleSection ruleConfig, Properties rule, Properties validation) { + assertMatch(ruleConfig.getName(), rule, "name"); + assertMatch(ruleConfig.getDescription(), rule, "description"); + assertMatch(ruleConfig.getSeverity(), rule, "severity"); + assertThat(ruleConfig.getAttributes(), is(equalTo(rule.get("attributes")))); + assertMatch(ruleConfig.getExpression(), rule, "validate"); + assertMatch(ruleConfig.getType(), validation, "type"); + assertMatch(ruleConfig.getObjectId(), validation, "objectId"); + } + + private void assertMatch(String value, Properties props, String key) { + assertThat(value, is(equalTo(props.getProperty(key)))); + } +} diff --git a/src/test/java/org/onap/aai/validation/ruledriven/mock/TestDefaultRules.java b/src/test/java/org/onap/aai/validation/ruledriven/mock/TestDefaultRules.java new file mode 100644 index 0000000..c3b36ed --- /dev/null +++ b/src/test/java/org/onap/aai/validation/ruledriven/mock/TestDefaultRules.java @@ -0,0 +1,148 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.ruledriven.mock; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; +import static org.mockito.Matchers.anyListOf; +import static org.mockito.Matchers.anyString; +import static org.mockito.Mockito.when; + +import com.google.gson.JsonObject; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collections; +import java.util.List; +import java.util.Optional; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.mockito.Mock; +import org.mockito.invocation.InvocationOnMock; +import org.mockito.runners.MockitoJUnitRunner; +import org.mockito.stubbing.Answer; +import org.onap.aai.validation.Validator; +import org.onap.aai.validation.exception.ValidationServiceException; +import org.onap.aai.validation.reader.EventReader; +import org.onap.aai.validation.reader.data.AttributeValues; +import org.onap.aai.validation.reader.data.Entity; +import org.onap.aai.validation.reader.data.EntityId; +import org.onap.aai.validation.result.ValidationResult; +import org.onap.aai.validation.result.Violation; +import org.onap.aai.validation.ruledriven.RuleDrivenValidator; + +/** + * Test that the rules present under bundleconfig/etc/rules/ can be loaded and evaluated (using a mocked event). + * + */ +@RunWith(MockitoJUnitRunner.class) +public class TestDefaultRules { + + static { + System.setProperty("APP_HOME", "."); + } + + enum TestCase { + NULL, + VSERVER; + } + + // Data returned by the mocked EventReader + enum TestData { + // @formatter:off + ENTITTY_DATA ("vserver dummy json data"), + ENTITTY_TYPE ("vserver"), + RESOURCE_VERSION_VALUE("1476735182"), + VSERVER_ID_KEY ("vserver-id"), + VSERVER_ID_VALUE ("13b629a4-87ae-492d-943f-acb8f3d9c3d9"); + // @formatter:on + + private String value; + + TestData(String value) { + this.value = value; + } + } + + @Mock + private EventReader eventReader; + + @Mock + private Entity entity; + + private Validator ruleDrivenValidator; + + @Before + public void createMockEventReader() throws ValidationServiceException { + when(eventReader.getEventType(TestCase.VSERVER.name())).thenReturn(Optional.of("aai-event")); + when(eventReader.getEventType(TestCase.NULL.name())).thenReturn(null); + + when(eventReader.getEntityType(anyString())).thenReturn(Optional.of(TestData.ENTITTY_TYPE.value)); + when(eventReader.getEntity(anyString())).thenReturn(entity); + + // Mocked entity returned by the event reader + when(entity.getType()).thenReturn(TestData.ENTITTY_TYPE.value); + when(entity.getResourceVersion()).thenReturn(Optional.of(TestData.RESOURCE_VERSION_VALUE.value)); + + EntityId entityId = new EntityId(TestData.VSERVER_ID_KEY.value, TestData.VSERVER_ID_VALUE.value); + when(entity.getIds()).thenReturn(new ArrayList<>(Arrays.asList(entityId))); + + // Return dummy values for any requested attributes + when(entity.getAttributeValues(anyListOf(String.class))).thenAnswer(new Answer<AttributeValues>() { + @SuppressWarnings("unchecked") + @Override + public AttributeValues answer(InvocationOnMock invocation) { + AttributeValues attributeValues = new AttributeValues(); + for (String attribute : (List<String>) invocation.getArguments()[0]) { + if (attribute.contains("[*]")) { + attributeValues.put(attribute, Collections.emptyList()); + } else { + attributeValues.put(attribute, ""); + } + } + return attributeValues; + } + }); + } + + @Before + public void createRuleDrivenValidator() throws ValidationServiceException { + Path configurationPath = Paths.get("bundleconfig/etc/rules"); + ruleDrivenValidator = new RuleDrivenValidator(configurationPath, null, eventReader, null); + } + + @Test + public void testExecuteRulesForVserver() throws Exception { + List<ValidationResult> results = ruleDrivenValidator.validate(TestCase.VSERVER.name()); + assertThat(results.size(), is(1)); + + ValidationResult validationResult = results.get(0); + assertThat(validationResult.getEntityType(), is(equalTo(TestData.ENTITTY_TYPE.value))); + JsonObject expectedEntityId = new JsonObject(); + expectedEntityId.addProperty(TestData.VSERVER_ID_KEY.value, TestData.VSERVER_ID_VALUE.value); + assertThat(validationResult.getEntityId(), is(equalTo(expectedEntityId))); + assertThat(validationResult.getViolations().size(), is(2)); + + Violation violation = validationResult.getViolations().get(0); + assertThat(violation.getCategory(), is(equalTo("MISSING_REL"))); + } + +} diff --git a/src/test/java/org/onap/aai/validation/ruledriven/rule/RuleHelper.java b/src/test/java/org/onap/aai/validation/ruledriven/rule/RuleHelper.java new file mode 100644 index 0000000..456d011 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/ruledriven/rule/RuleHelper.java @@ -0,0 +1,36 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.ruledriven.rule; + +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; + +import org.onap.aai.validation.reader.data.AttributeValues; +import org.onap.aai.validation.ruledriven.rule.Rule; + +public class RuleHelper { + + static void assertRuleResult(Rule rule, AttributeValues values, Boolean expectedResult) { + assertThat(rule + " failed for values [" + values + "]", rule.execute(values), is(equalTo(expectedResult))); + } + + static void assertRuleResult(Rule rule, Object value, Boolean expectedResult) { + assertThat(rule + " failed for value [" + value + "]", rule.execute(value), is(equalTo(expectedResult))); + } +} diff --git a/src/test/java/org/onap/aai/validation/ruledriven/rule/RuleTester.java b/src/test/java/org/onap/aai/validation/ruledriven/rule/RuleTester.java new file mode 100644 index 0000000..8593f93 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/ruledriven/rule/RuleTester.java @@ -0,0 +1,47 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.ruledriven.rule; + +import org.onap.aai.validation.reader.data.AttributeValues; +import org.onap.aai.validation.ruledriven.rule.Rule; + +/** + * Helper class for testing rules + * + */ +public class RuleTester { + + private Rule rule; + private AttributeValues attributeValues; + + /** + * @param trinityRule + * @param attributeValues + */ + public RuleTester(Rule trinityRule, AttributeValues attributeValues) { + this.rule = trinityRule; + this.attributeValues = attributeValues; + } + + /** + * @param expectedResult + */ + public void test(boolean expectedResult) { + RuleHelper.assertRuleResult(rule, attributeValues, expectedResult); + } +} diff --git a/src/test/java/org/onap/aai/validation/ruledriven/rule/TestConfigurationLoader.java b/src/test/java/org/onap/aai/validation/ruledriven/rule/TestConfigurationLoader.java new file mode 100644 index 0000000..f226252 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/ruledriven/rule/TestConfigurationLoader.java @@ -0,0 +1,190 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.ruledriven.rule; + +import com.google.gson.JsonArray; +import com.google.gson.JsonElement; +import com.google.gson.JsonObject; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.util.LinkedHashSet; +import java.util.Set; +import javax.inject.Inject; +import org.junit.Test; +import org.onap.aai.validation.reader.OxmReader; +import org.onap.aai.validation.reader.data.AttributeValues; +import org.onap.aai.validation.ruledriven.RuleDrivenValidator; +import org.onap.aai.validation.ruledriven.rule.Rule; + +public class TestConfigurationLoader { + + static { + System.setProperty("APP_HOME", "."); + } + + private enum AAIRelation { + RELATED_TO("related-to"), + PROPERTY_KEY("property-key"), + PROPERTY_VALUE("property-value"); + + private final String text; + + /** + * @param text + */ + private AAIRelation(final String text) { + this.text = text; + } + + /* + * (non-Javadoc) + * + * @see java.lang.Enum#toString() + */ + @Override + public String toString() { + return text; + } + } + + @Inject + private OxmReader oxmReader; + + /** + * If vserver is related to an image with image-name = 'TRINITY' then generic-vnf.vnf-name must match xxxxnnnnv + */ + @Test + public void testTrinityRule() throws Exception { + Path configurationPath = Paths.get("bundleconfig/etc/rules"); + + RuleDrivenValidator validator = new RuleDrivenValidator(configurationPath, oxmReader, null, null); + validator.initialise(); + + // Find the trinity rule + Rule trinityRule = null; + for (Rule rule : validator.getRulesForEntity("vserver", "aai-event")) { + if (rule.getName().contains("TRINITY") && rule.getName().contains("generic-vnf")) { + trinityRule = rule; + } + } + + // Create a set of relationship objects to be passed to the rule + Set<JsonObject> relationships = new LinkedHashSet<>(); + AttributeValues attributeValues = new AttributeValues(); + attributeValues.put("relationship-list.relationship[*]", relationships); + + // Test the rule against the relationships + RuleTester ruleTester = new RuleTester(trinityRule, attributeValues); + ruleTester.test(true); + + JsonObject genericVnfData = createRelationshipData(relationships, "generic-vnf"); + ruleTester.test(true); + + // Add a new object for the image relationship + JsonObject imageData = createRelationshipData(relationships, "image"); + ruleTester.test(true); + + createRelationshipData(relationships, "pserver"); + ruleTester.test(true); + + // Add a new JSON object for the image name + JsonObject imageNameProperty = createRelatedToProperty(imageData); + ruleTester.test(true); + + setPropertyKey(imageNameProperty, "image.image-name"); + ruleTester.test(true); + + setPropertyValue(imageNameProperty, "not TRINITY"); + ruleTester.test(true); + + setPropertyValue(imageNameProperty, "TRINITY"); + ruleTester.test(false); + + JsonObject vnfNameProperty = createRelatedToProperty(genericVnfData); + ruleTester.test(false); + + setPropertyKey(vnfNameProperty, "generic-vnf.vnf-name"); + ruleTester.test(false); + + setPropertyValue(vnfNameProperty, "invalid"); + ruleTester.test(false); + + setPropertyValue(vnfNameProperty, ""); + ruleTester.test(false); + + setPropertyValue(vnfNameProperty, "bmsx0001v"); + ruleTester.test(true); + + // Add another new object for a different image relationship + JsonObject image2Data = createRelationshipData(relationships, "image"); + ruleTester.test(true); + + JsonObject image2NameProperty = createRelatedToProperty(image2Data); + ruleTester.test(true); + + setPropertyKey(image2NameProperty, "image.image-name"); + ruleTester.test(true); + + setPropertyValue(image2NameProperty, "not TRINITY"); + ruleTester.test(true); + + setPropertyValue(vnfNameProperty, "invalid"); + ruleTester.test(false); + + setPropertyValue(imageNameProperty, "not TRINITY"); + ruleTester.test(true); + + setPropertyValue(image2NameProperty, "TRINITY"); + ruleTester.test(false); + + setPropertyValue(image2NameProperty, "also not TRINITY"); + ruleTester.test(true); + } + + /** + * @param relationshipData + * @return + */ + private JsonObject createRelatedToProperty(JsonObject relationshipData) { + JsonObject imageNameProperty = new JsonObject(); + JsonElement jsonArray = new JsonArray(); + jsonArray.getAsJsonArray().add(imageNameProperty); + relationshipData.add("related-to-property", jsonArray); + return imageNameProperty; + } + + /** + * @param relationships + * @param relatedObject + * @return + */ + private JsonObject createRelationshipData(Set<JsonObject> relationships, String relatedObject) { + JsonObject relationData = new JsonObject(); + relationData.addProperty(AAIRelation.RELATED_TO.toString(), relatedObject); + relationships.add(relationData); + return relationData; + } + + private void setPropertyKey(JsonObject objectMap, String propertyKeyName) { + objectMap.addProperty(AAIRelation.PROPERTY_KEY.toString(), propertyKeyName); + } + + private void setPropertyValue(JsonObject objectMap, String propertyValue) { + objectMap.addProperty(AAIRelation.PROPERTY_VALUE.toString(), propertyValue); + } +} diff --git a/src/test/java/org/onap/aai/validation/ruledriven/rule/TestRuleExecution.java b/src/test/java/org/onap/aai/validation/ruledriven/rule/TestRuleExecution.java new file mode 100644 index 0000000..15e958d --- /dev/null +++ b/src/test/java/org/onap/aai/validation/ruledriven/rule/TestRuleExecution.java @@ -0,0 +1,494 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.ruledriven.rule; + +import static org.hamcrest.CoreMatchers.containsString; + +import java.io.IOException; +import java.util.ArrayList; +import java.util.Arrays; +import java.util.Collection; +import java.util.Collections; +import java.util.HashMap; +import java.util.List; +import java.util.Map; +import java.util.Map.Entry; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.onap.aai.validation.reader.data.AttributeValues; +import org.onap.aai.validation.ruledriven.configuration.GroovyConfigurationException; +import org.onap.aai.validation.ruledriven.configuration.RuleSection; +import org.onap.aai.validation.ruledriven.rule.GroovyRule; + +/** + * Tests for creating an AuditRule object and then executing the rule expression against fixed attribute values + * + * @see GroovyRule + * + */ +public class TestRuleExecution { + + static { + System.setProperty("APP_HOME", "."); + } + + @Rule + public final ExpectedException exception = ExpectedException.none(); + + /** + * Simple example of a rule using a boolean expression, acting on a single attribute + * + * @throws Exception + */ + @Test + public void testRuleCreation() throws Exception { + // This object represents a rule + GroovyRule rule = buildRule("i", "i == 44"); + + // Success + assertRuleResult(rule, 44, true); + + // Failure + assertRuleResult(rule, 5, false); + } + + @Test + public void testRuleWithMultipleAttributes() throws Exception { + GroovyRule rule = buildRule(Arrays.asList("i", "j"), "i == 22 && j == 44"); + + // Success + assertRuleResult(rule, Arrays.asList(22, 44), true); + + // Failure + assertRuleResult(rule, Arrays.asList(5, 5), false); + assertRuleResult(rule, Arrays.asList(22, 5), false); + assertRuleResult(rule, Arrays.asList(5, 44), false); + } + + /** + * vserver is related to vpe and vserver-name contains me6 + */ + @Test + public void testConditionalRegExp() throws Exception { + // !related-to.contains("vpe") || vserver-name =~ "me6" + String expression = "!related-to.contains(\"vpe\") || vserver-name =~ \"me6\""; + List<String> attributes = Arrays.asList("related-to", "vserver-name"); + GroovyRule rule = buildRule(attributes, expression); + + // Create some tests, varying the values for each attribute + Collection<Collection<String>> relatedToTests = new ArrayList<>(); + Collection<Collection<String>> vserverNameTests = new ArrayList<>(); + + // These are the related-to values to test + relatedToTests.add(Collections.<String>emptyList()); + relatedToTests.add(Arrays.asList("vpe")); + relatedToTests.add(Arrays.asList("vpe", "vces")); + relatedToTests.add(Arrays.asList("vces")); + relatedToTests.add(Arrays.asList("other", "vces")); + + // These are the vserver-name values to test + Collection<String> testNames = new ArrayList<>(); + testNames.add("fred"); + testNames.add("me"); + testNames.add("me7"); + testNames.add("me6"); + testNames.add("123me6"); + testNames.add("me6789"); + testNames.add("123me6789"); + + // Additional test for no vserver-name values present + vserverNameTests.add(Collections.<String>emptyList()); + + for (String name : testNames) { + // Build single element lists containing the test vserver names + vserverNameTests.add(Arrays.asList(name)); + + // Also build multi-element lists containing the test vserver names + vserverNameTests.add(Arrays.asList(name, "6dummy")); + } + + // Now run the tests, computing the expected Boolean result each time + for (Collection<String> relatedToList : relatedToTests) { + // If no vpe is related, then the result will always be true + boolean expectedResult = !relatedToList.contains("vpe"); + + Map<String, Object> map = new HashMap<>(); + map.put("related-to", relatedToList); + + for (Collection<String> vserverNames : vserverNameTests) { + // Assign the strings to the attribute vserver-name + map.put("vserver-name", vserverNames); + + if (expectedResult == false) { + for (String name : vserverNames) { + if (name.contains("me6")) { + expectedResult = true; + break; + } + } + } + + testWithAttributeValue(rule, map, expectedResult); + } + } + } + + /** + * generic-vnf.vnf-type should be "BW NFM" and not "bnfm" + */ + @Test + public void testStringComparison() throws Exception { + String attribute = "generic-vnf.vnf-type"; + String expression = "vnf-type == 'BW NFM'"; + GroovyRule rule = buildRule(attribute, expression); + assertRuleResult(rule, "BW NFM", true); + assertRuleResult(rule, "bnfm", false); + assertRuleResult(rule, null, false); + assertRuleResult(rule, "", false); + assertRuleResult(rule, "fred", false); + assertRuleResult(rule, "bob", false); + assertRuleResult(rule, 5, false); + assertRuleResult(rule, 1000L, false); + } + + @Test + public void testNotEquals() throws Exception { + GroovyRule rule = buildRule("x", "x != 'foo'"); + assertRuleResult(rule, "", true); + assertRuleResult(rule, "bar", true); + assertRuleResult(rule, "foo", false); + assertRuleResult(rule, "foo\n", true); + assertRuleResult(rule, 5, true); + assertRuleResult(rule, 1000L, true); + assertRuleResult(rule, null, true); + } + + @Test + public void testGreaterThan() throws Exception { + Map<Object, Boolean> tests = new HashMap<>(); + tests.put(-1, false); + tests.put(0, false); + tests.put(1, false); + tests.put(4, false); + tests.put(5, true); + tests.put(55, true); + tests.put(null, false); + testRuleExpression("i", "i > 4", tests); + } + + @Test + public void testValidStringLength() throws Exception { + String attribute = "clli"; + String expression = "clli.size() == 8 || clli.size() == 11"; + Map<Object, Boolean> tests = new HashMap<>(); + tests.put("", false); + tests.put("X", false); + tests.put("1", false); + tests.put("1234", false); + tests.put("123456", false); + tests.put("1234567", false); + tests.put("12345678", true); + tests.put("123456789", false); + tests.put("1234567890", false); + tests.put("12345678901", true); + tests.put("1234567890ABC", false); + tests.put("1234567890123456789012345678901234567890", false); + testRuleExpression(attribute, expression, tests); + } + + /** + * location_clli is 8 or 11 characters and must be characters only + */ + @Test + public void testStringLengthAndChars() throws Exception { + String attribute = "location_clli"; + String expression = "location_clli != null && location_clli.matches('[a-zA-Z]{8,11}')"; + Map<Object, Boolean> tests = new HashMap<>(); + tests.put(null, false); + tests.put("", false); + tests.put("X", false); + tests.put("1234567", false); + tests.put("12345678", false); // 8 digits + tests.put("ABCDEFGH", true); // 8 chars + tests.put("1234567890A", false); // 11 mixed + tests.put("abcdefghijk", true); // 11 chars + tests.put("AbCdEfGhIjK", true); // 11 chars + tests.put("AbCdEfGhIj?", false); // special char + testRuleExpression(attribute, expression, tests); + } + + /** + * incorrect naming, e.g. expecting ae0.x (where x is unit/subinterface number), but receiving ae0.353.3303 + */ + @Test + public void testRegularExpression() throws Exception { + String attribute = "unit"; + String expression = "unit.matches('^ae0\\\\.(\\\\d)+')"; + Map<Object, Boolean> tests = new HashMap<>(); + tests.put("", false); + tests.put("X", false); + tests.put("ae0", false); + tests.put("ae0.", false); + tests.put("ae01", false); + tests.put("ae012", false); + tests.put("ae0.1", true); + tests.put("ae0.354", true); + tests.put("ae0.354.", false); + tests.put("ae0.353.3303", false); + tests.put("ae0.353.3303.1", false); + testRuleExpression(attribute, expression, tests); + } + + @Test + public void testNullStringLength() throws Exception { + String attribute = "clli"; + String expression = "clli.size() == 8 || clli.size() == 11"; + exception.expect(IllegalArgumentException.class); + exception.expectMessage(containsString("Argument")); + exception.expectMessage(containsString("null")); + GroovyRule rule = buildRule(attribute, expression); + rule.execute((Object[]) null); + } + + @Test + public void testStringLengthWithNull() throws Exception { + String attribute = "a"; + String expression = "a == null || a.size() > 4"; + Map<Object, Boolean> tests = new HashMap<>(); + tests.put("", false); + tests.put("X", false); + tests.put("1", false); + tests.put("1234", false); + tests.put("123456", true); + tests.put("1234567", true); + tests.put("12345678", true); + tests.put("123456789", true); + tests.put("1234567890", true); + tests.put("12345678901", true); + tests.put("1234567890ABC", true); + tests.put("1234567890123456789012345678901234567890", true); + testRuleExpression(attribute, expression, tests); + } + + /** + * Prov-status cannot be ACTIVE or NULL (empty) + */ + @Test + public void testStringTextWithNull() throws Exception { + String attribute = "prov-status"; + String expression = "prov-status != null && prov-status != 'ACTIVE'"; + Map<Object, Boolean> tests = new HashMap<>(); + tests.put(null, false); + tests.put("ACTIVE", false); + tests.put("", true); + tests.put("X", true); + tests.put("1", true); + tests.put("1234", true); + tests.put("123456", true); + tests.put("1234567", true); + tests.put("12345678", true); + tests.put("123456789", true); + tests.put("1234567890", true); + tests.put("12345678901", true); + tests.put("1234567890ABC", true); + tests.put("1234567890123456789012345678901234567890", true); + testRuleExpression(attribute, expression, tests); + } + + /** + * Prov-status cannot be ACTIVE/active or NULL/null or empty or missing + */ + @Test + public void testCaseInsensitveStringMatch() throws Exception { + String attribute = "prov-status"; + String expression = + "prov-status != null && prov-status.size() > 0 && !prov-status.equalsIgnoreCase('NULL') && !prov-status.equalsIgnoreCase('ACTIVE')"; + Map<Object, Boolean> tests = new HashMap<>(); + tests.put(null, false); + tests.put("", false); + tests.put("active", false); + tests.put("ACTIVE", false); + tests.put("null", false); + tests.put("NULL", false); + tests.put("NVTPROV", true); + tests.put("1", true); + tests.put("1234", true); + testRuleExpression(attribute, expression, tests); + } + + @Test + public void testUsingAttributeValuesObject() throws Exception { + List<String> attributes = Arrays.asList("attr1", "attr2"); + String expression = "attr1.size() == 8 || attr2.size() == 11"; + GroovyRule rule = buildRule(attributes, expression); + AttributeValues attributeValues = new AttributeValues("attr1", "other"); + attributeValues.put("attr2", "other"); + rule.execute(attributeValues); + } + + @Test + public void testMissingMethod() throws Exception { + String attribute = "clli"; + String expression = "clli.size() == 8 || clli.size() == 11"; + exception.expect(IllegalArgumentException.class); + exception.expectMessage(containsString("Integer")); + exception.expectMessage(containsString("size()")); + GroovyRule rule = buildRule(attribute, expression); + rule.execute(1); + } + + @Test + public void testMultipleAttributes() throws Exception { + List<String> attributes = Arrays.asList("clli", "other"); + String expression = "clli.size() == 8 || other.size() == 11"; + exception.expect(IllegalArgumentException.class); + exception.expectMessage(containsString("Integer")); + exception.expectMessage(containsString("size()")); + GroovyRule rule = buildRule(attributes, expression); + rule.execute(new Integer(1), new Integer(2)); + } + + /** + * Compare two attributes (using a sub-string match) + */ + @Test + public void testAttributeComparison() throws Exception { + String attribute1 = "heat-stack-id"; + String attribute2 = "vnf-name"; + + // Alternative forms of the expression + Collection<String> expressionsToTest = new ArrayList<>(); + expressionsToTest.add("heat-stack-id?.size() > 10 && heat-stack-id[0..10] == vnf-name"); + expressionsToTest.add("heat-stack-id?.size() > 10 && heat-stack-id.substring(0,11) == vnf-name"); + expressionsToTest.add("heat-stack-id?.size() > 10 && heat-stack-id.take(11) == vnf-name"); + + // Create some tests, varying the values for each attribute + Collection<String> heatStackIds = new ArrayList<>(); + Collection<String> vnfNames = new ArrayList<>(); + + heatStackIds.add("123me67890abcdef"); + heatStackIds.add("123me67890a"); + heatStackIds.add("fred"); + heatStackIds.add(""); + heatStackIds.add(null); + + vnfNames.add("123me67890abcdef"); + vnfNames.add("123me67890a"); + vnfNames.add("123me6789"); + vnfNames.add("fred"); + vnfNames.add("bob"); + vnfNames.add(""); + vnfNames.add(null); + + // Build a rule per expression + for (String expression : expressionsToTest) { + GroovyRule rule = buildRule(Arrays.asList(attribute1, attribute2), expression); + + // Now run the tests, computing the expected Boolean result each time + for (String heatStackId : heatStackIds) { + Map<String, Object> map = new HashMap<>(); + map.put(attribute1, heatStackId); + for (String vnfName : vnfNames) { + map.put(attribute2, vnfName); + boolean expectedExpressionResult = // Java equivalent of the expression + heatStackId != null && heatStackId.length() > 10 + && heatStackId.substring(0, 11).equals(vnfName); + testWithAttributeValue(rule, map, expectedExpressionResult); + } + } + } + } + + /** + * @param rule + * @param tests + */ + public void assertTestResults(GroovyRule rule, Map<Object, Boolean> tests) { + for (Entry<?, ?> e : tests.entrySet()) { + Object attributeValue = e.getKey(); + Boolean expectedResult = (Boolean) e.getValue(); + RuleHelper.assertRuleResult(rule, attributeValue, expectedResult); + } + } + + private void testWithAttributeValue(GroovyRule rule, Map<String, Object> map, boolean expectedResult) { + AttributeValues attributeValues = new AttributeValues(map); + RuleHelper.assertRuleResult(rule, attributeValues, expectedResult); + } + + private void testRuleExpression(String attributes, String expression, Map<Object, Boolean> tests) + throws InstantiationException, IllegalAccessException, IOException, GroovyConfigurationException { + GroovyRule rule = buildRule("testRule", attributes, expression); + assertTestResults(rule, tests); + } + + /** + * Build a simple rule using a RuleConfiguration object + * + * @param name the rule name + * @param attribute a named variable, referenced in the expression + * @param expression the expression to evaluate (returns a Boolean value) + * @return + * @throws IOException + * @throws InstantiationException + * @throws IllegalAccessException + * @throws GroovyConfigurationException + */ + private GroovyRule buildRule(String name, String attribute, String expression) + throws IOException, InstantiationException, IllegalAccessException, GroovyConfigurationException { + RuleSection ruleConfig = new RuleSection(); + ruleConfig.setName(name); + ruleConfig.setAttributes(Collections.singletonList(attribute)); + ruleConfig.setExpression(expression); + return new GroovyRule(ruleConfig); + } + + private GroovyRule buildRule(String name, List<String> attributes, String expression) + throws InstantiationException, IllegalAccessException, IOException, GroovyConfigurationException { + RuleSection ruleConfig = new RuleSection(); + ruleConfig.setName(name); + ruleConfig.setAttributes(attributes); + ruleConfig.setExpression(expression); + return new GroovyRule(ruleConfig); + } + + /** + * Build a simple rule (with a default name) using a RuleConfiguration object + * + * @see TestRuleExecution#buildRule(String, String, String) + * + * @param attribute a named variable, referenced in the expression + * @param expression the expression to evaluate (returns a Boolean value) + * @throws GroovyConfigurationException + */ + private GroovyRule buildRule(String attribute, String expression) + throws InstantiationException, IllegalAccessException, IOException, GroovyConfigurationException { + return buildRule("testRule", attribute, expression); + } + + private GroovyRule buildRule(List<String> attributes, String expression) + throws InstantiationException, IllegalAccessException, IOException, GroovyConfigurationException { + return buildRule("testRule", attributes, expression); + } + + private void assertRuleResult(GroovyRule rule, Object value, boolean expectedResult) { + RuleHelper.assertRuleResult(rule, value, expectedResult); + } + +} diff --git a/src/test/java/org/onap/aai/validation/ruledriven/rule/TestRuleValidation.java b/src/test/java/org/onap/aai/validation/ruledriven/rule/TestRuleValidation.java new file mode 100644 index 0000000..0650743 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/ruledriven/rule/TestRuleValidation.java @@ -0,0 +1,229 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.ruledriven.rule; + +import static org.hamcrest.CoreMatchers.containsString; +import static org.hamcrest.CoreMatchers.equalTo; +import static org.hamcrest.CoreMatchers.is; +import static org.junit.Assert.assertThat; + +import java.io.IOException; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Map.Entry; +import org.junit.Rule; +import org.junit.Test; +import org.junit.rules.ExpectedException; +import org.onap.aai.validation.ruledriven.configuration.GroovyConfigurationException; +import org.onap.aai.validation.ruledriven.configuration.RuleSection; +import org.onap.aai.validation.ruledriven.rule.GroovyRule; + +/** + * Tests for creating an AuditRule object and then executing the rule expression against fixed attribute values + * + * @see GroovyRule + * + */ +public class TestRuleValidation { + + static { + System.setProperty("APP_HOME", "."); + } + + @Rule + public final ExpectedException exception = ExpectedException.none(); + + /** + * Test multiple sample expressions each with various different attribute names. Each of the attribute names used in + * this test is valid for use within a rule. + * + * @throws GroovyConfigurationException + * @throws IOException + * @throws IllegalAccessException + * @throws InstantiationException + * + * @throws Exception + */ + @Test + public void testValidAttributeNames() + throws InstantiationException, IllegalAccessException, IOException, GroovyConfigurationException { + testValidExpressions("clli"); // Sample name + testValidExpressions("c"); + testValidExpressions("i"); // Short attribute name, part of the size() text + testValidExpressions("aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa"); + testValidExpressions("size"); // Does not interfere with .size() method call + testValidExpressions("s12"); // Digits allowed in the attribute name + testValidExpressions("s12s"); + testValidExpressions("12s"); + testValidExpressions("12-s"); // Hyphens supported + testValidExpressions("12_s"); // Underscores supported + testValidExpressions("if"); // Keyword + testValidExpressions("return"); + testValidExpressions("A.B.C"); // Dots indicate a JSON Path + } + + /** + * Test that the attribute name is sanitised. Each of the following attribute names is invalid for use in the rules + * configuration. + * + * @throws Exception + */ + @Test + public void testInvalidAttributeNames() throws Exception { + testInvalidAttributeName(""); // Zero-length + testInvalidAttributeName("null"); // Reserved keyword + testInvalidAttributeName("8"); // This would cause replacement of the value 8 in the expression + testInvalidAttributeName("size()"); // This would replace the call to size() + testInvalidAttributeName("s?"); // Special character not supported by the implementation + testInvalidAttributeName("\""); + testInvalidAttributeName("s\\"); + testInvalidAttributeName("s/"); + testInvalidAttributeName("s\""); + testInvalidAttributeName("s'"); + testInvalidAttributeName("=="); + } + + /** + * A rule cannot support an attribute that is zero-length. This test ensures that this is detected even when the + * expression itself is valid. + * + * @throws Exception + */ + @Test + public void testZeroLengthAttribute() throws Exception { + String attribute = ""; + String expression = "clli.size() == 8 || clli.size() == 11"; + GroovyRule rule = buildRule("testRule", attribute, expression); + assertThat(rule.toString(), rule.isValid(), is(equalTo(false))); + } + + @Test + public void testInvalidRuleSyntax() throws Exception { + String attribute = "fred"; + String expression = "fred. = 8 || fred.size() == 11"; + exception.expect(GroovyConfigurationException.class); + exception.expectMessage(containsString("unexpected")); + buildRule("testRule", attribute, expression); + } + + @Test + public void testInvalidAttribute() throws Exception { + String attribute = "fred"; + String expression = "size.size() == 8 || size.size() == 11"; + GroovyRule rule = buildRule("testRule", attribute, expression); + + assertThat(rule.toString(), rule.isValid(), is(equalTo(false))); + } + + /** + * Utility to build and test different expressions using the supplied attribute name + * + * @param attribute attribute (field) identifier + * @throws InstantiationException + * @throws IllegalAccessException + * @throws IOException + * @throws GroovyConfigurationException + */ + private void testValidExpressions(String attribute) + throws InstantiationException, IllegalAccessException, IOException, GroovyConfigurationException { + testValidLengthRule(attribute); + } + + /** + * Utility to build and test an expression asserting that the size() of the attribute is 8 or 11 + * + * @param attribute attribute (field) identifier + * @throws InstantiationException + * @throws IllegalAccessException + * @throws IOException + * @throws GroovyConfigurationException + */ + private void testValidLengthRule(String attribute) + throws InstantiationException, IllegalAccessException, IOException, GroovyConfigurationException { + String fieldName = attribute.substring(attribute.lastIndexOf(".") + 1); + String expression = fieldName + ".size() == 8 || " + fieldName + ".size() == 11"; + GroovyRule rule = buildRule("testRule", attribute, expression); + + // Test that the rule is valid + assertThat(rule.toString(), rule.isValid(), is(equalTo(true))); + + // Now test that the rule actually executes successfully + Map<Object, Boolean> tests = new HashMap<>(); + tests.put("", false); + tests.put("X", false); + tests.put("1234567", false); + tests.put("12345678", true); // 8 digits + tests.put("ABCDEFGH", true); // 8 chars + tests.put("12E4567890A", true); // 11 mixed digits/chars + tests.put("abcdefghijk", true); // 11 chars + tests.put("AbCdEfGhIjK", true); // 11 chars mixed case + tests.put("AbCdEfGhIj?", true); // special char + testRuleExpression(attribute, expression, tests); + } + + private void testRuleExpression(String attributes, String expression, Map<Object, Boolean> tests) + throws InstantiationException, IllegalAccessException, IOException, GroovyConfigurationException { + GroovyRule rule = buildRule("testRule", attributes, expression); + assertThat("The rule should be valid", rule.isValid(), is(equalTo(true))); + for (Entry<?, ?> e : tests.entrySet()) { + Object attributeValue = e.getKey(); + Boolean expectedResult = (Boolean) e.getValue(); + RuleHelper.assertRuleResult(rule, attributeValue, expectedResult); + } + } + + /** + * Build a simple rule using a RuleConfiguration object + * + * @param name the rule name + * @param attribute a named variable, referenced in the expression + * @param expression the expression to evaluate (returns a Boolean value) + * @return + * @throws IOException + * @throws InstantiationException + * @throws IllegalAccessException + * @throws GroovyConfigurationException + */ + private GroovyRule buildRule(String name, String attribute, String expression) + throws InstantiationException, IllegalAccessException, IOException, GroovyConfigurationException { + RuleSection ruleConfig = new RuleSection(); + ruleConfig.setName(name); + ruleConfig.setAttributes(Collections.singletonList(attribute)); + ruleConfig.setExpression(expression); + return new GroovyRule(ruleConfig); + } + + /** + * Utility to build a rule and test that the attribute is valid + * + * @param attribute attribute (field) identifier + * @throws InstantiationException + * @throws IllegalAccessException + * @throws IOException + * @throws GroovyConfigurationException + */ + private void testInvalidAttributeName(String attribute) + throws InstantiationException, IllegalAccessException, IOException, GroovyConfigurationException { + String expression = attribute + ".size() == 8 || " + attribute + ".size() == 11"; + GroovyRule rule = buildRule("testRule", attribute, expression); + + // Test that the rule is invalid + assertThat(rule.toString(), rule.isValid(), is(equalTo(false))); + } +} diff --git a/src/test/java/org/onap/aai/validation/ruledriven/validator/TestRuleDrivenValidator.java b/src/test/java/org/onap/aai/validation/ruledriven/validator/TestRuleDrivenValidator.java new file mode 100644 index 0000000..cf1e874 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/ruledriven/validator/TestRuleDrivenValidator.java @@ -0,0 +1,125 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.ruledriven.validator; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.CoreMatchers.notNullValue; +import static org.hamcrest.MatcherAssert.assertThat; + +import com.google.gson.JsonSyntaxException; +import java.io.IOException; +import java.net.URISyntaxException; +import java.nio.file.Files; +import java.nio.file.Path; +import java.nio.file.Paths; +import java.nio.file.attribute.BasicFileAttributes; +import java.util.ArrayList; +import java.util.List; +import java.util.function.BiPredicate; +import java.util.stream.Stream; +import javax.inject.Inject; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.aai.validation.exception.ValidationServiceException; +import org.onap.aai.validation.result.ValidationResult; +import org.onap.aai.validation.ruledriven.RuleDrivenValidator; +import org.onap.aai.validation.test.util.TestEntity; +import org.onap.aai.validation.test.util.ValidationResultIsEqual; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.TestPropertySource; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@TestPropertySource(properties = {"schemaIngestPropLoc = src/test/resources/oxm-reader/schemaIngest.properties"}) +@ContextConfiguration( + locations = {"classpath:" + TestRuleDrivenValidator.UNIT_TEST_FOLDER + "/test-rule-driven-validator-beans.xml"}) +public class TestRuleDrivenValidator { + + static { + System.setProperty("APP_HOME", "."); + } + + public static final String UNIT_TEST_FOLDER = "rule-driven-validator"; + private static final String TEST_EVENTS_PATH = "/test_events"; + + @Inject + private RuleDrivenValidator validator; + + /** + * @param testEntitiesPath + * @param testEventsPath + * @param resultsPath + * @return all test entities + * @throws URISyntaxException + */ + public static List<TestEntity> getEntities(String testEntitiesPath, String testEventsPath, String resultsPath) + throws URISyntaxException { + Path testEvents = Paths.get(ClassLoader.getSystemResource(testEntitiesPath + testEventsPath).toURI()); + + BiPredicate<Path, BasicFileAttributes> jsonMatcher = + (path, basicFileAttributes) -> path.toFile().getName().matches(".*\\.json"); + + List<TestEntity> entitiesList = new ArrayList<>(); + try (Stream<Path> paths = Files.find(testEvents, 2, jsonMatcher)) { + paths.forEach((path) -> entitiesList.add(new TestEntity(testEvents, path, testEventsPath, resultsPath))); + } catch (IOException e) { + throw new RuntimeException(e); + } + + return entitiesList; + } + + /** + * @throws ValidationServiceException + * @throws JsonSyntaxException + * @throws URISyntaxException + * @throws IOException + */ + @Test + public void testValidateUnitTestInstances() + throws ValidationServiceException, JsonSyntaxException, URISyntaxException, IOException { + validateEntities(UNIT_TEST_FOLDER, TEST_EVENTS_PATH, "/results/expected"); + } + + /** + * @param inputEventsFolder + * @param testEventsPath + * @param resultsPath + * @throws URISyntaxException + * @throws ValidationServiceException + * @throws IOException + */ + private void validateEntities(String inputEventsFolder, String testEventsPath, String resultsPath) + throws URISyntaxException, ValidationServiceException, IOException { + for (TestEntity entity : getEntities(inputEventsFolder, testEventsPath, resultsPath)) { + List<ValidationResult> results = validator.validate(entity.getJson()); + assertThat(results.size(), is(1)); + ValidationResult expectedResult = entity.getExpectedValidationResult(); + if (expectedResult == null) { + Path testEvents = Paths.get(ClassLoader.getSystemResource(inputEventsFolder + resultsPath).toURI()); + StringBuilder sb = new StringBuilder(); + Files.walk(testEvents).forEach((path) -> sb.append(path).append("\n")); + assertThat("Expected results missing (" + entity.expectedResultsFile + ")\n" + sb.toString(), + expectedResult, is(notNullValue())); + } + assertThat(entity.inputFile.getAbsolutePath(), results.get(0), + is(ValidationResultIsEqual.equalTo(expectedResult))); + } + } + +} diff --git a/src/test/java/org/onap/aai/validation/services/TestInfoService.java b/src/test/java/org/onap/aai/validation/services/TestInfoService.java new file mode 100644 index 0000000..0bfa8ba --- /dev/null +++ b/src/test/java/org/onap/aai/validation/services/TestInfoService.java @@ -0,0 +1,140 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.services; + +import static org.hamcrest.CoreMatchers.containsString; +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.CoreMatchers.not; +import static org.hamcrest.CoreMatchers.nullValue; +import static org.hamcrest.CoreMatchers.startsWith; +import static org.junit.Assert.assertThat; + +import java.io.IOException; +import java.net.URISyntaxException; +import java.nio.file.Path; +import java.nio.file.Paths; +import javax.inject.Inject; +import org.junit.Before; +import org.junit.Test; +import org.junit.runner.RunWith; +import org.onap.aai.validation.controller.ValidationController; +import org.onap.aai.validation.exception.ValidationServiceException; +import org.onap.aai.validation.publisher.MockEventPublisher; +import org.onap.aai.validation.services.InfoService; +import org.onap.aai.validation.test.util.TestEntity; +import org.onap.aai.validation.test.util.TestUtil; +import org.springframework.test.context.ContextConfiguration; +import org.springframework.test.context.TestPropertySource; +import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; + +@RunWith(SpringJUnit4ClassRunner.class) +@TestPropertySource(properties = {"schemaIngestPropLoc = src/test/resources/oxm-reader/schemaIngest.properties"}) +@ContextConfiguration(locations = {"classpath:/info-service/test-validation-service-beans.xml"}) +public class TestInfoService { + + static { + System.setProperty("APP_HOME", "."); + } + + enum TestData { + // @formatter:off + VSERVER ("rule-driven-validator/test_events/vserver-create-event.json"); + + private String filename; + TestData(String filename) {this.filename = filename;} + public String getFilename() {return this.filename;} + // @formatter:on + } + + private InfoService infoService; + + @Inject + private ValidationController validationController; + + @Inject + MockEventPublisher messagePublisher; + + @Before + public void setUp() throws ValidationServiceException { + infoService = new InfoService(); + infoService.setValidationController(validationController); + } + + /** + * @throws ValidationServiceException + */ + @Test + public void testInitialisedInfoService() throws ValidationServiceException { + assertThat(infoService.getValidationController(), is(validationController)); + String info = infoService.getInfo(); + assertResultsStringFormatted(info); + } + + /** + * @throws ValidationServiceException + */ + @Test + public void testThrowableRecorded() throws ValidationServiceException { + validationController.recordThrowable(new Exception()); + String info = infoService.getInfo(); + assertResultsStringFormatted(info); + assertThat(info, containsString("Exception reported")); + } + + /** + * @throws ValidationServiceException + */ + @Test + public void testInvalidEventRecorded() throws ValidationServiceException { + validationController.execute("", "http"); + String info = infoService.getInfo(); + assertResultsStringFormatted(info); + assertThat(info, containsString("errored=1")); + } + + /** + * @throws ValidationServiceException + * @throws IOException + * @throws URISyntaxException + */ + @Test + public void testVserverEventRecorded() throws ValidationServiceException, URISyntaxException, IOException { + Path vserverTestFile = Paths.get(ClassLoader.getSystemResource(TestData.VSERVER.getFilename()).toURI()); + Path root = vserverTestFile.getParent(); + assertThat(root, is(not(nullValue()))); + TestEntity entity = new TestEntity(root, vserverTestFile, "test_events", "results/expected"); + messagePublisher.setTestEntity(entity); + messagePublisher.setTestDescription(entity.inputFile.getAbsolutePath()); + validationController.execute(TestUtil.getFileAsString(TestData.VSERVER.getFilename()), "http"); + String info = infoService.getInfo(); + assertResultsStringFormatted(info); + assertThat(info, containsString("total=1")); + } + + /** + * Assert that the info service status string contains the expected standard results and formatting. + * + * @param info + */ + private void assertResultsStringFormatted(String info) { + assertThat(info, startsWith("Status: Up\n")); + assertThat(info, containsString("Started at")); + assertThat(info, containsString("total=0")); + } + +} diff --git a/src/test/java/org/onap/aai/validation/services/TestValidateServiceImpl.java b/src/test/java/org/onap/aai/validation/services/TestValidateServiceImpl.java new file mode 100644 index 0000000..e23f7a2 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/services/TestValidateServiceImpl.java @@ -0,0 +1,115 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.services; + +import static org.hamcrest.CoreMatchers.is; +import static org.hamcrest.CoreMatchers.notNullValue; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertThat; + +import java.net.URISyntaxException; +import java.security.cert.X509Certificate; +import java.util.Collections; +import java.util.List; +import java.util.Map.Entry; +import javax.security.auth.x500.X500Principal; +import javax.ws.rs.core.MultivaluedHashMap; +import org.junit.Before; +import org.junit.Test; +import org.mockito.Mockito; +import org.onap.aai.auth.AAIMicroServiceAuth; +import org.onap.aai.validation.controller.ValidationController; +import org.onap.aai.validation.services.ValidateServiceImpl; +import org.springframework.http.HttpHeaders; +import org.springframework.http.HttpStatus; +import org.springframework.http.ResponseEntity; +import org.springframework.mock.web.MockHttpServletRequest; + +public class TestValidateServiceImpl { + + static { + System.setProperty("APP_HOME", "."); + } + + private ValidationController mockValidationController; + private AAIMicroServiceAuth mockAaiMicroServiceAuth; + + @Before + public void setUp() { + mockValidationController = Mockito.mock(ValidationController.class); + mockAaiMicroServiceAuth = Mockito.mock(AAIMicroServiceAuth.class); + } + + @Test + public void validateConstructor() { + ValidateServiceImpl validateServiceImpl = + new ValidateServiceImpl(mockValidationController, mockAaiMicroServiceAuth); + assertNotNull(validateServiceImpl); + assertThat(validateServiceImpl.toString(), is(notNullValue())); + } + + @Test + public void testValidateEventWithoutHeaderFailure() { + ValidateServiceImpl validateServiceImpl = + new ValidateServiceImpl(mockValidationController, mockAaiMicroServiceAuth); + ResponseEntity<String> response = validateServiceImpl.validate("testEvent"); + assertThat(response.getStatusCode(), is(HttpStatus.INTERNAL_SERVER_ERROR)); + } + + /** + * Create a (mocked) HTTPS request and invoke the Babel generate artifacts API + * + * @param request for the Babel Service + * @return the Response from the HTTP API + * @throws URISyntaxException + */ + @Test + public void testRequestWithHeaders() throws URISyntaxException { + // Create mocked request headers map + MultivaluedHashMap<String, String> headersMap = new MultivaluedHashMap<>(); + headersMap.put("X-TransactionId", createSingletonList("transaction-id")); + headersMap.put("X-FromAppId", createSingletonList("app-id")); + headersMap.put("Host", createSingletonList("hostname")); + + HttpHeaders headers = Mockito.mock(HttpHeaders.class); + for (Entry<String, List<String>> entry : headersMap.entrySet()) { + Mockito.when(headers.get(entry.getKey())).thenReturn(entry.getValue()); + } + + MockHttpServletRequest servletRequest = new MockHttpServletRequest(); + servletRequest.setSecure(true); + servletRequest.setScheme("https"); + servletRequest.setServerPort(9501); + servletRequest.setServerName("localhost"); + servletRequest.setRequestURI("/services/validation-service/v1/app/validate"); + + X509Certificate mockCertificate = Mockito.mock(X509Certificate.class); + Mockito.when(mockCertificate.getSubjectX500Principal()) + .thenReturn(new X500Principal("CN=test, OU=qa, O=Test Ltd, L=London, ST=London, C=GB")); + + servletRequest.setAttribute("javax.servlet.request.X509Certificate", new X509Certificate[] {mockCertificate}); + servletRequest.setAttribute("javax.servlet.request.cipher_suite", ""); + + ValidateServiceImpl service = new ValidateServiceImpl(mockValidationController, mockAaiMicroServiceAuth); + service.validate(headers, servletRequest, "testEvent"); + } + + private List<String> createSingletonList(String listItem) { + return Collections.<String>singletonList(listItem); + } +} diff --git a/src/test/java/org/onap/aai/validation/test/util/RandomString.java b/src/test/java/org/onap/aai/validation/test/util/RandomString.java new file mode 100644 index 0000000..ba2d85e --- /dev/null +++ b/src/test/java/org/onap/aai/validation/test/util/RandomString.java @@ -0,0 +1,40 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.test.util; + +import java.util.Random; + +public class RandomString { + + private static final String VALID_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; + private static final int MAX_STRING_LENGTH = 50; + private static Random rng = new Random(); + + public static String generate() { + return generateString(rng, VALID_CHARS, rng.nextInt(MAX_STRING_LENGTH) + 1); + } + + public static String generateString(Random rng, String characters, int length) { + char[] text = new char[length]; + for (int i = 0; i < length; i++) { + text[i] = characters.charAt(rng.nextInt(characters.length())); + } + return new String(text); + } + +} diff --git a/src/test/java/org/onap/aai/validation/test/util/TestEntity.java b/src/test/java/org/onap/aai/validation/test/util/TestEntity.java new file mode 100644 index 0000000..e42873a --- /dev/null +++ b/src/test/java/org/onap/aai/validation/test/util/TestEntity.java @@ -0,0 +1,88 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.test.util; + +import com.google.gson.JsonSyntaxException; +import java.io.File; +import java.io.IOException; +import java.net.URI; +import java.net.URISyntaxException; +import java.nio.file.NoSuchFileException; +import java.nio.file.Path; +import org.onap.aai.validation.result.ValidationResult; + +public class TestEntity { + + public File inputFile; + public String expectedResultsFile; + + public TestEntity(Path root, Path inputFilePath, String inputEventsPath, String outputEventsPath) { + String rootUri = root.toUri().toString(); + String resultsRoot = rootUri.replaceAll(inputEventsPath + "/$", outputEventsPath + "/"); + String inputFileUri = inputFilePath.toUri().toString(); + this.inputFile = inputFilePath.toFile(); + this.expectedResultsFile = inputFileUri.replace(rootUri, resultsRoot).replaceAll("\\.json$", ".exp.json"); + } + + public String getJson() throws URISyntaxException, IOException { + return TestUtil.getFileAsString(inputFile.getPath()); + } + + /** + * @return the contents of the file that stores the expected JSON, or an empty string if there is no expected JSON + * @throws URISyntaxException + * @throws IOException + */ + public String getExpectedJson() throws URISyntaxException, IOException { + try { + return TestUtil.getFileAsString(new URI(expectedResultsFile).getPath()); + } catch (NoSuchFileException e) { + return ""; + } + } + + public ValidationResult getExpectedValidationResult() throws JsonSyntaxException, URISyntaxException, IOException { + return ValidationResult.fromJson(getExpectedJson()); + } + + @Override + public String toString() { + return "TestEntity [inputFile=" + inputFile + ", expectedResultsFile=" + expectedResultsFile + "]"; + } + + public boolean expectsError() throws URISyntaxException, IOException { + try { + getErrorFileContents(); + } catch (NoSuchFileException e) { + return false; + } + return true; + } + + public String getExpectedErrorMessage() throws URISyntaxException, IOException { + return getErrorFileContents().trim(); + } + + private String getErrorFileContents() throws URISyntaxException, IOException { + return TestUtil.getFileAsString(new URI(getErrorFileURI()).getPath()); + } + + private String getErrorFileURI() { + return expectedResultsFile.replaceAll("\\.exp\\.json$", ".error"); + } +} diff --git a/src/test/java/org/onap/aai/validation/test/util/TestUtil.java b/src/test/java/org/onap/aai/validation/test/util/TestUtil.java new file mode 100644 index 0000000..39d1246 --- /dev/null +++ b/src/test/java/org/onap/aai/validation/test/util/TestUtil.java @@ -0,0 +1,52 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.test.util; + +import java.io.File; +import java.io.IOException; +import java.net.URI; +import java.net.URISyntaxException; +import java.net.URL; +import java.nio.charset.StandardCharsets; +import java.nio.file.Files; +import java.nio.file.Paths; + +/** + * Test helper methods. + */ +public class TestUtil { + + /** + * Gets files, such as test data from the classpath. + * + * @param filename the name of the file + * @return a String with the file contents. + * @throws URISyntaxException + * @throws IOException + */ + public static String getFileAsString(String filename) throws URISyntaxException, IOException { + // Try loading the named file directly + URI uri = new File(filename).toURI(); + URL systemResource = ClassLoader.getSystemResource(filename); + if (systemResource != null) { + uri = systemResource.toURI(); + } + byte[] encoded = Files.readAllBytes(Paths.get(uri)); + return new String(encoded, StandardCharsets.UTF_8); + } +} diff --git a/src/test/java/org/onap/aai/validation/test/util/ValidationResultIsEqual.java b/src/test/java/org/onap/aai/validation/test/util/ValidationResultIsEqual.java new file mode 100644 index 0000000..aa6471f --- /dev/null +++ b/src/test/java/org/onap/aai/validation/test/util/ValidationResultIsEqual.java @@ -0,0 +1,58 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.test.util; + +import org.hamcrest.BaseMatcher; +import org.hamcrest.Description; +import org.hamcrest.Matcher; +import org.onap.aai.validation.result.ValidationResult; + +/** + * Matcher for comparing actual and expected ValidationResults + * + */ +public class ValidationResultIsEqual extends BaseMatcher<ValidationResult> { + private final ValidationResult expected; + + public static Matcher<? super ValidationResult> equalTo(ValidationResult validationResult) { + return new ValidationResultIsEqual(validationResult); + } + + private ValidationResultIsEqual(ValidationResult expected) { + this.expected = expected; + } + + @Override + public boolean matches(Object o) { + if (expected == null) { + return false; + } + ValidationResult actual = (ValidationResult) o; + return actual.getEntityId().equals(expected.getEntityId()) && // + actual.getEntityType().equals(expected.getEntityType()) && // + (actual.getEntityLink() == null ? "" : actual.getEntityLink()).equals(expected.getEntityLink()) && // + actual.getResourceVersion().equals(expected.getResourceVersion()) && // + actual.getViolations().equals(expected.getViolations()); + } + + @Override + public void describeTo(Description description) { + description.appendText(expected == null ? "<not defined>" : expected.toString()); + } + +} diff --git a/src/test/java/org/onap/aai/validation/util/TestStringUtils.java b/src/test/java/org/onap/aai/validation/util/TestStringUtils.java new file mode 100644 index 0000000..038e10d --- /dev/null +++ b/src/test/java/org/onap/aai/validation/util/TestStringUtils.java @@ -0,0 +1,170 @@ +/* + * ============LICENSE_START=================================================== + * Copyright (c) 2018 Amdocs + * ============================================================================ + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + * ============LICENSE_END===================================================== + */ +package org.onap.aai.validation.util; + +import static org.hamcrest.Matchers.containsInAnyOrder; +import static org.hamcrest.Matchers.is; +import static org.hamcrest.Matchers.nullValue; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertThat; + +import java.util.Arrays; +import java.util.List; +import org.junit.Test; +import org.onap.aai.validation.exception.ValidationServiceException; +import org.onap.aai.validation.util.StringUtils; + +public class TestStringUtils { + + static { + System.setProperty("APP_HOME", "."); + } + + @Test + public void testStripSinglePrefix() throws Exception { + String prefixDelimiter = "."; + String prefix = "prefix"; + String suffix = "suffix"; + String testString = prefix + prefixDelimiter + suffix; + + String result = StringUtils.stripPrefix(testString, prefixDelimiter); + + assertEquals("Prefix incorrectly stripped.", suffix, result); + } + + @Test + public void testStripMultiplePrefix() throws Exception { + String prefixDelimiter = "***"; + String prefix = "prefix"; + String suffix = "suffix"; + String testString = prefix + prefixDelimiter + prefix + prefixDelimiter + suffix; + + String result = StringUtils.stripPrefix(testString, prefixDelimiter); + + assertEquals("Prefix incorrectly stripped.", suffix, result); + } + + @Test + public void testStripSubstr() { + List<String> stringList = Arrays.asList("/text()one", "tw/text()o", "three/text()"); + List<String> stripSubstr = StringUtils.stripSuffix(stringList, "/text()"); + assertThat(stripSubstr, containsInAnyOrder("/text()one", "tw/text()o", "three")); + } + + @Test + public void testStripStringRegex() throws Exception { + String prefixDelimiter = "/aai/v8/"; + String prefix = "prefix"; + String suffix = "suffix"; + String testString = prefix + prefixDelimiter + suffix; + String regex = "\\/aai\\/v[0-9]*\\/"; + + String stripString = StringUtils.stripPrefixRegex(testString, regex); + + assertThat(stripString, is(suffix)); + } + + @Test + public void testStripStringRegexNotFound() throws Exception { + String prefixDelimiter = "delimiter"; + String prefix = "prefix"; + String suffix = "suffix"; + String testString = prefix + prefixDelimiter + suffix; + String regex = "\\/aai\\/v[0-9]*\\/"; + + String stripString = StringUtils.stripPrefixRegex(testString, regex); + + assertThat(stripString, is(testString)); + } + + @Test + public void testStripStringRegexMultiplePrefix() throws Exception { + String prefixDelimiter = "/aai/v8/"; + String prefix = "prefix"; + String suffix = "text" + prefixDelimiter + "text"; + String testString = prefix + prefixDelimiter + suffix; + String regex = "\\/aai\\/v[0-9]*\\/"; + + String stripString = StringUtils.stripPrefixRegex(testString, regex); + + assertThat(stripString, is(suffix)); + } + + @Test + public void testStripStringRegexNullString() throws Exception { + String testString = null; + String regex = "\\/aai\\/v[0-9]*\\/"; + + String stripString = StringUtils.stripPrefixRegex(testString, regex); + + assertThat(stripString, nullValue()); + } + + @Test + public void testStripStringRegexEmptyString() throws Exception { + String testString = ""; + String regex = "\\/aai\\/v[0-9]*\\/"; + + String stripString = StringUtils.stripPrefixRegex(testString, regex); + + assertThat(stripString, is(testString)); + } + + @Test + public void testStripStringRegexNullRegex() throws Exception { + String testString = "test"; + String regex = null; + + String stripString = StringUtils.stripPrefixRegex(testString, regex); + + assertThat(stripString, is(testString)); + } + + @Test + public void testStripStringRegexEmptyRegex() throws Exception { + String testString = "test"; + String regex = ""; + + String stripString = StringUtils.stripPrefixRegex(testString, regex); + + assertThat(stripString, is(testString)); + } + + @Test(expected = ValidationServiceException.class) + public void testStripStringRegexInvalidRegex() throws Exception { + String prefixDelimiter = "/aai/v8/"; + String prefix = "prefix"; + String suffix = "suffix"; + String testString = prefix + prefixDelimiter + suffix; + String regex = "***"; + + StringUtils.stripPrefixRegex(testString, regex); + } + + @Test + public void testStripStringRegexLimitedPrefix() throws Exception { + String prefixDelimiter = "/aai/v8/"; + String suffix = "suffix"; + String testString = prefixDelimiter + suffix; + String regex = "\\/aai\\/v[0-9]*\\/"; + + String stripString = StringUtils.stripPrefixRegex(testString, regex); + + assertThat(stripString, is(suffix)); + } +} |