2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2023-2024 Nordix Foundation
4 * ================================================================================
5 * Licensed under the Apache License, Version 2.0 (the 'License');
6 * you may not use this file except in compliance with the License.
7 * You may obtain a copy of the License at
9 * http://www.apache.org/licenses/LICENSE-2.0
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an 'AS IS' BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
17 * SPDX-License-Identifier: Apache-2.0
18 * ============LICENSE_END=========================================================
21 package org.onap.cps.integration.functional
23 import org.onap.cps.api.CpsModuleService
24 import org.onap.cps.integration.base.FunctionalSpecBase
25 import org.onap.cps.spi.CascadeDeleteAllowed
26 import org.onap.cps.spi.exceptions.AlreadyDefinedException
27 import org.onap.cps.spi.exceptions.DataspaceNotFoundException
28 import org.onap.cps.spi.exceptions.ModelValidationException
29 import org.onap.cps.spi.exceptions.SchemaSetInUseException
30 import org.onap.cps.spi.exceptions.SchemaSetNotFoundException
31 import org.onap.cps.spi.model.ModuleDefinition
32 import org.onap.cps.spi.model.ModuleReference
34 class CpsModuleServiceIntegrationSpec extends FunctionalSpecBase {
36 CpsModuleService objectUnderTest
38 private static def originalNumberOfModuleReferences = 2 // bookstore has two modules
39 private static def bookStoreModuleReference = new ModuleReference('stores','2024-01-30')
40 private static def bookStoreModuleReferenceWithNamespace = new ModuleReference('stores','2024-01-30', 'org:onap:cps:sample')
41 private static def bookStoreTypesModuleReference = new ModuleReference('bookstore-types','2024-01-30')
42 private static def bookStoreTypesModuleReferenceWithNamespace = new ModuleReference('bookstore-types','2024-01-30', 'org:onap:cps:types:sample')
43 static def NEW_RESOURCE_REVISION = '2023-05-10'
44 static def NEW_RESOURCE_CONTENT = 'module test_module {\n' +
45 ' yang-version 1.1;\n' +
46 ' namespace "org:onap:ccsdk:sample";\n' +
48 ' prefix book-store;\n' +
50 ' revision "2023-05-10" {\n' +
52 ' "Sample Model";\n' +
56 def newYangResourcesNameToContentMap = [:]
57 def moduleReferences = []
58 def noNewModules = [:]
59 def bookstoreModelFileContent = readResourceDataFile('bookstore/bookstore.yang')
60 def bookstoreTypesFileContent = readResourceDataFile('bookstore/bookstore-types.yang')
63 objectUnderTest = cpsModuleService
67 C R E A T E S C H E M A S E T U S E - C A S E S
70 def 'Create new schema set from yang resources with #scenario'() {
71 given: 'a new schema set with #numberOfModules modules'
72 populateNewYangResourcesNameToContentMapAndAllModuleReferences(numberOfNewModules)
73 when: 'the new schema set is created'
74 objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet', newYangResourcesNameToContentMap)
75 then: 'the number of module references has increased by #numberOfNewModules'
76 def yangResourceModuleReferences = objectUnderTest.getYangResourceModuleReferences(FUNCTIONAL_TEST_DATASPACE_1)
77 originalNumberOfModuleReferences + numberOfNewModules == yangResourceModuleReferences.size()
79 objectUnderTest.deleteSchemaSetsWithCascade(FUNCTIONAL_TEST_DATASPACE_1, [ 'newSchemaSet' ])
80 where: 'the following parameters are use'
81 scenario | numberOfNewModules
82 'two valid new modules' | 2
83 'empty schema set' | 0
84 'over max batch size #modules' | 101
87 def 'Create new schema set with recommended filename format but invalid yang'() {
88 given: 'a filename using RFC6020 recommended format (for coverage only)'
89 def fileName = 'test@2023-05-11.yang'
90 when: 'attempt to create a schema set with invalid Yang'
91 objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet', [(fileName) :'invalid yang'])
92 then: 'a model validation exception'
93 thrown(ModelValidationException)
96 def 'Create new schema set from modules with #scenario'() {
97 given: 'a new schema set with #numberOfNewModules modules'
98 populateNewYangResourcesNameToContentMapAndAllModuleReferences(numberOfNewModules)
99 and: 'add existing module references (optional)'
100 moduleReferences.addAll(existingModuleReferences)
101 when: 'the new schema set is created'
102 def schemaSetName = "NewSchemaWith${numberOfNewModules}Modules"
103 objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, schemaSetName, newYangResourcesNameToContentMap, moduleReferences)
104 and: 'associated with a new anchor'
105 cpsAnchorService.createAnchor(FUNCTIONAL_TEST_DATASPACE_1, schemaSetName, 'newAnchor')
106 then: 'the new anchor has the correct number of modules'
107 def yangResourceModuleReferences = objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'newAnchor')
108 assert expectedNumberOfModulesForAnchor == yangResourceModuleReferences.size()
110 objectUnderTest.deleteSchemaSetsWithCascade(FUNCTIONAL_TEST_DATASPACE_1, [ schemaSetName.toString() ])
111 where: 'the following module references are provided'
112 scenario | numberOfNewModules | existingModuleReferences || expectedNumberOfModulesForAnchor
113 'empty schema set' | 0 | [ ] || 0
114 'one existing module' | 0 | [bookStoreModuleReference ] || 1
115 'two new modules' | 2 | [ ] || 2
116 'two new modules, one existing' | 2 | [bookStoreModuleReference ] || 3
117 'over max batch size #modules' | 101 | [ ] || 101
118 'two valid, one invalid module' | 2 | [ new ModuleReference('NOT EXIST','IRRELEVANT') ] || 2
121 def 'Duplicate schema content.'() {
122 given: 'a map of yang resources'
123 populateNewYangResourcesNameToContentMapAndAllModuleReferences(1)
124 when: 'a new schema set is created'
125 objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchema1', newYangResourcesNameToContentMap)
126 then: 'the dataspace has one new module (reference)'
127 def numberOfModuleReferencesAfterFirstSchemaSetHasBeenAdded = objectUnderTest.getYangResourceModuleReferences(FUNCTIONAL_TEST_DATASPACE_1).size()
128 assert numberOfModuleReferencesAfterFirstSchemaSetHasBeenAdded == originalNumberOfModuleReferences + 1
129 when: 'a second new schema set is created'
130 objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchema2', newYangResourcesNameToContentMap)
131 then: 'the dataspace has no additional module (reference)'
132 assert numberOfModuleReferencesAfterFirstSchemaSetHasBeenAdded == objectUnderTest.getYangResourceModuleReferences(FUNCTIONAL_TEST_DATASPACE_1).size()
134 objectUnderTest.deleteSchemaSetsWithCascade(FUNCTIONAL_TEST_DATASPACE_1, [ 'newSchema1', 'newSchema2'])
137 def 'Create schema set error scenario: #scenario.'() {
138 when: 'attempt to store schema set #schemaSetName in dataspace #dataspaceName'
139 populateNewYangResourcesNameToContentMapAndAllModuleReferences(0)
140 objectUnderTest.createSchemaSet(dataspaceName, schemaSetName, newYangResourcesNameToContentMap)
141 then: 'an #expectedException is thrown'
142 thrown(expectedException)
143 where: 'the following data is used'
144 scenario | dataspaceName | schemaSetName || expectedException
145 'dataspace does not exist' | 'unknown' | 'not-relevant' || DataspaceNotFoundException
146 'schema set already exists' | FUNCTIONAL_TEST_DATASPACE_1 | BOOKSTORE_SCHEMA_SET || AlreadyDefinedException
150 R E A D S C H E M A S E T I N F O U S E - C A S E S
153 def 'Retrieving module definitions by anchor.'() {
154 when: 'the module definitions for an anchor are retrieved'
155 def result = objectUnderTest.getModuleDefinitionsByAnchorName(FUNCTIONAL_TEST_DATASPACE_1, BOOKSTORE_ANCHOR_1)
156 then: 'the correct module definitions are returned'
157 assert result.size() == 2
158 assert result.contains(new ModuleDefinition('stores','2024-01-30',bookstoreModelFileContent))
159 assert result.contains(new ModuleDefinition('bookstore-types','2024-01-30', bookstoreTypesFileContent))
162 def 'Retrieving module definitions: #scenarios'() {
163 when: 'module definitions for module name are retrieved'
164 def result = objectUnderTest.getModuleDefinitionsByAnchorAndModule(FUNCTIONAL_TEST_DATASPACE_1, BOOKSTORE_ANCHOR_1, moduleName, moduleRevision)
165 then: 'the correct module definitions are returned'
166 if (expectedNumberOfDefinitions > 0) {
167 assert result.size() == expectedNumberOfDefinitions
168 def expectedModuleDefinition = new ModuleDefinition('stores', '2024-01-30', bookstoreModelFileContent)
169 assert result[0] == expectedModuleDefinition
171 where: 'following parameters are used'
172 scenarios | moduleName | moduleRevision || expectedNumberOfDefinitions
173 'correct module name and revision' | 'stores' | '2024-01-30' || 1
174 'correct module name' | 'stores' | null || 1
175 'incorrect module name' | 'other' | null || 0
176 'incorrect revision' | 'stores' | '2025-11-22' || 0
179 def 'Retrieving yang resource module references by anchor.'() {
180 when: 'the yang resource module references for an anchor are retrieved'
181 def result = objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, BOOKSTORE_ANCHOR_1)
182 then: 'the correct module references are returned'
183 assert result.size() == 2
184 assert result.containsAll(bookStoreModuleReference, bookStoreTypesModuleReference)
187 def 'Identifying new module references with #scenario'() {
188 when: 'identifyNewModuleReferences is called'
189 def result = objectUnderTest.identifyNewModuleReferences(moduleReferences)
190 then: 'the correct module references are returned'
191 assert result.size() == expectedResult.size()
192 assert result.containsAll(expectedResult)
193 where: 'the following data is used'
194 scenario | moduleReferences || expectedResult
195 'just new module references' | [new ModuleReference('new1', 'r1'), new ModuleReference('new2', 'r1')] || [new ModuleReference('new1', 'r1'), new ModuleReference('new2', 'r1')]
196 'one new module,one existing reference' | [new ModuleReference('new1', 'r1'), bookStoreModuleReference] || [new ModuleReference('new1', 'r1')]
197 'no new module references' | [bookStoreModuleReference] || []
198 'no module references' | [] || []
199 'module references collection is null' | null || []
202 def 'Retrieve schema set.'() {
203 when: 'a specific schema set is retrieved'
204 def result = objectUnderTest.getSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, BOOKSTORE_SCHEMA_SET)
205 then: 'the result has the correct name and module(s)'
206 assert result.name == 'bookstoreSchemaSet'
207 assert result.moduleReferences.size() == 2
208 assert result.moduleReferences.containsAll(bookStoreModuleReferenceWithNamespace, bookStoreTypesModuleReferenceWithNamespace)
211 def 'Retrieve all schema sets.'() {
212 given: 'an extra schema set is stored'
213 populateNewYangResourcesNameToContentMapAndAllModuleReferences(1)
214 objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchema1', newYangResourcesNameToContentMap)
215 when: 'all schema sets are retrieved'
216 def result = objectUnderTest.getSchemaSets(FUNCTIONAL_TEST_DATASPACE_1)
217 then: 'the result contains all expected schema sets'
218 assert result.name == [ 'bookstoreSchemaSet', 'newSchema1' ]
220 objectUnderTest.deleteSchemaSetsWithCascade(FUNCTIONAL_TEST_DATASPACE_1, ['newSchema1'])
224 D E L E T E S C H E M A S E T U S E - C A S E S
227 def 'Delete schema sets with(out) cascade.'() {
228 given: 'a schema set'
229 populateNewYangResourcesNameToContentMapAndAllModuleReferences(1)
230 objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet', newYangResourcesNameToContentMap)
231 and: 'optionally create anchor for the schema set'
232 if (associateWithAnchor) {
233 cpsAnchorService.createAnchor(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet', 'newAnchor')
235 when: 'attempt to delete the schema set'
237 objectUnderTest.deleteSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet', cascadeDeleteAllowedOption)
239 catch (Exception e) { // only accept correct exception when schema set cannot be deleted
240 assert e instanceof SchemaSetInUseException && expectSchemaSetStillPresent
242 then: 'check if the dataspace still contains the new schema set or not'
243 def remainingSchemaSetNames = objectUnderTest.getSchemaSets(FUNCTIONAL_TEST_DATASPACE_1).name
244 assert remainingSchemaSetNames.contains('newSchemaSet') == expectSchemaSetStillPresent
246 objectUnderTest.deleteSchemaSetsWithCascade(FUNCTIONAL_TEST_DATASPACE_1, ['newSchemaSet'])
247 where: 'the following options are used'
248 associateWithAnchor | cascadeDeleteAllowedOption || expectSchemaSetStillPresent
249 false | CascadeDeleteAllowed.CASCADE_DELETE_ALLOWED || false
250 false | CascadeDeleteAllowed.CASCADE_DELETE_PROHIBITED || false
251 true | CascadeDeleteAllowed.CASCADE_DELETE_ALLOWED || false
252 true | CascadeDeleteAllowed.CASCADE_DELETE_PROHIBITED || true
255 def 'Delete schema sets with shared resources.'() {
256 given: 'a new schema set'
257 populateNewYangResourcesNameToContentMapAndAllModuleReferences(1)
258 objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet1', newYangResourcesNameToContentMap)
259 and: 'another schema set which shares one yang resource (module)'
260 populateNewYangResourcesNameToContentMapAndAllModuleReferences(2)
261 objectUnderTest.createSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'newSchemaSet2', newYangResourcesNameToContentMap)
262 when: 'all schema sets are retrieved'
263 def moduleRevisions = objectUnderTest.getYangResourceModuleReferences(FUNCTIONAL_TEST_DATASPACE_1).revision
264 then: 'both modules (revisions) are present'
265 assert moduleRevisions.containsAll(['2000-01-01', '2000-01-01'])
266 when: 'delete the second schema set that has two resources one of which is a shared resource'
267 objectUnderTest.deleteSchemaSetsWithCascade(FUNCTIONAL_TEST_DATASPACE_1, ['newSchemaSet2'])
268 then: 'only the second schema set is deleted'
269 def remainingSchemaSetNames = objectUnderTest.getSchemaSets(FUNCTIONAL_TEST_DATASPACE_1).name
270 assert remainingSchemaSetNames.contains('newSchemaSet1')
271 assert !remainingSchemaSetNames.contains('newSchemaSet2')
272 and: 'only the shared module (revision) remains'
273 def remainingModuleRevisions = objectUnderTest.getYangResourceModuleReferences(FUNCTIONAL_TEST_DATASPACE_1).revision
274 assert remainingModuleRevisions.contains('2000-01-01')
275 assert !remainingModuleRevisions.contains('2001-01-01')
277 objectUnderTest.deleteSchemaSetsWithCascade(FUNCTIONAL_TEST_DATASPACE_1, ['newSchemaSet1'])
280 def 'Delete schema set error scenario: #scenario.'() {
281 when: 'attempt to delete a schema set where #scenario'
282 objectUnderTest.deleteSchemaSet(dataspaceName, schemaSetName, CascadeDeleteAllowed.CASCADE_DELETE_PROHIBITED)
283 then: 'an #expectedException is thrown'
284 thrown(expectedException)
285 where: 'the following data is used'
286 scenario | dataspaceName | schemaSetName || expectedException
287 'dataspace does not exist' | 'unknown' | 'not-relevant' || DataspaceNotFoundException
288 'schema set does not exists' | FUNCTIONAL_TEST_DATASPACE_1 | 'unknown' || SchemaSetNotFoundException
295 def 'Upgrade schema set (with existing and new modules, no matching module set tag in NCMP)'() {
296 given: 'an anchor and schema set with 2 modules (to be upgraded)'
297 populateNewYangResourcesNameToContentMapAndAllModuleReferences('original', 2)
298 objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', newYangResourcesNameToContentMap, [])
299 cpsAnchorService.createAnchor(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', 'targetAnchor')
300 def yangResourceModuleReferencesBeforeUpgrade = objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'targetAnchor')
301 assert yangResourceModuleReferencesBeforeUpgrade.size() == 2
302 assert yangResourceModuleReferencesBeforeUpgrade.containsAll([new ModuleReference('original_0','2000-01-01'),new ModuleReference('original_1','2001-01-01')])
303 and: 'two new 2 modules (from node)'
304 populateNewYangResourcesNameToContentMapAndAllModuleReferences('new', 2)
305 def newModuleReferences = [new ModuleReference('new_0','2000-01-01'),new ModuleReference('new_1','2001-01-01')]
306 and: 'a list of all module references (normally retrieved from node)'
307 def allModuleReferences = []
308 allModuleReferences.add(bookStoreModuleReference)
309 allModuleReferences.addAll(newModuleReferences)
310 when: 'the schema set is upgraded'
311 objectUnderTest.upgradeSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', newYangResourcesNameToContentMap, allModuleReferences)
312 then: 'the new anchor has the correct new and existing modules'
313 def yangResourceModuleReferencesAfterUpgrade = objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'targetAnchor')
314 assert yangResourceModuleReferencesAfterUpgrade.size() == 3
315 assert yangResourceModuleReferencesAfterUpgrade.contains(bookStoreModuleReference)
316 assert yangResourceModuleReferencesAfterUpgrade.containsAll(newModuleReferences);
318 objectUnderTest.deleteSchemaSetsWithCascade(FUNCTIONAL_TEST_DATASPACE_1, ['targetSchema'])
321 def 'Upgrade existing schema set from another anchor (used in NCMP for matching module set tag)'() {
322 given: 'an anchor and schema set with 1 module (target)'
323 populateNewYangResourcesNameToContentMapAndAllModuleReferences('target', 1)
324 objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', newYangResourcesNameToContentMap, [])
325 cpsAnchorService.createAnchor(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', 'targetAnchor')
326 def moduleReferencesBeforeUpgrade = objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'targetAnchor')
327 assert moduleReferencesBeforeUpgrade.size() == 1
328 and: 'another anchor and schema set with 2 other modules (source for upgrade)'
329 populateNewYangResourcesNameToContentMapAndAllModuleReferences('source', 2)
330 objectUnderTest.createSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'sourceSchema', newYangResourcesNameToContentMap, [])
331 cpsAnchorService.createAnchor(FUNCTIONAL_TEST_DATASPACE_1, 'sourceSchema', 'sourceAnchor')
332 assert objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'sourceAnchor').size() == 2
333 when: 'the target schema is upgraded using the module references from the source anchor'
334 def moduleReferencesFromSourceAnchor = objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'sourceAnchor')
335 objectUnderTest.upgradeSchemaSetFromModules(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema', noNewModules, moduleReferencesFromSourceAnchor)
336 then: 'the target schema now refers to the source modules (with namespace) modules'
337 def schemaSetModuleReferencesAfterUpgrade = getObjectUnderTest().getSchemaSet(FUNCTIONAL_TEST_DATASPACE_1, 'targetSchema').moduleReferences
338 assert schemaSetModuleReferencesAfterUpgrade.containsAll([new ModuleReference('source_0','2000-01-01','org:onap:ccsdk:sample'),new ModuleReference('source_1','2001-01-01','org:onap:ccsdk:sample')]);
339 and: 'the associated target anchor has the same module references (without namespace but that is a legacy issue)'
340 def anchorModuleReferencesAfterUpgrade = objectUnderTest.getYangResourcesModuleReferences(FUNCTIONAL_TEST_DATASPACE_1, 'targetAnchor')
341 assert anchorModuleReferencesAfterUpgrade.containsAll([new ModuleReference('source_0','2000-01-01'),new ModuleReference('source_1','2001-01-01')]);
343 objectUnderTest.deleteSchemaSetsWithCascade(FUNCTIONAL_TEST_DATASPACE_1, ['sourceSchema', 'targetSchema'])
347 H E L P E R M E T H O D S
350 def populateNewYangResourcesNameToContentMapAndAllModuleReferences(numberOfModules) {
351 populateNewYangResourcesNameToContentMapAndAllModuleReferences('name', numberOfModules)
354 def populateNewYangResourcesNameToContentMapAndAllModuleReferences(namePrefix, numberOfModules) {
355 numberOfModules.times {
356 def uniqueName = namePrefix + '_' + it
357 def uniqueRevision = String.valueOf(2000 + it) + '-01-01'
358 moduleReferences.add(new ModuleReference(uniqueName, uniqueRevision))
359 def uniqueContent = NEW_RESOURCE_CONTENT.replace(NEW_RESOURCE_REVISION, uniqueRevision).replace('module test_module', 'module '+uniqueName)
360 newYangResourcesNameToContentMap.put(uniqueRevision, uniqueContent)