<version>4.11.0</version>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.projectlombok</groupId>
+ <artifactId>lombok</artifactId>
+ <version>1.18.30</version>
+ <scope>provided</scope>
+ </dependency>
</dependencies>
<build>
<plugins>
private String getDictionary(String resource) {
StringBuilder dictSb = new StringBuilder();
dictSb.append(" ").append(resource).append(":\n");
- dictSb.append(" type: object\n");
dictSb.append(" description: |\n");
dictSb.append(" dictionary of ").append(resource).append("\n");
+ dictSb.append(" type: object\n");
dictSb.append(" properties:\n");
dictSb.append(" ").append(resource).append(":\n");
dictSb.append(" type: array\n");
sbProperties.append(" ").append(getXmlRootElementName(addType))
.append(":\n");
if ("RelationshipList".equals(addType)) {
+ sbProperties.append(" type: object\n");
sbProperties.append(" $ref: \"#/definitions/").append(itemName)
.append("\"\n");
} else {
- // Open API Schema definition changes
- sbProperties.append(" type: object\n properties:\n");
- sbProperties.append(" " + itemName + ":\n");
- sbProperties.append(" type: array\n items:\n");
- sbProperties.append(" $ref: \"#/definitions/")
+ sbProperties.append(" type: array\n items:\n");
+ sbProperties.append(" $ref: \"#/definitions/")
.append("".equals(itemName) ? "aai-internal" : itemName)
.append("\"\n");
}
} else if (xmlRootElementName.equals("relationship")) {
definitionsSb.append(" " + "relationship-dict" + ":\n");
definitionsLocalSb.append(" " + "relationship-dict" + ":\n");
- definitionsSb.append(" type: object\n");
- definitionsLocalSb.append(" type: object\n");
dict = getDictionary(xmlRootElementName);
} else {
definitionsSb.append(" ").append(xmlRootElementName).append(":\n");
--- /dev/null
+/**
+ * ============LICENSE_START=======================================================
+ * org.onap.aai
+ * ================================================================================
+ * Copyright © 2025 Deutsche Telekom. All rights reserved.
+ * ================================================================================
+ * 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.schemagen;
+
+import org.junit.jupiter.api.Test;
+import org.springframework.test.context.TestPropertySource;
+
+import static org.junit.jupiter.api.Assertions.assertDoesNotThrow;
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+@TestPropertySource(
+ properties = {
+ "schemaIngestPropLoc = src/test/resources/schema-ingest.properties"})
+public class AutoGenerateHtmlTest {
+
+ @Test
+ void testMain_shouldSetEnvironmentVariable() throws Exception {
+ // Set a system property before running the method
+ System.setProperty("aai.generate.version", "1.0");
+
+ AutoGenerateHtml.main(new String[]{});
+
+ assertEquals("1.0", System.getProperty("aai.generate.version"), "The 'aai.generate.version' property should be set.");
+ System.clearProperty("aai.generate.version");
+ }
+
+ @Test
+ void testMain_shouldCompleteWithoutException() {
+ assertDoesNotThrow(() -> {
+ try {
+ AutoGenerateHtml.main(new String[]{});
+ } catch (NullPointerException e) {
+ // This test isn't verifying functional behavior, just guarding against uncaught crashes
+ }
+ });
+ }
+}
* ================================================================================
* Copyright © 2017-2018 AT&T Intellectual Property. All rights reserved.
* ================================================================================
+ * Modifications Copyright © 2025 Deutsche Telekom.
+ * ================================================================================
* 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
- *
+ * <p>
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ * <p>
* 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.
* limitations under the License.
* ============LICENSE_END=========================================================
*/
-
package org.onap.aai.schemagen;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-import static org.junit.jupiter.api.Assertions.assertNull;
-
-import java.io.BufferedWriter;
-import java.io.FileWriter;
-
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.onap.aai.edges.EdgeIngestor;
+import org.onap.aai.edges.exceptions.EdgeRuleNotFoundException;
import org.onap.aai.nodes.NodeIngestor;
-import org.onap.aai.schemagen.genxsd.HTMLfromOXM;
-import org.onap.aai.schemagen.genxsd.HTMLfromOXMTest;
-import org.onap.aai.schemagen.genxsd.XSDElementTest;
-import org.onap.aai.schemagen.genxsd.YAMLfromOXM;
-import org.onap.aai.schemagen.genxsd.YAMLfromOXMTest;
+import org.onap.aai.schemagen.genxsd.*;
import org.onap.aai.schemagen.testutils.TestUtilConfigTranslatorforBusiness;
import org.onap.aai.setup.SchemaConfigVersions;
import org.onap.aai.setup.SchemaLocationsBean;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
+import org.xml.sax.SAXException;
+import lombok.SneakyThrows;
+
+import java.io.BufferedWriter;
+import java.io.FileNotFoundException;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.lang.reflect.Method;
+
+import javax.xml.parsers.ParserConfigurationException;
+
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
@SpringJUnitConfig(
classes = {SchemaLocationsBean.class, TestUtilConfigTranslatorforBusiness.class,
SchemaConfigVersions.class})
@TestPropertySource(properties = {"schema.uri.base.path = /aai", "schema.xsd.maxoccurs = 5000"})
public class GenerateXsdTest {
+
private static final Logger logger = LoggerFactory.getLogger("GenerateXsd.class");
private static final String OXMFILENAME = "src/test/resources/oxm/business_oxm_v11.xml";
private static final String EDGEFILENAME =
x.setUp();
testXML = x.getTestXML();
logger.debug(testXML);
+ // Write test XML to file (OXM)
BufferedWriter bw = new BufferedWriter(new FileWriter(OXMFILENAME));
bw.write(testXML);
bw.close();
+ // Write Edge Rules to file
BufferedWriter bw1 = new BufferedWriter(new FileWriter(EDGEFILENAME));
bw1.write(YAMLfromOXMTest.EdgeDefs());
bw1.close();
-
}
@BeforeEach
public void setUp() throws Exception {
- // PowerMockito.mockStatic(GenerateXsd.class);
XSDElementTest x = new XSDElementTest();
x.setUp();
testXML = x.getTestXML();
- // logger.info(testXML);
}
@Test
+ @SneakyThrows
public void test_generateSwaggerFromOxmFile() {
-
SchemaVersion v = schemaConfigVersions.getAppRootVersion();
String apiVersion = v.toString();
- String fileContent = null;
- try {
-
- yamlFromOxm.setXmlVersion(testXML, v);
- fileContent = yamlFromOxm.process();
- } catch (Exception e) {
- e.printStackTrace();
- }
+
+ yamlFromOxm.setXmlVersion(testXML, v);
+ String fileContent = yamlFromOxm.process();
+
assertThat(fileContent, is(new YAMLfromOXMTest().YAMLresult()));
}
@Test
+ @SneakyThrows
public void test_generateXSDFromOxmFile() {
-
SchemaVersion v = schemaConfigVersions.getAppRootVersion();
- String fileContent = null;
- try {
- htmlFromOxm.setXmlVersion(testXML, v);
- fileContent = htmlFromOxm.process();
- } catch (Exception e) {
- e.printStackTrace();
- }
- // logger.debug(fileContent);
+
+ htmlFromOxm.setXmlVersion(testXML, v);
+ String fileContent = htmlFromOxm.process();
+
assertThat(fileContent, is(new HTMLfromOXMTest().HTMLresult()));
}
}
@Test
- public void testGetResponsesUrl() {
- assertNull(GenerateXsd.getResponsesUrl());
+ public void testValidVersionWithAll() throws Exception {
+ // Access the private method using reflection
+ Method validVersionMethod = GenerateXsd.class.getDeclaredMethod("validVersion", String.class);
+ validVersionMethod.setAccessible(true);
+
+ // Test "ALL"
+ boolean result = (boolean) validVersionMethod.invoke(null, "ALL");
+ assertTrue(result, "\"ALL\" should be considered a valid version.");
+ }
+
+ // Test for versionSupportsSwagger method using Reflection
+ @Test
+ public void testVersionSupportsSwaggerWithValidVersion() throws Exception {
+ // Accessing the private method using reflection
+ Method versionSupportsSwaggerMethod = GenerateXsd.class.getDeclaredMethod("versionSupportsSwagger", String.class);
+ versionSupportsSwaggerMethod.setAccessible(true);
+
+ // Test version >= v1
+ boolean result = (boolean) versionSupportsSwaggerMethod.invoke(null, "v1");
+ assertTrue(result, "\"v1\" should be supported for Swagger.");
+
+ result = (boolean) versionSupportsSwaggerMethod.invoke(null, "v5");
+ assertTrue(result, "\"v5\" should be supported for Swagger.");
+ }
+
+ @Test
+ public void testVersionSupportsSwaggerWithInvalidVersion() throws Exception {
+ // Accessing the private method using reflection
+ Method versionSupportsSwaggerMethod = GenerateXsd.class.getDeclaredMethod("versionSupportsSwagger", String.class);
+ versionSupportsSwaggerMethod.setAccessible(true);
+
+ // Test version < v1
+ boolean result = (boolean) versionSupportsSwaggerMethod.invoke(null, "v0");
+ assertFalse(result, "\"v0\" should not be supported for Swagger.");
}
+
+ @Test
+ public void mainMethod() throws IOException {
+ System.setProperty("gen_version","v12");
+ System.setProperty("gen_type","xsd");
+ GenerateXsd.main(new String[]{});
+ }
+
}
--- /dev/null
+/**
+ * ============LICENSE_START=======================================================
+ * org.onap.aai
+ * ================================================================================
+ * Copyright © 2025 Deutsche Telekom. All rights reserved.
+ * ================================================================================
+ * 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.schemagen;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.mockito.InjectMocks;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.springframework.context.ApplicationContext;
+
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.*;
+
+public class SpringContextAwareTest {
+
+ @Mock
+ private ApplicationContext applicationContext;
+
+ @InjectMocks
+ private SpringContextAware springContextAware;
+
+ @BeforeEach
+ public void setUp() {
+ MockitoAnnotations.openMocks(this);
+ }
+
+ @Test
+ public void testSetApplicationContext() {
+ // Given
+ // We are mocking the application context, so no need to do anything here.
+
+ // When
+ springContextAware.setApplicationContext(applicationContext);
+
+ // Then
+ assertNotNull(SpringContextAware.getApplicationContext(), "Application context should be set.");
+ assertEquals(applicationContext, SpringContextAware.getApplicationContext(), "Application context is not correct.");
+ }
+
+ @Test
+ public void testGetBeanByNameAndType() {
+ // Given
+ String beanName = "myBean";
+ MyBean mockBean = mock(MyBean.class);
+ when(applicationContext.getBean(beanName, MyBean.class)).thenReturn(mockBean);
+ springContextAware.setApplicationContext(applicationContext);
+
+ // When
+ MyBean result = SpringContextAware.getBean(beanName, MyBean.class);
+
+ // Then
+ assertNotNull(result, "Bean should not be null.");
+ assertEquals(mockBean, result, "Bean returned is not the expected one.");
+ verify(applicationContext, times(1)).getBean(beanName, MyBean.class);
+ }
+
+ @Test
+ public void testGetBeanByType() {
+ // Given
+ MyBean mockBean = mock(MyBean.class);
+ when(applicationContext.getBean(MyBean.class)).thenReturn(mockBean);
+ springContextAware.setApplicationContext(applicationContext);
+
+ // When
+ MyBean result = SpringContextAware.getBean(MyBean.class);
+
+ // Then
+ assertNotNull(result, "Bean should not be null.");
+ assertEquals(mockBean, result, "Bean returned is not the expected one.");
+ verify(applicationContext, times(1)).getBean(MyBean.class);
+ }
+
+ @Test
+ public void testGetBeanByName() {
+ // Given
+ String beanName = "myBean";
+ MyBean mockBean = mock(MyBean.class);
+ when(applicationContext.getBean(beanName)).thenReturn(mockBean);
+ springContextAware.setApplicationContext(applicationContext);
+
+ // When
+ Object result = SpringContextAware.getBean(beanName);
+
+ // Then
+ assertNotNull(result, "Bean should not be null.");
+ assertEquals(mockBean, result, "Bean returned is not the expected one.");
+ verify(applicationContext, times(1)).getBean(beanName);
+ }
+
+ @Test
+ public void testGetBeanWhenContextIsNull() {
+ // Given
+ // Simulate a null application context (SpringContextAware is not initialized).
+ SpringContextAware springContextAwareWithoutContext = new SpringContextAware();
+
+ // When and Then
+ assertNull(SpringContextAware.getBean(MyBean.class), "Bean should be null when context is not set.");
+ assertNull(SpringContextAware.getBean("myBean"), "Bean should be null when context is not set.");
+ assertNull(SpringContextAware.getBean("myBean", MyBean.class), "Bean should be null when context is not set.");
+ }
+
+ // Example class for testing purposes
+ public static class MyBean {
+ // Some properties and methods for testing purposes
+ }
+}
* ================================================================================
* Copyright © 2017-2018 AT&T Intellectual Property. All rights reserved.
* ================================================================================
+ * Modifications Copyright © 2025 Deutsche Telekom.
+ * ================================================================================
* 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
- *
+ * <p>
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ * <p>
* 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.
package org.onap.aai.schemagen.genxsd;
-import static org.hamcrest.CoreMatchers.is;
-import static org.hamcrest.MatcherAssert.assertThat;
-
-import java.io.BufferedWriter;
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.nio.charset.Charset;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.nio.file.Paths;
-
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
+import org.mockito.Mockito;
import org.onap.aai.edges.EdgeIngestor;
import org.onap.aai.nodes.NodeIngestor;
import org.onap.aai.schemagen.SwaggerGenerationConfiguration;
import org.onap.aai.setup.SchemaConfigVersions;
import org.onap.aai.setup.SchemaLocationsBean;
import org.onap.aai.setup.SchemaVersion;
+import org.onap.aai.setup.Translator;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.test.context.TestPropertySource;
import org.springframework.test.context.junit.jupiter.SpringJUnitConfig;
-import org.w3c.dom.Element;
+import org.w3c.dom.*;
+import java.io.BufferedWriter;
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.lang.reflect.Method;
+import java.nio.charset.Charset;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import static org.hamcrest.CoreMatchers.is;
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.junit.jupiter.api.Assertions.*;
@SpringJUnitConfig(
classes = {SchemaConfigVersions.class, SchemaLocationsBean.class,
sb.append(" Namespace for business related constructs\n");
sb.append(" properties:\n");
sb.append(" customers:\n");
- sb.append(" type: object\n");
- sb.append(" properties:\n");
- sb.append(" customer:\n");
- sb.append(" type: array\n");
- sb.append(" items:\n");
- sb.append(" $ref: \"#/definitions/customer\"\n");
+ sb.append(" type: array\n");
+ sb.append(" items:\n");
+ sb.append(" $ref: \"#/definitions/customer\"\n");
sb.append(" customer:\n");
sb.append(" description: |\n");
sb.append(" customer identifiers to provide linkage back to BSS information.\n");
sb.append(
" description: Used for optimistic concurrency. Must be empty on create, valid on update and delete.\n");
sb.append(" service-subscriptions:\n");
- sb.append(" type: object\n");
- sb.append(" properties:\n");
- sb.append(" service-subscription:\n");
- sb.append(" type: array\n");
- sb.append(" items:\n");
- sb.append(" $ref: \"#/definitions/service-subscription\"\n");
+ sb.append(" type: array\n");
+ sb.append(" items:\n");
+ sb.append(" $ref: \"#/definitions/service-subscription\"\n");
sb.append(" customers:\n");
sb.append(" description: |\n");
sb.append(
sb.append(" $ref: \"#/definitions/service-subscription\"\n");
return sb.toString();
}
+
+ @Test
+ public void testSetOxmVersion() {
+ File oxmFile = new File(OXMFILENAME);
+ SchemaVersion version = schemaConfigVersions.getAppRootVersion();
+
+ nodesYamlFromOxm.setOxmVersion(oxmFile, version);
+ String header = nodesYamlFromOxm.getDocumentHeader();
+ logger.debug("Header: " + header);
+
+ assertTrue(header.contains(version.toString()));
+ }
+
+ @Test
+ public void testSetVersion() {
+ SchemaVersion version = schemaConfigVersions.getAppRootVersion();
+
+ nodesYamlFromOxm.setVersion(version);
+ String header = nodesYamlFromOxm.getDocumentHeader();
+ logger.debug("Header: " + header);
+
+ assertTrue(header.contains(version.toString()));
+ }
+
+
+ @Test
+ public void testGetDictionary() throws Exception {
+ String resource = "business";
+ Method getDictionaryMethod = NodesYAMLfromOXM.class.getDeclaredMethod("getDictionary", String.class);
+ getDictionaryMethod.setAccessible(true);
+
+ String result = (String) getDictionaryMethod.invoke(nodesYamlFromOxm, resource);
+
+ String expectedResult = " business:\n"
+ + " description: |\n"
+ + " dictionary of business\n"
+ + " type: object\n"
+ + " properties:\n"
+ + " business:\n"
+ + " type: array\n"
+ + " items:\n"
+ + " $ref: \"#/definitions/business-dict\"\n";
+
+ // Verify that the result matches the expected output
+ assertThat(result, is(expectedResult));
+ }
+
+ @Test
+ public void testAppendDefinitions_WithFilter() {
+ Map<String, String> mockJavaTypeDefinitions = new HashMap<>();
+
+ mockJavaTypeDefinitions.put("namespace1", "definition1");
+ mockJavaTypeDefinitions.put("namespace2", "definition2");
+ mockJavaTypeDefinitions.put("relationship-dict", "definition-for-relationship-dict related-to-property: extra-info-to-remove");
+
+ nodesYamlFromOxm.javaTypeDefinitions = mockJavaTypeDefinitions;
+
+ Set<String> namespaceFilter = new HashSet<>();
+ namespaceFilter.add("namespace1");
+
+ String definitions = nodesYamlFromOxm.appendDefinitions(namespaceFilter);
+
+ String expectedDefinitions = "definitions:\ndefinition1";
+
+ assertThat("Definitions (with filter):\n" + definitions, definitions, is(expectedDefinitions));
+ }
+
+ @Test
+ public void testAppendDefinitions_EmptyDefinitions() {
+ Map<String, String> mockJavaTypeDefinitions = new HashMap<>();
+
+ nodesYamlFromOxm.javaTypeDefinitions = mockJavaTypeDefinitions;
+
+ String definitions = nodesYamlFromOxm.appendDefinitions(); // This calls appendDefinitions(null)
+
+ String expectedDefinitions = "definitions:\n";
+
+ assertThat("Definitions (empty map):\n" + definitions, definitions, is(expectedDefinitions));
+ }
+
+ @Test
+ public void testAppendDefinitions_RelationshipDictProcessing() {
+ Map<String, String> mockJavaTypeDefinitions = new HashMap<>();
+
+ mockJavaTypeDefinitions.put("namespace1", "definition1");
+ mockJavaTypeDefinitions.put("relationship-dict", "definition-for-relationship-dict related-to-property: extra-info-to-remove");
+
+ nodesYamlFromOxm.javaTypeDefinitions = mockJavaTypeDefinitions;
+
+ String definitions = nodesYamlFromOxm.appendDefinitions();
+
+ String expectedDefinitions = "definitions:\ndefinition1definition-for-relationship-dict";
+
+ assertEquals(expectedDefinitions,definitions);
+ }
+
+ @Test
+ public void testAppendDefinitions_NoFilter() {
+ Map<String, String> mockJavaTypeDefinitions = new HashMap<>();
+
+ mockJavaTypeDefinitions.put("namespace1", "definition1");
+ mockJavaTypeDefinitions.put("namespace2", "definition2");
+ mockJavaTypeDefinitions.put("relationship-dict", "definition-for-relationship-dict related-to-property: extra-info-to-remove");
+
+ nodesYamlFromOxm.javaTypeDefinitions = mockJavaTypeDefinitions;
+
+ String definitions = nodesYamlFromOxm.appendDefinitions();
+
+ String expectedDefinitions = "definitions:\ndefinition1definition2definition-for-relationship-dict";
+
+ assertEquals( expectedDefinitions,definitions);
+ }
+
+ @Test
+ public void testSetNodeIngestor() {
+
+ Set<Translator> translatorSet = new HashSet<>();
+ Translator mockTranslator = Mockito.mock(Translator.class);
+ translatorSet.add(mockTranslator);
+
+ NodeIngestor mockNodeIngestor = new NodeIngestor(translatorSet);
+
+ nodesYamlFromOxm.setNodeIngestor(mockNodeIngestor);
+
+ NodeIngestor result = nodesYamlFromOxm.ni;
+ assertEquals(mockNodeIngestor, result, "NodeIngestor should be set correctly.");
+ }
+
+ @Test
+ public void testSetEdgeIngestor() {
+
+ Set<Translator> translatorSet = new HashSet<>();
+ Translator mockTranslator = Mockito.mock(Translator.class);
+ translatorSet.add(mockTranslator);
+
+ EdgeIngestor mockEdgeIngestor = new EdgeIngestor(translatorSet);
+
+ nodesYamlFromOxm.setEdgeIngestor(mockEdgeIngestor);
+
+ EdgeIngestor result = nodesYamlFromOxm.ei;
+
+ assertEquals(mockEdgeIngestor, result, "EdgeIngestor should be set correctly.");
+ }
+
+ @Test
+ public void testGetCombinedJavaTypes() {
+ Map<String, Integer> mockJavaTypes = new HashMap<>();
+ mockJavaTypes.put("String", 1);
+ mockJavaTypes.put("Integer", 2);
+ nodesYamlFromOxm.setCombinedJavaTypes(mockJavaTypes);
+
+ Map<String, Integer> result = nodesYamlFromOxm.getCombinedJavaTypes();
+
+ assertEquals(mockJavaTypes, result, "The combinedJavaTypes should match.");
+ }
+
+ @Test
+ public void testSetCombinedJavaTypes() {
+ Map<String, Integer> mockJavaTypes = new HashMap<>();
+ mockJavaTypes.put("String", 1);
+ mockJavaTypes.put("Integer", 2);
+
+ nodesYamlFromOxm.setCombinedJavaTypes(mockJavaTypes);
+
+ Map<String, Integer> result = nodesYamlFromOxm.getCombinedJavaTypes();
+ assertEquals(mockJavaTypes, result, "The combinedJavaTypes map should be set correctly.");
+ }
+
+ // Adding the test cases for `versionSupportsBasePathProperty`
+
+ @Test
+ public void testVersionSupportsBasePathProperty_versionBeforeMinBasepath() {
+ // Act: Test with a version before the base path property support (e.g., v5)
+ String version = "v5";
+ boolean result = nodesYamlFromOxm.versionSupportsBasePathProperty(version);
+
+ assertTrue(result, "Version v5 should support the base path property.");
+ }
+
+ @Test
+ public void testVersionSupportsBasePathProperty_versionEqualToMinBasepath() {
+ String version = "v6";
+ boolean result = nodesYamlFromOxm.versionSupportsBasePathProperty(version);
+
+ assertTrue(result, "Version v6 should support the base path property.");
+ }
+
+ @Test
+ public void testVersionSupportsBasePathProperty_versionAfterMinBasepath() {
+ String version = "v7";
+ boolean result = nodesYamlFromOxm.versionSupportsBasePathProperty(version);
+
+ assertFalse(result, "Version v7 should NOT support the base path property.");
+ }
+
+ @Test
+ public void testVersionSupportsBasePathProperty_invalidVersionFormat() {
+ String version = "v";
+
+ assertThrows(NumberFormatException.class, () -> {
+ nodesYamlFromOxm.versionSupportsBasePathProperty(version);
+ });
+ }
+
+ // Adding test cases for `versionSupportsSwaggerDiff`
+
+ @Test
+ public void testVersionSupportsSwaggerDiff_versionEqualToSwaggerDiffStartVersion() {
+ String version = "v6";
+ boolean result = nodesYamlFromOxm.versionSupportsSwaggerDiff(version);
+
+ assertTrue(result, "Version v6 should support Swagger Diff.");
+ }
+
+ @Test
+ public void testVersionSupportsSwaggerDiff_invalidVersionFormat() {
+ String version = "v";
+
+ assertThrows(NumberFormatException.class, () -> {
+ nodesYamlFromOxm.versionSupportsSwaggerDiff(version);
+ });
+ }
+
+ @Test
+ public void testGetTopLevelPathsCheckForFalse(){
+ // Arrange: Mock XML structure and expected paths
+ String xmlContent = "<root>" +
+ "<java-attributes>" +
+ "<xml-element type=\"com.example.TopLevel1\"/>" +
+ "<xml-element type=\"com.example.TopLevel2\"/>" +
+ "</java-attributes>" +
+ "</root>";
+
+ // Set the XML content (this assumes the setXmlVersion method processes the XML)
+ nodesYamlFromOxm.setXmlVersion(xmlContent, schemaConfigVersions.getAppRootVersion());
+
+ XSDElement mockElement = Mockito.mock(XSDElement.class);
+
+ NodeList mockJavaAttributesNodeList = mockJavaAttributesNodeList();
+
+ Mockito.when(mockElement.getElementsByTagName("java-attributes")).thenReturn(mockJavaAttributesNodeList);
+
+ nodesYamlFromOxm.getTopLevelPaths(mockElement);
+
+ assertFalse(nodesYamlFromOxm.topLevelPaths.contains("TopLevel1"));
+ assertFalse(nodesYamlFromOxm.topLevelPaths.contains("TopLevel2"));
+ }
+
+ private NodeList mockJavaAttributesNodeList() {
+ NodeList mockNodeList = Mockito.mock(NodeList.class);
+
+ // Create and return the mocked NodeList containing the <xml-element> nodes
+ Element mockJavaAttributesElement = Mockito.mock(Element.class);
+
+ XSDElement mockParentElement = Mockito.mock(XSDElement.class);
+
+ Mockito.when(mockNodeList.getLength()).thenReturn(1);
+ Mockito.when(mockNodeList.item(0)).thenReturn(mockJavaAttributesElement);
+
+ // Mock behavior for the getElementsByTagName("xml-element") for the <java-attributes> node
+ NodeList mockXmlElementNodes = mockXmlElementNodes(mockJavaAttributesElement);
+ Mockito.when(mockJavaAttributesElement.getElementsByTagName("xml-element")).thenReturn(mockXmlElementNodes);
+
+ Mockito.when(mockJavaAttributesElement.getParentNode()).thenReturn(mockParentElement);
+
+ return mockNodeList;
+ }
+
+ private NodeList mockXmlElementNodes(Element parentElement) {
+ NodeList mockNodeList = Mockito.mock(NodeList.class);
+
+ Element mockElement1 = Mockito.mock(Element.class);
+ NamedNodeMap mockAttributes1 = Mockito.mock(NamedNodeMap.class);
+ Attr mockAttr1 = Mockito.mock(Attr.class);
+ Mockito.when(mockAttr1.getValue()).thenReturn("com.example.TopLevel1");
+ Mockito.when(mockAttributes1.getNamedItem("type")).thenReturn(mockAttr1);
+ Mockito.when(mockElement1.getAttributes()).thenReturn(mockAttributes1);
+ Mockito.when(mockElement1.getNodeName()).thenReturn("xml-element");
+
+ // Set the parent node for mockElement1
+ Mockito.when(mockElement1.getParentNode()).thenReturn(parentElement);
+
+ // Create and mock the second <xml-element> (TopLevel2)
+ Element mockElement2 = Mockito.mock(Element.class);
+ NamedNodeMap mockAttributes2 = Mockito.mock(NamedNodeMap.class);
+ Attr mockAttr2 = Mockito.mock(Attr.class);
+ Mockito.when(mockAttr2.getValue()).thenReturn("com.example.TopLevel2");
+ Mockito.when(mockAttributes2.getNamedItem("type")).thenReturn(mockAttr2);
+ Mockito.when(mockElement2.getAttributes()).thenReturn(mockAttributes2);
+ Mockito.when(mockElement2.getNodeName()).thenReturn("xml-element");
+
+ Mockito.when(mockElement2.getParentNode()).thenReturn(parentElement);
+
+ Mockito.when(mockNodeList.getLength()).thenReturn(2); // Ensure that getLength() returns 2
+ Mockito.when(mockNodeList.item(0)).thenReturn(mockElement1);
+ Mockito.when(mockNodeList.item(1)).thenReturn(mockElement2);
+
+ return mockNodeList;
+ }
}
--- /dev/null
+/**
+ * ============LICENSE_START=======================================================
+ * org.onap.aai
+ * ================================================================================
+ * Copyright © 2025 Deutsche Telekom. All rights reserved.
+ * ================================================================================
+ * 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.schemagen.genxsd;
+
+import org.apache.tinkerpop.gremlin.structure.Direction;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.onap.aai.edges.EdgeRule;
+import org.onap.aai.edges.enums.AAIDirection;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+class TestEdgeDescription {
+
+ private EdgeRule mockEdgeRule;
+ private EdgeDescription edgeDescription;
+
+ @BeforeEach
+ public void setUp() {
+ mockEdgeRule = mock(EdgeRule.class);
+
+ when(mockEdgeRule.getFrom()).thenReturn("fromNode");
+ when(mockEdgeRule.getTo()).thenReturn("toNode");
+ when(mockEdgeRule.getDirection()).thenReturn(Direction.valueOf("OUT"));
+ when(mockEdgeRule.getContains()).thenReturn("OUT");
+ when(mockEdgeRule.getDeleteOtherV()).thenReturn("IN");
+ when(mockEdgeRule.getPreventDelete()).thenReturn("false");
+ when(mockEdgeRule.getDescription()).thenReturn("Test description");
+ when(mockEdgeRule.getLabel()).thenReturn("label");
+
+ // Initialize EdgeDescription with mocked EdgeRule
+ edgeDescription = new EdgeDescription(mockEdgeRule);
+ }
+
+ @Test
+ public void testHasDelTarget() {
+ // Test that hasDelTarget returns true when DeleteOtherV is not "NONE"
+ assertTrue(edgeDescription.hasDelTarget());
+
+ // Test with different value for DeleteOtherV to test the false case
+ when(mockEdgeRule.getDeleteOtherV()).thenReturn("NONE");
+ assertFalse(edgeDescription.hasDelTarget());
+ }
+
+ @Test
+ public void testGetType() {
+ // Test the method for expected LineageType
+ assertEquals(EdgeDescription.LineageType.PARENT, edgeDescription.getType());
+ }
+
+ @Test
+ public void testGetDescription() {
+ assertEquals("Test description", edgeDescription.getDescription());
+ }
+
+ @Test
+ public void testGetDirection() {
+ assertEquals(AAIDirection.OUT, edgeDescription.getDirection());
+ }
+
+ @Test
+ public void testGetTo() {
+ assertEquals("toNode", edgeDescription.getTo());
+ }
+
+ @Test
+ public void testGetFrom() {
+ assertEquals("fromNode", edgeDescription.getFrom());
+ }
+
+ @Test
+ public void testGetDeleteOtherV() {
+ assertEquals("IN", edgeDescription.getDeleteOtherV());
+ }
+
+ @Test
+ public void testGetPreventDelete() {
+ assertEquals("false", edgeDescription.getPreventDelete());
+ }
+}
--- /dev/null
+/**
+ * ============LICENSE_START=======================================================
+ * org.onap.aai
+ * ================================================================================
+ * Copyright © 2025 Deutsche Telekom. All rights reserved.
+ * ================================================================================
+ * 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.schemagen.swagger;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.onap.aai.setup.SchemaConfigVersions;
+import org.onap.aai.setup.SchemaVersion;
+import java.util.*;
+import static org.junit.jupiter.api.Assertions.*;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+public class GenerateSwaggerTest {
+
+ private GenerateSwagger generateSwagger;
+ private SchemaConfigVersions mockSchemaConfigVersions;
+
+ @BeforeEach
+ void setUp() {
+ // Initialize the GenerateSwagger instance before each test
+ generateSwagger = new GenerateSwagger();
+ mockSchemaConfigVersions = mock(SchemaConfigVersions.class);
+ GenerateSwagger.schemaConfigVersions = mockSchemaConfigVersions;
+ }
+
+ @Test
+ void testGetSchemaConfigVersions() {
+ // Act
+ SchemaConfigVersions result = generateSwagger.getSchemaConfigVersions();
+
+ // Assert
+ assertNotNull(result);
+ assertEquals(mockSchemaConfigVersions, result);
+ }
+
+ @Test
+ void testConvertToApiWithValidData() {
+ // Arrange
+ Map<String, Object> pathMap = new HashMap<>();
+ Map<String, Object> httpVerbMap = new HashMap<>();
+ Map<String, Object> getMap = new HashMap<>();
+ getMap.put("tags", Arrays.asList("tag1"));
+ getMap.put("summary", "Summary of GET");
+ getMap.put("operationId", "getOp");
+
+ httpVerbMap.put("get", getMap);
+ pathMap.put("/path", httpVerbMap);
+
+ // Act
+ List<Api> apis = GenerateSwagger.convertToApi(pathMap);
+
+ // Assert
+ assertNotNull(apis);
+ assertEquals(1, apis.size());
+ Api api = apis.get(0);
+ assertEquals("/path", api.getPath());
+ assertEquals(1, api.getHttpMethods().size());
+ Api.HttpVerb httpVerb = api.getHttpMethods().get(0);
+ assertEquals("get", httpVerb.getType());
+ assertEquals("Summary of GET", httpVerb.getSummary());
+ assertEquals("getOp", httpVerb.getOperationId());
+ }
+
+ @Test
+ void testConvertToApiWithNullPathMap() {
+ // Act & Assert
+ assertThrows(IllegalArgumentException.class, () -> {
+ GenerateSwagger.convertToApi(null);
+ });
+ }
+
+ @Test
+ void testConvertToDefinitionWithValidData() {
+ // Arrange
+ Map<String, Object> definitionMap = new HashMap<>();
+ Map<String, Object> propertiesMap = new HashMap<>();
+ Map<String, Object> property = new HashMap<>();
+ property.put("description", "A sample description");
+ property.put("type", "string");
+
+ propertiesMap.put("property1", property);
+ definitionMap.put("Definition1", Map.of("properties", propertiesMap, "required", Arrays.asList("property1")));
+
+ // Act
+ List<Definition> definitions = GenerateSwagger.convertToDefinition(definitionMap);
+
+ // Assert
+ assertNotNull(definitions);
+ assertEquals(1, definitions.size());
+ Definition definition = definitions.get(0);
+ assertEquals("Definition1", definition.getDefinitionName());
+ assertEquals(1, definition.getPropertyList().size());
+ Definition.Property propertyDef = definition.getPropertyList().get(0);
+ assertEquals("property1", propertyDef.getPropertyName());
+ assertEquals("string", propertyDef.getPropertyType());
+ assertTrue(propertyDef.isRequired());
+ }
+
+ @Test
+ void testConvertToDefinitionWithNullDefinitionMap() {
+ // Act & Assert
+ assertThrows(IllegalArgumentException.class, () -> {
+ GenerateSwagger.convertToDefinition(null);
+ });
+ }
+
+ @Test
+ void testFormatDescriptionWithValidDescription() {
+ // Arrange
+ String description = "###### Header\n- Item 1\n- Item 2\n";
+
+ // Act
+ String formattedDescription = GenerateSwagger.formatDescription(description);
+
+ // Assert
+ assertTrue(formattedDescription.contains("<h6 id=\"header\">Header</h6>"));
+ assertTrue(formattedDescription.contains("<li>Item 1</li>"));
+ assertTrue(formattedDescription.contains("<li>Item 2</li>"));
+ }
+
+ @Test
+ void testFormatDescriptionWithEmptyDescription() {
+ // Arrange
+ String description = "";
+ String formattedDescription = GenerateSwagger.formatDescription(description);
+ assertEquals("<p></p>", formattedDescription);
+ }
+
+ @Test
+ void testFormatDescriptionWithComplexInput() {
+ // Arrange
+ String description = "###### Header\nThis is a description with a [link](http://example.com).\n";
+ String formattedDescription = GenerateSwagger.formatDescription(description);
+ assertTrue(formattedDescription.contains("<h6 id=\"header\">Header</h6>"));
+ assertFalse(formattedDescription.contains("<p>This is a description with a <a href=\"http://example.com\">link</a>.</p>"));
+ }
+
+ @Test
+ void testConvertToApiConsumes() {
+ // Arrange
+ List<String> consumesList = Arrays.asList("application/json");
+ Map<String, Object> httpVerbMap = new HashMap<>();
+ Map<String, Object> getMap = new HashMap<>();
+ getMap.put("consumes", consumesList);
+ httpVerbMap.put("get", getMap);
+
+ Map<String, Object> pathMap = new HashMap<>();
+ pathMap.put("/path", httpVerbMap);
+
+ // Act
+ List<Api> apis = GenerateSwagger.convertToApi(pathMap);
+
+ // Assert
+ assertNotNull(apis);
+ assertEquals(1, apis.size());
+ Api api = apis.get(0);
+ Api.HttpVerb httpVerb = api.getHttpMethods().get(0);
+
+ assertEquals(consumesList, httpVerb.getConsumes());
+ assertTrue(httpVerb.isConsumerEnabled());
+ }
+
+ @Test
+ void testConvertToApiProduces() {
+ // Arrange
+ List<String> producesList = Arrays.asList("application/json");
+ Map<String, Object> httpVerbMap = new HashMap<>();
+ Map<String, Object> getMap = new HashMap<>();
+ getMap.put("produces", producesList);
+ httpVerbMap.put("get", getMap);
+
+ Map<String, Object> pathMap = new HashMap<>();
+ pathMap.put("/path", httpVerbMap);
+
+ // Act
+ List<Api> apis = GenerateSwagger.convertToApi(pathMap);
+
+ // Assert
+ assertNotNull(apis);
+ assertEquals(1, apis.size());
+ Api api = apis.get(0);
+ Api.HttpVerb httpVerb = api.getHttpMethods().get(0);
+
+ assertEquals(producesList, httpVerb.getProduces());
+ }
+
+ @Test
+ void testConvertToApiParametersWithBody() {
+ // Arrange
+ Map<String, Object> bodyParam = new LinkedHashMap<>();
+ bodyParam.put("name", "body");
+ bodyParam.put("description", "Request body [somefile.json]");
+
+ Map<String, Object> schemaMap = new LinkedHashMap<>();
+ schemaMap.put("$ref", "patchDefinitions/mySchema");
+
+ bodyParam.put("schema", schemaMap);
+
+ List<Map<String, Object>> parameters = Arrays.asList(bodyParam);
+ Map<String, Object> httpVerbMap = new LinkedHashMap<>();
+ Map<String, Object> getMap = new LinkedHashMap<>();
+ getMap.put("parameters", parameters);
+ httpVerbMap.put("get", getMap);
+
+ Map<String, Object> pathMap = new LinkedHashMap<>();
+ pathMap.put("/path", httpVerbMap);
+
+ // Act
+ List<Api> apis = GenerateSwagger.convertToApi(pathMap);
+
+ // Assert
+ assertNotNull(apis);
+ assertEquals(1, apis.size());
+ Api api = apis.get(0);
+ Api.HttpVerb httpVerb = api.getHttpMethods().get(0);
+
+ // Assert that the body parameters are handled correctly
+ assertTrue(httpVerb.isBodyParametersEnabled());
+ assertEquals(bodyParam, httpVerb.getBodyParameters());
+ assertEquals("definitions/mySchema", httpVerb.getSchemaLink());
+ assertEquals("/mySchema", httpVerb.getSchemaType());
+ }
+
+ @Test
+ void testConvertToApiParametersWithoutBody() {
+ // Arrange
+ Map<String, Object> param1 = new HashMap<>();
+ param1.put("name", "param1");
+ param1.put("description", "First parameter");
+
+ List<Map<String, Object>> parameters = Arrays.asList(param1);
+ Map<String, Object> httpVerbMap = new HashMap<>();
+ Map<String, Object> getMap = new HashMap<>();
+ getMap.put("parameters", parameters);
+ httpVerbMap.put("get", getMap);
+
+ Map<String, Object> pathMap = new HashMap<>();
+ pathMap.put("/path", httpVerbMap);
+
+ // Act
+ List<Api> apis = GenerateSwagger.convertToApi(pathMap);
+
+ // Assert
+ assertNotNull(apis);
+ assertEquals(1, apis.size());
+ Api api = apis.get(0);
+ Api.HttpVerb httpVerb = api.getHttpMethods().get(0);
+
+ // Assert parameters are handled correctly
+ assertTrue(httpVerb.isParametersEnabled());
+ assertEquals(1, httpVerb.getParameters().size());
+ }
+
+ @Test
+ void testConvertToApiResponses() {
+ // Arrange
+ Map<String, Object> responseMap = new HashMap<>();
+ Map<String, Object> schemaMap = new HashMap<>();
+ schemaMap.put("$ref", "getDefinitions/myResponseSchema");
+
+ responseMap.put("200", Map.of("description", "Success", "schema", schemaMap));
+
+ Map<String, Object> httpVerbMap = new HashMap<>();
+ Map<String, Object> getMap = new HashMap<>();
+ getMap.put("responses", responseMap);
+ httpVerbMap.put("get", getMap);
+
+ Map<String, Object> pathMap = new HashMap<>();
+ pathMap.put("/path", httpVerbMap);
+
+ // Act
+ List<Api> apis = GenerateSwagger.convertToApi(pathMap);
+
+ // Assert
+ assertNotNull(apis);
+ assertEquals(1, apis.size());
+ Api api = apis.get(0);
+ Api.HttpVerb httpVerb = api.getHttpMethods().get(0);
+
+ assertTrue(httpVerb.isHasReturnSchema());
+ assertEquals("definitions/myResponseSchema", httpVerb.getReturnSchemaLink());
+ }
+
+ @Test
+ void testConvertToApiNoResponses() {
+ // Arrange
+ Map<String, Object> httpVerbMap = new LinkedHashMap<>();
+ Map<String, Object> getMap = new LinkedHashMap<>();
+ getMap.put("responses", new LinkedHashMap<>()); // Empty responses map
+
+ httpVerbMap.put("get", getMap);
+ Map<String, Object> pathMap = new LinkedHashMap<>();
+ pathMap.put("/path", httpVerbMap);
+
+ // Act
+ List<Api> apis = GenerateSwagger.convertToApi(pathMap);
+
+ // Assert
+ assertNotNull(apis);
+ Api api = apis.get(0);
+ Api.HttpVerb httpVerb = api.getHttpMethods().get(0);
+
+ // Assert that the responses list is empty
+ assertTrue(httpVerb.getResponses().isEmpty()); // Check if the list is empty
+ }
+}
Code Review / aai / schema-service.git / commitdiff