X-Git-Url: https://gerrit.onap.org/r/gitweb?a=blobdiff_plain;f=cps-service%2Fsrc%2Ftest%2Fgroovy%2Forg%2Fonap%2Fcps%2Fapi%2Fimpl%2FCpsModuleServiceImplSpec.groovy;h=2bb0e63ab245f96cb23ad6614d99a2b97a3e237f;hb=0fa2fabeec18763bab060d85f5123bceff8ee34c;hp=2c23aa1bc8d821c3da279245627ec482d1cc862e;hpb=bd8ab2fc4737aebada59962baed8b35d4f86dd1c;p=cps.git diff --git a/cps-service/src/test/groovy/org/onap/cps/api/impl/CpsModuleServiceImplSpec.groovy b/cps-service/src/test/groovy/org/onap/cps/api/impl/CpsModuleServiceImplSpec.groovy index 2c23aa1bc..2bb0e63ab 100644 --- a/cps-service/src/test/groovy/org/onap/cps/api/impl/CpsModuleServiceImplSpec.groovy +++ b/cps-service/src/test/groovy/org/onap/cps/api/impl/CpsModuleServiceImplSpec.groovy @@ -1,8 +1,9 @@ /* - * ============LICENSE_START======================================================= - * Copyright (C) 2020-2021 Nordix Foundation + * ============LICENSE_START======================================================= + * Copyright (C) 2020-2023 Nordix Foundation * Modifications Copyright (C) 2020-2021 Pantheon.tech - * Modifications Copyright (C) 2020-2021 Bell Canada. + * Modifications Copyright (C) 2020-2022 Bell Canada. + * Modifications Copyright (C) 2022 TechMahindra Ltd. * ================================================================================ * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. @@ -23,35 +24,30 @@ package org.onap.cps.api.impl import org.onap.cps.TestUtils +import org.onap.cps.api.CpsAdminService import org.onap.cps.spi.CpsModulePersistenceService import org.onap.cps.spi.exceptions.ModelValidationException -import org.onap.cps.spi.model.ExtendedModuleReference +import org.onap.cps.spi.exceptions.SchemaSetInUseException +import org.onap.cps.spi.utils.CpsValidator +import org.onap.cps.spi.model.Anchor import org.onap.cps.spi.model.ModuleReference -import org.spockframework.spring.SpringBean -import org.springframework.beans.factory.annotation.Autowired -import org.springframework.boot.test.context.SpringBootTest -import org.springframework.cache.CacheManager -import org.springframework.cache.annotation.EnableCaching -import org.springframework.cache.caffeine.CaffeineCacheManager -import org.springframework.test.context.ContextConfiguration +import org.onap.cps.spi.model.SchemaSet +import org.onap.cps.yang.TimedYangTextSchemaSourceSetBuilder +import org.onap.cps.yang.YangTextSchemaSourceSet +import org.onap.cps.yang.YangTextSchemaSourceSetBuilder import spock.lang.Specification - import static org.onap.cps.spi.CascadeDeleteAllowed.CASCADE_DELETE_ALLOWED import static org.onap.cps.spi.CascadeDeleteAllowed.CASCADE_DELETE_PROHIBITED -@SpringBootTest -@EnableCaching -@ContextConfiguration(classes = [YangTextSchemaSourceSetCache.class, CpsModuleServiceImpl.class]) class CpsModuleServiceImplSpec extends Specification { - @SpringBean - CpsModulePersistenceService mockModuleStoreService = Mock() - - @SpringBean - CacheManager cacheManager = new CaffeineCacheManager("yangSchema") + def mockCpsModulePersistenceService = Mock(CpsModulePersistenceService) + def mockCpsAdminService = Mock(CpsAdminService) + def mockYangTextSchemaSourceSetCache = Mock(YangTextSchemaSourceSetCache) + def mockCpsValidator = Mock(CpsValidator) + def timedYangTextSchemaSourceSetBuilder = new TimedYangTextSchemaSourceSetBuilder() - @Autowired - CpsModuleServiceImpl objectUnderTest + def objectUnderTest = new CpsModuleServiceImpl(mockCpsModulePersistenceService, mockYangTextSchemaSourceSetCache, mockCpsAdminService, mockCpsValidator,timedYangTextSchemaSourceSetBuilder) def 'Create schema set.'() { given: 'Valid yang resource as name-to-content map' @@ -59,18 +55,21 @@ class CpsModuleServiceImplSpec extends Specification { when: 'Create schema set method is invoked' objectUnderTest.createSchemaSet('someDataspace', 'someSchemaSet', yangResourcesNameToContentMap) then: 'Parameters are validated and processing is delegated to persistence service' - 1 * mockModuleStoreService.storeSchemaSet('someDataspace', 'someSchemaSet', yangResourcesNameToContentMap) + 1 * mockCpsModulePersistenceService.storeSchemaSet('someDataspace', 'someSchemaSet', yangResourcesNameToContentMap) + and: 'the CpsValidator is called on the dataspaceName and schemaSetName' + 1 * mockCpsValidator.validateNameCharacters('someDataspace', 'someSchemaSet') } def 'Create schema set from new modules and existing modules.'() { given: 'a list of existing modules module reference' - def moduleReferenceForExistingModule = new ExtendedModuleReference("test", "test.org", "2021-10-12") + def moduleReferenceForExistingModule = new ModuleReference("test", "2021-10-12","test.org") def listOfExistingModulesModuleReference = [moduleReferenceForExistingModule] when: 'create schema set from modules method is invoked' objectUnderTest.createSchemaSetFromModules("someDataspaceName", "someSchemaSetName", [newModule: "newContent"], listOfExistingModulesModuleReference) then: 'processing is delegated to persistence service' - 1 * mockModuleStoreService.storeSchemaSetFromModules("someDataspaceName", "someSchemaSetName", [newModule: "newContent"], listOfExistingModulesModuleReference) - + 1 * mockCpsModulePersistenceService.storeSchemaSetFromModules("someDataspaceName", "someSchemaSetName", [newModule: "newContent"], listOfExistingModulesModuleReference) + and: 'the CpsValidator is called on the dataspaceName and schemaSetName' + 1 * mockCpsValidator.validateNameCharacters('someDataspaceName', 'someSchemaSetName') } def 'Create schema set from invalid resources'() { @@ -85,51 +84,128 @@ class CpsModuleServiceImplSpec extends Specification { def 'Get schema set by name and dataspace.'() { given: 'an already present schema set' def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap('bookstore.yang') - mockModuleStoreService.getYangSchemaResources('someDataspace', 'someSchemaSet') >> yangResourcesNameToContentMap + and: 'yang resource cache returns the expected schema set' + mockYangTextSchemaSourceSetCache.get('someDataspace', 'someSchemaSet') >> YangTextSchemaSourceSetBuilder.of(yangResourcesNameToContentMap) when: 'get schema set method is invoked' def result = objectUnderTest.getSchemaSet('someDataspace', 'someSchemaSet') then: 'the correct schema set is returned' result.getName().contains('someSchemaSet') result.getDataspaceName().contains('someDataspace') - result.getExtendedModuleReferences().contains(new ExtendedModuleReference('stores', 'org:onap:ccsdk:sample', '2020-09-15')) + result.getModuleReferences().contains(new ModuleReference('stores', '2020-09-15', 'org:onap:ccsdk:sample')) + and: 'the CpsValidator is called on the dataspaceName and schemaSetName' + 1 * mockCpsValidator.validateNameCharacters('someDataspace', 'someSchemaSet') } - def 'Schema set caching.'() { - given: 'an schema set' - def yangResourcesNameToContentMap = TestUtils.getYangResourcesAsMap('bookstore.yang') - when: 'get schema set method is invoked twice' - 2.times { - objectUnderTest.getSchemaSet('someDataspace', 'someSchemaSet') - } - then: 'the persistency service called only once' - 1 * mockModuleStoreService.getYangSchemaResources('someDataspace', 'someSchemaSet') >> yangResourcesNameToContentMap + def 'Get schema sets by dataspace name.'() { + given: 'two already present schema sets' + def moduleReference = new ModuleReference('sample1', '2022-12-07') + def sampleSchemaSet1 = new SchemaSet('testSchemaSet1', 'testDataspace', [moduleReference]) + def sampleSchemaSet2 = new SchemaSet('testSchemaSet2', 'testDataspace', [moduleReference]) + and: 'the persistence service returns the created schema sets' + mockCpsModulePersistenceService.getSchemaSetsByDataspaceName('testDataspace') >> [sampleSchemaSet1, sampleSchemaSet2] + and: 'yang resource cache always returns a schema source set' + def mockYangTextSchemaSourceSet = Mock(YangTextSchemaSourceSet) + mockYangTextSchemaSourceSetCache.get('testDataspace', _) >> mockYangTextSchemaSourceSet + when: 'get schema sets method is invoked' + def result = objectUnderTest.getSchemaSets('testDataspace') + then: 'the correct schema sets are returned' + assert result.size() == 2 + assert result.containsAll(sampleSchemaSet1, sampleSchemaSet2) + and: 'the Cps Validator is called on the dataspaceName' + 1 * mockCpsValidator.validateNameCharacters('testDataspace') } - def 'Delete set by name and dataspace with #cascadeDeleteOption.'() { - when: 'schema set deletion is requested' - objectUnderTest.deleteSchemaSet(dataspaceName, schemaSetname, cascadeDeleteOption) - then: 'persistence service method is invoked with same parameters' - mockModuleStoreService.deleteSchemaSet(dataspaceName, schemaSetname, cascadeDeleteOption) + def 'Delete schema-set when cascade is allowed.'() { + given: '#numberOfAnchors anchors are associated with schemaset' + def associatedAnchors = createAnchors(numberOfAnchors) + mockCpsAdminService.getAnchors('my-dataspace', 'my-schemaset') >> associatedAnchors + when: 'schema set deletion is requested with cascade allowed' + objectUnderTest.deleteSchemaSet('my-dataspace', 'my-schemaset', CASCADE_DELETE_ALLOWED) + then: 'anchor deletion is called #numberOfAnchors times' + numberOfAnchors * mockCpsAdminService.deleteAnchor('my-dataspace', _) + and: 'persistence service method is invoked with same parameters' + 1 * mockCpsModulePersistenceService.deleteSchemaSet('my-dataspace', 'my-schemaset') + and: 'schema set will be removed from the cache' + 1 * mockYangTextSchemaSourceSetCache.removeFromCache('my-dataspace', 'my-schemaset') + and: 'orphan yang resources are deleted' + 1 * mockCpsModulePersistenceService.deleteUnusedYangResourceModules() + and: 'the CpsValidator is called on the dataspaceName and schemaSetName' + 1 * mockCpsValidator.validateNameCharacters('my-dataspace', _) where: 'following parameters are used' - dataspaceName | schemaSetname | cascadeDeleteOption - 'dataspace-1' | 'schemas-set-1' | CASCADE_DELETE_ALLOWED - 'dataspace-2' | 'schemas-set-2' | CASCADE_DELETE_PROHIBITED + numberOfAnchors << [0, 3] } - def 'Get all yang resources module references.'(){ - given: 'an already present module reference' - def moduleReferences = [new ExtendedModuleReference()] - mockModuleStoreService.getYangResourceModuleReferences('someDataspaceName') >> moduleReferences - expect: 'the list provided by persistence service is returned as result' - objectUnderTest.getYangResourceModuleReferences('someDataspaceName') == moduleReferences + def 'Delete schema-set when cascade is prohibited.'() { + given: 'no anchors are associated with schemaset' + mockCpsAdminService.getAnchors('my-dataspace', 'my-schemaset') >> Collections.emptyList() + when: 'schema set deletion is requested with cascade allowed' + objectUnderTest.deleteSchemaSet('my-dataspace', 'my-schemaset', CASCADE_DELETE_PROHIBITED) + then: 'no anchors are deleted' + 0 * mockCpsAdminService.deleteAnchor(_, _) + and: 'persistence service method is invoked with same parameters' + 1 * mockCpsModulePersistenceService.deleteSchemaSet('my-dataspace', 'my-schemaset') + and: 'schema set will be removed from the cache' + 1 * mockYangTextSchemaSourceSetCache.removeFromCache('my-dataspace', 'my-schemaset') + and: 'orphan yang resources are deleted' + 1 * mockCpsModulePersistenceService.deleteUnusedYangResourceModules() + and: 'the CpsValidator is called on the dataspaceName and schemaSetName' + 1 * mockCpsValidator.validateNameCharacters('my-dataspace', 'my-schemaset') + } + + def 'Delete schema-set when cascade is prohibited and schema-set has anchors.'() { + given: '2 anchors are associated with schemaset' + mockCpsAdminService.getAnchors('my-dataspace', 'my-schemaset') >> createAnchors(2) + when: 'schema set deletion is requested with cascade allowed' + objectUnderTest.deleteSchemaSet('my-dataspace', 'my-schemaset', CASCADE_DELETE_PROHIBITED) + then: 'Schema-Set in Use exception is thrown' + thrown(SchemaSetInUseException) } + def createAnchors(int anchorCount) { + def anchors = [] + (0..> moduleReferences + when: 'get yang resource module references is called' + def result = objectUnderTest.getYangResourceModuleReferences('someDataspaceName') + then: 'the list provided by persistence service is returned as result' + result == moduleReferences + and: 'the CpsValidator is called on the dataspaceName and schemaSetName' + 1 * mockCpsValidator.validateNameCharacters('someDataspaceName') + } + + def 'Get all yang resources module references for the given dataspace name and anchor name.'() { given: 'the module store service service returns a list module references' def moduleReferences = [new ModuleReference()] - mockModuleStoreService.getYangResourceModuleReferences('someDataspaceName', 'someAnchorName') >> moduleReferences - expect: 'the list provided by persistence service is returned as result' - objectUnderTest.getYangResourcesModuleReferences('someDataspaceName', 'someAnchorName') == moduleReferences + mockCpsModulePersistenceService.getYangResourceModuleReferences('someDataspaceName', 'someAnchorName') >> moduleReferences + when: 'get yang resource module references is called for dataspace name and anchor name' + def result = objectUnderTest.getYangResourcesModuleReferences('someDataspaceName', 'someAnchorName') + then: 'the list provided by persistence service is returned as result' + result == moduleReferences + and: 'the CpsValidator is called on the dataspaceName and schemaSetName' + 1 * mockCpsValidator.validateNameCharacters('someDataspaceName', 'someAnchorName') + } + + def 'Identifying new module references'(){ + given: 'module references from cm handle' + def moduleReferencesToCheck = [new ModuleReference('some-module', 'some-revision')] + when: 'identifyNewModuleReferences is called' + objectUnderTest.identifyNewModuleReferences(moduleReferencesToCheck) + then: 'cps module persistence service is called with module references to check' + 1 * mockCpsModulePersistenceService.identifyNewModuleReferences(moduleReferencesToCheck); + } + + def 'Getting module definitions.'() { + when: 'get module definitions method is called with a valid dataspace and anchor name' + objectUnderTest.getModuleDefinitionsByAnchorName('some-dataspace-name', 'some-anchor-name') + then: 'CPS module persistence service is invoked the correct number of times' + 1 * mockCpsModulePersistenceService.getYangResourceDefinitions('some-dataspace-name', 'some-anchor-name') + and: 'the CpsValidator is called on the dataspaceName and schemaSetName' + 1 * mockCpsValidator.validateNameCharacters('some-dataspace-name', 'some-anchor-name') } }