<cglib-nodep.version>3.1</cglib-nodep.version>
<commons-codec.version>1.15</commons-codec.version>
<commons-lang3.version>3.11</commons-lang3.version>
- <groovy.version>3.0.6</groovy.version>
+ <groovy.version>3.0.8</groovy.version>
<hibernate-types.version>2.10.0</hibernate-types.version>
<liquibase.version>4.3.1</liquibase.version>
<nexusproxy>https://nexus.onap.org</nexusproxy>
<snapshotNexusPath>/content/repositories/snapshots/</snapshotNexusPath>
<modelmapper.version>2.3.8</modelmapper.version>
<sonar.skip>true</sonar.skip>
- <spock-core.version>2.0-M2-groovy-3.0</spock-core.version>
- <spock-spring.version>1.3-groovy-2.5</spock-spring.version>
+ <spock-core.version>2.0-M5-groovy-3.0</spock-core.version>
+ <spock-spring.version>2.0-M5-groovy-3.0</spock-spring.version>
<spotbugs.version>4.2.0</spotbugs.version>
<springboot.version>2.3.8.RELEASE</springboot.version>
<springboot.cloud.version>Hoxton.SR9</springboot.cloud.version>
<artifactId>groovy</artifactId>
<version>${groovy.version}</version>
</dependency>
+ <dependency>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>groovy-json</artifactId>
+ <version>${groovy.version}</version>
+ </dependency>
<dependency>
<groupId>org.spockframework</groupId>
<artifactId>spock-core</artifactId>
<artifactId>groovy</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>groovy-json</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.spockframework</groupId>
<artifactId>spock-core</artifactId>
import org.springframework.http.MediaType
import org.springframework.test.web.servlet.MockMvc
import spock.lang.Specification
-import spock.lang.Unroll
@WebMvcTest
class NetworkCmProxyControllerSpec extends Specification {
def cmHandle = 'some handle'
def xpath = 'some xpath'
- @Unroll
def 'Query data node by cps path for the given cm handle with #scenario.'() {
given: 'service method returns a list containing a data node'
def dataNode = new DataNodeBuilder().withXpath('/xpath').build()
'descendants' | 'true' || INCLUDE_ALL_DESCENDANTS
}
- @Unroll
def 'Create data node: #scenario.'() {
given: 'json data'
def jsonData = 'json data'
import org.onap.cps.ncmp.api.impl.NetworkCmProxyDataServiceImpl
import org.onap.cps.spi.FetchDescendantsOption
import spock.lang.Specification
-import spock.lang.Unroll
class NetworkCmProxyDataServiceImplSpec extends Specification {
def objectUnderTest = new NetworkCmProxyDataServiceImpl()
fetchDescendantsOption << FetchDescendantsOption.values()
}
- @Unroll
def 'Create full data node: #scenario.'() {
given: 'a cm handle and root xpath'
def jsonData = 'some json'
<artifactId>groovy</artifactId>
<scope>test</scope>
</dependency>
+ <dependency>
+ <groupId>org.codehaus.groovy</groupId>
+ <artifactId>groovy-json</artifactId>
+ <scope>test</scope>
+ </dependency>
<dependency>
<groupId>org.spockframework</groupId>
<artifactId>spock-core</artifactId>
import org.springframework.util.LinkedMultiValueMap
import org.springframework.util.MultiValueMap
import spock.lang.Specification
-import spock.lang.Unroll
@WebMvcTest
class AdminRestControllerSpec extends Specification {
response.status == HttpStatus.CREATED.value()
}
- @Unroll
def 'Create schema set from zip archive having #caseDescriptor.'() {
given: 'an endpoint'
def schemaSetEndpoint = "$basePath/v1/dataspaces/$dataspaceName/schema-sets"
response.status == HttpStatus.BAD_REQUEST.value()
}
- @Unroll
def 'Create schema set from #fileType file with IOException occurrence on processing.'() {
given: 'an endpoint'
def schemaSetEndpoint = "$basePath/v1/dataspaces/$dataspaceName/schema-sets"
import org.springframework.test.web.servlet.MockMvc
import spock.lang.Shared
import spock.lang.Specification
-import spock.lang.Unroll
@WebMvcTest
class DataRestControllerSpec extends Specification {
dataNodeBaseEndpoint = "$basePath/v1/dataspaces/$dataspaceName"
}
- @Unroll
def 'Create a node: #scenario.'() {
given: 'some json to create a data node'
def endpoint = "$dataNodeBaseEndpoint/anchors/$anchorName/nodes"
1 * mockCpsDataService.saveData(dataspaceName, anchorName, parentNodeXpath, json)
}
- @Unroll
def 'Get data node with leaves'() {
given: 'the service returns data node leaves'
def xpath = 'some xPath'
response.contentAsString.contains('"leafList":["leaveListElement1","leaveListElement2"]')
}
- @Unroll
def 'Get data node with #scenario.'() {
given: 'the service returns data node with #scenario'
def xpath = 'some xPath'
'no descendant explicitly' | dataNodeWithLeavesNoChildren | 'false' || OMIT_DESCENDANTS | false
'with descendants' | dataNodeWithChild | 'true' || INCLUDE_ALL_DESCENDANTS | true
}
-
- @Unroll
+
def 'Update data node leaves: #scenario.'() {
given: 'json data'
def jsonData = 'json data'
'some xpath by parent' | '/some/xpath' || '/some/xpath'
}
- @Unroll
def 'Replace data node tree: #scenario.'() {
given: 'json data'
def jsonData = 'json data'
import org.springframework.http.HttpStatus
import org.springframework.test.web.servlet.MockMvc
import spock.lang.Specification
-import spock.lang.Unroll
@WebMvcTest
class QueryRestControllerSpec extends Specification {
@Value('${rest.api.cps-base-path}')
def basePath
- @Unroll
def 'Query data node by cps path for the given dataspace and anchor with #scenario.'() {
given: 'service method returns a list containing a data node'
def dataNode = new DataNodeBuilder().withXpath('/xpath').build()
import org.springframework.test.web.servlet.MockMvc
import spock.lang.Shared
import spock.lang.Specification
-import spock.lang.Unroll
@WebMvcTest
class CpsRestExceptionHandlerSpec extends Specification {
"Anchor with name ${existingObjectName} already exists for ${dataspaceName}.")
}
- @Unroll
def 'Get request with a #exceptionThrown.class.simpleName returns HTTP Status Bad Request'() {
when: 'CPS validation exception is thrown by the service'
setupTestException(exceptionThrown)
new CpsPathException(errorMessage, errorDetails)]
}
- @Unroll
def 'Delete request with a #exceptionThrown.class.simpleName returns HTTP Status Conflict'() {
when: 'CPS validation exception is thrown by the service'
setupTestException(exceptionThrown)
import org.springframework.mock.web.MockMultipartFile
import org.springframework.web.multipart.MultipartFile
import spock.lang.Specification
-import spock.lang.Unroll
class MultipartFileUtilSpec extends Specification {
assert result["component.yang"] == "fake component content 1\n"
}
- @Unroll
def 'Extract resources from zip archive having #caseDescriptor.'() {
when: 'attempt to extract resources from zip file is performed'
MultipartFileUtil.extractYangResourcesMap(multipartFile)
thrown(ModelValidationException)
}
- @Unroll
def 'IOException thrown during yang resources extraction from #fileType file.'() {
when: 'attempt to extract resources from the file is performed'
MultipartFileUtil.extractYangResourcesMap(multipartFileForIOException(fileType))
import org.onap.cps.spi.model.Anchor
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.jdbc.Sql
-import spock.lang.Unroll
class CpsAdminPersistenceServiceSpec extends CpsPersistenceSpecBase {
anchor.schemaSetName == SCHEMA_SET_NAME1
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Create anchor error scenario: #scenario.'() {
when: 'attempt to create new anchor named #anchorName in dataspace #dataspaceName with #schemaSetName'
'anchor already exists' | DATASPACE_NAME | SCHEMA_SET_NAME1 | ANCHOR_NAME1 || AlreadyDefinedException
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Get anchor error scenario: #scenario.'() {
when: 'attempt to get anchor named #anchorName in dataspace #dataspaceName'
'anchor does not exists' | DATASPACE_NAME | 'unknown' || AnchorNotFoundException
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Get all anchors in dataspace #dataspaceName.'() {
when: 'all anchors are retrieved from #DATASPACE_NAME'
assert fragmentRepository.findById(DELETED_FRAGMENT_ID).isEmpty()
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'delete anchor error scenario: #scenario'(){
when: 'delete anchor attempt is performed'
import org.onap.cps.spi.model.DataNodeBuilder
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.jdbc.Sql
-import spock.lang.Unroll
import static org.onap.cps.spi.FetchDescendantsOption.INCLUDE_ALL_DESCENDANTS
import static org.onap.cps.spi.FetchDescendantsOption.OMIT_DESCENDANTS
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Cps Path query for single leaf value with type: #type.'() {
when: 'a query is executed to get a data node by the given cps path'
'Integer and descendants' | '/parent-200/child-202[@common-leaf-name-int=5]' | INCLUDE_ALL_DESCENDANTS || 1
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Query for attribute by cps path with cps paths that return no data because of #scenario.'() {
when: 'a query is executed to get datanodes for the given cps path'
'incomplete end of xpath prefix' | '/parent-200/child-20[@common-leaf-name-int=5]'
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Cps Path query using descendant anywhere and #type (further) descendants.'() {
when: 'a query is executed to get a data node by the given cps path'
'include' | INCLUDE_ALL_DESCENDANTS || 1
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Cps Path query using descendant anywhere with %scenario '() {
when: 'a query is executed to get a data node by the given cps path'
'descendant name match end of other node' | '//child-202' || ['/parent-200/child-202','/parent-201/child-202']
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Cps Path query using descendant anywhere ends with yang list containing %scenario '() {
when: 'a query is executed to get a data node by the given cps path'
'attributes reversed in order' | '//child-202[@common-leaf-name="common-leaf value" and @common-leaf-name-int=5]' || ['/parent-200/child-202']
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Cps Path query error scenario using descendant anywhere ends with yang list containing %scenario '() {
when: 'a query is executed to get a data node by the given cps path'
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.dao.DataIntegrityViolationException
import org.springframework.test.context.jdbc.Sql
-import spock.lang.Unroll
import javax.validation.ConstraintViolationException
fragment2.xpath == xpath
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Store datanode error scenario: #scenario.'() {
when: 'attempt to store a data node with #scenario'
parentFragment.getChildFragments().find({ it.xpath == newChild.xpath })
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Add child error scenario: #scenario.'() {
when: 'attempt to add a child data node with #scenario'
return fragmentRepository.findByDataspaceAndAnchorAndXpath(dataspace, anchor, xpath).orElseThrow()
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Get data node by xpath without descendants.'() {
when: 'data node is requested'
'empty xpath' |''
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Get data node by xpath with all descendants.'() {
when: 'data node is requested with all descendants'
assert mappedResult.get('/parent-100/child-002').getChildDataNodes().size() == 1
and: 'extracted leaves maps are matching expected'
mappedResult.forEach(
- (inputXPath, dataNode) -> assertLeavesMaps(dataNode.getLeaves(), expectedLeavesByXpathMap[inputXPath]))
+ (xPath, dataNode) -> assertLeavesMaps(dataNode.getLeaves(), expectedLeavesByXpathMap[xPath]))
where: 'the following data is used'
scenario | inputXPath
'some xpath' |'/parent-100'
return flatMap
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Get data node error scenario: #scenario.'() {
when: 'attempt to get data node with #scenario'
assert childLeaves.'leaf-value' == 'original'
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Update data leaves error scenario: #scenario.'() {
when: 'attempt to update data node for #scenario'
assert childLeaves.'leaf-value' == 'original'
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Replace data node tree error scenario: #scenario.'() {
given: 'data node object'
import org.onap.cps.spi.repository.SchemaSetRepository
import org.springframework.beans.factory.annotation.Autowired
import org.springframework.test.context.jdbc.Sql
-import spock.lang.Unroll
class CpsModulePersistenceServiceSpec extends CpsPersistenceSpecBase {
dataspaceEntity = dataspaceRepository.getByName(DATASPACE_NAME)
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Store schema set error scenario: #scenario.'() {
when: 'attempt to store schema set #schemaSetName in dataspace #dataspaceName'
sharedResourceIds.each {yangResourceRepository.findById(it).isPresent() }
}
- @Unroll
@Sql([CLEAR_DATA, SET_DATA])
def 'Delete schema set error scenario: #scenario.'() {
when: 'attempt to delete a schema set where #scenario'
import org.onap.cps.spi.exceptions.CpsPathException
import spock.lang.Specification
-import spock.lang.Unroll
class CpsPathQuerySpec extends Specification {
def objectUnderTest = new CpsPathQuery()
- @Unroll
def 'Parse cps path with valid cps path and a filter with #scenario.'() {
when: 'the given cps path is parsed'
def result = objectUnderTest.createFrom(cpsPath)
'key in top container' | '/parent[@common-leaf-name-int=5]' || '/parent' |'common-leaf-name-int' | 5
}
- @Unroll
def 'Parse cps path of type ends with a #scenario.'() {
when: 'the given cps path is parsed'
def result = objectUnderTest.createFrom(cpsPath)
'parent & child' | '//parent/child' || 'parent/child'
}
- @Unroll
def 'Parse cps path that ends with a yang list containing #scenario.'() {
when: 'the given cps path is parsed'
def result = objectUnderTest.createFrom(cpsPath)
'more than one attribute' | '//child[@int-leaf=5 and @leaf-name="leaf value"]' || 2
}
- @Unroll
def 'Parse cps path with #scenario.'() {
when: 'the given cps path is parsed'
objectUnderTest.createFrom(cpsPath)
'missing attribute value' | '//child[@int-leaf=5 and @name]'
}
- @Unroll
def 'Convert cps leaf value to valid type with leaf of type #scenario.'() {
when: 'the given leaf value is converted'
def result = objectUnderTest.convertLeafValueToCorrectType(leafValueInputString, 'source xPath (for error message only)')
import org.onap.cps.yang.YangTextSchemaSourceSet
import org.onap.cps.yang.YangTextSchemaSourceSetBuilder
import spock.lang.Specification
-import spock.lang.Unroll
class CpsDataServiceImplSpec extends Specification {
def mockCpsDataPersistenceService = Mock(CpsDataPersistenceService)
{ dataNode -> dataNode.xpath == '/test-tree/branch[@name=\'New\']' })
}
- @Unroll
def 'Get data node with option #fetchDescendantsOption.'() {
def xpath = '/xpath'
def dataNode = new DataNodeBuilder().withXpath(xpath).build()
fetchDescendantsOption << FetchDescendantsOption.values()
}
- @Unroll
def 'Update data node leaves: #scenario.'() {
given: 'that the admin service will return an anchor'
def anchor = Anchor.builder().name(anchorName).schemaSetName(schemaSetName).build()
'level 2 node' | '/test-tree' | '{"branch": [{"name":"Name"}]}' | '/test-tree/branch[@name=\'Name\']' | ['name': 'Name']
}
- @Unroll
def 'Replace data node: #scenario.'() {
given: 'that the admin service will return an anchor'
def anchor = Anchor.builder().name(anchorName).schemaSetName(schemaSetName).build()
import org.springframework.context.annotation.ComponentScan
import org.springframework.test.context.ContextConfiguration
import spock.lang.Specification
-import spock.lang.Unroll
import static org.onap.cps.spi.CascadeDeleteAllowed.CASCADE_DELETE_ALLOWED
import static org.onap.cps.spi.CascadeDeleteAllowed.CASCADE_DELETE_PROHIBITED
1 * mockModuleStoreService.getYangSchemaResources('someDataspace', 'someSchemaSet') >> yangResourcesNameToContentMap
}
- @Unroll
def 'Delete set by name and dataspace with #cascadeDeleteOption.'() {
when: 'schema set deletion is requested'
objectUnderTest.deleteSchemaSet(dataspaceName, schemaSetname, cascadeDeleteOption)
import org.onap.cps.spi.CpsDataPersistenceService
import org.onap.cps.spi.FetchDescendantsOption
import spock.lang.Specification
-import spock.lang.Unroll
-
class CpsQueryServiceImplSpec extends Specification {
def mockCpsDataPersistenceService = Mock(CpsDataPersistenceService)
objectUnderTest.cpsDataPersistenceService = mockCpsDataPersistenceService
}
- @Unroll
def 'Query data nodes by cps path with #fetchDescendantsOption.'() {
given: 'a dataspace name, an anchor name and a cps path'
def dataspaceName = 'some dataspace'
import org.onap.cps.yang.YangTextSchemaSourceSetBuilder
import org.opendaylight.yangtools.yang.common.Revision
import spock.lang.Specification
-import spock.lang.Unroll
class YangTextSchemaSourceSetSpec extends Specification {
- @Unroll
def 'Building a valid YangTextSchemaSourceSet using #filenameCase filename.'() {
given: 'a yang model (file)'
def yangResourceNameToContent = [filename: TestUtils.getResourceFileContent('bookstore.yang')]
'RFC-6020 recommended' | 'bookstore-test@2020-09-15.YANG'
}
- @Unroll
def 'Building YangTextSchemaSourceSet error case: #description.'() {
given: 'a file with #description'
def yangResourceNameToContent = TestUtils.getYangResourcesAsMap(filename)
import org.opendaylight.yangtools.yang.common.QName
import org.opendaylight.yangtools.yang.data.api.schema.NormalizedNode
import spock.lang.Specification
-import spock.lang.Unroll
class YangUtilsSpec extends Specification {
def 'Parsing a valid Json String.'() {
result.nodeType == QName.create('org:onap:ccsdk:sample', '2020-09-15', 'bookstore')
}
- @Unroll
def 'Parsing invalid data: #description.'() {
given: 'a yang model (file)'
def yangResourceNameToContent = TestUtils.getYangResourcesAsMap('bookstore.yang')
'{" }' | 'json with syntax exception'
}
- @Unroll
def 'Parsing json data fragment by xpath for #scenario.'() {
given: 'schema context'
def yangResourcesMap = TestUtils.getYangResourcesAsMap('test-tree.yang')
'container element' | '{ "nest": { "name": "N", "birds": ["bird"] } }' | '/test-tree/branch[@name=\'Branch\']' || 'nest'
}
- @Unroll
def 'Parsing json data fragment by xpath error scenario: #scenario.'() {
given: 'schema context'
def yangResourcesMap = TestUtils.getYangResourcesAsMap('test-tree.yang')
Code Review / cps.git / commitdiff