2 files changed, 68 insertions, 57 deletions

diff --git a/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/init/SubscriptionModelLoader.java b/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/init/SubscriptionModelLoader.java
index 705c9d2664..231ba75b5d 100644
--- a/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/init/SubscriptionModelLoader.java
+++ b/cps-ncmp-service/src/main/java/org/onap/cps/ncmp/init/SubscriptionModelLoader.java
@@ -24,7 +24,6 @@ import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
 import java.time.OffsetDateTime;
 import java.util.Map;
-import lombok.NonNull;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
 import org.onap.cps.api.CpsAdminService;
@@ -45,6 +44,8 @@ public class SubscriptionModelLoader implements ModelLoader {
     private final CpsAdminService cpsAdminService;
     private final CpsModuleService cpsModuleService;
     private final CpsDataService cpsDataService;
+    private static final String SUBSCRIPTION_MODEL_FILENAME = "subscription.yang";
+    private static final String SUBSCRIPTION_MODEL_RESOURCE_PATH = "model/" + SUBSCRIPTION_MODEL_FILENAME;
     private static final String SUBSCRIPTION_DATASPACE_NAME = "NCMP-Admin";
     private static final String SUBSCRIPTION_ANCHOR_NAME = "AVC-Subscriptions";
     private static final String SUBSCRIPTION_SCHEMASET_NAME = "subscriptions";
@@ -59,10 +60,10 @@ public class SubscriptionModelLoader implements ModelLoader {
      * @param applicationReadyEvent the event to respond to
      */
     @Override
-    public void onApplicationEvent(@NonNull final ApplicationReadyEvent applicationReadyEvent) {
+    public void onApplicationEvent(final ApplicationReadyEvent applicationReadyEvent) {
         try {
             if (subscriptionModelLoaderEnabled) {
-                onboardSubscriptionModel();
+                onboardSubscriptionModel(createYangResourceToContentMap());
             } else {
                 log.info("Subscription Model Loader is disabled");
             }
@@ -75,21 +76,18 @@ public class SubscriptionModelLoader implements ModelLoader {
     /**
      * Method to onboard subscription model for NCMP.
      */
-    private void onboardSubscriptionModel() {
-        final Map<String, String> yangResourceContentMap = createYangResourceToContentMap();
-        if (!yangResourceContentMap.get("subscription.yang").isEmpty()) {
-            createSchemaSet(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_SCHEMASET_NAME, yangResourceContentMap);
-            createAnchor(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_SCHEMASET_NAME, SUBSCRIPTION_ANCHOR_NAME);
-            createTopLevelDataNode(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_ANCHOR_NAME,
-                SUBSCRIPTION_REGISTRY_DATANODE_NAME);
-        }
+    private void onboardSubscriptionModel(final Map<String, String> yangResourceContentMap) {
+        createSchemaSet(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_SCHEMASET_NAME, yangResourceContentMap);
+        createAnchor(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_SCHEMASET_NAME, SUBSCRIPTION_ANCHOR_NAME);
+        createTopLevelDataNode(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_ANCHOR_NAME,
+            SUBSCRIPTION_REGISTRY_DATANODE_NAME);
     }
 
 
     @Override
     public boolean createSchemaSet(final String dataspaceName,
-                                final String schemaSetName,
-                                final Map<String, String> yangResourceContentMap) {
+                                   final String schemaSetName,
+                                   final Map<String, String> yangResourceContentMap) {
         try {
             cpsModuleService.createSchemaSet(dataspaceName, schemaSetName, yangResourceContentMap);
         } catch (final AlreadyDefinedException exception) {
@@ -129,24 +127,24 @@ public class SubscriptionModelLoader implements ModelLoader {
         try {
             cpsDataService.saveData(dataspaceName, anchorName, nodeData, OffsetDateTime.now());
         } catch (final AlreadyDefinedException exception) {
-            log.info("Creating new data node {} failed as data node already exists", dataNodeName);
+            log.info("Creating new data node '{}' failed as data node already exists", dataNodeName);
         } catch (final Exception exception) {
             log.debug("Creating data node for subscription model failed: {}", exception.getMessage());
             throw new NcmpStartUpException("Creating data node failed", exception.getMessage());
         }
     }
 
-    private String getFileContentAsString() {
-        try (InputStream inputStream = getClass().getClassLoader()
-                .getResourceAsStream("model/subscription.yang")) {
+    private String getFileContentAsString(final String fileName) {
+        try (InputStream inputStream = getClass().getClassLoader().getResourceAsStream(fileName)) {
             return new String(inputStream.readAllBytes(), StandardCharsets.UTF_8);
         } catch (final Exception exception) {
-            log.debug("Onboarding failed as unable to read file: {}", exception.getCause().toString());
-            throw new NcmpStartUpException("Onboarding failed as unable to read file: {}", exception.getMessage());
+            final String message = String.format("Onboarding failed as unable to read file: %s", fileName);
+            log.debug(message);
+            throw new NcmpStartUpException(message, exception.getMessage());
         }
     }
 
     private Map<String, String> createYangResourceToContentMap() {
-        return Map.of("subscription.yang", getFileContentAsString());
+        return Map.of(SUBSCRIPTION_MODEL_FILENAME, getFileContentAsString(SUBSCRIPTION_MODEL_RESOURCE_PATH));
     }
 }
diff --git a/cps-ncmp-service/src/test/groovy/org/onap/cps/ncmp/init/SubscriptionModelLoaderSpec.groovy b/cps-ncmp-service/src/test/groovy/org/onap/cps/ncmp/init/SubscriptionModelLoaderSpec.groovy
index 650916e5c9..aa8bc53c9d 100644
--- a/cps-ncmp-service/src/test/groovy/org/onap/cps/ncmp/init/SubscriptionModelLoaderSpec.groovy
+++ b/cps-ncmp-service/src/test/groovy/org/onap/cps/ncmp/init/SubscriptionModelLoaderSpec.groovy
@@ -35,6 +35,7 @@ import org.onap.cps.spi.exceptions.SchemaSetNotFoundException
 import org.springframework.boot.SpringApplication
 import org.slf4j.LoggerFactory
 import org.springframework.boot.context.event.ApplicationReadyEvent
+import org.springframework.context.annotation.AnnotationConfigApplicationContext
 import spock.lang.Specification
 
 class SubscriptionModelLoaderSpec extends Specification {
@@ -44,30 +45,31 @@ class SubscriptionModelLoaderSpec extends Specification {
     def mockCpsDataService = Mock(CpsDataService)
     def objectUnderTest = new SubscriptionModelLoader(mockCpsAdminService, mockCpsModuleService, mockCpsDataService)
 
-    def SUBSCRIPTION_DATASPACE_NAME = objectUnderTest.SUBSCRIPTION_DATASPACE_NAME
-    def SUBSCRIPTION_ANCHOR_NAME = objectUnderTest.SUBSCRIPTION_ANCHOR_NAME
-    def SUBSCRIPTION_SCHEMASET_NAME = objectUnderTest.SUBSCRIPTION_SCHEMASET_NAME
-    def SUBSCRIPTION_REGISTRY_DATANODE_NAME = objectUnderTest.SUBSCRIPTION_REGISTRY_DATANODE_NAME
-
     def sampleYangContentMap = ['subscription.yang':'module subscription { *sample content* }']
 
-    def applicationReadyEvent = new ApplicationReadyEvent(new SpringApplication(), null, null, null)
+    def applicationContext = new AnnotationConfigApplicationContext()
+
+    def applicationReadyEvent = new ApplicationReadyEvent(new SpringApplication(), null, applicationContext, null)
 
+    def yangResourceToContentMap
     def logger
     def appender
 
     @BeforeEach
     void setup() {
+        yangResourceToContentMap = objectUnderTest.createYangResourceToContentMap()
         logger = (Logger) LoggerFactory.getLogger(objectUnderTest.getClass())
         appender = new ListAppender()
         logger.setLevel(Level.DEBUG)
         appender.start()
         logger.addAppender(appender)
+        applicationContext.refresh()
     }
 
     @AfterEach
     void teardown() {
         ((Logger) LoggerFactory.getLogger(SubscriptionModelLoader.class)).detachAndStopAllAppenders()
+        applicationContext.close()
     }
 
     def 'Onboard subscription model successfully via application ready event'() {
@@ -76,11 +78,11 @@ class SubscriptionModelLoaderSpec extends Specification {
         and: 'the application is ready'
             objectUnderTest.onApplicationEvent(applicationReadyEvent)
         then: 'the module service to create schema set is called once'
-            1 * mockCpsModuleService.createSchemaSet(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_SCHEMASET_NAME,sampleYangContentMap)
+            1 * mockCpsModuleService.createSchemaSet('NCMP-Admin', 'subscriptions',sampleYangContentMap)
         and: 'the admin service to create an anchor set is called once'
-            1 * mockCpsAdminService.createAnchor(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_SCHEMASET_NAME, SUBSCRIPTION_ANCHOR_NAME)
+            1 * mockCpsAdminService.createAnchor('NCMP-Admin', 'subscriptions', 'AVC-Subscriptions')
         and: 'the data service to create a top level datanode is called once'
-            1 * mockCpsDataService.saveData(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_ANCHOR_NAME, '{"' + SUBSCRIPTION_REGISTRY_DATANODE_NAME + '":{}}', _)
+            1 * mockCpsDataService.saveData('NCMP-Admin', 'AVC-Subscriptions', '{"subscription-registry":{}}', _)
     }
 
     def 'No subscription model onboarding when subscription model loader is disabled' () {
@@ -96,10 +98,20 @@ class SubscriptionModelLoaderSpec extends Specification {
             0 * mockCpsDataService.saveData(*_)
     }
 
+    def 'Exception occurred while schema set creation' () {
+        given: 'creating a schema set throws an exception'
+            mockCpsModuleService.createSchemaSet(*_) >>  { throw new DataValidationException(*_) }
+        and: 'model loader is enabled'
+            objectUnderTest.subscriptionModelLoaderEnabled = true
+        when: 'application is ready'
+            objectUnderTest.onApplicationEvent(applicationReadyEvent)
+        then: 'the admin service to create an anchor set was not called'
+            0 * mockCpsAdminService.createAnchor(*_)
+        and: 'the data service to create a top level datanode was not called'
+            0 * mockCpsDataService.saveData(*_)
+    }
 
     def 'Create schema set from model file'() {
-        given: 'the method to create yang resource to content map returns the correct map'
-            def yangResourceToContentMap = objectUnderTest.createYangResourceToContentMap()
         when: 'the method to create schema set is called with the following parameters'
             objectUnderTest.createSchemaSet("myDataspace", "mySchemaSet", yangResourceToContentMap)
         then: 'yang resource to content map is as expected'
@@ -109,25 +121,20 @@ class SubscriptionModelLoaderSpec extends Specification {
     }
 
     def 'Create schema set fails due to AlreadyDefined exception'() {
-        given: 'the method to create yang resource to content map returns the correct map'
-            def yangResourceToContentMap = objectUnderTest.createYangResourceToContentMap()
-        and: 'creating a schema set throws an exception as it already exists'
-            mockCpsModuleService.createSchemaSet(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_SCHEMASET_NAME, yangResourceToContentMap) >>
-                    { throw AlreadyDefinedException.forSchemaSet(SUBSCRIPTION_SCHEMASET_NAME, "sampleContextName", null) }
+        given: 'creating a schema set throws an exception as it already exists'
+            mockCpsModuleService.createSchemaSet('NCMP-Admin', 'subscriptions', yangResourceToContentMap) >>
+                    { throw AlreadyDefinedException.forSchemaSet('subscriptions', "sampleContextName", null) }
         when: 'the method to onboard model is called'
-            objectUnderTest.onboardSubscriptionModel()
+            objectUnderTest.onboardSubscriptionModel(yangResourceToContentMap)
         then: 'the admin service to create an anchor set is then called once'
-            1 * mockCpsAdminService.createAnchor(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_SCHEMASET_NAME, SUBSCRIPTION_ANCHOR_NAME)
+            1 * mockCpsAdminService.createAnchor('NCMP-Admin', 'subscriptions', 'AVC-Subscriptions')
     }
 
     def 'Create schema set fails due to any other exception'() {
-        given: 'the method to create yang resource to content map returns the correct map'
-            def yangResourceToContentMap = objectUnderTest.createYangResourceToContentMap()
-        and: 'creating a schema set throws an exception'
-            mockCpsModuleService.createSchemaSet(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_SCHEMASET_NAME, yangResourceToContentMap) >>
-                    { throw new NcmpStartUpException("Creating schema set failed", "") }
+        given: 'creating a schema set throws an exception'
+            mockCpsModuleService.createSchemaSet(*_) >> { throw new NcmpStartUpException("Creating schema set failed", "") }
         when: 'the method to onboard model is called'
-            objectUnderTest.onboardSubscriptionModel()
+            objectUnderTest.onboardSubscriptionModel(yangResourceToContentMap)
         then: 'the log message contains the correct exception message'
             def debugMessage = appender.list[0].toString()
             assert debugMessage.contains("Creating schema set failed")
@@ -137,20 +144,23 @@ class SubscriptionModelLoaderSpec extends Specification {
 
     def 'Create anchor fails due to AlreadyDefined exception'() {
         given: 'creating anchor throws an exception as it already exists'
-            mockCpsAdminService.createAnchor(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_SCHEMASET_NAME, SUBSCRIPTION_ANCHOR_NAME) >>
-                    { throw AlreadyDefinedException.forSchemaSet(SUBSCRIPTION_SCHEMASET_NAME, "sampleContextName", null) }
+            mockCpsAdminService.createAnchor(*_) >>
+                    { throw AlreadyDefinedException.forSchemaSet('subscriptions', "sampleContextName", null) }
         when: 'the method to onboard model is called'
-            objectUnderTest.onboardSubscriptionModel()
+            objectUnderTest.onboardSubscriptionModel(yangResourceToContentMap)
         then: 'no exception thrown'
             noExceptionThrown()
+        and: 'the log message contains the correct exception message'
+            def infoMessage = appender.list[0].toString()
+            assert infoMessage.contains("already exists")
     }
 
     def 'Create anchor fails due to any other exception'() {
         given: 'creating an anchor failed'
-            mockCpsAdminService.createAnchor(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_SCHEMASET_NAME, SUBSCRIPTION_ANCHOR_NAME) >>
-                    { throw new SchemaSetNotFoundException(SUBSCRIPTION_DATASPACE_NAME, SUBSCRIPTION_SCHEMASET_NAME) }
+            mockCpsAdminService.createAnchor(*_) >>
+                    { throw new SchemaSetNotFoundException('NCMP-Admin', 'subscriptions') }
         when: 'the method to onboard model is called'
-            objectUnderTest.onboardSubscriptionModel()
+            objectUnderTest.onboardSubscriptionModel(yangResourceToContentMap)
         then: 'the log message contains the correct exception message'
             def debugMessage = appender.list[0].toString()
             assert debugMessage.contains("Schema Set not found")
@@ -161,11 +171,14 @@ class SubscriptionModelLoaderSpec extends Specification {
     def 'Create top level node fails due to an AlreadyDefined exception'() {
         given: 'the saving of the node data will throw an Already Defined exception'
             mockCpsDataService.saveData(*_) >>
-                { throw AlreadyDefinedException.forDataNode('/xpath', "sampleContextName", null) }
+                    { throw AlreadyDefinedException.forDataNode('/xpath', "sampleContextName", null) }
         when: 'the method to onboard model is called'
-            objectUnderTest.onboardSubscriptionModel()
+            objectUnderTest.onboardSubscriptionModel(yangResourceToContentMap)
         then: 'no exception thrown'
             noExceptionThrown()
+        and: 'the log message contains the correct exception message'
+            def infoMessage = appender.list[0].toString()
+            assert infoMessage.contains("already exists")
     }
 
     def 'Create top level node fails due to any other exception'() {
@@ -173,7 +186,7 @@ class SubscriptionModelLoaderSpec extends Specification {
             mockCpsDataService.saveData(*_) >>
                 { throw new DataValidationException("Invalid JSON", "JSON Data is invalid") }
         when: 'the method to onboard model is called'
-            objectUnderTest.onboardSubscriptionModel()
+            objectUnderTest.onboardSubscriptionModel(yangResourceToContentMap)
         then: 'the log message contains the correct exception message'
             def debugMessage = appender.list[0].toString()
             assert debugMessage.contains("Creating data node for subscription model failed: Invalid JSON")
@@ -183,8 +196,8 @@ class SubscriptionModelLoaderSpec extends Specification {
 
     def 'Get file content as string'() {
         when: 'the method to get yang content is called'
-            def response = objectUnderTest.getFileContentAsString()
-        then: 'the response is as expected'
-            assert response == 'module subscription { *sample content* }'
+            objectUnderTest.getFileContentAsString('NonExistingFile')
+        then: 'exception is thrown'
+            thrown(NcmpStartUpException)
     }
-}
\ No newline at end of file
+}