2 * ============LICENSE_START=======================================================
3 * Copyright (C) 2021-2023 Nordix Foundation
4 * Modifications Copyright (C) 2021 Pantheon.tech
5 * Modifications Copyright (C) 2021-2022 Bell Canada.
6 * Modifications Copyright (C) 2022-2023 TechMahindra Ltd.
7 * Modifications Copyright (C) 2022 Deutsche Telekom AG
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
12 * http://www.apache.org/licenses/LICENSE-2.0
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
20 * SPDX-License-Identifier: Apache-2.0
21 * ============LICENSE_END=========================================================
24 package org.onap.cps.api.impl
26 import org.onap.cps.TestUtils
27 import org.onap.cps.api.CpsAdminService
28 import org.onap.cps.notification.NotificationService
29 import org.onap.cps.notification.Operation
30 import org.onap.cps.spi.CpsDataPersistenceService
31 import org.onap.cps.spi.FetchDescendantsOption
32 import org.onap.cps.spi.exceptions.DataValidationException
33 import org.onap.cps.spi.model.Anchor
34 import org.onap.cps.spi.model.DataNode
35 import org.onap.cps.spi.model.DataNodeBuilder
36 import org.onap.cps.utils.ContentType
37 import org.onap.cps.utils.TimedYangParser
38 import org.onap.cps.yang.YangTextSchemaSourceSet
39 import org.onap.cps.yang.YangTextSchemaSourceSetBuilder
40 import spock.lang.Specification
41 import org.onap.cps.spi.utils.CpsValidator
43 import java.time.OffsetDateTime
44 import java.util.stream.Collectors
46 class CpsDataServiceImplSpec extends Specification {
47 def mockCpsDataPersistenceService = Mock(CpsDataPersistenceService)
48 def mockCpsAdminService = Mock(CpsAdminService)
49 def mockYangTextSchemaSourceSetCache = Mock(YangTextSchemaSourceSetCache)
50 def mockNotificationService = Mock(NotificationService)
51 def mockCpsValidator = Mock(CpsValidator)
52 def timedYangParser = new TimedYangParser()
54 def objectUnderTest = new CpsDataServiceImpl(mockCpsDataPersistenceService, mockCpsAdminService,
55 mockYangTextSchemaSourceSetCache, mockNotificationService, mockCpsValidator, timedYangParser)
58 mockCpsAdminService.getAnchor(dataspaceName, anchorName) >> anchor
61 def dataspaceName = 'some-dataspace'
62 def anchorName = 'some-anchor'
63 def schemaSetName = 'some-schema-set'
64 def anchor = Anchor.builder().name(anchorName).dataspaceName(dataspaceName).schemaSetName(schemaSetName).build()
65 def observedTimestamp = OffsetDateTime.now()
67 def 'Saving multicontainer json data.'() {
68 given: 'schema set for given anchor and dataspace references test-tree model'
69 setupSchemaSetMocks('multipleDataTree.yang')
70 when: 'save data method is invoked with test-tree json data'
71 def jsonData = TestUtils.getResourceFileContent('multiple-object-data.json')
72 objectUnderTest.saveData(dataspaceName, anchorName, jsonData, observedTimestamp)
73 then: 'the persistence service method is invoked with correct parameters'
74 1 * mockCpsDataPersistenceService.storeDataNodes(dataspaceName, anchorName,
75 { dataNode -> dataNode.xpath[index] == xpath })
76 and: 'the CpsValidator is called on the dataspaceName and AnchorName'
77 1 * mockCpsValidator.validateNameCharacters(dataspaceName, anchorName)
78 and: 'data updated event is sent to notification service'
79 1 * mockNotificationService.processDataUpdatedEvent(anchor, '/', Operation.CREATE, observedTimestamp)
82 0 | '/first-container'
87 def 'Saving #scenario data.'() {
88 given: 'schema set for given anchor and dataspace references test-tree model'
89 setupSchemaSetMocks('test-tree.yang')
90 when: 'save data method is invoked with test-tree #scenario data'
91 def data = TestUtils.getResourceFileContent(dataFile)
92 objectUnderTest.saveData(dataspaceName, anchorName, data, observedTimestamp, contentType)
93 then: 'the persistence service method is invoked with correct parameters'
94 1 * mockCpsDataPersistenceService.storeDataNodes(dataspaceName, anchorName,
95 { dataNode -> dataNode.xpath[0] == '/test-tree' })
96 and: 'the CpsValidator is called on the dataspaceName and AnchorName'
97 1 * mockCpsValidator.validateNameCharacters(dataspaceName, anchorName)
98 and: 'data updated event is sent to notification service'
99 1 * mockNotificationService.processDataUpdatedEvent(anchor, '/', Operation.CREATE, observedTimestamp)
100 where: 'given parameters'
101 scenario | dataFile | contentType
102 'json' | 'test-tree.json' | ContentType.JSON
103 'xml' | 'test-tree.xml' | ContentType.XML
106 def 'Saving #scenarioDesired data with invalid data.'() {
107 given: 'schema set for given anchor and dataspace references test-tree model'
108 setupSchemaSetMocks('test-tree.yang')
109 when: 'save data method is invoked with test-tree json data'
110 objectUnderTest.saveData(dataspaceName, anchorName, invalidData, observedTimestamp, contentType)
111 then: 'a data validation exception is thrown'
112 thrown(DataValidationException)
113 where: 'given parameters'
114 scenarioDesired | invalidData | contentType
115 'json' | '{invalid json' | ContentType.XML
116 'xml' | '<invalid xml' | ContentType.JSON
120 def 'Saving child data fragment under existing node.'() {
121 given: 'schema set for given anchor and dataspace references test-tree model'
122 setupSchemaSetMocks('test-tree.yang')
123 when: 'save data method is invoked with test-tree json data'
124 def jsonData = '{"branch": [{"name": "New"}]}'
125 objectUnderTest.saveData(dataspaceName, anchorName, '/test-tree', jsonData, observedTimestamp)
126 then: 'the persistence service method is invoked with correct parameters'
127 1 * mockCpsDataPersistenceService.addChildDataNodes(dataspaceName, anchorName, '/test-tree',
128 { dataNode -> dataNode.xpath[0] == '/test-tree/branch[@name=\'New\']' })
129 and: 'the CpsValidator is called on the dataspaceName and AnchorName'
130 1 * mockCpsValidator.validateNameCharacters(dataspaceName, anchorName)
131 and: 'data updated event is sent to notification service'
132 1 * mockNotificationService.processDataUpdatedEvent(anchor, '/test-tree', Operation.CREATE, observedTimestamp)
135 def 'Saving list element data fragment under existing node.'() {
136 given: 'schema set for given anchor and dataspace references test-tree model'
137 setupSchemaSetMocks('test-tree.yang')
138 when: 'save data method is invoked with list element json data'
139 def jsonData = '{"branch": [{"name": "A"}, {"name": "B"}]}'
140 objectUnderTest.saveListElements(dataspaceName, anchorName, '/test-tree', jsonData, observedTimestamp)
141 then: 'the persistence service method is invoked with correct parameters'
142 1 * mockCpsDataPersistenceService.addListElements(dataspaceName, anchorName, '/test-tree',
143 { dataNodeCollection ->
145 assert dataNodeCollection.size() == 2
146 assert dataNodeCollection.collect { it.getXpath() }
147 .containsAll(['/test-tree/branch[@name=\'A\']', '/test-tree/branch[@name=\'B\']'])
151 and: 'the CpsValidator is called on the dataspaceName and AnchorName'
152 1 * mockCpsValidator.validateNameCharacters(dataspaceName, anchorName)
153 and: 'data updated event is sent to notification service'
154 1 * mockNotificationService.processDataUpdatedEvent(anchor, '/test-tree', Operation.UPDATE, observedTimestamp)
157 def 'Saving collection of a batch with data fragment under existing node.'() {
158 given: 'schema set for given anchor and dataspace references test-tree model'
159 setupSchemaSetMocks('test-tree.yang')
160 when: 'save data method is invoked with list element json data'
161 def jsonData = '{"branch": [{"name": "A"}, {"name": "B"}]}'
162 objectUnderTest.saveListElementsBatch(dataspaceName, anchorName, '/test-tree', [jsonData], observedTimestamp)
163 then: 'the persistence service method is invoked with correct parameters'
164 1 * mockCpsDataPersistenceService.addMultipleLists(dataspaceName, anchorName, '/test-tree',_) >> {
166 def listElementsCollection = args[3] as Collection<Collection<DataNode>>
167 assert listElementsCollection.size() == 1
168 def listOfXpaths = listElementsCollection.stream().flatMap(x -> x.stream()).map(it-> it.xpath).collect(Collectors.toList())
169 assert listOfXpaths.size() == 2
170 assert listOfXpaths.containsAll(['/test-tree/branch[@name=\'B\']','/test-tree/branch[@name=\'A\']'])
173 and: 'data updated event is sent to notification service'
174 1 * mockNotificationService.processDataUpdatedEvent(anchor, '/test-tree', Operation.UPDATE, observedTimestamp)
177 def 'Saving empty list element data fragment.'() {
178 given: 'schema set for given anchor and dataspace references test-tree model'
179 setupSchemaSetMocks('test-tree.yang')
180 when: 'save data method is invoked with an empty list'
181 def jsonData = '{"branch": []}'
182 objectUnderTest.saveListElements(dataspaceName, anchorName, '/test-tree', jsonData, observedTimestamp)
183 then: 'invalid data exception is thrown'
184 thrown(DataValidationException)
187 def 'Get all data nodes #scenario.'() {
188 given: 'persistence service returns data for GET request'
189 mockCpsDataPersistenceService.getDataNodes(dataspaceName, anchorName, xpath, fetchDescendantsOption) >> dataNode
190 expect: 'service returns same data if using same parameters'
191 objectUnderTest.getDataNodes(dataspaceName, anchorName, xpath, fetchDescendantsOption) == dataNode
192 where: 'following parameters were used'
193 scenario | xpath | fetchDescendantsOption | dataNode
194 'with root node xpath and descendants' | '/' | FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS | [new DataNodeBuilder().withXpath('/xpath-1').build(), new DataNodeBuilder().withXpath('/xpath-2').build()]
195 'with root node xpath and no descendants' | '/' | FetchDescendantsOption.OMIT_DESCENDANTS | [new DataNodeBuilder().withXpath('/xpath-1').build(), new DataNodeBuilder().withXpath('/xpath-2').build()]
196 'with valid xpath and descendants' | '/xpath'| FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS | [new DataNodeBuilder().withXpath('/xpath').build()]
197 'with valid xpath and no descendants' | '/xpath'| FetchDescendantsOption.OMIT_DESCENDANTS | [new DataNodeBuilder().withXpath('/xpath').build()]
200 def 'Get all data nodes over multiple xpaths with option #fetchDescendantsOption.'() {
201 def xpath1 = '/xpath-1'
202 def xpath2 = '/xpath-2'
203 def dataNode = [new DataNodeBuilder().withXpath(xpath1).build(), new DataNodeBuilder().withXpath(xpath2).build()]
204 given: 'persistence service returns data for get data request'
205 mockCpsDataPersistenceService.getDataNodesForMultipleXpaths(dataspaceName, anchorName, [xpath1, xpath2], fetchDescendantsOption) >> dataNode
206 expect: 'service returns same data if uses same parameters'
207 objectUnderTest.getDataNodesForMultipleXpaths(dataspaceName, anchorName, [xpath1, xpath2], fetchDescendantsOption) == dataNode
208 where: 'all fetch options are supported'
209 fetchDescendantsOption << [FetchDescendantsOption.OMIT_DESCENDANTS, FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS]
212 def 'Update data node leaves: #scenario.'() {
213 given: 'schema set for given anchor and dataspace references test-tree model'
214 setupSchemaSetMocks('test-tree.yang')
215 when: 'update data method is invoked with json data #jsonData and parent node xpath #parentNodeXpath'
216 objectUnderTest.updateNodeLeaves(dataspaceName, anchorName, parentNodeXpath, jsonData, observedTimestamp)
217 then: 'the persistence service method is invoked with correct parameters'
218 1 * mockCpsDataPersistenceService.updateDataLeaves(dataspaceName, anchorName, expectedNodeXpath, leaves)
219 and: 'the CpsValidator is called on the dataspaceName and AnchorName'
220 1 * mockCpsValidator.validateNameCharacters(dataspaceName, anchorName)
221 and: 'data updated event is sent to notification service'
222 1 * mockNotificationService.processDataUpdatedEvent(anchor, parentNodeXpath, Operation.UPDATE, observedTimestamp)
223 where: 'following parameters were used'
224 scenario | parentNodeXpath | jsonData || expectedNodeXpath | leaves
225 'top level node' | '/' | '{"test-tree": {"branch": []}}' || '/test-tree' | Collections.emptyMap()
226 'level 2 node' | '/test-tree' | '{"branch": [{"name":"Name"}]}' || '/test-tree/branch[@name=\'Name\']' | ['name': 'Name']
229 def 'Update list-element data node with : #scenario.'() {
230 given: 'schema set for given anchor and dataspace references bookstore model'
231 setupSchemaSetMocks('bookstore.yang')
232 when: 'update data method is invoked with json data #jsonData and parent node xpath'
233 objectUnderTest.updateNodeLeaves(dataspaceName, anchorName, '/bookstore/categories[@code=2]',
234 jsonData, observedTimestamp)
235 then: 'the persistence service method is invoked with correct parameters'
236 thrown(DataValidationException)
237 where: 'following parameters were used'
239 'multiple expectedLeaves' | '{"code": "01","name": "some-name"}'
240 'one leaf' | '{"name": "some-name"}'
243 def 'Update multiple data nodes' () {
244 given: 'schema set for given dataspace and anchor refers multipleDataTree model'
245 setupSchemaSetMocks('multipleDataTree.yang')
246 and: 'json string with multiple data trees'
247 def updatedJsonData = '{"first-container":{"a-leaf":"a-new-Value"},"last-container":{"x-leaf":"x-new-value"}}'
248 when: 'update operation is performed on multiple data nodes'
249 objectUnderTest.updateNodeLeaves(dataspaceName, anchorName, '/', updatedJsonData, observedTimestamp)
250 then: 'expected exception is thrown'
251 thrown(DataValidationException)
254 def 'Update Bookstore node leaves' () {
255 given: 'a DMI registry model'
256 setupSchemaSetMocks('bookstore.yang')
257 and: 'the expected json string'
258 def jsonData = '{"categories":[{"code":01,"name":"Romance"}]}'
259 when: 'update data method is invoked with json data and parent node xpath'
260 objectUnderTest.updateNodeLeavesAndExistingDescendantLeaves(dataspaceName, anchorName,
261 '/bookstore', jsonData, observedTimestamp)
262 then: 'the persistence service method is invoked with correct parameters'
263 1 * mockCpsDataPersistenceService.updateDataLeaves(dataspaceName, anchorName,
264 "/bookstore/categories[@code='01']", ['name':'Romance', 'code': '01'])
265 and: 'the CpsValidator is called on the dataspaceName and AnchorName'
266 1 * mockCpsValidator.validateNameCharacters(dataspaceName, anchorName)
267 and: 'the data updated event is sent to the notification service'
268 1 * mockNotificationService.processDataUpdatedEvent(anchor, '/bookstore', Operation.UPDATE, observedTimestamp)
271 def 'Replace data node using singular data node: #scenario.'() {
272 given: 'schema set for given anchor and dataspace references test-tree model'
273 setupSchemaSetMocks('test-tree.yang')
274 when: 'replace data method is invoked with json data #jsonData and parent node xpath #parentNodeXpath'
275 objectUnderTest.updateDataNodeAndDescendants(dataspaceName, anchorName, parentNodeXpath, jsonData, observedTimestamp)
276 then: 'the persistence service method is invoked with correct parameters'
277 1 * mockCpsDataPersistenceService.updateDataNodesAndDescendants(dataspaceName, anchorName,
278 { dataNode -> dataNode.xpath[0] == expectedNodeXpath })
279 and: 'data updated event is sent to notification service'
280 1 * mockNotificationService.processDataUpdatedEvent(anchor, parentNodeXpath, Operation.UPDATE, observedTimestamp)
281 and: 'the CpsValidator is called on the dataspaceName and AnchorName'
282 1 * mockCpsValidator.validateNameCharacters(dataspaceName, anchorName)
283 where: 'following parameters were used'
284 scenario | parentNodeXpath | jsonData || expectedNodeXpath
285 'top level node' | '/' | '{"test-tree": {"branch": []}}' || '/test-tree'
286 'level 2 node' | '/test-tree' | '{"branch": [{"name":"Name"}]}' || '/test-tree/branch[@name=\'Name\']'
289 def 'Replace data node using multiple data nodes: #scenario.'() {
290 given: 'schema set for given anchor and dataspace references test-tree model'
291 setupSchemaSetMocks('test-tree.yang')
292 when: 'replace data method is invoked with a map of xpaths and json data'
293 objectUnderTest.updateDataNodesAndDescendants(dataspaceName, anchorName, nodesJsonData, observedTimestamp)
294 then: 'the persistence service method is invoked with correct parameters'
295 1 * mockCpsDataPersistenceService.updateDataNodesAndDescendants(dataspaceName, anchorName,
296 { dataNode -> dataNode.xpath == expectedNodeXpath})
297 and: 'data updated event is sent to notification service'
298 1 * mockNotificationService.processDataUpdatedEvent(anchor, nodesJsonData.keySet()[0], Operation.UPDATE, observedTimestamp)
299 1 * mockNotificationService.processDataUpdatedEvent(anchor, nodesJsonData.keySet()[1], Operation.UPDATE, observedTimestamp)
300 and: 'the CpsValidator is called on the dataspaceName and AnchorName'
301 1 * mockCpsValidator.validateNameCharacters(dataspaceName, anchorName)
302 where: 'following parameters were used'
303 scenario | nodesJsonData || expectedNodeXpath
304 'top level node' | ['/' : '{"test-tree": {"branch": []}}', '/test-tree' : '{"branch": [{"name":"Name"}]}'] || ["/test-tree", "/test-tree/branch[@name='Name']"]
305 'level 2 node' | ['/test-tree' : '{"branch": [{"name":"Name"}]}', '/test-tree/branch[@name=\'Name\']':'{"nest":{"name":"nestName"}}'] || ["/test-tree/branch[@name='Name']", "/test-tree/branch[@name='Name']/nest"]
308 def 'Replace list content data fragment under parent node.'() {
309 given: 'schema set for given anchor and dataspace references test-tree model'
310 setupSchemaSetMocks('test-tree.yang')
311 when: 'replace list data method is invoked with list element json data'
312 def jsonData = '{"branch": [{"name": "A"}, {"name": "B"}]}'
313 objectUnderTest.replaceListContent(dataspaceName, anchorName, '/test-tree', jsonData, observedTimestamp)
314 then: 'the persistence service method is invoked with correct parameters'
315 1 * mockCpsDataPersistenceService.replaceListContent(dataspaceName, anchorName, '/test-tree',
316 { dataNodeCollection ->
318 assert dataNodeCollection.size() == 2
319 assert dataNodeCollection.collect { it.getXpath() }
320 .containsAll(['/test-tree/branch[@name=\'A\']', '/test-tree/branch[@name=\'B\']'])
324 and: 'the CpsValidator is called on the dataspaceName and AnchorName twice'
325 2 * mockCpsValidator.validateNameCharacters(dataspaceName, anchorName)
326 and: 'data updated event is sent to notification service'
327 1 * mockNotificationService.processDataUpdatedEvent(anchor, '/test-tree', Operation.UPDATE, observedTimestamp)
330 def 'Replace whole list content with empty list element.'() {
331 given: 'schema set for given anchor and dataspace references test-tree model'
332 setupSchemaSetMocks('test-tree.yang')
333 when: 'replace list data method is invoked with empty list'
334 def jsonData = '{"branch": []}'
335 objectUnderTest.replaceListContent(dataspaceName, anchorName, '/test-tree', jsonData, observedTimestamp)
336 then: 'invalid data exception is thrown'
337 thrown(DataValidationException)
340 def 'Delete list element under existing node.'() {
341 given: 'schema set for given anchor and dataspace references test-tree model'
342 setupSchemaSetMocks('test-tree.yang')
343 when: 'delete list data method is invoked with list element json data'
344 objectUnderTest.deleteListOrListElement(dataspaceName, anchorName, '/test-tree/branch', observedTimestamp)
345 then: 'the persistence service method is invoked with correct parameters'
346 1 * mockCpsDataPersistenceService.deleteListDataNode(dataspaceName, anchorName, '/test-tree/branch')
347 and: 'the CpsValidator is called on the dataspaceName and AnchorName'
348 1 * mockCpsValidator.validateNameCharacters(dataspaceName, anchorName)
349 and: 'data updated event is sent to notification service'
350 1 * mockNotificationService.processDataUpdatedEvent(anchor, '/test-tree/branch', Operation.DELETE, observedTimestamp)
353 def 'Delete multiple list elements under existing node.'() {
354 given: 'schema set for given anchor and dataspace references test-tree model'
355 setupSchemaSetMocks('test-tree.yang')
356 when: 'delete multiple list data method is invoked with list element json data'
357 objectUnderTest.deleteDataNodes(dataspaceName, anchorName, ['/test-tree/branch[@name="A"]', '/test-tree/branch[@name="B"]'], observedTimestamp)
358 then: 'the persistence service method is invoked with correct parameters'
359 1 * mockCpsDataPersistenceService.deleteDataNodes(dataspaceName, anchorName, ['/test-tree/branch[@name="A"]', '/test-tree/branch[@name="B"]'])
360 and: 'the CpsValidator is called on the dataspaceName and AnchorName'
361 1 * mockCpsValidator.validateNameCharacters(dataspaceName, anchorName)
362 and: 'two data updated events are sent to notification service'
363 2 * mockNotificationService.processDataUpdatedEvent(anchor, _, Operation.DELETE, observedTimestamp)
366 def 'Delete data node under anchor and dataspace.'() {
367 given: 'schema set for given anchor and dataspace references test tree model'
368 setupSchemaSetMocks('test-tree.yang')
369 when: 'delete data node method is invoked with correct parameters'
370 objectUnderTest.deleteDataNode(dataspaceName, anchorName, '/data-node', observedTimestamp)
371 then: 'the persistence service method is invoked with the correct parameters'
372 1 * mockCpsDataPersistenceService.deleteDataNode(dataspaceName, anchorName, '/data-node')
373 and: 'the CpsValidator is called on the dataspaceName and AnchorName'
374 1 * mockCpsValidator.validateNameCharacters(dataspaceName, anchorName)
375 and: 'data updated event is sent to notification service'
376 1 * mockNotificationService.processDataUpdatedEvent(anchor, '/data-node', Operation.DELETE, observedTimestamp)
379 def 'Delete all data nodes for a given anchor and dataspace.'() {
380 given: 'schema set for given anchor and dataspace references test tree model'
381 setupSchemaSetMocks('test-tree.yang')
382 when: 'delete data node method is invoked with correct parameters'
383 objectUnderTest.deleteDataNodes(dataspaceName, anchorName, observedTimestamp)
384 then: 'data updated event is sent to notification service before the delete'
385 1 * mockNotificationService.processDataUpdatedEvent(anchor, '/', Operation.DELETE, observedTimestamp)
386 and: 'the CpsValidator is called on the dataspaceName and AnchorName'
387 1 * mockCpsValidator.validateNameCharacters(dataspaceName, anchorName)
388 and: 'the persistence service method is invoked with the correct parameters'
389 1 * mockCpsDataPersistenceService.deleteDataNodes(dataspaceName, anchorName)
392 def 'Delete all data nodes for given dataspace and multiple anchors.'() {
393 given: 'schema set for given anchors and dataspace references test tree model'
394 setupSchemaSetMocks('test-tree.yang')
395 mockCpsAdminService.getAnchors(dataspaceName, ['anchor1', 'anchor2']) >>
396 [new Anchor(name: 'anchor1', dataspaceName: dataspaceName),
397 new Anchor(name: 'anchor2', dataspaceName: dataspaceName)]
398 when: 'delete data node method is invoked with correct parameters'
399 objectUnderTest.deleteDataNodes(dataspaceName, ['anchor1', 'anchor2'], observedTimestamp)
400 then: 'data updated events are sent to notification service before the delete'
401 2 * mockNotificationService.processDataUpdatedEvent(_, '/', Operation.DELETE, observedTimestamp)
402 and: 'the CpsValidator is called on the dataspace name and the anchor names'
403 2 * mockCpsValidator.validateNameCharacters(_)
404 and: 'the persistence service method is invoked with the correct parameters'
405 1 * mockCpsDataPersistenceService.deleteDataNodes(dataspaceName, _ as Collection<String>)
408 def setupSchemaSetMocks(String... yangResources) {
409 def mockYangTextSchemaSourceSet = Mock(YangTextSchemaSourceSet)
410 mockYangTextSchemaSourceSetCache.get(dataspaceName, schemaSetName) >> mockYangTextSchemaSourceSet
411 def yangResourceNameToContent = TestUtils.getYangResourcesAsMap(yangResources)
412 def schemaContext = YangTextSchemaSourceSetBuilder.of(yangResourceNameToContent).getSchemaContext()
413 mockYangTextSchemaSourceSet.getSchemaContext() >> schemaContext
416 def 'start session'() {
417 when: 'start session method is called'
418 objectUnderTest.startSession()
419 then: 'the persistence service method to start session is invoked'
420 1 * mockCpsDataPersistenceService.startSession()
423 def 'close session'(){
424 given: 'session Id from calling the start session method'
425 def sessionId = objectUnderTest.startSession()
426 when: 'close session method is called'
427 objectUnderTest.closeSession(sessionId)
428 then: 'the persistence service method to close session is invoked'
429 1 * mockCpsDataPersistenceService.closeSession(sessionId)
432 def 'lock anchor with no timeout parameter'(){
433 when: 'lock anchor method with no timeout parameter with details of anchor entity to lock'
434 objectUnderTest.lockAnchor('some-sessionId', 'some-dataspaceName', 'some-anchorName')
435 then: 'the persistence service method to lock anchor is invoked with default timeout'
436 1 * mockCpsDataPersistenceService.lockAnchor('some-sessionId', 'some-dataspaceName',
437 'some-anchorName', 300L)
440 def 'lock anchor with timeout parameter'(){
441 when: 'lock anchor method with timeout parameter is called with details of anchor entity to lock'
442 objectUnderTest.lockAnchor('some-sessionId', 'some-dataspaceName',
443 'some-anchorName', 250L)
444 then: 'the persistence service method to lock anchor is invoked with the given timeout'
445 1 * mockCpsDataPersistenceService.lockAnchor('some-sessionId', 'some-dataspaceName',
446 'some-anchorName', 250L)